on the crazy path to a better Kamon :D

3 files changed, 74 insertions, 48 deletions

diff --git a/kamon-core/src/main/scala/kamon/trace/Sampler.scala b/kamon-core/src/main/scala/kamon/trace/Sampler.scala
index 491cf358..3cb55e51 100644
--- a/kamon-core/src/main/scala/kamon/trace/Sampler.scala
+++ b/kamon-core/src/main/scala/kamon/trace/Sampler.scala
@@ -20,6 +20,9 @@ object Sampler {
 
   class Constant(decision: Boolean) extends Sampler {
     override def decide(spanID: Long): Boolean = decision
+
+    override def toString: String =
+      s"Sampler.Constant(decision = $decision)"
   }
 
   class Random(chance: Double) extends Sampler {
@@ -28,5 +31,8 @@ object Sampler {
 
     override def decide(spanID: Long): Boolean =
       spanID >= lowerBoundary && spanID <= upperBoundary
+
+    override def toString: String =
+      s"Sampler.Random(chance = $chance)"
   }
 }
diff --git a/kamon-core/src/main/scala/kamon/trace/Span.scala b/kamon-core/src/main/scala/kamon/trace/Span.scala
index e64d8118..635f9545 100644
--- a/kamon-core/src/main/scala/kamon/trace/Span.scala
+++ b/kamon-core/src/main/scala/kamon/trace/Span.scala
@@ -1,32 +1,13 @@
 package kamon
 package trace
 
-import scala.collection.JavaConverters._
-import kamon.util.Clock
-
-object Span {
-  val MetricCategory = "span"
-  val LatencyMetricName = "elapsed-time"
-  val ErrorMetricName = "error"
-  val MetricTagPrefix = "metric."
-  val BooleanTagTrueValue = "1"
-  val BooleanTagFalseValue = "0"
-
-  case class LogEntry(timestamp: Long, fields: Map[String, _])
-
-  case class CompletedSpan(
-    context: SpanContext,
-    operationName: String,
-    startTimestampMicros: Long,
-    endTimestampMicros: Long,
-    tags: Map[String, String],
-    logs: Seq[LogEntry]
-  )
-}
+import kamon.metric.MetricLookup
 
+import scala.collection.JavaConverters._
+import kamon.util.{Clock, MeasurementUnit}
 
 class Span(spanContext: SpanContext, initialOperationName: String, initialTags: Map[String, String], startTimestampMicros: Long,
-    recorderRegistry: Any, reporterRegistry: ReporterRegistryImpl) extends io.opentracing.Span {
+    metrics: MetricLookup, reporterRegistry: ReporterRegistryImpl) extends io.opentracing.Span {
 
   private var isOpen: Boolean = true
   private val sampled: Boolean = spanContext.sampled
@@ -35,7 +16,7 @@ class Span(spanContext: SpanContext, initialOperationName: String, initialTags:
 
   private var tags = initialTags
   private var logs = List.empty[Span.LogEntry]
-  private var metricTags = Map.empty[String, String]
+  private var additionalMetricTags = Map.empty[String, String]
 
 
   override def log(fields: java.util.Map[String, _]): Span =
@@ -117,7 +98,7 @@ class Span(spanContext: SpanContext, initialOperationName: String, initialTags:
 
   def setMetricTag(key: String, value: String): Span = synchronized {
     if (isOpen)
-      metricTags = metricTags ++ Map(key -> value)
+      additionalMetricTags = additionalMetricTags ++ Map(key -> value)
     this
   }
 
@@ -135,7 +116,7 @@ class Span(spanContext: SpanContext, initialOperationName: String, initialTags:
 
   private def extractMetricTag(tag: String, value: String): Unit =
     if(tag.startsWith(Span.MetricTagPrefix))
-      metricTags = metricTags ++ Map(tag.substring(Span.MetricTagPrefix.length) -> value)
+      additionalMetricTags = additionalMetricTags ++ Map(tag.substring(Span.MetricTagPrefix.length) -> value)
 
   override def finish(): Unit =
     finish(Clock.microTimestamp())
@@ -153,17 +134,32 @@ class Span(spanContext: SpanContext, initialOperationName: String, initialTags:
 
   private def recordSpanMetrics(): Unit = {
     val elapsedTime = endTimestampMicros - startTimestampMicros
-//    val entity = Entity(operationName, Span.MetricCategory, metricTags)
-//    val recorder = recorderRegistry.getRecorder(entity)
-
-//    recorder
-//      .histogram(Span.LatencyMetricName, MeasurementUnit.time.microseconds, DynamicRange.Default)
-//      .record(elapsedTime)
-//
-//    tags.get("error").foreach { errorTag =>
-//      if(errorTag != null && errorTag.equals(Span.BooleanTagTrueValue)) {
-//        recorder.counter(Span.ErrorMetricName).increment()
-//      }
-//    }
+    val metricTags = Map("operation" -> operationName) ++ additionalMetricTags
+
+    val latencyHistogram = metrics.histogram("span.processing-time", MeasurementUnit.time.microseconds, metricTags)
+    latencyHistogram.record(elapsedTime)
+
+    tags.get("error").foreach { errorTag =>
+      if(errorTag != null && errorTag.equals(Span.BooleanTagTrueValue)) {
+        metrics.counter("span.errors", MeasurementUnit.none, metricTags).increment()
+      }
+    }
   }
-}
\ No newline at end of file
+}
+
+object Span {
+  val MetricTagPrefix = "metric."
+  val BooleanTagTrueValue = "1"
+  val BooleanTagFalseValue = "0"
+
+  case class LogEntry(timestamp: Long, fields: Map[String, _])
+
+  case class CompletedSpan(
+    context: SpanContext,
+    operationName: String,
+    startTimestampMicros: Long,
+    endTimestampMicros: Long,
+    tags: Map[String, String],
+    logs: Seq[LogEntry]
+  )
+}
diff --git a/kamon-core/src/main/scala/kamon/trace/Tracer.scala b/kamon-core/src/main/scala/kamon/trace/Tracer.scala
index ed42b810..22e19ebc 100644
--- a/kamon-core/src/main/scala/kamon/trace/Tracer.scala
+++ b/kamon-core/src/main/scala/kamon/trace/Tracer.scala
@@ -2,19 +2,24 @@ package kamon.trace
 
 import java.util.concurrent.ThreadLocalRandom
 
+import com.typesafe.config.Config
 import com.typesafe.scalalogging.Logger
-import io.opentracing.propagation.{TextMap, Format}
+import io.opentracing.propagation.{Format, TextMap}
 import io.opentracing.propagation.Format.Builtin.{BINARY, HTTP_HEADERS, TEXT_MAP}
 import io.opentracing.util.ThreadLocalActiveSpanSource
 import kamon.ReporterRegistryImpl
+import kamon.metric.MetricLookup
 import kamon.util.Clock
 
-class Tracer(metrics: Any, reporterRegistry: ReporterRegistryImpl) extends io.opentracing.Tracer {
+
+
+
+class Tracer(metrics: MetricLookup, reporterRegistry: ReporterRegistryImpl) extends io.opentracing.Tracer {
   private val logger = Logger(classOf[Tracer])
-  ///private val metricsRecorder = new TracerMetricsRecorder(metrics.getRecorder(Entity("tracer", "tracer", Map.empty)))
+  private val tracerMetrics = new TracerMetrics(metrics)
   private val activeSpanSource = new ThreadLocalActiveSpanSource()
 
-  @volatile private var sampler: Sampler = Sampler.never
+  @volatile private var configuredSampler: Sampler = Sampler.never
   @volatile private var textMapSpanContextCodec = SpanContextCodec.TextMap
   @volatile private var httpHeaderSpanContextCodec = SpanContextCodec.ZipkinB3
 
@@ -22,8 +27,8 @@ class Tracer(metrics: Any, reporterRegistry: ReporterRegistryImpl) extends io.op
     new SpanBuilder(operationName)
 
   override def extract[C](format: Format[C], carrier: C): io.opentracing.SpanContext = format match {
-    case HTTP_HEADERS => httpHeaderSpanContextCodec.extract(carrier.asInstanceOf[TextMap], sampler)
-    case TEXT_MAP     => textMapSpanContextCodec.extract(carrier.asInstanceOf[TextMap], sampler)
+    case HTTP_HEADERS => httpHeaderSpanContextCodec.extract(carrier.asInstanceOf[TextMap], configuredSampler)
+    case TEXT_MAP     => textMapSpanContextCodec.extract(carrier.asInstanceOf[TextMap], configuredSampler)
     case BINARY       => null // TODO: Implement Binary Encoding
     case _            => null
   }
@@ -35,6 +40,9 @@ class Tracer(metrics: Any, reporterRegistry: ReporterRegistryImpl) extends io.op
     case _            =>
   }
 
+  def sampler: Sampler =
+    configuredSampler
+
   override def activeSpan(): io.opentracing.ActiveSpan =
     activeSpanSource.activeSpan()
 
@@ -114,15 +122,31 @@ class Tracer(metrics: Any, reporterRegistry: ReporterRegistryImpl) extends io.op
           new SpanContext(parentContext.traceID, createID(), parentContext.spanID, parentContext.sampled, initialTags)
         else {
           val traceID = createID()
-          new SpanContext(traceID, traceID, 0L, sampler.decide(traceID), initialTags)
+          new SpanContext(traceID, traceID, 0L, configuredSampler.decide(traceID), initialTags)
         }
 
-      //metricsRecorder.createdSpans.increment()
-      new Span(spanContext, operationName, initialTags, startTimestampMicros, ???, reporterRegistry)
+      tracerMetrics.createdSpans.increment()
+      new Span(spanContext, operationName, initialTags, startTimestampMicros, metrics, reporterRegistry)
     }
 
     private def createID(): Long =
       ThreadLocalRandom.current().nextLong()
   }
 
+
+  private[kamon] def reconfigure(config: Config): Unit = synchronized {
+    val traceConfig = config.getConfig("kamon.trace")
+
+    configuredSampler = traceConfig.getString("sampler") match {
+      case "always" => Sampler.always
+      case "never"  => Sampler.never
+      case "random" => Sampler.random(traceConfig.getDouble("sampler-random.chance"))
+      case other    => sys.error(s"Unexpected sampler name $other.")
+    }
+  }
+
+  private final class TracerMetrics(metricLookup: MetricLookup) {
+    val createdSpans = metricLookup.counter("tracer.spans-created")
+  }
+
 }