Add Support for W3C traceparent/tracestate propagation (#255)

* Implemented W3C traceparent propagation

Signed-off-by: Tobias Stadler <[email protected]>

* W3C should be lowercase as mentioned in https://www.jaegertracing.io/docs/1.21/client-features/,

Signed-off-by: Tobias Stadler <[email protected]>

* Added support for setting the propagation format via environment variables

Signed-off-by: Tobias Stadler <[email protected]>

* Fix assignment

Signed-off-by: Tobias Stadler <[email protected]>

* Implemented Support for W3C tracestate

Signed-off-by: Tobias Stadler <[email protected]>

* Extracted Jager porpagation and W3C propgation in their own classes

Signed-off-by: Tobias Stadler <[email protected]>

* Fix build

Signed-off-by: Tobias Stadler <[email protected]>

* Fix copyright

Signed-off-by: Tobias Stadler <[email protected]>

* Use shared_ptr instead of raw pointer

Signed-off-by: Tobias Stadler <[email protected]>

* Log unknown propagation formats and fall back to jaeger format

Signed-off-by: Tobias Stadler <[email protected]>

* Extracted propagation format parsing

Signed-off-by: Tobias Stadler <[email protected]>

* Use SpanContext with known IDs to simplify test

Signed-off-by: Tobias Stadler <[email protected]>

Author: tobiasstadler

CMakeLists.txt

@@ -171,6 +171,8 @@ set(SRC
     src/jaegertracing/propagation/HeadersConfig.cpp
     src/jaegertracing/propagation/Injector.cpp
     src/jaegertracing/propagation/Propagator.cpp
+    src/jaegertracing/propagation/JaegerPropagator.cpp
+    src/jaegertracing/propagation/W3CPropagator.cpp
     src/jaegertracing/reporters/CompositeReporter.cpp
     src/jaegertracing/reporters/Config.cpp
     src/jaegertracing/reporters/InMemoryReporter.cpp
@@ -332,6 +334,7 @@ if(BUILD_TESTING)
       src/jaegertracing/net/http/MethodTest.cpp
       src/jaegertracing/net/http/ResponseTest.cpp
       src/jaegertracing/propagation/PropagatorTest.cpp
+      src/jaegertracing/propagation/W3CPropagatorTest.cpp
       src/jaegertracing/reporters/ConfigTest.cpp
       src/jaegertracing/reporters/ReporterTest.cpp
       src/jaegertracing/samplers/SamplerTest.cpp

README.md

@@ -104,6 +104,7 @@ JAEGER_DISABLED _(not recommended)_ | Instructs the Configuration to return a no
 JAEGER_AGENT_HOST | The hostname for communicating with agent via UDP
 JAEGER_AGENT_PORT | The port for communicating with agent via UDP
 JAEGER_ENDPOINT | The traces endpoint, in case the client should connect directly to the Collector, like http://jaeger-collector:14268/api/traces
+JAEGER_PROPAGATION | The propagation format used by the tracer. Supported values are jaeger and w3c
 JAEGER_REPORTER_LOG_SPANS | Whether the reporter should also log the spans
 JAEGER_REPORTER_MAX_QUEUE_SIZE | The reporter's maximum queue size
 JAEGER_REPORTER_FLUSH_INTERVAL | The reporter's flush interval (ms)

src/jaegertracing/Config.cpp

@@ -32,12 +32,18 @@ void Config::fromEnv()
         _disabled = disabled.second;
     }
 
-    const auto traceId128Bit =
-        utils::EnvVariable::getBoolVariable(kJAEGER_JAEGER_TRACEID_128BIT_ENV_PROP);
+    const auto traceId128Bit = utils::EnvVariable::getBoolVariable(
+        kJAEGER_JAEGER_TRACEID_128BIT_ENV_PROP);
     if (traceId128Bit.first) {
         _traceId128Bit = traceId128Bit.second;
     }
 
+    const auto propagationFormat =
+        utils::EnvVariable::getStringVariable(kJAEGER_PROPAGATION_ENV_PROP);
+    if (!propagationFormat.empty()) {
+        _propagationFormat = parsePropagationFormat(propagationFormat);
+    }
+
     const auto serviceName =
         utils::EnvVariable::getStringVariable(kJAEGER_SERVICE_NAME_ENV_PROP);
     if (!serviceName.empty()) {
@@ -70,4 +76,20 @@ void Config::fromEnv()
     _sampler.fromEnv();
 }
 
+propagation::Format
+Config::parsePropagationFormat(std::string strPropagationFormat)
+{
+    auto propagationFormat = propagation::Format::JAEGER;
+    if (strPropagationFormat == "w3c") {
+        propagationFormat = propagation::Format::W3C;
+    }
+    else if (strPropagationFormat != "jaeger") {
+        std::cerr << "ERROR: unknown propagation format '"
+                  << strPropagationFormat
+                  << "', falling back to jaeger propagation format";
+    }
+
+    return propagationFormat;
+}
+
 }  // namespace jaegertracing

src/jaegertracing/Config.h

@@ -22,6 +22,7 @@
 #include "jaegertracing/Tag.h"
 #include "jaegertracing/baggage/RestrictionsConfig.h"
 #include "jaegertracing/propagation/HeadersConfig.h"
+#include "jaegertracing/propagation/Format.h"
 #include "jaegertracing/reporters/Config.h"
 #include "jaegertracing/samplers/Config.h"
 #include "jaegertracing/utils/YAML.h"
@@ -35,6 +36,7 @@ class Config {
     static constexpr auto kJAEGER_TAGS_ENV_PROP = "JAEGER_TAGS";
     static constexpr auto kJAEGER_JAEGER_DISABLED_ENV_PROP = "JAEGER_DISABLED";
     static constexpr auto kJAEGER_JAEGER_TRACEID_128BIT_ENV_PROP = "JAEGER_TRACEID_128BIT";
+    static constexpr auto kJAEGER_PROPAGATION_ENV_PROP = "JAEGER_PROPAGATION";
 
 #ifdef JAEGERTRACING_WITH_YAML_CPP
 
@@ -49,8 +51,14 @@ class Config {
 
         const auto disabled =
             utils::yaml::findOrDefault<bool>(configYAML, "disabled", false);
+
         const auto traceId128Bit =
             utils::yaml::findOrDefault<bool>(configYAML, "traceid_128bit", false);
+
+        const auto propagationFormat =
+            parsePropagationFormat(utils::yaml::findOrDefault<std::string>(
+                configYAML, "propagation_format", "jaeger"));
+
         const auto samplerNode = configYAML["sampler"];
         const auto sampler = samplers::Config::parse(samplerNode);
         const auto reporterNode = configYAML["reporter"];
@@ -60,8 +68,15 @@ class Config {
         const auto baggageRestrictionsNode = configYAML["baggage_restrictions"];
         const auto baggageRestrictions =
             baggage::RestrictionsConfig::parse(baggageRestrictionsNode);
-        return Config(
-            disabled, traceId128Bit, sampler, reporter, headers, baggageRestrictions, serviceName);
+        return Config(disabled,
+                      traceId128Bit,
+                      sampler,
+                      reporter,
+                      headers,
+                      baggageRestrictions,
+                      serviceName,
+                      std::vector<Tag>(),
+                      propagationFormat);
     }
 
 #endif  // JAEGERTRACING_WITH_YAML_CPP
@@ -75,9 +90,12 @@ class Config {
                     const baggage::RestrictionsConfig& baggageRestrictions =
                         baggage::RestrictionsConfig(),
                     const std::string& serviceName = "",
-                    const std::vector<Tag>&  tags = std::vector<Tag>())
+                    const std::vector<Tag>&  tags = std::vector<Tag>(),
+                    const propagation::Format propagationFormat =
+                        propagation::Format::JAEGER)
         : _disabled(disabled)
         , _traceId128Bit(traceId128Bit)
+        , _propagationFormat(propagationFormat)
         , _serviceName(serviceName)
         , _tags(tags)
         , _sampler(sampler)
@@ -91,6 +109,8 @@ class Config {
 
     bool traceId128Bit() const { return _traceId128Bit; }
 
+    propagation::Format propagationFormat() const { return _propagationFormat; }
+
     const samplers::Config& sampler() const { return _sampler; }
 
     const reporters::Config& reporter() const { return _reporter; }
@@ -109,8 +129,12 @@ class Config {
     void fromEnv();
 
   private:
+    static propagation::Format
+    parsePropagationFormat(std::string strPropagationFormat);
+
     bool _disabled;
     bool _traceId128Bit;
+    propagation::Format _propagationFormat;
     std::string _serviceName;
     std::vector< Tag > _tags;
     samplers::Config _sampler;

src/jaegertracing/ConfigTest.cpp

@@ -96,6 +96,17 @@ TEST(Config, testZeroSamplingParam)
     }
 }
 
+TEST(Config, testPropagationFormat)
+{
+    {
+        constexpr auto kConfigYAML = R"cfg(
+propagation_format: w3c
+)cfg";
+        const auto config = Config::parse(YAML::Load(kConfigYAML));
+        ASSERT_EQ(propagation::Format::W3C, config.propagationFormat());
+    }
+}
+
 #endif  // JAEGERTRACING_WITH_YAML_CPP
 
 TEST(Config, testFromEnv)
@@ -186,6 +197,11 @@ TEST(Config, testFromEnv)
     ASSERT_EQ(std::string("host33:445"),
               config.reporter().localAgentHostPort());
 
+    testutils::EnvVariable::setEnv("JAEGER_PROPAGATION", "w3c");
+
+    config.fromEnv();
+    ASSERT_EQ(propagation::Format::W3C, config.propagationFormat());
+
     testutils::EnvVariable::setEnv("JAEGER_AGENT_HOST", "");
     testutils::EnvVariable::setEnv("JAEGER_AGENT_PORT", "");
     testutils::EnvVariable::setEnv("JAEGER_ENDPOINT", "");
@@ -198,6 +214,7 @@ TEST(Config, testFromEnv)
     testutils::EnvVariable::setEnv("JAEGER_TAGS", "");
     testutils::EnvVariable::setEnv("JAEGER_DISABLED", "");
     testutils::EnvVariable::setEnv("JAEGER_TRACE_ID_128BIT", "");
+    testutils::EnvVariable::setEnv("JAEGER_PROPAGATION", "");
 }
 
 }  // namespace jaegertracing

src/jaegertracing/Constants.h.in

@@ -32,6 +32,8 @@ static constexpr auto kSamplerParamTagKey = "sampler.param";
 static constexpr auto kTraceContextHeaderName = "uber-trace-id";
 static constexpr auto kTracerStateHeaderName = kTraceContextHeaderName;
 static constexpr auto kTraceBaggageHeaderPrefix = "uberctx-";
+static constexpr auto kW3CTraceParentHeaderName = "traceparent";
+static constexpr auto kW3CTraceStateHeaderName = "tracestate";
 static constexpr auto kSamplerTypeConst = "const";
 static constexpr auto kSamplerTypeRemote = "remote";
 static constexpr auto kSamplerTypeProbabilistic = "probabilistic";

src/jaegertracing/SpanContext.h

@@ -54,13 +54,15 @@ class SpanContext : public opentracing::SpanContext {
                 uint64_t parentID,
                 unsigned char flags,
                 const StrMap& baggage,
-                const std::string& debugID = "")
+                const std::string& debugID = "",
+                const std::string& traceState = "")
         : _traceID(traceID)
         , _spanID(spanID)
         , _parentID(parentID)
         , _flags(flags)
         , _baggage(baggage)
         , _debugID(debugID)
+        , _traceState(traceState)
         , _mutex()
     {
     }
@@ -72,6 +74,7 @@ class SpanContext : public opentracing::SpanContext {
         , _flags(ctx._flags)
         , _baggage(ctx._baggage)
         , _debugID(ctx._debugID)
+        , _traceState(ctx._traceState)
     {
     }
 
@@ -90,6 +93,7 @@ class SpanContext : public opentracing::SpanContext {
         swap(_flags, ctx._flags);
         swap(_baggage, ctx._baggage);
         swap(_debugID, ctx._debugID);
+        swap(_traceState, ctx._traceState);
     }
 
     friend void swap(SpanContext& lhs, SpanContext& rhs) { lhs.swap(rhs); }
@@ -105,8 +109,13 @@ class SpanContext : public opentracing::SpanContext {
     SpanContext withBaggage(const StrMap& baggage) const
     {
         std::lock_guard<std::mutex> lock(_mutex);
-        return SpanContext(
-            _traceID, _spanID, _parentID, _flags, baggage, _debugID);
+        return SpanContext(_traceID,
+                           _spanID,
+                           _parentID,
+                           _flags,
+                           baggage,
+                           _debugID,
+                           _traceState);
     }
 
     template <typename Function>
@@ -140,6 +149,8 @@ class SpanContext : public opentracing::SpanContext {
         return _flags & static_cast<unsigned char>(Flag::kSampled);
     }
 
+    const std::string& traceState() const { return _traceState; }
+
     bool isDebug() const
     {
         return _flags & static_cast<unsigned char>(Flag::kDebug);
@@ -187,7 +198,8 @@ class SpanContext : public opentracing::SpanContext {
         }
         return lhs._traceID == rhs._traceID && lhs._spanID == rhs._spanID &&
                lhs._parentID == rhs._parentID && lhs._flags == rhs._flags &&
-               lhs._debugID == rhs._debugID;
+               lhs._debugID == rhs._debugID &&
+               lhs._traceState == rhs._traceState;
     }
 
     friend bool operator!=(const SpanContext& lhs, const SpanContext& rhs)
@@ -202,6 +214,7 @@ class SpanContext : public opentracing::SpanContext {
     unsigned char _flags;
     StrMap _baggage;
     std::string _debugID;
+    std::string _traceState;
     mutable std::mutex _mutex;  // Protects _baggage.
 };
 

src/jaegertracing/Tracer.cpp

@@ -18,6 +18,8 @@
 #include "jaegertracing/Tracer.h"
 #include "jaegertracing/Reference.h"
 #include "jaegertracing/TraceID.h"
+#include "jaegertracing/propagation/JaegerPropagator.h"
+#include "jaegertracing/propagation/W3CPropagator.h"
 #include "jaegertracing/samplers/SamplingStatus.h"
 #include <algorithm>
 #include <cassert>
@@ -258,6 +260,25 @@ Tracer::make(const std::string& serviceName,
     }
 
     auto metrics = std::make_shared<metrics::Metrics>(statsFactory);
+
+    std::shared_ptr<TextMapPropagator> textPropagator;
+    std::shared_ptr<HTTPHeaderPropagator> httpHeaderPropagator;
+    if (config.propagationFormat() == propagation::Format::W3C) {
+        textPropagator = std::shared_ptr<TextMapPropagator>(
+            new propagation::W3CTextMapPropagator(config.headers(), metrics));
+        httpHeaderPropagator = std::shared_ptr<HTTPHeaderPropagator>(
+            new propagation::W3CHTTPHeaderPropagator(config.headers(),
+                                                     metrics));
+    }
+    else {
+        textPropagator = std::shared_ptr<TextMapPropagator>(
+            new propagation::JaegerTextMapPropagator(config.headers(),
+                                                     metrics));
+        httpHeaderPropagator = std::shared_ptr<HTTPHeaderPropagator>(
+            new propagation::JaegerHTTPHeaderPropagator(config.headers(),
+                                                        metrics));
+    }
+
     std::shared_ptr<samplers::Sampler> sampler(
         config.sampler().makeSampler(serviceName, *logger, *metrics));
     std::shared_ptr<reporters::Reporter> reporter(
@@ -267,7 +288,8 @@ Tracer::make(const std::string& serviceName,
                                               reporter,
                                               logger,
                                               metrics,
-                                              config.headers(),
+                                              textPropagator,
+                                              httpHeaderPropagator,
                                               config.tags(),
                                               options));
 }

src/jaegertracing/Tracer.h

@@ -119,7 +119,7 @@ class Tracer : public opentracing::Tracer,
             return opentracing::make_expected_from_error<void>(
                 opentracing::invalid_span_context_error);
         }
-        _textPropagator.inject(*jaegerCtx, writer);
+        _textPropagator->inject(*jaegerCtx, writer);
         return opentracing::make_expected();
     }
 
@@ -132,7 +132,7 @@ class Tracer : public opentracing::Tracer,
             return opentracing::make_expected_from_error<void>(
                 opentracing::invalid_span_context_error);
         }
-        _httpHeaderPropagator.inject(*jaegerCtx, writer);
+        _httpHeaderPropagator->inject(*jaegerCtx, writer);
         return opentracing::make_expected();
     }
 
@@ -150,7 +150,7 @@ class Tracer : public opentracing::Tracer,
     opentracing::expected<std::unique_ptr<opentracing::SpanContext>>
     Extract(const opentracing::TextMapReader& reader) const override
     {
-        const auto spanContext = _textPropagator.extract(reader);
+        const auto spanContext = _textPropagator->extract(reader);
         if (spanContext == SpanContext()) {
             return std::unique_ptr<opentracing::SpanContext>();
         }
@@ -161,7 +161,7 @@ class Tracer : public opentracing::Tracer,
     opentracing::expected<std::unique_ptr<opentracing::SpanContext>>
     Extract(const opentracing::HTTPHeadersReader& reader) const override
     {
-        const auto spanContext = _httpHeaderPropagator.extract(reader);
+        const auto spanContext = _httpHeaderPropagator->extract(reader);
         if (spanContext == SpanContext()) {
             return std::unique_ptr<opentracing::SpanContext>();
         }
@@ -201,12 +201,20 @@ class Tracer : public opentracing::Tracer,
     }
 
   private:
+    using TextMapPropagator =
+        propagation::Propagator<const opentracing::TextMapReader&,
+                                const opentracing::TextMapWriter&>;
+    using HTTPHeaderPropagator =
+        propagation::Propagator<const opentracing::HTTPHeadersReader&,
+                                const opentracing::HTTPHeadersWriter&>;
+
     Tracer(const std::string& serviceName,
            const std::shared_ptr<samplers::Sampler>& sampler,
            const std::shared_ptr<reporters::Reporter>& reporter,
            const std::shared_ptr<logging::Logger>& logger,
            const std::shared_ptr<metrics::Metrics>& metrics,
-           const propagation::HeadersConfig& headersConfig,
+           const std::shared_ptr<TextMapPropagator> &textPropagator,
+           const std::shared_ptr<HTTPHeaderPropagator> &httpHeaderPropagator,
            const std::vector<Tag>& tags,
            int options)
         : _serviceName(serviceName)
@@ -216,8 +224,8 @@ class Tracer : public opentracing::Tracer,
         , _metrics(metrics)
         , _logger(logger)
         , _randomNumberGenerator()
-        , _textPropagator(headersConfig, _metrics)
-        , _httpHeaderPropagator(headersConfig, _metrics)
+        , _textPropagator(textPropagator)
+        , _httpHeaderPropagator(httpHeaderPropagator)
         , _binaryPropagator(_metrics)
         , _tags()
         , _restrictionManager(new baggage::DefaultRestrictionManager(0))
@@ -294,8 +302,8 @@ class Tracer : public opentracing::Tracer,
     std::shared_ptr<logging::Logger> _logger;
     mutable std::mt19937_64 _randomNumberGenerator;
     mutable std::mutex _randomMutex;
-    propagation::TextMapPropagator _textPropagator;
-    propagation::HTTPHeaderPropagator _httpHeaderPropagator;
+    std::shared_ptr<TextMapPropagator> _textPropagator;
+    std::shared_ptr<HTTPHeaderPropagator> _httpHeaderPropagator;
     propagation::BinaryPropagator _binaryPropagator;
     std::vector<Tag> _tags;
     std::unique_ptr<baggage::RestrictionManager> _restrictionManager;