! all: Kamon now works as a single instance in a companion object.

1 files changed, 44 insertions, 32 deletions

diff --git a/kamon-core/src/main/scala/kamon/Kamon.scala b/kamon-core/src/main/scala/kamon/Kamon.scala
index 6fedc065..2bed4737 100644
--- a/kamon-core/src/main/scala/kamon/Kamon.scala
+++ b/kamon-core/src/main/scala/kamon/Kamon.scala
@@ -16,49 +16,61 @@ package kamon
 
 import _root_.akka.actor
 import _root_.akka.actor._
-import com.typesafe.config.Config
+import com.typesafe.config.{ ConfigFactory, Config }
 import kamon.metric._
-import kamon.supervisor.ModuleSupervisor
-import kamon.trace.{ Tracer, TracerExtension }
+import kamon.trace.{ TracerExtensionImpl, TracerExtension }
 
-class Kamon(val actorSystem: ActorSystem) {
-  val metrics: MetricsExtension = Metrics.get(actorSystem)
-  val tracer: TracerExtension = Tracer.get(actorSystem)
-  val userMetrics: UserMetricsExtension = UserMetrics.get(actorSystem)
+object Kamon {
+  trait Extension extends actor.Extension
 
-  // This will cause all auto-start modules to initiate.
-  ModuleSupervisor.get(actorSystem)
+  private case class KamonCoreComponents(
+    metrics: MetricsExtension,
+    tracer: TracerExtension,
+    userMetrics: UserMetricsExtension)
 
-  def shutdown(): Unit =
-    actorSystem.shutdown()
-}
+  @volatile private var _system: ActorSystem = _
+  @volatile private var _coreComponents: Option[KamonCoreComponents] = None
 
-object Kamon {
-  trait Extension extends actor.Extension
-  def apply[T <: Extension](key: ExtensionId[T])(implicit system: ActorSystem): T = key(system)
+  def start(config: Config): Unit = synchronized {
+    if (_coreComponents.isEmpty) {
+      val metrics = MetricsExtensionImpl(config)
+      val simpleMetrics = UserMetricsExtensionImpl(metrics)
+      val tracer = TracerExtensionImpl(metrics, config)
 
-  def apply(): Kamon =
-    apply("kamon")
+      _coreComponents = Some(KamonCoreComponents(metrics, tracer, simpleMetrics))
+      _system = ActorSystem("kamon", config)
 
-  def apply(actorSystemName: String): Kamon =
-    apply(ActorSystem(actorSystemName))
+      metrics.start(_system)
+      tracer.start(_system)
 
-  def apply(actorSystemName: String, config: Config): Kamon =
-    apply(ActorSystem(actorSystemName, config))
+    } else sys.error("Kamon has already been started.")
+  }
 
-  def apply(system: ActorSystem): Kamon =
-    new Kamon(system)
+  def start(): Unit =
+    start(ConfigFactory.load)
 
-  def create(): Kamon =
-    apply()
+  def metrics: MetricsExtension =
+    ifStarted(_.metrics)
 
-  def create(actorSystemName: String): Kamon =
-    apply(ActorSystem(actorSystemName))
+  def tracer: TracerExtension =
+    ifStarted(_.tracer)
 
-  def create(actorSystemName: String, config: Config): Kamon =
-    apply(ActorSystem(actorSystemName, config))
+  def userMetrics: UserMetricsExtension =
+    ifStarted(_.userMetrics)
 
-  def create(system: ActorSystem): Kamon =
-    new Kamon(system)
+  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 extension[T <: Kamon.Extension](key: ExtensionId[T]): T =
+    apply(key)
+
+  private def ifStarted[T](thunk: KamonCoreComponents ⇒ T): T =
+    _coreComponents.map(thunk(_)) getOrElse (sys.error("Kamon has not been started yet."))
+
+}
 
-}
\ No newline at end of file