Rework

api/include/opentelemetry/logs/provider.h

@@ -16,8 +16,11 @@ namespace sdk
 {
 namespace logs
 {
+// The forward declaration is sufficient,
+// we do not want a API -> SDK dependency.
+// IWYU pragma: no_include "opentelemetry/sdk/logs/provider.h"
 class Provider;
-}
+}  // namespace logs
 }  // namespace sdk
 
 namespace logs
@@ -44,15 +47,18 @@ class OPENTELEMETRY_EXPORT Provider
     return nostd::shared_ptr<LoggerProvider>(GetProvider());
   }
 
+#if OPENTELEMETRY_ABI_VERSION_NO == 1
+
   /**
    * Changes the singleton LoggerProvider.
-   * While declared in the API class opentelemetry::logs::Provider,
-   * this method is actually part of the SDK, not API.
-   * An application **MUST** link with the opentelemetry-cpp SDK,
-   * to install a logs provider, when configuring OpenTelemetry.
-   * An instrumented library does not need to invoke this method.
    */
-  static void SetLoggerProvider(const nostd::shared_ptr<LoggerProvider> &lp) noexcept;
+  static void SetLoggerProvider(const nostd::shared_ptr<LoggerProvider> &tp) noexcept
+  {
+    std::lock_guard<common::SpinLockMutex> guard(GetLock());
+    GetProvider() = tp;
+  }
+
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
   /**
    * Returns the singleton EventLoggerProvider.
@@ -66,15 +72,18 @@ class OPENTELEMETRY_EXPORT Provider
     return nostd::shared_ptr<EventLoggerProvider>(GetEventProvider());
   }
 
+#if OPENTELEMETRY_ABI_VERSION_NO == 1
+
   /**
    * Changes the singleton EventLoggerProvider.
-   * While declared in the API class opentelemetry::logs::Provider,
-   * this method is actually part of the SDK, not API.
-   * An application **MUST** link with the opentelemetry-cpp SDK,
-   * to install an event logs provider, when configuring OpenTelemetry.
-   * An instrumented library does not need to invoke this method.
    */
-  static void SetEventLoggerProvider(const nostd::shared_ptr<EventLoggerProvider> &lp) noexcept;
+  static void SetEventLoggerProvider(const nostd::shared_ptr<EventLoggerProvider> &tp) noexcept
+  {
+    std::lock_guard<common::SpinLockMutex> guard(GetLock());
+    GetEventProvider() = tp;
+  }
+
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
 private:
   /* The SDK is allowed to change the singleton in the API. */

api/include/opentelemetry/metrics/provider.h

@@ -16,8 +16,11 @@ namespace sdk
 {
 namespace metrics
 {
+// The forward declaration is sufficient,
+// we do not want a API -> SDK dependency.
+// IWYU pragma: no_include "opentelemetry/sdk/metrics/provider.h"
 class Provider;  // IWYU pragma: keep
-}
+}  // namespace metrics
 }  // namespace sdk
 
 namespace metrics
@@ -43,15 +46,18 @@ class Provider
     return nostd::shared_ptr<MeterProvider>(GetProvider());
   }
 
+#if OPENTELEMETRY_ABI_VERSION_NO == 1
+
   /**
    * Changes the singleton MeterProvider.
-   * While declared in the API class opentelemetry::metrics::Provider,
-   * this method is actually part of the SDK, not API.
-   * An application **MUST** link with the opentelemetry-cpp SDK,
-   * to install a metrics provider, when configuring OpenTelemetry.
-   * An instrumented library does not need to invoke this method.
    */
-  static void SetMeterProvider(const nostd::shared_ptr<MeterProvider> &mp) noexcept;
+  static void SetMeterProvider(const nostd::shared_ptr<MeterProvider> &tp) noexcept
+  {
+    std::lock_guard<common::SpinLockMutex> guard(GetLock());
+    GetProvider() = tp;
+  }
+
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
 private:
   /* The SDK is allowed to change the singleton in the API. */

api/include/opentelemetry/trace/provider.h

@@ -11,17 +11,16 @@
 #include "opentelemetry/trace/tracer_provider.h"
 #include "opentelemetry/version.h"
 
-// The friend declaration is sufficient,
-// we do not want a API -> SDK dependency.
-// IWYU pragma: no_include "opentelemetry/sdk/trace/provider.h"
-
 OPENTELEMETRY_BEGIN_NAMESPACE
 namespace sdk
 {
 namespace trace
 {
+// The forward declaration is sufficient,
+// we do not want a API -> SDK dependency.
+// IWYU pragma: no_include "opentelemetry/sdk/trace/provider.h"
 class Provider;  // IWYU pragma: keep
-}
+}  // namespace trace
 }  // namespace sdk
 
 namespace trace
@@ -45,15 +44,18 @@ class OPENTELEMETRY_EXPORT Provider
     return nostd::shared_ptr<TracerProvider>(GetProvider());
   }
 
+#if OPENTELEMETRY_ABI_VERSION_NO == 1
+
   /**
    * Changes the singleton TracerProvider.
-   * While declared in the API class opentelemetry::trace::Provider,
-   * this method is actually part of the SDK, not API.
-   * An application **MUST** link with the opentelemetry-cpp SDK,
-   * to install a tracer provider, when configuring OpenTelemetry.
-   * An instrumented library does not need to invoke this method.
    */
-  static void SetTracerProvider(const nostd::shared_ptr<TracerProvider> &tp) noexcept;
+  static void SetTracerProvider(const nostd::shared_ptr<TracerProvider> &tp) noexcept
+  {
+    std::lock_guard<common::SpinLockMutex> guard(GetLock());
+    GetProvider() = tp;
+  }
+
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 
 private:
   /* The SDK is allowed to change the singleton in the API. */

api/test/logs/logger_test.cc

@@ -8,6 +8,7 @@
 #include <vector>
 
 #include "opentelemetry/common/attribute_value.h"
+#include "opentelemetry/common/key_value_iterable.h"
 #include "opentelemetry/common/key_value_iterable_view.h"
 #include "opentelemetry/logs/event_id.h"
 #include "opentelemetry/logs/event_logger.h"
@@ -20,6 +21,7 @@
 #include "opentelemetry/nostd/shared_ptr.h"
 #include "opentelemetry/nostd/span.h"
 #include "opentelemetry/nostd/string_view.h"
+#include "opentelemetry/nostd/unique_ptr.h"
 
 using opentelemetry::logs::EventId;
 using opentelemetry::logs::Logger;
@@ -189,3 +191,47 @@ TEST(Logger, EventLogMethodOverloads)
   event_logger->EmitEvent("event name", Severity::kDebug,
                           opentelemetry::common::MakeAttributes(vec));
 }
+
+// Define a basic Logger class
+class TestLogger : public Logger
+{
+  const nostd::string_view GetName() noexcept override { return "test logger"; }
+
+  nostd::unique_ptr<opentelemetry::logs::LogRecord> CreateLogRecord() noexcept override
+  {
+    return nullptr;
+  }
+
+  using Logger::EmitLogRecord;
+
+  void EmitLogRecord(nostd::unique_ptr<opentelemetry::logs::LogRecord> &&) noexcept override {}
+};
+
+// Define a basic LoggerProvider class that returns an instance of the logger class defined above
+class TestProvider : public LoggerProvider
+{
+  nostd::shared_ptr<Logger> GetLogger(nostd::string_view /* logger_name */,
+                                      nostd::string_view /* library_name */,
+                                      nostd::string_view /* library_version */,
+                                      nostd::string_view /* schema_url */,
+                                      const common::KeyValueIterable & /* attributes */) override
+  {
+    return nostd::shared_ptr<Logger>(new TestLogger());
+  }
+};
+
+#if OPENTELEMETRY_ABI_VERSION_NO == 1
+TEST(Logger, PushLoggerImplementation)
+{
+  // Push the new loggerprovider class into the global singleton
+  auto test_provider = shared_ptr<LoggerProvider>(new TestProvider());
+  Provider::SetLoggerProvider(test_provider);
+
+  auto lp = Provider::GetLoggerProvider();
+
+  // Check that the implementation was pushed by calling TestLogger's GetName()
+  nostd::string_view schema_url{"https://opentelemetry.io/schemas/1.11.0"};
+  auto logger = lp->GetLogger("TestLogger", "opentelelemtry_library", "", schema_url);
+  ASSERT_EQ("test logger", logger->GetName());
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */

api/test/logs/provider_test.cc

@@ -40,6 +40,25 @@ TEST(Provider, GetLoggerProviderDefault)
   EXPECT_NE(nullptr, tf);
 }
 
+#if OPENTELEMETRY_ABI_VERSION_NO == 1
+TEST(Provider, SetLoggerProvider)
+{
+  auto tf = shared_ptr<LoggerProvider>(new TestProvider());
+  Provider::SetLoggerProvider(tf);
+  ASSERT_EQ(tf, Provider::GetLoggerProvider());
+}
+
+TEST(Provider, MultipleLoggerProviders)
+{
+  auto tf = shared_ptr<LoggerProvider>(new TestProvider());
+  Provider::SetLoggerProvider(tf);
+  auto tf2 = shared_ptr<LoggerProvider>(new TestProvider());
+  Provider::SetLoggerProvider(tf2);
+
+  ASSERT_NE(Provider::GetLoggerProvider(), tf);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
 TEST(Provider, GetLogger)
 {
   auto tf = shared_ptr<LoggerProvider>(new TestProvider());
@@ -71,6 +90,25 @@ TEST(Provider, GetEventLoggerProviderDefault)
   EXPECT_NE(nullptr, tf);
 }
 
+#if OPENTELEMETRY_ABI_VERSION_NO == 1
+TEST(Provider, SetEventLoggerProvider)
+{
+  auto tf = nostd::shared_ptr<EventLoggerProvider>(new TestEventLoggerProvider());
+  Provider::SetEventLoggerProvider(tf);
+  ASSERT_EQ(tf, Provider::GetEventLoggerProvider());
+}
+
+TEST(Provider, MultipleEventLoggerProviders)
+{
+  auto tf = nostd::shared_ptr<EventLoggerProvider>(new TestEventLoggerProvider());
+  Provider::SetEventLoggerProvider(tf);
+  auto tf2 = nostd::shared_ptr<EventLoggerProvider>(new TestEventLoggerProvider());
+  Provider::SetEventLoggerProvider(tf2);
+
+  ASSERT_NE(Provider::GetEventLoggerProvider(), tf);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
 TEST(Provider, CreateEventLogger)
 {
   auto tf     = nostd::shared_ptr<TestEventLoggerProvider>(new TestEventLoggerProvider());

api/test/metrics/meter_provider_test.cc

@@ -3,13 +3,35 @@
 
 #include <gtest/gtest.h>
 
+#include "opentelemetry/metrics/noop.h"
 #include "opentelemetry/metrics/provider.h"
+#include "opentelemetry/nostd/shared_ptr.h"
 
 using opentelemetry::metrics::MeterProvider;
+using opentelemetry::metrics::NoopMeterProvider;
 using opentelemetry::metrics::Provider;
 
 TEST(Provider, GetMeterProviderDefault)
 {
   auto tf = Provider::GetMeterProvider();
   EXPECT_NE(nullptr, tf);
 }
+
+#if OPENTELEMETRY_ABI_VERSION_NO == 1
+TEST(Provider, SetMeterProvider)
+{
+  auto tf = opentelemetry::nostd::shared_ptr<MeterProvider>(new NoopMeterProvider());
+  Provider::SetMeterProvider(tf);
+  ASSERT_EQ(tf, Provider::GetMeterProvider());
+}
+
+TEST(Provider, MultipleMeterProviders)
+{
+  auto tf = opentelemetry::nostd::shared_ptr<MeterProvider>(new NoopMeterProvider());
+  Provider::SetMeterProvider(tf);
+  auto tf2 = opentelemetry::nostd::shared_ptr<MeterProvider>(new NoopMeterProvider());
+  Provider::SetMeterProvider(tf2);
+
+  ASSERT_NE(Provider::GetMeterProvider(), tf);
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */

api/test/trace/provider_test.cc

@@ -4,6 +4,7 @@
 #include <gtest/gtest.h>
 
 #include "opentelemetry/nostd/shared_ptr.h"
+#include "opentelemetry/nostd/string_view.h"
 #include "opentelemetry/trace/provider.h"
 #include "opentelemetry/trace/tracer_provider.h"
 
@@ -13,8 +14,39 @@ using opentelemetry::trace::TracerProvider;
 
 namespace nostd = opentelemetry::nostd;
 
+class TestProvider : public TracerProvider
+{
+
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+  nostd::shared_ptr<Tracer> GetTracer(
+      nostd::string_view /* name */,
+      nostd::string_view /* version */,
+      nostd::string_view /* schema_url */,
+      const opentelemetry::common::KeyValueIterable * /* attributes */) noexcept override
+  {
+    return nostd::shared_ptr<Tracer>(nullptr);
+  }
+#else
+  nostd::shared_ptr<Tracer> GetTracer(nostd::string_view /* name */,
+                                      nostd::string_view /* version */,
+                                      nostd::string_view /* schema_url */) noexcept override
+  {
+    return nostd::shared_ptr<Tracer>(nullptr);
+  }
+#endif
+};
+
 TEST(Provider, GetTracerProviderDefault)
 {
   auto tf = Provider::GetTracerProvider();
   EXPECT_NE(nullptr, tf);
 }
+
+#if OPENTELEMETRY_ABI_VERSION_NO == 1
+TEST(Provider, SetTracerProvider)
+{
+  auto tf = nostd::shared_ptr<TracerProvider>(new TestProvider());
+  Provider::SetTracerProvider(tf);
+  ASSERT_EQ(tf, Provider::GetTracerProvider());
+}
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */

examples/batch/main.cc

@@ -16,6 +16,7 @@
 #include "opentelemetry/sdk/trace/batch_span_processor_options.h"
 #include "opentelemetry/sdk/trace/exporter.h"
 #include "opentelemetry/sdk/trace/processor.h"
+#include "opentelemetry/sdk/trace/provider.h"
 #include "opentelemetry/sdk/trace/tracer_provider.h"
 #include "opentelemetry/sdk/trace/tracer_provider_factory.h"
 #include "opentelemetry/trace/provider.h"
@@ -56,13 +57,13 @@ void InitTracer()
       trace_sdk::TracerProviderFactory::Create(std::move(processor), resource);
 
   // Set the global trace provider.
-  trace_api::Provider::SetTracerProvider(provider);
+  trace_sdk::Provider::SetTracerProvider(provider);
 }
 
 void CleanupTracer()
 {
   std::shared_ptr<opentelemetry::trace::TracerProvider> none;
-  trace_api::Provider::SetTracerProvider(none);
+  trace_sdk::Provider::SetTracerProvider(none);
 }
 
 opentelemetry::nostd::shared_ptr<trace_api::Tracer> get_tracer()

examples/grpc/tracer_common.h

@@ -9,6 +9,7 @@
 #include "opentelemetry/nostd/shared_ptr.h"
 #include "opentelemetry/sdk/trace/exporter.h"
 #include "opentelemetry/sdk/trace/processor.h"
+#include "opentelemetry/sdk/trace/provider.h"
 #include "opentelemetry/sdk/trace/simple_processor_factory.h"
 #include "opentelemetry/sdk/trace/tracer_context.h"
 #include "opentelemetry/sdk/trace/tracer_context_factory.h"
@@ -85,7 +86,7 @@ void InitTracer()
   std::shared_ptr<opentelemetry::trace::TracerProvider> provider =
       opentelemetry::sdk::trace::TracerProviderFactory::Create(std::move(context));
   // Set the global trace provider
-  opentelemetry::trace::Provider::SetTracerProvider(provider);
+  opentelemetry::sdk::trace::Provider::SetTracerProvider(provider);
 
   // set global propagator
   opentelemetry::context::propagation::GlobalTextMapPropagator::SetGlobalPropagator(
@@ -96,7 +97,7 @@ void InitTracer()
 void CleanupTracer()
 {
   std::shared_ptr<opentelemetry::trace::TracerProvider> none;
-  opentelemetry::trace::Provider::SetTracerProvider(none);
+  opentelemetry::sdk::trace::Provider::SetTracerProvider(none);
 }
 
 opentelemetry::nostd::shared_ptr<opentelemetry::trace::Tracer> get_tracer(std::string tracer_name)