Support Custom span-id and trace-id generator (#681)

sdk/include/opentelemetry/sdk/trace/id_generator.h

@@ -0,0 +1,42 @@
+// Copyright 2021, OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+#include "opentelemetry/trace/span_id.h"
+#include "opentelemetry/trace/trace_id.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace trace
+{
+
+/** IdGenerator provides an interface for generating Trace Id and Span Id */
+class IdGenerator
+{
+
+public:
+  virtual ~IdGenerator() = default;
+
+  /** Returns a SpanId represented by opaque 128-bit trace identifier */
+  virtual opentelemetry::trace::SpanId GenerateSpanId() noexcept = 0;
+
+  /** Returns a TraceId represented by opaque 64-bit trace identifier */
+  virtual opentelemetry::trace::TraceId GenerateTraceId() noexcept = 0;
+};
+}  // namespace trace
+
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/trace/random_id_generator.h

@@ -0,0 +1,35 @@
+// Copyright 2021, OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+#include "opentelemetry/sdk/trace/id_generator.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace trace
+{
+
+class RandomIdGenerator : public IdGenerator
+{
+public:
+  opentelemetry::trace::SpanId GenerateSpanId() noexcept override;
+
+  opentelemetry::trace::TraceId GenerateTraceId() noexcept override;
+};
+
+}  // namespace trace
+
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/include/opentelemetry/sdk/trace/tracer.h

@@ -35,6 +35,9 @@ class Tracer final : public trace_api::Tracer, public std::enable_shared_from_th
   /** Returns the currently active span processor. */
   SpanProcessor &GetActiveProcessor() noexcept { return context_->GetActiveProcessor(); }
 
+  /** Returns the configured Id generator */
+  IdGenerator &GetIdGenerator() noexcept { return context_->GetIdGenerator(); }
+
   // Note: Test only
   Sampler &GetSampler() { return context_->GetSampler(); }
 

sdk/include/opentelemetry/sdk/trace/tracer_context.h

@@ -3,6 +3,7 @@
 #include "opentelemetry/sdk/common/atomic_unique_ptr.h"
 #include "opentelemetry/sdk/resource/resource.h"
 #include "opentelemetry/sdk/trace/processor.h"
+#include "opentelemetry/sdk/trace/random_id_generator.h"
 #include "opentelemetry/sdk/trace/samplers/always_on.h"
 #include "opentelemetry/version.h"
 
@@ -28,11 +29,13 @@ namespace trace
 class TracerContext
 {
 public:
-  explicit TracerContext(std::unique_ptr<SpanProcessor> processor,
-                         opentelemetry::sdk::resource::Resource resource =
-                             opentelemetry::sdk::resource::Resource::Create({}),
-                         std::unique_ptr<Sampler> sampler =
-                             std::unique_ptr<AlwaysOnSampler>(new AlwaysOnSampler)) noexcept;
+  explicit TracerContext(
+      std::unique_ptr<SpanProcessor> processor,
+      opentelemetry::sdk::resource::Resource resource =
+          opentelemetry::sdk::resource::Resource::Create({}),
+      std::unique_ptr<Sampler> sampler = std::unique_ptr<AlwaysOnSampler>(new AlwaysOnSampler),
+      std::unique_ptr<IdGenerator> id_generator =
+          std::unique_ptr<IdGenerator>(new RandomIdGenerator())) noexcept;
   /**
    * Attaches a span processor to this tracer context.
    *
@@ -61,6 +64,12 @@ class TracerContext
    */
   const opentelemetry::sdk::resource::Resource &GetResource() const noexcept;
 
+  /**
+   * Obtain the Id Generator associated with this tracer context.
+   * @return The ID Generator for this tracer context.
+   */
+  opentelemetry::sdk::trace::IdGenerator &GetIdGenerator() const noexcept;
+
   /**
    * Force all active SpanProcessors to flush any buffered spans
    * within the given timeout.
@@ -77,6 +86,7 @@ class TracerContext
   opentelemetry::sdk::common::AtomicUniquePtr<SpanProcessor> processor_;
   opentelemetry::sdk::resource::Resource resource_;
   std::unique_ptr<Sampler> sampler_;
+  std::unique_ptr<IdGenerator> id_generator_;
 };
 
 }  // namespace trace

sdk/include/opentelemetry/sdk/trace/tracer_provider.h

@@ -27,11 +27,14 @@ class TracerProvider final : public opentelemetry::trace::TracerProvider
    * @param sampler The sampler for this tracer provider. This must
    * not be a nullptr.
    */
-  explicit TracerProvider(std::unique_ptr<SpanProcessor> processor,
-                          opentelemetry::sdk::resource::Resource resource =
-                              opentelemetry::sdk::resource::Resource::Create({}),
-                          std::unique_ptr<Sampler> sampler =
-                              std::unique_ptr<AlwaysOnSampler>(new AlwaysOnSampler)) noexcept;
+  explicit TracerProvider(
+      std::unique_ptr<SpanProcessor> processor,
+      opentelemetry::sdk::resource::Resource resource =
+          opentelemetry::sdk::resource::Resource::Create({}),
+      std::unique_ptr<Sampler> sampler = std::unique_ptr<AlwaysOnSampler>(new AlwaysOnSampler),
+      std::unique_ptr<opentelemetry::sdk::trace::IdGenerator> id_generator =
+          std::unique_ptr<opentelemetry::sdk::trace::IdGenerator>(
+              new RandomIdGenerator())) noexcept;
 
   /**
    * Initialize a new tracer provider with a specified context

sdk/src/trace/CMakeLists.txt

@@ -6,7 +6,8 @@ add_library(
   span.cc
   batch_span_processor.cc
   samplers/parent.cc
-  samplers/trace_id_ratio.cc)
+  samplers/trace_id_ratio.cc
+  random_id_generator.cc)
 
 set_target_properties(opentelemetry_trace PROPERTIES EXPORT_NAME trace)
 

sdk/src/trace/random_id_generator.cc

@@ -0,0 +1,40 @@
+// Copyright 2021, OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "opentelemetry/sdk/trace/random_id_generator.h"
+#include "opentelemetry/version.h"
+#include "src/common/random.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace sdk
+{
+namespace trace
+{
+
+opentelemetry::trace::SpanId RandomIdGenerator::GenerateSpanId() noexcept
+{
+  uint8_t span_id_buf[opentelemetry::trace::SpanId::kSize];
+  sdk::common::Random::GenerateRandomBuffer(span_id_buf);
+  return opentelemetry::trace::SpanId(span_id_buf);
+}
+
+opentelemetry::trace::TraceId RandomIdGenerator::GenerateTraceId() noexcept
+{
+  uint8_t trace_id_buf[opentelemetry::trace::TraceId::kSize];
+  sdk::common::Random::GenerateRandomBuffer(trace_id_buf);
+  return opentelemetry::trace::TraceId(trace_id_buf);
+}
+}  // namespace trace
+}  // namespace sdk
+OPENTELEMETRY_END_NAMESPACE

sdk/src/trace/span.cc

@@ -41,22 +41,6 @@ SteadyTimestamp NowOr(const SteadyTimestamp &steady)
 }
 }  // namespace
 
-// Helper function to generate random trace id.
-trace_api::TraceId GenerateRandomTraceId()
-{
-  uint8_t trace_id_buf[trace_api::TraceId::kSize];
-  sdk::common::Random::GenerateRandomBuffer(trace_id_buf);
-  return trace_api::TraceId(trace_id_buf);
-}
-
-// Helper function to generate random span id.
-trace_api::SpanId GenerateRandomSpanId()
-{
-  uint8_t span_id_buf[trace_api::SpanId::kSize];
-  sdk::common::Random::GenerateRandomBuffer(span_id_buf);
-  return trace_api::SpanId(span_id_buf);
-}
-
 Span::Span(std::shared_ptr<Tracer> &&tracer,
            nostd::string_view name,
            const opentelemetry::common::KeyValueIterable &attributes,
@@ -77,7 +61,7 @@ Span::Span(std::shared_ptr<Tracer> &&tracer,
   recordable_->SetName(name);
 
   trace_api::TraceId trace_id;
-  trace_api::SpanId span_id = GenerateRandomSpanId();
+  trace_api::SpanId span_id = tracer_->GetIdGenerator().GenerateSpanId();
   trace_api::SpanId parent_span_id;
   bool is_parent_span_valid = false;
 
@@ -89,7 +73,7 @@ Span::Span(std::shared_ptr<Tracer> &&tracer,
   }
   else
   {
-    trace_id = GenerateRandomTraceId();
+    trace_id = tracer_->GetIdGenerator().GenerateTraceId();
   }
 
   span_context_ = std::unique_ptr<trace_api::SpanContext>(new trace_api::SpanContext(

sdk/src/trace/tracer_context.cc

@@ -9,8 +9,12 @@ namespace trace
 
 TracerContext::TracerContext(std::unique_ptr<SpanProcessor> processor,
                              opentelemetry::sdk::resource::Resource resource,
-                             std::unique_ptr<Sampler> sampler) noexcept
-    : processor_(std::move(processor)), resource_(resource), sampler_(std::move(sampler))
+                             std::unique_ptr<Sampler> sampler,
+                             std::unique_ptr<IdGenerator> id_generator) noexcept
+    : processor_(std::move(processor)),
+      resource_(resource),
+      sampler_(std::move(sampler)),
+      id_generator_(std::move(id_generator))
 {}
 
 Sampler &TracerContext::GetSampler() const noexcept
@@ -23,6 +27,11 @@ const opentelemetry::sdk::resource::Resource &TracerContext::GetResource() const
   return resource_;
 }
 
+opentelemetry::sdk::trace::IdGenerator &TracerContext::GetIdGenerator() const noexcept
+{
+  return *id_generator_;
+}
+
 void TracerContext::RegisterPipeline(std::unique_ptr<SpanProcessor> processor) noexcept
 {
   // TODO(jsuereth): Implement

sdk/src/trace/tracer_provider.cc

@@ -11,9 +11,12 @@ TracerProvider::TracerProvider(std::shared_ptr<sdk::trace::TracerContext> contex
 
 TracerProvider::TracerProvider(std::unique_ptr<SpanProcessor> processor,
                                opentelemetry::sdk::resource::Resource resource,
-                               std::unique_ptr<Sampler> sampler) noexcept
-    : TracerProvider(
-          std::make_shared<TracerContext>(std::move(processor), resource, std::move(sampler)))
+                               std::unique_ptr<Sampler> sampler,
+                               std::unique_ptr<IdGenerator> id_generator) noexcept
+    : TracerProvider(std::make_shared<TracerContext>(std::move(processor),
+                                                     resource,
+                                                     std::move(sampler),
+                                                     std::move(id_generator)))
 {}
 
 opentelemetry::nostd::shared_ptr<opentelemetry::trace::Tracer> TracerProvider::GetTracer(

sdk/test/trace/tracer_provider_test.cc

@@ -33,7 +33,8 @@ TEST(TracerProvider, GetTracer)
   ASSERT_EQ("AlwaysOnSampler", sdkTracer1->GetSampler().GetDescription());
   TracerProvider tp2(std::make_shared<TracerContext>(
       std::unique_ptr<SpanProcessor>(new SimpleSpanProcessor(nullptr)), Resource::Create({}),
-      std::unique_ptr<Sampler>(new AlwaysOffSampler())));
+      std::unique_ptr<Sampler>(new AlwaysOffSampler()),
+      std::unique_ptr<IdGenerator>(new RandomIdGenerator)));
   auto sdkTracer2 = dynamic_cast<Tracer *>(tp2.GetTracer("test").get());
   ASSERT_EQ("AlwaysOffSampler", sdkTracer2->GetSampler().GetDescription());
 }

sdk/test/trace/tracer_test.cc

@@ -45,6 +45,24 @@ class MockSampler final : public Sampler
   nostd::string_view GetDescription() const noexcept override { return "MockSampler"; }
 };
 
+/**
+ * A Mock Custom Id Generator
+ */
+class MockIdGenerator : public IdGenerator
+{
+  opentelemetry::trace::SpanId GenerateSpanId() noexcept override
+  {
+    return opentelemetry::trace::SpanId(buf_span);
+  }
+
+  opentelemetry::trace::TraceId GenerateTraceId() noexcept override
+  {
+    return opentelemetry::trace::TraceId(buf_trace);
+  }
+  uint8_t buf_span[8]   = {1, 2, 3, 4, 5, 6, 7, 8};
+  uint8_t buf_trace[16] = {1, 2, 3, 4, 5, 6, 7, 8, 8, 7, 6, 5, 4, 3, 2, 1};
+};
+
 namespace
 {
 std::shared_ptr<opentelemetry::trace::Tracer> initTracer(std::unique_ptr<SpanExporter> &&exporter)
@@ -57,12 +75,14 @@ std::shared_ptr<opentelemetry::trace::Tracer> initTracer(std::unique_ptr<SpanExp
 std::shared_ptr<opentelemetry::trace::Tracer> initTracer(
     std::unique_ptr<SpanExporter> &&exporter,
     // For testing, just shove a pointer over, we'll take it over.
-    Sampler *sampler)
+    Sampler *sampler,
+    IdGenerator *id_generator = new RandomIdGenerator)
 {
   auto processor = std::unique_ptr<SpanProcessor>(new SimpleSpanProcessor(std::move(exporter)));
   auto resource  = Resource::Create({});
   auto context   = std::make_shared<TracerContext>(std::move(processor), resource,
-                                                 std::unique_ptr<Sampler>(sampler));
+                                                 std::unique_ptr<Sampler>(sampler),
+                                                 std::unique_ptr<IdGenerator>(id_generator));
   return std::shared_ptr<opentelemetry::trace::Tracer>(new Tracer(context));
 }
 }  // namespace
@@ -132,6 +152,21 @@ TEST(Tracer, StartSpanSampleOff)
   ASSERT_EQ(0, span_data->GetSpans().size());
 }
 
+TEST(Tracer, StartSpanCustomIdGenerator)
+{
+  IdGenerator *id_generator = new MockIdGenerator();
+  std::unique_ptr<InMemorySpanExporter> exporter(new InMemorySpanExporter());
+  std::shared_ptr<InMemorySpanData> span_data = exporter->GetData();
+  auto tracer = initTracer(std::move(exporter), new AlwaysOnSampler(), id_generator);
+
+  tracer->StartSpan("span 1")->End();
+  auto spans          = span_data->GetSpans();
+  auto &cur_span_data = spans.at(0);
+
+  EXPECT_EQ(cur_span_data->GetTraceId(), id_generator->GenerateTraceId());
+  EXPECT_EQ(cur_span_data->GetSpanId(), id_generator->GenerateSpanId());
+}
+
 TEST(Tracer, StartSpanWithOptionsTime)
 {
   std::unique_ptr<InMemorySpanExporter> exporter(new InMemorySpanExporter());