wip, core/akka/spray are kind of migrated.

35 files changed, 245 insertions, 406 deletions

diff --git a/kamon-akka-remote/src/main/resources/reference.conf b/kamon-akka-remote/src/main/resources/reference.conf
index 1d805cad..2aac64db 100644
--- a/kamon-akka-remote/src/main/resources/reference.conf
+++ b/kamon-akka-remote/src/main/resources/reference.conf
@@ -6,10 +6,7 @@ kamon {
 
   modules {
     kamon-akka-remote {
-      // Nothing to auto-start here.
-      auto-start = no
       requires-aspectj = yes
-      extension-id = none
     }
   }
 }
\ No newline at end of file
diff --git a/kamon-akka/src/main/resources/reference.conf b/kamon-akka/src/main/resources/reference.conf
index c1e59e63..70758f83 100644
--- a/kamon-akka/src/main/resources/reference.conf
+++ b/kamon-akka/src/main/resources/reference.conf
@@ -33,9 +33,7 @@ kamon {
 
   modules {
     kamon-akka {
-      auto-start = yes
       requires-aspectj = yes
-      extension-id = "kamon.akka.Akka"
     }
   }
 }
\ No newline at end of file
diff --git a/kamon-akka/src/main/scala/kamon/akka/AkkaExtension.scala b/kamon-akka/src/main/scala/kamon/akka/AkkaExtension.scala
index e84a1030..2fe2a42f 100644
--- a/kamon-akka/src/main/scala/kamon/akka/AkkaExtension.scala
+++ b/kamon-akka/src/main/scala/kamon/akka/AkkaExtension.scala
@@ -16,22 +16,11 @@
 
 package kamon.akka
 
-import _root_.akka.actor
-import _root_.akka.actor._
-import _root_.akka.event.Logging
 import com.typesafe.config.Config
-import kamon._
+import kamon.Kamon
 
-class AkkaExtension(system: ExtendedActorSystem) extends Kamon.Extension {
-  val log = Logging(system, classOf[AkkaExtension])
-  val config = system.settings.config.getConfig("kamon.akka")
-
-  val askPatternTimeoutWarning = AskPatternTimeoutWarningSettings.fromConfig(config)
-}
-
-object Akka extends ExtensionId[AkkaExtension] with ExtensionIdProvider {
-  def lookup(): ExtensionId[_ <: actor.Extension] = Akka
-  def createExtension(system: ExtendedActorSystem): AkkaExtension = new AkkaExtension(system)
+object AkkaExtension {
+  val askPatternTimeoutWarning = AskPatternTimeoutWarningSettings.fromConfig(Kamon.config.getConfig("kamon.akka"))
 }
 
 sealed trait AskPatternTimeoutWarningSetting
diff --git a/kamon-akka/src/main/scala/kamon/akka/instrumentation/AskPatternInstrumentation.scala b/kamon-akka/src/main/scala/kamon/akka/instrumentation/AskPatternInstrumentation.scala
index e64b241e..64012163 100644
--- a/kamon-akka/src/main/scala/kamon/akka/instrumentation/AskPatternInstrumentation.scala
+++ b/kamon-akka/src/main/scala/kamon/akka/instrumentation/AskPatternInstrumentation.scala
@@ -17,8 +17,7 @@
 package akka.kamon.instrumentation
 
 import akka.util.Timeout
-import kamon.Kamon
-import kamon.akka.{ AkkaExtension, Akka }
+import kamon.akka.AkkaExtension
 import kamon.akka.AskPatternTimeoutWarningSettings.{ Heavyweight, Lightweight, Off }
 import akka.actor.{ InternalActorRef, ActorRef }
 import akka.pattern.AskTimeoutException
@@ -27,11 +26,13 @@ import kamon.util.SameThreadExecutionContext
 import org.aspectj.lang.ProceedingJoinPoint
 import org.aspectj.lang.annotation._
 import org.aspectj.lang.reflect.SourceLocation
+import org.slf4j.LoggerFactory
 import scala.concurrent.Future
 import scala.compat.Platform.EOL
 
 @Aspect
 class AskPatternInstrumentation {
+  private val log = LoggerFactory.getLogger(getClass)
 
   import AskPatternInstrumentation._
 
@@ -43,18 +44,19 @@ class AskPatternInstrumentation {
     actor match {
       // the AskPattern will only work for InternalActorRef's with these conditions.
       case ref: InternalActorRef if !ref.isTerminated && timeout.duration.length > 0 && Tracer.currentContext.nonEmpty ⇒
-        val akkaExtension = Kamon.extension(Akka)
         val future = pjp.proceed().asInstanceOf[Future[AnyRef]]
 
-        akkaExtension.askPatternTimeoutWarning match {
+        AkkaExtension.askPatternTimeoutWarning match {
           case Off         ⇒
-          case Lightweight ⇒ hookLightweightWarning(future, pjp.getSourceLocation, actor, akkaExtension)
-          case Heavyweight ⇒ hookHeavyweightWarning(future, new StackTraceCaptureException, actor, akkaExtension)
+          case Lightweight ⇒ hookLightweightWarning(future, pjp.getSourceLocation, actor)
+          case Heavyweight ⇒ hookHeavyweightWarning(future, new StackTraceCaptureException, actor)
         }
 
         future
 
-      case _ ⇒ pjp.proceed().asInstanceOf[Future[AnyRef]] //
+      case _ ⇒
+        pjp.proceed().asInstanceOf[Future[AnyRef]]
+
     }
 
   def ifAskTimeoutException(code: ⇒ Unit): PartialFunction[Throwable, Unit] = {
@@ -62,21 +64,21 @@ class AskPatternInstrumentation {
     case _                        ⇒
   }
 
-  def hookLightweightWarning(future: Future[AnyRef], sourceLocation: SourceLocation, actor: ActorRef, akkaExtension: AkkaExtension): Unit = {
+  def hookLightweightWarning(future: Future[AnyRef], sourceLocation: SourceLocation, actor: ActorRef): Unit = {
     val locationString = Option(sourceLocation)
       .map(location ⇒ s"${location.getFileName}:${location.getLine}")
       .getOrElse("<unknown position>")
 
     future.onFailure(ifAskTimeoutException {
-      akkaExtension.log.warning("Timeout triggered for ask pattern to actor [{}] at [{}]", actor.path.name, locationString)
+      log.warn(s"Timeout triggered for ask pattern to actor [${actor.path.name}] at [$locationString]")
     })(SameThreadExecutionContext)
   }
 
-  def hookHeavyweightWarning(future: Future[AnyRef], captureException: StackTraceCaptureException, actor: ActorRef, akkaExtension: AkkaExtension): Unit = {
+  def hookHeavyweightWarning(future: Future[AnyRef], captureException: StackTraceCaptureException, actor: ActorRef): Unit = {
     val locationString = captureException.getStackTrace.drop(3).mkString("", EOL, EOL)
 
     future.onFailure(ifAskTimeoutException {
-      akkaExtension.log.warning("Timeout triggered for ask pattern to actor [{}] at [{}]", actor.path.name, locationString)
+      log.warn(s"Timeout triggered for ask pattern to actor [${actor.path.name}] at [$locationString]")
     })(SameThreadExecutionContext)
   }
 }
diff --git a/kamon-akka/src/test/resources/application.conf b/kamon-akka/src/test/resources/application.conf
new file mode 100644
index 00000000..5407ccfe
--- /dev/null
+++ b/kamon-akka/src/test/resources/application.conf
@@ -0,0 +1,63 @@
+akka {
+  loglevel = INFO
+  loggers = [ "akka.event.slf4j.Slf4jLogger" ]
+}
+
+kamon.metric {
+  tick-interval = 1 hour
+  default-collection-context-buffer-size = 100
+
+  filters = {
+    akka-actor {
+      includes = [ "*/user/tracked-*", "*/user/measuring-*", "*/user/clean-after-collect", "*/user/stop", "*/" ]
+      excludes = [ "*/user/tracked-explicitly-excluded", "*/user/non-tracked-actor" ]
+    }
+
+    akka-router {
+      includes = [ "*/user/tracked-*", "*/user/measuring-*", "*/user/stop-*" ]
+      excludes = [ "*/user/tracked-explicitly-excluded-*"]
+    }
+
+    akka-dispatcher {
+      includes = [ "**" ]
+      excludes = [ "*/explicitly-excluded" ]
+    }
+  }
+
+  default-instrument-settings {
+    gauge.refresh-interval = 1 hour
+    min-max-counter.refresh-interval = 1 hour
+  }
+
+  instrument-settings {
+    akka-actor.mailbox-size.refresh-interval = 1 hour
+  }
+}
+
+explicitly-excluded {
+  type = "Dispatcher"
+  executor = "fork-join-executor"
+}
+
+tracked-fjp {
+  type = "Dispatcher"
+  executor = "fork-join-executor"
+
+  fork-join-executor {
+    parallelism-min = 8
+    parallelism-factor = 100.0
+    parallelism-max = 22
+  }
+}
+
+tracked-tpe {
+  type = "Dispatcher"
+  executor = "thread-pool-executor"
+
+  thread-pool-executor {
+    core-pool-size-min = 7
+    core-pool-size-factor = 100.0
+    max-pool-size-factor  = 100.0
+    max-pool-size-max = 21
+  }
+}
\ No newline at end of file
diff --git a/kamon-akka/src/test/resources/logback.xml b/kamon-akka/src/test/resources/logback.xml
new file mode 100644
index 00000000..df142eac
--- /dev/null
+++ b/kamon-akka/src/test/resources/logback.xml
@@ -0,0 +1,13 @@
+<configuration scan="true" debug="false">
+    <conversionRule conversionWord="traceToken" converterClass="kamon.trace.logging.LogbackTraceTokenConverter"/>
+
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%date{HH:mm:ss.SSS} %-5level [%traceToken][%thread] %logger{55} - %msg%n</pattern>
+        </encoder>
+    </appender>
+
+    <root level="off">
+        <appender-ref ref="STDOUT"/>
+    </root>
+</configuration>
diff --git a/kamon-akka/src/test/scala/kamon/akka/ActorMetricsSpec.scala b/kamon-akka/src/test/scala/kamon/akka/ActorMetricsSpec.scala
index 4647abc0..cd64988d 100644
--- a/kamon-akka/src/test/scala/kamon/akka/ActorMetricsSpec.scala
+++ b/kamon-akka/src/test/scala/kamon/akka/ActorMetricsSpec.scala
@@ -29,28 +29,6 @@ import kamon.testkit.BaseKamonSpec
 import scala.concurrent.duration._
 
 class ActorMetricsSpec extends BaseKamonSpec("actor-metrics-spec") {
-  override lazy val config =
-    ConfigFactory.parseString(
-      """
-        |kamon.metric {
-        |  tick-interval = 1 hour
-        |  default-collection-context-buffer-size = 10
-        |
-        |  filters {
-        |    akka-actor {
-        |      includes = [ "*/user/tracked-*", "*/user/measuring-*", "*/user/clean-after-collect", "*/user/stop", "*/" ]
-        |      excludes = [ "*/user/tracked-explicitly-excluded", "*/user/non-tracked-actor" ]
-        |    }
-        |  }
-        |
-        |  instrument-settings {
-        |    akka-actor.mailbox-size.refresh-interval = 1 hour
-        |  }
-        |}
-        |
-        |akka.loglevel = OFF
-        |
-      """.stripMargin)
 
   "the Kamon actor metrics" should {
     "respect the configured include and exclude filters" in new ActorMetricsFixtures {
diff --git a/kamon-akka/src/test/scala/kamon/akka/DispatcherMetricsSpec.scala b/kamon-akka/src/test/scala/kamon/akka/DispatcherMetricsSpec.scala
index 678c7f73..3fbb10fd 100644
--- a/kamon-akka/src/test/scala/kamon/akka/DispatcherMetricsSpec.scala
+++ b/kamon-akka/src/test/scala/kamon/akka/DispatcherMetricsSpec.scala
@@ -30,56 +30,6 @@ import scala.concurrent.duration._
 import scala.concurrent.{ Await, Future }
 
 class DispatcherMetricsSpec extends BaseKamonSpec("dispatcher-metrics-spec") {
-  override lazy val config =
-    ConfigFactory.parseString(
-      """
-        |kamon.metric {
-        |  tick-interval = 1 hour
-        |  default-collection-context-buffer-size = 10
-        |
-        |  filters = {
-        |    akka-dispatcher {
-        |      includes = [ "**" ]
-        |      excludes = [ "*/explicitly-excluded" ]
-        |    }
-        |  }
-        |
-        |  default-instrument-settings {
-        |    gauge.refresh-interval = 1 hour
-        |    min-max-counter.refresh-interval = 1 hour
-        |  }
-        |}
-        |
-        |explicitly-excluded {
-        |  type = "Dispatcher"
-        |  executor = "fork-join-executor"
-        |}
-        |
-        |tracked-fjp {
-        |  type = "Dispatcher"
-        |  executor = "fork-join-executor"
-        |
-        |  fork-join-executor {
-        |    parallelism-min = 8
-        |    parallelism-factor = 100.0
-        |    parallelism-max = 22
-        |  }
-        |}
-        |
-        |tracked-tpe {
-        |  type = "Dispatcher"
-        |  executor = "thread-pool-executor"
-        |
-        |  thread-pool-executor {
-        |    core-pool-size-min = 7
-        |    core-pool-size-factor = 100.0
-        |    max-pool-size-factor  = 100.0
-        |    max-pool-size-max = 21
-        |  }
-        |}
-        |
-      """.stripMargin)
-
   "the Kamon dispatcher metrics" should {
     "respect the configured include and exclude filters" in {
       val defaultDispatcher = forceInit(system.dispatchers.lookup("akka.actor.default-dispatcher"))
diff --git a/kamon-akka/src/test/scala/kamon/akka/RouterMetricsSpec.scala b/kamon-akka/src/test/scala/kamon/akka/RouterMetricsSpec.scala
index 4128c9ef..bff2382e 100644
--- a/kamon-akka/src/test/scala/kamon/akka/RouterMetricsSpec.scala
+++ b/kamon-akka/src/test/scala/kamon/akka/RouterMetricsSpec.scala
@@ -20,7 +20,6 @@ import java.nio.LongBuffer
 import akka.actor._
 import akka.routing._
 import akka.testkit.TestProbe
-import com.typesafe.config.ConfigFactory
 import kamon.Kamon
 import kamon.akka.RouterMetricsTestActor._
 import kamon.metric.EntitySnapshot
@@ -30,24 +29,6 @@ import kamon.testkit.BaseKamonSpec
 import scala.concurrent.duration._
 
 class RouterMetricsSpec extends BaseKamonSpec("router-metrics-spec") {
-  override lazy val config =
-    ConfigFactory.parseString(
-      """
-        |kamon.metric {
-        |  tick-interval = 1 hour
-        |  default-collection-context-buffer-size = 10
-        |
-        |  filters = {
-        |    akka-router {
-        |      includes = [ "*/user/tracked-*", "*/user/measuring-*", "*/user/stop-*" ]
-        |      excludes = [ "*/user/tracked-explicitly-excluded-*"]
-        |    }
-        |  }
-        |}
-        |
-        |akka.loglevel = OFF
-        |
-      """.stripMargin)
 
   "the Kamon router metrics" should {
     "respect the configured include and exclude filters" in new RouterMetricsFixtures {
diff --git a/kamon-akka/src/test/scala/kamon/akka/instrumentation/ActorLoggingInstrumentationSpec.scala b/kamon-akka/src/test/scala/kamon/akka/instrumentation/ActorLoggingInstrumentationSpec.scala
index 85f41795..d08f38a4 100644
--- a/kamon-akka/src/test/scala/kamon/akka/instrumentation/ActorLoggingInstrumentationSpec.scala
+++ b/kamon-akka/src/test/scala/kamon/akka/instrumentation/ActorLoggingInstrumentationSpec.scala
@@ -26,13 +26,6 @@ import org.scalatest.Inspectors
 import org.slf4j.MDC
 
 class ActorLoggingInstrumentationSpec extends BaseKamonSpec("actor-logging-instrumentation-spec") with Inspectors with MdcKeysSupport {
-  override lazy val config =
-    ConfigFactory.parseString(
-      """
-        |akka {
-        |  loggers = ["akka.event.slf4j.Slf4jLogger"]
-        |}
-      """.stripMargin)
 
   "the ActorLogging instrumentation" should {
     "attach the TraceContext (if available) to log events" in {
diff --git a/kamon-akka/src/test/scala/kamon/akka/instrumentation/ActorSystemMessageInstrumentationSpec.scala b/kamon-akka/src/test/scala/kamon/akka/instrumentation/ActorSystemMessageInstrumentationSpec.scala
index 1635fadc..d2e7d5e5 100644
--- a/kamon-akka/src/test/scala/kamon/akka/instrumentation/ActorSystemMessageInstrumentationSpec.scala
+++ b/kamon-akka/src/test/scala/kamon/akka/instrumentation/ActorSystemMessageInstrumentationSpec.scala
@@ -28,14 +28,6 @@ import scala.concurrent.duration._
 import scala.util.control.NonFatal
 
 class ActorSystemMessageInstrumentationSpec extends BaseKamonSpec("actor-system-message-instrumentation-spec") with WordSpecLike with ImplicitSender {
-  override lazy val config =
-    ConfigFactory.parseString(
-      """
-        |akka {
-        |  loglevel = OFF
-        |}
-      """.stripMargin)
-
   implicit lazy val executionContext = system.dispatcher
 
   "the system message passing instrumentation" should {
diff --git a/kamon-akka/src/test/scala/kamon/akka/instrumentation/AskPatternInstrumentationSpec.scala b/kamon-akka/src/test/scala/kamon/akka/instrumentation/AskPatternInstrumentationSpec.scala
index d9fbc2df..025c8d0c 100644
--- a/kamon-akka/src/test/scala/kamon/akka/instrumentation/AskPatternInstrumentationSpec.scala
+++ b/kamon-akka/src/test/scala/kamon/akka/instrumentation/AskPatternInstrumentationSpec.scala
@@ -20,25 +20,14 @@ import akka.actor._
 import akka.pattern.ask
 import akka.testkit.EventFilter
 import akka.util.Timeout
-import com.typesafe.config.ConfigFactory
-import kamon.Kamon
 import kamon.akka.AskPatternTimeoutWarningSettings.{ Off, Lightweight, Heavyweight }
-import kamon.akka.{ AskPatternTimeoutWarningSetting, Akka }
+import kamon.akka.{ AkkaExtension, AskPatternTimeoutWarningSetting }
 import kamon.testkit.BaseKamonSpec
 import kamon.trace.Tracer
 
 import scala.concurrent.duration._
 
 class AskPatternInstrumentationSpec extends BaseKamonSpec("ask-pattern-tracing-spec") {
-  override lazy val config =
-    ConfigFactory.parseString(
-      """
-        |akka {
-        |  loglevel = OFF
-        |  loggers = [akka.testkit.TestEventListener]
-        |}
-      """.stripMargin)
-
   implicit lazy val ec = system.dispatcher
   implicit val askTimeout = Timeout(10 millis)
 
@@ -93,10 +82,9 @@ class AskPatternInstrumentationSpec extends BaseKamonSpec("ask-pattern-tracing-s
   override protected def afterAll(): Unit = shutdown()
 
   def setAskPatternTimeoutWarningMode(mode: AskPatternTimeoutWarningSetting): Unit = {
-    val target = Kamon(Akka)
-    val field = target.getClass.getDeclaredField("askPatternTimeoutWarning")
+    val field = AkkaExtension.getClass.getDeclaredField("askPatternTimeoutWarning")
     field.setAccessible(true)
-    field.set(target, mode)
+    field.set(AkkaExtension, mode)
   }
 }
 
diff --git a/kamon-core/src/main/resources/reference.conf b/kamon-core/src/main/resources/reference.conf
index b3adbe83..fb12b213 100644
--- a/kamon-core/src/main/resources/reference.conf
+++ b/kamon-core/src/main/resources/reference.conf
@@ -141,6 +141,8 @@ kamon {
     }
   }
 
+  # FQCN for a implementation of
+  config-provider = default
 
   # All settings included under the internal-config key will be used to repleace the akka.* and spray.* settings. By
   # doing this we avoid applying custom settings that might make sense for the user application to the internal actor
diff --git a/kamon-core/src/main/scala/kamon/Kamon.scala b/kamon-core/src/main/scala/kamon/Kamon.scala
index 1c560d9f..f2d1e319 100644
--- a/kamon-core/src/main/scala/kamon/Kamon.scala
+++ b/kamon-core/src/main/scala/kamon/Kamon.scala
@@ -20,84 +20,62 @@ import _root_.akka.event.Logging
 import com.typesafe.config.{ ConfigFactory, Config }
 import kamon.metric._
 import kamon.trace.{ TracerModuleImpl, TracerModule }
+import org.slf4j.LoggerFactory
 
-object Kamon {
-  trait Extension extends actor.Extension
-
-  private case class KamonCoreComponents(metrics: MetricsModule, tracer: TracerModule)
-
-  private val shouldAutoStart = isSystemPropertyEnabled("kamon.auto-start")
-  private val shouldWarnOnDuplicateStart = !isSystemPropertyEnabled("kamon.disable-duplicate-start-warning")
+import _root_.scala.util.Try
 
-  @volatile private var _system: ActorSystem = _
-  @volatile private var _coreComponents: Option[KamonCoreComponents] = None
-
-  def start(config: Config): Unit = synchronized {
-
-    def resolveInternalConfig: Config = {
-      val internalConfig = config.getConfig("kamon.internal-config")
+object Kamon {
+  private val log = LoggerFactory.getLogger(getClass)
 
-      config
-        .withoutPath("akka")
-        .withoutPath("spray")
-        .withFallback(internalConfig)
-    }
+  trait Extension extends actor.Extension
 
-    if (_coreComponents.isEmpty) {
-      val metrics = MetricsModuleImpl(config)
-      val tracer = TracerModuleImpl(metrics, config)
+  val config = resolveConfiguration
+  val metrics = MetricsModuleImpl(config)
+  val tracer = TracerModuleImpl(metrics, config)
 
-      _coreComponents = Some(KamonCoreComponents(metrics, tracer))
-      _system = ActorSystem("kamon", resolveInternalConfig)
+  private lazy val _system = {
+    val internalConfig = config.getConfig("kamon.internal-config")
+    val patchedConfig = config
+      .withoutPath("akka")
+      .withoutPath("spray")
+      .withFallback(internalConfig)
 
-      metrics.start(_system)
-      tracer.start(_system)
-      _system.registerExtension(ModuleLoader)
+    log.info("Initializing KAMON DUUUDEEE")
 
-    } else if (shouldWarnOnDuplicateStart) {
-      val logger = Logging(_system, "Kamon")
-      logger.warning("An attempt to start Kamon has been made, but Kamon has already been started.")
-    }
+    ActorSystem("kamon", patchedConfig)
   }
 
-  private def isSystemPropertyEnabled(propertyName: String): Boolean =
-    sys.props.get(propertyName).map(_.equals("true")).getOrElse(false)
+  private lazy val _start = {
+    metrics.start(_system)
+    tracer.start(_system)
+    _system.registerExtension(ModuleLoader)
+  }
 
-  def start(): Unit =
-    start(ConfigFactory.load)
+  def start(): Unit = _start
 
   def shutdown(): Unit = {
-    _coreComponents = None
-    _system.shutdown()
-    _system = null
+    // TODO: Define what a proper shutdown should be like.
   }
 
-  def metrics: MetricsModule =
-    ifStarted(_.metrics)
-
-  def tracer: TracerModule =
-    ifStarted(_.tracer)
-
-  def apply[T <: Kamon.Extension](key: ExtensionId[T]): T =
-    ifStarted { _ ⇒
-      if (_system ne null)
-        key(_system)
-      else
-        sys.error("Cannot retrieve extensions while Kamon is being initialized.")
-    }
+  /*  def apply[T <: Kamon.Extension](key: ExtensionId[T]): T =
+    key(_system)
 
   def extension[T <: Kamon.Extension](key: ExtensionId[T]): T =
-    apply(key)
+    apply(key)*/
 
-  private def ifStarted[T](thunk: KamonCoreComponents ⇒ T): T =
-    _coreComponents.map(thunk(_)) getOrElse {
-      if (shouldAutoStart) {
-        start()
-        thunk(_coreComponents.get)
+  private def resolveConfiguration: Config = {
+    val defaultConfig = ConfigFactory.load()
 
-      } else sys.error("Kamon has not been started yet. You must either explicitlt call Kamon.start(...) or enable " +
-        "automatic startup by adding -Dkamon.auto-start=true to your JVM options.")
+    defaultConfig.getString("kamon.config-provider") match {
+      case "default" ⇒ defaultConfig
+      case fqcn ⇒
+        val dynamic = new ReflectiveDynamicAccess(getClass.getClassLoader)
+        dynamic.createInstanceFor[ConfigProvider](fqcn, Nil).get.config
     }
+  }
+}
 
+trait ConfigProvider {
+  def config: Config
 }
 
diff --git a/kamon-core/src/main/scala/kamon/ModuleLoader.scala b/kamon-core/src/main/scala/kamon/ModuleLoader.scala
index a26fd339..f240f6ce 100644
--- a/kamon-core/src/main/scala/kamon/ModuleLoader.scala
+++ b/kamon-core/src/main/scala/kamon/ModuleLoader.scala
@@ -21,6 +21,7 @@ import _root_.akka.actor._
 import _root_.akka.event.Logging
 import org.aspectj.lang.ProceedingJoinPoint
 import org.aspectj.lang.annotation.{ Around, Pointcut, Aspect }
+import org.slf4j.LoggerFactory
 
 private[kamon] object ModuleLoader extends ExtensionId[ModuleLoaderExtension] with ExtensionIdProvider {
   def lookup(): ExtensionId[_ <: actor.Extension] = ModuleLoader
@@ -28,23 +29,22 @@ private[kamon] object ModuleLoader extends ExtensionId[ModuleLoaderExtension] wi
 }
 
 private[kamon] class ModuleLoaderExtension(system: ExtendedActorSystem) extends Kamon.Extension {
-  val log = Logging(system, "ModuleLoader")
+  val log = LoggerFactory.getLogger(getClass)
   val settings = ModuleLoaderSettings(system)
 
   if (settings.modulesRequiringAspectJ.nonEmpty && !isAspectJPresent && settings.showAspectJMissingWarning)
     logAspectJWeaverMissing(settings.modulesRequiringAspectJ)
 
   // Force initialization of all modules marked with auto-start.
-  settings.availableModules.filter(_.autoStart).foreach { module ⇒
-    if (module.extensionClass == "none")
-      log.debug("Ignoring auto start of the [{}] module with no extension class.", module.name)
-    else
-      system.dynamicAccess.getObjectFor[ExtensionId[Kamon.Extension]](module.extensionClass).map { moduleID ⇒
-        log.debug("Auto starting the [{}] module.", module.name)
+  settings.availableModules.filter(_.startInfo.nonEmpty).foreach {
+    case AvailableModuleInfo(name, requiresAJ, Some(ModuleStartInfo(autoStart, extensionClass))) if autoStart ⇒
+
+      system.dynamicAccess.getObjectFor[ExtensionId[Kamon.Extension]](extensionClass).map { moduleID ⇒
+        log.debug(s"Auto starting the [$name] module.")
         moduleID.get(system)
 
       } recover {
-        case th: Throwable ⇒ log.error(th, "Failed to auto start the [{}] module.", module.name)
+        case th: Throwable ⇒ log.error(s"Failed to auto start the [$name] module.", th)
       }
 
   }
@@ -82,7 +82,8 @@ private[kamon] class ModuleLoaderExtension(system: ExtendedActorSystem) extends
   }
 }
 
-private[kamon] case class AvailableModuleInfo(name: String, extensionClass: String, requiresAspectJ: Boolean, autoStart: Boolean)
+private[kamon] case class AvailableModuleInfo(name: String, requiresAspectJ: Boolean, startInfo: Option[ModuleStartInfo])
+private[kamon] case class ModuleStartInfo(autoStart: Boolean, extensionClass: String)
 private[kamon] case class ModuleLoaderSettings(showAspectJMissingWarning: Boolean, availableModules: List[AvailableModuleInfo]) {
   val modulesRequiringAspectJ = availableModules.filter(_.requiresAspectJ)
 }
@@ -98,12 +99,15 @@ private[kamon] object ModuleLoaderSettings {
     val modules = config.firstLevelKeys
     val availableModules = modules.map { moduleName ⇒
       val moduleConfig = config.getConfig(moduleName)
+      val requiresAspectJ = moduleConfig.getBoolean("requires-aspectj")
+
+      val startInfo =
+        if (moduleConfig.hasPath("auto-start") && moduleConfig.hasPath("extension-class"))
+          Some(ModuleStartInfo(moduleConfig.getBoolean("auto-start"), moduleConfig.getString("extension-class")))
+        else
+          None
 
-      AvailableModuleInfo(
-        moduleName,
-        moduleConfig.getString("extension-id"),
-        moduleConfig.getBoolean("requires-aspectj"),
-        moduleConfig.getBoolean("auto-start"))
+      AvailableModuleInfo(moduleName, requiresAspectJ, startInfo)
 
     } toList
 
diff --git a/kamon-core/src/test/resources/application.conf b/kamon-core/src/test/resources/application.conf
index e8217fc2..f79ab822 100644
--- a/kamon-core/src/test/resources/application.conf
+++ b/kamon-core/src/test/resources/application.conf
@@ -1,3 +1,15 @@
 akka {
   loggers = ["akka.event.slf4j.Slf4jLogger"]
+}
+
+kamon {
+  metric {
+    tick-interval = 1 hour
+    default-collection-context-buffer-size = 100
+  }
+
+  trace {
+    level-of-detail = simple-trace
+    sampling = all
+  }
 }
\ No newline at end of file
diff --git a/kamon-core/src/test/resources/logback.xml b/kamon-core/src/test/resources/logback.xml
index dd623d61..7bb50450 100644
--- a/kamon-core/src/test/resources/logback.xml
+++ b/kamon-core/src/test/resources/logback.xml
@@ -1,4 +1,5 @@
-<configuration scan="true">
+<configuration
+        >
   <contextListener class="ch.qos.logback.classic.jul.LevelChangePropagator">
     <resetJUL>true</resetJUL>
   </contextListener>
diff --git a/kamon-core/src/test/scala/kamon/metric/SimpleMetricsSpec.scala b/kamon-core/src/test/scala/kamon/metric/SimpleMetricsSpec.scala
index 0180e980..6d753888 100644
--- a/kamon-core/src/test/scala/kamon/metric/SimpleMetricsSpec.scala
+++ b/kamon-core/src/test/scala/kamon/metric/SimpleMetricsSpec.scala
@@ -16,21 +16,12 @@
 
 package kamon.metric
 
-import com.typesafe.config.ConfigFactory
 import kamon.Kamon
 import kamon.metric.instrument.Histogram.DynamicRange
 import kamon.testkit.BaseKamonSpec
 import scala.concurrent.duration._
 
 class SimpleMetricsSpec extends BaseKamonSpec("simple-metrics-spec") {
-  override lazy val config =
-    ConfigFactory.parseString(
-      """
-        |kamon.metric {
-        |  tick-interval = 1 hour
-        |  default-collection-context-buffer-size = 10
-        |}
-      """.stripMargin)
 
   "the SimpleMetrics extension" should {
 
diff --git a/kamon-core/src/test/scala/kamon/metric/TickMetricSnapshotBufferSpec.scala b/kamon-core/src/test/scala/kamon/metric/TickMetricSnapshotBufferSpec.scala
index ac35cf58..97bf0e2c 100644
--- a/kamon-core/src/test/scala/kamon/metric/TickMetricSnapshotBufferSpec.scala
+++ b/kamon-core/src/test/scala/kamon/metric/TickMetricSnapshotBufferSpec.scala
@@ -26,21 +26,6 @@ import scala.concurrent.duration._
 import kamon.metric.SubscriptionsDispatcher.TickMetricSnapshot
 
 class TickMetricSnapshotBufferSpec extends BaseKamonSpec("trace-metrics-spec") with ImplicitSender {
-  override lazy val config =
-    ConfigFactory.parseString(
-      """
-        |kamon.metric {
-        |  tick-interval = 1 hour
-        |  default-collection-context-buffer-size = 10
-        |
-        |  filters {
-        |    trace {
-        |      includes = [ "*" ]
-        |      excludes = [ "non-tracked-trace" ]
-        |    }
-        |  }
-        |}
-      """.stripMargin)
 
   "the TickMetricSnapshotBuffer" should {
     "merge TickMetricSnapshots received until the flush timeout is reached and fix the from/to fields" in new SnapshotFixtures {
diff --git a/kamon-core/src/test/scala/kamon/metric/TraceMetricsSpec.scala b/kamon-core/src/test/scala/kamon/metric/TraceMetricsSpec.scala
index efdcb79b..3e3e2d8e 100644
--- a/kamon-core/src/test/scala/kamon/metric/TraceMetricsSpec.scala
+++ b/kamon-core/src/test/scala/kamon/metric/TraceMetricsSpec.scala
@@ -23,21 +23,6 @@ import kamon.trace.Tracer
 import kamon.metric.instrument.Histogram
 
 class TraceMetricsSpec extends BaseKamonSpec("trace-metrics-spec") with ImplicitSender {
-  override lazy val config =
-    ConfigFactory.parseString(
-      """
-        |kamon.metric {
-        |  tick-interval = 1 hour
-        |  default-collection-context-buffer-size = 10
-        |
-        |  filters {
-        |    trace {
-        |      includes = [ "*" ]
-        |      excludes = [ "non-tracked-trace"]
-        |    }
-        |  }
-        |}
-      """.stripMargin)
 
   "the TraceMetrics" should {
     "record the elapsed time between a trace creation and finish" in {
diff --git a/kamon-core/src/test/scala/kamon/testkit/BaseKamonSpec.scala b/kamon-core/src/test/scala/kamon/testkit/BaseKamonSpec.scala
index cb909ad9..f23d974c 100644
--- a/kamon-core/src/test/scala/kamon/testkit/BaseKamonSpec.scala
+++ b/kamon-core/src/test/scala/kamon/testkit/BaseKamonSpec.scala
@@ -28,12 +28,12 @@ import org.scalatest.{ BeforeAndAfterAll, Matchers, WordSpecLike }
 abstract class BaseKamonSpec(actorSystemName: String) extends TestKitBase with WordSpecLike with Matchers with ImplicitSender with BeforeAndAfterAll {
   lazy val collectionContext = Kamon.metrics.buildDefaultCollectionContext
   implicit lazy val system: ActorSystem = {
-    Kamon.start(config.withFallback(ConfigFactory.load()))
+    Kamon.start()
     ActorSystem(actorSystemName, config)
   }
 
   def config: Config =
-    ConfigFactory.empty()
+    Kamon.config
 
   def newContext(name: String): TraceContext =
     Kamon.tracer.newContext(name)
diff --git a/kamon-core/src/test/scala/kamon/trace/SimpleTraceSpec.scala b/kamon-core/src/test/scala/kamon/trace/SimpleTraceSpec.scala
index c8f1ebf6..d6886d4c 100644
--- a/kamon-core/src/test/scala/kamon/trace/SimpleTraceSpec.scala
+++ b/kamon-core/src/test/scala/kamon/trace/SimpleTraceSpec.scala
@@ -23,21 +23,6 @@ import scala.concurrent.duration._
 
 class SimpleTraceSpec extends BaseKamonSpec("simple-trace-spec") {
 
-  override lazy val config =
-    ConfigFactory.parseString(
-      """
-        |kamon {
-        |  metric {
-        |    tick-interval = 1 hour
-        |  }
-        |
-        |  trace {
-        |    level-of-detail = simple-trace
-        |    sampling = all
-        |  }
-        |}
-      """.stripMargin)
-
   "the simple tracing" should {
     "send a TraceInfo when the trace has finished and all segments are finished" in {
       Kamon.tracer.subscribe(testActor)
diff --git a/kamon-core/src/test/scala/kamon/trace/TraceContextManipulationSpec.scala b/kamon-core/src/test/scala/kamon/trace/TraceContextManipulationSpec.scala
index 46620461..ecef9271 100644
--- a/kamon-core/src/test/scala/kamon/trace/TraceContextManipulationSpec.scala
+++ b/kamon-core/src/test/scala/kamon/trace/TraceContextManipulationSpec.scala
@@ -20,20 +20,6 @@ import com.typesafe.config.ConfigFactory
 import kamon.testkit.BaseKamonSpec
 
 class TraceContextManipulationSpec extends BaseKamonSpec("trace-metrics-spec") {
-  override lazy val config =
-    ConfigFactory.parseString(
-      """
-        |kamon.metric {
-        |  tick-interval = 1 hour
-        |
-        |  filters {
-        |    trace {
-        |      includes = [ "*" ]
-        |      excludes = [ "non-tracked-trace"]
-        |    }
-        |  }
-        |}
-      """.stripMargin)
 
   "the TraceContext api" should {
     "allow starting a trace within a specified block of code, and only within that block of code" in {
diff --git a/kamon-playground/src/main/resources/application.conf b/kamon-playground/src/main/resources/application.conf
index a8ad9e75..b25549bf 100644
--- a/kamon-playground/src/main/resources/application.conf
+++ b/kamon-playground/src/main/resources/application.conf
@@ -1,5 +1,6 @@
 akka {
   loglevel = DEBUG
+  loggers = [ "akka.event.slf4j.Slf4jLogger" ]
 
   actor {
     debug {
@@ -21,9 +22,9 @@ kamon {
 
   metric {
     filters {
-      trace.includes = [ "**" ]
-      akka-actor.includes = [ "**" ]
-      akka-dispatcher.includes = [ "**" ]
+      //trace.includes = [ "**" ]
+      //akka-actor.includes = [ "**" ]
+      //akka-dispatcher.includes = [ "**" ]
     }
   }
 
@@ -34,6 +35,7 @@ kamon {
 
   internal-config {
     akka.loglevel = DEBUG
+    akka.loggers = [ "akka.event.slf4j.Slf4jLogger" ]
   }
 
   modules {
diff --git a/kamon-playground/src/main/scala/test/SimpleRequestProcessor.scala b/kamon-playground/src/main/scala/test/SimpleRequestProcessor.scala
index 280158c0..854fb073 100644
--- a/kamon-playground/src/main/scala/test/SimpleRequestProcessor.scala
+++ b/kamon-playground/src/main/scala/test/SimpleRequestProcessor.scala
@@ -37,7 +37,7 @@ object SimpleRequestProcessor extends App with SimpleRoutingApp with RequestBuil
 
   import scala.concurrent.duration._
 
-  Kamon.start()
+  //Kamon.start()
   implicit val system = ActorSystem("test")
   import test.SimpleRequestProcessor.system.dispatcher
 
@@ -98,6 +98,7 @@ object SimpleRequestProcessor extends App with SimpleRoutingApp with RequestBuil
           traceName("OKFuture") {
             dynamic {
               counter.increment()
+              Kamon.start()
               complete(Future { "OK" })
             }
           }
diff --git a/kamon-spray/src/main/scala/kamon/spray/SprayExtension.scala b/kamon-spray/src/main/scala/kamon/spray/SprayExtension.scala
index 044d2884..10f44bbe 100644
--- a/kamon-spray/src/main/scala/kamon/spray/SprayExtension.scala
+++ b/kamon-spray/src/main/scala/kamon/spray/SprayExtension.scala
@@ -22,28 +22,14 @@ import akka.event.{ Logging, LoggingAdapter }
 import kamon.Kamon
 import kamon.util.http.HttpServerMetrics
 import kamon.metric.Entity
+import org.slf4j.LoggerFactory
 import spray.http.HttpHeaders.Host
 import spray.http.HttpRequest
 
-object Spray extends ExtensionId[SprayExtension] with ExtensionIdProvider {
-  def lookup(): ExtensionId[_ <: actor.Extension] = Spray
-  def createExtension(system: ExtendedActorSystem): SprayExtension = new SprayExtensionImpl(system)
-
+object SprayExtension {
+  val log = LoggerFactory.getLogger("kamon.spray.SprayExtension")
+  val settings = SprayExtensionSettings(Kamon.config)
   val SegmentLibraryName = "spray-client"
-}
-
-trait SprayExtension extends Kamon.Extension {
-  def settings: SprayExtensionSettings
-  def log: LoggingAdapter
-  def httpServerMetrics: HttpServerMetrics
-  def generateTraceName(request: HttpRequest): String
-  def generateRequestLevelApiSegmentName(request: HttpRequest): String
-  def generateHostLevelApiSegmentName(request: HttpRequest): String
-}
-
-class SprayExtensionImpl(system: ExtendedActorSystem) extends SprayExtension {
-  val settings = SprayExtensionSettings(system)
-  val log = Logging(system, "SprayExtension")
 
   val httpServerMetrics = {
     val entity = Entity("spray-server", HttpServerMetrics.category)
diff --git a/kamon-spray/src/main/scala/kamon/spray/SprayExtensionSettings.scala b/kamon-spray/src/main/scala/kamon/spray/SprayExtensionSettings.scala
index 627d5176..9f4e70b3 100644
--- a/kamon-spray/src/main/scala/kamon/spray/SprayExtensionSettings.scala
+++ b/kamon-spray/src/main/scala/kamon/spray/SprayExtensionSettings.scala
@@ -1,6 +1,7 @@
 package kamon.spray
 
-import akka.actor.ExtendedActorSystem
+import akka.actor.ReflectiveDynamicAccess
+import com.typesafe.config.Config
 
 case class SprayExtensionSettings(
   includeTraceTokenHeader: Boolean,
@@ -9,16 +10,17 @@ case class SprayExtensionSettings(
   clientInstrumentationLevel: ClientInstrumentationLevel.Level)
 
 object SprayExtensionSettings {
-  def apply(system: ExtendedActorSystem): SprayExtensionSettings = {
-    val config = system.settings.config.getConfig("kamon.spray")
+  def apply(config: Config): SprayExtensionSettings = {
+    val sprayConfig = config.getConfig("kamon.spray")
 
-    val includeTraceTokenHeader: Boolean = config.getBoolean("automatic-trace-token-propagation")
-    val traceTokenHeaderName: String = config.getString("trace-token-header-name")
+    val includeTraceTokenHeader: Boolean = sprayConfig.getBoolean("automatic-trace-token-propagation")
+    val traceTokenHeaderName: String = sprayConfig.getString("trace-token-header-name")
 
-    val nameGeneratorFQN = config.getString("name-generator")
-    val nameGenerator: NameGenerator = system.dynamicAccess.createInstanceFor[NameGenerator](nameGeneratorFQN, Nil).get // let's bubble up any problems.
+    val nameGeneratorFQN = sprayConfig.getString("name-generator")
+    val nameGenerator: NameGenerator = new ReflectiveDynamicAccess(getClass.getClassLoader)
+      .createInstanceFor[NameGenerator](nameGeneratorFQN, Nil).get // let's bubble up any problems.
 
-    val clientInstrumentationLevel: ClientInstrumentationLevel.Level = config.getString("client.instrumentation-level") match {
+    val clientInstrumentationLevel: ClientInstrumentationLevel.Level = sprayConfig.getString("client.instrumentation-level") match {
       case "request-level" ⇒ ClientInstrumentationLevel.RequestLevelAPI
       case "host-level"    ⇒ ClientInstrumentationLevel.HostLevelAPI
       case other           ⇒ sys.error(s"Invalid client instrumentation level [$other] found in configuration.")
diff --git a/kamon-spray/src/main/scala/kamon/spray/instrumentation/ClientRequestInstrumentation.scala b/kamon-spray/src/main/scala/kamon/spray/instrumentation/ClientRequestInstrumentation.scala
index 1950787d..cf7e207b 100644
--- a/kamon-spray/src/main/scala/kamon/spray/instrumentation/ClientRequestInstrumentation.scala
+++ b/kamon-spray/src/main/scala/kamon/spray/instrumentation/ClientRequestInstrumentation.scala
@@ -16,14 +16,13 @@
 
 package spray.can.client
 
-import kamon.Kamon
 import kamon.util.SameThreadExecutionContext
 import org.aspectj.lang.annotation._
 import org.aspectj.lang.ProceedingJoinPoint
 import spray.http._
 import spray.http.HttpHeaders.RawHeader
 import kamon.trace._
-import kamon.spray.{ ClientInstrumentationLevel, Spray }
+import kamon.spray.{ SprayExtension, ClientInstrumentationLevel }
 import akka.actor.{ ActorRef, Status }
 import scala.concurrent.{ Future, ExecutionContext }
 import akka.util.Timeout
@@ -49,12 +48,10 @@ class ClientRequestInstrumentation {
     requestContext.traceContext
 
     Tracer.currentContext.collect { ctx ⇒
-      val sprayExtension = Kamon.extension(Spray)
-
-      if (sprayExtension.settings.clientInstrumentationLevel == ClientInstrumentationLevel.HostLevelAPI) {
+      if (SprayExtension.settings.clientInstrumentationLevel == ClientInstrumentationLevel.HostLevelAPI) {
         if (requestContext.segment.isEmpty) {
-          val clientRequestName = sprayExtension.generateHostLevelApiSegmentName(request)
-          val segment = ctx.startSegment(clientRequestName, SegmentCategory.HttpClient, Spray.SegmentLibraryName)
+          val clientRequestName = SprayExtension.generateHostLevelApiSegmentName(request)
+          val segment = ctx.startSegment(clientRequestName, SegmentCategory.HttpClient, SprayExtension.SegmentLibraryName)
           requestContext.segment = segment
         }
 
@@ -64,7 +61,7 @@ class ClientRequestInstrumentation {
         // name again here is that when the request was initially sent it might not have the Host information available
         // and it might be important to decide a proper segment name.
 
-        val clientRequestName = sprayExtension.generateHostLevelApiSegmentName(request)
+        val clientRequestName = SprayExtension.generateHostLevelApiSegmentName(request)
         request.asInstanceOf[SegmentAware].segment.rename(clientRequestName)
       }
     }
@@ -114,10 +111,9 @@ class ClientRequestInstrumentation {
 
     (request: HttpRequest) ⇒ {
       Tracer.currentContext.collect { ctx ⇒
-        val sprayExtension = Kamon.extension(Spray)
         val segment =
-          if (sprayExtension.settings.clientInstrumentationLevel == ClientInstrumentationLevel.RequestLevelAPI)
-            ctx.startSegment(sprayExtension.generateRequestLevelApiSegmentName(request), SegmentCategory.HttpClient, Spray.SegmentLibraryName)
+          if (SprayExtension.settings.clientInstrumentationLevel == ClientInstrumentationLevel.RequestLevelAPI)
+            ctx.startSegment(SprayExtension.generateRequestLevelApiSegmentName(request), SegmentCategory.HttpClient, SprayExtension.SegmentLibraryName)
           else
             EmptyTraceContext.EmptySegment
 
@@ -138,9 +134,8 @@ class ClientRequestInstrumentation {
   def aroundIncludingDefaultHeadersAtHttpHostConnector(pjp: ProceedingJoinPoint, request: HttpMessage, defaultHeaders: List[HttpHeader]): Any = {
 
     val modifiedHeaders = Tracer.currentContext.collect { ctx ⇒
-      val sprayExtension = Kamon.extension(Spray)
-      if (sprayExtension.settings.includeTraceTokenHeader)
-        RawHeader(sprayExtension.settings.traceTokenHeaderName, ctx.token) :: defaultHeaders
+      if (SprayExtension.settings.includeTraceTokenHeader)
+        RawHeader(SprayExtension.settings.traceTokenHeaderName, ctx.token) :: defaultHeaders
       else
         defaultHeaders
 
diff --git a/kamon-spray/src/main/scala/kamon/spray/instrumentation/ServerRequestInstrumentation.scala b/kamon-spray/src/main/scala/kamon/spray/instrumentation/ServerRequestInstrumentation.scala
index d773ecd8..d1031962 100644
--- a/kamon-spray/src/main/scala/kamon/spray/instrumentation/ServerRequestInstrumentation.scala
+++ b/kamon-spray/src/main/scala/kamon/spray/instrumentation/ServerRequestInstrumentation.scala
@@ -19,7 +19,7 @@ import org.aspectj.lang.annotation._
 import kamon.trace._
 import spray.http.{ HttpResponse, HttpMessagePartWrapper, HttpRequest }
 import kamon.Kamon
-import kamon.spray.{ SprayExtension, Spray }
+import kamon.spray.SprayExtension
 import org.aspectj.lang.ProceedingJoinPoint
 import spray.http.HttpHeaders.RawHeader
 
@@ -35,11 +35,10 @@ class ServerRequestInstrumentation {
   @After("openRequestInit(openRequest, request)")
   def afterInit(openRequest: TraceContextAware, request: HttpRequest): Unit = {
     import Kamon.tracer
-    val sprayExtension = Kamon(Spray)
 
-    val defaultTraceName = sprayExtension.generateTraceName(request)
-    val token = if (sprayExtension.settings.includeTraceTokenHeader) {
-      request.headers.find(_.name == sprayExtension.settings.traceTokenHeaderName).map(_.value)
+    val defaultTraceName = SprayExtension.generateTraceName(request)
+    val token = if (SprayExtension.settings.includeTraceTokenHeader) {
+      request.headers.find(_.name == SprayExtension.settings.traceTokenHeaderName).map(_.value)
     } else None
 
     val newContext = tracer.newContext(defaultTraceName, token)
@@ -71,17 +70,15 @@ class ServerRequestInstrumentation {
     if (incomingContext.isEmpty)
       pjp.proceed()
     else {
-      val sprayExtension = Kamon(Spray)
-
-      val proceedResult = if (sprayExtension.settings.includeTraceTokenHeader) {
-        val responseWithHeader = includeTraceTokenIfPossible(response, sprayExtension.settings.traceTokenHeaderName, incomingContext.token)
+      val proceedResult = if (SprayExtension.settings.includeTraceTokenHeader) {
+        val responseWithHeader = includeTraceTokenIfPossible(response, SprayExtension.settings.traceTokenHeaderName, incomingContext.token)
         pjp.proceed(Array(openRequest, responseWithHeader))
 
       } else pjp.proceed
 
       Tracer.currentContext.finish()
 
-      recordHttpServerMetrics(response, incomingContext.name, sprayExtension)
+      recordHttpServerMetrics(response, incomingContext.name)
 
       proceedResult
     }
@@ -89,7 +86,7 @@ class ServerRequestInstrumentation {
 
   def verifyTraceContextConsistency(incomingTraceContext: TraceContext, storedTraceContext: TraceContext): Unit = {
     def publishWarning(text: String): Unit =
-      Kamon(Spray).log.warning(text)
+      SprayExtension.log.warn(text)
 
     if (incomingTraceContext.nonEmpty) {
       if (incomingTraceContext.token != storedTraceContext.token)
@@ -98,9 +95,9 @@ class ServerRequestInstrumentation {
       publishWarning(s"EmptyTraceContext present while closing the trace with token [${storedTraceContext.token}]")
   }
 
-  def recordHttpServerMetrics(response: HttpMessagePartWrapper, traceName: String, sprayExtension: SprayExtension): Unit =
+  def recordHttpServerMetrics(response: HttpMessagePartWrapper, traceName: String): Unit =
     response match {
-      case httpResponse: HttpResponse ⇒ sprayExtension.httpServerMetrics.recordResponse(traceName, httpResponse.status.intValue.toString)
+      case httpResponse: HttpResponse ⇒ SprayExtension.httpServerMetrics.recordResponse(traceName, httpResponse.status.intValue.toString)
       case other                      ⇒ // Nothing to do then.
     }
 
diff --git a/kamon-spray/src/test/resources/application.conf b/kamon-spray/src/test/resources/application.conf
index 8b137891..88b0de3d 100644
--- a/kamon-spray/src/test/resources/application.conf
+++ b/kamon-spray/src/test/resources/application.conf
@@ -1 +1,6 @@
+kamon {
+  metric.tick-interval = 1 hour
+  spray.name-generator = kamon.spray.TestNameGenerator
+}
 
+akka.loggers = ["akka.event.slf4j.Slf4jLogger"]
diff --git a/kamon-spray/src/test/scala/kamon/spray/ClientRequestInstrumentationSpec.scala b/kamon-spray/src/test/scala/kamon/spray/ClientRequestInstrumentationSpec.scala
index 2279469c..61ad2836 100644
--- a/kamon-spray/src/test/scala/kamon/spray/ClientRequestInstrumentationSpec.scala
+++ b/kamon-spray/src/test/scala/kamon/spray/ClientRequestInstrumentationSpec.scala
@@ -35,17 +35,6 @@ import scala.concurrent.duration._
 class ClientRequestInstrumentationSpec extends BaseKamonSpec("client-request-instrumentation-spec") with ScalaFutures
     with RequestBuilding with TestServer {
 
-  override lazy val config =
-    ConfigFactory.parseString(
-      """
-        |kamon {
-        |  metric.tick-interval = 1 hour
-        |  spray.name-generator = kamon.spray.TestNameGenerator
-        |}
-        |
-        |akka.loggers = ["akka.event.slf4j.Slf4jLogger"]
-      """.stripMargin)
-
   implicit def ec = system.dispatcher
   implicit val defaultPatience = PatienceConfig(timeout = Span(10, Seconds), interval = Span(5, Millis))
 
@@ -134,7 +123,7 @@ class ClientRequestInstrumentationSpec extends BaseKamonSpec("client-request-ins
           tags = Map(
             "trace" -> "assign-name-to-segment-with-request-level-api",
             "category" -> SegmentCategory.HttpClient,
-            "library" -> Spray.SegmentLibraryName))
+            "library" -> SprayExtension.SegmentLibraryName))
 
         segmentMetricsSnapshot.histogram("elapsed-time").get.numberOfMeasurements should be(1)
       }
@@ -169,7 +158,7 @@ class ClientRequestInstrumentationSpec extends BaseKamonSpec("client-request-ins
           tags = Map(
             "trace" -> "assign-name-to-segment-with-request-level-api",
             "category" -> SegmentCategory.HttpClient,
-            "library" -> Spray.SegmentLibraryName))
+            "library" -> SprayExtension.SegmentLibraryName))
 
         segmentMetricsSnapshot.histogram("elapsed-time").get.numberOfMeasurements should be(1)
       }
@@ -206,7 +195,7 @@ class ClientRequestInstrumentationSpec extends BaseKamonSpec("client-request-ins
           tags = Map(
             "trace" -> "rename-segment-with-request-level-api",
             "category" -> SegmentCategory.HttpClient,
-            "library" -> Spray.SegmentLibraryName))
+            "library" -> SprayExtension.SegmentLibraryName))
 
         segmentMetricsSnapshot.histogram("elapsed-time").get.numberOfMeasurements should be(1)
       }
@@ -300,7 +289,7 @@ class ClientRequestInstrumentationSpec extends BaseKamonSpec("client-request-ins
           tags = Map(
             "trace" -> "create-segment-with-host-level-api",
             "category" -> SegmentCategory.HttpClient,
-            "library" -> Spray.SegmentLibraryName))
+            "library" -> SprayExtension.SegmentLibraryName))
 
         segmentMetricsSnapshot.histogram("elapsed-time").get.numberOfMeasurements should be(1)
       }
@@ -308,7 +297,7 @@ class ClientRequestInstrumentationSpec extends BaseKamonSpec("client-request-ins
   }
 
   def traceTokenHeader(token: String): RawHeader =
-    RawHeader(Kamon(Spray).settings.traceTokenHeaderName, token)
+    RawHeader(SprayExtension.settings.traceTokenHeaderName, token)
 
   def enableInternalSegmentCollectionStrategy(): Unit = setSegmentCollectionStrategy(ClientInstrumentationLevel.HostLevelAPI)
   def enablePipeliningSegmentCollectionStrategy(): Unit = setSegmentCollectionStrategy(ClientInstrumentationLevel.RequestLevelAPI)
@@ -316,14 +305,14 @@ class ClientRequestInstrumentationSpec extends BaseKamonSpec("client-request-ins
   def disableAutomaticTraceTokenPropagation(): Unit = setIncludeTraceToken(false)
 
   def setSegmentCollectionStrategy(strategy: ClientInstrumentationLevel.Level): Unit = {
-    val target = Kamon(Spray).settings
+    val target = SprayExtension.settings
     val field = target.getClass.getDeclaredField("clientInstrumentationLevel")
     field.setAccessible(true)
     field.set(target, strategy)
   }
 
   def setIncludeTraceToken(include: Boolean): Unit = {
-    val target = Kamon(Spray).settings
+    val target = SprayExtension.settings
     val field = target.getClass.getDeclaredField("includeTraceTokenHeader")
     field.setAccessible(true)
     field.set(target, include)
@@ -331,7 +320,7 @@ class ClientRequestInstrumentationSpec extends BaseKamonSpec("client-request-ins
 }
 
 class TestNameGenerator extends NameGenerator {
-  def generateTraceName(request: HttpRequest): String = request.uri.path.toString()
+  def generateTraceName(request: HttpRequest): String = "UnnamedTrace"
   def generateRequestLevelApiSegmentName(request: HttpRequest): String = "request-level " + request.uri.path.toString()
   def generateHostLevelApiSegmentName(request: HttpRequest): String = "host-level " + request.uri.path.toString()
 }
diff --git a/kamon-spray/src/test/scala/kamon/spray/SprayServerMetricsSpec.scala b/kamon-spray/src/test/scala/kamon/spray/SprayServerMetricsSpec.scala
index 69f8d2bd..ed0f208f 100644
--- a/kamon-spray/src/test/scala/kamon/spray/SprayServerMetricsSpec.scala
+++ b/kamon-spray/src/test/scala/kamon/spray/SprayServerMetricsSpec.scala
@@ -10,16 +10,6 @@ import spray.httpx.RequestBuilding
 class SprayServerMetricsSpec extends BaseKamonSpec("spray-server-metrics-spec") with RequestBuilding with ScalaFutures
     with PatienceConfiguration with TestServer {
 
-  override lazy val config =
-    ConfigFactory.parseString(
-      """
-        |kamon.metric {
-        |  tick-interval = 1 hour
-        |}
-        |
-        |akka.loggers = ["akka.event.slf4j.Slf4jLogger"]
-      """.stripMargin)
-
   "the Spray Server metrics instrumentation" should {
     "record trace metrics for processed requests" in {
       val (connection, server) = buildClientConnectionAndServer
diff --git a/kamon-spray/src/test/scala/kamon/spray/SprayServerTracingSpec.scala b/kamon-spray/src/test/scala/kamon/spray/SprayServerTracingSpec.scala
index bfd88ac8..45a704db 100644
--- a/kamon-spray/src/test/scala/kamon/spray/SprayServerTracingSpec.scala
+++ b/kamon-spray/src/test/scala/kamon/spray/SprayServerTracingSpec.scala
@@ -19,7 +19,6 @@ package kamon.spray
 import _root_.spray.httpx.RequestBuilding
 import akka.testkit.TestProbe
 import kamon.testkit.BaseKamonSpec
-import kamon.Kamon
 import org.scalatest.concurrent.{ PatienceConfiguration, ScalaFutures }
 import spray.http.HttpHeaders.RawHeader
 import spray.http.{ HttpResponse, HttpRequest }
@@ -53,7 +52,7 @@ class SprayServerTracingSpec extends BaseKamonSpec("spray-server-tracing-spec")
       server.reply(HttpResponse(entity = "ok"))
       val response = client.expectMsgType[HttpResponse]
 
-      response.headers.count(_.name == Kamon(Spray).settings.traceTokenHeaderName) should be(1)
+      response.headers.count(_.name == SprayExtension.settings.traceTokenHeaderName) should be(1)
 
     }
 
@@ -73,13 +72,13 @@ class SprayServerTracingSpec extends BaseKamonSpec("spray-server-tracing-spec")
   }
 
   def traceTokenHeader(token: String): RawHeader =
-    RawHeader(Kamon(Spray).settings.traceTokenHeaderName, token)
+    RawHeader(SprayExtension.settings.traceTokenHeaderName, token)
 
   def enableAutomaticTraceTokenPropagation(): Unit = setIncludeTraceToken(true)
   def disableAutomaticTraceTokenPropagation(): Unit = setIncludeTraceToken(false)
 
   def setIncludeTraceToken(include: Boolean): Unit = {
-    val target = Kamon(Spray).settings
+    val target = SprayExtension.settings
     val field = target.getClass.getDeclaredField("includeTraceTokenHeader")
     field.setAccessible(true)
     field.set(target, include)
diff --git a/project/Dependencies.scala b/project/Dependencies.scala
index e7aaa14f..dd200757 100644
--- a/project/Dependencies.scala
+++ b/project/Dependencies.scala
@@ -46,10 +46,10 @@ object Dependencies {
   val akkaTestKit       = "com.typesafe.akka"         %%  "akka-testkit"          % akkaVersion
   val akkaRemote        = "com.typesafe.akka"         %%  "akka-remote"           % akkaVersion
   val akkaCluster       = "com.typesafe.akka"         %%  "akka-cluster"          % akkaVersion
-  val slf4Api           = "org.slf4j"                 %   "slf4j-api"             % slf4jVersion
-  val slf4nop           = "org.slf4j"                 %   "slf4j-nop"             % slf4jVersion
-  val slf4Jul           = "org.slf4j"                 %   "jul-to-slf4j"          % slf4jVersion
-  val slf4Log4j         = "org.slf4j"                 %   "log4j-over-slf4j"      % slf4jVersion
+  val slf4jApi          = "org.slf4j"                 %   "slf4j-api"             % slf4jVersion
+  val slf4jnop          = "org.slf4j"                 %   "slf4j-nop"             % slf4jVersion
+  val slf4jJul          = "org.slf4j"                 %   "jul-to-slf4j"          % slf4jVersion
+  val slf4jLog4j        = "org.slf4j"                 %   "log4j-over-slf4j"      % slf4jVersion
   val scalazConcurrent  = "org.scalaz"                %%  "scalaz-concurrent"     % "7.1.0"
   val sigarLoader       = "io.kamon"                  %   "sigar-loader"          % "1.6.5-rev002"
   val h2                = "com.h2database"            %   "h2"                    % "1.4.182"
diff --git a/project/Projects.scala b/project/Projects.scala
index a68677ef..9a199797 100644
--- a/project/Projects.scala
+++ b/project/Projects.scala
@@ -36,10 +36,10 @@ object Projects extends Build {
     .settings(
       javacOptions in Compile ++= Seq("-XDignore.symbol.file"),
       libraryDependencies ++=
-        compile(akkaActor, hdrHistogram, typesafeConfig) ++
+        compile(akkaActor, hdrHistogram, typesafeConfig, slf4jApi) ++
         provided(aspectJ) ++
         optional(logback) ++
-        test(scalatest, akkaTestKit, akkaSlf4j, slf4Jul, slf4Log4j, logback))
+        test(scalatest, akkaTestKit, akkaSlf4j, slf4jJul, slf4jLog4j, logback))
 
 
   lazy val kamonAkka = Project("kamon-akka", file("kamon-akka"))
@@ -53,7 +53,7 @@ object Projects extends Build {
         compile(akkaActor) ++
           provided(aspectJ) ++
           optional(logback) ++
-          test(scalatest, akkaTestKit, akkaSlf4j, slf4Jul, slf4Log4j, logback))
+          test(scalatest, akkaTestKit, akkaSlf4j, slf4jJul, slf4jLog4j, logback))
 
 
   lazy val kamonScala = Project("kamon-scala", file("kamon-scala"))
@@ -66,7 +66,7 @@ object Projects extends Build {
         compile() ++
         provided(aspectJ) ++
         optional(scalazConcurrent) ++
-        test(scalatest, akkaTestKit, akkaSlf4j, slf4Jul, slf4Log4j, logback))
+        test(scalatest, akkaTestKit, akkaSlf4j, slf4jJul, slf4jLog4j, logback))
 
   lazy val kamonAkkaRemote = Project("kamon-akka-remote", file("kamon-akka-remote"))
     .dependsOn(kamonAkka)
@@ -77,7 +77,7 @@ object Projects extends Build {
       libraryDependencies ++=
         compile(akkaRemote, akkaCluster) ++
         provided(aspectJ) ++
-        test(scalatest, akkaTestKit, akkaSlf4j, slf4Jul, slf4Log4j, logback))
+        test(scalatest, akkaTestKit, akkaSlf4j, slf4jJul, slf4jLog4j, logback))
 
 
   lazy val kamonSpray = Project("kamon-spray", file("kamon-spray"))
@@ -89,7 +89,7 @@ object Projects extends Build {
       libraryDependencies ++=
         compile(akkaActor, sprayCan, sprayClient, sprayRouting) ++
         provided(aspectJ) ++
-        test(scalatest, akkaTestKit, sprayTestkit, akkaSlf4j, slf4Jul, slf4Log4j, logback))
+        test(scalatest, akkaTestKit, sprayTestkit, akkaSlf4j, slf4jJul, slf4jLog4j, logback))
 
   lazy val kamonNewrelic = Project("kamon-newrelic", file("kamon-newrelic"))
     .dependsOn(kamonCore % "compile->compile;test->test", kamonTestkit % "test->test")
@@ -100,7 +100,7 @@ object Projects extends Build {
       libraryDependencies ++=
         compile(sprayCan, sprayClient, sprayRouting, sprayJson, sprayJsonLenses, newrelic, akkaSlf4j) ++
         provided(aspectJ) ++
-        test(scalatest, akkaTestKit, sprayTestkit, slf4Api, akkaSlf4j))
+        test(scalatest, akkaTestKit, sprayTestkit, slf4jApi, akkaSlf4j))
 
 
   lazy val kamonPlayground = Project("kamon-playground", file("kamon-playground"))
@@ -122,7 +122,7 @@ object Projects extends Build {
       libraryDependencies ++=
         compile(akkaActor, akkaTestKit) ++
         provided(aspectJ) ++
-        test(slf4Api, slf4nop))
+        test(slf4jApi, slf4jnop))
 
   lazy val kamonPlay23 = Project("kamon-play-23", file("kamon-play-2.3.x"))
     .dependsOn(kamonCore % "compile->compile;test->test", kamonScala)
@@ -133,7 +133,7 @@ object Projects extends Build {
       libraryDependencies ++=
         compile(play23, playWS23) ++
         provided(aspectJ) ++
-        test(playTest23, akkaTestKit, slf4Api))
+        test(playTest23, akkaTestKit, slf4jApi))
 
   lazy val kamonPlay24 = Project("kamon-play-24", file("kamon-play-2.4.x"))
     .dependsOn(kamonCore % "compile->compile;test->test", kamonScala)
@@ -144,7 +144,7 @@ object Projects extends Build {
       libraryDependencies ++=
         compile(play24, playWS24) ++
         provided(aspectJ, typesafeConfig) ++
-        test(playTest24, akkaTestKit, slf4Api))
+        test(playTest24, akkaTestKit, slf4jApi))
 
   lazy val kamonStatsD = Project("kamon-statsd", file("kamon-statsd"))
     .dependsOn(kamonCore % "compile->compile;test->test")
@@ -153,7 +153,7 @@ object Projects extends Build {
     .settings(
       libraryDependencies ++=
         compile(akkaActor) ++
-        test(scalatest, akkaTestKit, slf4Api, slf4nop))
+        test(scalatest, akkaTestKit, slf4jApi, slf4jnop))
 
   lazy val kamonDatadog = Project("kamon-datadog", file("kamon-datadog"))
     .dependsOn(kamonCore % "compile->compile;test->test")
@@ -162,7 +162,7 @@ object Projects extends Build {
     .settings(
       libraryDependencies ++=
         compile(akkaActor) ++
-        test(scalatest, akkaTestKit, slf4Api, slf4nop))
+        test(scalatest, akkaTestKit, slf4jApi, slf4jnop))
 
 
   lazy val kamonLogReporter = Project("kamon-log-reporter", file("kamon-log-reporter"))
@@ -172,7 +172,7 @@ object Projects extends Build {
     .settings(
       libraryDependencies ++=
         compile(akkaActor) ++
-        test(scalatest, akkaTestKit, slf4Api, slf4nop))
+        test(scalatest, akkaTestKit, slf4jApi, slf4jnop))
 
 
   lazy val kamonSystemMetrics = Project("kamon-system-metrics", file("kamon-system-metrics"))
@@ -183,7 +183,7 @@ object Projects extends Build {
     .settings(
       libraryDependencies ++=
         compile(sigarLoader) ++
-        test(scalatest, akkaTestKit, slf4Api, slf4Jul, slf4Log4j, logback))
+        test(scalatest, akkaTestKit, slf4jApi, slf4jJul, slf4jLog4j, logback))
 
   lazy val kamonJdbc = Project("kamon-jdbc", file("kamon-jdbc"))
     .dependsOn(kamonCore % "compile->compile;test->test")
@@ -192,7 +192,7 @@ object Projects extends Build {
     .settings(aspectJSettings: _*)
     .settings(
       libraryDependencies ++=
-        test(h2,scalatest, akkaTestKit, slf4Api) ++
+        test(h2,scalatest, akkaTestKit, slf4jApi) ++
         provided(aspectJ))
 
   lazy val kamonAnnotation = Project("kamon-annotation", file("kamon-annotation"))
@@ -203,7 +203,7 @@ object Projects extends Build {
     .settings(
       libraryDependencies ++=
         compile(el) ++
-          test(scalatest, akkaTestKit, slf4Api) ++
+          test(scalatest, akkaTestKit, slf4jApi) ++
           provided(aspectJ))
 
   lazy val kamonSPM = Project("kamon-spm", file("kamon-spm"))
@@ -213,7 +213,7 @@ object Projects extends Build {
     .settings(
       libraryDependencies ++=
         compile(sprayCan, sprayClient, sprayRouting, sprayJson, sprayJsonLenses, newrelic, akkaSlf4j) ++
-        test(scalatest, akkaTestKit, slf4Api, slf4nop))
+        test(scalatest, akkaTestKit, slf4jApi, slf4jnop))
 
   val noPublishing = Seq(publish := (), publishLocal := (), publishArtifact := false)
 }