diff --git a/CHANGELOG.md b/CHANGELOG.md
index 27c379349f..cd92d15ba4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -21,6 +21,60 @@ Increment the:
 * [CI] Upgrade to clang-format 18
   [#2684](https://github.com/open-telemetry/opentelemetry-cpp/pull/2684)
 
+* [API/SDK] Provider cleanup
+  [#2664](https://github.com/open-telemetry/opentelemetry-cpp/pull/2664)
+
+Important changes:
+
+* [API/SDK] Provider cleanup
+  [#2664](https://github.com/open-telemetry/opentelemetry-cpp/pull/2664)
+  * Before this fix:
+    * The API class `opentelemetry::trace::Tracer` exposed methods such
+      as `ForceFlush()`, `ForceFlushWithMicroseconds()`, `Close()`
+      and `CloseWithMicroseconds()`.
+    * These methods are meant to be used when configuring the SDK,
+      and should not be part of the API. Exposing them was an oversight.
+    * Two of these methods are virtual, and therefore part of the ABI.
+  * After this fix:
+    * In `OPENTELEMETRY_ABI_VERSION_NO 1`, nothing is changed,
+      because removing this code would break the ABI.
+    * In `OPENTELEMETRY_ABI_VERSION_NO 2`, these methods are moved
+      from the API to the SDK. This is a breaking change for ABI version 2,
+      which is still experimental.
+  * In all cases, instrumenting an application should not
+    invoke flush or close on a tracer, do not use these methods.
+
+Breaking changes:
+
+* [API/SDK] Provider cleanup
+  [#2664](https://github.com/open-telemetry/opentelemetry-cpp/pull/2664)
+  * Before this fix:
+    * SDK factory methods such as:
+      * opentelemetry::sdk::trace::TracerProviderFactory::Create()
+      * opentelemetry::sdk::metrics::MeterProviderFactory::Create()
+      * opentelemetry::sdk::logs::LoggerProviderFactory::Create()
+      * opentelemetry::sdk::logs::EventLoggerProviderFactory::Create()
+      returned an API object (opentelemetry::trace::TracerProvider)
+      to the caller.
+  * After this fix, these methods return an SDK level object
+    (opentelemetry::sdk::trace::TracerProvider) to the caller.
+  * Returning an SDK object is necessary for the application to
+    cleanup and invoke SDK level methods, such as ForceFlush(),
+    on a provider.
+  * The application code that configures the SDK, by calling
+    the various provider factories, may need adjustment.
+  * All the examples have been updated, and in particular no
+    longer perform static_cast do convert an API object to an SDK object.
+    Please refer to examples for guidance on how to adjust.
+  * If adjusting application code is impractical,
+    an alternate and temporary solution is to build with option
+    WITH_DEPRECATED_SDK_FACTORY=ON in CMake.
+  * Option WITH_DEPRECATED_SDK_FACTORY=ON will allow to build code
+    without application changes, posponing changes for later.
+  * WITH_DEPRECATED_SDK_FACTORY=ON is temporary, only to provide
+    an easier migration path. Expect this flag to be removed,
+    as early as by the next release.
+
 Notes on experimental features:
 
 * [#2372](https://github.com/open-telemetry/opentelemetry-cpp/issues/2372)
diff --git a/CMakeLists.txt b/CMakeLists.txt
index cc085b1af4..d01d7054ef 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -154,6 +154,14 @@ message(STATUS "OPENTELEMETRY_VERSION=${OPENTELEMETRY_VERSION}")
 
 option(WITH_NO_DEPRECATED_CODE "Do not include deprecated code" OFF)
 
+# This option is temporary, and will be removed. Set
+# WITH_DEPRECATED_SDK_FACTORY=OFF to migrate to the new SDK code.
+option(WITH_DEPRECATED_SDK_FACTORY "Use deprecated SDK provider factory" ON)
+
+if(WITH_DEPRECATED_SDK_FACTORY)
+  message(WARNING "WITH_DEPRECATED_SDK_FACTORY=ON is temporary and deprecated")
+endif()
+
 set(WITH_STL
     "OFF"
     CACHE STRING "Which version of the Standard Library for C++ to use")
diff --git a/DEPRECATED.md b/DEPRECATED.md
index 0632f50503..7db5ba9d93 100644
--- a/DEPRECATED.md
+++ b/DEPRECATED.md
@@ -88,7 +88,85 @@ No date set yet for the Jaeger Propagator.
 
 ## [opentelemetry-cpp SDK]
 
-N/A
+### SDK ProviderFactory cleanup
+
+#### Announcement (SDK ProviderFactory cleanup)
+
+* Version: 1.15.0
+* Date: 2024-06-03
+* PR: [API/SDK] Provider cleanup
+  [#2664](https://github.com/open-telemetry/opentelemetry-cpp/pull/2664)
+
+This PR introduces changes to SDK ProviderFactory methods.
+
+#### Motivation (SDK ProviderFactory cleanup)
+
+SDK Factory methods for signal providers, such as:
+
+* opentelemetry::sdk::trace::TracerProviderFactory
+* opentelemetry::sdk::metrics::MeterProviderFactory
+* opentelemetry::sdk::logs::LoggerProviderFactory
+* opentelemetry::sdk::logs::EventLoggerProviderFactory
+
+currently returns a unique pointer on a API class.
+
+This is incorrect, the proper return type should be
+a unique pointer on a SDK class instead.
+
+#### Scope (SDK ProviderFactory cleanup)
+
+All the current Create methods in:
+
+* class opentelemetry::sdk::trace::TracerProviderFactory
+* class opentelemetry::sdk::metrics::MeterProviderFactory
+* class opentelemetry::sdk::logs::LoggerProviderFactory
+* class opentelemetry::sdk::logs::EventLoggerProviderFactory
+
+are marked as deprecated, as they return an API object.
+
+Instead, another set of Create methods is provided,
+with a different return type, an SDK object.
+
+Both sets can not be exposed at the same time,
+as this would cause build breaks,
+so a compilation flag is defined to select which methods to use.
+
+When OPENTELEMETRY_DEPRECATED_SDK_FACTORY is defined,
+the old, deprecated, methods are available.
+
+When OPENTELEMETRY_DEPRECATED_SDK_FACTORY is not defined,
+the new methods are available.
+
+The scope of this deprecation and removal,
+is to remove the flag OPENTELEMETRY_DEPRECATED_SDK_FACTORY itself,
+which implies that only the new set of Create() methods,
+returning an SDK object, are supported.
+
+#### Mitigation (SDK ProviderFactory cleanup)
+
+Build without defining flag OPENTELEMETRY_DEPRECATED_SDK_FACTORY.
+
+Existing code, such as:
+
+```cpp
+  std::shared_ptr<opentelemetry::trace::TracerProvider> tracer_provider;
+  tracer_provider = opentelemetry::sdk::trace::TracerProviderFactory::Create(...);
+```
+
+should be adjusted to:
+
+```cpp
+  std::shared_ptr<opentelemetry::sdk::trace::TracerProvider> tracer_provider;
+  tracer_provider = opentelemetry::sdk::trace::TracerProviderFactory::Create(...);
+```
+
+#### Planned removal (SDK ProviderFactory cleanup)
+
+Flag OPENTELEMETRY_DEPRECATED_SDK_FACTORY is introduced in release 1.16.0,
+to provide a migration path.
+
+This flag is meant to be temporary, and short lived.
+Expect removal by release 1.17.0
 
 ## [opentelemetry-cpp Exporter]
 
diff --git a/api/CMakeLists.txt b/api/CMakeLists.txt
index 78e97ad029..e07275efed 100644
--- a/api/CMakeLists.txt
+++ b/api/CMakeLists.txt
@@ -35,6 +35,11 @@ if(WITH_NO_DEPRECATED_CODE)
                              INTERFACE OPENTELEMETRY_NO_DEPRECATED_CODE)
 endif()
 
+if(WITH_DEPRECATED_SDK_FACTORY)
+  target_compile_definitions(opentelemetry_api
+                             INTERFACE OPENTELEMETRY_DEPRECATED_SDK_FACTORY)
+endif()
+
 if(WITH_ABSEIL)
   target_compile_definitions(opentelemetry_api INTERFACE HAVE_ABSEIL)
   target_link_libraries(
diff --git a/api/include/opentelemetry/plugin/tracer.h b/api/include/opentelemetry/plugin/tracer.h
index 068b08071d..9f3c7c76d1 100644
--- a/api/include/opentelemetry/plugin/tracer.h
+++ b/api/include/opentelemetry/plugin/tracer.h
@@ -104,6 +104,8 @@ class Tracer final : public trace::Tracer, public std::enable_shared_from_this<T
     return nostd::shared_ptr<trace::Span>{new (std::nothrow) Span{this->shared_from_this(), span}};
   }
 
+#if OPENTELEMETRY_ABI_VERSION_NO == 1
+
   void ForceFlushWithMicroseconds(uint64_t timeout) noexcept override
   {
     tracer_handle_->tracer().ForceFlushWithMicroseconds(timeout);
@@ -114,6 +116,8 @@ class Tracer final : public trace::Tracer, public std::enable_shared_from_this<T
     tracer_handle_->tracer().CloseWithMicroseconds(timeout);
   }
 
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
+
 private:
   // Note: The order is important here.
   //
diff --git a/api/include/opentelemetry/trace/noop.h b/api/include/opentelemetry/trace/noop.h
index 407f3c1ac9..345c4ba0c9 100644
--- a/api/include/opentelemetry/trace/noop.h
+++ b/api/include/opentelemetry/trace/noop.h
@@ -102,9 +102,13 @@ class OPENTELEMETRY_EXPORT NoopTracer final : public Tracer,
     return noop_span;
   }
 
+#if OPENTELEMETRY_ABI_VERSION_NO == 1
+
   void ForceFlushWithMicroseconds(uint64_t /*timeout*/) noexcept override {}
 
   void CloseWithMicroseconds(uint64_t /*timeout*/) noexcept override {}
+
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 };
 
 /**
diff --git a/api/include/opentelemetry/trace/tracer.h b/api/include/opentelemetry/trace/tracer.h
index 7fc758511f..c10fff6c60 100644
--- a/api/include/opentelemetry/trace/tracer.h
+++ b/api/include/opentelemetry/trace/tracer.h
@@ -163,6 +163,13 @@ class Tracer
     }
   }
 
+#if OPENTELEMETRY_ABI_VERSION_NO == 1
+
+  /*
+   * The following is removed from the API in ABI version 2.
+   * It belongs to the SDK.
+   */
+
   /**
    * Force any buffered spans to flush.
    * @param timeout to complete the flush
@@ -188,6 +195,8 @@ class Tracer
   }
 
   virtual void CloseWithMicroseconds(uint64_t timeout) noexcept = 0;
+
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 };
 }  // namespace trace
 OPENTELEMETRY_END_NAMESPACE
diff --git a/api/test/singleton/singleton_test.cc b/api/test/singleton/singleton_test.cc
index 0973a1427f..fb4551cfe9 100644
--- a/api/test/singleton/singleton_test.cc
+++ b/api/test/singleton/singleton_test.cc
@@ -250,9 +250,13 @@ class MyTracer : public trace::Tracer
     return result;
   }
 
+#if OPENTELEMETRY_ABI_VERSION_NO == 1
+
   void ForceFlushWithMicroseconds(uint64_t /* timeout */) noexcept override {}
 
   void CloseWithMicroseconds(uint64_t /* timeout */) noexcept override {}
+
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 };
 
 class MyTracerProvider : public trace::TracerProvider
diff --git a/ci/do_ci.ps1 b/ci/do_ci.ps1
index bdab94ae04..f6a12e3877 100644
--- a/ci/do_ci.ps1
+++ b/ci/do_ci.ps1
@@ -133,6 +133,7 @@ switch ($action) {
     cmake $SRC_DIR `
       -DOTELCPP_MAINTAINER_MODE=ON `
       -DWITH_NO_DEPRECATED_CODE=ON `
+      -DWITH_DEPRECATED_SDK_FACTORY=OFF `
       -DVCPKG_TARGET_TRIPLET=x64-windows `
       "-DCMAKE_TOOLCHAIN_FILE=$VCPKG_DIR/scripts/buildsystems/vcpkg.cmake"
     $exit = $LASTEXITCODE
@@ -157,6 +158,7 @@ switch ($action) {
       -DCMAKE_CXX_STANDARD=20 `
       -DOTELCPP_MAINTAINER_MODE=ON `
       -DWITH_NO_DEPRECATED_CODE=ON `
+      -DWITH_DEPRECATED_SDK_FACTORY=OFF `
       -DVCPKG_TARGET_TRIPLET=x64-windows `
       "-DCMAKE_TOOLCHAIN_FILE=$VCPKG_DIR/scripts/buildsystems/vcpkg.cmake"
     $exit = $LASTEXITCODE
diff --git a/ci/do_ci.sh b/ci/do_ci.sh
index b7c97a3800..2d089ef21e 100755
--- a/ci/do_ci.sh
+++ b/ci/do_ci.sh
@@ -130,6 +130,7 @@ elif [[ "$1" == "cmake.maintainer.sync.test" ]]; then
         -DWITH_ASYNC_EXPORT_PREVIEW=OFF \
         -DOTELCPP_MAINTAINER_MODE=ON \
         -DWITH_NO_DEPRECATED_CODE=ON \
+        -DWITH_DEPRECATED_SDK_FACTORY=OFF \
         -DWITH_OTLP_HTTP_COMPRESSION=ON \
         ${IWYU} \
         "${SRC_DIR}"
@@ -152,6 +153,7 @@ elif [[ "$1" == "cmake.maintainer.async.test" ]]; then
         -DWITH_ASYNC_EXPORT_PREVIEW=ON \
         -DOTELCPP_MAINTAINER_MODE=ON \
         -DWITH_NO_DEPRECATED_CODE=ON \
+        -DWITH_DEPRECATED_SDK_FACTORY=OFF \
         -DWITH_OTLP_HTTP_COMPRESSION=ON \
         ${IWYU} \
         "${SRC_DIR}"
@@ -175,6 +177,7 @@ elif [[ "$1" == "cmake.maintainer.cpp11.async.test" ]]; then
         -DWITH_ASYNC_EXPORT_PREVIEW=ON \
         -DOTELCPP_MAINTAINER_MODE=ON \
         -DWITH_NO_DEPRECATED_CODE=ON \
+        -DWITH_DEPRECATED_SDK_FACTORY=OFF \
         -DWITH_OTLP_HTTP_COMPRESSION=ON \
         "${SRC_DIR}"
   make -k -j $(nproc)
@@ -196,6 +199,7 @@ elif [[ "$1" == "cmake.maintainer.abiv2.test" ]]; then
         -DWITH_ASYNC_EXPORT_PREVIEW=OFF \
         -DOTELCPP_MAINTAINER_MODE=ON \
         -DWITH_NO_DEPRECATED_CODE=ON \
+        -DWITH_DEPRECATED_SDK_FACTORY=OFF \
         -DWITH_ABI_VERSION_1=OFF \
         -DWITH_ABI_VERSION_2=ON \
         -DWITH_OTLP_HTTP_COMPRESSION=ON \
diff --git a/examples/logs_simple/main.cc b/examples/logs_simple/main.cc
index 54a872ad0e..e104724e2a 100644
--- a/examples/logs_simple/main.cc
+++ b/examples/logs_simple/main.cc
@@ -1,19 +1,20 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
+#include "opentelemetry/exporters/ostream/log_record_exporter.h"
 #include "opentelemetry/exporters/ostream/span_exporter_factory.h"
+#include "opentelemetry/logs/provider.h"
+#include "opentelemetry/sdk/logs/logger_provider.h"
+#include "opentelemetry/sdk/logs/logger_provider_factory.h"
+#include "opentelemetry/sdk/logs/processor.h"
+#include "opentelemetry/sdk/logs/simple_log_record_processor_factory.h"
 #include "opentelemetry/sdk/trace/exporter.h"
 #include "opentelemetry/sdk/trace/processor.h"
 #include "opentelemetry/sdk/trace/simple_processor_factory.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
 #include "opentelemetry/sdk/trace/tracer_provider_factory.h"
 #include "opentelemetry/trace/provider.h"
 
-#include "opentelemetry/exporters/ostream/log_record_exporter.h"
-#include "opentelemetry/logs/provider.h"
-#include "opentelemetry/sdk/logs/logger_provider_factory.h"
-#include "opentelemetry/sdk/logs/processor.h"
-#include "opentelemetry/sdk/logs/simple_log_record_processor_factory.h"
-
 #ifdef BAZEL_BUILD
 #  include "examples/common/logs_foo_library/foo_library.h"
 #else
@@ -35,11 +36,18 @@ void InitTracer()
   // Create ostream span exporter instance
   auto exporter  = trace_exporter::OStreamSpanExporterFactory::Create();
   auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));
-  std::shared_ptr<trace_api::TracerProvider> provider =
-      trace_sdk::TracerProviderFactory::Create(std::move(processor));
+
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+  std::shared_ptr<opentelemetry::trace::TracerProvider> provider =
+      opentelemetry::sdk::trace::TracerProviderFactory::Create(std::move(processor));
+#else
+  std::shared_ptr<opentelemetry::sdk::trace::TracerProvider> provider =
+      opentelemetry::sdk::trace::TracerProviderFactory::Create(std::move(processor));
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
 
   // Set the global trace provider
-  trace_api::Provider::SetTracerProvider(provider);
+  std::shared_ptr<trace_api::TracerProvider> api_provider = provider;
+  trace_api::Provider::SetTracerProvider(api_provider);
 }
 
 void CleanupTracer()
@@ -54,11 +62,18 @@ void InitLogger()
   auto exporter =
       std::unique_ptr<logs_sdk::LogRecordExporter>(new logs_exporter::OStreamLogRecordExporter);
   auto processor = logs_sdk::SimpleLogRecordProcessorFactory::Create(std::move(exporter));
-  std::shared_ptr<logs_api::LoggerProvider> provider(
-      logs_sdk::LoggerProviderFactory::Create(std::move(processor)));
+
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+  std::shared_ptr<opentelemetry::logs::LoggerProvider> provider(
+      opentelemetry::sdk::logs::LoggerProviderFactory::Create(std::move(processor)));
+#else
+  std::shared_ptr<opentelemetry::sdk::logs::LoggerProvider> provider(
+      opentelemetry::sdk::logs::LoggerProviderFactory::Create(std::move(processor)));
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
 
   // Set the global logger provider
-  logs_api::Provider::SetLoggerProvider(provider);
+  std::shared_ptr<logs_api::LoggerProvider> api_provider = provider;
+  logs_api::Provider::SetLoggerProvider(api_provider);
 }
 
 void CleanupLogger()
diff --git a/examples/metrics_simple/metrics_ostream.cc b/examples/metrics_simple/metrics_ostream.cc
index 7248bc9148..770b2db81a 100644
--- a/examples/metrics_simple/metrics_ostream.cc
+++ b/examples/metrics_simple/metrics_ostream.cc
@@ -46,10 +46,14 @@ void InitMetrics(const std::string &name)
   auto reader =
       metrics_sdk::PeriodicExportingMetricReaderFactory::Create(std::move(exporter), options);
 
-  auto u_provider = metrics_sdk::MeterProviderFactory::Create();
-  auto *p         = static_cast<metrics_sdk::MeterProvider *>(u_provider.get());
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+  auto u_provider = opentelemetry::sdk::metrics::MeterProviderFactory::Create();
+  auto *provider  = static_cast<opentelemetry::sdk::metrics::MeterProvider *>(u_provider.get());
+#else
+  auto provider = opentelemetry::sdk::metrics::MeterProviderFactory::Create();
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
 
-  p->AddMetricReader(std::move(reader));
+  provider->AddMetricReader(std::move(reader));
 
   // counter view
   std::string counter_name = name + "_counter";
@@ -63,7 +67,7 @@ void InitMetrics(const std::string &name)
   auto sum_view = metrics_sdk::ViewFactory::Create(name, "description", unit,
                                                    metrics_sdk::AggregationType::kSum);
 
-  p->AddView(std::move(instrument_selector), std::move(meter_selector), std::move(sum_view));
+  provider->AddView(std::move(instrument_selector), std::move(meter_selector), std::move(sum_view));
 
   // observable counter view
   std::string observable_counter_name = name + "_observable_counter";
@@ -76,8 +80,8 @@ void InitMetrics(const std::string &name)
   auto observable_sum_view = metrics_sdk::ViewFactory::Create(name, "test_description", unit,
                                                               metrics_sdk::AggregationType::kSum);
 
-  p->AddView(std::move(observable_instrument_selector), std::move(observable_meter_selector),
-             std::move(observable_sum_view));
+  provider->AddView(std::move(observable_instrument_selector), std::move(observable_meter_selector),
+                    std::move(observable_sum_view));
 
   // histogram view
   std::string histogram_name = name + "_histogram";
@@ -100,11 +104,16 @@ void InitMetrics(const std::string &name)
   auto histogram_view = metrics_sdk::ViewFactory::Create(
       name, "description", unit, metrics_sdk::AggregationType::kHistogram, aggregation_config);
 
-  p->AddView(std::move(histogram_instrument_selector), std::move(histogram_meter_selector),
-             std::move(histogram_view));
+  provider->AddView(std::move(histogram_instrument_selector), std::move(histogram_meter_selector),
+                    std::move(histogram_view));
+
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+  std::shared_ptr<opentelemetry::metrics::MeterProvider> api_provider(std::move(u_provider));
+#else
+  std::shared_ptr<opentelemetry::metrics::MeterProvider> api_provider(std::move(provider));
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
 
-  std::shared_ptr<opentelemetry::metrics::MeterProvider> provider(std::move(u_provider));
-  metrics_api::Provider::SetMeterProvider(provider);
+  metrics_api::Provider::SetMeterProvider(api_provider);
 }
 
 void CleanupMetrics()
diff --git a/examples/otlp/file_log_main.cc b/examples/otlp/file_log_main.cc
index f903449c56..9254c9947f 100644
--- a/examples/otlp/file_log_main.cc
+++ b/examples/otlp/file_log_main.cc
@@ -8,20 +8,17 @@
 #include "opentelemetry/exporters/otlp/otlp_file_log_record_exporter_options.h"
 #include "opentelemetry/logs/provider.h"
 #include "opentelemetry/sdk/logs/exporter.h"
+#include "opentelemetry/sdk/logs/logger_provider.h"
 #include "opentelemetry/sdk/logs/logger_provider_factory.h"
 #include "opentelemetry/sdk/logs/processor.h"
 #include "opentelemetry/sdk/logs/simple_log_record_processor_factory.h"
 #include "opentelemetry/sdk/trace/exporter.h"
 #include "opentelemetry/sdk/trace/processor.h"
 #include "opentelemetry/sdk/trace/simple_processor_factory.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
 #include "opentelemetry/sdk/trace/tracer_provider_factory.h"
 #include "opentelemetry/trace/provider.h"
 
-// sdk::TracerProvider and sdk::LoggerProvider is just used to call ForceFlush and prevent to cancel
-// running exportings when destroy and shutdown exporters.It's optional to users.
-#include "opentelemetry/sdk/logs/logger_provider.h"
-#include "opentelemetry/sdk/trace/tracer_provider.h"
-
 #include <iostream>
 #include <string>
 #include <utility>
@@ -43,27 +40,40 @@ namespace
 {
 opentelemetry::exporter::otlp::OtlpFileExporterOptions opts;
 opentelemetry::exporter::otlp::OtlpFileLogRecordExporterOptions log_opts;
+
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+std::shared_ptr<opentelemetry::trace::TracerProvider> tracer_provider;
+std::shared_ptr<opentelemetry::logs::LoggerProvider> logger_provider;
+#else
+std::shared_ptr<opentelemetry::sdk::trace::TracerProvider> tracer_provider;
+std::shared_ptr<opentelemetry::sdk::logs::LoggerProvider> logger_provider;
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
+
 void InitTracer()
 {
   // Create OTLP exporter instance
-  auto exporter  = otlp::OtlpFileExporterFactory::Create(opts);
-  auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));
-  std::shared_ptr<opentelemetry::trace::TracerProvider> provider =
-      trace_sdk::TracerProviderFactory::Create(std::move(processor));
+  auto exporter   = otlp::OtlpFileExporterFactory::Create(opts);
+  auto processor  = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));
+  tracer_provider = trace_sdk::TracerProviderFactory::Create(std::move(processor));
+
   // Set the global trace provider
-  trace::Provider::SetTracerProvider(provider);
+  std::shared_ptr<opentelemetry::trace::TracerProvider> api_provider = tracer_provider;
+  trace::Provider::SetTracerProvider(api_provider);
 }
 
 void CleanupTracer()
 {
   // We call ForceFlush to prevent to cancel running exportings, It's optional.
-  opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider> provider =
-      trace::Provider::GetTracerProvider();
-  if (provider)
+  if (tracer_provider)
   {
-    static_cast<trace_sdk::TracerProvider *>(provider.get())->ForceFlush();
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+    static_cast<opentelemetry::sdk::trace::TracerProvider *>(tracer_provider.get())->ForceFlush();
+#else
+    tracer_provider->ForceFlush();
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
   }
 
+  tracer_provider.reset();
   std::shared_ptr<opentelemetry::trace::TracerProvider> none;
   trace::Provider::SetTracerProvider(none);
 }
@@ -71,24 +81,27 @@ void CleanupTracer()
 void InitLogger()
 {
   // Create OTLP exporter instance
-  auto exporter  = otlp::OtlpFileLogRecordExporterFactory::Create(log_opts);
-  auto processor = logs_sdk::SimpleLogRecordProcessorFactory::Create(std::move(exporter));
-  nostd::shared_ptr<logs::LoggerProvider> provider(
-      logs_sdk::LoggerProviderFactory::Create(std::move(processor)));
+  auto exporter   = otlp::OtlpFileLogRecordExporterFactory::Create(log_opts);
+  auto processor  = logs_sdk::SimpleLogRecordProcessorFactory::Create(std::move(exporter));
+  logger_provider = logs_sdk::LoggerProviderFactory::Create(std::move(processor));
 
-  opentelemetry::logs::Provider::SetLoggerProvider(provider);
+  std::shared_ptr<opentelemetry::logs::LoggerProvider> api_provider = logger_provider;
+  opentelemetry::logs::Provider::SetLoggerProvider(api_provider);
 }
 
 void CleanupLogger()
 {
   // We call ForceFlush to prevent to cancel running exportings, It's optional.
-  opentelemetry::nostd::shared_ptr<logs::LoggerProvider> provider =
-      logs::Provider::GetLoggerProvider();
-  if (provider)
+  if (logger_provider)
   {
-    static_cast<logs_sdk::LoggerProvider *>(provider.get())->ForceFlush();
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+    static_cast<opentelemetry::sdk::logs::LoggerProvider *>(logger_provider.get())->ForceFlush();
+#else
+    logger_provider->ForceFlush();
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
   }
 
+  logger_provider.reset();
   nostd::shared_ptr<logs::LoggerProvider> none;
   opentelemetry::logs::Provider::SetLoggerProvider(none);
 }
diff --git a/examples/otlp/file_main.cc b/examples/otlp/file_main.cc
index e0a1264fb6..13db0e4ad1 100644
--- a/examples/otlp/file_main.cc
+++ b/examples/otlp/file_main.cc
@@ -4,13 +4,10 @@
 #include "opentelemetry/exporters/otlp/otlp_file_exporter_factory.h"
 #include "opentelemetry/sdk/trace/processor.h"
 #include "opentelemetry/sdk/trace/simple_processor_factory.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
 #include "opentelemetry/sdk/trace/tracer_provider_factory.h"
 #include "opentelemetry/trace/provider.h"
 
-// sdk::TracerProvider is just used to call ForceFlush and prevent to cancel running exportings when
-// destroy and shutdown exporters.It's optional to users.
-#include "opentelemetry/sdk/trace/tracer_provider.h"
-
 #include <iostream>
 #include <string>
 #include <utility>
@@ -28,27 +25,38 @@ namespace otlp      = opentelemetry::exporter::otlp;
 namespace
 {
 opentelemetry::exporter::otlp::OtlpFileExporterOptions opts;
+
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+std::shared_ptr<opentelemetry::trace::TracerProvider> provider;
+#else
+std::shared_ptr<opentelemetry::sdk::trace::TracerProvider> provider;
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
+
 void InitTracer()
 {
   // Create OTLP exporter instance
   auto exporter  = otlp::OtlpFileExporterFactory::Create(opts);
   auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));
-  std::shared_ptr<opentelemetry::trace::TracerProvider> provider =
-      trace_sdk::TracerProviderFactory::Create(std::move(processor));
+  provider       = trace_sdk::TracerProviderFactory::Create(std::move(processor));
+
   // Set the global trace provider
-  trace::Provider::SetTracerProvider(provider);
+  std::shared_ptr<opentelemetry::trace::TracerProvider> api_provider = provider;
+  trace::Provider::SetTracerProvider(api_provider);
 }
 
 void CleanupTracer()
 {
   // We call ForceFlush to prevent to cancel running exportings, It's optional.
-  opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider> provider =
-      trace::Provider::GetTracerProvider();
   if (provider)
   {
-    static_cast<trace_sdk::TracerProvider *>(provider.get())->ForceFlush();
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+    static_cast<opentelemetry::sdk::trace::TracerProvider *>(provider.get())->ForceFlush();
+#else
+    provider->ForceFlush();
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
   }
 
+  provider.reset();
   std::shared_ptr<opentelemetry::trace::TracerProvider> none;
   trace::Provider::SetTracerProvider(none);
 }
diff --git a/examples/otlp/grpc_log_main.cc b/examples/otlp/grpc_log_main.cc
index 9d7399dbaf..24037f6190 100644
--- a/examples/otlp/grpc_log_main.cc
+++ b/examples/otlp/grpc_log_main.cc
@@ -7,20 +7,17 @@
 #include "opentelemetry/exporters/otlp/otlp_grpc_log_record_exporter_options.h"
 #include "opentelemetry/logs/provider.h"
 #include "opentelemetry/sdk/logs/exporter.h"
+#include "opentelemetry/sdk/logs/logger_provider.h"
 #include "opentelemetry/sdk/logs/logger_provider_factory.h"
 #include "opentelemetry/sdk/logs/processor.h"
 #include "opentelemetry/sdk/logs/simple_log_record_processor_factory.h"
 #include "opentelemetry/sdk/trace/exporter.h"
 #include "opentelemetry/sdk/trace/processor.h"
 #include "opentelemetry/sdk/trace/simple_processor_factory.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
 #include "opentelemetry/sdk/trace/tracer_provider_factory.h"
 #include "opentelemetry/trace/provider.h"
 
-// sdk::TracerProvider and sdk::LoggerProvider is just used to call ForceFlush and prevent to cancel
-// running exportings when destroy and shutdown exporters.It's optional to users.
-#include "opentelemetry/sdk/logs/logger_provider.h"
-#include "opentelemetry/sdk/trace/tracer_provider.h"
-
 #include <string>
 
 #ifdef BAZEL_BUILD
@@ -40,27 +37,40 @@ namespace
 {
 opentelemetry::exporter::otlp::OtlpGrpcExporterOptions opts;
 opentelemetry::exporter::otlp::OtlpGrpcLogRecordExporterOptions log_opts;
+
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+std::shared_ptr<opentelemetry::trace::TracerProvider> tracer_provider;
+std::shared_ptr<opentelemetry::logs::LoggerProvider> logger_provider;
+#else
+std::shared_ptr<opentelemetry::sdk::trace::TracerProvider> tracer_provider;
+std::shared_ptr<opentelemetry::sdk::logs::LoggerProvider> logger_provider;
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
+
 void InitTracer()
 {
   // Create OTLP exporter instance
-  auto exporter  = otlp::OtlpGrpcExporterFactory::Create(opts);
-  auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));
-  std::shared_ptr<opentelemetry::trace::TracerProvider> provider =
-      trace_sdk::TracerProviderFactory::Create(std::move(processor));
+  auto exporter   = otlp::OtlpGrpcExporterFactory::Create(opts);
+  auto processor  = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));
+  tracer_provider = trace_sdk::TracerProviderFactory::Create(std::move(processor));
+
   // Set the global trace provider
-  trace::Provider::SetTracerProvider(provider);
+  std::shared_ptr<opentelemetry::trace::TracerProvider> api_provider = tracer_provider;
+  trace::Provider::SetTracerProvider(api_provider);
 }
 
 void CleanupTracer()
 {
   // We call ForceFlush to prevent to cancel running exportings, It's optional.
-  opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider> provider =
-      trace::Provider::GetTracerProvider();
-  if (provider)
+  if (tracer_provider)
   {
-    static_cast<trace_sdk::TracerProvider *>(provider.get())->ForceFlush();
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+    static_cast<opentelemetry::sdk::trace::TracerProvider *>(tracer_provider.get())->ForceFlush();
+#else
+    tracer_provider->ForceFlush();
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
   }
 
+  tracer_provider.reset();
   std::shared_ptr<opentelemetry::trace::TracerProvider> none;
   trace::Provider::SetTracerProvider(none);
 }
@@ -68,24 +78,28 @@ void CleanupTracer()
 void InitLogger()
 {
   // Create OTLP exporter instance
-  auto exporter  = otlp::OtlpGrpcLogRecordExporterFactory::Create(log_opts);
-  auto processor = logs_sdk::SimpleLogRecordProcessorFactory::Create(std::move(exporter));
-  nostd::shared_ptr<logs::LoggerProvider> provider(
-      logs_sdk::LoggerProviderFactory::Create(std::move(processor)));
+  auto exporter   = otlp::OtlpGrpcLogRecordExporterFactory::Create(log_opts);
+  auto processor  = logs_sdk::SimpleLogRecordProcessorFactory::Create(std::move(exporter));
+  logger_provider = logs_sdk::LoggerProviderFactory::Create(std::move(processor));
 
-  opentelemetry::logs::Provider::SetLoggerProvider(provider);
+  // Set the global logger provider
+  std::shared_ptr<opentelemetry::logs::LoggerProvider> api_provider = logger_provider;
+  opentelemetry::logs::Provider::SetLoggerProvider(api_provider);
 }
 
 void CleanupLogger()
 {
   // We call ForceFlush to prevent to cancel running exportings, It's optional.
-  opentelemetry::nostd::shared_ptr<logs::LoggerProvider> provider =
-      logs::Provider::GetLoggerProvider();
-  if (provider)
+  if (logger_provider)
   {
-    static_cast<logs_sdk::LoggerProvider *>(provider.get())->ForceFlush();
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+    static_cast<opentelemetry::sdk::logs::LoggerProvider *>(logger_provider.get())->ForceFlush();
+#else
+    logger_provider->ForceFlush();
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
   }
 
+  logger_provider.reset();
   nostd::shared_ptr<logs::LoggerProvider> none;
   opentelemetry::logs::Provider::SetLoggerProvider(none);
 }
diff --git a/examples/otlp/grpc_main.cc b/examples/otlp/grpc_main.cc
index c238d9ad2a..15499985af 100644
--- a/examples/otlp/grpc_main.cc
+++ b/examples/otlp/grpc_main.cc
@@ -2,14 +2,13 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include "opentelemetry/exporters/otlp/otlp_grpc_exporter_factory.h"
+#include "opentelemetry/nostd/shared_ptr.h"
 #include "opentelemetry/sdk/trace/processor.h"
 #include "opentelemetry/sdk/trace/simple_processor_factory.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
 #include "opentelemetry/sdk/trace/tracer_provider_factory.h"
 #include "opentelemetry/trace/provider.h"
-
-// sdk::TracerProvider is just used to call ForceFlush and prevent to cancel running exportings when
-// destroy and shutdown exporters.It's optional to users.
-#include "opentelemetry/sdk/trace/tracer_provider.h"
+#include "opentelemetry/trace/tracer_provider.h"
 
 #ifdef BAZEL_BUILD
 #  include "examples/common/foo_library/foo_library.h"
@@ -24,27 +23,38 @@ namespace otlp      = opentelemetry::exporter::otlp;
 namespace
 {
 opentelemetry::exporter::otlp::OtlpGrpcExporterOptions opts;
+
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+std::shared_ptr<opentelemetry::trace::TracerProvider> provider;
+#else
+std::shared_ptr<opentelemetry::sdk::trace::TracerProvider> provider;
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
+
 void InitTracer()
 {
   // Create OTLP exporter instance
   auto exporter  = otlp::OtlpGrpcExporterFactory::Create(opts);
   auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));
-  std::shared_ptr<opentelemetry::trace::TracerProvider> provider =
-      trace_sdk::TracerProviderFactory::Create(std::move(processor));
+  provider       = trace_sdk::TracerProviderFactory::Create(std::move(processor));
+
   // Set the global trace provider
-  trace::Provider::SetTracerProvider(provider);
+  std::shared_ptr<opentelemetry::trace::TracerProvider> api_provider = provider;
+  trace::Provider::SetTracerProvider(api_provider);
 }
 
 void CleanupTracer()
 {
   // We call ForceFlush to prevent to cancel running exportings, It's optional.
-  opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider> provider =
-      trace::Provider::GetTracerProvider();
   if (provider)
   {
-    static_cast<trace_sdk::TracerProvider *>(provider.get())->ForceFlush();
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+    static_cast<opentelemetry::sdk::trace::TracerProvider *>(provider.get())->ForceFlush();
+#else
+    provider->ForceFlush();
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
   }
 
+  provider.reset();
   std::shared_ptr<opentelemetry::trace::TracerProvider> none;
   trace::Provider::SetTracerProvider(none);
 }
diff --git a/examples/otlp/http_log_main.cc b/examples/otlp/http_log_main.cc
index 7b68ad44c7..e2b219de1c 100644
--- a/examples/otlp/http_log_main.cc
+++ b/examples/otlp/http_log_main.cc
@@ -6,19 +6,16 @@
 #include "opentelemetry/exporters/otlp/otlp_http_log_record_exporter_options.h"
 #include "opentelemetry/logs/provider.h"
 #include "opentelemetry/sdk/common/global_log_handler.h"
+#include "opentelemetry/sdk/logs/logger_provider.h"
 #include "opentelemetry/sdk/logs/logger_provider_factory.h"
 #include "opentelemetry/sdk/logs/processor.h"
 #include "opentelemetry/sdk/logs/simple_log_record_processor_factory.h"
 #include "opentelemetry/sdk/trace/processor.h"
 #include "opentelemetry/sdk/trace/simple_processor_factory.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
 #include "opentelemetry/sdk/trace/tracer_provider_factory.h"
 #include "opentelemetry/trace/provider.h"
 
-// sdk::TracerProvider and sdk::LoggerProvider is just used to call ForceFlush and prevent to cancel
-// running exportings when destroy and shutdown exporters.It's optional to users.
-#include "opentelemetry/sdk/logs/logger_provider.h"
-#include "opentelemetry/sdk/trace/tracer_provider.h"
-
 #include <iostream>
 #include <string>
 
@@ -40,6 +37,13 @@ namespace
 {
 
 opentelemetry::exporter::otlp::OtlpHttpExporterOptions trace_opts;
+
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+std::shared_ptr<opentelemetry::trace::TracerProvider> tracer_provider;
+#else
+std::shared_ptr<opentelemetry::sdk::trace::TracerProvider> tracer_provider;
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
+
 void InitTracer()
 {
   if (trace_opts.url.size() > 9)
@@ -58,53 +62,68 @@ void InitTracer()
     }
   }
   std::cout << "Using " << trace_opts.url << " to export trace spans." << std::endl;
+
   // Create OTLP exporter instance
-  auto exporter  = otlp::OtlpHttpExporterFactory::Create(trace_opts);
-  auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));
-  std::shared_ptr<opentelemetry::trace::TracerProvider> provider =
-      trace_sdk::TracerProviderFactory::Create(std::move(processor));
+  auto exporter   = otlp::OtlpHttpExporterFactory::Create(trace_opts);
+  auto processor  = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));
+  tracer_provider = trace_sdk::TracerProviderFactory::Create(std::move(processor));
+
   // Set the global trace provider
-  trace::Provider::SetTracerProvider(provider);
+  std::shared_ptr<opentelemetry::trace::TracerProvider> api_provider = tracer_provider;
+  trace::Provider::SetTracerProvider(api_provider);
 }
 
 void CleanupTracer()
 {
   // We call ForceFlush to prevent to cancel running exportings, It's optional.
-  opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider> provider =
-      trace::Provider::GetTracerProvider();
-  if (provider)
+  if (tracer_provider)
   {
-    static_cast<trace_sdk::TracerProvider *>(provider.get())->ForceFlush();
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+    static_cast<opentelemetry::sdk::trace::TracerProvider *>(tracer_provider.get())->ForceFlush();
+#else
+    tracer_provider->ForceFlush();
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
   }
 
+  tracer_provider.reset();
   std::shared_ptr<opentelemetry::trace::TracerProvider> none;
   trace::Provider::SetTracerProvider(none);
 }
 
 opentelemetry::exporter::otlp::OtlpHttpLogRecordExporterOptions logger_opts;
+
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+std::shared_ptr<opentelemetry::logs::LoggerProvider> logger_provider;
+#else
+std::shared_ptr<opentelemetry::sdk::logs::LoggerProvider> logger_provider;
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
+
 void InitLogger()
 {
   std::cout << "Using " << logger_opts.url << " to export log records." << std::endl;
   logger_opts.console_debug = true;
   // Create OTLP exporter instance
-  auto exporter  = otlp::OtlpHttpLogRecordExporterFactory::Create(logger_opts);
-  auto processor = logs_sdk::SimpleLogRecordProcessorFactory::Create(std::move(exporter));
-  std::shared_ptr<logs::LoggerProvider> provider =
-      logs_sdk::LoggerProviderFactory::Create(std::move(processor));
+  auto exporter   = otlp::OtlpHttpLogRecordExporterFactory::Create(logger_opts);
+  auto processor  = logs_sdk::SimpleLogRecordProcessorFactory::Create(std::move(exporter));
+  logger_provider = logs_sdk::LoggerProviderFactory::Create(std::move(processor));
 
-  opentelemetry::logs::Provider::SetLoggerProvider(provider);
+  std::shared_ptr<opentelemetry::logs::LoggerProvider> api_provider = logger_provider;
+  opentelemetry::logs::Provider::SetLoggerProvider(api_provider);
 }
 
 void CleanupLogger()
 {
   // We call ForceFlush to prevent to cancel running exportings, It's optional.
-  opentelemetry::nostd::shared_ptr<logs::LoggerProvider> provider =
-      logs::Provider::GetLoggerProvider();
-  if (provider)
+  if (logger_provider)
   {
-    static_cast<logs_sdk::LoggerProvider *>(provider.get())->ForceFlush();
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+    static_cast<opentelemetry::sdk::logs::LoggerProvider *>(logger_provider.get())->ForceFlush();
+#else
+    logger_provider->ForceFlush();
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
   }
 
+  logger_provider.reset();
   std::shared_ptr<logs::LoggerProvider> none;
   opentelemetry::logs::Provider::SetLoggerProvider(none);
 }
diff --git a/examples/otlp/http_main.cc b/examples/otlp/http_main.cc
index 6a0667b918..9ad476bd47 100644
--- a/examples/otlp/http_main.cc
+++ b/examples/otlp/http_main.cc
@@ -6,13 +6,10 @@
 #include "opentelemetry/sdk/common/global_log_handler.h"
 #include "opentelemetry/sdk/trace/processor.h"
 #include "opentelemetry/sdk/trace/simple_processor_factory.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
 #include "opentelemetry/sdk/trace/tracer_provider_factory.h"
 #include "opentelemetry/trace/provider.h"
 
-// sdk::TracerProvider is just used to call ForceFlush and prevent to cancel running exportings when
-// destroy and shutdown exporters.It's optional to users.
-#include "opentelemetry/sdk/trace/tracer_provider.h"
-
 #include <string>
 
 #ifdef BAZEL_BUILD
@@ -30,27 +27,37 @@ namespace internal_log = opentelemetry::sdk::common::internal_log;
 namespace
 {
 opentelemetry::exporter::otlp::OtlpHttpExporterOptions opts;
+
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+std::shared_ptr<opentelemetry::trace::TracerProvider> provider;
+#else
+std::shared_ptr<opentelemetry::sdk::trace::TracerProvider> provider;
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
+
 void InitTracer()
 {
   // Create OTLP exporter instance
   auto exporter  = otlp::OtlpHttpExporterFactory::Create(opts);
   auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));
-  std::shared_ptr<opentelemetry::trace::TracerProvider> provider =
-      trace_sdk::TracerProviderFactory::Create(std::move(processor));
+  provider       = trace_sdk::TracerProviderFactory::Create(std::move(processor));
   // Set the global trace provider
-  trace::Provider::SetTracerProvider(provider);
+  std::shared_ptr<opentelemetry::trace::TracerProvider> api_provider = provider;
+  trace::Provider::SetTracerProvider(api_provider);
 }
 
 void CleanupTracer()
 {
   // We call ForceFlush to prevent to cancel running exportings, It's optional.
-  opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider> provider =
-      trace::Provider::GetTracerProvider();
   if (provider)
   {
-    static_cast<trace_sdk::TracerProvider *>(provider.get())->ForceFlush();
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+    static_cast<opentelemetry::sdk::trace::TracerProvider *>(provider.get())->ForceFlush();
+#else
+    provider->ForceFlush();
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
   }
 
+  provider.reset();
   std::shared_ptr<opentelemetry::trace::TracerProvider> none;
   trace::Provider::SetTracerProvider(none);
 }
diff --git a/examples/plugin/plugin/tracer.h b/examples/plugin/plugin/tracer.h
index af2a4c5e92..1480b44541 100644
--- a/examples/plugin/plugin/tracer.h
+++ b/examples/plugin/plugin/tracer.h
@@ -20,7 +20,11 @@ class Tracer final : public opentelemetry::trace::Tracer,
       const opentelemetry::trace::SpanContextKeyValueIterable & /*links*/,
       const opentelemetry::trace::StartSpanOptions & /*options */) noexcept override;
 
+#if OPENTELEMETRY_ABI_VERSION_NO == 1
+
   void ForceFlushWithMicroseconds(uint64_t /*timeout*/) noexcept override {}
 
   void CloseWithMicroseconds(uint64_t /*timeout*/) noexcept override {}
+
+#endif /* OPENTELEMETRY_ABI_VERSION_NO */
 };
diff --git a/examples/simple/main.cc b/examples/simple/main.cc
index 48768b6448..284ec2f693 100644
--- a/examples/simple/main.cc
+++ b/examples/simple/main.cc
@@ -5,6 +5,7 @@
 #include "opentelemetry/sdk/trace/exporter.h"
 #include "opentelemetry/sdk/trace/processor.h"
 #include "opentelemetry/sdk/trace/simple_processor_factory.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
 #include "opentelemetry/sdk/trace/tracer_provider_factory.h"
 #include "opentelemetry/trace/provider.h"
 
@@ -24,11 +25,18 @@ void InitTracer()
 {
   auto exporter  = trace_exporter::OStreamSpanExporterFactory::Create();
   auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));
+
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
   std::shared_ptr<opentelemetry::trace::TracerProvider> provider =
-      trace_sdk::TracerProviderFactory::Create(std::move(processor));
+      opentelemetry::sdk::trace::TracerProviderFactory::Create(std::move(processor));
+#else
+  std::shared_ptr<opentelemetry::sdk::trace::TracerProvider> provider =
+      opentelemetry::sdk::trace::TracerProviderFactory::Create(std::move(processor));
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
 
   // Set the global trace provider
-  trace_api::Provider::SetTracerProvider(provider);
+  std::shared_ptr<opentelemetry::trace::TracerProvider> api_provider = provider;
+  trace_api::Provider::SetTracerProvider(api_provider);
 }
 
 void CleanupTracer()
diff --git a/exporters/otlp/test/otlp_file_exporter_test.cc b/exporters/otlp/test/otlp_file_exporter_test.cc
index 497bb0b203..16a1306f88 100644
--- a/exporters/otlp/test/otlp_file_exporter_test.cc
+++ b/exporters/otlp/test/otlp_file_exporter_test.cc
@@ -88,7 +88,7 @@ class OtlpFileExporterTestPeer : public ::testing::Test
 
     auto processor = std::unique_ptr<sdk::trace::SpanProcessor>(
         new sdk::trace::BatchSpanProcessor(std::move(exporter), processor_opts));
-    auto provider = nostd::shared_ptr<trace::TracerProvider>(
+    auto provider = nostd::shared_ptr<sdk::trace::TracerProvider>(
         new sdk::trace::TracerProvider(std::move(processor), resource));
 
     std::string report_trace_id;
@@ -110,7 +110,7 @@ class OtlpFileExporterTestPeer : public ::testing::Test
     child_span->End();
     parent_span->End();
 
-    static_cast<sdk::trace::TracerProvider *>(provider.get())->ForceFlush();
+    provider->ForceFlush();
 
     {
       auto check_json        = nlohmann::json::parse(output.str(), nullptr, false);
diff --git a/exporters/otlp/test/otlp_grpc_log_record_exporter_test.cc b/exporters/otlp/test/otlp_grpc_log_record_exporter_test.cc
index c0c04c577a..4c7a9fd7f1 100644
--- a/exporters/otlp/test/otlp_grpc_log_record_exporter_test.cc
+++ b/exporters/otlp/test/otlp_grpc_log_record_exporter_test.cc
@@ -288,10 +288,17 @@ TEST_F(OtlpGrpcLogRecordExporterTestPeer, ExportIntegrationTest)
   std::unique_ptr<proto::collector::trace::v1::TraceService::StubInterface> trace_stub_interface(
       trace_mock_stub);
 
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
   auto trace_provider = opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider>(
       opentelemetry::sdk::trace::TracerProviderFactory::Create(
           opentelemetry::sdk::trace::SimpleSpanProcessorFactory::Create(
               GetExporter(trace_stub_interface))));
+#else
+  auto trace_provider = opentelemetry::nostd::shared_ptr<opentelemetry::sdk::trace::TracerProvider>(
+      opentelemetry::sdk::trace::TracerProviderFactory::Create(
+          opentelemetry::sdk::trace::SimpleSpanProcessorFactory::Create(
+              GetExporter(trace_stub_interface))));
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
 
   // Trace and Logs should both receive datas when links static gRPC on ELF ABI.
   EXPECT_CALL(*trace_mock_stub, Export(_, _, _))
@@ -331,7 +338,7 @@ TEST_F(OtlpGrpcLogRecordExporterTestPeer, ExportIntegrationTest)
   opentelemetry::trace::Provider::SetTracerProvider(
       opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider>(
           new opentelemetry::trace::NoopTracerProvider()));
-  trace_provider = opentelemetry::nostd::shared_ptr<opentelemetry::trace::TracerProvider>();
+  trace_provider = opentelemetry::nostd::shared_ptr<opentelemetry::sdk::trace::TracerProvider>();
 }
 
 }  // namespace otlp
diff --git a/exporters/otlp/test/otlp_http_exporter_test.cc b/exporters/otlp/test/otlp_http_exporter_test.cc
index 8f4b938b78..e4f69f502b 100644
--- a/exporters/otlp/test/otlp_http_exporter_test.cc
+++ b/exporters/otlp/test/otlp_http_exporter_test.cc
@@ -135,7 +135,7 @@ class OtlpHttpExporterTestPeer : public ::testing::Test
 
     auto processor = std::unique_ptr<sdk::trace::SpanProcessor>(
         new sdk::trace::BatchSpanProcessor(std::move(exporter), processor_opts));
-    auto provider = nostd::shared_ptr<trace::TracerProvider>(
+    auto provider = nostd::shared_ptr<sdk::trace::TracerProvider>(
         new sdk::trace::TracerProvider(std::move(processor), resource));
 
     std::string report_trace_id;
@@ -190,7 +190,7 @@ class OtlpHttpExporterTestPeer : public ::testing::Test
     child_span->End();
     parent_span->End();
 
-    static_cast<sdk::trace::TracerProvider *>(provider.get())->ForceFlush();
+    provider->ForceFlush();
   }
 
 #  ifdef ENABLE_ASYNC_EXPORT
@@ -226,7 +226,7 @@ class OtlpHttpExporterTestPeer : public ::testing::Test
 
     auto processor = std::unique_ptr<sdk::trace::SpanProcessor>(
         new sdk::trace::BatchSpanProcessor(std::move(exporter), processor_opts));
-    auto provider = nostd::shared_ptr<trace::TracerProvider>(
+    auto provider = nostd::shared_ptr<sdk::trace::TracerProvider>(
         new sdk::trace::TracerProvider(std::move(processor), resource));
 
     std::string report_trace_id;
@@ -285,7 +285,7 @@ class OtlpHttpExporterTestPeer : public ::testing::Test
     child_span->End();
     parent_span->End();
 
-    static_cast<sdk::trace::TracerProvider *>(provider.get())->ForceFlush();
+    provider->ForceFlush();
   }
 #  endif
 
@@ -321,7 +321,7 @@ class OtlpHttpExporterTestPeer : public ::testing::Test
 
     auto processor = std::unique_ptr<sdk::trace::SpanProcessor>(
         new sdk::trace::BatchSpanProcessor(std::move(exporter), processor_opts));
-    auto provider = nostd::shared_ptr<trace::TracerProvider>(
+    auto provider = nostd::shared_ptr<sdk::trace::TracerProvider>(
         new sdk::trace::TracerProvider(std::move(processor), resource));
 
     std::string report_trace_id;
@@ -366,7 +366,7 @@ class OtlpHttpExporterTestPeer : public ::testing::Test
     child_span->End();
     parent_span->End();
 
-    static_cast<sdk::trace::TracerProvider *>(provider.get())->ForceFlush();
+    provider->ForceFlush();
   }
 
 #  ifdef ENABLE_ASYNC_EXPORT
@@ -402,7 +402,7 @@ class OtlpHttpExporterTestPeer : public ::testing::Test
 
     auto processor = std::unique_ptr<sdk::trace::SpanProcessor>(
         new sdk::trace::BatchSpanProcessor(std::move(exporter), processor_opts));
-    auto provider = nostd::shared_ptr<trace::TracerProvider>(
+    auto provider = nostd::shared_ptr<sdk::trace::TracerProvider>(
         new sdk::trace::TracerProvider(std::move(processor), resource));
 
     std::string report_trace_id;
@@ -452,7 +452,7 @@ class OtlpHttpExporterTestPeer : public ::testing::Test
     child_span->End();
     parent_span->End();
 
-    static_cast<sdk::trace::TracerProvider *>(provider.get())->ForceFlush();
+    provider->ForceFlush();
   }
 #  endif
 };
diff --git a/ext/src/dll/input.src b/ext/src/dll/input.src
index 91ed42d303..98c4c140fe 100644
--- a/ext/src/dll/input.src
+++ b/ext/src/dll/input.src
@@ -9,8 +9,8 @@ Create@LoggerProviderFactory@logs@sdk@v1@opentelemetry
 Create@BatchLogRecordProcessorFactory@logs@sdk@v1@opentelemetry
 Create@SimpleLogRecordProcessorFactory@logs@sdk@v1@opentelemetry
 Create@MultiLogRecordProcessorFactory@logs@sdk@v1@opentelemetry
-ForceFlush@TracerProvider@trace@sdk@v1@opentelemetry
-ForceFlush@LoggerProvider@logs@sdk@v1@opentelemetry
+TracerProvider@trace@sdk@v1@opentelemetry
+LoggerProvider@logs@sdk@v1@opentelemetry
 OStreamLogRecordExporter@logs@exporter@v1@opentelemetry
 Create@OStreamMetricExporterFactory@metrics@exporter@v1@opentelemetry
 Create@PeriodicExportingMetricReaderFactory@metrics@sdk@v1@opentelemetry
@@ -21,6 +21,7 @@ Create@MeterSelectorFactory@metrics@sdk@v1@opentelemetry
 Create@InstrumentSelectorFactory@metrics@sdk@v1@opentelemetry
 AddMetricReader@MeterContext@metrics@sdk@v1@opentelemetry
 AddMetricReader@MeterProvider@metrics@sdk@v1@opentelemetry
+MeterProvider@metrics@sdk@v1@opentelemetry
 AddView@MeterProvider@metrics@sdk@v1@opentelemetry
 
 #if defined(WITH_OTLP_GRPC) || defined(WITH_OTLP_HTTP)
@@ -64,4 +65,4 @@ GetOtlpDefaultHttpTracesEndpoint@otlp@exporter@v1@opentelemetry
 GetOtlpDefaultHttpMetricsEndpoint@otlp@exporter@v1@opentelemetry
 GetOtlpDefaultHttpLogsEndpoint@otlp@exporter@v1@opentelemetry
 #endif  // defined(WITH_OTLP_HTTP)
-// clang-format on
\ No newline at end of file
+// clang-format on
diff --git a/functional/otlp/func_http_main.cc b/functional/otlp/func_http_main.cc
index d584a85687..9cd3585668 100644
--- a/functional/otlp/func_http_main.cc
+++ b/functional/otlp/func_http_main.cc
@@ -173,8 +173,6 @@ void payload()
   auto span = tracer->StartSpan(k_span_name);
   span->SetAttribute(k_attr_test_name, opt_test_name);
   span->End();
-
-  tracer->ForceFlushWithMicroseconds(1000000);
 }
 
 void cleanup()
diff --git a/sdk/include/opentelemetry/sdk/logs/event_logger_provider.h b/sdk/include/opentelemetry/sdk/logs/event_logger_provider.h
index 2f3d2a0afd..4572647356 100644
--- a/sdk/include/opentelemetry/sdk/logs/event_logger_provider.h
+++ b/sdk/include/opentelemetry/sdk/logs/event_logger_provider.h
@@ -20,7 +20,8 @@ namespace logs
 class EventLogger;
 class Logger;
 
-class EventLoggerProvider final : public opentelemetry::logs::EventLoggerProvider
+class OPENTELEMETRY_EXPORT EventLoggerProvider final
+    : public opentelemetry::logs::EventLoggerProvider
 {
 public:
   EventLoggerProvider() noexcept;
diff --git a/sdk/include/opentelemetry/sdk/logs/event_logger_provider_factory.h b/sdk/include/opentelemetry/sdk/logs/event_logger_provider_factory.h
index 0b8c066fc6..621cbea6c8 100644
--- a/sdk/include/opentelemetry/sdk/logs/event_logger_provider_factory.h
+++ b/sdk/include/opentelemetry/sdk/logs/event_logger_provider_factory.h
@@ -4,14 +4,11 @@
 #pragma once
 
 #include <memory>
+
+#include "opentelemetry/sdk/logs/event_logger_provider.h"
 #include "opentelemetry/version.h"
 
 OPENTELEMETRY_BEGIN_NAMESPACE
-namespace logs
-{
-class EventLoggerProvider;
-}  // namespace logs
-
 namespace sdk
 {
 namespace logs
@@ -26,7 +23,17 @@ class EventLoggerProviderFactory
   /**
    * Create a EventLoggerProvider.
    */
+
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+
+#  ifndef OPENTELEMETRY_NO_DEPRECATED_CODE
+  OPENTELEMETRY_DEPRECATED
   static std::unique_ptr<opentelemetry::logs::EventLoggerProvider> Create();
+#  endif /* OPENTELEMETRY_NO_DEPRECATED_CODE */
+
+#else
+  static std::unique_ptr<opentelemetry::sdk::logs::EventLoggerProvider> Create();
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
 };
 
 }  // namespace logs
diff --git a/sdk/include/opentelemetry/sdk/logs/logger_provider.h b/sdk/include/opentelemetry/sdk/logs/logger_provider.h
index 0ab5683d3e..bced6061f5 100644
--- a/sdk/include/opentelemetry/sdk/logs/logger_provider.h
+++ b/sdk/include/opentelemetry/sdk/logs/logger_provider.h
@@ -26,7 +26,7 @@ class Logger;
 class LoggerContext;
 class LogRecordProcessor;
 
-class LoggerProvider final : public opentelemetry::logs::LoggerProvider
+class OPENTELEMETRY_EXPORT LoggerProvider final : public opentelemetry::logs::LoggerProvider
 {
 public:
   /**
diff --git a/sdk/include/opentelemetry/sdk/logs/logger_provider_factory.h b/sdk/include/opentelemetry/sdk/logs/logger_provider_factory.h
index 987a09fe16..7b8f636e68 100644
--- a/sdk/include/opentelemetry/sdk/logs/logger_provider_factory.h
+++ b/sdk/include/opentelemetry/sdk/logs/logger_provider_factory.h
@@ -6,25 +6,17 @@
 #include <memory>
 #include <vector>
 
+#include "opentelemetry/sdk/logs/logger_context.h"
+#include "opentelemetry/sdk/logs/logger_provider.h"
+#include "opentelemetry/sdk/logs/processor.h"
+#include "opentelemetry/sdk/resource/resource.h"
 #include "opentelemetry/version.h"
 
 OPENTELEMETRY_BEGIN_NAMESPACE
-namespace logs
-{
-class LoggerProvider;
-}  // namespace logs
-
 namespace sdk
 {
-namespace resource
-{
-class Resource;
-}  // namespace resource
-
 namespace logs
 {
-class LoggerContext;
-class LogRecordProcessor;
 
 /**
  * Factory class for LoggerProvider.
@@ -32,37 +24,69 @@ class LogRecordProcessor;
 class OPENTELEMETRY_EXPORT LoggerProviderFactory
 {
 public:
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+
+#  ifndef OPENTELEMETRY_NO_DEPRECATED_CODE
+
+  OPENTELEMETRY_DEPRECATED
+  static std::unique_ptr<opentelemetry::logs::LoggerProvider> Create(
+      std::unique_ptr<LogRecordProcessor> &&processor);
+
+  OPENTELEMETRY_DEPRECATED
+  static std::unique_ptr<opentelemetry::logs::LoggerProvider> Create(
+      std::unique_ptr<LogRecordProcessor> &&processor,
+      const opentelemetry::sdk::resource::Resource &resource);
+
+  OPENTELEMETRY_DEPRECATED
+  static std::unique_ptr<opentelemetry::logs::LoggerProvider> Create(
+      std::vector<std::unique_ptr<LogRecordProcessor>> &&processors);
+
+  OPENTELEMETRY_DEPRECATED
+  static std::unique_ptr<opentelemetry::logs::LoggerProvider> Create(
+      std::vector<std::unique_ptr<LogRecordProcessor>> &&processors,
+      const opentelemetry::sdk::resource::Resource &resource);
+
+  OPENTELEMETRY_DEPRECATED
+  static std::unique_ptr<opentelemetry::logs::LoggerProvider> Create(
+      std::unique_ptr<LoggerContext> context);
+
+#  endif /* OPENTELEMETRY_NO_DEPRECATED_CODE */
+
+#else
+
   /**
    * Create a LoggerProvider.
    */
-  static std::unique_ptr<opentelemetry::logs::LoggerProvider> Create(
+  static std::unique_ptr<opentelemetry::sdk::logs::LoggerProvider> Create(
       std::unique_ptr<LogRecordProcessor> &&processor);
 
   /**
    * Create a LoggerProvider.
    */
-  static std::unique_ptr<opentelemetry::logs::LoggerProvider> Create(
+  static std::unique_ptr<opentelemetry::sdk::logs::LoggerProvider> Create(
       std::unique_ptr<LogRecordProcessor> &&processor,
       const opentelemetry::sdk::resource::Resource &resource);
 
   /**
    * Create a LoggerProvider.
    */
-  static std::unique_ptr<opentelemetry::logs::LoggerProvider> Create(
+  static std::unique_ptr<opentelemetry::sdk::logs::LoggerProvider> Create(
       std::vector<std::unique_ptr<LogRecordProcessor>> &&processors);
 
   /**
    * Create a LoggerProvider.
    */
-  static std::unique_ptr<opentelemetry::logs::LoggerProvider> Create(
+  static std::unique_ptr<opentelemetry::sdk::logs::LoggerProvider> Create(
       std::vector<std::unique_ptr<LogRecordProcessor>> &&processors,
       const opentelemetry::sdk::resource::Resource &resource);
 
   /**
    * Create a LoggerProvider.
    */
-  static std::unique_ptr<opentelemetry::logs::LoggerProvider> Create(
+  static std::unique_ptr<opentelemetry::sdk::logs::LoggerProvider> Create(
       std::unique_ptr<LoggerContext> context);
+
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
 };
 
 }  // namespace logs
diff --git a/sdk/include/opentelemetry/sdk/metrics/meter_context_factory.h b/sdk/include/opentelemetry/sdk/metrics/meter_context_factory.h
index 13e3a9f290..1185a6075a 100644
--- a/sdk/include/opentelemetry/sdk/metrics/meter_context_factory.h
+++ b/sdk/include/opentelemetry/sdk/metrics/meter_context_factory.h
@@ -3,21 +3,19 @@
 
 #pragma once
 
+#include <memory>
+
+#include "opentelemetry/sdk/metrics/meter_context.h"
+#include "opentelemetry/sdk/metrics/view/view_registry.h"
 #include "opentelemetry/sdk/resource/resource.h"
 #include "opentelemetry/version.h"
 
-#include <memory>
-
 OPENTELEMETRY_BEGIN_NAMESPACE
 namespace sdk
 {
 namespace metrics
 {
 
-// forward declaration
-class MeterContext;
-class ViewRegistry;
-
 /**
  * Factory class for MeterContext.
  */
diff --git a/sdk/include/opentelemetry/sdk/metrics/meter_provider_factory.h b/sdk/include/opentelemetry/sdk/metrics/meter_provider_factory.h
index 15aa13badc..cb9106ddc8 100644
--- a/sdk/include/opentelemetry/sdk/metrics/meter_provider_factory.h
+++ b/sdk/include/opentelemetry/sdk/metrics/meter_provider_factory.h
@@ -7,6 +7,7 @@
 
 #include "opentelemetry/metrics/meter_provider.h"
 #include "opentelemetry/sdk/metrics/meter_context.h"
+#include "opentelemetry/sdk/metrics/meter_provider.h"
 #include "opentelemetry/sdk/metrics/view/view_registry.h"
 #include "opentelemetry/sdk/resource/resource.h"
 #include "opentelemetry/version.h"
@@ -17,56 +18,46 @@ namespace sdk
 namespace metrics
 {
 
-/*
-  MAINTAINER:
+class OPENTELEMETRY_EXPORT MeterProviderFactory
+{
+public:
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
 
-  The best design is to return an API object:
-    std::unique_ptr<opentelemetry::metrics::MeterProvider>
-  to shield the calling application from SDK implementation details.
+#  ifndef OPENTELEMETRY_NO_DEPRECATED_CODE
 
-  This however assumes that the SDK object can be created in one call,
-  instead of making multiple calls to the SDK to setup a meter provider.
+  OPENTELEMETRY_DEPRECATED
+  static std::unique_ptr<opentelemetry::metrics::MeterProvider> Create();
 
-  Because existing code, already advertised in examples:
-  - creates an instance of sdk::MeterProvider
-  - calls SDK methods on it to continue the setup, such as
-    MeterProvider::AddMetricReader()
-    MeterProvider::AddView()
-  existing applications will need to access the underlying
-  class sdk::MeterProvider.
+  OPENTELEMETRY_DEPRECATED
+  static std::unique_ptr<opentelemetry::metrics::MeterProvider> Create(
+      std::unique_ptr<ViewRegistry> views);
 
-  We need to decide whether to return:
-  - (1) std::unique_ptr<opentelemetry::metrics::MeterProvider>
-  - (2) std::unique_ptr<opentelemetry::metrics::sdk::MeterProvider>
-  from a Create() method.
+  OPENTELEMETRY_DEPRECATED
+  static std::unique_ptr<opentelemetry::metrics::MeterProvider> Create(
+      std::unique_ptr<ViewRegistry> views,
+      const opentelemetry::sdk::resource::Resource &resource);
 
-  In the long term, (1) is better, but forces users to use a down cast,
-  to make additional calls to the SDK class, until such a time when
-  the builders can take all the necessary input at once,
-  for example using a std::vector<MetricReader> to add all readers.
+  OPENTELEMETRY_DEPRECATED
+  static std::unique_ptr<opentelemetry::metrics::MeterProvider> Create(
+      std::unique_ptr<sdk::metrics::MeterContext> context);
 
-  Implementing (2) is forcing technical debt, and prevents the
-  calling application configuring the SDK to be decoupled from it,
-  making deployment of shared libraries much more difficult.
+#  endif /* OPENTELEMETRY_NO_DEPRECATED_CODE */
 
-  The design choice here is to return (1) an API MeterProvider,
-  even if this forces, temporarily, existing applications to use a downcast.
-*/
+#else
 
-class OPENTELEMETRY_EXPORT MeterProviderFactory
-{
-public:
-  static std::unique_ptr<opentelemetry::metrics::MeterProvider> Create();
+  static std::unique_ptr<opentelemetry::sdk::metrics::MeterProvider> Create();
 
-  static std::unique_ptr<opentelemetry::metrics::MeterProvider> Create(
+  static std::unique_ptr<opentelemetry::sdk::metrics::MeterProvider> Create(
       std::unique_ptr<ViewRegistry> views);
 
-  static std::unique_ptr<opentelemetry::metrics::MeterProvider> Create(
+  static std::unique_ptr<opentelemetry::sdk::metrics::MeterProvider> Create(
       std::unique_ptr<ViewRegistry> views,
       const opentelemetry::sdk::resource::Resource &resource);
 
-  static std::unique_ptr<opentelemetry::metrics::MeterProvider> Create(
+  static std::unique_ptr<opentelemetry::sdk::metrics::MeterProvider> Create(
       std::unique_ptr<sdk::metrics::MeterContext> context);
+
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
 };
 
 }  // namespace metrics
diff --git a/sdk/include/opentelemetry/sdk/trace/tracer.h b/sdk/include/opentelemetry/sdk/trace/tracer.h
index 778ffe8173..fb8342c1d5 100644
--- a/sdk/include/opentelemetry/sdk/trace/tracer.h
+++ b/sdk/include/opentelemetry/sdk/trace/tracer.h
@@ -45,9 +45,38 @@ class Tracer final : public opentelemetry::trace::Tracer,
       const opentelemetry::trace::SpanContextKeyValueIterable &links,
       const opentelemetry::trace::StartSpanOptions &options = {}) noexcept override;
 
+#if OPENTELEMETRY_ABI_VERSION_NO >= 2
+  /**
+   * Force any buffered spans to flush.
+   * @param timeout to complete the flush
+   */
+  template <class Rep, class Period>
+  void ForceFlush(std::chrono::duration<Rep, Period> timeout) noexcept
+  {
+    this->ForceFlushWithMicroseconds(static_cast<uint64_t>(
+        std::chrono::duration_cast<std::chrono::microseconds>(timeout).count()));
+  }
+
+  void ForceFlushWithMicroseconds(uint64_t timeout) noexcept;
+
+  /**
+   * ForceFlush any buffered spans and stop reporting spans.
+   * @param timeout to complete the flush
+   */
+  template <class Rep, class Period>
+  void Close(std::chrono::duration<Rep, Period> timeout) noexcept
+  {
+    this->CloseWithMicroseconds(static_cast<uint64_t>(
+        std::chrono::duration_cast<std::chrono::microseconds>(timeout).count()));
+  }
+
+  void CloseWithMicroseconds(uint64_t timeout) noexcept;
+#else
+  /* Exposed in the API in ABI version 1, but does not belong to the API */
   void ForceFlushWithMicroseconds(uint64_t timeout) noexcept override;
 
   void CloseWithMicroseconds(uint64_t timeout) noexcept override;
+#endif
 
   /** Returns the configured span processor. */
   SpanProcessor &GetProcessor() noexcept { return context_->GetProcessor(); }
diff --git a/sdk/include/opentelemetry/sdk/trace/tracer_provider.h b/sdk/include/opentelemetry/sdk/trace/tracer_provider.h
index e0f3ce0c4c..0d05a94043 100644
--- a/sdk/include/opentelemetry/sdk/trace/tracer_provider.h
+++ b/sdk/include/opentelemetry/sdk/trace/tracer_provider.h
@@ -28,7 +28,7 @@ namespace sdk
 namespace trace
 {
 
-class TracerProvider final : public opentelemetry::trace::TracerProvider
+class OPENTELEMETRY_EXPORT TracerProvider final : public opentelemetry::trace::TracerProvider
 {
 public:
   /**
diff --git a/sdk/include/opentelemetry/sdk/trace/tracer_provider_factory.h b/sdk/include/opentelemetry/sdk/trace/tracer_provider_factory.h
index 17f7ea395a..7c4b6903de 100644
--- a/sdk/include/opentelemetry/sdk/trace/tracer_provider_factory.h
+++ b/sdk/include/opentelemetry/sdk/trace/tracer_provider_factory.h
@@ -11,6 +11,7 @@
 #include "opentelemetry/sdk/trace/processor.h"
 #include "opentelemetry/sdk/trace/sampler.h"
 #include "opentelemetry/sdk/trace/tracer_context.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
 #include "opentelemetry/trace/tracer_provider.h"
 #include "opentelemetry/version.h"
 
@@ -27,20 +28,28 @@ namespace trace
 class OPENTELEMETRY_EXPORT TracerProviderFactory
 {
 public:
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+
+#  ifndef OPENTELEMETRY_NO_DEPRECATED_CODE
+
   /* Serie of builders with a single processor. */
 
+  OPENTELEMETRY_DEPRECATED
   static std::unique_ptr<opentelemetry::trace::TracerProvider> Create(
       std::unique_ptr<SpanProcessor> processor);
 
+  OPENTELEMETRY_DEPRECATED
   static std::unique_ptr<opentelemetry::trace::TracerProvider> Create(
       std::unique_ptr<SpanProcessor> processor,
       const opentelemetry::sdk::resource::Resource &resource);
 
+  OPENTELEMETRY_DEPRECATED
   static std::unique_ptr<opentelemetry::trace::TracerProvider> Create(
       std::unique_ptr<SpanProcessor> processor,
       const opentelemetry::sdk::resource::Resource &resource,
       std::unique_ptr<Sampler> sampler);
 
+  OPENTELEMETRY_DEPRECATED
   static std::unique_ptr<opentelemetry::trace::TracerProvider> Create(
       std::unique_ptr<SpanProcessor> processor,
       const opentelemetry::sdk::resource::Resource &resource,
@@ -49,18 +58,22 @@ class OPENTELEMETRY_EXPORT TracerProviderFactory
 
   /* Serie of builders with a vector of processor. */
 
+  OPENTELEMETRY_DEPRECATED
   static std::unique_ptr<opentelemetry::trace::TracerProvider> Create(
       std::vector<std::unique_ptr<SpanProcessor>> &&processors);
 
+  OPENTELEMETRY_DEPRECATED
   static std::unique_ptr<opentelemetry::trace::TracerProvider> Create(
       std::vector<std::unique_ptr<SpanProcessor>> &&processors,
       const opentelemetry::sdk::resource::Resource &resource);
 
+  OPENTELEMETRY_DEPRECATED
   static std::unique_ptr<opentelemetry::trace::TracerProvider> Create(
       std::vector<std::unique_ptr<SpanProcessor>> &&processors,
       const opentelemetry::sdk::resource::Resource &resource,
       std::unique_ptr<Sampler> sampler);
 
+  OPENTELEMETRY_DEPRECATED
   static std::unique_ptr<opentelemetry::trace::TracerProvider> Create(
       std::vector<std::unique_ptr<SpanProcessor>> &&processors,
       const opentelemetry::sdk::resource::Resource &resource,
@@ -69,8 +82,60 @@ class OPENTELEMETRY_EXPORT TracerProviderFactory
 
   /* Create with a tracer context. */
 
+  OPENTELEMETRY_DEPRECATED
   static std::unique_ptr<opentelemetry::trace::TracerProvider> Create(
       std::unique_ptr<TracerContext> context);
+
+#  endif /* OPENTELEMETRY_NO_DEPRECATED_CODE */
+
+#else
+
+  /* Serie of builders with a single processor. */
+
+  static std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> Create(
+      std::unique_ptr<SpanProcessor> processor);
+
+  static std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> Create(
+      std::unique_ptr<SpanProcessor> processor,
+      const opentelemetry::sdk::resource::Resource &resource);
+
+  static std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> Create(
+      std::unique_ptr<SpanProcessor> processor,
+      const opentelemetry::sdk::resource::Resource &resource,
+      std::unique_ptr<Sampler> sampler);
+
+  static std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> Create(
+      std::unique_ptr<SpanProcessor> processor,
+      const opentelemetry::sdk::resource::Resource &resource,
+      std::unique_ptr<Sampler> sampler,
+      std::unique_ptr<IdGenerator> id_generator);
+
+  /* Serie of builders with a vector of processor. */
+
+  static std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> Create(
+      std::vector<std::unique_ptr<SpanProcessor>> &&processors);
+
+  static std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> Create(
+      std::vector<std::unique_ptr<SpanProcessor>> &&processors,
+      const opentelemetry::sdk::resource::Resource &resource);
+
+  static std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> Create(
+      std::vector<std::unique_ptr<SpanProcessor>> &&processors,
+      const opentelemetry::sdk::resource::Resource &resource,
+      std::unique_ptr<Sampler> sampler);
+
+  static std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> Create(
+      std::vector<std::unique_ptr<SpanProcessor>> &&processors,
+      const opentelemetry::sdk::resource::Resource &resource,
+      std::unique_ptr<Sampler> sampler,
+      std::unique_ptr<IdGenerator> id_generator);
+
+  /* Create with a tracer context. */
+
+  static std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> Create(
+      std::unique_ptr<TracerContext> context);
+
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
 };
 
 }  // namespace trace
diff --git a/sdk/src/logs/event_logger_provider_factory.cc b/sdk/src/logs/event_logger_provider_factory.cc
index 0c9eff4570..7f5c8cadf1 100644
--- a/sdk/src/logs/event_logger_provider_factory.cc
+++ b/sdk/src/logs/event_logger_provider_factory.cc
@@ -3,7 +3,7 @@
 
 #include "opentelemetry/sdk/logs/event_logger_provider_factory.h"
 #include "opentelemetry/sdk/logs/event_logger_provider.h"
-#include "opentelemetry/sdk/resource/resource.h"
+#include "opentelemetry/version.h"
 
 OPENTELEMETRY_BEGIN_NAMESPACE
 namespace sdk
@@ -11,11 +11,22 @@ namespace sdk
 namespace logs
 {
 
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+
 std::unique_ptr<opentelemetry::logs::EventLoggerProvider> EventLoggerProviderFactory::Create()
 {
   return std::unique_ptr<opentelemetry::logs::EventLoggerProvider>(new EventLoggerProvider());
 }
 
+#else
+
+std::unique_ptr<opentelemetry::sdk::logs::EventLoggerProvider> EventLoggerProviderFactory::Create()
+{
+  return std::unique_ptr<opentelemetry::sdk::logs::EventLoggerProvider>(new EventLoggerProvider());
+}
+
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
+
 }  // namespace logs
 }  // namespace sdk
 OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/src/logs/logger_provider_factory.cc b/sdk/src/logs/logger_provider_factory.cc
index 76e662a909..8c169866ff 100644
--- a/sdk/src/logs/logger_provider_factory.cc
+++ b/sdk/src/logs/logger_provider_factory.cc
@@ -1,9 +1,11 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
-#include "opentelemetry/sdk/logs/logger_provider_factory.h"
+#include <utility>
+
 #include "opentelemetry/sdk/logs/logger_context.h"
 #include "opentelemetry/sdk/logs/logger_provider.h"
+#include "opentelemetry/sdk/logs/logger_provider_factory.h"
 #include "opentelemetry/sdk/resource/resource.h"
 
 OPENTELEMETRY_BEGIN_NAMESPACE
@@ -12,6 +14,8 @@ namespace sdk
 namespace logs
 {
 
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+
 std::unique_ptr<opentelemetry::logs::LoggerProvider> LoggerProviderFactory::Create(
     std::unique_ptr<LogRecordProcessor> &&processor)
 {
@@ -52,6 +56,50 @@ std::unique_ptr<opentelemetry::logs::LoggerProvider> LoggerProviderFactory::Crea
   return provider;
 }
 
+#else
+
+std::unique_ptr<opentelemetry::sdk::logs::LoggerProvider> LoggerProviderFactory::Create(
+    std::unique_ptr<LogRecordProcessor> &&processor)
+{
+  auto resource = opentelemetry::sdk::resource::Resource::Create({});
+  return Create(std::move(processor), resource);
+}
+
+std::unique_ptr<opentelemetry::sdk::logs::LoggerProvider> LoggerProviderFactory::Create(
+    std::unique_ptr<LogRecordProcessor> &&processor,
+    const opentelemetry::sdk::resource::Resource &resource)
+{
+  std::unique_ptr<opentelemetry::sdk::logs::LoggerProvider> provider(
+      new LoggerProvider(std::move(processor), resource));
+  return provider;
+}
+
+std::unique_ptr<opentelemetry::sdk::logs::LoggerProvider> LoggerProviderFactory::Create(
+    std::vector<std::unique_ptr<LogRecordProcessor>> &&processors)
+{
+  auto resource = opentelemetry::sdk::resource::Resource::Create({});
+  return Create(std::move(processors), resource);
+}
+
+std::unique_ptr<opentelemetry::sdk::logs::LoggerProvider> LoggerProviderFactory::Create(
+    std::vector<std::unique_ptr<LogRecordProcessor>> &&processors,
+    const opentelemetry::sdk::resource::Resource &resource)
+{
+  std::unique_ptr<opentelemetry::sdk::logs::LoggerProvider> provider(
+      new LoggerProvider(std::move(processors), resource));
+  return provider;
+}
+
+std::unique_ptr<opentelemetry::sdk::logs::LoggerProvider> LoggerProviderFactory::Create(
+    std::unique_ptr<LoggerContext> context)
+{
+  std::unique_ptr<opentelemetry::sdk::logs::LoggerProvider> provider(
+      new LoggerProvider(std::move(context)));
+  return provider;
+}
+
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
+
 }  // namespace logs
 }  // namespace sdk
 OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/src/metrics/meter_provider_factory.cc b/sdk/src/metrics/meter_provider_factory.cc
index 43c060e5f9..7749a13124 100644
--- a/sdk/src/metrics/meter_provider_factory.cc
+++ b/sdk/src/metrics/meter_provider_factory.cc
@@ -1,23 +1,25 @@
 // Copyright The OpenTelemetry Authors
 // SPDX-License-Identifier: Apache-2.0
 
+#include <memory>
 #include <utility>
 
-#include "opentelemetry/metrics/meter.h"
+#include "opentelemetry/sdk/metrics/meter_context.h"
 #include "opentelemetry/sdk/metrics/meter_provider.h"
 #include "opentelemetry/sdk/metrics/meter_provider_factory.h"
+#include "opentelemetry/sdk/metrics/view/view_registry.h"
 #include "opentelemetry/sdk/metrics/view/view_registry_factory.h"
+#include "opentelemetry/sdk/resource/resource.h"
 #include "opentelemetry/version.h"
 
-namespace resource    = opentelemetry::sdk::resource;
-namespace metrics_sdk = opentelemetry::sdk::metrics;
-
 OPENTELEMETRY_BEGIN_NAMESPACE
 namespace sdk
 {
 namespace metrics
 {
 
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+
 std::unique_ptr<opentelemetry::metrics::MeterProvider> MeterProviderFactory::Create()
 {
   auto views = ViewRegistryFactory::Create();
@@ -36,7 +38,7 @@ std::unique_ptr<opentelemetry::metrics::MeterProvider> MeterProviderFactory::Cre
     const opentelemetry::sdk::resource::Resource &resource)
 {
   std::unique_ptr<opentelemetry::metrics::MeterProvider> provider(
-      new metrics_sdk::MeterProvider(std::move(views), resource));
+      new opentelemetry::sdk::metrics::MeterProvider(std::move(views), resource));
   return provider;
 }
 
@@ -44,10 +46,44 @@ std::unique_ptr<opentelemetry::metrics::MeterProvider> MeterProviderFactory::Cre
     std::unique_ptr<sdk::metrics::MeterContext> context)
 {
   std::unique_ptr<opentelemetry::metrics::MeterProvider> provider(
-      new metrics_sdk::MeterProvider(std::move(context)));
+      new opentelemetry::sdk::metrics::MeterProvider(std::move(context)));
+  return provider;
+}
+
+#else
+
+std::unique_ptr<opentelemetry::sdk::metrics::MeterProvider> MeterProviderFactory::Create()
+{
+  auto views = ViewRegistryFactory::Create();
+  return Create(std::move(views));
+}
+
+std::unique_ptr<opentelemetry::sdk::metrics::MeterProvider> MeterProviderFactory::Create(
+    std::unique_ptr<ViewRegistry> views)
+{
+  auto resource = opentelemetry::sdk::resource::Resource::Create({});
+  return Create(std::move(views), resource);
+}
+
+std::unique_ptr<opentelemetry::sdk::metrics::MeterProvider> MeterProviderFactory::Create(
+    std::unique_ptr<ViewRegistry> views,
+    const opentelemetry::sdk::resource::Resource &resource)
+{
+  std::unique_ptr<opentelemetry::sdk::metrics::MeterProvider> provider(
+      new opentelemetry::sdk::metrics::MeterProvider(std::move(views), resource));
   return provider;
 }
 
+std::unique_ptr<opentelemetry::sdk::metrics::MeterProvider> MeterProviderFactory::Create(
+    std::unique_ptr<sdk::metrics::MeterContext> context)
+{
+  std::unique_ptr<opentelemetry::sdk::metrics::MeterProvider> provider(
+      new opentelemetry::sdk::metrics::MeterProvider(std::move(context)));
+  return provider;
+}
+
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
+
 }  // namespace metrics
 }  // namespace sdk
 OPENTELEMETRY_END_NAMESPACE
diff --git a/sdk/src/trace/tracer_provider_factory.cc b/sdk/src/trace/tracer_provider_factory.cc
index d22330b866..eeb18a1e59 100644
--- a/sdk/src/trace/tracer_provider_factory.cc
+++ b/sdk/src/trace/tracer_provider_factory.cc
@@ -14,27 +14,24 @@
 #include "opentelemetry/sdk/trace/tracer_context.h"
 #include "opentelemetry/sdk/trace/tracer_provider.h"
 #include "opentelemetry/sdk/trace/tracer_provider_factory.h"
-#include "opentelemetry/trace/span_id.h"
-#include "opentelemetry/trace/tracer_provider.h"
 #include "opentelemetry/version.h"
 
-namespace trace_api = opentelemetry::trace;
-namespace trace_sdk = opentelemetry::sdk::trace;
-
 OPENTELEMETRY_BEGIN_NAMESPACE
 namespace sdk
 {
 namespace trace
 {
 
-std::unique_ptr<trace_api::TracerProvider> TracerProviderFactory::Create(
+#ifdef OPENTELEMETRY_DEPRECATED_SDK_FACTORY
+
+std::unique_ptr<opentelemetry::trace::TracerProvider> TracerProviderFactory::Create(
     std::unique_ptr<SpanProcessor> processor)
 {
   auto resource = opentelemetry::sdk::resource::Resource::Create({});
   return Create(std::move(processor), resource);
 }
 
-std::unique_ptr<trace_api::TracerProvider> TracerProviderFactory::Create(
+std::unique_ptr<opentelemetry::trace::TracerProvider> TracerProviderFactory::Create(
     std::unique_ptr<SpanProcessor> processor,
     const opentelemetry::sdk::resource::Resource &resource)
 {
@@ -57,8 +54,9 @@ std::unique_ptr<opentelemetry::trace::TracerProvider> TracerProviderFactory::Cre
     std::unique_ptr<Sampler> sampler,
     std::unique_ptr<IdGenerator> id_generator)
 {
-  std::unique_ptr<trace_api::TracerProvider> provider(new trace_sdk::TracerProvider(
-      std::move(processor), resource, std::move(sampler), std::move(id_generator)));
+  std::unique_ptr<opentelemetry::trace::TracerProvider> provider(
+      new opentelemetry::sdk::trace::TracerProvider(std::move(processor), resource,
+                                                    std::move(sampler), std::move(id_generator)));
   return provider;
 }
 
@@ -92,19 +90,104 @@ std::unique_ptr<opentelemetry::trace::TracerProvider> TracerProviderFactory::Cre
     std::unique_ptr<Sampler> sampler,
     std::unique_ptr<IdGenerator> id_generator)
 {
-  std::unique_ptr<trace_api::TracerProvider> provider(new trace_sdk::TracerProvider(
-      std::move(processors), resource, std::move(sampler), std::move(id_generator)));
+  std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> provider(
+      new opentelemetry::sdk::trace::TracerProvider(std::move(processors), resource,
+                                                    std::move(sampler), std::move(id_generator)));
+  return provider;
+}
+
+std::unique_ptr<opentelemetry::trace::TracerProvider> TracerProviderFactory::Create(
+    std::unique_ptr<TracerContext> context)
+{
+  std::unique_ptr<opentelemetry::trace::TracerProvider> provider(
+      new opentelemetry::sdk::trace::TracerProvider(std::move(context)));
+  return provider;
+}
+
+#else
+
+std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> TracerProviderFactory::Create(
+    std::unique_ptr<SpanProcessor> processor)
+{
+  auto resource = opentelemetry::sdk::resource::Resource::Create({});
+  return Create(std::move(processor), resource);
+}
+
+std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> TracerProviderFactory::Create(
+    std::unique_ptr<SpanProcessor> processor,
+    const opentelemetry::sdk::resource::Resource &resource)
+{
+  auto sampler = AlwaysOnSamplerFactory::Create();
+  return Create(std::move(processor), resource, std::move(sampler));
+}
+
+std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> TracerProviderFactory::Create(
+    std::unique_ptr<SpanProcessor> processor,
+    const opentelemetry::sdk::resource::Resource &resource,
+    std::unique_ptr<Sampler> sampler)
+{
+  auto id_generator = RandomIdGeneratorFactory::Create();
+  return Create(std::move(processor), resource, std::move(sampler), std::move(id_generator));
+}
+
+std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> TracerProviderFactory::Create(
+    std::unique_ptr<SpanProcessor> processor,
+    const opentelemetry::sdk::resource::Resource &resource,
+    std::unique_ptr<Sampler> sampler,
+    std::unique_ptr<IdGenerator> id_generator)
+{
+  std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> provider(
+      new opentelemetry::sdk::trace::TracerProvider(std::move(processor), resource,
+                                                    std::move(sampler), std::move(id_generator)));
+  return provider;
+}
+
+std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> TracerProviderFactory::Create(
+    std::vector<std::unique_ptr<SpanProcessor>> &&processors)
+{
+  auto resource = opentelemetry::sdk::resource::Resource::Create({});
+  return Create(std::move(processors), resource);
+}
+
+std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> TracerProviderFactory::Create(
+    std::vector<std::unique_ptr<SpanProcessor>> &&processors,
+    const opentelemetry::sdk::resource::Resource &resource)
+{
+  auto sampler = AlwaysOnSamplerFactory::Create();
+  return Create(std::move(processors), resource, std::move(sampler));
+}
+
+std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> TracerProviderFactory::Create(
+    std::vector<std::unique_ptr<SpanProcessor>> &&processors,
+    const opentelemetry::sdk::resource::Resource &resource,
+    std::unique_ptr<Sampler> sampler)
+{
+  auto id_generator = RandomIdGeneratorFactory::Create();
+  return Create(std::move(processors), resource, std::move(sampler), std::move(id_generator));
+}
+
+std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> TracerProviderFactory::Create(
+    std::vector<std::unique_ptr<SpanProcessor>> &&processors,
+    const opentelemetry::sdk::resource::Resource &resource,
+    std::unique_ptr<Sampler> sampler,
+    std::unique_ptr<IdGenerator> id_generator)
+{
+  std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> provider(
+      new opentelemetry::sdk::trace::TracerProvider(std::move(processors), resource,
+                                                    std::move(sampler), std::move(id_generator)));
   return provider;
 }
 
-std::unique_ptr<trace_api::TracerProvider> TracerProviderFactory::Create(
+std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> TracerProviderFactory::Create(
     std::unique_ptr<TracerContext> context)
 {
-  std::unique_ptr<trace_api::TracerProvider> provider(
-      new trace_sdk::TracerProvider(std::move(context)));
+  std::unique_ptr<opentelemetry::sdk::trace::TracerProvider> provider(
+      new opentelemetry::sdk::trace::TracerProvider(std::move(context)));
   return provider;
 }
 
+#endif /* OPENTELEMETRY_DEPRECATED_SDK_FACTORY */
+
 }  // namespace trace
 }  // namespace sdk
 OPENTELEMETRY_END_NAMESPACE