From 7cf98a6043cf90a17b5d0a51cf2399e35239cc0c Mon Sep 17 00:00:00 2001 From: Ivan Topolnjak Date: Wed, 19 Jul 2017 09:35:30 +0200 Subject: tests for Span building and the ExtendedB3 codec, related bugfixes --- .../trace/ExtendedB3SpanContextCodecSpec.scala | 89 ++++++++++-- .../src/test/scala/kamon/trace/TracerSpec.scala | 154 ++++++++++++++++++++- 2 files changed, 226 insertions(+), 17 deletions(-) (limited to 'kamon-core/src/test/scala/kamon/trace') 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) + } -- cgit v1.2.3