ceph/src/jaegertracing/opentelemetry-cpp/sdk/test/trace/span_data_test.cc

   1 // Copyright The OpenTelemetry Authors
   2 // SPDX-License-Identifier: Apache-2.0
   3
   4 #include "opentelemetry/sdk/trace/span_data.h"
   5 #include "opentelemetry/nostd/variant.h"
   6 #include "opentelemetry/trace/span.h"
   7 #include "opentelemetry/trace/span_id.h"
   8 #include "opentelemetry/trace/trace_id.h"
   9
  10 #include <gtest/gtest.h>
  11
  12 using opentelemetry::sdk::trace::SpanData;
  13 namespace trace_api = opentelemetry::trace;
  14 namespace common    = opentelemetry::common;
  15 namespace nostd     = opentelemetry::nostd;
  16
  17 TEST(SpanData, DefaultValues)
  18 {
  19   trace_api::SpanContext empty_span_context{false, false};
  20   trace_api::SpanId zero_span_id;
  21   SpanData data;
  22
  23   ASSERT_EQ(data.GetTraceId(), empty_span_context.trace_id());
  24   ASSERT_EQ(data.GetSpanId(), empty_span_context.span_id());
  25   ASSERT_EQ(data.GetSpanContext(), empty_span_context);
  26   ASSERT_EQ(data.GetParentSpanId(), zero_span_id);
  27   ASSERT_EQ(data.GetName(), "");
  28   ASSERT_EQ(data.GetStatus(), trace_api::StatusCode::kUnset);
  29   ASSERT_EQ(data.GetDescription(), "");
  30   ASSERT_EQ(data.GetStartTime().time_since_epoch(), std::chrono::nanoseconds(0));
  31   ASSERT_EQ(data.GetDuration(), std::chrono::nanoseconds(0));
  32   ASSERT_EQ(data.GetAttributes().size(), 0);
  33   ASSERT_EQ(data.GetEvents().size(), 0);
  34 }
  35
  36 TEST(SpanData, Set)
  37 {
  38   constexpr uint8_t trace_id_buf[]       = {1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8};
  39   constexpr uint8_t span_id_buf[]        = {1, 2, 3, 4, 5, 6, 7, 8};
  40   constexpr uint8_t parent_span_id_buf[] = {8, 7, 6, 5, 4, 3, 2, 1};
  41   trace_api::TraceId trace_id{trace_id_buf};
  42   trace_api::SpanId span_id{span_id_buf};
  43   trace_api::SpanId parent_span_id{parent_span_id_buf};
  44   const auto trace_state = trace_api::TraceState::GetDefault()->Set("key1", "value");
  45   const trace_api::SpanContext span_context{
  46       trace_id, span_id, trace_api::TraceFlags{trace_api::TraceFlags::kIsSampled}, true,
  47       trace_state};
  48   common::SystemTimestamp now(std::chrono::system_clock::now());
  49
  50   SpanData data;
  51   data.SetIdentity(span_context, parent_span_id);
  52   data.SetName("span name");
  53   data.SetSpanKind(trace_api::SpanKind::kServer);
  54   data.SetStatus(trace_api::StatusCode::kOk, "description");
  55   data.SetStartTime(now);
  56   data.SetDuration(std::chrono::nanoseconds(1000000));
  57   data.SetAttribute("attr1", (int64_t)314159);
  58   data.AddEvent("event1", now);
  59
  60   ASSERT_EQ(data.GetTraceId(), trace_id);
  61   ASSERT_EQ(data.GetSpanId(), span_id);
  62   ASSERT_EQ(data.GetSpanContext(), span_context);
  63   std::string trace_state_key1_value;
  64   ASSERT_EQ(data.GetSpanContext().trace_state()->Get("key1", trace_state_key1_value), true);
  65   ASSERT_EQ(trace_state_key1_value, "value");
  66   ASSERT_EQ(data.GetParentSpanId(), parent_span_id);
  67   ASSERT_EQ(data.GetName(), "span name");
  68   ASSERT_EQ(data.GetSpanKind(), trace_api::SpanKind::kServer);
  69   ASSERT_EQ(data.GetStatus(), trace_api::StatusCode::kOk);
  70   ASSERT_EQ(data.GetDescription(), "description");
  71   ASSERT_EQ(data.GetStartTime().time_since_epoch(), now.time_since_epoch());
  72   ASSERT_EQ(data.GetDuration(), std::chrono::nanoseconds(1000000));
  73   ASSERT_EQ(nostd::get<int64_t>(data.GetAttributes().at("attr1")), 314159);
  74   ASSERT_EQ(data.GetEvents().at(0).GetName(), "event1");
  75   ASSERT_EQ(data.GetEvents().at(0).GetTimestamp(), now);
  76 }
  77
  78 TEST(SpanData, EventAttributes)
  79 {
  80   SpanData data;
  81   const int kNumAttributes                  = 3;
  82   std::string keys[kNumAttributes]          = {"attr1", "attr2", "attr3"};
  83   int64_t values[kNumAttributes]            = {3, 5, 20};
  84   std::map<std::string, int64_t> attributes = {
  85       {keys[0], values[0]}, {keys[1], values[1]}, {keys[2], values[2]}};
  86
  87   data.AddEvent("Test Event", std::chrono::system_clock::now(),
  88                 common::KeyValueIterableView<std::map<std::string, int64_t>>(attributes));
  89
  90   for (int i = 0; i < kNumAttributes; i++)
  91   {
  92     EXPECT_EQ(nostd::get<int64_t>(data.GetEvents().at(0).GetAttributes().at(keys[i])), values[i]);
  93   }
  94 }
  95
  96 TEST(SpanData, Resources)
  97 {
  98   SpanData data;
  99   auto resource   = opentelemetry::sdk::resource::Resource::Create({});
 100   auto input_attr = resource.GetAttributes();
 101   data.SetResource(resource);
 102   auto output_attr = data.GetResource().GetAttributes();
 103   EXPECT_EQ(input_attr, output_attr);
 104 }
 105
 106 TEST(SpanData, Links)
 107 {
 108   SpanData data;
 109   const int kNumAttributes                  = 3;
 110   std::string keys[kNumAttributes]          = {"attr1", "attr2", "attr3"};
 111   int64_t values[kNumAttributes]            = {4, 12, 33};
 112   std::map<std::string, int64_t> attributes = {
 113       {keys[0], values[0]}, {keys[1], values[1]}, {keys[2], values[2]}};
 114
 115   // produce valid SpanContext with pseudo span and trace Id.
 116   uint8_t span_id_buf[trace_api::SpanId::kSize] = {
 117       1,
 118   };
 119   trace_api::SpanId span_id{span_id_buf};
 120   uint8_t trace_id_buf[trace_api::TraceId::kSize] = {
 121       2,
 122   };
 123   trace_api::TraceId trace_id{trace_id_buf};
 124   const auto span_context = trace_api::SpanContext(
 125       trace_id, span_id, trace_api::TraceFlags{trace_api::TraceFlags::kIsSampled}, true);
 126
 127   data.AddLink(span_context,
 128                common::KeyValueIterableView<std::map<std::string, int64_t>>(attributes));
 129
 130   EXPECT_EQ(data.GetLinks().at(0).GetSpanContext(), span_context);
 131   for (int i = 0; i < kNumAttributes; i++)
 132   {
 133     EXPECT_EQ(nostd::get<int64_t>(data.GetLinks().at(0).GetAttributes().at(keys[i])), values[i]);
 134   }
 135 }