tests for Span building and the ExtendedB3 codec, related bugfixes

4 files changed, 295 insertions, 20 deletions

diff --git a/kamon-core/src/test/scala/kamon/testkit/SpanBuilding.scala b/kamon-core/src/test/scala/kamon/testkit/SpanBuilding.scala
new file mode 100644
index 00000000..9b845ac9
--- /dev/null
+++ b/kamon-core/src/test/scala/kamon/testkit/SpanBuilding.scala
@@ -0,0 +1,20 @@
+package kamon.testkit
+
+import kamon.trace.SpanContext.{SamplingDecision, Source}
+import kamon.trace.{IdentityProvider, SpanContext, SpanContextCodec}
+
+trait SpanBuilding {
+  private val identityProvider = IdentityProvider.Default()
+  private val extendedB3Codec = SpanContextCodec.ExtendedB3(identityProvider)
+
+  def createSpanContext(samplingDecision: SamplingDecision = SamplingDecision.Sample): SpanContext =
+    SpanContext(
+      traceID = identityProvider.traceIdentifierGenerator().generate(),
+      spanID = identityProvider.spanIdentifierGenerator().generate(),
+      parentID = identityProvider.spanIdentifierGenerator().generate(),
+      samplingDecision = samplingDecision,
+      baggage = SpanContext.Baggage(),
+      source = Source.Local
+    )
+
+}
diff --git a/kamon-core/src/test/scala/kamon/testkit/SpanInspector.scala b/kamon-core/src/test/scala/kamon/testkit/SpanInspector.scala
index b0bb3e39..3ef1012b 100644
--- a/kamon-core/src/test/scala/kamon/testkit/SpanInspector.scala
+++ b/kamon-core/src/test/scala/kamon/testkit/SpanInspector.scala
@@ -1,15 +1,61 @@
 package kamon.testkit
 
-import kamon.trace.Span
+import kamon.trace.{ActiveSpan, Span, SpanContext}
 import kamon.trace.Span.FinishedSpan
+import kamon.util.Clock
+
+import scala.reflect.ClassTag
+import scala.util.Try
 
 class SpanInspector(span: Span) {
+  private val (realSpan, spanData) = {
+    val realSpan = span match {
+      case _: Span.Real => span
+      case a: ActiveSpan =>
+        getField[ActiveSpan.Default, Span](a, "wrappedSpan")
+    }
+
+    val spanData = invoke[Span.Real, FinishedSpan](realSpan, "toFinishedSpan", classOf[Long] -> Long.box(Clock.microTimestamp()))
+    (realSpan, spanData)
+  }
+
+  def nonEmpty: Boolean =
+    !span.isInstanceOf[Span.Empty]
+
+  def spanTag(key: String): Option[Span.TagValue] =
+    spanData.tags.get(key)
+
+  def spanTags(): Map[String, Span.TagValue] =
+    spanData.tags
+
+  def metricTags(): Map[String, String] =
+    getField[Span.Real, Map[String, String]](realSpan, "customMetricTags")
 
+  def startTimestamp(): Long =
+    getField[Span.Real, Long](realSpan, "startTimestampMicros")
 
-  private def getSpanData(): Option[FinishedSpan] = {
-    
+  def context(): SpanContext =
+    spanData.context
+
+  def operationName(): String =
+    spanData.operationName
+
+
+
+
+  private def getField[T, R](target: Any, fieldName: String)(implicit classTag: ClassTag[T]): R = {
+    val toFinishedSpanMethod = classTag.runtimeClass.getDeclaredField(fieldName)
+    toFinishedSpanMethod.setAccessible(true)
+    toFinishedSpanMethod.get(target).asInstanceOf[R]
   }
 
+  private def invoke[T, R](target: Any, fieldName: String, parameters: (Class[_], AnyRef)*)(implicit classTag: ClassTag[T]): R = {
+    val parameterClasses = parameters.map(_._1)
+    val parameterInstances = parameters.map(_._2)
+    val toFinishedSpanMethod = classTag.runtimeClass.getDeclaredMethod(fieldName, parameterClasses: _*)
+    toFinishedSpanMethod.setAccessible(true)
+    toFinishedSpanMethod.invoke(target, parameterInstances: _*).asInstanceOf[R]
+  }
 }
 
 object SpanInspector {
diff --git a/kamon-core/src/test/scala/kamon/trace/ExtendedB3SpanContextCodecSpec.scala b/kamon-core/src/test/scala/kamon/trace/ExtendedB3SpanContextCodecSpec.scala
index 9491181f..a11aaa4b 100644
--- a/kamon-core/src/test/scala/kamon/trace/ExtendedB3SpanContextCodecSpec.scala
+++ b/kamon-core/src/test/scala/kamon/trace/ExtendedB3SpanContextCodecSpec.scala
@@ -16,15 +16,19 @@
 
 package kamon.trace
 
+import kamon.testkit.SpanBuilding
 import kamon.trace.IdentityProvider.Identifier
-import kamon.trace.SpanContext.{SamplingDecision, Source}
+import kamon.trace.SpanContext.SamplingDecision
 import org.scalatest.{Matchers, OptionValues, WordSpecLike}
 
 
-class ExtendedB3SpanContextCodecSpec extends WordSpecLike with Matchers with OptionValues {
+class ExtendedB3SpanContextCodecSpec extends WordSpecLike with Matchers with OptionValues with SpanBuilding {
+  val identityProvider = IdentityProvider.Default()
+  val extendedB3Codec = SpanContextCodec.ExtendedB3(identityProvider)
+
   "The ExtendedB3 SpanContextCodec" should {
     "return a TextMap containing the SpanContext data" in {
-      val context = createSpanContext()
+      val context = testSpanContext()
       context.baggage.add("some", "baggage")
       context.baggage.add("more", "baggage")
 
@@ -37,7 +41,7 @@ class ExtendedB3SpanContextCodecSpec extends WordSpecLike with Matchers with Opt
     }
 
     "allow to provide the TextMap to be used for encoding" in {
-      val context = createSpanContext()
+      val context = testSpanContext()
       context.baggage.add("some", "baggage")
       context.baggage.add("more", "baggage")
 
@@ -69,6 +73,36 @@ class ExtendedB3SpanContextCodecSpec extends WordSpecLike with Matchers with Opt
       )
     }
 
+    "decode the sampling decision based on the X-B3-Sampled header" in {
+      val sampledTextMap = TextMap.Default()
+      sampledTextMap.put("X-B3-TraceId", "1234")
+      sampledTextMap.put("X-B3-SpanId", "4321")
+      sampledTextMap.put("X-B3-Sampled", "1")
+
+      val notSampledTextMap = TextMap.Default()
+      notSampledTextMap.put("X-B3-TraceId", "1234")
+      notSampledTextMap.put("X-B3-SpanId", "4321")
+      notSampledTextMap.put("X-B3-Sampled", "0")
+
+      val noSamplingTextMap = TextMap.Default()
+      noSamplingTextMap.put("X-B3-TraceId", "1234")
+      noSamplingTextMap.put("X-B3-SpanId", "4321")
+
+      extendedB3Codec.extract(sampledTextMap).value.samplingDecision shouldBe SamplingDecision.Sample
+      extendedB3Codec.extract(notSampledTextMap).value.samplingDecision shouldBe SamplingDecision.DoNotSample
+      extendedB3Codec.extract(noSamplingTextMap).value.samplingDecision shouldBe SamplingDecision.Unknown
+    }
+
+    "not include the X-B3-Sampled header if the sampling decision is unknown" in {
+      val sampledSpanContext = testSpanContext()
+      val notSampledSpanContext = testSpanContext().copy(samplingDecision = SamplingDecision.DoNotSample)
+      val unknownSamplingSpanContext = testSpanContext().copy(samplingDecision = SamplingDecision.Unknown)
+
+      extendedB3Codec.inject(sampledSpanContext).get("X-B3-Sampled").value shouldBe("1")
+      extendedB3Codec.inject(notSampledSpanContext).get("X-B3-Sampled").value shouldBe("0")
+      extendedB3Codec.inject(unknownSamplingSpanContext).get("X-B3-Sampled") shouldBe empty
+    }
+
     "use the Debug flag to override the sampling decision, if provided." in {
       val textMap = TextMap.Default()
       textMap.put("X-B3-TraceId", "1234")
@@ -103,6 +137,26 @@ class ExtendedB3SpanContextCodecSpec extends WordSpecLike with Matchers with Opt
       spanContext.baggage.getAll() shouldBe empty
     }
 
+    "do not extract a SpanContext if Trace ID and Span ID are not provided" in {
+      val onlyTraceID = TextMap.Default()
+      onlyTraceID.put("X-B3-TraceId", "1234")
+      onlyTraceID.put("X-B3-Sampled", "0")
+      onlyTraceID.put("X-B3-Flags", "1")
+
+      val onlySpanID = TextMap.Default()
+      onlySpanID.put("X-B3-SpanId", "4321")
+      onlySpanID.put("X-B3-Sampled", "0")
+      onlySpanID.put("X-B3-Flags", "1")
+
+      val noIds = TextMap.Default()
+      noIds.put("X-B3-Sampled", "0")
+      noIds.put("X-B3-Flags", "1")
+
+      extendedB3Codec.extract(onlyTraceID) shouldBe empty
+      extendedB3Codec.extract(onlySpanID) shouldBe empty
+      extendedB3Codec.extract(noIds) shouldBe empty
+    }
+
     "round trip a SpanContext from TextMap -> SpanContext -> TextMap" in {
       val textMap = TextMap.Default()
       textMap.put("X-B3-TraceId", "1234")
@@ -118,7 +172,7 @@ class ExtendedB3SpanContextCodecSpec extends WordSpecLike with Matchers with Opt
     }
 
     "round trip a baggage that has special characters in there" in {
-      val spanContext = createSpanContext()
+      val spanContext = testSpanContext()
       spanContext.baggage.add("key-with-!specials", "value=with~spec;als")
 
       val textMap = extendedB3Codec.inject(spanContext)
@@ -126,19 +180,26 @@ class ExtendedB3SpanContextCodecSpec extends WordSpecLike with Matchers with Opt
       extractedSpanContext.baggage.getAll().values.toSeq should contain theSameElementsAs(spanContext.baggage.getAll().values.toSeq)
     }
 
+    "internally carry the X-B3-Flags value so that it can be injected in outgoing requests" in {
+      val textMap = TextMap.Default()
+      textMap.put("X-B3-TraceId", "1234")
+      textMap.put("X-B3-ParentSpanId", "2222")
+      textMap.put("X-B3-SpanId", "4321")
+      textMap.put("X-B3-Sampled", "1")
+      textMap.put("X-B3-Flags", "1")
+      textMap.put("X-B3-Extra-Baggage", "some=baggage;more=baggage")
 
-  }
+      val spanContext = extendedB3Codec.extract(textMap).value
+      val injectTextMap = extendedB3Codec.inject(spanContext)
 
-  val identityProvider = IdentityProvider.Default()
-  val extendedB3Codec = SpanContextCodec.ExtendedB3(identityProvider)
+      injectTextMap.get("X-B3-Flags").value shouldBe("1")
+    }
+  }
 
-  def createSpanContext(samplingDecision: SamplingDecision = SamplingDecision.Sample): SpanContext =
-    SpanContext(
+  def testSpanContext(): SpanContext =
+    createSpanContext().copy(
       traceID = Identifier("1234", Array[Byte](1, 2, 3, 4)),
       spanID = Identifier("4321", Array[Byte](4, 3, 2, 1)),
-      parentID = Identifier("2222", Array[Byte](2, 2, 2, 2)),
-      samplingDecision = samplingDecision,
-      baggage = SpanContext.Baggage(),
-      source = Source.Local
+      parentID = Identifier("2222", Array[Byte](2, 2, 2, 2))
     )
 }
\ No newline at end of file
diff --git a/kamon-core/src/test/scala/kamon/trace/TracerSpec.scala b/kamon-core/src/test/scala/kamon/trace/TracerSpec.scala
index 686c15d0..3e05adb5 100644
--- a/kamon-core/src/test/scala/kamon/trace/TracerSpec.scala
+++ b/kamon-core/src/test/scala/kamon/trace/TracerSpec.scala
@@ -1,18 +1,166 @@
 package kamon.trace
 
+import com.typesafe.config.ConfigFactory
 import kamon.Kamon
-import org.scalatest.{Matchers, WordSpec}
+import kamon.testkit.{SpanBuilding, SpanInspector}
+import kamon.trace.Span.TagValue
+import kamon.trace.SpanContext.Source
+import kamon.trace.SpanContextCodec.Format
+import org.scalatest.{Matchers, OptionValues, WordSpec}
 
-class TracerSpec extends WordSpec with Matchers {
+class TracerSpec extends WordSpec with Matchers with SpanBuilding with OptionValues {
 
   "the Kamon tracer" should {
-    "build spans that contain all information given to the builder" in {
+    "construct a minimal Span that only has a operation name" in {
+      val span = tracer.buildSpan("myOperation").start()
+      val spanData = inspect(span)
+
+      spanData.operationName() shouldBe "myOperation"
+      spanData.metricTags() shouldBe empty
+      spanData.spanTags() shouldBe empty
+    }
+
+    "pass the operation name and tags to started Span" in {
       val span = tracer.buildSpan("myOperation")
+        .withMetricTag("metric-tag", "value")
+        .withMetricTag("metric-tag", "value")
         .withSpanTag("hello", "world")
+        .withSpanTag("kamon", "rulez")
+        .withSpanTag("number", 123)
+        .withSpanTag("boolean", true)
         .start()
+
+      val spanData = inspect(span)
+      spanData.operationName() shouldBe "myOperation"
+      spanData.metricTags() should contain only (
+        ("metric-tag" -> "value"))
+
+      spanData.spanTags() should contain allOf(
+        ("hello" -> TagValue.String("world")),
+        ("kamon" -> TagValue.String("rulez")),
+        ("number" -> TagValue.Number(123)),
+        ("boolean" -> TagValue.True))
+    }
+
+    "do not interfere with the currently active Span if not requested when starting a Span" in {
+      val previouslyActiveSpan = tracer.activeSpan()
+      tracer.buildSpan("myOperation").start()
+      tracer.activeSpan() should be theSameInstanceAs(previouslyActiveSpan)
+    }
+
+    "make a span active with started with the .startActive() function and restore the previous Span when deactivated" in {
+      val previouslyActiveSpan = tracer.activeSpan()
+      val activeSpan = tracer.buildSpan("myOperation").startActive()
+
+      tracer.activeSpan() shouldNot be theSameInstanceAs(previouslyActiveSpan)
+      val activeSpanData = inspect(activeSpan)
+      activeSpanData.operationName() shouldBe "myOperation"
+
+      activeSpan.deactivate()
+      tracer.activeSpan() should be theSameInstanceAs(previouslyActiveSpan)
+    }
+
+    "not have any parent Span if there is ActiveSpan and no parent was explicitly given" in {
+      val span = tracer.buildSpan("myOperation").start()
+      val spanData = inspect(span)
+      spanData.context().parentID shouldBe IdentityProvider.NoIdentifier
+    }
+
+    "use the currently active span as parent" in {
+      val parent = tracer.buildSpan("myOperation").startActive()
+      val child = tracer.buildSpan("childOperation").asChildOf(parent).start()
+      parent.deactivate()
+
+      val parentData = inspect(parent)
+      val childData = inspect(child)
+      parentData.context().spanID shouldBe childData.context().parentID
+    }
+
+    "ignore the currently active span as parent if explicitly requested" in {
+      val parent = tracer.buildSpan("myOperation").startActive()
+      val child = tracer.buildSpan("childOperation").ignoreActiveSpan().start()
+      parent.deactivate()
+
+      val childData = inspect(child)
+      childData.context().parentID shouldBe IdentityProvider.NoIdentifier
+    }
+
+    "allow overriding the start timestamp for a Span" in {
+      val span = tracer.buildSpan("myOperation").withStartTimestamp(100).start()
+      val spanData = inspect(span)
+      spanData.startTimestamp() shouldBe 100
     }
+
+    "inject and extract a SpanContext from a TextMap carrier" in {
+      val spanContext = createSpanContext()
+      val injected = Kamon.inject(spanContext, Format.TextMap)
+      val extractedSpanContext = Kamon.extract(Format.TextMap, injected).value
+
+      spanContext.traceID shouldBe(extractedSpanContext.traceID)
+      spanContext.spanID shouldBe(extractedSpanContext.spanID)
+      spanContext.parentID shouldBe(extractedSpanContext.parentID)
+      spanContext.baggage.getAll() shouldBe(extractedSpanContext.baggage.getAll())
+    }
+
+    "inject and extract a SpanContext from a TextMap carrier supplied by the caller" in {
+      val spanContext = createSpanContext()
+      val carrier = TextMap.Default()
+      Kamon.inject(spanContext, Format.TextMap, carrier)
+      val extractedSpanContext = Kamon.extract(Format.TextMap, carrier).value
+
+      spanContext.traceID shouldBe(extractedSpanContext.traceID)
+      spanContext.spanID shouldBe(extractedSpanContext.spanID)
+      spanContext.parentID shouldBe(extractedSpanContext.parentID)
+      spanContext.baggage.getAll() shouldBe(extractedSpanContext.baggage.getAll())
+    }
+
+    "inject and extract a SpanContext from a HttpHeaders carrier" in {
+      val spanContext = createSpanContext()
+      val injected = Kamon.inject(spanContext, Format.HttpHeaders)
+      val extractedSpanContext = Kamon.extract(Format.HttpHeaders, injected).value
+
+      spanContext.traceID shouldBe(extractedSpanContext.traceID)
+      spanContext.spanID shouldBe(extractedSpanContext.spanID)
+      spanContext.parentID shouldBe(extractedSpanContext.parentID)
+      spanContext.baggage.getAll() shouldBe(extractedSpanContext.baggage.getAll())
+    }
+
+    "inject and extract a SpanContext from a HttpHeaders using a TextMap provided by the caller" in {
+      val spanContext = createSpanContext()
+      val carrier = TextMap.Default()
+      Kamon.inject(spanContext, Format.HttpHeaders, carrier)
+      val extractedSpanContext = Kamon.extract(Format.HttpHeaders, carrier).value
+
+      spanContext.traceID shouldBe(extractedSpanContext.traceID)
+      spanContext.spanID shouldBe(extractedSpanContext.spanID)
+      spanContext.parentID shouldBe(extractedSpanContext.parentID)
+      spanContext.baggage.getAll() shouldBe(extractedSpanContext.baggage.getAll())
+    }
+
+
+    "preserve the same Span and Parent identifier when creating a Span with a remote parent if join-remote-parents-with-same-span-id is enabled" in {
+      val previousConfig = Kamon.config()
+
+      Kamon.reconfigure {
+        ConfigFactory.parseString("kamon.trace.join-remote-parents-with-same-span-id = yes")
+          .withFallback(Kamon.config())
+      }
+
+      val remoteParent = createSpanContext().copy(source = Source.Remote)
+      val childData = inspect(tracer.buildSpan("local").asChildOf(remoteParent).start())
+
+      childData.context().traceID shouldBe remoteParent.traceID
+      childData.context().parentID shouldBe remoteParent.parentID
+      childData.context().spanID shouldBe remoteParent.spanID
+
+      Kamon.reconfigure(previousConfig)
+    }
+
   }
 
   val tracer: Tracer = Kamon
 
+  def inspect(span: Span): SpanInspector =
+    SpanInspector(span)
+
 }