From 18b9fc25d556fef50c5033f8880fab2594783caa Mon Sep 17 00:00:00 2001 From: Ivan Topolnjak Date: Sun, 30 Jul 2017 11:25:11 +0200 Subject: rename ActiveSpanSource into ActiveSpanStorage --- kamon-core/src/main/scala/kamon/Kamon.scala | 2 - .../main/scala/kamon/trace/ActiveSpanSource.scala | 46 -------------- .../main/scala/kamon/trace/ActiveSpanStorage.scala | 74 ++++++++++++++++++++++ kamon-core/src/main/scala/kamon/trace/Span.scala | 6 +- kamon-core/src/main/scala/kamon/trace/Tracer.scala | 7 +- 5 files changed, 79 insertions(+), 56 deletions(-) delete mode 100644 kamon-core/src/main/scala/kamon/trace/ActiveSpanSource.scala create mode 100644 kamon-core/src/main/scala/kamon/trace/ActiveSpanStorage.scala (limited to 'kamon-core/src/main/scala/kamon') diff --git a/kamon-core/src/main/scala/kamon/Kamon.scala b/kamon-core/src/main/scala/kamon/Kamon.scala index 6de45e25..7c3beb84 100644 --- a/kamon-core/src/main/scala/kamon/Kamon.scala +++ b/kamon-core/src/main/scala/kamon/Kamon.scala @@ -108,8 +108,6 @@ object Kamon extends MetricLookup with ReporterRegistry with Tracer { override def activate(span: Span): Scope = _tracer.activate(span) - override def activate(span: Span, finishOnClose: Boolean): Scope = - _tracer.activate(span, finishOnClose) /** * Makes the provided Span active before code is evaluated and deactivates it afterwards. diff --git a/kamon-core/src/main/scala/kamon/trace/ActiveSpanSource.scala b/kamon-core/src/main/scala/kamon/trace/ActiveSpanSource.scala deleted file mode 100644 index f4a363a6..00000000 --- a/kamon-core/src/main/scala/kamon/trace/ActiveSpanSource.scala +++ /dev/null @@ -1,46 +0,0 @@ -package kamon.trace - - -trait Scope extends AutoCloseable { - def close(): Unit -} - -trait ActiveSpanSource { - def activeSpan(): Span - - def activate(span: Span): Scope - def activate(span: Span, finishOnClose: Boolean): Scope -} - -object ActiveSpanSource { - - final class ThreadLocalBased extends ActiveSpanSource { - private val emptySpan = Span.Empty(this) - private val storage: ThreadLocal[Span] = new ThreadLocal[Span] { - override def initialValue(): Span = emptySpan - } - - override def activeSpan(): Span = - storage.get() - - override def activate(span: Span): Scope = - activate(span, finishOnClose = false) - - override def activate(span: Span, finishOnClose: Boolean): Scope = { - val previouslyActiveSpan = storage.get() - storage.set(span) - - new Scope { - override def close(): Unit = { - storage.set(previouslyActiveSpan) - if (finishOnClose && span != null) - span.finish() - } - } - } - } - - object ThreadLocalBased { - def apply(): ThreadLocalBased = new ThreadLocalBased() - } -} \ No newline at end of file diff --git a/kamon-core/src/main/scala/kamon/trace/ActiveSpanStorage.scala b/kamon-core/src/main/scala/kamon/trace/ActiveSpanStorage.scala new file mode 100644 index 00000000..85e94ef2 --- /dev/null +++ b/kamon-core/src/main/scala/kamon/trace/ActiveSpanStorage.scala @@ -0,0 +1,74 @@ +package kamon.trace + +/** + * A means of storing and retrieving the currently active Span. The application code execution is always considered to + * contribute to the completion of the operation represented by the currently active Span. + * + * The activation of a Span is of temporary nature and users of this API must ensure that all Scopes created via calls + * to `activate(span)` are timely closed; failing to do so might lead to unexpected behavior. Typically, the same block + * of code designating a Span as currently active will close the created Scope after finishing execution. + * + */ +trait ActiveSpanStorage { + + /** + * @return the currently active Span. + */ + def activeSpan(): Span + + /** + * Sets + * @param span the Span to be set as currently active. + * @return a [[Scope]] that will finish the designation of the given Span as active once it's closed. + */ + def activate(span: Span): Scope + +} + +/** + * Encapsulates the state (if any) required to handle the removal of a Span from it's currently active designation. + * + * Typically a Scope will enclose the previously active Span and return the previously active Span when closed, + * although no assumptions are made. + * + */ +trait Scope extends AutoCloseable { + + /** + * Removes the currently active Span from the ActiveSpanStorage. + * + */ + def close(): Unit +} + +object ActiveSpanStorage { + + /** + * A ActiveSpanStorage that uses a [[java.lang.ThreadLocal]] as the underlying storage. + * + */ + final class ThreadLocal extends ActiveSpanStorage { + private val emptySpan = Span.Empty(this) + private val storage: java.lang.ThreadLocal[Span] = new java.lang.ThreadLocal[Span] { + override def initialValue(): Span = emptySpan + } + + override def activeSpan(): Span = + storage.get() + + override def activate(span: Span): Scope = { + val previouslyActiveSpan = storage.get() + storage.set(span) + + new Scope { + override def close(): Unit = { + storage.set(previouslyActiveSpan) + } + } + } + } + + object ThreadLocal { + def apply(): ThreadLocal = new ThreadLocal() + } +} \ No newline at end of file diff --git a/kamon-core/src/main/scala/kamon/trace/Span.scala b/kamon-core/src/main/scala/kamon/trace/Span.scala index 6b38ae48..84cc5625 100644 --- a/kamon-core/src/main/scala/kamon/trace/Span.scala +++ b/kamon-core/src/main/scala/kamon/trace/Span.scala @@ -71,7 +71,7 @@ trait Span extends BaseSpan { object Span { - final class Empty(activeSpanSource: ActiveSpanSource) extends Span { + final class Empty(activeSpanSource: ActiveSpanStorage) extends Span { override val context: SpanContext = SpanContext.EmptySpanContext override def annotate(annotation: Annotation): Span = this @@ -87,7 +87,7 @@ object Span { } object Empty { - def apply(activeSpanSource: ActiveSpanSource): Empty = new Empty(activeSpanSource) + def apply(activeSpanSource: ActiveSpanStorage): Empty = new Empty(activeSpanSource) } /** @@ -99,7 +99,7 @@ object Span { * @param spanSink */ final class Real(spanContext: SpanContext, initialOperationName: String, initialSpanTags: Map[String, Span.TagValue], - initialMetricTags: Map[String, String], startTimestampMicros: Long, spanSink: SpanSink, activeSpanSource: ActiveSpanSource) extends Span { + initialMetricTags: Map[String, String], startTimestampMicros: Long, spanSink: SpanSink, activeSpanSource: ActiveSpanStorage) extends Span { private var collectMetrics: Boolean = true private var open: Boolean = true diff --git a/kamon-core/src/main/scala/kamon/trace/Tracer.scala b/kamon-core/src/main/scala/kamon/trace/Tracer.scala index 737a8b8d..bfdd561d 100644 --- a/kamon-core/src/main/scala/kamon/trace/Tracer.scala +++ b/kamon-core/src/main/scala/kamon/trace/Tracer.scala @@ -29,7 +29,7 @@ import org.slf4j.LoggerFactory import scala.collection.immutable import scala.util.Try -trait Tracer extends ActiveSpanSource { +trait Tracer extends ActiveSpanStorage { def buildSpan(operationName: String): SpanBuilder def extract[C](format: SpanContextCodec.Format[C], carrier: C): Option[SpanContext] @@ -41,7 +41,7 @@ object Tracer { final class Default(metrics: MetricLookup, reporterRegistry: ReporterRegistryImpl, initialConfig: Config) extends Tracer { private val logger = LoggerFactory.getLogger(classOf[Tracer]) - private val activeSpanSource = ActiveSpanSource.ThreadLocalBased() + private val activeSpanSource = ActiveSpanStorage.ThreadLocal() private[Tracer] val tracerMetrics = new TracerMetrics(metrics) @volatile private[Tracer] var joinRemoteParentsWithSameSpanID: Boolean = true @@ -79,9 +79,6 @@ object Tracer { override def activate(span: Span): Scope = activeSpanSource.activate(span) - override def activate(span: Span, finishOnClose: Boolean): Scope = - activeSpanSource.activate(span, finishOnClose) - def sampler: Sampler = configuredSampler -- cgit v1.2.3