make the SpanContextCodecs configurable

2 files changed, 71 insertions, 9 deletions

diff --git a/kamon-core/src/main/resources/reference.conf b/kamon-core/src/main/resources/reference.conf
index cd8fa379..cc4da03e 100644
--- a/kamon-core/src/main/resources/reference.conf
+++ b/kamon-core/src/main/resources/reference.conf
@@ -107,6 +107,37 @@ kamon {
       # Probability of a span being sampled. Must be a value between 0 and 1.
       probability = 0.01
     }
+
+    # The IdentityProvider used to generate Trace and Span Identifiers in Kamon. There are two default implementations
+    # that ship with Kamon:
+    #   - kamon.trace.IdentityProvider.Default: Creates 8-byte identifiers for both Traces and Spans.
+    #   - kamon.trace.IdentityProvider.DoubleSizeTraceID: Creates 16-byte identifiers for Traces and 8-byte identifiers
+    #     for Spans.
+    #
+    # Any external implementation can be configured here, as long as it can be instantiated with a parameterless constructor.
+    identity-provider = "kamon.trace.IdentityProvider.Default"
+
+    # The SpanContextCodecs are used to encode/decode the SpanContext data into simple TextMaps, HTTP Headers or Binary
+    # carriers. The decision about which one to use is based on the kamon.trace.SpanContextCodec.Format instance passed
+    # to inject/extract calls.
+    #
+    # Any external implementation can be configured here, as long as it can be instantiated with a single parameter
+    # constructor that accepts a IdentityProvider.
+    span-context-codec {
+
+      # Encodes/Decodes the SpanContext data using a simple key/value pair. Since this is very rarely going to be used
+      # we default to using the same codec for HTTP Headers, as it is built on top of a TextMap.
+      text-map = "kamon.trace.SpanContextCodec.ExtendedB3"
+
+      # Encodes/Decodes the SpanContext into a TextMap with HTTP Header friendly, URLEncoded values. The default
+      # implementation follows the guidelines of B3 propagation. See more at https://github.com/openzipkin/b3-propagation.
+      http-headers = "kamon.trace.SpanContextCodec.ExtendedB3"
+
+      # Encodes/Decodes the SpanContext using a binary representation.
+      binary = "TODO"
+    }
+
+
   }
 
   util {
diff --git a/kamon-core/src/main/scala/kamon/trace/Tracer.scala b/kamon-core/src/main/scala/kamon/trace/Tracer.scala
index d7ca5609..f95a8cef 100644
--- a/kamon-core/src/main/scala/kamon/trace/Tracer.scala
+++ b/kamon-core/src/main/scala/kamon/trace/Tracer.scala
@@ -24,9 +24,12 @@ import kamon.metric.MetricLookup
 import kamon.trace.Span.TagValue
 import kamon.trace.SpanContext.{SamplingDecision, Source}
 import kamon.trace.Tracer.SpanBuilder
-import kamon.util.Clock
+import kamon.util.{Clock, DynamicAccess}
 import org.slf4j.LoggerFactory
 
+import scala.collection.immutable
+import scala.util.Try
+
 
 trait ActiveSpanSource {
   def activeSpan(): ActiveSpan
@@ -94,16 +97,44 @@ object Tracer {
       configuredSampler
 
     private[kamon] def reconfigure(config: Config): Unit = synchronized {
-      val traceConfig = config.getConfig("kamon.trace")
+      Try {
+        val dynamic = new DynamicAccess(classOf[Tracer].getClassLoader)
+        val traceConfig = config.getConfig("kamon.trace")
 
-      configuredSampler = traceConfig.getString("sampler") match {
-        case "always" => Sampler.Always
-        case "never"  => Sampler.Never
-        case "random" => Sampler.random(traceConfig.getDouble("random-sampler.probability"))
-        case other    => sys.error(s"Unexpected sampler name $other.")
-      }
+        val newSampler = traceConfig.getString("sampler") match {
+          case "always" => Sampler.Always
+          case "never" => Sampler.Never
+          case "random" => Sampler.random(traceConfig.getDouble("random-sampler.probability"))
+          case other => sys.error(s"Unexpected sampler name $other.")
+        }
+
+        val newJoinRemoteParentsWithSameSpanID = traceConfig.getBoolean("join-remote-parents-with-same-span-id")
+
+        val newIdentityProvider = dynamic.createInstanceFor[IdentityProvider](
+          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
 
-      joinRemoteParentsWithSameSpanID = traceConfig.getBoolean("join-remote-parents-with-same-span-id")
+        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
+
+      }
     }
   }