diff options
Diffstat (limited to 'kamon-core/src/test/scala')
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) + } |