wip: only the modules that actually require an actor system are getting one.

5 files changed, 42 insertions, 55 deletions

diff --git a/kamon-jdbc/src/main/resources/reference.conf b/kamon-jdbc/src/main/resources/reference.conf
index e058c873..457fd76f 100644
--- a/kamon-jdbc/src/main/resources/reference.conf
+++ b/kamon-jdbc/src/main/resources/reference.conf
@@ -18,9 +18,7 @@ kamon {
 
   modules {
     kamon-jdbc {
-      auto-start = yes
       requires-aspectj = yes
-      extension-id = "kamon.jdbc.Jdbc"
     }
   }
 }
\ No newline at end of file
diff --git a/kamon-jdbc/src/main/scala/kamon/jdbc/Jdbc.scala b/kamon-jdbc/src/main/scala/kamon/jdbc/Jdbc.scala
index f66af7a6..eca3f89d 100644
--- a/kamon-jdbc/src/main/scala/kamon/jdbc/Jdbc.scala
+++ b/kamon-jdbc/src/main/scala/kamon/jdbc/Jdbc.scala
@@ -17,27 +17,23 @@ package kamon.jdbc
 
 import kamon.util.ConfigTools.Syntax
 
-import akka.actor.{ ExtendedActorSystem, Extension, ExtensionId, ExtensionIdProvider }
+import akka.actor._
 import kamon.Kamon
 
-object Jdbc extends ExtensionId[JdbcExtension] with ExtensionIdProvider {
-  override def lookup(): ExtensionId[_ <: Extension] = Jdbc
-  override def createExtension(system: ExtendedActorSystem): JdbcExtension = new JdbcExtension(system)
-
+object JdbcExtension {
   val SegmentLibraryName = "jdbc"
-}
 
-class JdbcExtension(system: ExtendedActorSystem) extends Kamon.Extension {
-  private val config = system.settings.config.getConfig("kamon.jdbc")
+  private val config = Kamon.config.getConfig("kamon.jdbc")
+  private val dynamic = new ReflectiveDynamicAccess(getClass.getClassLoader)
 
   private val nameGeneratorFQN = config.getString("name-generator")
-  private val nameGenerator: JdbcNameGenerator = system.dynamicAccess.createInstanceFor[JdbcNameGenerator](nameGeneratorFQN, Nil).get
+  private val nameGenerator: JdbcNameGenerator = dynamic.createInstanceFor[JdbcNameGenerator](nameGeneratorFQN, Nil).get
 
   private val slowQueryProcessorClass = config.getString("slow-query-processor")
-  private val slowQueryProcessor: SlowQueryProcessor = system.dynamicAccess.createInstanceFor[SlowQueryProcessor](slowQueryProcessorClass, Nil).get
+  private val slowQueryProcessor: SlowQueryProcessor = dynamic.createInstanceFor[SlowQueryProcessor](slowQueryProcessorClass, Nil).get
 
   private val sqlErrorProcessorClass = config.getString("sql-error-processor")
-  private val sqlErrorProcessor: SqlErrorProcessor = system.dynamicAccess.createInstanceFor[SqlErrorProcessor](sqlErrorProcessorClass, Nil).get
+  private val sqlErrorProcessor: SqlErrorProcessor = dynamic.createInstanceFor[SqlErrorProcessor](sqlErrorProcessorClass, Nil).get
 
   val slowQueryThreshold = config.getFiniteDuration("slow-query-threshold").toMillis
 
diff --git a/kamon-jdbc/src/main/scala/kamon/jdbc/instrumentation/StatementInstrumentation.scala b/kamon-jdbc/src/main/scala/kamon/jdbc/instrumentation/StatementInstrumentation.scala
index bef20667..321ce398 100644
--- a/kamon-jdbc/src/main/scala/kamon/jdbc/instrumentation/StatementInstrumentation.scala
+++ b/kamon-jdbc/src/main/scala/kamon/jdbc/instrumentation/StatementInstrumentation.scala
@@ -18,7 +18,7 @@ package kamon.jdbc.instrumentation
 import java.util.concurrent.TimeUnit.{ NANOSECONDS ⇒ nanos }
 
 import kamon.Kamon
-import kamon.jdbc.{ JdbcExtension, Jdbc }
+import kamon.jdbc.JdbcExtension
 import kamon.jdbc.metric.StatementsMetrics
 import kamon.trace.{ Tracer, TraceContext, SegmentCategory }
 import org.aspectj.lang.ProceedingJoinPoint
@@ -44,14 +44,13 @@ class StatementInstrumentation {
   @Around("onExecuteStatement(sql) || onExecutePreparedStatement(sql) || onExecutePreparedCall(sql)")
   def aroundExecuteStatement(pjp: ProceedingJoinPoint, sql: String): Any = {
     Tracer.currentContext.collect { ctx ⇒
-      val jdbcExtension = Kamon(Jdbc)
       implicit val statementRecorder = Kamon.metrics.entity(StatementsMetrics, "jdbc-statements")
 
       sql.replaceAll(CommentPattern, Empty) match {
-        case SelectStatement(_) ⇒ withSegment(ctx, Select, jdbcExtension)(recordRead(pjp, sql, jdbcExtension))
-        case InsertStatement(_) ⇒ withSegment(ctx, Insert, jdbcExtension)(recordWrite(pjp, sql, jdbcExtension))
-        case UpdateStatement(_) ⇒ withSegment(ctx, Update, jdbcExtension)(recordWrite(pjp, sql, jdbcExtension))
-        case DeleteStatement(_) ⇒ withSegment(ctx, Delete, jdbcExtension)(recordWrite(pjp, sql, jdbcExtension))
+        case SelectStatement(_) ⇒ withSegment(ctx, Select)(recordRead(pjp, sql))
+        case InsertStatement(_) ⇒ withSegment(ctx, Insert)(recordWrite(pjp, sql))
+        case UpdateStatement(_) ⇒ withSegment(ctx, Update)(recordWrite(pjp, sql))
+        case DeleteStatement(_) ⇒ withSegment(ctx, Delete)(recordWrite(pjp, sql))
         case anythingElse ⇒
           log.debug(s"Unable to parse sql [$sql]")
           pjp.proceed()
@@ -64,27 +63,27 @@ class StatementInstrumentation {
     try thunk finally timeSpent(System.nanoTime() - start)
   }
 
-  def withSegment[A](ctx: TraceContext, statement: String, jdbcExtension: JdbcExtension)(thunk: ⇒ A): A = {
-    val segmentName = jdbcExtension.generateJdbcSegmentName(statement)
-    val segment = ctx.startSegment(segmentName, SegmentCategory.Database, Jdbc.SegmentLibraryName)
+  def withSegment[A](ctx: TraceContext, statement: String)(thunk: ⇒ A): A = {
+    val segmentName = JdbcExtension.generateJdbcSegmentName(statement)
+    val segment = ctx.startSegment(segmentName, SegmentCategory.Database, JdbcExtension.SegmentLibraryName)
     try thunk finally segment.finish()
   }
 
-  def recordRead(pjp: ProceedingJoinPoint, sql: String, jdbcExtension: JdbcExtension)(implicit statementRecorder: StatementsMetrics): Any = {
-    withTimeSpent(pjp.proceedWithErrorHandler(sql, jdbcExtension)) { timeSpent ⇒
+  def recordRead(pjp: ProceedingJoinPoint, sql: String)(implicit statementRecorder: StatementsMetrics): Any = {
+    withTimeSpent(pjp.proceedWithErrorHandler(sql)) { timeSpent ⇒
       statementRecorder.reads.record(timeSpent)
 
       val timeSpentInMillis = nanos.toMillis(timeSpent)
 
-      if (timeSpentInMillis >= jdbcExtension.slowQueryThreshold) {
+      if (timeSpentInMillis >= JdbcExtension.slowQueryThreshold) {
         statementRecorder.slows.increment()
-        jdbcExtension.processSlowQuery(sql, timeSpentInMillis)
+        JdbcExtension.processSlowQuery(sql, timeSpentInMillis)
       }
     }
   }
 
-  def recordWrite(pjp: ProceedingJoinPoint, sql: String, jdbcExtension: JdbcExtension)(implicit statementRecorder: StatementsMetrics): Any = {
-    withTimeSpent(pjp.proceedWithErrorHandler(sql, jdbcExtension)) { timeSpent ⇒
+  def recordWrite(pjp: ProceedingJoinPoint, sql: String)(implicit statementRecorder: StatementsMetrics): Any = {
+    withTimeSpent(pjp.proceedWithErrorHandler(sql)) { timeSpent ⇒
       statementRecorder.writes.record(timeSpent)
     }
   }
@@ -106,12 +105,12 @@ object StatementInstrumentation {
   val Delete = "Delete"
 
   implicit class PimpedProceedingJoinPoint(pjp: ProceedingJoinPoint) {
-    def proceedWithErrorHandler(sql: String, jdbcExtension: JdbcExtension)(implicit statementRecorder: StatementsMetrics): Any = {
+    def proceedWithErrorHandler(sql: String)(implicit statementRecorder: StatementsMetrics): Any = {
       try {
         pjp.proceed()
       } catch {
         case NonFatal(cause) ⇒
-          jdbcExtension.processSqlError(sql, cause)
+          JdbcExtension.processSqlError(sql, cause)
           statementRecorder.errors.increment()
           throw cause
       }
diff --git a/kamon-jdbc/src/test/resources/application.conf b/kamon-jdbc/src/test/resources/application.conf
new file mode 100644
index 00000000..8713252c
--- /dev/null
+++ b/kamon-jdbc/src/test/resources/application.conf
@@ -0,0 +1,14 @@
+kamon {
+  jdbc {
+    slow-query-threshold = 100 milliseconds
+
+    # Fully qualified name of the implementation of kamon.jdbc.SlowQueryProcessor.
+    slow-query-processor = kamon.jdbc.instrumentation.NoOpSlowQueryProcessor
+
+    # Fully qualified name of the implementation of kamon.jdbc.SqlErrorProcessor.
+    sql-error-processor = kamon.jdbc.instrumentation.NoOpSqlErrorProcessor
+
+    # Fully qualified name of the implementation of kamon.jdbc.JdbcNameGenerator
+    name-generator = kamon.jdbc.instrumentation.NoOpJdbcNameGenerator
+  }
+}
\ No newline at end of file
diff --git a/kamon-jdbc/src/test/scala/kamon/jdbc/instrumentation/StatementInstrumentationSpec.scala b/kamon-jdbc/src/test/scala/kamon/jdbc/instrumentation/StatementInstrumentationSpec.scala
index 80107dff..a7781447 100644
--- a/kamon-jdbc/src/test/scala/kamon/jdbc/instrumentation/StatementInstrumentationSpec.scala
+++ b/kamon-jdbc/src/test/scala/kamon/jdbc/instrumentation/StatementInstrumentationSpec.scala
@@ -18,31 +18,11 @@ package kamon.jdbc.instrumentation
 import java.sql.{ DriverManager, SQLException }
 
 import com.typesafe.config.ConfigFactory
-import kamon.jdbc.{ Jdbc, JdbcNameGenerator, SqlErrorProcessor, SlowQueryProcessor }
-import kamon.metric.TraceMetricsSpec
+import kamon.jdbc.{ JdbcExtension, JdbcNameGenerator, SqlErrorProcessor, SlowQueryProcessor }
 import kamon.testkit.BaseKamonSpec
 import kamon.trace.{ Tracer, SegmentCategory }
 
 class StatementInstrumentationSpec extends BaseKamonSpec("jdbc-spec") {
-  override lazy val config =
-    ConfigFactory.parseString(
-      """
-        |kamon {
-        |   jdbc {
-        |     slow-query-threshold = 100 milliseconds
-        |
-        |     # Fully qualified name of the implementation of kamon.jdbc.SlowQueryProcessor.
-        |     slow-query-processor = kamon.jdbc.instrumentation.NoOpSlowQueryProcessor
-        |
-        |     # Fully qualified name of the implementation of kamon.jdbc.SqlErrorProcessor.
-        |     sql-error-processor = kamon.jdbc.instrumentation.NoOpSqlErrorProcessor
-        |
-        |     # Fully qualified name of the implementation of kamon.jdbc.JdbcNameGenerator
-        |     name-generator = kamon.jdbc.instrumentation.NoOpJdbcNameGenerator
-        |   }
-        |}
-      """.stripMargin)
-
   val connection = DriverManager.getConnection("jdbc:h2:mem:jdbc-spec", "SA", "")
 
   override protected def beforeAll(): Unit = {
@@ -79,7 +59,7 @@ class StatementInstrumentationSpec extends BaseKamonSpec("jdbc-spec") {
         tags = Map(
           "trace" -> "jdbc-trace-insert",
           "category" -> SegmentCategory.Database,
-          "library" -> Jdbc.SegmentLibraryName))
+          "library" -> JdbcExtension.SegmentLibraryName))
 
       segmentSnapshot.histogram("elapsed-time").get.numberOfMeasurements should be(100)
     }
@@ -105,7 +85,7 @@ class StatementInstrumentationSpec extends BaseKamonSpec("jdbc-spec") {
         tags = Map(
           "trace" -> "jdbc-trace-select",
           "category" -> SegmentCategory.Database,
-          "library" -> Jdbc.SegmentLibraryName))
+          "library" -> JdbcExtension.SegmentLibraryName))
 
       segmentSnapshot.histogram("elapsed-time").get.numberOfMeasurements should be(100)
     }
@@ -131,7 +111,7 @@ class StatementInstrumentationSpec extends BaseKamonSpec("jdbc-spec") {
         tags = Map(
           "trace" -> "jdbc-trace-update",
           "category" -> SegmentCategory.Database,
-          "library" -> Jdbc.SegmentLibraryName))
+          "library" -> JdbcExtension.SegmentLibraryName))
 
       segmentSnapshot.histogram("elapsed-time").get.numberOfMeasurements should be(100)
     }
@@ -157,7 +137,7 @@ class StatementInstrumentationSpec extends BaseKamonSpec("jdbc-spec") {
         tags = Map(
           "trace" -> "jdbc-trace-delete",
           "category" -> SegmentCategory.Database,
-          "library" -> Jdbc.SegmentLibraryName))
+          "library" -> JdbcExtension.SegmentLibraryName))
 
       segmentSnapshot.histogram("elapsed-time").get.numberOfMeasurements should be(100)