ceph/src/jaegertracing/opentelemetry-cpp/api/test/trace/propagation/jaeger_propagation_test.cc

   1 // Copyright The OpenTelemetry Authors
   2 // SPDX-License-Identifier: Apache-2.0
   3
   4 #include "opentelemetry/trace/propagation/jaeger.h"
   5 #include "opentelemetry/trace/scope.h"
   6 #include "util.h"
   7
   8 #include <map>
   9
  10 #include <gtest/gtest.h>
  11
  12 using namespace opentelemetry;
  13
  14 class TextMapCarrierTest : public context::propagation::TextMapCarrier
  15 {
  16 public:
  17   virtual nostd::string_view Get(nostd::string_view key) const noexcept override
  18   {
  19     auto it = headers_.find(std::string(key));
  20     if (it != headers_.end())
  21     {
  22       return nostd::string_view(it->second);
  23     }
  24     return "";
  25   }
  26   virtual void Set(nostd::string_view key, nostd::string_view value) noexcept override
  27   {
  28     headers_[std::string(key)] = std::string(value);
  29   }
  30
  31   std::map<std::string, std::string> headers_;
  32 };
  33
  34 using Propagator = trace::propagation::JaegerPropagator;
  35
  36 static Propagator format = Propagator();
  37
  38 TEST(JaegerPropagatorTest, ExtractValidSpans)
  39 {
  40   struct TestTrace
  41   {
  42     std::string trace_state;
  43     std::string expected_trace_id;
  44     std::string expected_span_id;
  45     bool sampled;
  46   };
  47
  48   std::vector<TestTrace> traces = {
  49       {
  50           "4bf92f3577b34da6a3ce929d0e0e4736:0102030405060708:0:00",
  51           "4bf92f3577b34da6a3ce929d0e0e4736",
  52           "0102030405060708",
  53           false,
  54       },
  55       {
  56           "4bf92f3577b34da6a3ce929d0e0e4736:0102030405060708:0:ff",
  57           "4bf92f3577b34da6a3ce929d0e0e4736",
  58           "0102030405060708",
  59           true,
  60       },
  61       {
  62           "4bf92f3577b34da6a3ce929d0e0e4736:0102030405060708:0:f",
  63           "4bf92f3577b34da6a3ce929d0e0e4736",
  64           "0102030405060708",
  65           true,
  66       },
  67       {
  68           "a3ce929d0e0e4736:0102030405060708:0:00",
  69           "0000000000000000a3ce929d0e0e4736",
  70           "0102030405060708",
  71           false,
  72       },
  73       {
  74           "A3CE929D0E0E4736:ABCDEFABCDEF1234:0:01",
  75           "0000000000000000a3ce929d0e0e4736",
  76           "abcdefabcdef1234",
  77           true,
  78       },
  79       {
  80           "ff:ABCDEFABCDEF1234:0:0",
  81           "000000000000000000000000000000ff",
  82           "abcdefabcdef1234",
  83           false,
  84       },
  85       {
  86           "4bf92f3577b34da6a3ce929d0e0e4736:0102030405060708:0102030405060708:00",
  87           "4bf92f3577b34da6a3ce929d0e0e4736",
  88           "0102030405060708",
  89           false,
  90       },
  91
  92   };
  93
  94   for (TestTrace &test_trace : traces)
  95   {
  96     TextMapCarrierTest carrier;
  97     carrier.headers_      = {{"uber-trace-id", test_trace.trace_state}};
  98     context::Context ctx1 = context::Context{};
  99     context::Context ctx2 = format.Extract(carrier, ctx1);
 100
 101     auto span = trace::GetSpan(ctx2)->GetContext();
 102     EXPECT_TRUE(span.IsValid());
 103
 104     EXPECT_EQ(Hex(span.trace_id()), test_trace.expected_trace_id);
 105     EXPECT_EQ(Hex(span.span_id()), test_trace.expected_span_id);
 106     EXPECT_EQ(span.IsSampled(), test_trace.sampled);
 107     EXPECT_EQ(span.IsRemote(), true);
 108   }
 109 }
 110
 111 TEST(JaegerPropagatorTest, ExctractInvalidSpans)
 112 {
 113   TextMapCarrierTest carrier;
 114   std::vector<std::string> traces = {
 115       "4bf92f3577b34da6a3ce929d0e0e47344:0102030405060708:0:00",  // too long trace id
 116       "4bf92f3577b34da6a3ce929d0e0e4734:01020304050607089:0:00",  // too long span id
 117       "4bf92f3577b34da6x3ce929d0y0e4734:01020304050607089:0:00",  // invalid trace id character
 118       "4bf92f3577b34da6a3ce929d0e0e4734:01020304g50607089:0:00",  // invalid span id character
 119       "4bf92f3577b34da6a3ce929d0e0e4734::0:00",
 120       "",
 121       "::::",
 122       "0:0:0:0",
 123       ":abcdef12:0:0",
 124   };
 125
 126   for (auto &trace : traces)
 127   {
 128     carrier.headers_      = {{"uber-trace-id", trace}};
 129     context::Context ctx1 = context::Context{};
 130     context::Context ctx2 = format.Extract(carrier, ctx1);
 131
 132     auto span = trace::GetSpan(ctx2)->GetContext();
 133     EXPECT_FALSE(span.IsValid());
 134   }
 135 }
 136
 137 TEST(JaegerPropagatorTest, InjectsContext)
 138 {
 139   TextMapCarrierTest carrier;
 140   constexpr uint8_t buf_span[]  = {1, 2, 3, 4, 5, 6, 7, 8};
 141   constexpr uint8_t buf_trace[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
 142   trace::SpanContext span_context{trace::TraceId{buf_trace}, trace::SpanId{buf_span},
 143                                   trace::TraceFlags{true}, false};
 144   nostd::shared_ptr<trace::Span> sp{new trace::DefaultSpan{span_context}};
 145   trace::Scope scoped_span{sp};
 146
 147   format.Inject(carrier, context::RuntimeContext::GetCurrent());
 148   EXPECT_EQ(carrier.headers_["uber-trace-id"],
 149             "0102030405060708090a0b0c0d0e0f10:0102030405060708:0:01");
 150
 151   std::vector<std::string> fields;
 152   format.Fields([&fields](nostd::string_view field) {
 153     fields.push_back(field.data());
 154     return true;
 155   });
 156   EXPECT_EQ(fields.size(), 1);
 157   EXPECT_EQ(fields[0], opentelemetry::trace::propagation::kJaegerTraceHeader);
 158 }
 159
 160 TEST(JaegerPropagatorTest, DoNotInjectInvalidContext)
 161 {
 162   TextMapCarrierTest carrier;
 163   context::Context ctx{
 164       "current-span",
 165       nostd::shared_ptr<trace::Span>(new trace::DefaultSpan(trace::SpanContext::GetInvalid()))};
 166   format.Inject(carrier, ctx);
 167   EXPECT_TRUE(carrier.headers_.count("uber-trace-id") == 0);
 168 }