Sampler tracer integration

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

@@ -2,6 +2,7 @@
 
 #include "opentelemetry/sdk/common/atomic_shared_ptr.h"
 #include "opentelemetry/sdk/trace/processor.h"
+#include "opentelemetry/sdk/trace/samplers/always_on.h"
 #include "opentelemetry/trace/tracer.h"
 #include "opentelemetry/version.h"
 
@@ -20,7 +21,8 @@ class Tracer final : public trace_api::Tracer, public std::enable_shared_from_th
    * @param processor The span processor for this tracer. This must not be a
    * nullptr.
    */
-  explicit Tracer(std::shared_ptr<SpanProcessor> processor) noexcept : processor_{processor} {}
+  explicit Tracer(std::shared_ptr<SpanProcessor> processor,
+                  std::shared_ptr<Sampler> sampler = std::make_shared<AlwaysOnSampler>()) noexcept;
 
   /**
    * Set the span processor associated with this tracer.
@@ -35,6 +37,12 @@ class Tracer final : public trace_api::Tracer, public std::enable_shared_from_th
    */
   std::shared_ptr<SpanProcessor> GetProcessor() const noexcept;
 
+  /**
+   * Obtain the sampler associated with this tracer.
+   * @return The sampler for this tracer.
+   */
+  std::shared_ptr<Sampler> GetSampler() const noexcept;
+
   nostd::unique_ptr<trace_api::Span> StartSpan(
       nostd::string_view name,
       const trace_api::KeyValueIterable &attributes,
@@ -46,6 +54,7 @@ class Tracer final : public trace_api::Tracer, public std::enable_shared_from_th
 
 private:
   opentelemetry::sdk::AtomicSharedPtr<SpanProcessor> processor_;
+  const std::shared_ptr<Sampler> sampler_;
 };
 }  // namespace trace
 }  // namespace sdk

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

@@ -6,6 +6,7 @@
 
 #include "opentelemetry/nostd/shared_ptr.h"
 #include "opentelemetry/sdk/trace/processor.h"
+#include "opentelemetry/sdk/trace/samplers/always_on.h"
 #include "opentelemetry/sdk/trace/tracer.h"
 #include "opentelemetry/trace/tracer_provider.h"
 
@@ -18,11 +19,15 @@ class TracerProvider final : public opentelemetry::trace::TracerProvider
 {
 public:
   /**
-   * Initialize a new tracer provider.
+   * Initialize a new tracer provider with a specified sampler
    * @param processor The span processor for this tracer provider. This must
    * not be a nullptr.
+   * @param sampler The sampler for this tracer provider. This must
+   * not be a nullptr.
    */
-  explicit TracerProvider(std::shared_ptr<SpanProcessor> processor) noexcept;
+  explicit TracerProvider(
+      std::shared_ptr<SpanProcessor> processor,
+      std::shared_ptr<Sampler> sampler = std::make_shared<AlwaysOnSampler>()) noexcept;
 
   opentelemetry::nostd::shared_ptr<opentelemetry::trace::Tracer> GetTracer(
       nostd::string_view library_name,
@@ -41,9 +46,16 @@ class TracerProvider final : public opentelemetry::trace::TracerProvider
    */
   std::shared_ptr<SpanProcessor> GetProcessor() const noexcept;
 
+  /**
+   * Obtain the sampler associated with this tracer provider.
+   * @return The span processor for this tracer provider.
+   */
+  std::shared_ptr<Sampler> GetSampler() const noexcept;
+
 private:
   opentelemetry::sdk::AtomicSharedPtr<SpanProcessor> processor_;
   std::shared_ptr<opentelemetry::trace::Tracer> tracer_;
+  const std::shared_ptr<Sampler> sampler_;
 };
 }  // namespace trace
 }  // namespace sdk

sdk/src/trace/tracer.cc

@@ -9,6 +9,10 @@ namespace sdk
 {
 namespace trace
 {
+Tracer::Tracer(std::shared_ptr<SpanProcessor> processor, std::shared_ptr<Sampler> sampler) noexcept
+    : processor_{processor}, sampler_{sampler}
+{}
+
 void Tracer::SetProcessor(std::shared_ptr<SpanProcessor> processor) noexcept
 {
   processor_.store(processor);
@@ -19,6 +23,11 @@ std::shared_ptr<SpanProcessor> Tracer::GetProcessor() const noexcept
   return processor_.load();
 }
 
+std::shared_ptr<Sampler> Tracer::GetSampler() const noexcept
+{
+  return sampler_;
+}
+
 nostd::unique_ptr<trace_api::Span> Tracer::StartSpan(
     nostd::string_view name,
     const trace_api::KeyValueIterable &attributes,

sdk/src/trace/tracer_provider.cc

@@ -5,8 +5,9 @@ namespace sdk
 {
 namespace trace
 {
-TracerProvider::TracerProvider(std::shared_ptr<SpanProcessor> processor) noexcept
-    : processor_{processor}, tracer_(new Tracer(std::move(processor)))
+TracerProvider::TracerProvider(std::shared_ptr<SpanProcessor> processor,
+                               std::shared_ptr<Sampler> sampler) noexcept
+    : processor_{processor}, tracer_(new Tracer(std::move(processor))), sampler_(sampler)
 {}
 
 opentelemetry::nostd::shared_ptr<opentelemetry::trace::Tracer> TracerProvider::GetTracer(
@@ -28,6 +29,11 @@ std::shared_ptr<SpanProcessor> TracerProvider::GetProcessor() const noexcept
 {
   return processor_.load();
 }
+
+std::shared_ptr<Sampler> TracerProvider::GetSampler() const noexcept
+{
+  return sampler_;
+}
 }  // namespace trace
 }  // namespace sdk
 OPENTELEMETRY_END_NAMESPACE

sdk/test/trace/tracer_provider_test.cc

@@ -1,4 +1,6 @@
 #include "opentelemetry/sdk/trace/tracer_provider.h"
+#include "opentelemetry/sdk/trace/samplers/always_off.h"
+#include "opentelemetry/sdk/trace/samplers/always_on.h"
 #include "opentelemetry/sdk/trace/simple_processor.h"
 #include "opentelemetry/sdk/trace/tracer.h"
 
@@ -27,3 +29,28 @@ TEST(TracerProvider, GetTracer)
   ASSERT_NE(nullptr, sdkTracer);
   ASSERT_EQ(processor, sdkTracer->GetProcessor());
 }
+
+TEST(TracerProvider, GetSampler)
+{
+  std::shared_ptr<SpanProcessor> processor1(new SimpleSpanProcessor(nullptr));
+
+  // Create a TracerProvicer with a default AlwaysOnSampler.
+  TracerProvider tf1(processor1);
+  auto t1 = tf1.GetSampler();
+  auto t2 = tf1.GetSampler();
+  ASSERT_NE(nullptr, t1);
+  ASSERT_NE(nullptr, t2);
+
+  // Should return the same sampler each time.
+  ASSERT_EQ(t1, t2);
+
+  // Should be AlwaysOnSampler
+  ASSERT_EQ("AlwaysOnSampler", t2->GetDescription());
+
+  // Create a TracerProvicer with a custom AlwaysOffSampler.
+  std::shared_ptr<SpanProcessor> processor2(new SimpleSpanProcessor(nullptr));
+  TracerProvider tf2(processor2, std::make_shared<AlwaysOffSampler>());
+  auto t3 = tf2.GetSampler();
+
+  ASSERT_EQ("AlwaysOffSampler", t3->GetDescription());
+}

sdk/test/trace/tracer_test.cc

@@ -1,5 +1,7 @@
 #include "opentelemetry/sdk/trace/tracer.h"
 #include "opentelemetry/sdk/trace/simple_processor.h"
+#include "opentelemetry/sdk/trace/samplers/always_on.h"
+#include "opentelemetry/sdk/trace/samplers/always_off.h"
 #include "opentelemetry/sdk/trace/span_data.h"
 
 #include <gtest/gtest.h>
@@ -139,3 +141,21 @@ TEST(Tracer, StartSpanWithAttributes)
   ASSERT_EQ(1, span_data2->GetAttributes().size());
   ASSERT_EQ(3.0, nostd::get<double>(span_data2->GetAttributes().at("attr3")));
 }
+
+
+TEST(Tracer, GetSampler)
+{
+  // Create a Tracer with a default AlwaysOnSampler
+  std::shared_ptr<SpanProcessor> processor_1(new SimpleSpanProcessor(nullptr));
+  std::shared_ptr<Tracer> tracer_on(new Tracer(std::move(processor_1)));
+
+  auto t1 = tracer_on->GetSampler();
+  ASSERT_EQ("AlwaysOnSampler", t1->GetDescription());
+
+  // Create a Tracer with a AlwaysOffSampler
+  std::shared_ptr<SpanProcessor> processor_2(new SimpleSpanProcessor(nullptr));
+  std::shared_ptr<Tracer> tracer_off(new Tracer(std::move(processor_2), std::make_shared<AlwaysOffSampler>()));
+
+  auto t2 = tracer_off->GetSampler();
+  ASSERT_EQ("AlwaysOffSampler", t2->GetDescription());
+}