Add support for Trace context

CMakeLists.txt

@@ -217,6 +217,8 @@ set(LIGHTSTEP_SRCS src/common/utility.cpp
                    src/tracer/propagation/baggage_propagator.cpp
                    src/tracer/propagation/binary_propagation.cpp
                    src/tracer/propagation/envoy_propagator.cpp
+                   src/tracer/propagation/trace_context.cpp
+                   src/tracer/propagation/trace_context_propagator.cpp
                    src/tracer/propagation/lightstep_propagator.cpp
                    src/tracer/propagation/multiheader_propagator.cpp
                    src/tracer/propagation/propagation.cpp
@@ -231,6 +233,7 @@ set(LIGHTSTEP_SRCS src/common/utility.cpp
                    src/tracer/tracer_impl.cpp
                    src/tracer/tracer.cpp
                    src/tracer/tag.cpp
+                   src/tracer/utility.cpp
                    )
 
 if (WIN32)

include/lightstep/tracer.h

@@ -22,7 +22,12 @@ const std::string& CollectorMethodName();
 enum class LogLevel { debug = 1, info = 2, warn = 3, error = 4, off = 6 };
 
 // Denotes different span context propagation formats.
-enum class PropagationMode { lightstep = 1, b3 = 2, envoy = 3 };
+enum class PropagationMode {
+  lightstep = 1,
+  b3 = 2,
+  envoy = 3,
+  trace_context = 4
+};
 
 // DynamicConfigurationValue is used for configuration values that can
 // be either fixed or changed at runtime. To specify a fixed value, just assign

lightstep-tracer-configuration/tracer_configuration.schema.json

@@ -79,7 +79,7 @@
       "items": {
         "type": "string"
       },
-      "description": "A list of propagation modes to use for injection/extraction.\nValid values are \"lightstep\", \"b3\", and \"envoy\"."
+      "description": "A list of propagation modes to use for injection/extraction.\nValid values are \"lightstep\", \"b3\", \"envoy\", and \"trace_context\"."
     }
   },
   "definitions": {

src/common/hex_conversion.cpp

@@ -1,37 +1,46 @@
 #include "common/hex_conversion.h"
 
+#include <cassert>
+
 namespace lightstep {
+//--------------------------------------------------------------------------------------------------
+// Nil
+//--------------------------------------------------------------------------------------------------
+static const unsigned char Nil = std::numeric_limits<unsigned char>::max();
+
+//--------------------------------------------------------------------------------------------------
+// HexTable
+//--------------------------------------------------------------------------------------------------
+static const std::array<unsigned char, 256> HexTable = {
+    {Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil,
+     Nil, Nil, Nil, 0,   1,   2,   3,   4,   5,   6,   7,   8,   9,   Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, 10,  11,  12,  13,  14,  15,  Nil, Nil, Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, Nil, Nil, 10,  11,  12,  13,  14,  15,  Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil,
+     Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil,
+     Nil}};
 
 //--------------------------------------------------------------------------------------------------
-// HexToUint64Impl
-//--------------------------------------------------------------------------------------------------
-static opentracing::expected<uint64_t> HexToUint64Impl(
-    const char* i, const char* last) noexcept {
-  static const unsigned char nil = std::numeric_limits<unsigned char>::max();
-  static const std::array<unsigned char, 256> hextable = {
-      {nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil, nil, nil, 0,   1,   2,   3,   4,   5,   6,   7,
-       8,   9,   nil, nil, nil, nil, nil, nil, nil, 10,  11,  12,  13,  14,
-       15,  nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, 10,
-       11,  12,  13,  14,  15,  nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil, nil,
-       nil, nil, nil, nil}};
-  uint64_t result = 0;
+// HexToUintImpl
+//--------------------------------------------------------------------------------------------------
+template <class T>
+static opentracing::expected<T> HexToUintImpl(const char* i,
+                                              const char* last) noexcept {
+  T result = 0;
   for (; i != last; ++i) {
-    auto value = hextable[*i];
-    if (value == nil) {
+    auto value = HexTable[*i];
+    if (value == Nil) {
       return opentracing::make_unexpected(
           std::make_error_code(std::errc::invalid_argument));
     }
@@ -114,7 +123,7 @@ opentracing::expected<uint64_t> HexToUint64(
         std::make_error_code(std::errc::invalid_argument));
   }
 
-  return HexToUint64Impl(i, last);
+  return HexToUintImpl<uint64_t>(i, last);
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -158,7 +167,7 @@ opentracing::expected<void> HexToUint128(opentracing::string_view s,
   // handle the case when we have a number that fits in a 64-bit integer
   if (length <= Num64BitHexDigits) {
     x_high = 0;
-    auto x_maybe = HexToUint64Impl(i, last);
+    auto x_maybe = HexToUintImpl<uint64_t>(i, last);
     if (!x_maybe) {
       return opentracing::make_unexpected(x_maybe.error());
     }
@@ -169,17 +178,57 @@ opentracing::expected<void> HexToUint128(opentracing::string_view s,
   // handle the case when we have a number that requires more than a single
   // 64-bit integer
   auto boundary = i + (length - Num64BitHexDigits);
-  auto x_high_maybe = HexToUint64Impl(i, boundary);
+  auto x_high_maybe = HexToUintImpl<uint64_t>(i, boundary);
   if (!x_high_maybe) {
     return opentracing::make_unexpected(x_high_maybe.error());
   }
   x_high = *x_high_maybe;
 
-  auto x_low_maybe = HexToUint64Impl(boundary, last);
+  auto x_low_maybe = HexToUintImpl<uint64_t>(boundary, last);
   if (!x_low_maybe) {
     return opentracing::make_unexpected(x_low_maybe.error());
   }
   x_low = *x_low_maybe;
   return {};
 }
+
+//--------------------------------------------------------------------------------------------------
+// NormalizedHexToUint8
+//--------------------------------------------------------------------------------------------------
+opentracing::expected<uint8_t> NormalizedHexToUint8(
+    opentracing::string_view s) noexcept {
+  assert(s.size() == Num8BitHexDigits);
+  return HexToUintImpl<uint8_t>(s.data(), s.data() + s.size());
+}
+
+//--------------------------------------------------------------------------------------------------
+// NormalizedHexToUint64
+//--------------------------------------------------------------------------------------------------
+opentracing::expected<uint64_t> NormalizedHexToUint64(
+    opentracing::string_view s) noexcept {
+  assert(s.size() == Num64BitHexDigits);
+  return HexToUintImpl<uint64_t>(s.data(), s.data() + s.size());
+}
+
+//--------------------------------------------------------------------------------------------------
+// NormalizedHexToUint128
+//--------------------------------------------------------------------------------------------------
+opentracing::expected<void> NormalizedHexToUint128(opentracing::string_view s,
+                                                   uint64_t& x_high,
+                                                   uint64_t& x_low) noexcept {
+  assert(s.size() == 2 * Num64BitHexDigits);
+  auto x_maybe =
+      HexToUintImpl<uint64_t>(s.data(), s.data() + Num64BitHexDigits);
+  if (!x_maybe) {
+    return opentracing::make_unexpected(x_maybe.error());
+  }
+  x_high = *x_maybe;
+  x_maybe = HexToUintImpl<uint64_t>(s.data() + Num64BitHexDigits,
+                                    s.data() + 2 * Num64BitHexDigits);
+  if (!x_maybe) {
+    return opentracing::make_unexpected(x_maybe.error());
+  }
+  x_low = *x_maybe;
+  return {};
+}
 }  // namespace lightstep

src/common/hex_conversion.h

@@ -10,8 +10,12 @@
 namespace lightstep {
 const size_t Num64BitHexDigits = std::numeric_limits<uint64_t>::digits / 4;
 
+const size_t Num128BitHexDigits = 2 * Num64BitHexDigits;
+
 const size_t Num32BitHexDigits = std::numeric_limits<uint32_t>::digits / 4;
 
+const size_t Num8BitHexDigits = std::numeric_limits<uint8_t>::digits / 4;
+
 extern const unsigned char HexDigitLookupTable[513];
 
 /**
@@ -46,6 +50,19 @@ inline opentracing::string_view Uint32ToHex(uint32_t x, char* output) noexcept {
   return {output, Num32BitHexDigits};
 }
 
+/**
+ * Writes a 8-bit number in hex.
+ * @param x the number to write
+ * @param output where to output the number
+ * @return x as a hex string
+ */
+inline opentracing::string_view Uint8ToHex(uint8_t x, char* output) noexcept {
+  auto lookup_index = static_cast<int>(x) * 2;
+  output[0] = HexDigitLookupTable[lookup_index];
+  output[1] = HexDigitLookupTable[lookup_index + 1];
+  return {output, Num8BitHexDigits};
+}
+
 // Converts a hexidecimal number to a 64-bit integer. Either returns the number
 // or an error code.
 opentracing::expected<uint64_t> HexToUint64(
@@ -55,6 +72,16 @@ opentracing::expected<void> HexToUint128(opentracing::string_view s,
                                          uint64_t& x_high,
                                          uint64_t& x_low) noexcept;
 
+opentracing::expected<uint8_t> NormalizedHexToUint8(
+    opentracing::string_view s) noexcept;
+
+opentracing::expected<uint64_t> NormalizedHexToUint64(
+    opentracing::string_view s) noexcept;
+
+opentracing::expected<void> NormalizedHexToUint128(opentracing::string_view s,
+                                                   uint64_t& x_high,
+                                                   uint64_t& x_low) noexcept;
+
 /**
  * Serialize integers to hex
  */

src/tracer/BUILD

@@ -36,6 +36,9 @@ lightstep_cc_library(
     private_hdrs = [
         "utility.h",
     ],
+    srcs = [
+        "utility.cpp",
+    ],
     deps = [
         "//src/recorder:recorder_interface",
     ],
@@ -77,6 +80,7 @@ lightstep_cc_library(
     ],
     deps = [
         "//src/tracer:lightstep_span_context_interface",
+        "//src/tracer/propagation:trace_context_lib",
     ],
 )
 

src/tracer/immutable_span_context.cpp

@@ -7,10 +7,8 @@ namespace lightstep {
 ImmutableSpanContext::ImmutableSpanContext(
     uint64_t trace_id_high, uint64_t trace_id_low, uint64_t span_id,
     bool sampled, const std::unordered_map<std::string, std::string>& baggage)
-    : trace_id_high_{trace_id_high},
-      trace_id_low_{trace_id_low},
-      span_id_{span_id},
-      sampled_{sampled} {
+    : ImmutableSpanContext{trace_id_high, trace_id_low, span_id, sampled,
+                           BaggageProtobufMap{}} {
   for (auto& baggage_item : baggage) {
     baggage_.insert(BaggageProtobufMap::value_type(baggage_item.first,
                                                    baggage_item.second));
@@ -28,7 +26,17 @@ ImmutableSpanContext::ImmutableSpanContext(
     : trace_id_high_{trace_id_high},
       trace_id_low_{trace_id_low},
       span_id_{span_id},
-      sampled_{sampled},
+      trace_flags_{SetTraceFlag<SampledFlagMask>(0, sampled)},
+      baggage_{std::move(baggage)} {}
+
+ImmutableSpanContext::ImmutableSpanContext(
+    const TraceContext& trace_context, std::string&& trace_state,
+    BaggageProtobufMap&& baggage) noexcept
+    : trace_id_high_{trace_context.trace_id_high},
+      trace_id_low_{trace_context.trace_id_low},
+      span_id_{trace_context.parent_id},
+      trace_flags_{trace_context.trace_flags},
+      trace_state_{std::move(trace_state)},
       baggage_{std::move(baggage)} {}
 
 //------------------------------------------------------------------------------

src/tracer/immutable_span_context.h

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "tracer/lightstep_span_context.h"
+#include "tracer/propagation/trace_context.h"
 
 namespace lightstep {
 /**
@@ -20,14 +21,22 @@ class ImmutableSpanContext final : public LightStepSpanContext {
                        uint64_t span_id, bool sampled,
                        BaggageProtobufMap&& baggage) noexcept;
 
+  ImmutableSpanContext(const TraceContext& trace_context,
+                       std::string&& trace_state,
+                       BaggageProtobufMap&& baggage) noexcept;
+
   // LightStepSpanContext
   uint64_t trace_id_high() const noexcept override { return trace_id_high_; }
 
   uint64_t trace_id_low() const noexcept override { return trace_id_low_; }
 
   uint64_t span_id() const noexcept override { return span_id_; }
 
-  bool sampled() const noexcept override { return sampled_; }
+  uint8_t trace_flags() const noexcept override { return trace_flags_; }
+
+  opentracing::string_view trace_state() const noexcept override {
+    return trace_state_;
+  }
 
   void ForeachBaggageItem(
       std::function<bool(const std::string& key, const std::string& value)> f)
@@ -55,14 +64,20 @@ class ImmutableSpanContext final : public LightStepSpanContext {
   uint64_t trace_id_high_;
   uint64_t trace_id_low_;
   uint64_t span_id_;
-  bool sampled_;
+  uint8_t trace_flags_;
+  std::string trace_state_;
   BaggageProtobufMap baggage_;
 
   template <class Carrier>
   opentracing::expected<void> InjectImpl(
       const PropagationOptions& propagation_options, Carrier& writer) const {
-    return InjectSpanContext(propagation_options, writer, trace_id_high_,
-                             trace_id_low_, span_id_, sampled_, baggage_);
+    TraceContext trace_context;
+    trace_context.trace_id_high = trace_id_high_;
+    trace_context.trace_id_low = trace_id_low_;
+    trace_context.parent_id = span_id_;
+    trace_context.trace_flags = trace_flags_;
+    return InjectSpanContext(propagation_options, writer, trace_context,
+                             trace_state_, baggage_);
   }
 };
 }  // namespace lightstep

src/tracer/json_options.cpp

@@ -44,6 +44,9 @@ static PropagationMode GetPropagationMode(opentracing::string_view s) {
   if (s == "envoy") {
     return PropagationMode::envoy;
   }
+  if (s == "trace_context") {
+    return PropagationMode::trace_context;
+  }
   std::ostringstream oss;
   oss << "invalid propagation mode " << s;
   throw std::runtime_error{oss.str()};