diff options
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) } |