From 72b9071e57a87478446c48513dcb491426eb9920 Mon Sep 17 00:00:00 2001
From: hunterpayne-ck <hunter.payne@creditkarma.com>
Date: Sun, 11 Dec 2016 17:08:52 -0300
Subject: + core:  adding back a method to allow passing of a configuration
 into kamon

*  more-flexible-kamon-config: adding back a method to allow passing of a configuration into kamon but still allows for kamon's internal config to control the actor system responsible for metrics

(cherry picked from commit 1734c2b)
---
 kamon-core/src/main/scala/kamon/Kamon.scala        | 87 +++++++++++++++-------
 .../test/scala/kamon/testkit/BaseKamonSpec.scala   | 15 ++--
 2 files changed, 69 insertions(+), 33 deletions(-)

diff --git a/kamon-core/src/main/scala/kamon/Kamon.scala b/kamon-core/src/main/scala/kamon/Kamon.scala
index 46e75b4e..24b7c07c 100644
--- a/kamon-core/src/main/scala/kamon/Kamon.scala
+++ b/kamon-core/src/main/scala/kamon/Kamon.scala
@@ -24,23 +24,61 @@ import kamon.util.logger.LazyLogger
 import _root_.scala.util.control.NonFatal
 import _root_.scala.util.{Failure, Success, Try}
 
+trait ConfigProvider {
+  def config: Config
+
+  final def patchedConfig: Config = {
+    val internalConfig = config.getConfig("kamon.internal-config")
+    config
+      .withoutPath("akka")
+      .withoutPath("spray")
+      .withFallback(internalConfig)
+  }
+}
+
 object Kamon {
 
   private val log = LazyLogger("Kamon")
 
   trait Extension extends actor.Extension
 
-  val config = resolveConfiguration
-  val metrics = MetricsModuleImpl(config)
-  val tracer = TracerModuleImpl(metrics, config)
+  def defaultConfig = ConfigFactory.load(this.getClass.getClassLoader, ConfigParseOptions.defaults(), ConfigResolveOptions.defaults().setAllowUnresolved(true))
 
-  private lazy val _system = {
-    val internalConfig = config.getConfig("kamon.internal-config")
+  class KamonDefaultConfigProvider extends ConfigProvider {
+    def config = resolveConfiguration
 
-    val patchedConfig = config
-      .withoutPath("akka")
-      .withoutPath("spray")
-      .withFallback(internalConfig)
+    private def resolveConfiguration: Config = {
+      val defaultConf = defaultConfig
+
+      defaultConf.getString("kamon.config-provider") match {
+        case "default" ⇒ defaultConf
+        case fqcn ⇒
+          val dynamic = new ReflectiveDynamicAccess(getClass.getClassLoader)
+          dynamic.createInstanceFor[ConfigProvider](fqcn, Nil).get.config
+      }
+    }
+  }
+
+  class KamonConfigProvider(_config: Config) extends ConfigProvider {
+    def config = _config
+  }
+
+  private[kamon] var configProvider: Option[ConfigProvider] = None
+  def config: Config =
+    configProvider match {
+      case Some(provider) ⇒ provider.config
+      case None           ⇒ throw new Exception("Kamon.start() not called yet")
+    }
+  lazy val metrics = MetricsModuleImpl(config)
+  lazy val tracer = TracerModuleImpl(metrics, config)
+
+  private lazy val _system = {
+    val patchedConfig =
+      configProvider match {
+        case Some(provider) ⇒ provider.patchedConfig
+        case None ⇒
+          throw new Exception("Kamon.start() not called yet")
+      }
 
     log.info("Initializing Kamon...")
 
@@ -55,7 +93,20 @@ object Kamon {
     _system.registerExtension(ModuleLoader)
   }
 
-  def start(): Unit = _start
+  def start(): Unit = {
+    configProvider = Some(new KamonDefaultConfigProvider())
+    _start
+  }
+
+  def start(conf: Config): Unit = {
+    configProvider = Some(new KamonConfigProvider(conf))
+    _start
+  }
+
+  def start(provider: ConfigProvider): Unit = {
+    configProvider = Some(provider)
+    _start
+  }
 
   def shutdown(): Unit = {
     _system.shutdown()
@@ -74,20 +125,4 @@ object Kamon {
       case Failure(NonFatal(reason)) ⇒ log.debug(s"Kamon-autoweave failed to load. Reason: ${reason.getMessage}.")
     }
   }
-
-  private def resolveConfiguration: Config = {
-    val defaultConfig = ConfigFactory.load(this.getClass.getClassLoader, ConfigParseOptions.defaults(), ConfigResolveOptions.defaults().setAllowUnresolved(true))
-
-    defaultConfig.getString("kamon.config-provider") match {
-      case "default" ⇒ defaultConfig.resolve()
-      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/test/scala/kamon/testkit/BaseKamonSpec.scala b/kamon-core/src/test/scala/kamon/testkit/BaseKamonSpec.scala
index d2e569ad..b11acbb3 100644
--- a/kamon-core/src/test/scala/kamon/testkit/BaseKamonSpec.scala
+++ b/kamon-core/src/test/scala/kamon/testkit/BaseKamonSpec.scala
@@ -17,23 +17,24 @@
 package kamon.testkit
 
 import akka.actor.ActorSystem
-import akka.testkit.{ImplicitSender, TestKitBase}
+import akka.testkit.{ ImplicitSender, TestKitBase }
 import com.typesafe.config.Config
 import kamon.Kamon
-import kamon.metric.{Entity, EntitySnapshot, SubscriptionsDispatcher}
+import kamon.metric.{ Entity, EntitySnapshot, SubscriptionsDispatcher }
 import kamon.trace.TraceContext
 import kamon.util.LazyActorRef
-import org.scalatest.{BeforeAndAfterAll, Matchers, WordSpecLike}
+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()
-    ActorSystem(actorSystemName, config)
+    Kamon.start(mergedConfig)
+    ActorSystem(actorSystemName, mergedConfig)
   }
 
-  def config: Config =
-    Kamon.config
+  def config: Config = Kamon.defaultConfig
+
+  def mergedConfig: Config = config.withFallback(Kamon.defaultConfig)
 
   def newContext(name: String): TraceContext =
     Kamon.tracer.newContext(name)
-- 
cgit v1.2.3