aboutsummaryrefslogtreecommitdiff
path: root/kamon-core/src/main/scala/kamon/trace/Tracer.scala
diff options
context:
space:
mode:
Diffstat (limited to 'kamon-core/src/main/scala/kamon/trace/Tracer.scala')
-rw-r--r--kamon-core/src/main/scala/kamon/trace/Tracer.scala105
1 files changed, 25 insertions, 80 deletions
diff --git a/kamon-core/src/main/scala/kamon/trace/Tracer.scala b/kamon-core/src/main/scala/kamon/trace/Tracer.scala
index bfdd561d..7d8830ca 100644
--- a/kamon-core/src/main/scala/kamon/trace/Tracer.scala
+++ b/kamon-core/src/main/scala/kamon/trace/Tracer.scala
@@ -15,13 +15,11 @@
package kamon.trace
-import java.nio.ByteBuffer
-
import com.typesafe.config.Config
-import kamon.ReporterRegistryImpl
+import kamon.{Kamon, ReporterRegistryImpl}
import kamon.metric.MetricLookup
import kamon.trace.Span.TagValue
-import kamon.trace.SpanContext.{SamplingDecision, Source}
+import kamon.trace.SpanContext.SamplingDecision
import kamon.trace.Tracer.SpanBuilder
import kamon.util.{Clock, DynamicAccess}
import org.slf4j.LoggerFactory
@@ -29,55 +27,28 @@ import org.slf4j.LoggerFactory
import scala.collection.immutable
import scala.util.Try
-trait Tracer extends ActiveSpanStorage {
+trait Tracer {
def buildSpan(operationName: String): SpanBuilder
-
- def extract[C](format: SpanContextCodec.Format[C], carrier: C): Option[SpanContext]
- def inject[C](spanContext: SpanContext, format: SpanContextCodec.Format[C], carrier: C): C
- def inject[C](spanContext: SpanContext, format: SpanContextCodec.Format[C]): C
+ def identityProvider: IdentityProvider
}
object Tracer {
final class Default(metrics: MetricLookup, reporterRegistry: ReporterRegistryImpl, initialConfig: Config) extends Tracer {
private val logger = LoggerFactory.getLogger(classOf[Tracer])
- private val activeSpanSource = ActiveSpanStorage.ThreadLocal()
private[Tracer] val tracerMetrics = new TracerMetrics(metrics)
@volatile private[Tracer] var joinRemoteParentsWithSameSpanID: Boolean = true
@volatile private[Tracer] var configuredSampler: Sampler = Sampler.Never
- @volatile private[Tracer] var identityProvider: IdentityProvider = IdentityProvider.Default()
- @volatile private[Tracer] var textMapSpanContextCodec: SpanContextCodec[TextMap] = SpanContextCodec.ExtendedB3(identityProvider)
- @volatile private[Tracer] var httpHeaderSpanContextCodec: SpanContextCodec[TextMap] = SpanContextCodec.ExtendedB3(identityProvider)
+ @volatile private[Tracer] var _identityProvider: IdentityProvider = IdentityProvider.Default()
reconfigure(initialConfig)
override def buildSpan(operationName: String): SpanBuilder =
new SpanBuilder(operationName, this, reporterRegistry)
- override def extract[C](format: SpanContextCodec.Format[C], carrier: C): Option[SpanContext] = format match {
- case SpanContextCodec.Format.HttpHeaders => httpHeaderSpanContextCodec.extract(carrier.asInstanceOf[TextMap])
- case SpanContextCodec.Format.TextMap => textMapSpanContextCodec.extract(carrier.asInstanceOf[TextMap])
- case SpanContextCodec.Format.Binary => None
- }
-
- override def inject[C](spanContext: SpanContext, format: SpanContextCodec.Format[C], carrier: C): C = format match {
- case SpanContextCodec.Format.HttpHeaders => httpHeaderSpanContextCodec.inject(spanContext, carrier.asInstanceOf[TextMap])
- case SpanContextCodec.Format.TextMap => textMapSpanContextCodec.inject(spanContext, carrier.asInstanceOf[TextMap])
- case SpanContextCodec.Format.Binary => carrier
- }
-
- override def inject[C](spanContext: SpanContext, format: SpanContextCodec.Format[C]): C = format match {
- case SpanContextCodec.Format.HttpHeaders => httpHeaderSpanContextCodec.inject(spanContext)
- case SpanContextCodec.Format.TextMap => textMapSpanContextCodec.inject(spanContext)
- case SpanContextCodec.Format.Binary => ByteBuffer.allocate(0) // TODO: Implement binary encoding.
- }
-
- override def activeSpan(): Span =
- activeSpanSource.activeSpan()
-
- override def activate(span: Span): Scope =
- activeSpanSource.activate(span)
+ override def identityProvider: IdentityProvider =
+ this._identityProvider
def sampler: Sampler =
configuredSampler
@@ -100,25 +71,9 @@ object Tracer {
traceConfig.getString("identity-provider"), immutable.Seq.empty[(Class[_], AnyRef)]
).get
- val spanContextCodecs = traceConfig.getConfig("span-context-codec")
- val newTextMapSpanContextCodec = dynamic.createInstanceFor[SpanContextCodec[TextMap]](
- spanContextCodecs.getString("text-map"), immutable.Seq((classOf[IdentityProvider], newIdentityProvider))
- ).get
-
- val newHttpHeadersSpanContextCodec = dynamic.createInstanceFor[SpanContextCodec[TextMap]](
- spanContextCodecs.getString("http-headers"), immutable.Seq((classOf[IdentityProvider], newIdentityProvider))
- ).get
-
-// val newBinarySpanContextCodec = dynamic.createInstanceFor[SpanContextCodec[TextMap]](
-// spanContextCodecs.getString("binary"), immutable.Seq((classOf[IdentityProvider], newIdentityProvider))
-// ).get // TODO: Make it happen!
-
-
configuredSampler = newSampler
joinRemoteParentsWithSameSpanID = newJoinRemoteParentsWithSameSpanID
- identityProvider = newIdentityProvider
- textMapSpanContextCodec = newTextMapSpanContextCodec
- httpHeaderSpanContextCodec = newHttpHeadersSpanContextCodec
+ _identityProvider = newIdentityProvider
}.failed.foreach {
ex => logger.error("Unable to reconfigure Kamon Tracer", ex)
@@ -132,25 +87,17 @@ object Tracer {
}
final class SpanBuilder(operationName: String, tracer: Tracer.Default, reporterRegistry: ReporterRegistryImpl) {
- private var parentContext: SpanContext = _
+ private var parentSpan: Span = _
private var startTimestamp = 0L
private var initialSpanTags = Map.empty[String, Span.TagValue]
private var initialMetricTags = Map.empty[String, String]
private var useActiveSpanAsParent = true
- def asChildOf(parentContext: SpanContext): SpanBuilder = {
- this.parentContext = parentContext
+ def asChildOf(parent: Span): SpanBuilder = {
+ if(parent != Span.Empty) this.parentSpan = parent
this
}
- def asChildOf(parentContext: Option[SpanContext]): SpanBuilder = {
- parentContext.foreach(asChildOf)
- this
- }
-
- def asChildOf(parentSpan: Span): SpanBuilder =
- asChildOf(parentSpan.context())
-
def withMetricTag(key: String, value: String): SpanBuilder = {
this.initialMetricTags = this.initialMetricTags + (key -> value)
this
@@ -185,38 +132,36 @@ object Tracer {
def start(): Span = {
val startTimestampMicros = if(startTimestamp != 0L) startTimestamp else Clock.microTimestamp()
- val parentSpanContext: Option[SpanContext] = Option(parentContext)
- .orElse(if(useActiveSpanAsParent) Some(tracer.activeSpan().context()) else None)
- .filter(spanContext => spanContext != SpanContext.EmptySpanContext)
+ val parentSpan: Option[Span] = Option(this.parentSpan)
+ .orElse(if(useActiveSpanAsParent) Some(Kamon.currentContext().get(Span.ContextKey)) else None)
+ .filter(span => span != Span.Empty)
- val samplingDecision: SamplingDecision = parentSpanContext
- .map(_.samplingDecision)
+ val samplingDecision: SamplingDecision = parentSpan
+ .map(_.context.samplingDecision)
.filter(_ != SamplingDecision.Unknown)
.getOrElse(tracer.sampler.decide(operationName, initialSpanTags))
- val spanContext = parentSpanContext match {
+ val spanContext = parentSpan match {
case Some(parent) => joinParentContext(parent, samplingDecision)
case None => newSpanContext(samplingDecision)
}
tracer.tracerMetrics.createdSpans.increment()
- Span.Real(spanContext, operationName, initialSpanTags, initialMetricTags, startTimestampMicros, reporterRegistry, tracer)
+ Span.Local(spanContext, operationName, initialSpanTags, initialMetricTags, startTimestampMicros, reporterRegistry)
}
- private def joinParentContext(parent: SpanContext, samplingDecision: SamplingDecision): SpanContext =
- if(parent.source == Source.Remote && tracer.joinRemoteParentsWithSameSpanID)
- parent.copy(samplingDecision = samplingDecision)
+ private def joinParentContext(parent: Span, samplingDecision: SamplingDecision): SpanContext =
+ if(parent.isRemote() && tracer.joinRemoteParentsWithSameSpanID)
+ parent.context().copy(samplingDecision = samplingDecision)
else
- parent.createChild(tracer.identityProvider.spanIdentifierGenerator().generate(), samplingDecision)
+ parent.context().createChild(tracer._identityProvider.spanIdGenerator().generate(), samplingDecision)
private def newSpanContext(samplingDecision: SamplingDecision): SpanContext =
SpanContext(
- traceID = tracer.identityProvider.traceIdentifierGenerator().generate(),
- spanID = tracer.identityProvider.spanIdentifierGenerator().generate(),
+ traceID = tracer._identityProvider.traceIdGenerator().generate(),
+ spanID = tracer._identityProvider.spanIdGenerator().generate(),
parentID = IdentityProvider.NoIdentifier,
- samplingDecision = samplingDecision,
- baggage = SpanContext.Baggage(),
- source = Source.Local
+ samplingDecision = samplingDecision
)
}
generated by cgit v1.2.3 (git 2.39.1) at 2024-05-31 19:33:43 +0000