Adding upstream version 18.2.2.upstream/18.2.2

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

143 files changed, 30258 insertions, 0 deletions

diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/CMakeLists.txt b/src/jaegertracing/opentelemetry-cpp/exporters/CMakeLists.txt
new file mode 100644
index 000000000..862d2c779
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/CMakeLists.txt
@@ -0,0 +1,40 @@
+# Copyright 2021, OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+if(WITH_OTLP)
+  add_subdirectory(otlp)
+endif()
+
+add_subdirectory(ostream)
+add_subdirectory(memory)
+
+if(WITH_PROMETHEUS)
+  add_subdirectory(prometheus)
+endif()
+
+if(WITH_ZIPKIN)
+  add_subdirectory(zipkin)
+endif()
+
+if(WITH_ELASTICSEARCH AND WITH_LOGS_PREVIEW)
+  add_subdirectory(elasticsearch)
+endif()
+
+if(WITH_ETW)
+  add_subdirectory(etw)
+endif()
+
+if(WITH_JAEGER)
+  add_subdirectory(jaeger)
+endif()
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/BUILD b/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/BUILD
new file mode 100644
index 000000000..78ff94d46
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/BUILD
@@ -0,0 +1,43 @@
+package(default_visibility = ["//visibility:public"])
+
+cc_library(
+    name = "es_log_exporter",
+    srcs = [
+        "src/es_log_exporter.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/elasticsearch/es_log_exporter.h",
+        "include/opentelemetry/exporters/elasticsearch/es_log_recordable.h",
+    ],
+    linkopts = select({
+        "//bazel:windows": [
+            "-DEFAULTLIB:advapi32.lib",
+            "-DEFAULTLIB:crypt32.lib",
+            "-DEFAULTLIB:Normaliz.lib",
+        ],
+        "//conditions:default": [],
+    }),
+    strip_include_prefix = "include",
+    tags = ["es"],
+    deps = [
+        "//ext:headers",
+        "//ext/src/http/client/curl:http_client_curl",
+        "//sdk/src/logs",
+        "@curl",
+        "@github_nlohmann_json//:json",
+    ],
+)
+
+cc_test(
+    name = "es_log_exporter_test",
+    srcs = ["test/es_log_exporter_test.cc"],
+    tags = [
+        "es",
+        "test",
+    ],
+    deps = [
+        ":es_log_exporter",
+        "@com_google_googletest//:gtest_main",
+        "@curl",
+    ],
+)
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/CMakeLists.txt b/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/CMakeLists.txt
new file mode 100644
index 000000000..ed6488316
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/CMakeLists.txt
@@ -0,0 +1,41 @@
+add_library(opentelemetry_exporter_elasticsearch_logs src/es_log_exporter.cc)
+
+set_target_properties(opentelemetry_exporter_elasticsearch_logs
+                      PROPERTIES EXPORT_NAME elasticsearch_log_exporter)
+
+target_include_directories(
+  opentelemetry_exporter_elasticsearch_logs
+  PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+         "$<INSTALL_INTERFACE:include>")
+
+target_link_libraries(
+  opentelemetry_exporter_elasticsearch_logs
+  PUBLIC opentelemetry_trace opentelemetry_logs opentelemetry_http_client_curl
+         nlohmann_json::nlohmann_json)
+
+install(
+  TARGETS opentelemetry_exporter_elasticsearch_logs
+  EXPORT "${PROJECT_NAME}-target"
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+install(
+  DIRECTORY include/opentelemetry/exporters/elasticsearch
+  DESTINATION include/opentelemetry/exporters
+  FILES_MATCHING
+  PATTERN "*.h"
+  PATTERN "es_log_recordable.h" EXCLUDE)
+
+if(BUILD_TESTING)
+  add_executable(es_log_exporter_test test/es_log_exporter_test.cc)
+
+  target_link_libraries(
+    es_log_exporter_test ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
+    opentelemetry_exporter_elasticsearch_logs)
+
+  gtest_add_tests(
+    TARGET es_log_exporter_test
+    TEST_PREFIX exporter.
+    TEST_LIST es_log_exporter_test)
+endif() # BUILD_TESTING
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/include/opentelemetry/exporters/elasticsearch/es_log_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/include/opentelemetry/exporters/elasticsearch/es_log_exporter.h
new file mode 100644
index 000000000..ea58807e9
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/include/opentelemetry/exporters/elasticsearch/es_log_exporter.h
@@ -0,0 +1,114 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifdef ENABLE_LOGS_PREVIEW
+
+#  include "nlohmann/json.hpp"
+#  include "opentelemetry/common/spin_lock_mutex.h"
+#  include "opentelemetry/ext/http/client/curl/http_client_curl.h"
+#  include "opentelemetry/nostd/type_traits.h"
+#  include "opentelemetry/sdk/logs/exporter.h"
+#  include "opentelemetry/sdk/logs/log_record.h"
+
+#  include <time.h>
+#  include <iostream>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace logs
+{
+/**
+ * Struct to hold Elasticsearch exporter configuration options.
+ */
+struct ElasticsearchExporterOptions
+{
+  // Configuration options to establish Elasticsearch connection
+  std::string host_;
+  int port_;
+  std::string index_;
+
+  // Maximum time to wait for response after sending request to Elasticsearch
+  int response_timeout_;
+
+  // Whether to print the status of the exporter in the console
+  bool console_debug_;
+
+  /**
+   * Constructor for the ElasticsearchExporterOptions. By default, the endpoint is
+   * localhost:9200/logs with a timeout of 30 seconds and disabled console debugging
+   * @param host The host of the Elasticsearch instance
+   * @param port The port of the Elasticsearch instance
+   * @param index The index/shard that the logs will be written to
+   * @param response_timeout The maximum time in seconds the exporter should wait for a response
+   * from elasticsearch
+   * @param console_debug If true, print the status of the exporter methods in the console
+   */
+  ElasticsearchExporterOptions(std::string host     = "localhost",
+                               int port             = 9200,
+                               std::string index    = "logs",
+                               int response_timeout = 30,
+                               bool console_debug   = false)
+      : host_{host},
+        port_{port},
+        index_{index},
+        response_timeout_{response_timeout},
+        console_debug_{console_debug}
+  {}
+};
+
+/**
+ * The ElasticsearchLogExporter exports logs to Elasticsearch in JSON format
+ */
+class ElasticsearchLogExporter final : public opentelemetry::sdk::logs::LogExporter
+{
+public:
+  /**
+   * Create an ElasticsearchLogExporter with default exporter options.
+   */
+  ElasticsearchLogExporter();
+
+  /**
+   * Create an ElasticsearchLogExporter with user specified options.
+   * @param options An object containing the user's configuration options.
+   */
+  ElasticsearchLogExporter(const ElasticsearchExporterOptions &options);
+
+  /**
+   * Creates a recordable that stores the data in a JSON object
+   */
+  std::unique_ptr<opentelemetry::sdk::logs::Recordable> MakeRecordable() noexcept override;
+
+  /**
+   * Exports a vector of log records to the Elasticsearch instance. Guaranteed to return after a
+   * timeout specified from the options passed from the constructor.
+   * @param records A list of log records to send to Elasticsearch.
+   */
+  sdk::common::ExportResult Export(
+      const opentelemetry::nostd::span<std::unique_ptr<opentelemetry::sdk::logs::Recordable>>
+          &records) noexcept override;
+
+  /**
+   * Shutdown this exporter.
+   * @param timeout The maximum time to wait for the shutdown method to return
+   */
+  bool Shutdown(
+      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+
+private:
+  // Stores if this exporter had its Shutdown() method called
+  bool is_shutdown_ = false;
+
+  // Configuration options for the exporter
+  ElasticsearchExporterOptions options_;
+
+  // Object that stores the HTTP sessions that have been created
+  std::unique_ptr<ext::http::client::HttpClient> http_client_;
+  mutable opentelemetry::common::SpinLockMutex lock_;
+  bool isShutdown() const noexcept;
+};
+}  // namespace logs
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/include/opentelemetry/exporters/elasticsearch/es_log_recordable.h b/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/include/opentelemetry/exporters/elasticsearch/es_log_recordable.h
new file mode 100755
index 000000000..c38bf8769
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/include/opentelemetry/exporters/elasticsearch/es_log_recordable.h
@@ -0,0 +1,229 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifdef ENABLE_LOGS_PREVIEW
+
+#  include <map>
+#  include <sstream>
+#  include <type_traits>
+#  include <unordered_map>
+
+#  include "nlohmann/json.hpp"
+#  include "opentelemetry/sdk/common/attribute_utils.h"
+#  include "opentelemetry/sdk/logs/recordable.h"
+#  include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace logs
+{
+
+/**
+ * An Elasticsearch Recordable implemenation that stores the 10 fields of the Log Data Model inside
+ * a JSON object,
+ */
+class ElasticSearchRecordable final : public sdk::logs::Recordable
+{
+private:
+  // Define a JSON object that will be populated with the log data
+  nlohmann::json json_;
+
+  /**
+   * A helper method that writes a key/value pair under a specified name, the two names used here
+   * being "attributes" and "resources"
+   */
+  void WriteKeyValue(nostd::string_view key,
+                     const opentelemetry::common::AttributeValue &value,
+                     std::string name)
+  {
+    switch (value.index())
+    {
+      case common::AttributeType::kTypeBool:
+        json_[name][key.data()] = opentelemetry::nostd::get<bool>(value) ? true : false;
+        return;
+      case common::AttributeType::kTypeInt:
+        json_[name][key.data()] = opentelemetry::nostd::get<int>(value);
+        return;
+      case common::AttributeType::kTypeInt64:
+        json_[name][key.data()] = opentelemetry::nostd::get<int64_t>(value);
+        return;
+      case common::AttributeType::kTypeUInt:
+        json_[name][key.data()] = opentelemetry::nostd::get<unsigned int>(value);
+        return;
+      case common::AttributeType::kTypeUInt64:
+        json_[name][key.data()] = opentelemetry::nostd::get<uint64_t>(value);
+        return;
+      case common::AttributeType::kTypeDouble:
+        json_[name][key.data()] = opentelemetry::nostd::get<double>(value);
+        return;
+      case common::AttributeType::kTypeCString:
+        json_[name][key.data()] = opentelemetry::nostd::get<const char *>(value);
+        return;
+      case common::AttributeType::kTypeString:
+        json_[name][key.data()] =
+            opentelemetry::nostd::get<opentelemetry::nostd::string_view>(value).data();
+        return;
+      default:
+        return;
+    }
+  }
+
+  void WriteKeyValue(nostd::string_view key,
+                     const opentelemetry::sdk::common::OwnedAttributeValue &value,
+                     std::string name)
+  {
+    namespace common = opentelemetry::sdk::common;
+    switch (value.index())
+    {
+      case common::kTypeBool:
+        json_[name][key.data()] = opentelemetry::nostd::get<bool>(value) ? true : false;
+        return;
+      case common::kTypeInt:
+        json_[name][key.data()] = opentelemetry::nostd::get<int>(value);
+        return;
+      case common::kTypeInt64:
+        json_[name][key.data()] = opentelemetry::nostd::get<int64_t>(value);
+        return;
+      case common::kTypeUInt:
+        json_[name][key.data()] = opentelemetry::nostd::get<unsigned int>(value);
+        return;
+      case common::kTypeUInt64:
+        json_[name][key.data()] = opentelemetry::nostd::get<uint64_t>(value);
+        return;
+      case common::kTypeDouble:
+        json_[name][key.data()] = opentelemetry::nostd::get<double>(value);
+        return;
+      case common::kTypeString:
+        json_[name][key.data()] = opentelemetry::nostd::get<std::string>(value).data();
+        return;
+      default:
+        return;
+    }
+  }
+
+public:
+  /**
+   * Set the severity for this log.
+   * @param severity the severity of the event
+   */
+  void SetSeverity(opentelemetry::logs::Severity severity) noexcept override
+  {
+    // Convert the severity enum to a string
+    std::uint32_t severity_index = static_cast<std::uint32_t>(severity);
+    if (severity_index >= std::extent<decltype(opentelemetry::logs::SeverityNumToText)>::value)
+    {
+      std::stringstream sout;
+      sout << "Invalid severity(" << severity_index << ")";
+      json_["severity"] = sout.str();
+    }
+    else
+    {
+      json_["severity"] = opentelemetry::logs::SeverityNumToText[severity_index];
+    }
+  }
+
+  /**
+   * Set body field for this log.
+   * @param message the body to set
+   */
+  void SetBody(nostd::string_view message) noexcept override { json_["body"] = message.data(); }
+
+  /**
+   * Set Resource of this log
+   * @param Resource the resource to set
+   */
+  void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept override
+  {
+    for (auto &kv : resource.GetAttributes())
+    {
+      WriteKeyValue(kv.first, kv.second, "resource");
+    }
+  }
+
+  /**
+   * Set an attribute of a log.
+   * @param key the key of the attribute
+   * @param value the attribute value
+   */
+  void SetAttribute(nostd::string_view key,
+                    const opentelemetry::common::AttributeValue &value) noexcept override
+  {
+    WriteKeyValue(key, value, "attributes");
+  }
+
+  /**
+   * Set trace id for this log.
+   * @param trace_id the trace id to set
+   */
+  void SetTraceId(opentelemetry::trace::TraceId trace_id) noexcept override
+  {
+    char trace_buf[32];
+    trace_id.ToLowerBase16(trace_buf);
+    json_["traceid"] = std::string(trace_buf, sizeof(trace_buf));
+  }
+
+  /**
+   * Set span id for this log.
+   * @param span_id the span id to set
+   */
+  virtual void SetSpanId(opentelemetry::trace::SpanId span_id) noexcept override
+  {
+    char span_buf[16];
+    span_id.ToLowerBase16(span_buf);
+    json_["spanid"] = std::string(span_buf, sizeof(span_buf));
+  }
+
+  /**
+   * Inject a trace_flags  for this log.
+   * @param trace_flags the span id to set
+   */
+  void SetTraceFlags(opentelemetry::trace::TraceFlags trace_flags) noexcept override
+  {
+    char flag_buf[2];
+    trace_flags.ToLowerBase16(flag_buf);
+    json_["traceflags"] = std::string(flag_buf, sizeof(flag_buf));
+  }
+
+  /**
+   * Set the timestamp for this log.
+   * @param timestamp the timestamp of the event
+   */
+  void SetTimestamp(common::SystemTimestamp timestamp) noexcept override
+  {
+    json_["timestamp"] = timestamp.time_since_epoch().count();
+  }
+
+  /**
+   * Returns a JSON object contain the log information
+   */
+  nlohmann::json GetJSON() noexcept { return json_; }
+
+  /**
+   * Set instrumentation_library for this log.
+   * @param instrumentation_library the instrumentation library to set
+   */
+  void SetInstrumentationLibrary(
+      const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary
+          &instrumentation_library) noexcept
+  {
+    json_["name"]            = instrumentation_library.GetName();
+    instrumentation_library_ = &instrumentation_library;
+  }
+
+  /** Returns the associated instruementation library */
+  const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary &
+  GetInstrumentationLibrary() const noexcept
+  {
+    return *instrumentation_library_;
+  }
+
+private:
+  const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary
+      *instrumentation_library_ = nullptr;
+};
+}  // namespace logs
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/src/es_log_exporter.cc b/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/src/es_log_exporter.cc
new file mode 100644
index 000000000..a5a66ebe0
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/src/es_log_exporter.cc
@@ -0,0 +1,221 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_LOGS_PREVIEW
+
+#  include <sstream>  // std::stringstream
+
+#  include <mutex>
+#  include "opentelemetry/exporters/elasticsearch/es_log_exporter.h"
+#  include "opentelemetry/exporters/elasticsearch/es_log_recordable.h"
+#  include "opentelemetry/sdk_config.h"
+
+namespace nostd       = opentelemetry::nostd;
+namespace sdklogs     = opentelemetry::sdk::logs;
+namespace http_client = opentelemetry::ext::http::client;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace logs
+{
+/**
+ * This class handles the response message from the Elasticsearch request
+ */
+class ResponseHandler : public http_client::EventHandler
+{
+public:
+  /**
+   * Creates a response handler, that by default doesn't display to console
+   */
+  ResponseHandler(bool console_debug = false) : console_debug_{console_debug} {}
+
+  /**
+   * Automatically called when the response is received, store the body into a string and notify any
+   * threads blocked on this result
+   */
+  void OnResponse(http_client::Response &response) noexcept override
+  {
+    // Lock the private members so they can't be read while being modified
+    {
+      std::unique_lock<std::mutex> lk(mutex_);
+
+      // Store the body of the request
+      body_ = std::string(response.GetBody().begin(), response.GetBody().end());
+
+      // Set the response_received_ flag to true and notify any threads waiting on this result
+      response_received_ = true;
+    }
+    cv_.notify_all();
+  }
+
+  /**
+   * A method the user calls to block their thread until the response is received. The longest
+   * duration is the timeout of the request, set by SetTimeoutMs()
+   */
+  bool waitForResponse()
+  {
+    std::unique_lock<std::mutex> lk(mutex_);
+    cv_.wait(lk);
+    return response_received_;
+  }
+
+  /**
+   * Returns the body of the response
+   */
+  std::string GetResponseBody()
+  {
+    // Lock so that body_ can't be written to while returning it
+    std::unique_lock<std::mutex> lk(mutex_);
+    return body_;
+  }
+
+  // Callback method when an http event occurs
+  void OnEvent(http_client::SessionState state, nostd::string_view reason) noexcept override
+  {
+    // If any failure event occurs, release the condition variable to unblock main thread
+    switch (state)
+    {
+      case http_client::SessionState::ConnectFailed:
+        OTEL_INTERNAL_LOG_ERROR("[ES Trace Exporter] Connection to elasticsearch failed");
+        cv_.notify_all();
+        break;
+      case http_client::SessionState::SendFailed:
+        OTEL_INTERNAL_LOG_ERROR("[ES Trace Exporter] Request failed to be sent to elasticsearch");
+        cv_.notify_all();
+        break;
+      case http_client::SessionState::TimedOut:
+        OTEL_INTERNAL_LOG_ERROR("[ES Trace Exporter] Request to elasticsearch timed out");
+        cv_.notify_all();
+        break;
+      case http_client::SessionState::NetworkError:
+        OTEL_INTERNAL_LOG_ERROR("[ES Trace Exporter] Network error to elasticsearch");
+        cv_.notify_all();
+        break;
+    }
+  }
+
+private:
+  // Define a condition variable and mutex
+  std::condition_variable cv_;
+  std::mutex mutex_;
+
+  // Whether the response from Elasticsearch has been received
+  bool response_received_ = false;
+
+  // A string to store the response body
+  std::string body_ = "";
+
+  // Whether to print the results from the callback
+  bool console_debug_ = false;
+};
+
+ElasticsearchLogExporter::ElasticsearchLogExporter()
+    : options_{ElasticsearchExporterOptions()},
+      http_client_{new ext::http::client::curl::HttpClient()}
+{}
+
+ElasticsearchLogExporter::ElasticsearchLogExporter(const ElasticsearchExporterOptions &options)
+    : options_{options}, http_client_{new ext::http::client::curl::HttpClient()}
+{}
+
+std::unique_ptr<sdklogs::Recordable> ElasticsearchLogExporter::MakeRecordable() noexcept
+{
+  return std::unique_ptr<sdklogs::Recordable>(new ElasticSearchRecordable);
+}
+
+sdk::common::ExportResult ElasticsearchLogExporter::Export(
+    const nostd::span<std::unique_ptr<sdklogs::Recordable>> &records) noexcept
+{
+  // Return failure if this exporter has been shutdown
+  if (isShutdown())
+  {
+    OTEL_INTERNAL_LOG_ERROR("[ES Log Exporter] Exporting "
+                            << records.size() << " log(s) failed, exporter is shutdown");
+    return sdk::common::ExportResult::kFailure;
+  }
+
+  // Create a connection to the ElasticSearch instance
+  auto session = http_client_->CreateSession(options_.host_ + std::to_string(options_.port_));
+  auto request = session->CreateRequest();
+
+  // Populate the request with headers and methods
+  request->SetUri(options_.index_ + "/_bulk?pretty");
+  request->SetMethod(http_client::Method::Post);
+  request->AddHeader("Content-Type", "application/json");
+  request->SetTimeoutMs(std::chrono::milliseconds(1000 * options_.response_timeout_));
+
+  // Create the request body
+  std::string body = "";
+  for (auto &record : records)
+  {
+    // Append {"index":{}} before JSON body, which tells Elasticsearch to write to index specified
+    // in URI
+    body += "{\"index\" : {}}\n";
+
+    // Add the context of the Recordable
+    auto json_record = std::unique_ptr<ElasticSearchRecordable>(
+        static_cast<ElasticSearchRecordable *>(record.release()));
+    body += json_record->GetJSON().dump() + "\n";
+  }
+  std::vector<uint8_t> body_vec(body.begin(), body.end());
+  request->SetBody(body_vec);
+
+  // Send the request
+  std::unique_ptr<ResponseHandler> handler(new ResponseHandler(options_.console_debug_));
+  session->SendRequest(*handler);
+
+  // Wait for the response to be received
+  if (options_.console_debug_)
+  {
+    OTEL_INTERNAL_LOG_DEBUG(
+        "[ES Trace Exporter] waiting for response from Elasticsearch (timeout = "
+        << options_.response_timeout_ << " seconds)");
+  }
+  bool write_successful = handler->waitForResponse();
+
+  // End the session
+  session->FinishSession();
+
+  // If an error occurred with the HTTP request
+  if (!write_successful)
+  {
+    // TODO: retry logic
+    return sdk::common::ExportResult::kFailure;
+  }
+
+  // Parse the response output to determine if Elasticsearch consumed it correctly
+  std::string responseBody = handler->GetResponseBody();
+  if (responseBody.find("\"failed\" : 0") == std::string::npos)
+  {
+    OTEL_INTERNAL_LOG_ERROR(
+        "[ES Trace Exporter] Logs were not written to Elasticsearch correctly, response body: "
+        << responseBody);
+    // TODO: Retry logic
+    return sdk::common::ExportResult::kFailure;
+  }
+
+  return sdk::common::ExportResult::kSuccess;
+}
+
+bool ElasticsearchLogExporter::Shutdown(std::chrono::microseconds timeout) noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  is_shutdown_ = true;
+
+  // Shutdown the session manager
+  http_client_->CancelAllSessions();
+  http_client_->FinishAllSessions();
+
+  return true;
+}
+
+bool ElasticsearchLogExporter::isShutdown() const noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  return is_shutdown_;
+}
+}  // namespace logs
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/test/es_log_exporter_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/test/es_log_exporter_test.cc
new file mode 100644
index 000000000..943f9fa7b
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/elasticsearch/test/es_log_exporter_test.cc
@@ -0,0 +1,86 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_LOGS_PREVIEW
+
+#  include "opentelemetry/exporters/elasticsearch/es_log_exporter.h"
+#  include "opentelemetry/ext/http/server/http_server.h"
+#  include "opentelemetry/logs/provider.h"
+#  include "opentelemetry/sdk/logs/exporter.h"
+#  include "opentelemetry/sdk/logs/log_record.h"
+#  include "opentelemetry/sdk/logs/logger_provider.h"
+#  include "opentelemetry/sdk/logs/simple_log_processor.h"
+
+#  include <gtest/gtest.h>
+#  include <iostream>
+
+namespace sdklogs       = opentelemetry::sdk::logs;
+namespace logs_api      = opentelemetry::logs;
+namespace nostd         = opentelemetry::nostd;
+namespace logs_exporter = opentelemetry::exporter::logs;
+
+TEST(ElasticsearchLogsExporterTests, Dummy)
+{
+  // to enable linking
+}
+
+#  if 0
+// Attempt to write a log to an invalid host/port, test that the Export() returns failure
+TEST(ElasticsearchLogsExporterTests, InvalidEndpoint)
+{
+  // Create invalid connection options for the elasticsearch exporter
+  logs_exporter::ElasticsearchExporterOptions options("localhost", -1);
+
+  // Create an elasticsearch exporter
+  auto exporter =
+      std::unique_ptr<sdklogs::LogExporter>(new logs_exporter::ElasticsearchLogExporter(options));
+
+  // Create a log record and send to the exporter
+  auto record = exporter->MakeRecordable();
+  auto result = exporter->Export(nostd::span<std::unique_ptr<sdklogs::Recordable>>(&record, 1));
+
+  // Ensure the return value is failure
+  ASSERT_EQ(result, sdk::common::ExportResult::kFailure);
+}
+
+// Test that when the exporter is shutdown, any call to Export should return failure
+TEST(ElasticsearchLogsExporterTests, Shutdown)
+{
+  // Create an elasticsearch exporter and immediately shut it down
+  auto exporter =
+      std::unique_ptr<sdklogs::LogExporter>(new logs_exporter::ElasticsearchLogExporter);
+  bool shutdownResult = exporter->Shutdown();
+  ASSERT_TRUE(shutdownResult);
+
+  // Write a log to the shutdown exporter
+  auto record = exporter->MakeRecordable();
+  auto result = exporter->Export(nostd::span<std::unique_ptr<sdklogs::Recordable>>(&record, 1));
+
+  // Ensure the return value is failure
+  ASSERT_EQ(result, sdk::common::ExportResult::kFailure);
+}
+
+// Test the elasticsearch recordable object
+TEST(ElasticsearchLogsExporterTests, RecordableCreation)
+{
+  // Create an elasticsearch exporter
+  auto exporter =
+      std::unique_ptr<sdklogs::LogExporter>(new logs_exporter::ElasticsearchLogExporter);
+
+  // Create a recordable
+  auto record = exporter->MakeRecordable();
+  record->SetSeverity(logs_api::Severity::kFatal);
+  record->SetTimestamp(std::chrono::system_clock::now());
+  record->SetBody("Body of the log message");
+
+  // Attributes and resource support different types
+  record->SetAttribute("key0", false);
+  record->SetAttribute("key1", "1");
+
+  auto resource = opentelemetry::sdk::resource::Resource::Create({{"key2", 2}, {"key3", 3142}});
+  record->SetResource(resource);
+
+  exporter->Export(nostd::span<std::unique_ptr<sdklogs::Recordable>>(&record, 1));
+}
+#  endif
+#endif
\ No newline at end of file
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/BUILD b/src/jaegertracing/opentelemetry-cpp/exporters/etw/BUILD
new file mode 100644
index 000000000..c2328ed4e
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/BUILD
@@ -0,0 +1,69 @@
+package(default_visibility = ["//visibility:public"])
+
+cc_library(
+    name = "etw_exporter",
+    hdrs = glob([
+        "include/opentelemetry/exporters/etw/*.h",
+    ]),
+    includes = ["include"],
+    local_defines = [
+        "HAVE_MSGPACK",
+    ],
+    tags = ["etw"],
+    deps = [
+        "//api",
+        "//sdk/src/trace",
+        "@github_nlohmann_json//:json",
+    ],
+)
+
+cc_test(
+    name = "etw_provider_test",
+    srcs = ["test/etw_provider_test.cc"],
+    local_defines = [
+        "HAVE_MSGPACK",
+    ],
+    tags = [
+        "etw",
+        "test",
+    ],
+    deps = [
+        ":etw_exporter",
+        "@com_google_googletest//:gtest_main",
+        "@github_nlohmann_json//:json",
+    ],
+)
+
+cc_test(
+    name = "etw_tracer_test",
+    srcs = ["test/etw_tracer_test.cc"],
+    local_defines = [
+        "HAVE_MSGPACK",
+    ],
+    tags = [
+        "etw",
+        "test",
+    ],
+    deps = [
+        ":etw_exporter",
+        "@com_google_googletest//:gtest_main",
+        "@github_nlohmann_json//:json",
+    ],
+)
+
+cc_test(
+    name = "etw_logger_test",
+    srcs = ["test/etw_logger_test.cc"],
+    local_defines = [
+        "HAVE_MSGPACK",
+    ],
+    tags = [
+        "etw",
+        "test",
+    ],
+    deps = [
+        ":etw_exporter",
+        "@com_google_googletest//:gtest_main",
+        "@github_nlohmann_json//:json",
+    ],
+)
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/CMakeLists.txt b/src/jaegertracing/opentelemetry-cpp/exporters/etw/CMakeLists.txt
new file mode 100644
index 000000000..47791b4ab
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/CMakeLists.txt
@@ -0,0 +1,63 @@
+add_library(opentelemetry_exporter_etw INTERFACE)
+
+target_include_directories(
+  opentelemetry_exporter_etw
+  INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+            "$<INSTALL_INTERFACE:include>")
+
+set_target_properties(opentelemetry_exporter_etw PROPERTIES EXPORT_NAME
+                                                            etw_exporter)
+
+target_link_libraries(opentelemetry_exporter_etw
+                      INTERFACE nlohmann_json::nlohmann_json)
+if(nlohmann_json_clone)
+  add_dependencies(opentelemetry_exporter_etw nlohmann_json::nlohmann_json)
+endif()
+
+install(
+  TARGETS opentelemetry_exporter_etw
+  EXPORT "${PROJECT_NAME}-target"
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+install(
+  DIRECTORY include/opentelemetry/exporters/etw
+  DESTINATION include/opentelemetry/exporters
+  FILES_MATCHING
+  PATTERN "*.h")
+
+if(BUILD_TESTING)
+  add_executable(etw_provider_test test/etw_provider_test.cc)
+  add_executable(etw_tracer_test test/etw_tracer_test.cc)
+  add_executable(etw_logger_test test/etw_logger_test.cc)
+
+  add_executable(etw_perf_test test/etw_perf_test.cc)
+
+  target_link_libraries(etw_provider_test ${GTEST_BOTH_LIBRARIES}
+                        opentelemetry_exporter_etw ${CMAKE_THREAD_LIBS_INIT})
+
+  target_link_libraries(etw_tracer_test ${GTEST_BOTH_LIBRARIES}
+                        opentelemetry_exporter_etw ${CMAKE_THREAD_LIBS_INIT})
+
+  target_link_libraries(etw_logger_test ${GTEST_BOTH_LIBRARIES}
+                        opentelemetry_exporter_etw ${CMAKE_THREAD_LIBS_INIT})
+
+  target_link_libraries(
+    etw_perf_test benchmark::benchmark ${GTEST_BOTH_LIBRARIES}
+    opentelemetry_exporter_etw ${CMAKE_THREAD_LIBS_INIT})
+
+  gtest_add_tests(
+    TARGET etw_provider_test
+    TEST_PREFIX exporter.
+    TEST_LIST etw_provider_test)
+  gtest_add_tests(
+    TARGET etw_tracer_test
+    TEST_PREFIX exporter.
+    TEST_LIST etw_tracer_test)
+  gtest_add_tests(
+    TARGET etw_logger_test
+    TEST_PREFIX exporter.
+    TEST_LIST etw_logger_test)
+
+endif() # BUILD_TESTING
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/README.md b/src/jaegertracing/opentelemetry-cpp/exporters/etw/README.md
new file mode 100644
index 000000000..29dc3de43
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/README.md
@@ -0,0 +1,226 @@
+# Getting Started with OpenTelemetry C++ SDK and ETW exporter on Windows
+
+Event Tracing for Windows (ETW) is an efficient kernel-level tracing facility
+that lets you log kernel or application-defined events to a log file. You can
+consume the events in real time or from a log file and use them to debug an
+application or to determine where performance issues are occurring in the
+application.
+
+OpenTelemetry C++ SDK ETW exporter allows the code instrumented using
+OpenTelemetry API to forward events to out-of-process ETW listener, for
+subsequent data recording or forwarding to alternate pipelines and flows.
+Windows Event Tracing infrastructure is available to any vendor or application
+being deployed on Windows.
+
+## API support
+
+These are the features planned to be supported by ETW exporter:
+
+- [x] OpenTelemetry Tracing API and SDK headers are **stable** and moving
+  towards GA.
+- [ ] OpenTelemetry Logging API is work-in-progress, pending implementation of
+  [Latest Logging API spec
+  here](https://github.com/open-telemetry/oteps/pull/150)
+- [ ] OpenTelemetry Metrics API is not implemented yet.
+
+Implementation of OpenTelemetry C++ SDK ETW exporter on Windows OS is `header
+only` :
+
+- full definitions of all macros, functions and classes comprising the library
+are visible to the compiler in a header file form.
+- implementation does not need to be separately compiled, packaged and installed
+  in order to be used.
+
+All that is required is to point the compiler at the location of the headers,
+and then `#include` the header files into the application source. Compiler's
+optimizer can do a much better job when all the library's source code is
+available. Several options below may be turned on to optimize the code with the
+usage of standard C++ library, Microsoft Guidelines Support library, Google
+Abseil Variant library. Or enabling support for non-standard features, such as
+8-bit byte arrays support that enables performance-efficient representation of
+binary blobs on ETW wire.
+
+## Example project
+
+The following include directories are required, relative to the top-level source
+tree of OpenTelemetry C++ repo:
+
+- api/include/
+- exporters/etw/include/
+- sdk/include/
+
+Code that instantiates ETW TracerProvider, subsequently obtaining a Tracer bound
+to `OpenTelemetry-ETW-Provider`, and emitting a span named `MySpan` with
+attributes on it, as well as `MyEvent` within that span.
+
+```cpp
+
+#include <map>
+#include <string>
+
+#include "opentelemetry/exporters/etw/etw_tracer_exporter.h"
+
+using namespace OPENTELEMETRY_NAMESPACE;
+using namespace opentelemetry::exporter::etw;
+
+// Supply unique instrumentation name (ETW Provider Name) here:
+std::string providerName = "OpenTelemetry-ETW-Provider";
+
+exporter::etw::TracerProvider tp;
+
+int main(int argc, const char* argv[])
+{
+  // Obtain a Tracer object for instrumentation name.
+  // Each Tracer is associated with unique TraceId.
+  auto tracer = tp.GetTracer(providerName, "TLD");
+
+  // Properties is a helper class in ETW namespace that is otherwise compatible
+  // with Key-Value Iterable accepted by OpenTelemetry API. Using Properties
+  // should enable more efficient data transfer without unnecessary memcpy.
+
+  // Span attributes
+  Properties attribs =
+  {
+    {"attrib1", 1},
+    {"attrib2", 2}
+  };
+
+  // Start Span with attributes
+  auto span = tracer->StartSpan("MySpan", attribs);
+
+  // Emit an event on Span
+  std::string eventName = "MyEvent1";
+  Properties event =
+  {
+    {"uint32Key", (uint32_t)1234},
+    {"uint64Key", (uint64_t)1234567890},
+    {"strKey", "someValue"}
+  };
+  span->AddEvent(eventName, event);
+
+  // End Span.
+  span->End();
+
+  // Close the Tracer on application stop.
+  tracer->CloseWithMicroseconds(0);
+
+  return 0;
+}
+```
+
+Note that different `Tracer` objects may be bound to different ETW destinations.
+
+## Build options and Compiler Defines
+
+While including OpenTelemetry C++ SDK with ETW exporter, the customers are in
+complete control of what options they would like to enable for their project
+using `Preprocessor Definitions`.
+
+These options affect how "embedded in application" OpenTelemetry C++ SDK code is
+compiled:
+
+| Name        | Description                                                      |
+|---------------------|------------------------------------------------------------------------------------------------------------------------|
+| HAVE_CPP_STDLIB   | Use STL classes for API surface. This option requires at least C++17. C++20 is recommended. Some customers may benefit from STL library provided with the compiler instead of using custom OpenTelemetry `nostd::` implementation due to security and performance considerations. |
+| HAVE_GSL      | Use [Microsoft GSL](https://github.com/microsoft/GSL) for `gsl::span` implementation. Library must be in include path. Microsoft GSL claims to be the most feature-complete implementation of `std::span`. It may be used instead of `nostd::span` implementation in projects that statically link OpenTelemetry SDK. |
+| HAVE_TLD      | Use ETW/TraceLogging Dynamic protocol. This is the default implementation compatible with existing C# "listeners" / "decoders" of ETW events. This option requires an additional optional Microsoft MIT-licensed `TraceLoggingDynamic.h` header. |
+
+## Debugging
+
+### ETW TraceLogging Dynamic Events
+
+ETW supports a mode that is called "Dynamic Manifest", where event may contain
+strongly-typed key-value pairs, with primitive types such as `integer`,
+`double`, `string`, etc. This mode requires `TraceLoggingDynamic.h` header.
+Please refer to upstream repository containining [Microsoft TraceLogging Dynamic
+framework](https://github.com/microsoft/tracelogging-dynamic-windows) licensed
+under [MIT
+License](https://github.com/microsoft/tracelogging-dynamic-windows/blob/main/LICENSE).
+
+Complete [list of ETW
+types](https://docs.microsoft.com/en-us/windows/win32/wes/eventmanifestschema-outputtype-complextype#remarks).
+
+OpenTelemetry C++ ETW exporter implements the following type mapping:
+
+| OpenTelemetry C++ API type | ETW type        |
+|----------------------------|-----------------|
+| bool                       | xs:byte         |
+| int (32-bit)               | xs:int          |
+| int (64-bit)               | xs:long         |
+| uint (32-bit)              | xs:unsignedInt  |
+| uint (64-bit)              | xs:unsignedLong |
+| double                     | xs:double       |
+| string                     | win:Utf8        |
+
+Support for arrays of primitive types is not implemented yet.
+
+Visual Studio 2019 allows to use `View -> Other Windows -> Diagnostic Events` to
+capture events that are emitted by instrumented application and sent to ETW
+provider in a live view. Instrumentation name passed to `GetTracer` API above
+corresponds to `ETW Provider Name`. If Instrumentation name contains a GUID -
+starts with a curly brace, e.g. `{deadbeef-fade-dead-c0de-cafebabefeed}` then
+the parameter is assumed to be `ETW Provider GUID`.
+
+Click on `Settings` and add the provider to monitor either by its Name or by
+GUID. In above example, the provider name is `OpenTelemetry-ETW-Provider`.
+Please refer to Diagnostic Events usage instructions
+[here](https://docs.microsoft.com/en-us/azure/service-fabric/service-fabric-diagnostics-how-to-monitor-and-diagnose-services-locally#view-service-fabric-system-events-in-visual-studio)
+to learn more. Note that running ETW Listener in Visual Studio requires
+Elevation, i.e. Visual Studio would prompt you to confirm that you accept to run
+the ETW Listener process as Administrator. This is a limitation of ETW
+Listeners, they must be run as privileged process.
+
+### ETW events encoded in MessagePack
+
+OpenTelemetry ETW exporter optionally allows to encode the incoming event
+payload using [MessagePack](https://msgpack.org/index.html) compact binary
+protocol. ETW/MsgPack encoding requires
+[nlohmann/json](https://github.com/nlohmann/json) library to be included in the
+build of OpenTelemetry ETW exporter. Any recent version of `nlohmann/json` is
+compatible with ETW exporter. For example, the version included in
+`third_party/nlohmann-json` directory may be used.
+
+There is currently **no built-in decoder available** for this format. However,
+there is ongoing effort to include the ETW/MsgPack decoder in
+[Azure/diagnostics-eventflow](https://github.com/Azure/diagnostics-eventflow)
+project, which may be used as a side-car listener to forward incoming
+ETW/MsgPack events to many other destinations, such as:
+
+- StdOutput (console output)
+- HTTP (json via http)
+- Application Insights
+- Azure EventHub
+- Elasticsearch
+- Azure Monitor Logs
+
+And community-contributed exporters:
+
+- Google Big Query output
+- SQL Server output
+- ReflectInsight output
+- Splunk output
+
+[This PR](https://github.com/Azure/diagnostics-eventflow/pull/382) implements
+the `Input adapter` for OpenTelemetry ETW/MsgPack protocol encoded events for
+Azure EventFlow.
+
+Other standard tools for processing ETW events on Windows OS, such as:
+
+- [PerfView](https://github.com/microsoft/perfview)
+- [PerfViewJS](https://github.com/microsoft/perfview/tree/main/src/PerfViewJS)
+
+will be augmented in future with support for ETW/MsgPack encoding.
+
+## Addendum
+
+This document needs to be supplemented with additional information:
+
+- [ ] mapping between OpenTelemetry fields and concepts and their corresponding
+  ETW counterparts
+- [ ] links to E2E instrumentation example and ETW listener
+- [ ] Logging API example
+- [ ] Metrics API example (once Metrics spec is finalized)
+- [ ] example how ETW Listener may employ OpenTelemetry .NET SDK to 1-1
+  transform from ETW events back to OpenTelemetry flow
+- [ ] links to NuGet package that contains the source code of SDK that includes
+  OpenTelemetry SDK and ETW exporter
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/LICENSE b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/LICENSE
new file mode 100644
index 000000000..cfc21fd2c
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/LICENSE
@@ -0,0 +1,23 @@
+TraceLogging Dynamic for Windows
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/TraceLoggingDynamic.h b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/TraceLoggingDynamic.h
new file mode 100644
index 000000000..17ee108c6
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/TraceLoggingDynamic.h
@@ -0,0 +1,3458 @@
+/* ++
+
+Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+SPDX-License-Identifier: MIT
+Copyright (c) Microsoft Corporation.  All rights reserved.
+
+Module Name:
+
+    TraceLoggingDynamic.h
+
+Abstract:
+
+    Dynamic TraceLogging Provider API for C++.
+
+Environment:
+
+    User mode.
+
+--*/
+
+#pragma once
+#include <windows.h>
+#include <evntprov.h>
+#include <stdlib.h> // byteswap
+
+namespace tld
+{
+#pragma region Public interface
+
+    /*
+    GENERAL:
+
+    - This implementation of manifest-free ETW supports more functionality
+      than the implementation in TraceLoggingProvider.h, but it also has
+      higher runtime costs. This implementation is intended for use only when
+      the set of events is not known at compile-time. For example,
+      TraceLoggingDynamic.h might be used to implement a library providing
+      manifest-free ETW to a scripting language like JavaScript or Perl.
+    - This header is not optimized for direct use by developers adding events
+      to their code. There is no way to make an optimal solution that
+      works for all of the intended target users. Instead, this header
+      provides various pieces that you can build upon to create a user-friendly
+      implementation of manifest-free ETW tailored for a specific scenario.
+
+    HIGH-LEVEL API:
+
+    The high-level API provides an easy way to get up and running with
+    TraceLogging ETW events.
+
+    Contents:
+    - Class:    tld::Provider
+    - Class:    tld::Event
+    - Class:    tld::EventBuilder
+    - Enum:     tld::Type
+
+    Basic usage:
+    - Create a Provider object.
+    - Check provider.IsEnabled(...) so that you don't do the remaining steps
+      if nobody is listening for your event.
+    - Create an Event<std::vector<BYTE>> object.
+    - Add fields definitions (metadata) and values (data) using methods on
+      Event. (You are responsible for making sure that the metadata you add
+      matches the data you add -- the Event object does not validate this.)
+    - Some methods on the Event object return EventBuilder objects, which are
+      used to build the fields of nested structures. Note that Event inherits
+      from EventBuilder, so if you write a function that accepts an
+      EventBuilder&, it will also accept an Event&.
+    - Once you've added all data and metadata, call event.Write() to send the
+      event to ETW.
+
+    LOW-LEVEL API:
+
+    The low-level API provides components that you can mix and match to build
+    your own solution when the high-level components don't precisely meet your
+    needs. For example, you might use the high-level Provider class to manage
+    your REGHANDLE and the ETW callbacks, but you might use
+    EventMetadataBuilder and EventDataBuilder directly instead of using Event
+    so that you can cache event definitions.
+
+    Contents:
+    - Function: tld::RegisterProvider
+    - Function: tld::UnregisterProvider
+    - Function: tld::GetGuidForName
+    - Function: tld::SetInformation
+    - Class:    tld::ProviderMetadataBuilder
+    - Class:    tld::EventMetadataBuilder
+    - Class:    tld::EventDataBuilder
+    - Struct:   tld::EventDescriptor
+    - Class:    tld::ByteArrayWrapper
+    - Enum:     tld::InType
+    - Enum:     tld::OutType
+    - Enum:     tld::ProviderTraitType
+    - Function: tld::WriteEvent
+    - Function: tld::WriteEventEx
+    - Function: tld::PushBackAsUtf8
+    - Function: tld::MakeType
+    - Macro:    TLD_HAVE_EVENT_SET_INFORMATION
+    - Macro:    TLD_HAVE_EVENT_WRITE_EX
+
+    Notes:
+    - EventDataDescCreate is a native ETW API from <evntprov.h>. It is not
+      part of this API, but you may want to use it to initialize
+      EVENT_DATA_DESCRIPTOR structures instead of doing it directly.
+    - If you directly initialize your EVENT_DATA_DESCRIPTOR structures instead
+      of using EventDataDescCreate, be sure to properly initialize the
+      EVENT_DATA_DESCRIPTOR.Reserved field (e.g. by setting it to 0).
+      Initializing the Reserved field is NOT optional. (EventDataDescCreate
+      does correctly initialize the Reserved field.)
+    - When the API asks for a byte-buffer, you can use std::vector<BYTE> or
+      another similar type. If you don't want to use a vector, the provided
+      ByteArrayWrapper type allows you to use your own allocation strategy for
+      the buffer.
+    - By default, TraceLogging events have Id=0 and Version=0, indicating
+      that the event does not have an assigned Id. However, events can have
+      Id and Version assigned (typically assigned manually). If you don't want
+      to manage event IDs, set both Id and Version to 0. If you do assign
+      IDs to your events, the Id must be non-zero and there should be a
+      one-to-one mapping between {provider.Id + event.Id + event.Version} and
+      {event metadata}. In other words, any event with a given non-zero
+      Id+Version combination must always have exactly the same event metadata.
+      (Note to decoders: this can be used as an optimization, but do not rely
+      on providers to follow this rule.)
+    - TraceLogging events default to channel 11 (WINEVENT_CHANNEL_TRACELOGGING).
+      This channel has no effect other than to mark the event as TraceLogging-
+      compatible. Other channels can be used, but channels other than 11 will
+      only work if the provider is running on a version of Windows that
+      understands TraceLogging (Windows 7sp1 with latest updates, Windows 8.1
+      with latest updates, Windows 10, or later). If your provider is running
+      on a version of Windows that does not understand TraceLogging and you use
+      a channel other than 11, the resulting events will not decode correctly.
+
+    Low-level provider management:
+    - Use tld::ProviderMetadataBuilder to build a provider metadata blob.
+    - If you don't have a specific provider GUID already selected, use
+      tld::GetGuidForName to compute your provider GUID.
+    - Use tld::RegisterProvider to open the REGHANDLE.
+    - Use the REGHANDLE in calls to tld::WriteEvent.
+    - Use tld::UnregisterProvider to close the REGHANDLE.
+
+    Low-level event management:
+    - Use tld::EventMetadataBuilder to build an event metadata blob.
+      - Use tld::Type values to define field types, or create non-standard
+        types using tld::MakeType, tld::InType, and tld::OutType.
+    - Use tld::EventDataBuilder to build an event data blob.
+    - Create an EVENT_DESCRIPTOR for your event.
+      - Optionally use the tld::EventDescriptor wrapper class to simplify
+        initialization of EVENT_DESCRIPTOR structures.
+    - Allocate an array of EVENT_DATA_DESCRIPTORs. Size should be two more
+      than you need for your event payload (the first two are reserved for the
+      provider and event metadata).
+    - Use EventDataDescCreate to fill in the data descriptor array (skipping
+      the first two) to reference your event payload data.
+    - Use tld::WriteEvent to write your event.
+    */
+
+    /*
+    class Provider (high-level API):
+
+    Manages an ETW REGHANDLE and the provider metadata blob.
+    - Constructor creates the provider metadata blob and registers the provider.
+      Note that this includes configuring ETW callbacks.
+    - Destructor unregisters the provider and frees the metadata blob.
+    - IsEnabled APIs provide very efficient checks for whether an event needs
+      to be written.
+    - Write APIs call WriteEvent, automatically providing the correct REGHANDLE
+      and provider metadata blobs.
+
+    Typical usage:
+
+    tld::Provider provider("ProviderName", ...);
+    if (provider.IsEnabled(eventLevel, eventKeywords))
+    {
+        (prepare event);
+        provider.Write(...);
+    }
+
+    It is not a problem to call provider.Write without checking
+    provider.IsEnabled(...), but it is more efficient to check
+    provider.IsEnabled(...) so that you can skip the process of preparing the
+    event if the event is not enabled.
+    */
+    class Provider;
+
+    /*
+    class Event (high-level API):
+
+    Manages the data and metadata for an event. You create an Event object,
+    set properties, add field definitions, add field values, and then Write
+    the event.
+
+    ByteVectorTy will usually be std::vector<BYTE>, though other similar
+    types could be used instead.
+
+    Typical usage:
+
+    if (provider.IsEnabled(eventLevel, eventKeywords))
+    {
+        Event event(provider, szEventName, eventLevel, eventKeywords);
+        (add fields definitions and values);
+        event.Write();
+    }
+
+    You can reuse an Event object by calling event.Reset(...).
+    */
+    template<class ByteVectorTy>
+    class Event;
+
+    /*
+    class EventBuilder (high-level API):
+
+    This class exposes an interface for adding field metadata/data to an event.
+    The Event class inherits from EventBuilder so that it can expose this
+    interface. In addition, each call to eventBuilder.AddStruct(...) returns a
+    new EventBuilder that can be used to add fields to a nested structure.
+    You won't directly create instances of this type -- you'll use instances
+    returned by Event.AddStruct or by EventBuilder.AddStruct.
+
+    You can use EventBuilder& as the type of a parameter to a function, and
+    then pass either an Event or an EventBuilder to that function (allowing
+    for recursive processing of event fields).
+
+    Note that order is important but not checked when using multiple Event or
+    EventBuilder objects. Fields are always added to the end of the overall
+    event, regardless of which Event or EventBuilder you use to add the field.
+    The separate Event and EventBuilder objects are used for the sole purpose
+    of tracking the number of fields in each struct.
+
+    Assume that you have obtained EventBuilder object b from object a, i.e.
+    EventBuilder b = a.AddStruct(...). You must complete all operations using
+    b before resuming any operations using a. If this rule is not followed,
+    fields may end up nesting in unexpected ways.
+    */
+    template<class ByteVectorTy>
+    class EventBuilder;
+
+    /*
+    enum Type (high-level API and low-level API):
+
+    Types for event fields, corresponding to a combination of TDH_INTYPE and
+    TDH_OUTTYPE values. The Type enumeration contains predefined combinations
+    of InType and OutType that are known to work well and are recognized by
+    decoders such as TDH and xperf.
+
+    Advanced use: It is possible to create other Type values by combining
+    values from the InType and OutType enumerations using the tld::MakeType
+    function. (Valid Type values consist of one InType combined with one
+    OutType.) However, custom combinations not already present in the Type
+    enumeration are unlikely to be recognized by xperf or other decoders,
+    and will usually end up being decoded as if they had used OutTypeDefault.
+
+    When providing payload for a field, the payload data must match the InType.
+    Payload is always packed tightly with no alignment or padding.
+
+    ****
+
+    How to pack single values:
+    
+    Primitive values (int, GUID) are packed directly, with no padding or
+    alignment. Just reserve sizeof(value) bytes in the buffer, then memcpy the
+    value into the buffer. Note that there should be no alignment or padding
+    between items -- the payload is always tightly-packed.
+
+    NUL-terminated strings are also simply memcpy'ed into the buffer. Be sure
+    to include the NUL termination when reserving space and copying the value.
+    There is no special encoding reserved for a NULL string. The encoding
+    helpers in this header simply treat a NULL string the same as an empty
+    string, i.e. AddString((char*)NULL) is the same as AppendString("").
+    
+    Binary, CountedString, and CountedAnsiString scalars are all encoded as a
+    UINT16 byte-count followed by the string data. In this case, no NUL
+    termination should be included. Remember that the size is a byte count,
+    not a character count.
+
+    ****
+
+    How to pack arrays:
+
+    Assume you have a function Pack(payloadVec, item) that correctly appends an
+    item to the end of payloadVec.
+
+    Packing a variable-length array of N items is done by appending N (encoded
+    as UINT16) to payloadVec followed by calling Pack(...) N times.
+
+    Packing a constant-length array of N items is done by calling Pack(...) N
+    times. The value of N is encoded in the metadata (it was provided in the
+    field's declaration) so it does not need to be provided in the payload.
+
+    Note: while this header allows you to create arrays of anything, you
+    should avoid creating arrays of the following, as they might not decode
+    correctly:
+    - TypeNone (or anything based on InTypeNull).
+    - TypeBinary (or anything based on InTypeBinary).
+
+    It is ok to create an array of nested structures where fields in the
+    structure have TypeNone or TypeBinary.
+    */
+    enum Type : UINT16;
+
+    /*
+    Used for composing Type values.
+    Normally you'll use a precomposed Type... value, but you can compose a
+    custom Type... value by combining a value from InType with a value from
+    OutType using MakeType.
+
+    The InType tells the pipeline how to encode the field's payload (primarily
+    how to determine payload size). In addition, each InType has an implicit
+    default formatting behavior that will be used if not overridden by an
+    OutType.
+
+    The comments for each InType value indicate the payload encoding rules and
+    the OutTypes that are most likely to be usable with this InType.
+    */
+    enum InType : UINT8;
+
+    /*
+    Used for composing Type values.
+    Normally you'll use a precomposed Type... value, but you can compose a
+    custom Type... value by combining a value from InType with a value from
+    OutType using MakeType.
+
+    The OutType gives the pipeline a formatting hint that the trace consumer
+    may use to override the InType's default formatting behavior. If no
+    OutType is specified (i.e. if OutTypeDefault is used) or if the trace
+    consumer does not recognize the specified InType+OutType combination, the
+    trace consumer will perform default formatting based solely on InType.
+
+    The comments for each OutType indicate the InTypes for which the OutType
+    might have valid semantics. However, most trace consumer only recognize a
+    small subset of the "valid" InType+OutType combinations, so even if the
+    semantics are valid, the OutType might still be ignored by the trace
+    consumer. The most commonly-supported combinations are the combinations
+    with corresponding precomposed Type... values.
+    */
+    enum OutType : UINT8;
+
+    /*
+    enum ProviderTraitType (low-level API):
+
+    The type of a provider trait. Used when building up provider metadata.
+    */
+    enum ProviderTraitType : UINT8;
+
+    /*
+    macro TLD_HAVE_EVENT_SET_INFORMATION (low-level API):
+
+    Configuration macro for controlling the behavior of SetInformation.
+
+    Not all versions of Windows support the EventSetInformation API. The
+    tld::SetInformation wrapper provides default behavior that works well in
+    most cases, but may not meet the needs of all users. The configuration
+    macros can be used to control how the tld::SetInformation function invokes
+    the EventSetInformation API. (Note that tld::SetInformation is called
+    automatically by the Provider class's constructor to register the
+    provider's traits with ETW.)
+
+    When TLD_HAVE_EVENT_SET_INFORMATION is not defined and WINVER < 0x0602:
+    SetInformation uses GetModuleHandleExW+GetProcAddress to find the
+    EventSetInformation function. If found, SetInformation calls it and
+    returns whatever EventSetInformation returns. Otherwise, SetInformation
+    returns an error.
+
+    When TLD_HAVE_EVENT_SET_INFORMATION is not defined and WINVER >= 0x0602:
+    SetInformation directly calls the EventSetInformation(...) function and
+    returns whatever EventSetInformation returns.
+
+    If you set TLD_HAVE_EVENT_SET_INFORMATION:
+    - If TLD_HAVE_EVENT_SET_INFORMATION == 0, SetInformation always returns an
+      error.
+    - If TLD_HAVE_EVENT_SET_INFORMATION == 1, SetInformation calls
+      EventSetInformation.
+    - If TLD_HAVE_EVENT_SET_INFORMATION == 2, SetInformation locates
+      EventSetInformation via GetProcAddress.
+    */
+#ifndef TLD_HAVE_EVENT_SET_INFORMATION
+  #if WINVER < 0x0602 // If targeting Windows before Windows 8
+    #define TLD_HAVE_EVENT_SET_INFORMATION 2 // Find "EventSetInformation" via GetModuleHandleExW/GetProcAddress
+  #else
+    #define TLD_HAVE_EVENT_SET_INFORMATION 1 // Directly invoke EventSetInformation(...)
+  #endif
+#endif // TLD_HAVE_EVENT_SET_INFORMATION
+
+    /*
+    macro TLD_HAVE_EVENT_WRITE_EX (low-level API):
+
+    Configuration macro for enabling/disabling WriteEventEx, WriteEx.
+
+    If TLD_HAVE_EVENT_WRITE_EX is not defined and WINVER < 0x0601, or
+    if TLD_HAVE_EVENT_WRITE_EX is defined as 0,
+    then the WriteEventEx, WriteEx, and related APIs will not be available.
+
+    If TLD_HAVE_EVENT_WRITE_EX is not defined and WINVER >= 0x0601, or
+    if TLD_HAVE_EVENT_WRITE_EX is defined as 1,
+    then the WriteEventEx, WriteEx, and related APIs will be available.
+    */
+#ifndef TLD_HAVE_EVENT_WRITE_EX
+  #if WINVER < 0x0601 // If targeting Windows before Windows 7
+    #define TLD_HAVE_EVENT_WRITE_EX 0
+  #else
+    #define TLD_HAVE_EVENT_WRITE_EX 1
+  #endif
+#endif // TLD_HAVE_EVENT_WRITE_EX
+
+
+    /*
+    class ProviderMetadataBuilder (low-level API):
+
+    Helper for building the provider metadata blob.
+    The type provided for ByteBufferTy must behave like a std::vector<BYTE>.
+
+    Example usage:
+
+        std::vector<BYTE> byteVector;
+        tld::ProviderMetadataBuilder<std::vector<BYTE>> builder(byteVector);
+        builder.Begin(szProviderName); // Note: calls byteVector.clear().
+        if (builder.End()) // Returns false if the metadata is too large.
+        {
+            // byteVector now contains a valid provider metadata blob.
+        }
+    */
+    template<class ByteBufferTy>
+    class ProviderMetadataBuilder;
+
+    /*
+    class EventMetadataBuilder (low-level API):
+
+    Helper for building the event metadata blob, including field definitions.
+    The type provided for ByteBufferTy must behave like a std::vector<BYTE>.
+
+    Example usage:
+
+        std::vector<BYTE> byteVector;
+        tld::EventMetadataBuilder<std::vector<BYTE>> builder(byteVector);
+        builder.Begin(eventName); // Note: calls byteVector.clear().
+        builder.AddField("Field1", TypeBOOL32); // top-level field
+        auto  struct1 = builder.AddStruct("Struct1");
+        struct1.AddField("Nested1", TypeINT32) // nested field
+        struct1.AddField("Nested2", TypeANSISTRING); // nested field
+        if (builder.End()) // Returns false if the metadata is too large.
+        {
+            // byteVector now contains a valid event metadata blob.
+        }
+    */
+    template<class ByteBufferTy>
+    class EventMetadataBuilder;
+
+    /*
+    class EventDataBuilder (low-level API):
+
+    Helpers for adding event data to an event data blob.
+    The type provided for ByteBufferTy must behave like a std::vector<BYTE>.
+    */
+    template<class ByteBufferTy>
+    class EventDataBuilder;
+
+    /*
+    class EventDescriptor (low-level API):
+
+    Derives from EVENT_DESCRIPTOR. Adds convenient constructor and Reset
+    members. Contains an event's Id/Version/Level/Opcode/Task/Keyword
+    settings. Use of this class is optional - you can use this class if you
+    want to use the constructor or Reset methods, or you can use
+    EVENT_DESCRIPTOR directly if you don't need the convenience methods.
+    */
+    struct EventDescriptor;
+
+    /*
+    class ByteArrayWrapper (low-level API):
+
+    Adapter that allows a regular BYTE array (stack-allocated or
+    manually-allocated) to be used as the buffer in MetadataBuilder
+    operations. If the underlying BYTE array is too small, or if no array is
+    provided at all, this adapter will stop writing data beyond the end of the
+    array, but will continue to "accept" data (and will increment it size
+    member accordingly). This allows you to determine the size of the required
+    array so that the operation can be retried with a correctly-sized array.
+
+    Example usage:
+
+        // Create a wrapper with a default (0-length) buffer.
+        tld::ByteArrayWrapper wrapper;
+
+        // Create a metadata builder attached to the wrapper.
+        tld::ProviderMetadataBuilder<tld::ByteArrayWrapper> builder(wrapper);
+
+        // Determine the size needed for provider metadata.
+        builder.Begin(providerName);
+        builder.End();
+
+        // Allocate a real buffer and reset the wrapper to use it.
+        BYTE* pBuffer = new BYTE[wrapper.size()];
+        wrapper.reset(pBuffer, wrapper.size());
+
+        // Redo the operation with the real buffer.
+        builder.Begin(providerName);
+        if (builder.End())
+        {
+            // pBuffer now contains a valid provider metadata blob.
+        }
+    */
+    class ByteArrayWrapper;
+
+    /*
+    function RegisterProvider (low-level API):
+
+    Calls EventRegister. If EventRegister succeeds, calls EventSetInformation
+    to register your provider traits with ETW. Use this instead of calling
+    EventRegister directly to ensure that your provider traits are properly
+    registered.
+    */
+    inline HRESULT RegisterProvider(
+        _Out_ REGHANDLE* phProvider,
+        _In_ GUID const* pProviderId,
+        _In_count_x_((UINT16*)pProviderMetadata) UINT8 const* pProviderMetadata,
+        _In_opt_ PENABLECALLBACK pEnableCallback = 0,
+        _In_opt_ void* pEnableCallbackContext = 0);
+
+    /*
+    function UnregisterProvider (low-level API):
+
+    Calls EventUnregister.
+    */
+    inline HRESULT UnregisterProvider(
+        REGHANDLE hProvider);
+
+    /*
+    function WriteEvent (low-level API):
+
+    Calls EventWriteTransfer. You must provide 2 more data descriptors than
+    are required for your data. The first two elements in pDataDescriptors
+    will be used for provider and event metadata. The actual payload (if any)
+    is expected to be in the remaining elements of pDataDescriptors.
+
+    Example usage:
+
+        tld::EventDescriptor eventDescriptor(
+            level,
+            opcode,
+            task,
+            keywords);
+        EVENT_DATA_DESCRIPTOR pDataDescriptors[cFields + 2];
+        for (int i = 0; i < cFields; i++)
+        {
+            EventDataDescCreate(&pDataDescriptors[i + 2], ...);
+        }
+        tld::WriteEvent(
+            hProvider,
+            eventDescriptor,
+            pProviderMetadata,
+            pEventMetadata,
+            cFields + 2,
+            pDataDescriptors);
+    */
+    inline HRESULT WriteEvent(
+        _In_ REGHANDLE hProvider,
+        _In_ EVENT_DESCRIPTOR const& eventDescriptor,
+        _In_count_x_((UINT16*)pProviderMetadata) UINT8 const* pProviderMetadata,
+        _In_count_x_((UINT16*)pEventMetadata) UINT8 const* pEventMetadata,
+        _In_range_(2, 128) ULONG cDataDescriptors,
+        _Inout_count_(cDataDescriptors) EVENT_DATA_DESCRIPTOR* pDataDescriptors,
+        _In_opt_ GUID const* pActivityId = 0,
+        _In_opt_ GUID const* pRelatedActivityId = 0);
+
+#if TLD_HAVE_EVENT_WRITE_EX == 1
+
+    /*
+    function WriteEventEx (low-level API):
+    Calls EventWriteEx. Otherwise works like the WriteEvent function.
+    */
+    inline HRESULT WriteEventEx(
+        _In_ REGHANDLE hProvider,
+        _In_ EVENT_DESCRIPTOR const& eventDescriptor,
+        _In_count_x_((UINT16*)pProviderMetadata) UINT8 const* pProviderMetadata,
+        _In_count_x_((UINT16*)pEventMetadata) UINT8 const* pEventMetadata,
+        _In_range_(2, 128) ULONG cDataDescriptors,
+        _Inout_count_(cDataDescriptors) EVENT_DATA_DESCRIPTOR* pDataDescriptors,
+        ULONG64 filter = 0,
+        ULONG flags = 0,
+        _In_opt_ GUID const* pActivityId = 0,
+        _In_opt_ GUID const* pRelatedActivityId = 0);
+
+#endif // TLD_HAVE_EVENT_WRITE_EX
+
+    /*
+    function SetInformation (low-level API):
+
+    Wrapper for ETW API EventSetInformation.
+    If TraceLoggingDynamic.cpp was compiled to require Win8 or later (as
+    determined by WINVER), this directly calls EventSetInformation. Otherwise,
+    this attempts to dynamically load the EventSetInformation API via
+    GetModuleHandleExW.
+
+    The behavior of this function (e.g. to override the WINVER check) can be
+    adjusted by setting the TLD_HAVE_EVENT_SET_INFORMATION macro as described
+    below.
+    */
+    inline HRESULT SetInformation(
+        _In_ REGHANDLE hProvider,
+        EVENT_INFO_CLASS informationClass,
+        _In_reads_bytes_opt_(cbInformation) void* pbInformation,
+        ULONG cbInformation);
+
+    /*
+    function GetGuidForName (low-level API):
+
+    Hashes a provider name to generate a GUID. Uses the same GUID generation
+    algorithm as System.Diagnostics.Tracing.EventSource (from .NET) and
+    Windows.Foundation.Diagnostics.LoggingChannel (from Windows Runtime).
+    */
+    inline GUID GetGuidForName(
+        _In_z_ char const* szUtf8Name);
+
+    /*
+    function GetGuidForName (low-level API):
+
+    Hashes a provider name to generate a GUID. Uses the same GUID generation
+    algorithm as .NET System.Diagnostics.Tracing.EventSource and Windows
+    Runtime Windows.Foundation.Diagnostics.LoggingChannel.
+    */
+    inline GUID GetGuidForName(
+        _In_z_ wchar_t const* szUtf16Name);
+
+    /*
+    function PushBackAsUtf8 (low-level API):
+
+    Transcodes a NUL-terminated UTF-16LE string to a NUL-terminated UTF-8
+    string. Intended for use when appending provider/event/field names to
+    metadata buffers.
+    */
+    template<class ByteBufferTy>
+    void PushBackAsUtf8(
+        ByteBufferTy& buffer,
+        _In_z_ wchar_t const* szUtf16);
+
+#pragma endregion
+
+    namespace detail
+    {
+#pragma region Internal macros
+
+#define _tld_MAKE_TYPE(inType, outType) \
+    static_cast<::tld::Type>((inType) | (static_cast<int>(outType) << 8))
+
+#ifndef TLD_DEBUG
+  #if (DBG || defined(DEBUG) || defined(_DEBUG)) && !defined(NDEBUG)
+    #define TLD_DEBUG 1
+  #else // DBG
+    #define TLD_DEBUG 0
+  #endif // DBG
+#endif // TLD_DEBUG
+
+#ifndef _tld_ASSERT
+  #if TLD_DEBUG
+    #define _tld_ASSERT(exp, str) ((void)(!(exp) ? (__annotation(L"Debug", L"AssertFail", L"TraceLogging: " L#exp L" : " L##str), DbgRaiseAssertionFailure(), 0) : 0))
+  #else // TLD_DEBUG
+    #define _tld_ASSERT(exp, str) ((void)0)
+  #endif // TLD_DEBUG
+#endif // _tld_ASSERT
+
+#pragma endregion
+
+#pragma region MetadataBuilderBase
+
+        template<class ByteBufferTy>
+        class MetadataBuilderBase
+        {
+            ByteBufferTy& m_buffer;
+
+            MetadataBuilderBase(MetadataBuilderBase const&); // = delete
+            void operator=(MetadataBuilderBase const&); // = delete
+
+        protected:
+
+            explicit MetadataBuilderBase(ByteBufferTy& buffer)
+                : m_buffer(buffer)
+            {
+                return;
+            }
+
+            void BaseBegin()
+            {
+                m_buffer.clear();
+                AddU16(0); // Metadata size filled in by BaseEnd
+            }
+
+            bool BaseEnd()
+            {
+                auto size = m_buffer.size();
+                _tld_ASSERT(2 <= size, "Begin was not called");
+                SetU16(0, static_cast<UINT16>(size));
+                return size < 32768;
+            }
+
+            void AddBytes(
+                _In_reads_bytes_(cb) void const* p,
+                unsigned cb)
+            {
+                auto pb = static_cast<UINT8 const*>(p);
+                for (unsigned i = 0; i != cb; i++)
+                {
+                    m_buffer.push_back(pb[i]);
+                }
+            }
+
+            void AddString(
+                _In_z_ char const* szUtf8)
+            {
+                for (unsigned i = 0;; i++)
+                {
+                    m_buffer.push_back(szUtf8[i]);
+                    if (szUtf8[i] == 0)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            void AddString(
+                _In_z_ wchar_t const* szUtf16)
+            {
+                PushBackAsUtf8(m_buffer, szUtf16);
+            }
+
+            void AddU8(
+                UINT8 val)
+            {
+                m_buffer.push_back(val);;
+            }
+
+            void AddU16(
+                UINT16 val)
+            {
+                m_buffer.push_back(static_cast<UINT8>(val));
+                m_buffer.push_back(static_cast<UINT8>(val >> 8));
+            }
+
+            UINT32 GetBookmark()
+            {
+                return static_cast<UINT32>(m_buffer.size());
+            }
+
+            void SetU8(
+                UINT32 bookmark,
+                UINT8 val)
+            {
+                _tld_ASSERT(bookmark < m_buffer.size(), "bookmark out of range");
+                m_buffer[bookmark] = val;
+            }
+
+            void SetU16(
+                UINT32 bookmark,
+                UINT16 val)
+            {
+                _tld_ASSERT(1 <= bookmark + 1, "bookmark out of range");
+                SetU8(bookmark + 0, static_cast<UINT8>(val));
+                SetU8(bookmark + 1, static_cast<UINT8>(val >> 8));
+            }
+
+            void IncrementU7(
+                UINT32 bookmark)
+            {
+                _tld_ASSERT(bookmark < m_buffer.size(), "bookmark out of range");
+                UINT8 result;
+                result = ++m_buffer[bookmark];
+                _tld_ASSERT((result & 0x7f) != 0, "too many fields in struct");
+            }
+
+        public:
+
+            ByteBufferTy& GetBuffer()
+            {
+                return m_buffer;
+            }
+
+            ByteBufferTy const& GetBuffer() const
+            {
+                return m_buffer;
+            }
+        };
+
+#pragma endregion
+
+#pragma region Sha1ForNonSecretPurposes
+
+        /*
+        Implements the SHA1 hashing algorithm. Note that this implementation is
+        for hashing public information. Do not use this code to hash private data,
+        as this implementation does not take any steps to avoid information
+        disclosure (i.e. does not scrub its buffers).
+        */
+        class Sha1ForNonSecretPurposes
+        {
+            Sha1ForNonSecretPurposes(Sha1ForNonSecretPurposes const&); // = delete
+            void operator=(Sha1ForNonSecretPurposes const&); // = delete
+
+            UINT64 m_length; // Total message length in bits
+            unsigned m_pos; // Length of current chunk in bytes
+            UINT32 m_results[5];
+            UINT32 m_w[80]; // Workspace
+
+        public:
+
+            Sha1ForNonSecretPurposes()
+                : m_length()
+                , m_pos()
+            {
+                m_results[0] = 0x67452301;
+                m_results[1] = 0xEFCDAB89;
+                m_results[2] = 0x98BADCFE;
+                m_results[3] = 0x10325476;
+                m_results[4] = 0xC3D2E1F0;
+            }
+
+            void Append(
+                _In_reads_bytes_(cbInput) void const* pInput,
+                unsigned cbInput)
+            {
+                for (unsigned i = 0; i != cbInput; i++)
+                {
+                    Append(static_cast<UINT8 const*>(pInput)[i]);
+                }
+            }
+
+            void Append(UINT8 input)
+            {
+                reinterpret_cast<UINT8*>(m_w)[m_pos++] = input;
+                if (64 == m_pos)
+                {
+                    Drain();
+                }
+            }
+
+            _Ret_bytecount_(20) UINT8* Finish()
+            {
+                UINT64 totalBitCount = m_length + 8 * m_pos;
+                Append(0x80);
+                while (m_pos != 56)
+                {
+                    Append(0x00);
+                }
+
+                *reinterpret_cast<UINT64*>(m_w + 14) = _byteswap_uint64(totalBitCount);
+                Drain();
+
+                for (unsigned i = 0; i != 5; i++)
+                {
+                    m_results[i] = _byteswap_ulong(m_results[i]);
+                }
+
+                return reinterpret_cast<UINT8*>(m_results);
+            }
+
+        private:
+
+            void Drain()
+            {
+                for (unsigned i = 0; i != 16; i++)
+                {
+                    m_w[i] = _byteswap_ulong(m_w[i]);
+                }
+
+                for (unsigned i = 16; i != 80; i++)
+                {
+                    m_w[i] = _rotl((m_w[i - 3] ^ m_w[i - 8] ^ m_w[i - 14] ^ m_w[i - 16]), 1);
+                }
+
+                UINT32 a = m_results[0];
+                UINT32 b = m_results[1];
+                UINT32 c = m_results[2];
+                UINT32 d = m_results[3];
+                UINT32 e = m_results[4];
+
+                for (unsigned i = 0; i != 20; i++)
+                {
+                    UINT32 const k = 0x5A827999;
+                    UINT32 f = (b & c) | ((~b) & d);
+                    UINT32 temp = _rotl(a, 5) + f + e + k + m_w[i]; e = d; d = c; c = _rotl(b, 30); b = a; a = temp;
+                }
+
+                for (unsigned i = 20; i != 40; i++)
+                {
+                    const UINT32 k = 0x6ED9EBA1;
+                    UINT32 f = b ^ c ^ d;
+                    UINT32 temp = _rotl(a, 5) + f + e + k + m_w[i]; e = d; d = c; c = _rotl(b, 30); b = a; a = temp;
+                }
+
+                for (unsigned i = 40; i != 60; i++)
+                {
+                    const UINT32 k = 0x8F1BBCDC;
+                    UINT32 f = (b & c) | (b & d) | (c & d);
+                    UINT32 temp = _rotl(a, 5) + f + e + k + m_w[i]; e = d; d = c; c = _rotl(b, 30); b = a; a = temp;
+                }
+
+                for (unsigned i = 60; i != 80; i++)
+                {
+                    const UINT32 k = 0xCA62C1D6;
+                    UINT32 f = b ^ c ^ d;
+                    UINT32 temp = _rotl(a, 5) + f + e + k + m_w[i]; e = d; d = c; c = _rotl(b, 30); b = a; a = temp;
+                }
+
+                m_results[0] += a;
+                m_results[1] += b;
+                m_results[2] += c;
+                m_results[3] += d;
+                m_results[4] += e;
+
+                m_length += 512; // 64 bytes == 512 bits
+                m_pos = 0;
+            }
+        };
+
+#pragma endregion
+
+#pragma region CopyUtfCodePoint
+
+        /*
+        Transcodes one code point from UTF-8 to UTF-16LE.
+    
+        Note that this function requires the input buffer to be nul-terminated.
+        This function may try to read several bytes from the input buffer, and the
+        nul-termination is required to ensure that it doesn't read off the end of
+        the valid buffer when decoding what appears to be a multi-byte code point.
+
+        The UTF-8 validation is very permissive -- anything that is not valid
+        UTF-8 is treated as if it were ISO-8859-1 (i.e. the BYTE value is cast
+        to wchar_t and assumed to be a valid Unicode code point). This usually
+        works well - it has a reasonable probability of doing what the developer
+        expects even when the input is CP1252/Latin1 instead of UTF-8, and doesn't
+        fail too badly when it doesn't do what the developer expects.
+
+        pchUtf16Output:
+        Buffer that receives a single code point, encoded in UTF-16-LE as one or
+        two 16-bit wchar_t values.
+    
+        pszUtf8Input:
+        Pointer into a nul-terminated UTF-8 byte sequence. On entry, this points
+        to the next char to be consumed. This function will advance the pointer
+        past the consumed data.
+
+        returns:
+        The number of 16-bit wchar_t values added to pchUtf16Output (one or two).
+        */
+        static unsigned CopyUtfCodePoint(
+            _Out_writes_to_(2, return) wchar_t* pchUtf16Output,
+            char const*& pszUtf8Input)
+        {
+            unsigned cchOutput = 1;
+            unsigned ch = static_cast<unsigned char>(*pszUtf8Input);
+            pszUtf8Input += 1;
+            if (ch <= 0xbf)
+            {
+                // 0x01..0x7f: ASCII - pass through.
+                // 0x80..0xbf: Invalid - pass through.
+            }
+            else if ((pszUtf8Input[0] & 0xc0) != 0x80)
+            {
+                // Invalid trail byte - pass through.
+            }
+            else if (ch <= 0xdf)
+            {
+                // 0xc0..0xdf: Two-byte encoding for 0x0080..0x07ff.
+                unsigned ch2 = ((ch & 0x1f) << 6)
+                    | (pszUtf8Input[0] & 0x3f);
+                if (0x0080 <= ch2)
+                {
+                    ch = ch2;
+                    pszUtf8Input += 1;
+                }
+            }
+            else if ((pszUtf8Input[1] & 0xc0) != 0x80)
+            {
+                // Invalid trail byte - pass through.
+            }
+            else if (ch <= 0xef)
+            {
+                // 0xe0..0xef: Three-byte encoding for 0x0800..0xffff.
+                unsigned ch2 = ((ch & 0x0f) << 12)
+                    | ((pszUtf8Input[0] & 0x3f) << 6)
+                    | (pszUtf8Input[1] & 0x3f);
+                if (0x0800 <= ch2)
+                {
+                    ch = ch2;
+                    pszUtf8Input += 2;
+                }
+            }
+            else if ((pszUtf8Input[2] & 0xc0) != 0x80)
+            {
+                // Invalid trail byte - pass through.
+            }
+            else if (ch <= 0xf4)
+            {
+                // 0xf0..0xf4: Four-byte encoding for 0x010000..0x10ffff.
+                unsigned ch2 = ((ch & 0x07) << 18)
+                    | ((pszUtf8Input[0] & 0x3f) << 12)
+                    | ((pszUtf8Input[1] & 0x3f) << 6)
+                    | (pszUtf8Input[2] & 0x3f);
+                ch2 -= 0x10000;
+                if (ch2 <= 0xfffff)
+                {
+                    // Decode into surrogate pair (2 wchar_t units)
+                    pchUtf16Output[1] = static_cast<wchar_t>(0xdc00 | (ch2 & 0x3ff));
+                    ch = 0xd800 | (ch2 >> 10);
+                    pszUtf8Input += 3;
+                    cchOutput = 2;
+                }
+            }
+
+            pchUtf16Output[0] = static_cast<wchar_t>(ch);
+            return cchOutput;
+        }
+
+        /*
+        Copies one code point of UTF-16LE data.
+
+        Note that this function requires the input buffer to be nul-terminated.
+        This function may try to read several words from the input buffer, and the
+        nul-termination is required to ensure that it doesn't read off the end of
+        the valid buffer when copying what appears to be a surrogate pair.
+
+        pchUtf16Output:
+        Buffer that receives a single code point, encoded in UTF-16-LE as one or
+        two 16-bit wchar_t values.
+
+        pszUtf16Input:
+        Pointer into a nul-terminated UTF-16-LE wchar_t sequence. On entry, this
+        points to the next wchar_t to be consumed. This function will advance the
+        pointer past the consumed data.
+
+        returns:
+        The number of 16-bit wchar_t values added to pchUtf16Output (one or two).
+        */
+        static unsigned CopyUtfCodePoint(
+            _Out_writes_to_(2, return) wchar_t* pchUtf16Output,
+            wchar_t const*& pszUtf16Input)
+        {
+            unsigned cchOutput = 1;
+            wchar_t ch = *pszUtf16Input;
+            pszUtf16Input += 1;
+            if (0xd800 <= ch && ch < 0xdc00 &&
+                0xdc00 <= *pszUtf16Input && *pszUtf16Input < 0xe000)
+            {
+                pchUtf16Output[1] = *pszUtf16Input;
+                pszUtf16Input += 1;
+                cchOutput = 2;
+            }
+            pchUtf16Output[0] = ch;
+            return cchOutput;
+        }
+
+#pragma endregion
+
+#pragma region GetGuidForNameImpl
+
+        __declspec(selectany) extern UINT32 const NamespaceValue[] = {
+            0xB22D2C48, 0xC84790C3, 0x151AF887, 0xFB30C1Bf
+        };
+
+        template<class CharTy>
+        GUID GetGuidForNameImpl(
+            _In_z_ CharTy const* szUtfName)
+        {
+            /*
+            Algorithm:
+            szNameUpperBE = ByteSwap(ToUpper(szName));
+            hash = SHA1(namespaceBytes + szNameUpperBE); // Does not include zero-termination in hash.
+            hash[7] = (hash[7] & 0x0F) | 0x50;
+            guid = First16Bytes(hash);
+            */
+
+            WCHAR buffer[16];
+            unsigned const cchBuffer = ARRAYSIZE(buffer);
+            Sha1ForNonSecretPurposes sha1;
+
+            sha1.Append(NamespaceValue, sizeof(NamespaceValue));
+            if (szUtfName[0] != 0)
+            {
+                CharTy const* pszName = szUtfName;
+                unsigned iBuffer = 0;
+                for (;;)
+                {
+                    // CopyUtfCodePoint may add up to 2 wchar_t units to buffer.
+                    iBuffer += CopyUtfCodePoint(buffer + iBuffer, pszName);
+                    _tld_ASSERT(iBuffer <= cchBuffer, "buffer overflow");
+
+                    bool const bDone = *pszName == 0;
+                    if (bDone || cchBuffer - 1 <= iBuffer)
+                    {
+    #pragma warning(suppress: 26035) // string is counted, not nul-terminated.
+                        LCMapStringEx(
+                            LOCALE_NAME_INVARIANT,
+                            LCMAP_UPPERCASE | LCMAP_BYTEREV,
+                            buffer,
+                            iBuffer,
+                            buffer,
+                            iBuffer,
+                            NULL,
+                            NULL,
+                            0);
+                        sha1.Append(buffer, iBuffer * 2);
+
+                        if (bDone)
+                        {
+                            break;
+                        }
+
+                        iBuffer = 0;
+                    }
+                }
+            }
+
+            UINT8* pSha1 = sha1.Finish();
+
+            // Set high 4 bits of octet 7 to 5, as per RFC 4122
+            pSha1[7] = (pSha1[7] & 0x0f) | 0x50;
+
+            return *reinterpret_cast<GUID*>(pSha1);
+        }
+
+#pragma endregion
+    }
+    // namespace detail
+
+#pragma region Enumerations
+
+    enum InType : UINT8
+    {
+        /*
+        A field with no value (0-length payload).
+        Arrays of InTypeNull are illegal.
+        */
+        InTypeNull,
+
+        /*
+        A nul-terminated CHAR16 string.
+        Useful OutTypes: Xml, Json.
+        */
+        InTypeUnicodeString,
+
+        /*
+        A nul-terminated CHAR8 string.
+        Useful OutTypes: Xml, Json, Utf8.
+        */
+        InTypeAnsiString,
+
+        /*
+        INT8.
+        */
+        InTypeInt8,
+
+        /*
+        UINT8.
+        Useful OutTypes: String, Boolean, Hex.
+        */
+        InTypeUInt8,
+
+        /*
+        INT16.
+        */
+        InTypeInt16,
+
+        /*
+        UINT16.
+        Useful OutTypes: String, Hex, Port.
+        */
+        InTypeUInt16,
+
+        /*
+        INT32.
+        Useful OutTypes: HResult.
+        */
+        InTypeInt32,
+
+        /*
+        UINT32.
+        Useful OutTypes: Pid, Tid, IPv4, Win32Error, NTStatus.
+        */
+        InTypeUInt32,
+
+        /*
+        INT64.
+        */
+        InTypeInt64,
+
+        /*
+        UINT64.
+        */
+        InTypeUInt64,
+
+        /*
+        FLOAT.
+        */
+        InTypeFloat,
+
+        /*
+        DOUBLE.
+        */
+        InTypeDouble,
+
+        /*
+        BOOL.
+        */
+        InTypeBool32,
+
+        /*
+        UINT16 byte-count followed by binary data.
+        Useful OutTypes: IPv6, SocketAddress.
+        Arrays of InTypeBinary are not supported. (No error will be reported,
+        but decoding tools will probably not be able to decode them).
+        */
+        InTypeBinary,
+
+        /*
+        GUID.
+        */
+        InTypeGuid,
+
+        /*
+        Not supported. Use InTypePointer. (No error will be reported,
+        but decoding tools will probably not be able to decode them).
+        */
+        InTypePointer_PlatformSpecific,
+
+        /*
+        FILETIME.
+        */
+        InTypeFileTime,
+
+        /*
+        SYSTEMTIME.
+        */
+        InTypeSystemTime,
+
+        /*
+        SID. Size is determined from the number of subauthorities.
+        */
+        InTypeSid,
+
+        /*
+        INT32.
+        */
+        InTypeHexInt32,
+
+        /*
+        INT64.
+        */
+        InTypeHexInt64,
+
+        /*
+        UINT16 byte-count followed by UTF-16 data.
+        */
+        InTypeCountedString,
+
+        /*
+        UINT16 byte-count followed by MBCS data.
+        */
+        InTypeCountedAnsiString,
+
+        /*
+        This field has no value by itself, but it causes the decoder to treat
+        the next N fields as part of this field. The value of N is taken from
+        the field's OutType.
+
+        Note that it is valid to have an array of structs. The array length
+        will apply to the entire group of fields contained in the array.
+
+        The Struct type is special. Do not use it directly. Use helper APIs to
+        create nested structures.
+        */
+        InTypeStruct,
+
+        /*
+        INT_PTR.
+        InTypeIntPtr is an alias for either InTypeInt32 or InTypeInt64.
+        */
+        InTypeIntPtr = sizeof(void*) == 8 ? InTypeInt64 : InTypeInt32,
+
+        /*
+        UINT_PTR.
+        InTypeUIntPtr is an alias for either InTypeUInt32 or InTypeUInt64.
+        */
+        InTypeUIntPtr = sizeof(void*) == 8 ? InTypeUInt64 : InTypeUInt32,
+
+        /*
+        LPVOID.
+        InTypePointer is an alias for either InTypeHexInt32 or InTypeHexInt64.
+        */
+        InTypePointer = sizeof(void*) == 8 ? InTypeHexInt64 : InTypeHexInt32,
+
+        /*
+        InType must fit in 5 bits.
+        */
+        InTypeMask = 31
+    };
+
+    enum OutType : UINT8
+    {
+        OutTypeDefault = 0x00,
+        OutTypeNoPrint = 0x01,
+        OutTypeString = 0x02,    // affects 8-bit and 16-bit integral types.
+        OutTypeBoolean = 0x03,   // affects 8-bit and 32-bit integral types.
+        OutTypeHex = 0x04,       // affects integral types.
+        OutTypePid = 0x05,       // affects 32-bit integral types.
+        OutTypeTid = 0x06,       // affects 32-bit integral types.
+        OutTypePort = 0x07,      // affects 16-bit integral types.
+        OutTypeIPv4 = 0x08,      // affects 32-bit integral types.
+        OutTypeIPv6 = 0x09,      // affects arrays of 8-bit integral types, e.g. UInt8[].
+        OutTypeSocketAddress = 0x0a, // affects arrays of 8-bit integral types, e.g. UInt8[].
+        OutTypeXml = 0x0b,       // affects strings; affects arrays of 8-bit and 16-bit integral types.
+        OutTypeJson = 0x0c,      // affects strings; affects arrays of 8-bit and 16-bit integral types.
+        OutTypeWin32Error = 0x0d,// affects 32-bit integral types.
+        OutTypeNTStatus = 0x0e,  // affects 32-bit integral types.
+        OutTypeHResult = 0x0f,   // affects 32-bit integral types.
+        OutTypeFileTime = 0x10,  // affects 64-bit integral types.
+        OutTypeSigned = 0x11,    // affects integral types.
+        OutTypeUnsigned = 0x12,  // affects integral types.
+        OutTypeDateTimeCultureInsensitive = 0x21, // affects FileTime, SystemTime.
+        OutTypeUtf8 = 0x23,      // affects AnsiString types.
+        OutTypePkcs7WithTypeInfo = 0x24, // affects binary types.
+        OutTypeCodePointer = 0x25, // affects UInt32, UInt64, HexInt32, HexInt64.
+        OutTypeDateTimeUtc = 0x26, // affects FileTime, SystemTime.
+        OutTypeMask = 0x7f // OutType must fit into 7 bits.
+    };
+
+    enum Type : UINT16
+    {
+        /*
+        Field with no data (empty). 0-length payload.
+        Can only be used on scalar fields. Illegal for arrays.
+        NOTE: Not well-supported by decoders.
+        */
+        TypeNone = InTypeNull,
+
+        /*
+        Encoding assumes 0-terminated CHAR16 string.
+        Formatting treats as UTF-16LE string.
+        */
+        TypeUtf16String = InTypeUnicodeString,
+
+        /*
+        Encoding assumes 0-terminated CHAR8 string.
+        Formatting treats as MBCS string.
+        */
+        TypeMbcsString = InTypeAnsiString,
+
+        /*
+        Encoding assumes nul-terminated CHAR8 string.
+        Formatting treats as UTF-8 string.
+        */
+        TypeUtf8String = _tld_MAKE_TYPE(InTypeAnsiString, OutTypeUtf8),
+
+        /*
+        Encoding assumes 1-byte value.
+        Formatting treats as signed integer.
+        */
+        TypeInt8 = InTypeInt8,
+
+        /*
+        Encoding assumes 1-byte value.
+        Formatting treats as unsigned integer.
+        */
+        TypeUInt8 = InTypeUInt8,
+
+        /*
+        Encoding assumes 2-byte value.
+        Formatting treats as signed integer.
+        */
+        TypeInt16 = InTypeInt16,
+
+        /*
+        Encoding assumes 2-byte value.
+        Formatting treats as unsigned integer.
+        */
+        TypeUInt16 = InTypeUInt16,
+
+        /*
+        Encoding assumes 4-byte value.
+        Formatting treats as signed integer.
+        */
+        TypeInt32 = InTypeInt32,
+
+        /*
+        Encoding assumes 4-byte value.
+        Formatting treats as unsigned integer.
+        */
+        TypeUInt32 = InTypeUInt32,
+
+        /*
+        Encoding assumes 8-byte value.
+        Formatting treats as signed integer.
+        */
+        TypeInt64 = InTypeInt64,
+
+        /*
+        Encoding assumes 8-byte value.
+        Formatting treats as unsigned integer.
+        */
+        TypeUInt64 = InTypeUInt64,
+
+        /*
+        Encoding assumes 4-byte value.
+        Formatting treats as Float32.
+        */
+        TypeFloat = InTypeFloat,
+
+        /*
+        Encoding assumes 8-byte value.
+        Formatting treats as Float64.
+        */
+        TypeDouble = InTypeDouble,
+
+        /*
+        Encoding assumes 4-byte value.
+        Formatting treats as Boolean.
+        */
+        TypeBool32 = InTypeBool32,
+
+        /*
+        Encoding assumes 2-byte length followed by binary data.
+        Formatting treats as binary blob.
+        Arrays of TypeBinary are not supported. (No error will be reported,
+        but decoding tools will probably not be able to decode them).
+        */
+        TypeBinary = InTypeBinary,
+
+        /*
+        Encoding assumes 16-byte value.
+        Formatting treats as GUID.
+        */
+        TypeGuid = InTypeGuid,
+
+        /*
+        Encoding assumes 8-byte value.
+        Formatting treats as FILETIME.
+        */
+        TypeFileTime = InTypeFileTime,
+
+        /*
+        Encoding assumes 16-byte value.
+        Formatting treats as SYSTEMTIME.
+        */
+        TypeSystemTime = InTypeSystemTime,
+
+        /*
+        Encoding assumes 16-byte value.
+        Formatting treats as UTC SYSTEMTIME.
+        */
+        TypeSystemTimeUtc = _tld_MAKE_TYPE(InTypeSystemTime, OutTypeDateTimeUtc),
+
+        /*
+        Encoding assumes SID. Length is determined from number of subauthorities.
+        Formatting treats as a SID.
+        */
+        TypeSid = InTypeSid,
+
+        /*
+        Encoding assumes 4-byte value.
+        Formatting treats as hexadecimal unsigned integer.
+        */
+        TypeHexInt32 = InTypeHexInt32,
+
+        /*
+        Encoding assumes 8-byte value.
+        Formatting treats as hexadecimal unsigned integer.
+        */
+        TypeHexInt64 = InTypeHexInt64,
+
+        /*
+        Encoding assumes 2-byte bytecount followed by CHAR16 data.
+        Formatting treats as UTF-16LE string.
+        */
+        TypeCountedUtf16String = InTypeCountedString,
+
+        /*
+        Encoding assumes 2-byte bytecount followed by CHAR8 data.
+        Formatting treats as MBCS string.
+        */
+        TypeCountedMbcsString = InTypeCountedAnsiString,
+
+        /*
+        Encoding assumes 2-byte bytecount followed by CHAR8 data.
+        Formatting treats as UTF-8 string.
+        */
+        TypeCountedUtf8String = _tld_MAKE_TYPE(InTypeCountedAnsiString, OutTypeUtf8),
+
+        /*
+        Encoding assumes pointer-sized value.
+        Formatting treats as signed integer.
+        Note: the value of this enum is different on 32-bit and 64-bit systems.
+        This is an alias for TypeInt32 when compiled for a 32-bit target.
+        This is an alias for TypeInt64 when compiled for a 64-bit target.
+        */
+        TypeIntPtr = InTypeIntPtr,
+
+        /*
+        Encoding assumes pointer-sized value.
+        Formatting treats as unsigned integer.
+        Note: the value of this enum is different on 32-bit and 64-bit systems.
+        This is an alias for TypeUInt32 when compiled for a 32-bit target.
+        This is an alias for TypeUInt64 when compiled for a 64-bit target.
+        */
+        TypeUIntPtr = InTypeUIntPtr,
+
+        /*
+        Encoding assumes pointer-sized value.
+        Formatting treats as hexadecimal unsigned integer.
+        Note: the value of this enum is different on 32-bit and 64-bit systems.
+        This is an alias for TypeHexInt32 when compiled for a 32-bit target.
+        This is an alias for TypeHexInt64 when compiled for a 64-bit target.
+        */
+        TypePointer = InTypePointer,
+
+        /*
+        Encoding assumes pointer-sized value.
+        Formatting treats as code pointer.
+        Note: the value of this enum is different on 32-bit and 64-bit systems.
+        This is a subtype of TypeHexInt32 when compiled for a 32-bit target.
+        This is a subtype of TypeHexInt64 when compiled for a 64-bit target.
+        */
+        TypeCodePointer = _tld_MAKE_TYPE(InTypePointer, OutTypeCodePointer),
+
+        /*
+        Encoding assumes 2-byte value.
+        Formatting treats as UTF-16LE character.
+        */
+        TypeChar16 = _tld_MAKE_TYPE(InTypeUInt16, OutTypeString),
+
+        /*
+        Encoding assumes 1-byte value.
+        Formatting treats as ANSI character.
+        */
+        TypeChar8 = _tld_MAKE_TYPE(InTypeUInt8, OutTypeString),
+
+        /*
+        Encoding assumes 1-byte value.
+        Formatting treats as Boolean.
+        */
+        TypeBool8 = _tld_MAKE_TYPE(InTypeUInt8, OutTypeBoolean),
+
+        /*
+        Encoding assumes 1-byte value.
+        Formatting treats as hexadecimal unsigned integer.
+        */
+        TypeHexInt8 = _tld_MAKE_TYPE(InTypeUInt8, OutTypeHex),
+
+        /*
+        Encoding assumes 2-byte value.
+        Formatting treats as hexadecimal unsigned integer.
+        */
+        TypeHexInt16 = _tld_MAKE_TYPE(InTypeUInt16, OutTypeHex),
+
+        /*
+        Encoding assumes 4-byte value.
+        Formatting treats as process identifier.
+        */
+        TypePid = _tld_MAKE_TYPE(InTypeUInt32, OutTypePid),
+
+        /*
+        Encoding assumes 4-byte value.
+        Formatting treats as thread identifier.
+        */
+        TypeTid = _tld_MAKE_TYPE(InTypeUInt32, OutTypeTid),
+
+        /*
+        Encoding assumes 2-byte value.
+        Formatting treats as big-endian IP port(s).
+        */
+        TypePort = _tld_MAKE_TYPE(InTypeUInt16, OutTypePort),
+
+        /*
+        Encoding assumes 4-byte value.
+        Formatting treats as IPv4 address.
+        */
+        TypeIPv4 = _tld_MAKE_TYPE(InTypeUInt32, OutTypeIPv4),
+
+        /*
+        Encoding assumes 2-byte length followed by binary data.
+        Formatting treats as IPv6 address.
+        Arrays of TypeIPv6 are not supported. (No error will be reported,
+        but decoding tools will probably not be able to decode them).
+        */
+        TypeIPv6 = _tld_MAKE_TYPE(InTypeBinary, OutTypeIPv6),
+
+        /*
+        Encoding assumes 2-byte length followed by binary data.
+        Formatting treats as SOCKADDR.
+        Arrays of TypeSocketAddress are not supported. (No error will be
+        reported, but decoding tools will probably not be able to decode them).
+        */
+        TypeSocketAddress = _tld_MAKE_TYPE(InTypeBinary, OutTypeSocketAddress),
+
+        /*
+        Encoding assumes nul-terminated CHAR16 string.
+        Formatting treats as UTF-16LE XML.
+        */
+        TypeUtf16Xml = _tld_MAKE_TYPE(InTypeUnicodeString, OutTypeXml),
+
+        /*
+        Encoding assumes nul-terminated CHAR8 string.
+        Formatting treats as UTF-8 XML.
+        */
+        TypeMbcsXml = _tld_MAKE_TYPE(InTypeAnsiString, OutTypeXml),
+
+        /*
+        Encoding assumes nul-terminated CHAR16 string.
+        Formatting treats as UTF-16LE JSON.
+        */
+        TypeUtf16Json = _tld_MAKE_TYPE(InTypeUnicodeString, OutTypeJson),
+
+        /*
+        Encoding assumes nul-terminated CHAR8 string.
+        Formatting treats as UTF-8 JSON.
+        */
+        TypeMbcsJson = _tld_MAKE_TYPE(InTypeAnsiString, OutTypeJson),
+
+        /*
+        Encoding assumes 2-byte bytecount followed by CHAR16 data.
+        Formatting treats as UTF-16LE XML.
+        */
+        TypeCountedUtf16Xml = _tld_MAKE_TYPE(InTypeCountedString, OutTypeXml),
+
+        /*
+        Encoding assumes 2-byte bytecount followed by CHAR8 data.
+        Formatting treats as UTF-8 XML.
+        */
+        TypeCountedMbcsXml = _tld_MAKE_TYPE(InTypeCountedAnsiString, OutTypeXml),
+
+        /*
+        Encoding assumes 2-byte bytecount followed by CHAR16 data.
+        Formatting treats as UTF-16LE JSON.
+        */
+        TypeCountedUtf16Json = _tld_MAKE_TYPE(InTypeCountedString, OutTypeJson),
+
+        /*
+        Encoding assumes 2-byte bytecount followed by CHAR8 data.
+        Formatting treats as UTF-8 JSON.
+        */
+        TypeCountedMbcsJson = _tld_MAKE_TYPE(InTypeCountedAnsiString, OutTypeJson),
+
+        /*
+        Encoding assumes 4-byte value.
+        Formatting treats as Win32 error(s).
+        */
+        TypeWin32Error = _tld_MAKE_TYPE(InTypeUInt32, OutTypeWin32Error),
+
+        /*
+        Encoding assumes 4-byte value.
+        Formatting treats as NTSTATUS(s).
+        */
+        TypeNTStatus = _tld_MAKE_TYPE(InTypeUInt32, OutTypeNTStatus),
+
+        /*
+        Encoding assumes 4-byte value.
+        Formatting treats as HRESULT(s).
+        */
+        TypeHResult = _tld_MAKE_TYPE(InTypeInt32, OutTypeHResult)
+    };
+
+    enum ProviderTraitType : UINT8
+    {
+        ProviderTraitNone = 0, // Invalid value
+        ProviderTraitGroupGuid = 1 // Data is the group GUID.
+    };
+
+#pragma endregion
+
+#pragma region EventDescriptor
+
+    /*
+    Simple wrapper around the ETW EVENT_DESCRIPTOR structure.
+    Provides a constructor to make initialization easier.
+    Can be used anywhere an EVENT_DESCRIPTOR is required.
+
+    Notes:
+    - Channel defaults to 11 (WINEVENT_CHANNEL_TRACELOGGING). Other channels
+      will only work if the provider is running on a TraceLogging-enabled OS
+      (Windows 10 or later, or Windows 7 sp1 with updates, or Windows 8.1 with
+      updates). If the provider is running on an earlier version of Windows and
+      you use a channel other than 11, the events will not decode correctly.
+    - If you are not assigning unique Ids for your events, set both Id and
+      Version to 0.
+    */
+    struct EventDescriptor
+        : EVENT_DESCRIPTOR
+    {
+        explicit EventDescriptor(
+            UCHAR level = 5, // 5 = WINEVENT_LEVEL_VERBOSE
+            ULONGLONG keyword = 0, // 0 = no keywords
+            UCHAR opcode = 0, // 0 = WINEVENT_OPCODE_INFO
+            USHORT task = 0) // 0 = WINEVENT_TASK_NONE
+        {
+            Reset(level, keyword, opcode, task);
+        }
+
+        void Reset(
+            UCHAR level = 5, // 5 = WINEVENT_LEVEL_VERBOSE
+            ULONGLONG keyword = 0, // 0 = no keywords
+            UCHAR opcode = 0, // 0 = WINEVENT_OPCODE_INFO
+            USHORT task = 0) // 0 = WINEVENT_TASK_NONE
+        {
+            Id = 0;
+            Version = 0;
+            Channel = 11; // WINEVENT_CHANNEL_TRACELOGGING
+            Level = level;
+            Opcode = opcode;
+            Task = task;
+            Keyword = keyword;
+        }
+    };
+
+#pragma endregion
+
+#pragma region Support functions
+
+#pragma warning(push)
+#pragma warning(disable: 26018) // PREfast: Potential read overflow. (Analysis is incorrect.)
+
+    template<class ByteBufferTy>
+    void PushBackAsUtf8(
+        ByteBufferTy& buffer,
+        _In_z_ wchar_t const* szUtf16)
+    {
+        for (unsigned i = 0;; i++)
+        {
+            unsigned ch = szUtf16[i];
+            if (ch < 0x80)
+            {
+                buffer.push_back(static_cast<UINT8>(ch));
+                if (ch == 0)
+                {
+                    break;
+                }
+            }
+            else if (ch < 0x800)
+            {
+                buffer.push_back(static_cast<UINT8>(((ch >> 6)) | 0xc0));
+                buffer.push_back(static_cast<UINT8>(((ch)& 0x3f) | 0x80));
+            }
+            else if (
+                0xd800 <= ch && ch < 0xdc00 &&
+                0xdc00 <= szUtf16[i + 1] && szUtf16[i + 1] < 0xe000)
+            {
+                // Decode surrogate pair.
+                ++i;
+                ch = 0x010000 + (((ch - 0xd800) << 10) | (szUtf16[i] - 0xdc00));
+                buffer.push_back(static_cast<UINT8>(((ch >> 18)) | 0xf0));
+                buffer.push_back(static_cast<UINT8>(((ch >> 12) & 0x3f) | 0x80));
+                buffer.push_back(static_cast<UINT8>(((ch >> 6) & 0x3f) | 0x80));
+                buffer.push_back(static_cast<UINT8>(((ch)& 0x3f) | 0x80));
+            }
+            else
+            {
+                buffer.push_back(static_cast<UINT8>(((ch >> 12)) | 0xe0));
+                buffer.push_back(static_cast<UINT8>(((ch >> 6) & 0x3f) | 0x80));
+                buffer.push_back(static_cast<UINT8>(((ch)& 0x3f) | 0x80));
+            }
+        }
+    }
+
+#pragma warning(pop)
+
+    inline ::tld::Type MakeType(
+        ::tld::InType inType,
+        ::tld::OutType outType)
+    {
+        return _tld_MAKE_TYPE(inType & InTypeMask, outType & OutTypeMask);
+    }
+
+    _Use_decl_annotations_
+    inline GUID GetGuidForName(
+        wchar_t const* szUtf16Name)
+    {
+        return ::tld::detail::GetGuidForNameImpl(szUtf16Name);
+    }
+
+    _Use_decl_annotations_
+    inline GUID GetGuidForName(
+        char const* szUtf8Name)
+    {
+        return ::tld::detail::GetGuidForNameImpl(szUtf8Name);
+    }
+
+    inline HRESULT RegisterProvider(
+        _Out_ REGHANDLE* phProvider,
+        _In_ GUID const* pProviderId,
+        _In_count_x_((UINT16*)pProviderMetadata) UINT8 const* pProviderMetadata,
+        _In_opt_ PENABLECALLBACK pEnableCallback,
+        _In_opt_ void* pEnableCallbackContext)
+    {
+        HRESULT hr;
+        REGHANDLE hProvider = 0;
+        ULONG status = ::EventRegister(
+            pProviderId,
+            pEnableCallback,
+            pEnableCallbackContext,
+            &hProvider);
+        if (status == 0)
+        {
+            auto cbMetadata = *reinterpret_cast<UINT16 const*>(pProviderMetadata);
+            status = tld::SetInformation(
+                hProvider,
+                static_cast<EVENT_INFO_CLASS>(2), // EventProviderSetTraits
+                const_cast<UINT8*>(pProviderMetadata),
+                cbMetadata);
+            hr = S_OK; // Ignore any failures from SetInformation.
+        }
+        else
+        {
+            hr = HRESULT_FROM_WIN32(status);
+        }
+
+        *phProvider = hProvider;
+        return hr;
+    }
+
+    inline HRESULT UnregisterProvider(
+        REGHANDLE hProvider)
+    {
+        ULONG status = ::EventUnregister(hProvider);
+        return HRESULT_FROM_WIN32(status);
+    }
+
+    _Use_decl_annotations_
+    inline HRESULT SetInformation(
+        REGHANDLE hProvider,
+        EVENT_INFO_CLASS informationClass,
+        void* pvInformation,
+        ULONG cbInformation)
+    {
+        ULONG status;
+
+#if TLD_HAVE_EVENT_SET_INFORMATION == 1
+
+#pragma warning(suppress: 6387) // It's ok for pvInformation to be null if cbInformation is 0.
+        status = ::EventSetInformation(
+            hProvider,
+            informationClass,
+            pvInformation,
+            cbInformation);
+
+#elif TLD_HAVE_EVENT_SET_INFORMATION == 2
+
+        HMODULE hEventing;
+        status = ERROR_NOT_SUPPORTED;
+        if (GetModuleHandleExW(0, L"api-ms-win-eventing-provider-l1-1-0", &hEventing) ||
+            GetModuleHandleExW(0, L"advapi32.dll", &hEventing))
+        {
+            typedef ULONG(WINAPI* PFEventSetInformation)(
+                _In_ REGHANDLE RegHandle,
+                _In_ EVENT_INFO_CLASS InformationClass,
+                _In_reads_bytes_opt_(InformationLength) PVOID EventInformation,
+                _In_ ULONG InformationLength);
+            PFEventSetInformation pfEventSetInformation =
+                (PFEventSetInformation)GetProcAddress(hEventing, "EventSetInformation");
+            if (pfEventSetInformation)
+            {
+                status = pfEventSetInformation(
+                    hProvider,
+                    informationClass,
+                    pvInformation,
+                    cbInformation);
+            }
+
+            FreeLibrary(hEventing);
+        }
+
+#else // TLD_HAVE_EVENT_SET_INFORMATION == 0
+
+        (void)hProvider;
+        (void)informationClass;
+        (void)pvInformation;
+        (void)cbInformation;
+
+        status = ERROR_NOT_SUPPORTED;
+
+#endif // TLD_HAVE_EVENT_SET_INFORMATION
+
+        return HRESULT_FROM_WIN32(status);
+    }
+
+    _Use_decl_annotations_
+    inline HRESULT WriteEvent(
+        REGHANDLE hProvider,
+        EVENT_DESCRIPTOR const& eventDescriptor,
+        UINT8 const* pProviderMetadata,
+        UINT8 const* pEventMetadata,
+        ULONG cDataDescriptors,
+        EVENT_DATA_DESCRIPTOR* pDataDescriptors,
+        LPCGUID pActivityId,
+        LPCGUID pRelatedActivityId)
+    {
+        _tld_ASSERT(3 <= *(UINT16*)pProviderMetadata, "Invalid provider metadata.");
+        _tld_ASSERT(4 <= *(UINT16*)pEventMetadata, "Invalid event metadata.");
+        pDataDescriptors[0].Ptr = (ULONG_PTR)pProviderMetadata;
+        pDataDescriptors[0].Size = *(UINT16*)pProviderMetadata;
+        pDataDescriptors[0].Reserved = 2; // Descriptor contains provider metadata.
+        pDataDescriptors[1].Ptr = (ULONG_PTR)pEventMetadata;
+        pDataDescriptors[1].Size = *(UINT16*)pEventMetadata;
+        pDataDescriptors[1].Reserved = 1; // Descriptor contains event metadata.
+        ULONG status = ::EventWriteTransfer(
+            hProvider,
+            &eventDescriptor,
+            pActivityId,
+            pRelatedActivityId,
+            cDataDescriptors,
+            pDataDescriptors);
+        return HRESULT_FROM_WIN32(status);
+    }
+
+#if TLD_HAVE_EVENT_WRITE_EX == 1
+
+    _Use_decl_annotations_
+    inline HRESULT WriteEventEx(
+        REGHANDLE hProvider,
+        EVENT_DESCRIPTOR const& eventDescriptor,
+        UINT8 const* pProviderMetadata,
+        UINT8 const* pEventMetadata,
+        ULONG cDataDescriptors,
+        EVENT_DATA_DESCRIPTOR* pDataDescriptors,
+        ULONG64 filter,
+        ULONG flags,
+        GUID const* pActivityId,
+        GUID const* pRelatedActivityId)
+    {
+        _tld_ASSERT(3 <= *(UINT16*)pProviderMetadata, "Invalid provider metadata.");
+        _tld_ASSERT(4 <= *(UINT16*)pEventMetadata, "Invalid event metadata.");
+        pDataDescriptors[0].Ptr = (ULONG_PTR)pProviderMetadata;
+        pDataDescriptors[0].Size = *(UINT16*)pProviderMetadata;
+        pDataDescriptors[0].Reserved = 2; // Descriptor contains provider metadata.
+        pDataDescriptors[1].Ptr = (ULONG_PTR)pEventMetadata;
+        pDataDescriptors[1].Size = *(UINT16*)pEventMetadata;
+        pDataDescriptors[1].Reserved = 1; // Descriptor contains event metadata.
+        ULONG status = ::EventWriteEx(
+            hProvider,
+            &eventDescriptor,
+            filter,
+            flags,
+            pActivityId,
+            pRelatedActivityId,
+            cDataDescriptors,
+            pDataDescriptors);
+        return HRESULT_FROM_WIN32(status);
+    }
+
+#endif // TLD_HAVE_EVENT_WRITE_EX
+
+#pragma endregion
+
+#pragma region ByteArrayWrapper
+
+    class ByteArrayWrapper
+    {
+        UINT8* m_pb;
+        UINT32 m_cbMax;
+        UINT32 m_cbCur;
+
+    public:
+
+        ByteArrayWrapper()
+        {
+            reset();
+        }
+
+        ByteArrayWrapper(
+            _Out_writes_(cbMax) UINT8* pb,
+            UINT32 cbMax)
+        {
+            reset(pb, cbMax);
+        }
+
+        void reset()
+        {
+            m_pb = 0;
+            m_cbMax = 0;
+            m_cbCur = 0;
+        }
+
+        void reset(
+            _Inout_updates_bytes_(cbMax) UINT8* pb,
+            UINT32 cbMax)
+        {
+            m_pb = pb;
+            m_cbMax = cbMax;
+            m_cbCur = 0;
+        }
+
+        void clear()
+        {
+            m_cbCur = 0;
+        }
+
+        UINT32 size() const
+        {
+            return m_cbCur;
+        }
+
+        BYTE const& front() const
+        {
+            return *m_pb;
+        }
+
+        BYTE const* data() const
+        {
+            return m_pb;
+        }
+
+        UINT32 capacity() const
+        {
+            return m_cbMax;
+        }
+
+        void push_back(UINT8 val)
+        {
+            if (m_cbCur < m_cbMax)
+            {
+                m_pb[m_cbCur] = val;
+            }
+
+            m_cbCur += 1;
+        }
+
+        UINT8& operator[](UINT32 index)
+        {
+            static UINT8 dummy;
+            return index < m_cbMax
+                ? m_pb[index]
+                : dummy;
+        }
+    };
+
+#pragma endregion
+
+#pragma region ProviderMetadataBuilder
+
+    template<class ByteBufferTy>
+    class ProviderMetadataBuilder
+        : public detail::MetadataBuilderBase<ByteBufferTy>
+    {
+        /*
+        ProviderMetadata =
+        Size    : UINT16; // Size counts the whole data structure, including the Size field.
+        Name    : Nul-terminated UTF-8.
+        Traits[]: ProviderTrait (parse until you have consumed Size bytes)
+
+        ProviderTrait =
+        TraitSize: UINT16;
+        TraitType: UINT8;
+        TraitData: UINT8[TraitSize - 3];
+        */
+
+    public:
+
+        explicit ProviderMetadataBuilder(ByteBufferTy& buffer)
+            : detail::MetadataBuilderBase<ByteBufferTy>(buffer)
+        {
+            return;
+        }
+
+        template<class CharTy>
+        void Begin(
+            _In_z_ CharTy const* szUtfProviderName)
+        {
+            this->BaseBegin();
+            this->AddString(szUtfProviderName);
+        }
+
+        void AddTrait(
+            ProviderTraitType type,
+            _In_reads_bytes_(cbData) void const* pData,
+            unsigned cbData)
+        {
+            this->AddU16(static_cast<UINT16>(cbData + 3));
+            this->AddU8(static_cast<UINT8>(type));
+            this->AddBytes(pData, cbData);
+        }
+
+        bool End()
+        {
+            return this->BaseEnd();
+        }
+    };
+
+#pragma endregion
+
+#pragma region EventMetadataBuilder
+
+    template<class ByteBufferTy>
+    class EventMetadataBuilder
+        : public detail::MetadataBuilderBase<ByteBufferTy>
+    {
+        /*
+        EventMetadata =
+        Size    : UINT16; // Size counts the whole data structure, including the Size field.
+        Tags[]  : UINT8 (read bytes until you encounter a byte with high bit unset);
+        Name    : Nul-terminated UTF-8;
+        Fields[]: FieldMetadata (parse until you get to end of EventMetadata);
+
+        FieldMetadata =
+        Name    : Nul-terminated UTF-8.
+        InMeta  : UINT8.
+        OutMeta : UINT8 (only present if InMeta & InMetaChain);
+        Tags[]  : UINT8 (only present if OutMeta & OutMetaChain, read bytes until you encounter a byte with high bit unset);
+        Ccount  : UINT16 (only present if InMeta & InMetaCountMask == InMetaCcount);
+        CbSchema: UINT16 (only present if InMeta & InMetaCountMask == InMetaCustom);
+        Schema  : UINT8[CbSchema]
+        */
+
+        static const UINT8 InMetaScalar = 0;
+        static const UINT8 InMetaCcount = 32;
+        static const UINT8 InMetaVcount = 64;
+        static const UINT8 InMetaCustom = 96;
+        static const UINT8 InMetaCountMask = 96;
+        static const UINT8 InMetaChain = 128;
+        static const UINT8 OutMetaChain = 128;
+
+        UINT32 const m_bookmark;
+
+        EventMetadataBuilder(
+            ByteBufferTy& buffer,
+            UINT32 bookmark)
+            : detail::MetadataBuilderBase<ByteBufferTy>(buffer)
+            , m_bookmark(bookmark)
+        {
+            return;
+        }
+
+        void AddTags(UINT32 tags)
+        {
+            _tld_ASSERT(0 == (tags & 0xf0000000), "Tags only supports 28-bit values.");
+            for (;;)
+            {
+                auto val = static_cast<UINT8>(tags >> 21);
+                if ((tags & 0x1fffff) == 0)
+                {
+                    this->AddU8(val & 0x7f);
+                    break;
+                }
+
+                this->AddU8(val | 0x80);
+                tags = tags << 7;
+            }
+        }
+
+        void AddFieldInfo(UINT8 arity, Type type, UINT32 tags)
+        {
+            _tld_ASSERT((type & InTypeMask) == (type & 0xff), "InType out of range");
+            _tld_ASSERT((type & _tld_MAKE_TYPE(0, OutTypeMask)) == (Type)(type & 0xffffff00), "OutType out of range");
+
+            UINT8 inMeta = arity | static_cast<UINT8>(type);
+            UINT8 outMeta = static_cast<UINT8>(type >> 8);
+            if (tags != 0)
+            {
+                this->AddU8(static_cast<UINT8>(inMeta | InMetaChain));
+                this->AddU8(static_cast<UINT8>(outMeta | OutMetaChain));
+                AddTags(tags);
+            }
+            else if (outMeta != 0)
+            {
+                this->AddU8(static_cast<UINT8>(inMeta | InMetaChain));
+                this->AddU8(static_cast<UINT8>(outMeta));
+            }
+            else
+            {
+                this->AddU8(inMeta);
+            }
+
+            if (m_bookmark != 0)
+            {
+                this->IncrementU7(m_bookmark);
+            }
+        }
+
+        UINT32 AddStructInfo(UINT8 arity, UINT32 tags)
+        {
+            UINT8 inMeta = arity | InTypeStruct;
+            this->AddU8(static_cast<UINT8>(inMeta | InMetaChain));
+            UINT32 bookmark = this->GetBookmark();
+            if (tags == 0)
+            {
+                this->AddU8(0);
+            }
+            else
+            {
+                this->AddU8(OutMetaChain);
+                AddTags(tags);
+            }
+
+            if (m_bookmark != 0)
+            {
+                this->IncrementU7(m_bookmark);
+            }
+
+            return bookmark;
+        }
+
+    public:
+
+        explicit EventMetadataBuilder(
+            ByteBufferTy& buffer)
+            : detail::MetadataBuilderBase<ByteBufferTy>(buffer)
+            , m_bookmark(0)
+        {
+            return;
+        }
+
+        EventMetadataBuilder(EventMetadataBuilder& other)
+            : detail::MetadataBuilderBase<ByteBufferTy>(other.GetBuffer())
+            , m_bookmark(other.m_bookmark)
+        {
+            return;
+        }
+
+        EventMetadataBuilder(EventMetadataBuilder&& other)
+            : detail::MetadataBuilderBase<ByteBufferTy>(other.GetBuffer())
+            , m_bookmark(other.m_bookmark)
+        {
+            return;
+        }
+
+        template<class CharTy>
+        void Begin(
+            _In_z_ CharTy const* szUtfEventName,
+            UINT32 eventTags = 0)
+        {
+            _tld_ASSERT(m_bookmark == 0, "Must not call Begin on a struct builder");
+            this->BaseBegin();
+            AddTags(eventTags);
+            this->AddString(szUtfEventName);
+        }
+
+        bool End()
+        {
+            _tld_ASSERT(m_bookmark == 0, "Must not call End on a struct builder");
+            return this->BaseEnd();
+        }
+
+        // Note: Do not create structs with 0 fields.
+        template<class CharTy>
+        EventMetadataBuilder AddStruct(
+            _In_z_ CharTy const* szUtfStructName,
+            UINT32 fieldTags = 0)
+        {
+            this->AddString(szUtfStructName);
+            auto bookmark = AddStructInfo(InMetaScalar, fieldTags);
+            return EventMetadataBuilder(this->GetBuffer(), bookmark);
+        }
+
+        // Note: Do not create structs with 0 fields.
+        template<class CharTy>
+        UINT32 AddStructRaw(
+            _In_z_ CharTy const* szUtfStructName,
+            UINT32 fieldTags = 0)
+        {
+            this->AddString(szUtfStructName);
+            auto bookmark = AddStructInfo(InMetaScalar, fieldTags);
+            return bookmark;
+        }
+
+        // Note: Do not create structs with 0 fields.
+        template<class CharTy>
+        EventMetadataBuilder AddStructArray(
+            _In_z_ CharTy const* szUtfStructName,
+            UINT32 fieldTags = 0)
+        {
+            this->AddString(szUtfStructName);
+            auto bookmark = AddStructInfo(InMetaVcount, fieldTags);
+            return EventMetadataBuilder(this->GetBuffer(), bookmark);
+        }
+
+        // Note: Do not use 0 for itemCount.
+        // Note: Do not create structs with 0 fields.
+        template<class CharTy>
+        EventMetadataBuilder AddStructFixedArray(
+            _In_z_ CharTy const* szUtfStructName,
+            UINT16 itemCount,
+            UINT32 fieldTags = 0)
+        {
+            this->AddString(szUtfStructName);
+            auto bookmark = AddStructInfo(InMetaCcount, fieldTags);
+            this->AddU16(itemCount);
+            return EventMetadataBuilder(this->GetBuffer(), bookmark);
+        }
+
+        template<class CharTy>
+        void AddField(
+            _In_z_ CharTy const* szUtfFieldName,
+            Type type,
+            UINT32 fieldTags = 0)
+        {
+            this->AddString(szUtfFieldName);
+            AddFieldInfo(InMetaScalar, type, fieldTags);
+        }
+
+        template<class CharTy>
+        void AddFieldArray(
+            _In_z_ CharTy const* szUtfFieldName,
+            Type type,
+            UINT32 fieldTags = 0)
+        {
+            this->AddString(szUtfFieldName);
+            AddFieldInfo(InMetaVcount, type, fieldTags);
+        }
+
+        // Note: Do not use 0 for itemCount.
+        template<class CharTy>
+        void AddFieldFixedArray(
+            _In_z_ CharTy const* szUtfFieldName,
+            UINT16 itemCount,
+            Type type,
+            UINT32 fieldTags = 0)
+        {
+            this->AddString(szUtfFieldName);
+            AddFieldInfo(InMetaCcount, type, fieldTags);
+            this->AddU16(itemCount);
+        }
+
+        template<class CharTy>
+        void AddFieldCustom(
+            _In_z_ CharTy const* szUtfFieldName,
+            _In_reads_bytes_(cbSchema) void const* pSchema,
+            UINT16 cbSchema,
+            Type type,
+            UINT32 fieldTags = 0)
+        {
+            this->AddString(szUtfFieldName);
+            AddFieldInfo(InMetaCustom, type, fieldTags);
+            this->AddU16(cbSchema);
+            auto pbSchema = static_cast<UINT8 const*>(pSchema);
+            for (UINT32 i = 0; i != cbSchema; i++)
+            {
+                this->AddU8(pbSchema[i]);
+            }
+        }
+    };
+
+#pragma endregion
+
+#pragma region EventDataBuilder
+
+    template<class ByteBufferTy>
+    class EventDataBuilder
+    {
+        void operator=(EventDataBuilder const&); // = delete
+        ByteBufferTy& m_buffer;
+
+    public:
+
+        explicit EventDataBuilder(ByteBufferTy& buffer)
+            : m_buffer(buffer)
+        {
+            return;
+        }
+
+        EventDataBuilder(EventDataBuilder& other)
+            : m_buffer(other.m_buffer)
+        {
+            return;
+        }
+
+        EventDataBuilder(EventDataBuilder&& other)
+            : m_buffer(other.m_buffer)
+        {
+            return;
+        }
+
+        ByteBufferTy& Buffer()
+        {
+            return m_buffer;
+        }
+
+        ByteBufferTy const& Buffer() const
+        {
+            return m_buffer;
+        }
+
+        void Clear()
+        {
+            m_buffer.clear();
+        }
+
+        UINT32 Size() const
+        {
+            return static_cast<UINT32>(m_buffer.size());
+        }
+
+        UINT8& operator[](UINT32 index)
+        {
+            return m_buffer[index];
+        }
+
+        void AddArrayCount(UINT16 cItems)
+        {
+            AddBytes(&cItems, sizeof(cItems));
+        }
+
+        /*
+        Adds a value to the payload.
+        Note: should only be used for blittable POD types with no padding.
+        */
+        template<class T>
+        void AddValue(T const& value)
+        {
+            AddBytes(&reinterpret_cast<const char&>(value), sizeof(T));
+        }
+
+        /*
+        Adds an array of values to the payload.
+        Note: should only be used for blittable POD types with no padding.
+        */
+        template<class T>
+        void AddValues(_In_reads_(cValues) T const* pValues, unsigned cValues)
+        {
+            AddBytes(pValues, sizeof(T) * cValues);
+        }
+
+        /*
+        Appends an InTypeBinary field to the payload.
+        Compatible with: TypeBinary, TypeIPv6, TypeSocketAddress.
+        */
+        void AddBinary(_In_reads_bytes_(cbData) void const* pbData, UINT16 cbData)
+        {
+            AddBytes(&cbData, sizeof(cbData));
+            AddBytes(pbData, cbData);
+        }
+
+        /*
+        Appends an InTypeCountedAnsiString field to the payload.
+        Compatible with: TypeCountedMbcsString, TypeCountedMbcsXml, TypeCountedMbcsJson.
+        */
+        void AddCountedString(_In_reads_(cch) char const* pch, UINT16 cch)
+        {
+            AddBinary(pch, cch * sizeof(*pch));
+        }
+
+        /*
+        Appends an InTypeCountedString field to the payload.
+        Compatible with: TypeCountedUtf16String, TypeCountedUtf16Xml, TypeCountedUtf16Json.
+        */
+        void AddCountedString(_In_reads_(cch) wchar_t const* pch, UINT16 cch)
+        {
+            AddBinary(pch, cch * sizeof(*pch));
+        }
+
+        /*
+        Appends an InTypeAnsiString field to the payload.
+        Compatible with: TypeMbcsString, TypeMbcsXml, TypeMbcsJson.
+        */
+        void AddString(_In_z_ char const* psz)
+        {
+            AddBytes(psz, static_cast<unsigned>(strlen(psz) + 1));
+        }
+
+        /*
+        Appends a InTypeUnicodeString field to the payload.
+        Compatible with: TypeUtf16String, TypeUtf16Xml, TypeUtf16Json
+        */
+        void AddString(_In_z_ wchar_t const* psz)
+        {
+            AddBytes(psz, static_cast<unsigned>(2 * (wcslen(psz) + 1)));
+        }
+
+        /*
+        Appends a raw byte to the payload. (Calls buffer.push_back)
+        */
+        void AddByte(UINT8 val)
+        {
+            m_buffer.push_back(val);
+        }
+
+        /*
+        Appends raw bytes to the payload. (Calls buffer.insert)
+        */
+        void AddBytes(_In_reads_bytes_(cbData) void const* pbData, unsigned cbData)
+        {
+            auto pb = static_cast<UINT8 const*>(pbData);
+            m_buffer.insert(m_buffer.end(), pb + 0, pb + cbData);
+        }
+    };
+
+#pragma endregion
+
+#pragma region Provider
+
+    class Provider
+    {
+        Provider(Provider const&); // = delete
+        void operator=(Provider const&); // = delete
+
+        UINT32 m_levelPlus1;
+        HRESULT m_hrInitialization;
+        ULONGLONG m_keywordsAny;
+        ULONGLONG m_keywordsAll;
+        REGHANDLE m_hProvider;
+        UINT8 const* m_pbMetadata;
+        PENABLECALLBACK m_pfCallback;
+        LPVOID m_pCallbackContext;
+        GUID m_id;
+
+        /*
+        Shortest possible valid provider metadata blob:
+        Size = 0x0003, Name = "", no options.
+        */
+        static _Ret_bytecount_(3) UINT8 const* NullMetadata()
+        {
+            return reinterpret_cast<UINT8 const*>("\03\0");
+        }
+
+        static VOID NTAPI EnableCallback(
+            _In_ LPCGUID pSourceId,
+            _In_ ULONG callbackType,
+            _In_ UCHAR level,
+            _In_ ULONGLONG keywordsAny,
+            _In_ ULONGLONG keywordsAll,
+            _In_opt_ PEVENT_FILTER_DESCRIPTOR pFilterData,
+            _Inout_opt_ PVOID pCallbackContext)
+        {
+            if (pCallbackContext)
+            {
+                Provider* pProvider = static_cast<Provider*>(pCallbackContext);
+                switch (callbackType)
+                {
+                case 0: // EVENT_CONTROL_CODE_DISABLE_PROVIDER
+                    pProvider->m_levelPlus1 = 0;
+                    break;
+                case 1: // EVENT_CONTROL_CODE_ENABLE_PROVIDER
+                    pProvider->m_levelPlus1 = level != 0 ? (UINT32)level + 1u : 256u;
+                    pProvider->m_keywordsAny = keywordsAny;
+                    pProvider->m_keywordsAll = keywordsAll;
+                    break;
+                }
+
+                if (pProvider->m_pfCallback)
+                {
+                    pProvider->m_pfCallback(
+                        pSourceId,
+                        callbackType,
+                        level,
+                        keywordsAny,
+                        keywordsAll,
+                        pFilterData,
+                        pProvider->m_pCallbackContext);
+                }
+            }
+        }
+
+        _Ret_opt_bytecount_(cbMetadata)
+        static UINT8* MetadataAlloc(
+            UINT32 cbMetadata)
+        {
+            return static_cast<UINT8*>(HeapAlloc(GetProcessHeap(), 0, cbMetadata));
+        }
+
+        static void MetadataFree(
+            _Post_invalid_ UINT8* pbMetadata)
+        {
+            if (pbMetadata)
+            {
+                HeapFree(GetProcessHeap(), 0, pbMetadata);
+            }
+        }
+
+        void InitFail(
+            HRESULT hr)
+        {
+            _tld_ASSERT(m_pbMetadata != NullMetadata(), "InitFail called with m_pbMetadata == NullMetadata()");
+            MetadataFree(const_cast<UINT8*>(m_pbMetadata));
+            m_hrInitialization = hr;
+            m_pbMetadata = NullMetadata();
+        }
+
+        template<class CharTy>
+        void Init(
+            _In_z_ CharTy const* szName,
+            _In_opt_ GUID const* pGroupId)
+        {
+            // Already initialized: m_pfCallback, m_pCallbackContext, m_id.
+            m_levelPlus1 = 0;
+            m_hrInitialization = 0;
+            m_keywordsAny = 0;
+            m_keywordsAll = 0;
+            m_hProvider = 0;
+            m_pbMetadata = 0;
+
+            ByteArrayWrapper wrapper(0, 0);
+            ProviderMetadataBuilder<ByteArrayWrapper> builder(wrapper);
+            builder.Begin(szName);
+            if (pGroupId)
+            {
+                builder.AddTrait(ProviderTraitGroupGuid, pGroupId, sizeof(GUID));
+            }
+            if (!builder.End())
+            {
+                InitFail(E_INVALIDARG); // Metadata > 64KB.
+                goto Done;
+            }
+
+            {
+                UINT32 const cbMetadata = wrapper.size();
+                UINT8* pbMetadata = MetadataAlloc(cbMetadata);
+                if (!pbMetadata)
+                {
+                    InitFail(E_OUTOFMEMORY);
+                    goto Done;
+                }
+
+                m_pbMetadata = pbMetadata;
+                wrapper.reset(pbMetadata, cbMetadata);
+                builder.Begin(szName);
+                if (pGroupId)
+                {
+                    builder.AddTrait(ProviderTraitGroupGuid, pGroupId, sizeof(GUID));
+                }
+                if (!builder.End() || cbMetadata < wrapper.size())
+                {
+                    InitFail(0x8000000CL); // E_CHANGED_STATE
+                    goto Done;
+                }
+
+                {
+                    HRESULT hr = ::tld::RegisterProvider(&m_hProvider, &m_id, m_pbMetadata, &EnableCallback, this);
+                    if (FAILED(hr))
+                    {
+                        InitFail(hr);
+                    }
+                }
+            }
+
+        Done:
+
+            return;
+        }
+
+        bool IsEnabledForKeywords(ULONGLONG keywords) const
+        {
+            return keywords == 0 || (
+                (keywords & m_keywordsAny) != 0 &&
+                (keywords & m_keywordsAll) == m_keywordsAll);
+        }
+
+    public:
+
+        ~Provider()
+        {
+            EventUnregister(m_hProvider);
+            if (m_pbMetadata != NullMetadata())
+            {
+                MetadataFree(const_cast<UINT8*>(m_pbMetadata));
+            }
+        }
+
+        Provider(
+            _In_z_ wchar_t const* szUtf16Name,
+            GUID const& providerId,
+            _In_opt_ GUID const* pGroupId = 0,
+            PENABLECALLBACK pfCallback = 0,
+            LPVOID pCallbackContext = 0)
+            : m_pfCallback(pfCallback)
+            , m_pCallbackContext(pCallbackContext)
+            , m_id(providerId)
+        {
+            Init(szUtf16Name, pGroupId);
+        }
+
+        Provider(
+            _In_z_ char const* szUtf8Name,
+            GUID const& providerId,
+            _In_opt_ GUID const* pGroupId = 0,
+            PENABLECALLBACK pfCallback = 0,
+            LPVOID pCallbackContext = 0)
+            : m_pfCallback(pfCallback)
+            , m_pCallbackContext(pCallbackContext)
+            , m_id(providerId)
+        {
+            Init(szUtf8Name, pGroupId);
+        }
+
+        explicit Provider(
+            _In_z_ wchar_t const* szUtf16Name,
+            _In_opt_ GUID const* pGroupId = 0,
+            PENABLECALLBACK pfCallback = 0,
+            LPVOID pCallbackContext = 0)
+            : m_pfCallback(pfCallback)
+            , m_pCallbackContext(pCallbackContext)
+            , m_id(GetGuidForName(szUtf16Name))
+        {
+            Init(szUtf16Name, pGroupId);
+        }
+
+        explicit Provider(
+            _In_z_ char const* szUtf8Name,
+            _In_opt_ GUID const* pGroupId = 0,
+            PENABLECALLBACK pfCallback = 0,
+            LPVOID pCallbackContext = 0)
+            : m_pfCallback(pfCallback)
+            , m_pCallbackContext(pCallbackContext)
+            , m_id(GetGuidForName(szUtf8Name))
+        {
+            Init(szUtf8Name, pGroupId);
+        }
+
+        HRESULT InitializationResult() const
+        {
+            return m_hrInitialization;
+        }
+
+        _Ret_z_ char const* Name() const
+        {
+            return reinterpret_cast<char const*>(m_pbMetadata + 2);
+        }
+
+        GUID const& Id() const
+        {
+            return m_id;
+        }
+
+        _Ret_notnull_ UINT8 const* GetMetadata() const
+        {
+            return m_pbMetadata;
+        }
+
+        UINT16 GetMetadataSize() const
+        {
+            return *reinterpret_cast<UINT16 const*>(m_pbMetadata);
+        }
+
+        bool IsEnabled() const
+        {
+            return m_levelPlus1 != 0;
+        }
+
+        bool IsEnabled(UCHAR level) const
+        {
+            return level < m_levelPlus1;
+        }
+
+        bool IsEnabled(UCHAR level, ULONGLONG keywords) const
+        {
+            return level < m_levelPlus1 && IsEnabledForKeywords(keywords);
+        }
+
+        HRESULT SetInformation(
+            EVENT_INFO_CLASS informationClass,
+            _In_reads_bytes_opt_(cbInformation) void* pbInformation,
+            ULONG cbInformation
+            ) const
+        {
+            return ::tld::SetInformation(m_hProvider, informationClass, pbInformation, cbInformation);
+        }
+
+        HRESULT WriteGather(
+            EVENT_DESCRIPTOR const& eventDescriptor,
+            _In_count_x_((UINT16*)pEventMetadata) UINT8 const* pEventMetadata,
+            _In_range_(2, 128) ULONG cDataDescriptors,
+            _Inout_count_(cDataDescriptors) EVENT_DATA_DESCRIPTOR* pDataDescriptors,
+            _In_opt_ LPCGUID pActivityId = 0,
+            _In_opt_ LPCGUID pRelatedActivityId = 0
+            ) const
+        {
+            return ::tld::WriteEvent(
+                m_hProvider,
+                eventDescriptor,
+                m_pbMetadata,
+                pEventMetadata,
+                cDataDescriptors,
+                pDataDescriptors,
+                pActivityId,
+                pRelatedActivityId);
+        }
+
+        HRESULT Write(
+            EVENT_DESCRIPTOR const& eventDescriptor,
+            _In_count_x_((UINT16*)pEventMetadata) UINT8 const* pEventMetadata,
+            _In_reads_bytes_(cbData) LPCVOID pbData,
+            UINT32 cbData,
+            _In_opt_ LPCGUID pActivityId = 0,
+            _In_opt_ LPCGUID pRelatedActivityId = 0
+            ) const
+        {
+            EVENT_DATA_DESCRIPTOR dataDesc[3];
+            EventDataDescCreate(dataDesc + 2, pbData, cbData);
+            return ::tld::WriteEvent(
+                m_hProvider,
+                eventDescriptor,
+                m_pbMetadata,
+                pEventMetadata,
+                cbData ? 3 : 2,
+                dataDesc,
+                pActivityId,
+                pRelatedActivityId);
+        }
+
+#if TLD_HAVE_EVENT_WRITE_EX == 1
+
+        HRESULT WriteGatherEx(
+            EVENT_DESCRIPTOR const& eventDescriptor,
+            _In_count_x_((UINT16*)pEventMetadata) UINT8 const* pEventMetadata,
+            _In_range_(2, 128) ULONG cDataDescriptors,
+            _Inout_count_(cDataDescriptors) EVENT_DATA_DESCRIPTOR* pDataDescriptors,
+            ULONG64 filter,
+            ULONG flags,
+            _In_opt_ LPCGUID pActivityId = 0,
+            _In_opt_ LPCGUID pRelatedActivityId = 0
+            ) const
+        {
+            return ::tld::WriteEventEx(
+                m_hProvider,
+                eventDescriptor,
+                m_pbMetadata,
+                pEventMetadata,
+                cDataDescriptors,
+                pDataDescriptors,
+                filter,
+                flags,
+                pActivityId,
+                pRelatedActivityId);
+        }
+
+        HRESULT WriteEx(
+            EVENT_DESCRIPTOR const& eventDescriptor,
+            _In_count_x_((UINT16*)pEventMetadata) UINT8 const* pEventMetadata,
+            _In_reads_bytes_(cbData) LPCVOID pbData,
+            UINT32 cbData,
+            ULONG64 filter,
+            ULONG flags,
+            _In_opt_ LPCGUID pActivityId = 0,
+            _In_opt_ LPCGUID pRelatedActivityId = 0
+            ) const
+        {
+            EVENT_DATA_DESCRIPTOR dataDesc[3];
+            EventDataDescCreate(dataDesc + 2, pbData, cbData);
+            return ::tld::WriteEventEx(
+                m_hProvider,
+                eventDescriptor,
+                m_pbMetadata,
+                pEventMetadata,
+                cbData ? 3 : 2,
+                dataDesc,
+                filter,
+                flags,
+                pActivityId,
+                pRelatedActivityId);
+        }
+
+#endif // TLD_HAVE_EVENT_WRITE_EX
+    };
+
+#pragma endregion
+
+#pragma region EventBuilder
+
+    enum EventState
+    {
+        EventStateOpen,
+        EventStateClosed,
+        EventStateError
+    };
+
+    template<class ByteBufferTy>
+    class EventBuilder
+    {
+        void operator=(EventBuilder const&); // = delete
+
+        EventMetadataBuilder<ByteBufferTy> m_metaBuilder;
+        EventDataBuilder<ByteBufferTy> m_dataBuilder;
+        EventState& m_eventState;
+
+        EventBuilder(EventBuilder& other, EventMetadataBuilder<ByteBufferTy>&& metaBuilder)
+            : m_metaBuilder(metaBuilder)
+            , m_dataBuilder(other.m_dataBuilder)
+            , m_eventState(other.m_eventState)
+        {
+            return;
+        }
+
+    protected:
+
+        EventBuilder(
+            ByteBufferTy& metaBuffer,
+            ByteBufferTy& dataBuffer,
+            EventState& eventState)
+            : m_metaBuilder(metaBuffer)
+            , m_dataBuilder(dataBuffer)
+            , m_eventState(eventState)
+        {
+            return;
+        }
+
+    public:
+
+        EventBuilder(EventBuilder& other)
+            : m_metaBuilder(other.m_metaBuilder)
+            , m_dataBuilder(other.m_dataBuilder)
+            , m_eventState(other.m_eventState)
+        {
+            return;
+        }
+
+        EventBuilder(EventBuilder&& other)
+            : m_metaBuilder(other.m_metaBuilder)
+            , m_dataBuilder(other.m_dataBuilder)
+            , m_eventState(other.m_eventState)
+        {
+            return;
+        }
+
+        /*
+        Returns a const reference to the event metadata's underlying buffer.
+        */
+        ByteBufferTy const& MetaBuffer() const
+        {
+            return m_metaBuilder.GetBuffer();
+        }
+
+        /*
+        Returns a const reference to the event payload data's underlying buffer.
+        */
+        ByteBufferTy const& DataBuffer() const
+        {
+            return m_dataBuilder.Buffer();
+        }
+
+        /*
+        Adds a nested struct to the event's metadata.
+        Use the returned EventBuilder to add data and metadata for the fields
+        of the nested struct.
+        Note: do not call any Add methods on this builder object until you are
+        done calling Add methods on the nested builder object.
+        Note: Do not create structs with 0 fields.
+        */
+        template<class CharTy>
+        EventBuilder AddStruct(
+            _In_z_ CharTy const* szUtfStructName,
+            UINT32 fieldTags = 0)
+        {
+            _tld_ASSERT(m_eventState == EventStateOpen, "Metadata already prepared.");
+            return EventBuilder(*this, m_metaBuilder.AddStruct(szUtfStructName, fieldTags));
+        }
+
+        /*
+        Adds a nested array of struct to the event's metadata.
+        Use the returned EventBuilder to add data and metadata for the fields
+        of the nested struct.
+        Note: do not call any Add methods on this builder object until you are
+        done calling Add methods on the nested builder object.
+        Note: Do not create structs with 0 fields.
+        */
+        template<class CharTy>
+        EventBuilder AddStructArray(
+            _In_z_ CharTy const* szUtfStructName,
+            UINT32 fieldTags = 0)
+        {
+            _tld_ASSERT(m_eventState == EventStateOpen, "Metadata already prepared.");
+            return EventBuilder(*this, m_metaBuilder.AddStructArray(szUtfStructName, fieldTags));
+        }
+
+        /*
+        Adds a nested array of struct to the event's metadata.
+        Use the returned EventBuilder to add data and metadata for the fields
+        of the nested struct.
+        Note: do not call any Add methods on this builder object until you are
+        done calling Add methods on the nested builder object.
+        Note: Do not use 0 for itemCount.
+        Note: Do not create structs with 0 fields.
+        */
+        template<class CharTy>
+        EventBuilder AddStructFixedArray(
+            _In_z_ CharTy const* szUtfStructName,
+            UINT16 itemCount,
+            UINT32 fieldTags = 0)
+        {
+            _tld_ASSERT(m_eventState == EventStateOpen, "Metadata already prepared.");
+            return EventBuilder(*this, m_metaBuilder.AddStructFixedArray(szUtfStructName, itemCount, fieldTags));
+        }
+
+        /*
+        Adds a scalar field to the event's metadata.
+        */
+        template<class CharTy>
+        void AddField(
+            _In_z_ CharTy const* szUtfFieldName,
+            Type type,
+            UINT32 fieldTags = 0)
+        {
+            _tld_ASSERT(m_eventState == EventStateOpen, "Metadata already prepared.");
+            m_metaBuilder.AddField(szUtfFieldName, type, fieldTags);
+        }
+
+        /*
+        Adds a variable-length array field to the event's metadata.
+        The length (item count) must be added to the event's payload
+        immediately before the array item values.
+        */
+        template<class CharTy>
+        void AddFieldArray(
+            _In_z_ CharTy const* szUtfFieldName,
+            Type type,
+            UINT32 fieldTags = 0)
+        {
+            _tld_ASSERT(m_eventState == EventStateOpen, "Metadata already prepared.");
+            m_metaBuilder.AddFieldArray(szUtfFieldName, type, fieldTags);
+        }
+
+        /*
+        Adds a fixed-length array field to the event's metadata.
+        The length (item count) is encoded in the metadata, so it does not
+        need to be included in the event's payload.
+        Note: Do not use 0 for itemCount.
+        */
+        template<class CharTy>
+        void AddFieldFixedArray(
+            _In_z_ CharTy const* szUtfFieldName,
+            UINT16 itemCount,
+            Type type,
+            UINT32 fieldTags = 0)
+        {
+            _tld_ASSERT(m_eventState == EventStateOpen, "Metadata already prepared.");
+            m_metaBuilder.AddFieldFixedArray(szUtfFieldName, itemCount, type, fieldTags);
+        }
+
+        /*
+        Adds a custom-encoded field to the event's metadata.
+        Custom-encoded means that you are using some other serialization
+        system (e.g. Bond, Protocol Buffers) to produce the schema and data.
+        The payload is encoded as a UINT16 byte count followed by the data.
+        */
+        template<class CharTy>
+        void AddFieldCustom(
+            _In_z_ CharTy const* szUtfFieldName,
+            _In_reads_bytes_(cbSchema) void const* pSchema,
+            UINT16 cbSchema,
+            Type type,
+            UINT32 fieldTags = 0)
+        {
+            _tld_ASSERT(m_eventState == EventStateOpen, "Metadata already prepared.");
+            m_metaBuilder.AddFieldCustom(szUtfFieldName, pSchema, cbSchema, type, fieldTags);
+        }
+
+        /*
+        Advanced use: adds raw metadata bytes.
+        */
+        void AddRawMetadata(
+            _In_reads_bytes_(cbMetadata) void const* pMetadata,
+            UINT32 cbMetadata)
+        {
+            auto& buf = m_metaBuilder.GetBuffer();
+            auto pb = static_cast<BYTE const*>(pMetadata);
+            buf.insert(buf.end(), pb + 0u, pb + cbMetadata);
+        }
+
+        /*
+        Adds an array length (item count) to the payload. This is for
+        variable-length arrays only (not fixed-length), and must occur
+        immediately before the array item values are written to the payload.
+        */
+        void AddArrayCount(UINT16 cItems)
+        {
+            m_dataBuilder.AddArrayCount(cItems);
+        }
+
+        /*
+        Adds a value to the payload.
+        Note: should only be used for blittable POD types with no padding,
+        e.g. INT32, FILETIME, GUID, not for strings or structs.
+        */
+        template<class T>
+        void AddValue(T const& value)
+        {
+            m_dataBuilder.AddValue(value);
+        }
+
+        /*
+        Adds an array of values to the payload.
+        Note: should only be used for blittable POD types with no padding,
+        e.g. INT32, FILETIME, GUID, not for strings or structs.
+        */
+        template<class T>
+        void AddValues(_In_reads_(cValues) T const* pValues, unsigned cValues)
+        {
+            m_dataBuilder.AddValues(pValues, cValues);
+        }
+
+        /*
+        Appends an InTypeBinary field to the payload.
+        Compatible with: TypeBinary, TypeIPv6, TypeSocketAddress.
+        */
+        void AddBinary(_In_reads_bytes_(cbData) void const* pbData, UINT16 cbData)
+        {
+            m_dataBuilder.AddBinary(pbData, cbData);
+        }
+
+        /*
+        Appends an InTypeCountedAnsiString field to the payload.
+        Compatible with: TypeCountedMbcsString, TypeCountedMbcsXml, TypeCountedMbcsJson.
+        */
+        void AddCountedString(_In_reads_(cch) char const* pch, UINT16 cch)
+        {
+            m_dataBuilder.AddCountedString(pch, cch);
+        }
+
+        /*
+        Appends an InTypeCountedString field to the payload.
+        Compatible with: TypeCountedUtf16String, TypeCountedUtf16Xml, TypeCountedUtf16Json.
+        */
+        void AddCountedString(_In_reads_(cch) wchar_t const* pch, UINT16 cch)
+        {
+            m_dataBuilder.AddCountedString(pch, cch);
+        }
+
+        /*
+        Appends an InTypeAnsiString field to the payload.
+        Compatible with: TypeMbcsString, TypeMbcsXml, TypeMbcsJson.
+        */
+        void AddString(_In_z_ char const* psz)
+        {
+            m_dataBuilder.AddString(psz);
+        }
+
+        /*
+        Appends a InTypeUnicodeString field to the payload.
+        Compatible with: TypeUtf16String, TypeUtf16Xml, TypeUtf16Json
+        */
+        void AddString(_In_z_ wchar_t const* psz)
+        {
+            m_dataBuilder.AddString(psz);
+        }
+
+        /*
+        Appends a raw byte to the payload.
+        */
+        void AddByte(UINT8 val)
+        {
+            m_dataBuilder.AddByte(val);
+        }
+
+        /*
+        Appends raw bytes to the payload.
+        */
+        void AddBytes(_In_reads_bytes_(cbData) void const* pbData, unsigned cbData)
+        {
+            m_dataBuilder.AddBytes(pbData, cbData);
+        }
+    };
+
+#pragma endregion
+
+#pragma region Event
+
+    template<class ByteBufferTy>
+    class Event
+        : public EventBuilder<ByteBufferTy>
+    {
+        Event(Event const&); // = delete
+        void operator=(Event const&); // = delete
+
+        ByteBufferTy m_metaBuffer;
+        ByteBufferTy m_dataBuffer;
+        EventDescriptor m_descriptor;
+        GUID const* m_pActivityId;
+        GUID const* m_pRelatedActivityId;
+        EventState m_state;
+
+    public:
+
+        Event(
+            _In_z_ char const* szUtf8Name,
+            UCHAR level = 5,
+            ULONGLONG keywords = 0,
+            UINT32 tags = 0,
+            UCHAR opcode = 0,
+            USHORT task = 0,
+            GUID const* pActivityId = 0,
+            GUID const* pRelatedActivityId = 0)
+            : EventBuilder<ByteBufferTy>(m_metaBuffer, m_dataBuffer, m_state)
+            , m_descriptor(level, keywords, opcode, task)
+            , m_pActivityId(pActivityId)
+            , m_pRelatedActivityId(pRelatedActivityId)
+            , m_state(EventStateOpen)
+        {
+            EventMetadataBuilder<ByteBufferTy>(m_metaBuffer).Begin(szUtf8Name, tags);
+        }
+
+        Event(
+            _In_z_ wchar_t const* szUtf16Name,
+            UCHAR level = 5,
+            ULONGLONG keywords = 0,
+            UINT32 tags = 0,
+            UCHAR opcode = 0,
+            USHORT task = 0,
+            GUID const* pActivityId = 0,
+            GUID const* pRelatedActivityId = 0)
+            : EventBuilder<ByteBufferTy>(m_metaBuffer, m_dataBuffer, m_state)
+            , m_descriptor(level, keywords, opcode, task)
+            , m_pActivityId(pActivityId)
+            , m_pRelatedActivityId(pRelatedActivityId)
+            , m_state(EventStateOpen)
+        {
+            EventMetadataBuilder<ByteBufferTy>(m_metaBuffer).Begin(szUtf16Name, tags);
+        }
+
+        /*
+        Clears the metadata and the payload.
+        */
+        template<class CharTy>
+        void Reset(
+            _In_z_ CharTy const* szUtfName,
+            UCHAR level = 5,
+            ULONGLONG keywords = 0,
+            UINT32 tags = 0,
+            UCHAR opcode = 0,
+            USHORT task = 0,
+            GUID* pActivityId = 0,
+            GUID* pRelatedActivityId = 0)
+        {
+            m_metaBuffer.clear();
+            m_dataBuffer.clear();
+            m_descriptor.Reset(level, keywords, opcode, task);
+            m_pActivityId = pActivityId;
+            m_pRelatedActivityId = pRelatedActivityId;
+            m_state = EventStateOpen;
+            EventMetadataBuilder<ByteBufferTy>(m_metaBuffer).Begin(szUtfName, tags);
+        }
+
+        /*
+        Clears the payload without clearing the metadata.
+        */
+        void ResetData()
+        {
+            m_dataBuffer.clear();
+        }
+
+        /*
+        Sends the event to ETW using EventWriteTransfer.
+        */
+        HRESULT Write(Provider const& provider)
+        {
+            HRESULT hr = E_INVALIDARG;
+            if (PrepareEvent())
+            {
+                hr = provider.Write(
+                    m_descriptor,
+                    &m_metaBuffer.front(),
+                    m_dataBuffer.empty() ? NULL : &m_dataBuffer.front(),
+                    static_cast<UINT32>(m_dataBuffer.size()),
+                    m_pActivityId,
+                    m_pRelatedActivityId);
+            }
+            return hr;
+        }
+
+        /*
+        Sends the event to ETW using EventWriteTransfer.
+        */
+        HRESULT Write(
+            REGHANDLE hProvider,
+            _In_count_x_((UINT16*)pProviderMetadata) UINT8 const* pProviderMetadata)
+        {
+            HRESULT hr = E_INVALIDARG;
+
+            if (PrepareEvent())
+            {
+                EVENT_DATA_DESCRIPTOR dataDesc[3];
+                ULONG cDataDesc = 2;
+                if (!m_dataBuffer.empty())
+                {
+                    EventDataDescCreate(
+                        &dataDesc[cDataDesc++],
+                        &m_dataBuffer.front(),
+                        static_cast<ULONG>(m_dataBuffer.size()));
+                }
+
+                hr = ::tld::WriteEvent(
+                    hProvider,
+                    m_descriptor,
+                    pProviderMetadata,
+                    &m_metaBuffer.front(),
+                    cDataDesc,
+                    dataDesc,
+                    m_pActivityId,
+                    m_pRelatedActivityId);
+            }
+
+            return hr;
+        }
+
+#if TLD_HAVE_EVENT_WRITE_EX == 1
+
+        /*
+        Sends the event to ETW using EventWriteEx.
+        */
+        HRESULT WriteEx(
+            Provider const& provider,
+            ULONG64 filter,
+            ULONG flags)
+        {
+            HRESULT hr = E_INVALIDARG;
+            if (PrepareEvent())
+            {
+                hr = provider.WriteEx(
+                    m_descriptor,
+                    &m_metaBuffer.front(),
+                    m_dataBuffer.empty() ? NULL : &m_dataBuffer.front(),
+                    static_cast<UINT32>(m_dataBuffer.size()),
+                    filter,
+                    flags,
+                    m_pActivityId,
+                    m_pRelatedActivityId);
+            }
+            return hr;
+        }
+
+        /*
+        Sends the event to ETW using EventWriteEx.
+        */
+        HRESULT WriteEx(
+            REGHANDLE hProvider,
+            _In_count_x_((UINT16*)pEventMetadata) UINT8 const* pProviderMetadata,
+            ULONG64 filter,
+            ULONG flags)
+        {
+            HRESULT hr = E_INVALIDARG;
+
+            if (PrepareEvent())
+            {
+                EVENT_DATA_DESCRIPTOR dataDesc[3];
+                ULONG cDataDesc = 2;
+                if (!m_dataBuffer.empty())
+                {
+                    EventDataDescCreate(
+                        &dataDesc[cDataDesc++],
+                        &m_dataBuffer.front(),
+                        static_cast<ULONG>(m_dataBuffer.size()));
+                }
+
+                hr = ::tld::WriteEventEx(
+                    hProvider,
+                    m_descriptor,
+                    pProviderMetadata,
+                    &m_metaBuffer.front(),
+                    cDataDesc,
+                    dataDesc,
+                    filter,
+                    flags,
+                    m_pActivityId,
+                    m_pRelatedActivityId);
+            }
+
+            return hr;
+        }
+
+#endif // TLD_HAVE_EVENT_WRITE_EX
+
+#pragma region Basic properties
+
+        UCHAR Channel() const
+        {
+            return m_descriptor.Channel;
+        }
+
+        /*
+        Note: the default channel is 11 (WINEVENT_CHANNEL_TRACELOGGING). 
+        Other channels are only supported if the provider is running on
+        Windows 10 or later. If a provider is running on an earlier version
+        of Windows and it uses a channel other than 11, TDH will not be able
+        to decode the events.
+        */
+        void Channel(UCHAR channel)
+        {
+            m_descriptor.Channel = channel;
+        }
+
+        UCHAR Level() const
+        {
+            return m_descriptor.Level;
+        }
+
+        void Level(UCHAR value)
+        {
+            m_descriptor.Level = value;
+        }
+
+        ULONGLONG Keywords() const
+        {
+            return m_descriptor.Keyword;
+        }
+
+        void Keywords(ULONGLONG value)
+        {
+            m_descriptor.Keyword = value;
+        }
+
+        UCHAR Opcode() const
+        {
+            return m_descriptor.Opcode;
+        }
+
+        void Opcode(UCHAR value)
+        {
+            m_descriptor.Opcode = value;
+        }
+
+        USHORT Task() const
+        {
+            return m_descriptor.Task;
+        }
+
+        void Task(USHORT value)
+        {
+            m_descriptor.Task = value;
+        }
+
+        const GUID* ActivityId() const
+        {
+            return m_pActivityId;
+        }
+
+        void ActivityId(GUID* pValue)
+        {
+            m_pActivityId = pValue;
+        }
+
+        const GUID* RelatedActivityId() const
+        {
+            return m_pRelatedActivityId;
+        }
+
+        void RelatedActivityId(GUID* pValue)
+        {
+            m_pRelatedActivityId = pValue;
+        }
+
+        bool IsEnabledFor(Provider const& provider) const
+        {
+            return provider.IsEnabled(m_descriptor.Level, m_descriptor.Keyword);
+        }
+
+#pragma endregion
+
+    private:
+
+        bool PrepareEvent()
+        {
+            if (m_state == EventStateOpen)
+            {
+                PrepareEventImpl();
+            }
+            return m_state == EventStateClosed;
+        }
+
+        void PrepareEventImpl()
+        {
+            m_state =
+                EventMetadataBuilder<ByteBufferTy>(m_metaBuffer).End()
+                ? EventStateClosed
+                : EventStateError;
+        }
+    };
+
+#pragma endregion
+}
+// namespace tld
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_config.h b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_config.h
new file mode 100644
index 000000000..60cac48a5
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_config.h
@@ -0,0 +1,186 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#include <map>
+
+#include "opentelemetry/nostd/shared_ptr.h"
+#include "opentelemetry/nostd/string_view.h"
+#include "opentelemetry/nostd/unique_ptr.h"
+#include "opentelemetry/nostd/variant.h"
+#include "opentelemetry/trace/span_id.h"
+
+#include "opentelemetry/exporters/etw/etw_provider.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace etw
+{
+/**
+ * @brief TelemetryProvider Options passed via SDK API.
+ */
+using TelemetryProviderOptions =
+    std::map<std::string, nostd::variant<std::string, uint64_t, float, bool>>;
+
+/**
+ * @brief TelemetryProvider runtime configuration class. Internal representation
+ * of TelemetryProviderOptions used by various components of SDK.
+ */
+typedef struct
+{
+  bool enableTraceId;            // Set `TraceId` on ETW events
+  bool enableSpanId;             // Set `SpanId` on ETW events
+  bool enableActivityId;         // Assign `SpanId` to `ActivityId`
+  bool enableActivityTracking;   // Emit TraceLogging events for Span/Start and Span/Stop Not used
+                                 // for Logs
+  bool enableRelatedActivityId;  // Assign parent `SpanId` to `RelatedActivityId`
+  bool enableAutoParent;  // Start new spans as children of current active span, Not used for Logs
+  ETWProvider::EventFormat
+      encoding;  // Event encoding to use for this provider (TLD, MsgPack, XML, etc.).
+} TelemetryProviderConfiguration;
+
+/**
+ * @brief Helper template to convert a variant value from TelemetryProviderOptions to
+ * LoggerProviderConfiguration
+ *
+ * @param options           TelemetryProviderOptions passed on API surface
+ * @param key               Option name
+ * @param value             Reference to destination value
+ * @param defaultValue      Default value if option is not supplied
+ */
+template <typename T>
+static inline void GetOption(const TelemetryProviderOptions &options,
+                             const char *key,
+                             T &value,
+                             T defaultValue)
+{
+  auto it = options.find(key);
+  if (it != options.end())
+  {
+    auto val = it->second;
+    value    = nostd::get<T>(val);
+  }
+  else
+  {
+    value = defaultValue;
+  }
+}
+
+/**
+ * @brief Helper template to convert encoding config option to EventFormat.
+ * Configuration option passed as `options["encoding"] = "MsgPack"`.
+ * Default encoding is TraceLogging Dynamic Manifest (TLD).
+ *
+ * Valid encoding names listed below.
+ *
+ * For MessagePack encoding:
+ * - "MSGPACK"
+ * - "MsgPack"
+ * - "MessagePack"
+ *
+ * For XML encoding:
+ * - "XML"
+ * - "xml"
+ *
+ * For TraceLogging Dynamic encoding:
+ * - "TLD"
+ * - "tld"
+ *
+ */
+static inline ETWProvider::EventFormat GetEncoding(const TelemetryProviderOptions &options)
+{
+  ETWProvider::EventFormat evtFmt = ETWProvider::EventFormat::ETW_MANIFEST;
+
+  auto it = options.find("encoding");
+  if (it != options.end())
+  {
+    auto varValue   = it->second;
+    std::string val = nostd::get<std::string>(varValue);
+
+#pragma warning(push)
+#pragma warning(disable : 4307) /* Integral constant overflow - OK while computing hash */
+    auto h = utils::hashCode(val.c_str());
+    switch (h)
+    {
+      case CONST_HASHCODE(MSGPACK):
+        // nobrk
+      case CONST_HASHCODE(MsgPack):
+        // nobrk
+      case CONST_HASHCODE(MessagePack):
+        evtFmt = ETWProvider::EventFormat::ETW_MSGPACK;
+        break;
+
+      case CONST_HASHCODE(XML):
+        // nobrk
+      case CONST_HASHCODE(xml):
+        evtFmt = ETWProvider::EventFormat::ETW_XML;
+        break;
+
+      case CONST_HASHCODE(TLD):
+        // nobrk
+      case CONST_HASHCODE(tld):
+        // nobrk
+        evtFmt = ETWProvider::EventFormat::ETW_MANIFEST;
+        break;
+
+      default:
+        break;
+    }
+#pragma warning(pop)
+  }
+
+  return evtFmt;
+}
+
+/**
+ * @brief Utility template to obtain etw::TracerProvider._config or etw::LoggerProvider._config
+ *
+ * @tparam T    etw::TracerProvider
+ * @param t     etw::TracerProvider ref
+ * @return      TelemetryProviderConfiguration ref
+ */
+template <class T>
+TelemetryProviderConfiguration &GetConfiguration(T &t)
+{
+  return t.config_;
+}
+
+/**
+ * @brief Utility template to convert SpanId or TraceId to hex.
+ * @param id - value of SpanId or TraceId
+ * @return Hexadecimal representation of Id as string.
+ */
+template <class T>
+static inline std::string ToLowerBase16(const T &id)
+{
+  char buf[2 * T::kSize] = {0};
+  id.ToLowerBase16(buf);
+  return std::string(buf, sizeof(buf));
+}
+
+/**
+ * @brief Utility method to convert span_id (8 byte) to ActivityId GUID (16 bytes)
+ * @param span OpenTelemetry Span Id object
+ * @return GUID struct containing 8-bytes of SpanId + 8 NUL bytes.
+ */
+static inline bool CopySpanIdToActivityId(const opentelemetry::trace::SpanId &span_id,
+                                          GUID &outGuid)
+{
+  memset(&outGuid, 0, sizeof(outGuid));
+  if (!span_id.IsValid())
+  {
+    return false;
+  }
+  auto spanId      = span_id.Id().data();
+  uint8_t *guidPtr = reinterpret_cast<uint8_t *>(&outGuid);
+  for (size_t i = 0; i < 8; i++)
+  {
+    guidPtr[i] = spanId[i];
+  }
+  return true;
+}
+
+}  // namespace etw
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_fields.h b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_fields.h
new file mode 100644
index 000000000..a2fd6c727
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_fields.h
@@ -0,0 +1,142 @@
+/* // Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#pragma once
+
+#include <unordered_map>
+
+#include "opentelemetry/exporters/etw/utils.h"
+
+/* clang-format off */
+#ifdef CUSTOM_ETW_FIELDS_H
+/* Customers may redefine the default field names by including CUSTOM_ETW_FIELDS_H header */
+#  include CUSTOM_ETW_FIELDS_H
+#else
+
+/**
+
+  List of configurable Field Name constants:
+
+   Version                      - Schema version (optional for ETW exporter).
+   _name                        - Built-in ETW name at envelope level (dedicated ETW field).
+   _time                        - Built-in ETW time at envelope level (dedicated ETW field).
+   SpanId                       - OT SpanId
+   TraceId                      - OT TraceId
+   StartTime                    - OT Span start time
+   Kind                         - OT Span kind
+   Name                         - OT Span name in ETW 'Payload["Name"]'
+   ParentId                     - OT Span parentId
+   Links                        - OT Span links array
+
+  Other standard fields (reserved names) that may be appended by ETW channel:
+
+   Level                        - a 1-byte integer that enables filtering based on the severity or verbosity of events
+   ProviderGuid                 - ETW Provider Guid
+   ProviderName                 - ETW Provider Name
+   OpcodeName                   - Name of Opcode (e.g. Start, Stop)
+   KeywordName                  - Name of Keyword
+   TaskName                     - TaskName, could be handled as an alias to Payload['name']
+   ChannelName                  - ETW Channel Name
+   EventMessage                 - ETW Event Message string for unstructured events
+   ActivityId                   - ActivityId for EventSource parenting (current event)
+   RelatedActivityId            - RelatedActivityId for EventSource parenting (parent event)
+   Pid                          - Process Id
+   Tid                          - Thread Id
+
+  Example "Span" as shown in Visual Studio "Diagnostic Events" view. EventName="Span":
+
+    {
+      "Timestamp": "2021-04-01T00:33:25.5876605-07:00",
+      "ProviderName": "OpenTelemetry-ETW-TLD",
+      "Id": 20,
+      "Message": null,
+      "ProcessId": 10424,
+      "Level": "Always",
+      "Keywords": "0x0000000000000000",
+      "EventName": "Span",
+      "ActivityID": "56f2366b-5475-496f-0000-000000000000",
+      "RelatedActivityID": null,
+      "Payload": {
+        "Duration": 0,
+        "Name": "B.max",
+        "ParentId": "8ad900d0587fad4a",
+        "SpanId": "6b36f25675546f49",
+        "StartTime": "2021-04-01T07:33:25.587Z",
+        "TraceId": "8f8ac710c37c5a419f0fe574f335e986"
+      }
+    }
+
+  Example named Event on Span. Note that EventName="MyEvent2" in this case:
+
+    {
+      "Timestamp": "2021-04-01T00:33:22.5848789-07:00",
+      "ProviderName": "OpenTelemetry-ETW-TLD",
+      "Id": 15,
+      "Message": null,
+      "ProcessId": 10424,
+      "Level": "Always",
+      "Keywords": "0x0000000000000000",
+      "EventName": "MyEvent2",
+      "ActivityID": null,
+      "RelatedActivityID": null,
+      "Payload": {
+        "SpanId": "0da9f6bf7524a449",
+        "TraceId": "7715c9d490f54f44a5d0c6b62570f1b2",
+        "strKey": "anotherValue",
+        "uint32Key": 9876,
+        "uint64Key": 987654321
+      }
+    }
+
+ */
+#  define ETW_FIELD_VERSION         "Version"               /* Event version           */
+#  define ETW_FIELD_TYPE            "Type"              	/* Event type              */
+#  define ETW_FIELD_NAME            "_name"              	/* Event name              */
+#  define ETW_FIELD_TIME            "_time"              	/* Event time              */
+#  define ETW_FIELD_OPCODE          "OpCode"            	/* OpCode for TraceLogging */
+
+#  define ETW_FIELD_TRACE_ID        "TraceId"        		/* Trace Id                */
+#  define ETW_FIELD_SPAN_ID         "SpanId"         		/* Span Id                 */
+#  define ETW_FIELD_SPAN_PARENTID   "ParentId"              /* Span ParentId           */
+#  define ETW_FIELD_SPAN_KIND       "Kind"                  /* Span Kind               */
+#  define ETW_FIELD_SPAN_LINKS      "Links"                 /* Span Links array        */
+
+#  define ETW_FIELD_PAYLOAD_NAME    "Name"                  /* ETW Payload["Name"]     */
+
+/* Span option constants */
+#  define ETW_FIELD_STARTTIME       "StartTime"             /* Operation start time    */
+#  define ETW_FIELD_DURATION        "Duration"              /* Operation duration      */
+#  define ETW_FIELD_STATUSCODE      "StatusCode"            /* Span status code        */
+#  define ETW_FIELD_STATUSMESSAGE   "StatusMessage"         /* Span status message     */
+#  define ETW_FIELD_SUCCESS         "Success"               /* Span success            */
+#  define ETW_FIELD_TIMESTAMP       "Timestamp"             /* Log timestamp   */
+
+/* Value constants */
+#  define ETW_VALUE_SPAN            "Span"                  /* ETW event name for Span */
+#  define ETW_VALUE_LOG             "Log"                   /* ETW event name for Log */
+
+#  define ETW_VALUE_SPAN_START      "SpanStart"             /* ETW for Span Start      */
+#  define ETW_VALUE_SPAN_END        "SpanEnd"               /* ETW for Span Start      */
+
+
+/* Log specific */
+# define ETW_FIELD_LOG_BODY               "body"                 /* Log body   */
+# define ETW_FIELD_LOG_SEVERITY_TEXT      "severityText"         /* Sev text  */
+# define ETW_FIELD_LOG_SEVERITY_NUM       "severityNumber"      /* Sev num   */
+
+
+#endif
+
+/* clang-format on */
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_logger.h b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_logger.h
new file mode 100644
index 000000000..bd2478224
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_logger.h
@@ -0,0 +1,297 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifdef ENABLE_LOGS_PREVIEW
+
+#  include <algorithm>
+
+#  include <cstdint>
+#  include <cstdio>
+#  include <cstdlib>
+#  include <sstream>
+#  include <type_traits>
+
+#  include <fstream>
+
+#  include <map>
+
+#  include "opentelemetry/nostd/shared_ptr.h"
+#  include "opentelemetry/nostd/string_view.h"
+#  include "opentelemetry/nostd/unique_ptr.h"
+#  include "opentelemetry/nostd/variant.h"
+
+#  include "opentelemetry/common/key_value_iterable_view.h"
+
+#  include "opentelemetry/logs/logger_provider.h"
+#  include "opentelemetry/trace/span_id.h"
+#  include "opentelemetry/trace/trace_id.h"
+
+#  include "opentelemetry/exporters/etw/etw_config.h"
+#  include "opentelemetry/exporters/etw/etw_fields.h"
+#  include "opentelemetry/exporters/etw/etw_properties.h"
+#  include "opentelemetry/exporters/etw/etw_provider.h"
+#  include "opentelemetry/exporters/etw/utils.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace etw
+{
+
+class LoggerProvider;
+
+/**
+ * @brief Logger  class that allows to send logs to ETW Provider.
+ */
+class Logger : public opentelemetry::logs::Logger
+{
+
+  /**
+   * @brief Parent provider of this Tracer
+   */
+  etw::LoggerProvider &loggerProvider_;
+
+  /**
+   * @brief ProviderId (Name or GUID)
+   */
+  std::string provId;
+
+  /**
+   * @brief Encoding (Manifest, MessagePack or XML)
+   */
+  ETWProvider::EventFormat encoding;
+
+  /**
+   * @brief Provider Handle
+   */
+  ETWProvider::Handle &provHandle;
+
+  /**
+   * @brief ETWProvider is a singleton that aggregates all ETW writes.
+   * @return
+   */
+  static ETWProvider &etwProvider()
+  {
+    static ETWProvider instance;  // C++11 magic static
+    return instance;
+  }
+
+  /**
+   * @brief Init a reference to etw::ProviderHandle
+   * @return Provider Handle
+   */
+  ETWProvider::Handle &initProvHandle() { return etwProvider().open(provId, encoding); }
+
+public:
+  /**
+   * @brief Tracer constructor
+   * @param parent Parent LoggerProvider
+   * @param providerId ProviderId - Name or GUID
+   * @param encoding ETW encoding format to use.
+   */
+  Logger(etw::LoggerProvider &parent,
+         nostd::string_view providerId     = "",
+         ETWProvider::EventFormat encoding = ETWProvider::EventFormat::ETW_MANIFEST)
+      : opentelemetry::logs::Logger(),
+        loggerProvider_(parent),
+        provId(providerId.data(), providerId.size()),
+        encoding(encoding),
+        provHandle(initProvHandle())
+  {}
+
+  void Log(opentelemetry::logs::Severity severity,
+           nostd::string_view body,
+           const common::KeyValueIterable &attributes,
+           opentelemetry::trace::TraceId trace_id,
+           opentelemetry::trace::SpanId span_id,
+           opentelemetry::trace::TraceFlags trace_flags,
+           common::SystemTimestamp timestamp) noexcept override
+  {
+
+#  ifdef OPENTELEMETRY_RTTI_ENABLED
+    common::KeyValueIterable &attribs = const_cast<common::KeyValueIterable &>(attributes);
+    Properties *evt                   = dynamic_cast<Properties *>(&attribs);
+    // Properties *res                   = dynamic_cast<Properties *>(&resr);
+
+    if (evt != nullptr)
+    {
+      // Pass as a reference to original modifyable collection without creating a copy
+      return Log(severity, provId, body, *evt, trace_id, span_id, trace_flags, timestamp);
+    }
+#  endif
+    Properties evtCopy = attributes;
+    return Log(severity, provId, body, evtCopy, trace_id, span_id, trace_flags, timestamp);
+  }
+
+  void Log(opentelemetry::logs::Severity severity,
+           nostd::string_view name,
+           nostd::string_view body,
+           const common::KeyValueIterable &attributes,
+           opentelemetry::trace::TraceId trace_id,
+           opentelemetry::trace::SpanId span_id,
+           opentelemetry::trace::TraceFlags trace_flags,
+           common::SystemTimestamp timestamp) noexcept override
+  {
+
+#  ifdef OPENTELEMETRY_RTTI_ENABLED
+    common::KeyValueIterable &attribs = const_cast<common::KeyValueIterable &>(attributes);
+    Properties *evt                   = dynamic_cast<Properties *>(&attribs);
+    // Properties *res                   = dynamic_cast<Properties *>(&resr);
+
+    if (evt != nullptr)
+    {
+      // Pass as a reference to original modifyable collection without creating a copy
+      return Log(severity, name, body, *evt, trace_id, span_id, trace_flags, timestamp);
+    }
+#  endif
+    Properties evtCopy = attributes;
+    return Log(severity, name, body, evtCopy, trace_id, span_id, trace_flags, timestamp);
+  }
+
+  virtual void Log(opentelemetry::logs::Severity severity,
+                   nostd::string_view name,
+                   nostd::string_view body,
+                   Properties &evt,
+                   opentelemetry::trace::TraceId trace_id,
+                   opentelemetry::trace::SpanId span_id,
+                   opentelemetry::trace::TraceFlags trace_flags,
+                   common::SystemTimestamp timestamp) noexcept
+  {
+    // Populate Etw.EventName attribute at envelope level
+    evt[ETW_FIELD_NAME] = ETW_VALUE_LOG;
+
+#  ifdef HAVE_FIELD_TIME
+    {
+      auto timeNow        = std::chrono::system_clock::now().time_since_epoch();
+      auto millis         = std::chrono::duration_cast<std::chrono::milliseconds>(timeNow).count();
+      evt[ETW_FIELD_TIME] = utils::formatUtcTimestampMsAsISO8601(millis);
+    }
+#  endif
+    const auto &cfg = GetConfiguration(loggerProvider_);
+    if (cfg.enableSpanId)
+    {
+      evt[ETW_FIELD_SPAN_ID] = ToLowerBase16(span_id);
+    }
+    if (cfg.enableTraceId)
+    {
+      evt[ETW_FIELD_TRACE_ID] = ToLowerBase16(trace_id);
+    }
+    // Populate ActivityId if enabled
+    GUID ActivityId;
+    LPGUID ActivityIdPtr = nullptr;
+    if (cfg.enableActivityId)
+    {
+      if (CopySpanIdToActivityId(span_id, ActivityId))
+      {
+        ActivityIdPtr = &ActivityId;
+      }
+    }
+    evt[ETW_FIELD_PAYLOAD_NAME]              = std::string(name.data(), name.size());
+    std::chrono::system_clock::time_point ts = timestamp;
+    int64_t tsMs =
+        std::chrono::duration_cast<std::chrono::milliseconds>(ts.time_since_epoch()).count();
+    evt[ETW_FIELD_TIMESTAMP] = utils::formatUtcTimestampMsAsISO8601(tsMs);
+    int severity_index       = static_cast<int>(severity);
+    if (severity_index < 0 ||
+        severity_index >= std::extent<decltype(opentelemetry::logs::SeverityNumToText)>::value)
+    {
+      std::stringstream sout;
+      sout << "Invalid severity(" << severity_index << ")";
+      evt[ETW_FIELD_LOG_SEVERITY_TEXT] = sout.str();
+    }
+    else
+    {
+      evt[ETW_FIELD_LOG_SEVERITY_TEXT] =
+          opentelemetry::logs::SeverityNumToText[severity_index].data();
+    }
+    evt[ETW_FIELD_LOG_SEVERITY_NUM] = static_cast<uint32_t>(severity);
+    evt[ETW_FIELD_LOG_BODY]         = std::string(body.data(), body.length());
+    etwProvider().write(provHandle, evt, nullptr, nullptr, 0, encoding);
+  }
+
+  const nostd::string_view GetName() noexcept override { return std::string(); }
+  // TODO : Flush and Shutdown method in main Logger API
+  ~Logger() { etwProvider().close(provHandle); }
+};
+
+/**
+ * @brief ETW LoggerProvider
+ */
+class LoggerProvider : public opentelemetry::logs::LoggerProvider
+{
+public:
+  /**
+   * @brief LoggerProvider options supplied during initialization.
+   */
+  TelemetryProviderConfiguration config_;
+
+  /**
+   * @brief Construct instance of LoggerProvider with given options
+   * @param options Configuration options
+   */
+  LoggerProvider(TelemetryProviderOptions options) : opentelemetry::logs::LoggerProvider()
+  {
+    GetOption(options, "enableTraceId", config_.enableTraceId, true);
+    GetOption(options, "enableSpanId", config_.enableSpanId, true);
+    GetOption(options, "enableActivityId", config_.enableActivityId, false);
+
+    // Determines what encoding to use for ETW events: TraceLogging Dynamic, MsgPack, XML, etc.
+    config_.encoding = GetEncoding(options);
+  }
+
+  LoggerProvider() : opentelemetry::logs::LoggerProvider()
+  {
+    config_.encoding = ETWProvider::EventFormat::ETW_MANIFEST;
+  }
+
+  nostd::shared_ptr<opentelemetry::logs::Logger> GetLogger(
+      nostd::string_view logger_name,
+      nostd::string_view options,
+      nostd::string_view library_name,
+      nostd::string_view version    = "",
+      nostd::string_view schema_url = "") override
+  {
+    UNREFERENCED_PARAMETER(options);
+    UNREFERENCED_PARAMETER(library_name);
+    UNREFERENCED_PARAMETER(version);
+    UNREFERENCED_PARAMETER(schema_url);
+    ETWProvider::EventFormat evtFmt = config_.encoding;
+    return nostd::shared_ptr<opentelemetry::logs::Logger>{
+        new (std::nothrow) etw::Logger(*this, logger_name, evtFmt)};
+  }
+
+  /**
+   * @brief Obtain ETW Tracer.
+   * @param name ProviderId (instrumentation name) - Name or GUID
+   * @param args Additional arguments that controls `codec` of the provider.
+   * Possible values are:
+   * - "ETW"            - 'classic' Trace Logging Dynamic manifest ETW events.
+   * - "MSGPACK"        - MessagePack-encoded binary payload ETW events.
+   * - "XML"            - XML events (reserved for future use)
+   * @param library_name Library name
+   * @param version Library version
+   * @param schema_url schema URL
+   * @return
+   */
+  nostd::shared_ptr<opentelemetry::logs::Logger> GetLogger(
+      nostd::string_view logger_name,
+      nostd::span<nostd::string_view> args,
+      nostd::string_view library_name,
+      nostd::string_view version    = "",
+      nostd::string_view schema_url = "") override
+  {
+    UNREFERENCED_PARAMETER(args);
+    UNREFERENCED_PARAMETER(library_name);
+    UNREFERENCED_PARAMETER(version);
+    UNREFERENCED_PARAMETER(schema_url);
+    ETWProvider::EventFormat evtFmt = config_.encoding;
+    return nostd::shared_ptr<opentelemetry::logs::Logger>{
+        new (std::nothrow) etw::Logger(*this, logger_name, evtFmt)};
+  }
+};
+
+}  // namespace etw
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif  // ENABLE_LOGS_PREVIEW
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_logger_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_logger_exporter.h
new file mode 100644
index 000000000..9b96cb27a
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_logger_exporter.h
@@ -0,0 +1,30 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#ifdef ENABLE_LOGS_PREVIEW
+#  include <cstdint>
+#  include <cstdio>
+#  include <cstdlib>
+
+#  include <mutex>
+
+#  include "opentelemetry/nostd/shared_ptr.h"
+#  include "opentelemetry/nostd/string_view.h"
+#  include "opentelemetry/nostd/unique_ptr.h"
+
+#  include "opentelemetry/common/key_value_iterable_view.h"
+
+#  include "opentelemetry/logs/logger_provider.h"
+#  include "opentelemetry/trace/span_id.h"
+#  include "opentelemetry/trace/trace_id.h"
+
+#  include "opentelemetry/sdk/logs/exporter.h"
+
+#  include "opentelemetry/exporters/etw/etw_config.h"
+#  include "opentelemetry/exporters/etw/etw_logger.h"
+#  include "opentelemetry/exporters/etw/etw_provider.h"
+
+#  include "opentelemetry/exporters/etw/utils.h"
+
+#endif  // ENABLE_LOGS_PREVIEW
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_properties.h b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_properties.h
new file mode 100644
index 000000000..3cf365c8a
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_properties.h
@@ -0,0 +1,456 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include "opentelemetry/version.h"
+
+#include "opentelemetry/common/key_value_iterable_view.h"
+
+#include <opentelemetry/nostd/span.h>
+#include <map>
+#include <string>
+#include <vector>
+
+#ifdef _WIN32
+#  include <Windows.h>
+#endif
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace etw
+{
+
+/**
+ * @brief PropertyVariant provides:
+ * - a constructor to initialize from initializer lists
+ * - an owning wrapper around `common::AttributeValue`
+ */
+using PropertyVariant =
+    nostd::variant<bool,
+                   int32_t,
+                   int64_t,
+                   uint32_t,
+                   uint64_t,
+                   double,
+                   std::string,
+                   const char *,
+                   // 8-bit byte arrays / binary blobs are not part of OT spec yet!
+                   // Ref: https://github.com/open-telemetry/opentelemetry-specification/issues/780
+                   std::vector<uint8_t>,
+                   std::vector<bool>,
+                   std::vector<int32_t>,
+                   std::vector<int64_t>,
+                   std::vector<uint32_t>,
+                   std::vector<uint64_t>,
+                   std::vector<double>,
+                   std::vector<std::string>>;
+
+enum PropertyType
+{
+  kTypeBool,
+  kTypeInt,
+  kTypeInt64,
+  kTypeUInt,
+  kTypeUInt64,
+  kTypeDouble,
+  kTypeString,
+  kTypeCString,
+  kTypeSpanByte,
+  kTypeSpanBool,
+  kTypeSpanInt,
+  kTypeSpanInt64,
+  kTypeSpanUInt,
+  kTypeSpanUInt64,
+  kTypeSpanDouble,
+  kTypeSpanString
+};
+
+/**
+ * @brief PropertyValue class that holds PropertyVariant and
+ * provides converter for non-owning common::AttributeValue
+ */
+class PropertyValue : public PropertyVariant
+{
+
+  /**
+   * @brief Convert span<T> to vector<T>
+   * @tparam T
+   * @param source
+   * @return
+   */
+  template <typename T>
+  static std::vector<T> to_vector(const nostd::span<const T, nostd::dynamic_extent> &source)
+  {
+    return std::vector<T>(source.begin(), source.end());
+  }
+
+  /**
+   * @brief Convert span<string_view> to vector<string>
+   * @param source Span of non-owning string views.
+   * @return Vector of owned strings.
+   */
+  std::vector<std::string> static to_vector(const nostd::span<const nostd::string_view> &source)
+  {
+    std::vector<std::string> result(source.size());
+    for (const auto &item : source)
+    {
+      result.push_back(std::string(item.data()));
+    }
+    return result;
+  }
+
+  /**
+   * @brief Convert vector<INTEGRAL> to span<INTEGRAL>.
+   * @tparam T Integral type
+   * @param vec Vector of integral type primitives to convert to span.
+   * @return Span of integral type primitives.
+   */
+  template <typename T, std::enable_if_t<std::is_integral<T>::value, bool> = true>
+  static nostd::span<const T> to_span(const std::vector<T> &vec)
+  {
+    nostd::span<const T> result(vec.data(), vec.size());
+    return result;
+  }
+
+  /**
+   * @brief Convert vector<FLOAT> to span<const FLOAT>.
+   * @tparam T Float type
+   * @param vec Vector of float type primitives to convert to span.
+   * @return Span of float type primitives.
+   */
+  template <typename T, std::enable_if_t<std::is_floating_point<T>::value, bool> = true>
+  static nostd::span<const T> to_span(const std::vector<T> &vec)
+  {
+    nostd::span<const T> result(vec.data(), vec.size());
+    return result;
+  }
+
+public:
+  /**
+   * @brief PropertyValue from bool
+   * @param v
+   * @return
+   */
+  PropertyValue(bool value) : PropertyVariant(value) {}
+
+  /**
+   * @brief PropertyValue from integral.
+   * @param v
+   * @return
+   */
+  template <typename TInteger, std::enable_if_t<std::is_integral<TInteger>::value, bool> = true>
+  PropertyValue(TInteger number) : PropertyVariant(number)
+  {}
+
+  /**
+   * @brief PropertyValue from floating point.
+   * @param v
+   * @return
+   */
+  template <typename TFloat, std::enable_if_t<std::is_floating_point<TFloat>::value, bool> = true>
+  PropertyValue(TFloat number) : PropertyVariant(double(number))
+  {}
+
+  /**
+   * @brief Default PropertyValue (int32_t=0)
+   * @param v
+   * @return
+   */
+  PropertyValue() : PropertyVariant(int32_t(0)) {}
+
+  /**
+   * @brief PropertyValue from array of characters as string.
+   *
+   * @param v
+   * @return
+   */
+  PropertyValue(char value[]) : PropertyVariant(std::string(value)) {}
+
+  /**
+   * @brief PropertyValue from array of characters as string.
+   *
+   * @param v
+   * @return
+   */
+  PropertyValue(const char *value) : PropertyVariant(std::string(value)) {}
+
+  /**
+   * @brief PropertyValue from string.
+   *
+   * @param v
+   * @return
+   */
+  PropertyValue(const std::string &value) : PropertyVariant(value) {}
+
+  /**
+   * @brief PropertyValue from vector as array.
+   * @return
+   */
+  template <typename T>
+  PropertyValue(std::vector<T> value) : PropertyVariant(value)
+  {}
+
+  /**
+   * @brief Convert non-owning common::AttributeValue to owning PropertyValue.
+   * @return
+   */
+  PropertyValue &FromAttributeValue(const common::AttributeValue &v)
+  {
+    switch (v.index())
+    {
+      case common::AttributeType::kTypeBool:
+        PropertyVariant::operator=(nostd::get<bool>(v));
+        break;
+      case common::AttributeType::kTypeInt:
+        PropertyVariant::operator=(nostd::get<int32_t>(v));
+        break;
+      case common::AttributeType::kTypeInt64:
+        PropertyVariant::operator=(nostd::get<int64_t>(v));
+        break;
+      case common::AttributeType::kTypeUInt:
+        PropertyVariant::operator=(nostd::get<uint32_t>(v));
+        break;
+      case common::AttributeType::kTypeUInt64:
+        PropertyVariant::operator=(nostd::get<uint64_t>(v));
+        break;
+      case common::AttributeType::kTypeDouble:
+        PropertyVariant::operator=(nostd::get<double>(v));
+        break;
+      case common::AttributeType::kTypeCString: {
+        PropertyVariant::operator=(nostd::get<const char *>(v));
+        break;
+      }
+      case common::AttributeType::kTypeString: {
+        PropertyVariant::operator=
+            (std::string{nostd::string_view(nostd::get<nostd::string_view>(v)).data()});
+        break;
+      }
+
+      case common::AttributeType::kTypeSpanByte:
+        PropertyVariant::operator=(to_vector(nostd::get<nostd::span<const uint8_t>>(v)));
+        break;
+
+      case common::AttributeType::kTypeSpanBool:
+        PropertyVariant::operator=(to_vector(nostd::get<nostd::span<const bool>>(v)));
+        break;
+
+      case common::AttributeType::kTypeSpanInt:
+        PropertyVariant::operator=(to_vector(nostd::get<nostd::span<const int32_t>>(v)));
+        break;
+
+      case common::AttributeType::kTypeSpanInt64:
+        PropertyVariant::operator=(to_vector(nostd::get<nostd::span<const int64_t>>(v)));
+        break;
+
+      case common::AttributeType::kTypeSpanUInt:
+        PropertyVariant::operator=(to_vector(nostd::get<nostd::span<const uint32_t>>(v)));
+        break;
+
+      case common::AttributeType::kTypeSpanUInt64:
+        PropertyVariant::operator=(to_vector(nostd::get<nostd::span<const uint64_t>>(v)));
+        break;
+
+      case common::AttributeType::kTypeSpanDouble:
+        PropertyVariant::operator=(to_vector(nostd::get<nostd::span<const double>>(v)));
+        break;
+
+      case common::AttributeType::kTypeSpanString:
+        PropertyVariant::operator=(to_vector(nostd::get<nostd::span<const nostd::string_view>>(v)));
+        break;
+
+      default:
+        break;
+    }
+    return (*this);
+  }
+
+  /**
+   * @brief Convert owning PropertyValue to non-owning common::AttributeValue
+   * @param other
+   */
+  common::AttributeValue ToAttributeValue() const
+  {
+    common::AttributeValue value;
+
+    switch (this->index())
+    {
+      case PropertyType::kTypeBool:
+        value = nostd::get<bool>(*this);
+        break;
+      case PropertyType::kTypeInt:
+        value = nostd::get<int32_t>(*this);
+        break;
+      case PropertyType::kTypeInt64:
+        value = nostd::get<int64_t>(*this);
+        break;
+      case PropertyType::kTypeUInt:
+        value = nostd::get<uint32_t>(*this);
+        break;
+      case PropertyType::kTypeUInt64:
+        value = nostd::get<uint64_t>(*this);
+        break;
+      case PropertyType::kTypeDouble:
+        value = nostd::get<double>(*this);
+        break;
+      case PropertyType::kTypeString: {
+        const std::string &str = nostd::get<std::string>(*this);
+        return nostd::string_view(str.data(), str.size());
+        break;
+      }
+      case PropertyType::kTypeCString: {
+        const char *data = nostd::get<const char *>(*this);
+        return nostd::string_view(data, (data) ? strlen(data) : 0);
+        break;
+      }
+      case PropertyType::kTypeSpanByte: {
+        value = to_span(nostd::get<std::vector<uint8_t>>(*this));
+        break;
+      }
+      case PropertyType::kTypeSpanBool: {
+        const auto &vec = nostd::get<std::vector<bool>>(*this);
+        // FIXME: sort out how to remap from vector<bool> to span<bool>
+        UNREFERENCED_PARAMETER(vec);
+        break;
+      }
+      case PropertyType::kTypeSpanInt:
+        value = to_span(nostd::get<std::vector<int32_t>>(*this));
+        break;
+
+      case PropertyType::kTypeSpanInt64:
+        value = to_span(nostd::get<std::vector<int64_t>>(*this));
+        break;
+
+      case PropertyType::kTypeSpanUInt:
+        value = to_span(nostd::get<std::vector<uint32_t>>(*this));
+        break;
+
+      case PropertyType::kTypeSpanUInt64:
+        value = to_span(nostd::get<std::vector<uint64_t>>(*this));
+        break;
+
+      case PropertyType::kTypeSpanDouble:
+        value = to_span(nostd::get<std::vector<double>>(*this));
+        break;
+
+      case PropertyType::kTypeSpanString:
+        // FIXME: sort out how to remap from vector<string> to span<string_view>
+        // value = to_span(nostd::get<std::vector<std::string>>(self));
+        break;
+
+      default:
+        break;
+    }
+    return value;
+  }
+};
+
+/**
+ * @brief Map of PropertyValue
+ */
+using PropertyValueMap = std::map<std::string, PropertyValue>;
+
+/**
+ * @brief Map of PropertyValue with common::KeyValueIterable interface.
+ */
+class Properties : public common::KeyValueIterable, public PropertyValueMap
+{
+
+  /**
+   * @brief Helper tyoe for map constructor.
+   */
+  using PropertyValueType = std::pair<const std::string, PropertyValue>;
+
+public:
+  /**
+   * @brief PropertyValueMap constructor.
+   */
+  Properties() : PropertyValueMap() {}
+
+  /**
+   * @brief PropertyValueMap constructor from initializer list.
+   */
+  Properties(const std::initializer_list<PropertyValueType> properties) : PropertyValueMap()
+  {
+    (*this) = (properties);
+  }
+
+  /**
+   * @brief PropertyValueMap assignment operator from initializer list.
+   */
+  Properties &operator=(std::initializer_list<PropertyValueType> properties)
+  {
+    PropertyValueMap::operator=(properties);
+    return (*this);
+  }
+
+  /**
+   * @brief PropertyValueMap constructor from map.
+   */
+  Properties(const PropertyValueMap &properties) : PropertyValueMap() { (*this) = properties; }
+
+  /**
+   * @brief PropertyValueMap assignment operator from map.
+   */
+  Properties &operator=(const PropertyValueMap &properties)
+  {
+    PropertyValueMap::operator=(properties);
+    return (*this);
+  }
+
+  /**
+   * @brief PropertyValueMap constructor from KeyValueIterable
+   * allows to convert non-Owning KeyValueIterable to owning
+   * container.
+   *
+   */
+  Properties(const common::KeyValueIterable &other) { (*this) = other; }
+
+  /**
+   * @brief PropertyValueMap assignment operator.
+   */
+  Properties &operator=(const common::KeyValueIterable &other)
+  {
+    clear();
+    other.ForEachKeyValue([&](nostd::string_view key, common::AttributeValue value) noexcept {
+      std::string k(key.data(), key.length());
+      (*this)[k].FromAttributeValue(value);
+      return true;
+    });
+    return (*this);
+  }
+
+  /**
+   * @brief PropertyValueMap property accessor.
+   */
+  PropertyValue &operator[](const std::string &k) { return PropertyValueMap::operator[](k); }
+
+  /**
+   * Iterate over key-value pairs
+   * @param callback a callback to invoke for each key-value. If the callback returns false,
+   * the iteration is aborted.
+   * @return true if every key-value pair was iterated over
+   */
+  bool ForEachKeyValue(nostd::function_ref<bool(nostd::string_view, common::AttributeValue)>
+                           callback) const noexcept override
+  {
+    for (const auto &kv : (*this))
+    {
+      const common::AttributeValue &value = kv.second.ToAttributeValue();
+      if (!callback(nostd::string_view{kv.first}, value))
+      {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * @return the number of key-value pairs
+   */
+  size_t size() const noexcept override { return PropertyValueMap::size(); }
+};
+
+}  // namespace etw
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_provider.h b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_provider.h
new file mode 100644
index 000000000..51cca03a6
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_provider.h
@@ -0,0 +1,629 @@
+// // Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#ifndef WIN32_LEAN_AND_MEAN
+#  define WIN32_LEAN_AND_MEAN
+#endif
+
+#ifdef _MSC_VER
+#  pragma warning(push)
+#  pragma warning(disable : 4459)
+#  pragma warning(disable : 4018)
+#  pragma warning(disable : 5054)
+#endif
+
+#include "opentelemetry/exporters/etw/etw_properties.h"
+#include "opentelemetry/exporters/etw/uuid.h"
+#include "opentelemetry/version.h"
+
+#include "opentelemetry/exporters/etw/etw_fields.h"
+#include "opentelemetry/exporters/etw/utils.h"
+
+#ifdef HAVE_MSGPACK
+#  include "nlohmann/json.hpp"
+#endif
+
+#include "opentelemetry/exporters/etw/etw_traceloggingdynamic.h"
+
+#include <map>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#ifdef HAVE_KRABS_TESTS
+// krabs.hpp requires this definition of min macro from Windows.h
+#  ifndef min
+#    define min(a, b) (((a) < (b)) ? (a) : (b))
+#  endif
+#endif
+
+#define MICROSOFT_EVENTTAG_NORMAL_PERSISTENCE 0x01000000
+
+using namespace OPENTELEMETRY_NAMESPACE::exporter::etw;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+
+class ETWProvider
+{
+
+public:
+  const unsigned long STATUS_OK    = 0;
+  const unsigned long STATUS_ERROR = ULONG_MAX;
+  const unsigned long STATUS_EFBIG = ULONG_MAX - 1;
+
+  enum EventFormat
+  {
+    ETW_MANIFEST = 0,
+    ETW_MSGPACK  = 1,
+    ETW_XML      = 2
+  };
+
+  /// <summary>
+  /// Entry that contains Provider Handle, Provider MetaData and Provider GUID
+  /// </summary>
+  struct Handle
+  {
+    uint64_t refCount;
+    REGHANDLE providerHandle;
+    std::vector<BYTE> providerMetaVector;
+    GUID providerGuid;
+  };
+
+  /// <summary>
+  /// Check if given provider is registered.
+  /// </summary>
+  /// <param name="providerId"></param>
+  /// <returns></returns>
+  bool is_registered(const std::string &providerId)
+  {
+    std::lock_guard<std::mutex> lock(m_providerMapLock);
+    auto it = providers().find(providerId);
+    if (it != providers().end())
+    {
+      if (it->second.providerHandle != INVALID_HANDLE)
+      {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /// <summary>
+  /// Get Provider by Name or string representation of GUID
+  /// </summary>
+  /// <param name="providerId"></param>
+  /// <returns></returns>
+  Handle &open(const std::string &providerId, EventFormat format = EventFormat::ETW_MSGPACK)
+  {
+    std::lock_guard<std::mutex> lock(m_providerMapLock);
+
+    // Check and return if provider is already registered
+    auto it = providers().find(providerId);
+    if (it != providers().end())
+    {
+      if (it->second.providerHandle != INVALID_HANDLE)
+      {
+        it->second.refCount++;
+        return it->second;
+      }
+    }
+
+    // Register provider if necessary
+    auto &data = providers()[providerId];
+    data.providerMetaVector.clear();
+
+    utils::UUID guid = (providerId.rfind("{", 0) == 0) ? utils::UUID(providerId.c_str())
+                                                       :                // It's a ProviderGUID
+                           utils::GetProviderGuid(providerId.c_str());  // It's a ProviderName
+
+    data.providerGuid = guid.to_GUID();
+
+    // TODO: currently we do not allow to specify a custom group GUID
+    GUID providerGroupGuid = NULL_GUID;
+
+    switch (format)
+    {
+      // Register with TraceLoggingDynamic facility - dynamic manifest ETW events.
+      case EventFormat::ETW_MANIFEST: {
+        tld::ProviderMetadataBuilder<std::vector<BYTE>> providerMetaBuilder(
+            data.providerMetaVector);
+
+        // Use Tenant ID as provider Name
+        providerMetaBuilder.Begin(providerId.c_str());
+        providerMetaBuilder.AddTrait(tld::ProviderTraitType::ProviderTraitGroupGuid,
+                                     (void *)&providerGroupGuid, sizeof(GUID));
+        providerMetaBuilder.End();
+
+        REGHANDLE hProvider = 0;
+        if (0 !=
+            tld::RegisterProvider(&hProvider, &data.providerGuid, data.providerMetaVector.data()))
+        {
+          // There was an error registering the ETW provider
+          data.refCount       = 0;
+          data.providerHandle = INVALID_HANDLE;
+        }
+        else
+        {
+          data.refCount       = 1;
+          data.providerHandle = hProvider;
+        }
+      }
+      break;
+
+#ifdef HAVE_MSGPACK
+      // Register for MsgPack payload ETW events.
+      case EventFormat::ETW_MSGPACK: {
+        REGHANDLE hProvider = 0;
+        if (EventRegister(&data.providerGuid, NULL, NULL, &hProvider) != ERROR_SUCCESS)
+        {
+          // There was an error registering the ETW provider
+          data.refCount       = 0;
+          data.providerHandle = INVALID_HANDLE;
+        }
+        else
+        {
+          data.refCount       = 1;
+          data.providerHandle = hProvider;
+        }
+      }
+      break;
+#endif
+
+      default:
+        // TODO: other protocols, e.g. XML events - not supported yet
+        break;
+    }
+
+    // We always return an entry even if we failed to register.
+    // Caller should check whether the hProvider handle is valid.
+    return data;
+  }
+
+  /**
+   * @brief Unregister provider
+   * @param data Provider Handle
+   * @return status code
+   */
+  unsigned long close(Handle handle)
+  {
+    std::lock_guard<std::mutex> lock(m_providerMapLock);
+
+    // use reference to provider list, NOT it' copy.
+    auto &m = providers();
+    auto it = m.begin();
+    while (it != m.end())
+    {
+      if (it->second.providerHandle == handle.providerHandle)
+      {
+        // reference to item in the map of open provider handles
+        auto &data           = it->second;
+        unsigned long result = STATUS_OK;
+
+        data.refCount--;
+        if (data.refCount == 0)
+        {
+          if (data.providerMetaVector.size())
+          {
+            // ETW/TraceLoggingDynamic provider
+            result = tld::UnregisterProvider(data.providerHandle);
+          }
+          else
+          {
+            // Other provider types, e.g. ETW/MsgPack
+            result = EventUnregister(data.providerHandle);
+          }
+
+          it->second.providerHandle = INVALID_HANDLE;
+          if (result == STATUS_OK)
+          {
+            m.erase(it);
+          }
+        }
+        return result;
+      }
+    }
+    return STATUS_ERROR;
+  }
+
+  unsigned long writeMsgPack(Handle &providerData,
+                             exporter::etw::Properties &eventData,
+                             LPCGUID ActivityId        = nullptr,
+                             LPCGUID RelatedActivityId = nullptr,
+                             uint8_t Opcode            = 0)
+  {
+#ifdef HAVE_MSGPACK
+    // Events can only be sent if provider is registered
+    if (providerData.providerHandle == INVALID_HANDLE)
+    {
+      // Provider not registered!
+      return STATUS_ERROR;
+    }
+
+    std::string eventName = "NoName";
+    auto nameField        = eventData[ETW_FIELD_NAME];
+
+#  ifdef HAVE_FIELD_TIME
+    // Event time is appended by ETW layer itself by default. This code allows
+    // to override the timestamp by millisecond timestamp, in case if it has
+    // not been already provided by the upper layer.
+    if (!eventData.count(ETW_FIELD_TIME))
+    {
+      // TODO: if nanoseconds resolution is required, then we can populate it in 96-bit MsgPack
+      // spec. auto nanos =
+      // std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch()).count();
+      eventData[ETW_FIELD_TIME] = opentelemetry::utils::getUtcSystemTimeMs();
+    }
+#  endif
+
+    switch (nameField.index())
+    {
+      case PropertyType::kTypeString:
+        eventName = (char *)(nostd::get<std::string>(nameField).data());  // must be 0-terminated!
+        break;
+      case PropertyType::kTypeCString:
+        eventName = (char *)(nostd::get<const char *>(nameField));
+        break;
+      default:
+        // If invalid event name is supplied, then we replace it with 'NoName'
+        break;
+    }
+
+    /* clang-format off */
+    nlohmann::json jObj =
+    {
+      { ETW_FIELD_NAME, eventName },
+      { ETW_FIELD_OPCODE, Opcode }
+    };
+    /* clang-format on */
+
+    std::string eventFieldName(ETW_FIELD_NAME);
+    for (auto &kv : eventData)
+    {
+      const char *name = kv.first.data();
+
+      // Don't include event name field in the Payload section
+      if (eventFieldName == name)
+        continue;
+
+      auto &value = kv.second;
+      switch (value.index())
+      {
+        case PropertyType::kTypeBool: {
+          UINT8 temp = static_cast<UINT8>(nostd::get<bool>(value));
+          jObj[name] = temp;
+          break;
+        }
+        case PropertyType::kTypeInt: {
+          auto temp  = nostd::get<int32_t>(value);
+          jObj[name] = temp;
+          break;
+        }
+        case PropertyType::kTypeInt64: {
+          auto temp  = nostd::get<int64_t>(value);
+          jObj[name] = temp;
+          break;
+        }
+        case PropertyType::kTypeUInt: {
+          auto temp  = nostd::get<uint32_t>(value);
+          jObj[name] = temp;
+          break;
+        }
+        case PropertyType::kTypeUInt64: {
+          auto temp  = nostd::get<uint64_t>(value);
+          jObj[name] = temp;
+          break;
+        }
+        case PropertyType::kTypeDouble: {
+          auto temp  = nostd::get<double>(value);
+          jObj[name] = temp;
+          break;
+        }
+        case PropertyType::kTypeString: {
+          jObj[name] = nostd::get<std::string>(value);
+          break;
+        }
+        case PropertyType::kTypeCString: {
+          auto temp  = nostd::get<const char *>(value);
+          jObj[name] = temp;
+          break;
+        }
+#  if HAVE_TYPE_GUID
+          // TODO: consider adding UUID/GUID to spec
+        case common::AttributeType::TYPE_GUID: {
+          auto temp = nostd::get<GUID>(value);
+          // TODO: add transform from GUID type to string?
+          jObj[name] = temp;
+          break;
+        }
+#  endif
+
+        // TODO: arrays are not supported yet
+        case PropertyType::kTypeSpanByte:
+        case PropertyType::kTypeSpanBool:
+        case PropertyType::kTypeSpanInt:
+        case PropertyType::kTypeSpanInt64:
+        case PropertyType::kTypeSpanUInt:
+        case PropertyType::kTypeSpanUInt64:
+        case PropertyType::kTypeSpanDouble:
+        case PropertyType::kTypeSpanString:
+        default:
+          // TODO: unsupported type
+          break;
+      }
+    }
+
+    std::vector<uint8_t> v = nlohmann::json::to_msgpack(jObj);
+
+    EVENT_DESCRIPTOR evtDescriptor;
+    // TODO: event descriptor may be populated with additional values as follows:
+    // Id       - if 0, auto-incremented sequence number that uniquely identifies event in a trace
+    // Version  - event version
+    // Channel  - 11 for TraceLogging
+    // Level    - verbosity level
+    // Task     - TaskId
+    // Opcode   - described in evntprov.h:259 : 0 - info, 1 - activity start, 2 - activity stop.
+    EventDescCreate(&evtDescriptor, 0, 0x1, 0, 0, 0, Opcode, 0);
+    EVENT_DATA_DESCRIPTOR evtData[1];
+    EventDataDescCreate(&evtData[0], v.data(), static_cast<ULONG>(v.size()));
+    ULONG writeResponse = 0;
+    if ((ActivityId != nullptr) || (RelatedActivityId != nullptr))
+    {
+      writeResponse = EventWriteTransfer(providerData.providerHandle, &evtDescriptor, ActivityId,
+                                         RelatedActivityId, 1, evtData);
+    }
+    else
+    {
+      writeResponse = EventWrite(providerData.providerHandle, &evtDescriptor, 1, evtData);
+    }
+
+    switch (writeResponse)
+    {
+      case ERROR_INVALID_PARAMETER:
+        break;
+      case ERROR_INVALID_HANDLE:
+        break;
+      case ERROR_ARITHMETIC_OVERFLOW:
+        break;
+      case ERROR_MORE_DATA:
+        break;
+      case ERROR_NOT_ENOUGH_MEMORY:
+        break;
+      default:
+        break;
+    }
+
+    if (writeResponse == ERROR_ARITHMETIC_OVERFLOW)
+    {
+      return STATUS_EFBIG;
+    }
+    return (unsigned long)(writeResponse);
+#else
+    UNREFERENCED_PARAMETER(providerData);
+    UNREFERENCED_PARAMETER(eventData);
+    UNREFERENCED_PARAMETER(ActivityId);
+    UNREFERENCED_PARAMETER(RelatedActivityId);
+    UNREFERENCED_PARAMETER(Opcode);
+    return STATUS_ERROR;
+#endif
+  }
+
+  /// <summary>
+  /// Send event to Provider Id
+  /// </summary>
+  /// <param name="providerId"></param>
+  /// <param name="eventData"></param>
+  /// <returns></returns>
+  unsigned long writeTld(Handle &providerData,
+                         Properties &eventData,
+                         LPCGUID ActivityId        = nullptr,
+                         LPCGUID RelatedActivityId = nullptr,
+                         uint8_t Opcode            = 0 /* Information */)
+  {
+    // Make sure you stop sending event before register unregistering providerData
+    if (providerData.providerHandle == INVALID_HANDLE)
+    {
+      // Provider not registered!
+      return STATUS_ERROR;
+    }
+
+    UINT32 eventTags = MICROSOFT_EVENTTAG_NORMAL_PERSISTENCE;
+
+    std::vector<BYTE> byteVector;
+    std::vector<BYTE> byteDataVector;
+    tld::EventMetadataBuilder<std::vector<BYTE>> builder(byteVector);
+    tld::EventDataBuilder<std::vector<BYTE>> dbuilder(byteDataVector);
+
+    const std::string EVENT_NAME = ETW_FIELD_NAME;
+    std::string eventName        = "NoName";
+    auto nameField               = eventData[EVENT_NAME];
+    switch (nameField.index())
+    {
+      case PropertyType::kTypeString:
+        eventName = (char *)(nostd::get<std::string>(nameField).data());
+        break;
+      case PropertyType::kTypeCString:
+        eventName = (char *)(nostd::get<const char *>(nameField));
+        break;
+      default:
+        // This is user error. Invalid event name!
+        // We supply default 'NoName' event name in this case.
+        break;
+    }
+
+    builder.Begin(eventName.c_str(), eventTags);
+
+    for (auto &kv : eventData)
+    {
+      const char *name = kv.first.data();
+      auto &value      = kv.second;
+      switch (value.index())
+      {
+        case PropertyType::kTypeBool: {
+          builder.AddField(name, tld::TypeBool8);
+          UINT8 temp = static_cast<UINT8>(nostd::get<bool>(value));
+          dbuilder.AddByte(temp);
+          break;
+        }
+        case PropertyType::kTypeInt: {
+          builder.AddField(name, tld::TypeInt32);
+          auto temp = nostd::get<int32_t>(value);
+          dbuilder.AddValue(temp);
+          break;
+        }
+        case PropertyType::kTypeInt64: {
+          builder.AddField(name, tld::TypeInt64);
+          auto temp = nostd::get<int64_t>(value);
+          dbuilder.AddValue(temp);
+          break;
+        }
+        case PropertyType::kTypeUInt: {
+          builder.AddField(name, tld::TypeUInt32);
+          auto temp = nostd::get<uint32_t>(value);
+          dbuilder.AddValue(temp);
+          break;
+        }
+        case PropertyType::kTypeUInt64: {
+          builder.AddField(name, tld::TypeUInt64);
+          auto temp = nostd::get<uint64_t>(value);
+          dbuilder.AddValue(temp);
+          break;
+        }
+        case PropertyType::kTypeDouble: {
+          builder.AddField(name, tld::TypeDouble);
+          auto temp = nostd::get<double>(value);
+          dbuilder.AddValue(temp);
+          break;
+        }
+        case PropertyType::kTypeString: {
+          builder.AddField(name, tld::TypeUtf8String);
+          dbuilder.AddString(nostd::get<std::string>(value).data());
+          break;
+        }
+        case PropertyType::kTypeCString: {
+          builder.AddField(name, tld::TypeUtf8String);
+          auto temp = nostd::get<const char *>(value);
+          dbuilder.AddString(temp);
+          break;
+        }
+#if HAVE_TYPE_GUID
+          // TODO: consider adding UUID/GUID to spec
+        case PropertyType::kGUID: {
+          builder.AddField(name.c_str(), TypeGuid);
+          auto temp = nostd::get<GUID>(value);
+          dbuilder.AddBytes(&temp, sizeof(GUID));
+          break;
+        }
+#endif
+
+        // TODO: arrays are not supported
+        case PropertyType::kTypeSpanByte:
+        case PropertyType::kTypeSpanBool:
+        case PropertyType::kTypeSpanInt:
+        case PropertyType::kTypeSpanInt64:
+        case PropertyType::kTypeSpanUInt:
+        case PropertyType::kTypeSpanUInt64:
+        case PropertyType::kTypeSpanDouble:
+        case PropertyType::kTypeSpanString:
+        default:
+          // TODO: unsupported type
+          break;
+      }
+    }
+
+    if (!builder.End())  // Returns false if the metadata is too large.
+    {
+      return STATUS_EFBIG;  // if event is too big for UTC to handle
+    }
+
+    tld::EventDescriptor eventDescriptor;
+    eventDescriptor.Opcode = Opcode;
+    eventDescriptor.Level  = 0; /* FIXME: Always on for now */
+
+    EVENT_DATA_DESCRIPTOR pDataDescriptors[3];
+    EventDataDescCreate(&pDataDescriptors[2], byteDataVector.data(),
+                        static_cast<ULONG>(byteDataVector.size()));
+
+    HRESULT writeResponse = 0;
+    if ((ActivityId != nullptr) || (RelatedActivityId != nullptr))
+    {
+      writeResponse = tld::WriteEvent(providerData.providerHandle, eventDescriptor,
+                                      providerData.providerMetaVector.data(), byteVector.data(), 3,
+                                      pDataDescriptors, ActivityId, RelatedActivityId);
+    }
+    else
+    {
+      writeResponse = tld::WriteEvent(providerData.providerHandle, eventDescriptor,
+                                      providerData.providerMetaVector.data(), byteVector.data(), 3,
+                                      pDataDescriptors);
+    }
+
+    // Event is larger than ETW max sized of 64KB
+    if (writeResponse == HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW))
+    {
+      return STATUS_EFBIG;
+    }
+
+    return (unsigned long)(writeResponse);
+  }
+
+  unsigned long write(Handle &providerData,
+                      Properties &eventData,
+                      LPCGUID ActivityId,
+                      LPCGUID RelatedActivityId,
+                      uint8_t Opcode,
+                      ETWProvider::EventFormat format)
+  {
+    if (format == ETWProvider::EventFormat::ETW_MANIFEST)
+    {
+      return writeTld(providerData, eventData, ActivityId, RelatedActivityId, Opcode);
+    }
+    if (format == ETWProvider::EventFormat::ETW_MSGPACK)
+    {
+      return writeMsgPack(providerData, eventData, ActivityId, RelatedActivityId, Opcode);
+    }
+    if (format == ETWProvider::EventFormat::ETW_XML)
+    {
+      // TODO: not implemented
+      return STATUS_ERROR;
+    }
+    return STATUS_ERROR;
+  }
+
+  static const REGHANDLE INVALID_HANDLE = _UI64_MAX;
+
+protected:
+  const unsigned int LargeEventSizeKB = 62;
+
+  const GUID NULL_GUID = {0, 0, 0, {0, 0, 0, 0, 0, 0, 0, 0}};
+
+  mutable std::mutex m_providerMapLock;
+
+  using ProviderMap = std::map<std::string, Handle>;
+
+  ProviderMap &providers()
+  {
+    static std::map<std::string, Handle> providers;
+    return providers;
+  }
+};
+
+OPENTELEMETRY_END_NAMESPACE
+
+#ifdef _MSC_VER
+#  pragma warning(pop)
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_traceloggingdynamic.h b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_traceloggingdynamic.h
new file mode 100644
index 000000000..a6243c46d
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_traceloggingdynamic.h
@@ -0,0 +1,15 @@
+#pragma once
+
+#ifdef __has_include
+#  if __has_include("TraceLoggingDynamic.h")
+#    include "TraceLoggingDynamic.h"
+#    ifndef HAVE_TLD
+#      define HAVE_TLD
+#    endif
+#  endif
+#else
+#  ifndef HAVE_TLD
+#    define HAVE_TLD
+#  endif
+#  include "TraceLoggingDynamic.h"
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_tracer.h b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_tracer.h
new file mode 100644
index 000000000..5db31a7a7
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_tracer.h
@@ -0,0 +1,995 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <algorithm>
+#include <atomic>
+
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <sstream>
+#include <vector>
+
+#include "opentelemetry/nostd/shared_ptr.h"
+#include "opentelemetry/nostd/string_view.h"
+#include "opentelemetry/nostd/unique_ptr.h"
+#include "opentelemetry/nostd/variant.h"
+
+#include "opentelemetry/common/key_value_iterable_view.h"
+
+#include "opentelemetry/trace/span.h"
+#include "opentelemetry/trace/span_context_kv_iterable_view.h"
+#include "opentelemetry/trace/span_id.h"
+#include "opentelemetry/trace/trace_id.h"
+#include "opentelemetry/trace/tracer_provider.h"
+
+#include "opentelemetry/sdk/trace/exporter.h"
+
+#include "opentelemetry/exporters/etw/etw_config.h"
+#include "opentelemetry/exporters/etw/etw_fields.h"
+#include "opentelemetry/exporters/etw/etw_properties.h"
+#include "opentelemetry/exporters/etw/etw_provider.h"
+#include "opentelemetry/exporters/etw/utils.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace etw
+{
+
+class Span;
+
+/**
+ * @brief Template that allows to instantiate new Span object for header-only forward-declared
+ * etw::Span type
+ *
+ * @tparam SpanType     Expected to be etw::Span
+ * @tparam TracerType   expected to be etw::Tracer
+ * @param objPtr        Pointer to parent
+ * @param name          Span Name
+ * @param options       Span Options
+ * @return              Span instance
+ */
+template <class SpanType, class TracerType>
+SpanType *new_span(TracerType *objPtr,
+                   nostd::string_view name,
+                   const opentelemetry::trace::StartSpanOptions &options)
+{
+  return new (std::nothrow) SpanType{*objPtr, name, options};
+}
+
+/**
+ * @brief Template that allows to convert etw::Span pointer to smart shared pointer to
+ * `opentelemetry::trace::Span`
+ * @tparam SpanType     Expected to be etw::Span
+ * @param ptr           Pointer to etw::Span
+ * @return              Smart shared pointer to `opentelemetry::trace::Span`
+ */
+template <class SpanType>
+nostd::shared_ptr<opentelemetry::trace::Span> to_span_ptr(SpanType *ptr)
+{
+  return nostd::shared_ptr<opentelemetry::trace::Span>{ptr};
+}
+
+class TracerProvider;
+
+/**
+ * @brief Utility template for obtaining Span Name
+ * @tparam T            etw::Span
+ * @param t             instance of etw::Span
+ * @return              Span Name
+ */
+template <class T>
+std::string GetName(T &t)
+{
+  auto sV = t.GetName();
+  return std::string(sV.data(), sV.length());
+}
+
+/**
+ * @brief Utility template to obtain Span start time
+ * @tparam T            etw::Span
+ * @param t             instance of etw::Span
+ * @return              Span Start timestamp
+ */
+template <class T>
+common::SystemTimestamp GetStartTime(T &t)
+{
+  return t.GetStartTime();
+}
+
+/**
+ * @brief Utility template to obtain Span end time
+ * @tparam T           etw::Span
+ * @param t            instance of etw::Span
+ * @return             Span Stop timestamp
+ */
+template <class T>
+common::SystemTimestamp GetEndTime(T &t)
+{
+  return t.GetEndTime();
+}
+
+class Properties;
+
+/**
+ * @brief Utility template to store Attributes on Span
+ * @tparam T           etw::Span
+ * @param instance     instance of etw::Span
+ * @param t            Properties to store as Attributes
+ */
+template <class T>
+void SetSpanAttributes(T &instance, Properties &t)
+{
+  instance.SetAttributes(t);
+}
+
+/**
+ * @brief Utility template to obtain Span Attributes
+ * @tparam T           etw::Span
+ * @param instance     instance of etw::Span
+ * @return             ref to Span Attributes
+ */
+template <class T>
+Properties &GetSpanAttributes(T &instance)
+{
+  return instance.GetAttributes();
+}
+
+template <class T>
+void UpdateStatus(T &t, Properties &props)
+{
+  t.UpdateStatus(props);
+}
+
+/**
+ * @brief Tracer class that allows to send spans to ETW Provider.
+ */
+class Tracer : public opentelemetry::trace::Tracer
+{
+
+  /**
+   * @brief Parent provider of this Tracer
+   */
+  etw::TracerProvider &tracerProvider_;
+
+  /**
+   * @brief ProviderId (Name or GUID)
+   */
+  std::string provId;
+
+  /**
+   * @brief Encoding (Manifest, MessagePack or XML)
+   */
+  ETWProvider::EventFormat encoding;
+
+  /**
+   * @brief Provider Handle
+   */
+  ETWProvider::Handle &provHandle;
+
+  opentelemetry::trace::TraceId traceId_;
+
+  std::atomic<bool> isClosed_{true};
+
+  /**
+   * @brief ETWProvider is a singleton that aggregates all ETW writes.
+   * @return
+   */
+  static ETWProvider &etwProvider()
+  {
+    static ETWProvider instance;  // C++11 magic static
+    return instance;
+  }
+
+  /**
+   * @brief Internal method that allows to populate Links to other Spans.
+   * Span links are in hexadecimal representation, comma-separated in their
+   * order of appearance.
+   *
+   * @param attributes
+   * @param links
+   */
+  virtual void DecorateLinks(Properties &attributes,
+                             const opentelemetry::trace::SpanContextKeyValueIterable &links) const
+  {
+    // Add `SpanLinks` attribute if the list is not empty
+    if (links.size())
+    {
+      size_t idx = 0;
+      std::string linksValue;
+      links.ForEachKeyValue(
+          [&](opentelemetry::trace::SpanContext ctx, const common::KeyValueIterable &) {
+            if (!linksValue.empty())
+            {
+              linksValue += ',';
+              linksValue += ToLowerBase16(ctx.span_id());
+            }
+            idx++;
+            return true;
+          });
+      attributes[ETW_FIELD_SPAN_LINKS] = linksValue;
+    }
+  }
+
+  /**
+   * @brief Allow our friendly etw::Span to end itself on Tracer.
+   * @param span
+   * @param
+   */
+  virtual void EndSpan(const Span &span,
+                       const opentelemetry::trace::Span *parentSpan = nullptr,
+                       const opentelemetry::trace::EndSpanOptions & = {})
+  {
+    const auto &cfg = GetConfiguration(tracerProvider_);
+    const opentelemetry::trace::Span &spanBase =
+        reinterpret_cast<const opentelemetry::trace::Span &>(span);
+    auto spanContext = spanBase.GetContext();
+
+    // Populate Span with presaved attributes
+    Span &currentSpan   = const_cast<Span &>(span);
+    Properties evt      = GetSpanAttributes(currentSpan);
+    evt[ETW_FIELD_NAME] = GetName(span);
+
+    if (cfg.enableSpanId)
+    {
+      evt[ETW_FIELD_SPAN_ID] = ToLowerBase16(spanContext.span_id());
+    }
+
+    if (cfg.enableTraceId)
+    {
+      evt[ETW_FIELD_TRACE_ID] = ToLowerBase16(spanContext.trace_id());
+    }
+
+    // Populate ActivityId if enabled
+    GUID ActivityId;
+    LPGUID ActivityIdPtr = nullptr;
+    if (cfg.enableActivityId)
+    {
+      if (CopySpanIdToActivityId(spanBase.GetContext().span_id(), ActivityId))
+      {
+        ActivityIdPtr = &ActivityId;
+      }
+    }
+
+    // Populate RelatedActivityId if enabled
+    GUID RelatedActivityId;
+    LPGUID RelatedActivityIdPtr = nullptr;
+    if (cfg.enableRelatedActivityId)
+    {
+      if (parentSpan != nullptr)
+      {
+        if (CopySpanIdToActivityId(parentSpan->GetContext().span_id(), RelatedActivityId))
+        {
+          RelatedActivityIdPtr = &RelatedActivityId;
+        }
+      }
+    }
+
+    if (cfg.enableActivityTracking)
+    {
+      // TODO: check what EndSpanOptions should be supported for this exporter.
+      // The only option available currently (end_steady_time) does not apply.
+      //
+      // This event on Span Stop enables generation of "non-transactional"
+      // OpCode=Stop in alignment with TraceLogging Activity "EventSource"
+      // spec.
+      etwProvider().write(provHandle, evt, ActivityIdPtr, RelatedActivityIdPtr, 2, encoding);
+    }
+
+    {
+      // Now since the span has ended, we need to emit the "Span" event that
+      // contains the entire span information, attributes, time, etc. on it.
+      evt[ETW_FIELD_NAME]         = ETW_VALUE_SPAN;
+      evt[ETW_FIELD_PAYLOAD_NAME] = GetName(span);
+
+      // Add timing details in ISO8601 format, which adequately represents
+      // the actual time, taking Timezone into consideration. This is NOT
+      // local time, but rather UTC time (Z=0).
+      std::chrono::system_clock::time_point startTime = GetStartTime(currentSpan);
+      std::chrono::system_clock::time_point endTime   = GetEndTime(currentSpan);
+      int64_t startTimeMs =
+          std::chrono::duration_cast<std::chrono::milliseconds>(startTime.time_since_epoch())
+              .count();
+      int64_t endTimeMs =
+          std::chrono::duration_cast<std::chrono::milliseconds>(endTime.time_since_epoch()).count();
+
+      // It may be more optimal to enable passing timestamps as UTC milliseconds
+      // since Unix epoch instead of string, but that implies additional tooling
+      // is needed to convert it, rendering it NOT human-readable.
+      evt[ETW_FIELD_STARTTIME] = utils::formatUtcTimestampMsAsISO8601(startTimeMs);
+#ifdef ETW_FIELD_ENDTTIME
+      // ETW has its own precise timestamp at envelope layer for every event.
+      // However, in some scenarios it is easier to deal with ISO8601 strings.
+      // In that case we convert the app-created timestamp and place it into
+      // Payload[$ETW_FIELD_TIME] field. The option configurable at compile-time.
+      evt[ETW_FIELD_ENDTTIME] = utils::formatUtcTimestampMsAsISO8601(endTimeMs);
+#endif
+      // Duration of Span in milliseconds
+      evt[ETW_FIELD_DURATION] = endTimeMs - startTimeMs;
+      // Presently we assume that all spans are server spans
+      evt[ETW_FIELD_SPAN_KIND] = uint32_t(opentelemetry::trace::SpanKind::kServer);
+      UpdateStatus(currentSpan, evt);
+      etwProvider().write(provHandle, evt, ActivityIdPtr, RelatedActivityIdPtr, 0, encoding);
+    }
+  }
+
+  const opentelemetry::trace::TraceId &trace_id() { return traceId_; }
+
+  friend class Span;
+
+  /**
+   * @brief Init a reference to etw::ProviderHandle
+   * @return Provider Handle
+   */
+  ETWProvider::Handle &initProvHandle()
+  {
+    isClosed_ = false;
+    return etwProvider().open(provId, encoding);
+  }
+
+public:
+  /**
+   * @brief Tracer constructor
+   * @param parent Parent TraceProvider
+   * @param providerId ProviderId - Name or GUID
+   * @param encoding ETW encoding format to use.
+   */
+  Tracer(etw::TracerProvider &parent,
+         nostd::string_view providerId     = "",
+         ETWProvider::EventFormat encoding = ETWProvider::EventFormat::ETW_MANIFEST)
+      : opentelemetry::trace::Tracer(),
+        tracerProvider_(parent),
+        provId(providerId.data(), providerId.size()),
+        encoding(encoding),
+        provHandle(initProvHandle())
+  {
+    // Generate random GUID
+    GUID trace_id;
+    CoCreateGuid(&trace_id);
+    // Populate TraceId of the Tracer with the above GUID
+    const auto *traceIdPtr = reinterpret_cast<const uint8_t *>(std::addressof(trace_id));
+    nostd::span<const uint8_t, opentelemetry::trace::TraceId::kSize> traceIdBytes(
+        traceIdPtr, traceIdPtr + opentelemetry::trace::TraceId::kSize);
+    traceId_ = opentelemetry::trace::TraceId(traceIdBytes);
+  }
+
+  /**
+   * @brief Start Span
+   * @param name Span name
+   * @param attributes Span attributes
+   * @param links Span links
+   * @param options Span options
+   * @return
+   */
+  nostd::shared_ptr<opentelemetry::trace::Span> StartSpan(
+      nostd::string_view name,
+      const common::KeyValueIterable &attributes,
+      const opentelemetry::trace::SpanContextKeyValueIterable &links,
+      const opentelemetry::trace::StartSpanOptions &options = {}) noexcept override
+  {
+#ifdef OPENTELEMETRY_RTTI_ENABLED
+    common::KeyValueIterable &attribs = const_cast<common::KeyValueIterable &>(attributes);
+    Properties *evt                   = dynamic_cast<Properties *>(&attribs);
+    if (evt != nullptr)
+    {
+      // Pass as a reference to original modifyable collection without creating a copy
+      return StartSpan(name, *evt, links, options);
+    }
+#endif
+    Properties evtCopy = attributes;
+    return StartSpan(name, evtCopy, links, options);
+  }
+
+  /**
+   * @brief Start Span
+   * @param name Span name
+   * @param attributes Span attributes
+   * @param links Span links
+   * @param options Span options
+   * @return
+   */
+  virtual nostd::shared_ptr<opentelemetry::trace::Span> StartSpan(
+      nostd::string_view name,
+      Properties &evt,
+      const opentelemetry::trace::SpanContextKeyValueIterable &links,
+      const opentelemetry::trace::StartSpanOptions &options = {}) noexcept
+  {
+    const auto &cfg = GetConfiguration(tracerProvider_);
+
+    // Parent Context:
+    // - either use current span
+    // - or attach to parent SpanContext specified in options
+    opentelemetry::trace::SpanContext parentContext = GetCurrentSpan()->GetContext();
+    if (nostd::holds_alternative<opentelemetry::trace::SpanContext>(options.parent))
+    {
+      auto span_context = nostd::get<opentelemetry::trace::SpanContext>(options.parent);
+      if (span_context.IsValid())
+      {
+        parentContext = span_context;
+      }
+    }
+
+    // Populate Etw.RelatedActivityId at envelope level if enabled
+    GUID RelatedActivityId;
+    LPCGUID RelatedActivityIdPtr = nullptr;
+    if (cfg.enableAutoParent)
+    {
+      if (cfg.enableRelatedActivityId)
+      {
+        if (CopySpanIdToActivityId(parentContext.span_id(), RelatedActivityId))
+        {
+          RelatedActivityIdPtr = &RelatedActivityId;
+        }
+      }
+    }
+
+    // This template pattern allows us to forward-declare the etw::Span,
+    // create an instance of it, then assign it to tracer::Span result.
+    auto currentSpan = new_span<Span, Tracer>(this, name, options);
+    nostd::shared_ptr<opentelemetry::trace::Span> result = to_span_ptr<Span>(currentSpan);
+
+    auto spanContext = result->GetContext();
+
+    // Decorate with additional standard fields
+    std::string eventName = name.data();
+
+    // Populate Etw.EventName attribute at envelope level
+    evt[ETW_FIELD_NAME] = eventName;
+
+    // Populate Payload["SpanId"] attribute
+    // Populate Payload["ParentSpanId"] attribute if parent Span is valid
+    if (cfg.enableSpanId)
+    {
+      if (parentContext.IsValid())
+      {
+        evt[ETW_FIELD_SPAN_PARENTID] = ToLowerBase16(parentContext.span_id());
+      }
+      evt[ETW_FIELD_SPAN_ID] = ToLowerBase16(spanContext.span_id());
+    }
+
+    // Populate Etw.Payload["TraceId"] attribute
+    if (cfg.enableTraceId)
+    {
+      evt[ETW_FIELD_TRACE_ID] = ToLowerBase16(spanContext.trace_id());
+    }
+
+    // Populate Etw.ActivityId at envelope level if enabled
+    GUID ActivityId;
+    LPCGUID ActivityIdPtr = nullptr;
+    if (cfg.enableActivityId)
+    {
+      if (CopySpanIdToActivityId(result.get()->GetContext().span_id(), ActivityId))
+      {
+        ActivityIdPtr = &ActivityId;
+      }
+    }
+
+    // Links
+    DecorateLinks(evt, links);
+
+    // Remember Span attributes to be passed down to ETW on Span end
+    SetSpanAttributes(*currentSpan, evt);
+
+    if (cfg.enableActivityTracking)
+    {
+      // TODO: add support for options that are presently ignored :
+      // - options.kind
+      // - options.start_steady_time
+      // - options.start_system_time
+      etwProvider().write(provHandle, evt, ActivityIdPtr, RelatedActivityIdPtr, 1, encoding);
+    }
+
+    return result;
+  }
+
+  /**
+   * @brief Force flush data to Tracer, spending up to given amount of microseconds to flush.
+   * NOTE: this method has no effect for the realtime streaming Tracer.
+   *
+   * @param timeout Allow Tracer to drop data if timeout is reached
+   * @return
+   */
+  void ForceFlushWithMicroseconds(uint64_t) noexcept override {}
+
+  /**
+   * @brief Close tracer, spending up to given amount of microseconds to flush and close.
+   * NOTE: This method decrements the reference count on current ETW Provider Handle and
+   * closes it if reference count on that provider handle is zero.
+   *
+   * @param  timeout Allow Tracer to drop data if timeout is reached.
+   * @return
+   */
+  void CloseWithMicroseconds(uint64_t) noexcept override
+  {
+    // Close once only
+    if (!isClosed_.exchange(true))
+    {
+      etwProvider().close(provHandle);
+    }
+  }
+
+  /**
+   * @brief Add event data to span associated with tracer.
+   * @param span Parent span.
+   * @param name Event name.
+   * @param timestamp Event timestamp.
+   * @param attributes Event attributes.
+   * @return
+   */
+  void AddEvent(opentelemetry::trace::Span &span,
+                nostd::string_view name,
+                common::SystemTimestamp timestamp,
+                const common::KeyValueIterable &attributes) noexcept
+  {
+#ifdef OPENTELEMETRY_RTTI_ENABLED
+    common::KeyValueIterable &attribs = const_cast<common::KeyValueIterable &>(attributes);
+    Properties *evt                   = dynamic_cast<Properties *>(&attribs);
+    if (evt != nullptr)
+    {
+      // Pass as a reference to original modifyable collection without creating a copy
+      return AddEvent(span, name, timestamp, *evt);
+    }
+#endif
+    // Pass a copy converted to Properties object on stack
+    Properties evtCopy = attributes;
+    return AddEvent(span, name, timestamp, evtCopy);
+  }
+
+  /**
+   * @brief Add event data to span associated with tracer.
+   * @param span Parent span.
+   * @param name Event name.
+   * @param timestamp Event timestamp.
+   * @param attributes Event attributes.
+   * @return
+   */
+  void AddEvent(opentelemetry::trace::Span &span,
+                nostd::string_view name,
+                common::SystemTimestamp timestamp,
+                Properties &evt) noexcept
+  {
+    // TODO: respect originating timestamp. Do we need to reserve
+    // a special 'Timestamp' field or is it an overkill? The delta
+    // between when `AddEvent` API is called and when ETW layer
+    // timestamp is appended is nanos- to micros-, thus handling
+    // the explicitly provided timestamp is only necessary in case
+    // if a process wants to submit back-dated or future-dated
+    // timestamp. Unless there is a strong ask from any ETW customer
+    // to have it, this feature (custom timestamp) remains unimplemented.
+    (void)timestamp;
+
+    const auto &cfg = GetConfiguration(tracerProvider_);
+
+    evt[ETW_FIELD_NAME] = name.data();
+
+    const auto &spanContext = span.GetContext();
+    if (cfg.enableSpanId)
+    {
+      evt[ETW_FIELD_SPAN_ID] = ToLowerBase16(spanContext.span_id());
+    }
+
+    if (cfg.enableTraceId)
+    {
+      evt[ETW_FIELD_TRACE_ID] = ToLowerBase16(spanContext.trace_id());
+    }
+
+    LPGUID ActivityIdPtr = nullptr;
+    GUID ActivityId;
+    if (cfg.enableActivityId)
+    {
+      if (CopySpanIdToActivityId(spanContext.span_id(), ActivityId))
+      {
+        ActivityIdPtr = &ActivityId;
+      }
+    }
+
+#ifdef HAVE_FIELD_TIME
+    {
+      auto timeNow        = std::chrono::system_clock::now().time_since_epoch();
+      auto millis         = std::chrono::duration_cast<std::chrono::milliseconds>(timeNow).count();
+      evt[ETW_FIELD_TIME] = utils::formatUtcTimestampMsAsISO8601(millis);
+    }
+#endif
+
+    etwProvider().write(provHandle, evt, ActivityIdPtr, nullptr, 0, encoding);
+  }
+
+  /**
+   * @brief Add event data to span associated with tracer.
+   * @param span Span.
+   * @param name Event name.
+   * @param timestamp Event timestamp.
+   * @return
+   */
+  void AddEvent(opentelemetry::trace::Span &span,
+                nostd::string_view name,
+                common::SystemTimestamp timestamp) noexcept
+  {
+    AddEvent(span, name, timestamp, sdk::GetEmptyAttributes());
+  }
+
+  /**
+   * @brief Add event data to span associated with tracer.
+   * @param span Spab.
+   * @param name Event name.
+   */
+  void AddEvent(opentelemetry::trace::Span &span, nostd::string_view name)
+  {
+    AddEvent(span, name, std::chrono::system_clock::now(), sdk::GetEmptyAttributes());
+  }
+
+  /**
+   * @brief Tracer destructor.
+   */
+  virtual ~Tracer() { CloseWithMicroseconds(0); }
+};
+
+/**
+ * @brief etw::Span allows to send event data to ETW listener.
+ */
+class Span : public opentelemetry::trace::Span
+{
+protected:
+  friend class Tracer;
+
+  /**
+   * @brief Span properties are attached on "Span" event on end of Span.
+   */
+  Properties attributes_;
+
+  common::SystemTimestamp start_time_;
+  common::SystemTimestamp end_time_;
+
+  opentelemetry::trace::StatusCode status_code_{opentelemetry::trace::StatusCode::kUnset};
+  std::string status_description_;
+
+  /**
+   * @brief Owner Tracer of this Span
+   */
+  Tracer &owner_;
+
+  /**
+   * @brief Span name.
+   */
+  nostd::string_view name_;
+
+  /**
+   * @brief Attribute indicating that the span has ended.
+   */
+  std::atomic<bool> has_ended_{false};
+
+  /**
+   * @brief Attribute indicating that the span has started.
+   */
+  std::atomic<bool> has_started_{false};
+
+  /**
+   * @brief Parent Span of this nested Span (optional)
+   */
+  Span *parent_{nullptr};
+
+  /**
+   * @brief Get Parent Span of this nested Span.
+   * @return Pointer to Parent or nullptr if no Parent.
+   */
+  Span *GetParent() const { return parent_; }
+
+  opentelemetry::trace::SpanContext context_;
+
+  const opentelemetry::trace::SpanContext CreateContext()
+  {
+    GUID activity_id;
+    // Generate random GUID
+    CoCreateGuid(&activity_id);
+    const auto *activityIdPtr = reinterpret_cast<const uint8_t *>(std::addressof(activity_id));
+
+    // Populate SpanId with that GUID
+    nostd::span<const uint8_t, opentelemetry::trace::SpanId::kSize> spanIdBytes(
+        activityIdPtr, activityIdPtr + opentelemetry::trace::SpanId::kSize);
+    const opentelemetry::trace::SpanId spanId(spanIdBytes);
+
+    // Inherit trace_id from Tracer
+    const opentelemetry::trace::TraceId traceId{owner_.trace_id()};
+    // TODO: TraceFlags are not supported by ETW exporter.
+    const opentelemetry::trace::TraceFlags flags{0};
+    // TODO: Remote parent is not supported by ETW exporter.
+    const bool hasRemoteParent = false;
+    return opentelemetry::trace::SpanContext{traceId, spanId, flags, hasRemoteParent};
+  }
+
+public:
+  /**
+   * @brief Update Properties object with current Span status
+   * @param evt
+   */
+  void UpdateStatus(Properties &evt)
+  {
+    /* Should we avoid populating this extra field if status is unset? */
+    if ((status_code_ == opentelemetry::trace::StatusCode::kUnset) ||
+        (status_code_ == opentelemetry::trace::StatusCode::kOk))
+    {
+      evt[ETW_FIELD_SUCCESS]       = "True";
+      evt[ETW_FIELD_STATUSCODE]    = uint32_t(status_code_);
+      evt[ETW_FIELD_STATUSMESSAGE] = status_description_;
+    }
+    else
+    {
+      evt[ETW_FIELD_SUCCESS]       = "False";
+      evt[ETW_FIELD_STATUSCODE]    = uint32_t(status_code_);
+      evt[ETW_FIELD_STATUSMESSAGE] = status_description_;
+    }
+  }
+
+  /**
+   * @brief Get start time of this Span.
+   * @return
+   */
+  common::SystemTimestamp GetStartTime() { return start_time_; }
+
+  /**
+   * @brief Get end time of this Span.
+   * @return
+   */
+  common::SystemTimestamp GetEndTime() { return end_time_; }
+
+  /**
+   * @brief Get Span Name.
+   * @return Span Name.
+   */
+  nostd::string_view GetName() const { return name_; }
+
+  /**
+   * @brief Span constructor
+   * @param owner Owner Tracer
+   * @param name Span name
+   * @param options Span options
+   * @param parent Parent Span (optional)
+   * @return
+   */
+  Span(Tracer &owner,
+       nostd::string_view name,
+       const opentelemetry::trace::StartSpanOptions &options,
+       Span *parent = nullptr) noexcept
+      : opentelemetry::trace::Span(),
+        start_time_(std::chrono::system_clock::now()),
+        owner_(owner),
+        parent_(parent),
+        context_(CreateContext())
+  {
+    name_ = name;
+    UNREFERENCED_PARAMETER(options);
+  }
+
+  /**
+   * @brief Span Destructor
+   */
+  ~Span() { End(); }
+
+  /**
+   * @brief Add named event with no attributes.
+   * @param name Event name.
+   * @return
+   */
+  void AddEvent(nostd::string_view name) noexcept override { owner_.AddEvent(*this, name); }
+
+  /**
+   * @brief Add named event with custom timestamp.
+   * @param name
+   * @param timestamp
+   * @return
+   */
+  void AddEvent(nostd::string_view name, common::SystemTimestamp timestamp) noexcept override
+  {
+    owner_.AddEvent(*this, name, timestamp);
+  }
+
+  /**
+   * @brief Add named event with custom timestamp and attributes.
+   * @param name Event name.
+   * @param timestamp Event timestamp.
+   * @param attributes Event attributes.
+   * @return
+   */
+  void AddEvent(nostd::string_view name,
+                common::SystemTimestamp timestamp,
+                const common::KeyValueIterable &attributes) noexcept override
+  {
+    owner_.AddEvent(*this, name, timestamp, attributes);
+  }
+
+  /**
+   * @brief Set Span status
+   * @param code Span status code.
+   * @param description Span description.
+   * @return
+   */
+  void SetStatus(opentelemetry::trace::StatusCode code,
+                 nostd::string_view description) noexcept override
+  {
+    status_code_        = code;
+    status_description_ = description.data();
+  }
+
+  void SetAttributes(Properties attributes) { attributes_ = attributes; }
+
+  /**
+   * @brief Obtain span attributes specified at Span start.
+   * NOTE: please consider that this method is NOT thread-safe.
+   *
+   * @return ref to Properties collection
+   */
+  Properties &GetAttributes() { return attributes_; }
+
+  /**
+   * @brief Sets an attribute on the Span. If the Span previously contained a mapping
+   * for the key, the old value is replaced.
+   *
+   * @param key
+   * @param value
+   * @return
+   */
+  void SetAttribute(nostd::string_view key, const common::AttributeValue &value) noexcept override
+  {
+    // don't override fields propagated from span data.
+    if (key == ETW_FIELD_NAME || key == ETW_FIELD_SPAN_ID || key == ETW_FIELD_TRACE_ID)
+    {
+      return;
+    }
+    attributes_[std::string{key}].FromAttributeValue(value);
+  }
+
+  /**
+   * @brief Update Span name.
+   *
+   * NOTE: this method is a no-op for streaming implementation.
+   * We cannot change the Span name after it started streaming.
+   *
+   * @param name
+   * @return
+   */
+  void UpdateName(nostd::string_view) noexcept override
+  {
+    // We can't do that!
+    // name_ = name;
+  }
+
+  /**
+   * @brief End Span.
+   * @param EndSpanOptions
+   * @return
+   */
+  void End(const opentelemetry::trace::EndSpanOptions &options = {}) noexcept override
+  {
+    end_time_ = std::chrono::system_clock::now();
+
+    if (!has_ended_.exchange(true))
+    {
+      owner_.EndSpan(*this, parent_, options);
+    }
+  }
+
+  /**
+   * @brief Obtain SpanContext
+   * @return
+   */
+  opentelemetry::trace::SpanContext GetContext() const noexcept override { return context_; }
+
+  /**
+   * @brief Check if Span is recording data.
+   * @return
+   */
+  bool IsRecording() const noexcept override
+  {
+    // For streaming implementation this should return the state of ETW Listener.
+    // In certain unprivileged environments, ex. containers, it is impossible
+    // to determine if a listener is registered. Thus, we always return true.
+    return true;
+  }
+
+  virtual void SetToken(nostd::unique_ptr<context::Token> &&token) noexcept
+  {
+    // TODO: not implemented
+    UNREFERENCED_PARAMETER(token);
+  }
+
+  /// <summary>
+  /// Get Owner tracer of this Span
+  /// </summary>
+  /// <returns></returns>
+  opentelemetry::trace::Tracer &tracer() const noexcept { return this->owner_; }
+};
+
+/**
+ * @brief ETW TracerProvider
+ */
+class TracerProvider : public opentelemetry::trace::TracerProvider
+{
+public:
+  /**
+   * @brief TracerProvider options supplied during initialization.
+   */
+  TelemetryProviderConfiguration config_;
+
+  /**
+   * @brief Construct instance of TracerProvider with given options
+   * @param options Configuration options
+   */
+  TracerProvider(TelemetryProviderOptions options) : opentelemetry::trace::TracerProvider()
+  {
+    // By default we ensure that all events carry their with TraceId and SpanId
+    GetOption(options, "enableTraceId", config_.enableTraceId, true);
+    GetOption(options, "enableSpanId", config_.enableSpanId, true);
+
+    // Backwards-compatibility option that allows to reuse ETW-specific parenting described here:
+    // https://docs.microsoft.com/en-us/uwp/api/windows.foundation.diagnostics.loggingoptions.relatedactivityid
+    // https://docs.microsoft.com/en-us/windows/win32/api/evntprov/nf-evntprov-eventwritetransfer
+
+    // Emit separate events compatible with TraceLogging Activity/Start and Activity/Stop
+    // format for every Span emitted.
+    GetOption(options, "enableActivityTracking", config_.enableActivityTracking, false);
+
+    // Map current `SpanId` to ActivityId - GUID that uniquely identifies this activity. If NULL,
+    // ETW gets the identifier from the thread local storage. For details on getting this
+    // identifier, see EventActivityIdControl.
+    GetOption(options, "enableActivityId", config_.enableActivityId, false);
+
+    // Map parent `SpanId` to RelatedActivityId -  Activity identifier from the previous
+    // component. Use this parameter to link your component's events to the previous component's
+    // events.
+    GetOption(options, "enableRelatedActivityId", config_.enableRelatedActivityId, false);
+
+    // When a new Span is started, the current span automatically becomes its parent.
+    GetOption(options, "enableAutoParent", config_.enableAutoParent, false);
+
+    // Determines what encoding to use for ETW events: TraceLogging Dynamic, MsgPack, XML, etc.
+    config_.encoding = GetEncoding(options);
+  }
+
+  TracerProvider() : opentelemetry::trace::TracerProvider()
+  {
+    config_.enableTraceId           = true;
+    config_.enableSpanId            = true;
+    config_.enableActivityId        = false;
+    config_.enableActivityTracking  = false;
+    config_.enableRelatedActivityId = false;
+    config_.enableAutoParent        = false;
+    config_.encoding                = ETWProvider::EventFormat::ETW_MANIFEST;
+  }
+
+  /**
+   * @brief Obtain ETW Tracer.
+   * @param name ProviderId (instrumentation name) - Name or GUID
+   *
+   * @param args Additional arguments that controls `codec` of the provider.
+   * Possible values are:
+   * - "ETW"            - 'classic' Trace Logging Dynamic manifest ETW events.
+   * - "MSGPACK"        - MessagePack-encoded binary payload ETW events.
+   * - "XML"            - XML events (reserved for future use)
+   * @return
+   */
+  nostd::shared_ptr<opentelemetry::trace::Tracer> GetTracer(
+      nostd::string_view name,
+      nostd::string_view args       = "",
+      nostd::string_view schema_url = "") noexcept override
+  {
+    UNREFERENCED_PARAMETER(args);
+    UNREFERENCED_PARAMETER(schema_url);
+    ETWProvider::EventFormat evtFmt = config_.encoding;
+    return nostd::shared_ptr<opentelemetry::trace::Tracer>{new (std::nothrow)
+                                                               Tracer(*this, name, evtFmt)};
+  }
+};
+
+}  // namespace etw
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_tracer_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_tracer_exporter.h
new file mode 100644
index 000000000..b28f1a021
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/etw_tracer_exporter.h
@@ -0,0 +1,28 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+
+#include <mutex>
+
+#include "opentelemetry/nostd/shared_ptr.h"
+#include "opentelemetry/nostd/string_view.h"
+#include "opentelemetry/nostd/unique_ptr.h"
+
+#include "opentelemetry/common/key_value_iterable_view.h"
+#include "opentelemetry/trace/span.h"
+#include "opentelemetry/trace/span_context_kv_iterable_view.h"
+#include "opentelemetry/trace/span_id.h"
+#include "opentelemetry/trace/trace_id.h"
+#include "opentelemetry/trace/tracer_provider.h"
+
+#include "opentelemetry/sdk/trace/exporter.h"
+
+#include "opentelemetry/exporters/etw/etw_config.h"
+#include "opentelemetry/exporters/etw/etw_provider.h"
+#include "opentelemetry/exporters/etw/etw_tracer.h"
+
+#include "opentelemetry/exporters/etw/utils.h"
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/utils.h b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/utils.h
new file mode 100644
index 000000000..4d38c1fb6
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/utils.h
@@ -0,0 +1,274 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <algorithm>
+#include <chrono>
+#include <ctime>
+#include <iomanip>
+#include <locale>
+#include <sstream>
+#include <string>
+
+#include "opentelemetry/common/macros.h"
+#include "opentelemetry/exporters/etw/uuid.h"
+#include "opentelemetry/version.h"
+
+#ifdef _WIN32
+#  include <Windows.h>
+#  include <evntprov.h>
+#  include <wincrypt.h>
+#  pragma comment(lib, "Advapi32.lib")
+#  pragma comment(lib, "Rpcrt4.lib")
+#  include <Objbase.h>
+#  pragma comment(lib, "Ole32.Lib")
+#else
+#  include <codecvt>
+#endif
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+
+namespace utils
+{
+
+/// <summary>
+/// Compile-time constexpr djb2 hash function for strings
+/// </summary>
+static constexpr uint32_t hashCode(const char *str, uint32_t h = 0)
+{
+  return (uint32_t)(!str[h] ? 5381 : ((uint32_t)hashCode(str, h + 1) * (uint32_t)33) ^ str[h]);
+}
+
+#define CONST_UINT32_T(x) std::integral_constant<uint32_t, (uint32_t)x>::value
+
+#define CONST_HASHCODE(name) CONST_UINT32_T(OPENTELEMETRY_NAMESPACE::utils::hashCode(#name))
+
+#ifdef _WIN32
+
+/// <summary>
+/// Compute SHA-1 hash of input buffer and save to output
+/// </summary>
+/// <param name="pData">Input buffer</param>
+/// <param name="nData">Input buffer size</param>
+/// <param name="pHashedData">Output buffer</param>
+/// <param name="nHashedData">Output buffer size</param>
+/// <returns></returns>
+static inline bool sha1(const BYTE *pData, DWORD nData, BYTE *pHashedData, DWORD &nHashedData)
+{
+  bool bRet        = false;
+  HCRYPTPROV hProv = NULL;
+  HCRYPTHASH hHash = NULL;
+
+  if (!CryptAcquireContext(&hProv,                // handle of the CSP
+                           NULL,                  // key container name
+                           NULL,                  // CSP name
+                           PROV_RSA_FULL,         // provider type
+                           CRYPT_VERIFYCONTEXT))  // no key access is requested
+  {
+    bRet = false;
+    goto CleanUp;
+  }
+
+  if (!CryptCreateHash(hProv,      // handle of the CSP
+                       CALG_SHA1,  // hash algorithm to use
+                       0,          // hash key
+                       0,          // reserved
+                       &hHash))    //
+  {
+    bRet = false;
+    goto CleanUp;
+  }
+
+  if (!CryptHashData(hHash,  // handle of the HMAC hash object
+                     pData,  // message to hash
+                     nData,  // number of bytes of data to add
+                     0))     // flags
+  {
+    bRet = false;
+    goto CleanUp;
+  }
+
+  if (!CryptGetHashParam(hHash,         // handle of the HMAC hash object
+                         HP_HASHVAL,    // query on the hash value
+                         pHashedData,   // filled on second call
+                         &nHashedData,  // length, in bytes,of the hash
+                         0))
+  {
+    bRet = false;
+    goto CleanUp;
+  }
+
+  bRet = true;
+
+CleanUp:
+
+  if (hHash)
+  {
+    CryptDestroyHash(hHash);
+  }
+
+  if (hProv)
+  {
+    CryptReleaseContext(hProv, 0);
+  }
+  return bRet;
+}
+
+/// <summary>
+/// Convert UTF-8 string to UTF-16 wide string.
+///
+/// </summary>
+/// <param name="in"></param>
+/// <returns></returns>
+static inline std::wstring to_utf16_string(const std::string &in)
+{
+#  ifdef _WIN32
+  int in_length  = static_cast<int>(in.size());
+  int out_length = MultiByteToWideChar(CP_UTF8, 0, &in[0], in_length, NULL, 0);
+  std::wstring result(out_length, '\0');
+  MultiByteToWideChar(CP_UTF8, 0, &in[0], in_length, &result[0], out_length);
+  return result;
+#  else
+  std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>, wchar_t> converter;
+  return converter.from_bytes(in);
+#  endif
+}
+
+/// <summary>
+/// Transform ETW provider name to provider GUID as described here:
+/// https://blogs.msdn.microsoft.com/dcook/2015/09/08/etw-provider-names-and-guids/
+/// </summary>
+/// <param name="providerName"></param>
+/// <returns></returns>
+static inline GUID GetProviderGuid(const char *providerName)
+{
+  std::string name(providerName);
+  std::transform(name.begin(), name.end(), name.begin(),
+                 [](unsigned char c) { return (char)::toupper(c); });
+
+  size_t len      = name.length() * 2 + 0x10;
+  uint8_t *buffer = new uint8_t[len];
+  uint32_t num    = 0x482c2db2;
+  uint32_t num2   = 0xc39047c8;
+  uint32_t num3   = 0x87f81a15;
+  uint32_t num4   = 0xbfc130fb;
+
+  for (int i = 3; i >= 0; i--)
+  {
+    buffer[i]      = (uint8_t)num;
+    num            = num >> 8;
+    buffer[i + 4]  = (uint8_t)num2;
+    num2           = num2 >> 8;
+    buffer[i + 8]  = (uint8_t)num3;
+    num3           = num3 >> 8;
+    buffer[i + 12] = (uint8_t)num4;
+    num4           = num4 >> 8;
+  }
+
+  for (size_t j = 0; j < name.length(); j++)
+  {
+    buffer[((2 * j) + 0x10) + 1] = (uint8_t)name[j];
+    buffer[(2 * j) + 0x10]       = (uint8_t)(name[j] >> 8);
+  }
+
+  const size_t sha1_hash_size = 21;
+  uint8_t *buffer2            = new uint8_t[sha1_hash_size];
+  DWORD len2                  = sha1_hash_size;
+  sha1((const BYTE *)buffer, (DWORD)len, (BYTE *)buffer2, len2);
+
+  unsigned long a     = (((((buffer2[3] << 8) + buffer2[2]) << 8) + buffer2[1]) << 8) + buffer2[0];
+  unsigned short b    = (unsigned short)((buffer2[5] << 8) + buffer2[4]);
+  unsigned short num9 = (unsigned short)((buffer2[7] << 8) + buffer2[6]);
+
+  GUID guid;
+  guid.Data1    = a;
+  guid.Data2    = b;
+  guid.Data3    = (unsigned short)((num9 & 0xfff) | 0x5000);
+  guid.Data4[0] = buffer2[8];
+  guid.Data4[1] = buffer2[9];
+  guid.Data4[2] = buffer2[10];
+  guid.Data4[3] = buffer2[11];
+  guid.Data4[4] = buffer2[12];
+  guid.Data4[5] = buffer2[13];
+  guid.Data4[6] = buffer2[14];
+  guid.Data4[7] = buffer2[15];
+
+  delete[] buffer;
+  delete[] buffer2;
+
+  return guid;
+}
+#endif
+
+static inline int64_t getUtcSystemTimeMs()
+{
+#ifdef _WIN32
+  ULARGE_INTEGER now;
+  ::GetSystemTimeAsFileTime(reinterpret_cast<FILETIME *>(&now));
+  return (now.QuadPart - 116444736000000000ull) / 10000;
+#else
+  return std::chrono::system_clock::now().time_since_epoch() / std::chrono::milliseconds(1);
+#endif
+}
+
+static inline int64_t getUtcSystemTimeinTicks()
+{
+#ifdef _WIN32
+  FILETIME tocks;
+  ::GetSystemTimeAsFileTime(&tocks);
+  ULONGLONG ticks = (ULONGLONG(tocks.dwHighDateTime) << 32) | tocks.dwLowDateTime;
+  // number of days from beginning to 1601 multiplied by ticks per day
+  return ticks + 0x701ce1722770000ULL;
+#else
+  // On Un*x systems system_clock de-facto contains UTC time. Ref:
+  // https://en.cppreference.com/w/cpp/chrono/system_clock
+  // This UTC epoch contract has been signed in blood since C++20
+  std::chrono::time_point<std::chrono::system_clock> now = std::chrono::system_clock::now();
+  auto duration                                          = now.time_since_epoch();
+  auto millis    = std::chrono::duration_cast<std::chrono::milliseconds>(duration).count();
+  uint64_t ticks = millis;
+  ticks *= 10000;                 // convert millis to ticks (1 tick = 100ns)
+  ticks += 0x89F7FF5F7B58000ULL;  // UTC time 0 in .NET ticks
+  return ticks;
+#endif
+}
+
+/**
+ * @brief Convert local system milliseconds time to ISO8601 string UTC time
+ *
+ * @param timestampMs   Milliseconds since epoch in system time
+ *
+ * @return ISO8601 UTC string with microseconds part set to 000
+ */
+static inline std::string formatUtcTimestampMsAsISO8601(int64_t timestampMs)
+{
+  char buf[sizeof("YYYY-MM-DDTHH:MM:SS.ssssssZ") + 1] = {0};
+#ifdef _WIN32
+  __time64_t seconds = static_cast<__time64_t>(timestampMs / 1000);
+  int milliseconds   = static_cast<int>(timestampMs % 1000);
+  tm tm;
+  if (::_gmtime64_s(&tm, &seconds) != 0)
+  {
+    memset(&tm, 0, sizeof(tm));
+  }
+  ::_snprintf_s(buf, _TRUNCATE, "%04d-%02d-%02dT%02d:%02d:%02d.%06dZ", 1900 + tm.tm_year,
+                1 + tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, 1000 * milliseconds);
+#else
+  time_t seconds   = static_cast<time_t>(timestampMs / 1000);
+  int milliseconds = static_cast<int>(timestampMs % 1000);
+  tm tm;
+  bool valid = (gmtime_r(&seconds, &tm) != NULL);
+  if (!valid)
+  {
+    memset(&tm, 0, sizeof(tm));
+  }
+  (void)snprintf(buf, sizeof(buf), "%04d-%02d-%02dT%02d:%02d:%02d.%06dZ", 1900 + tm.tm_year,
+                 1 + tm.tm_mon, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec, 1000 * milliseconds);
+#endif
+  return buf;
+}
+
+};  // namespace utils
+
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/uuid.h b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/uuid.h
new file mode 100644
index 000000000..a004aec9e
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/include/opentelemetry/exporters/etw/uuid.h
@@ -0,0 +1,412 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/version.h"
+
+#include <cstddef>
+#include <cstring>
+#include <functional>
+#include <initializer_list>
+#include <string>
+#include <vector>
+
+#ifdef _WIN32
+#  include "Windows.h"
+#endif
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+
+namespace utils
+{
+
+/// <summary>
+/// The UUID structure represents the portable cross-platform implementation of a GUID (Globally
+/// Unique ID).
+/// </summary>
+/// <remarks>
+/// UUIDs identify objects such as interfaces, manager entry-point vectors (EPVs), and class
+/// objects. A UUID is a 128-bit value consisting of one group of eight hexadecimal digits, followed
+/// by three groups of four hexadecimal digits, each followed by one group of 12 hexadecimal digits.
+/// </remarks>
+#pragma pack(push) /* push current alignment to stack */
+#pragma pack(1)    /* set alignment to 1 byte boundary */
+struct UUID
+{
+  /// <summary>
+  /// Specifies the first eight hexadecimal digits of the GUID.
+  /// </summary>
+  uint32_t Data1;
+
+  /// <summary>
+  /// Specifies the first group of four hexadecimal digits.
+  ///</summary>
+  uint16_t Data2;
+
+  /// <summary>
+  /// Specifies the second group of four hexadecimal digits.
+  /// </summary>
+  uint16_t Data3;
+
+  /// <summary>
+  /// An array of eight bytes.
+  /// The first two bytes contain the third group of four hexadecimal digits.
+  /// The remaining six bytes contain the final 12 hexadecimal digits.
+  /// </summary>
+  uint8_t Data4[8];
+
+  /// <summary>
+  /// The default UUID constructor.
+  /// Creates a null instance of the UUID object (initialized to all zeros).
+  /// {00000000-0000-0000-0000-000000000000}.
+  /// </summary>
+  UUID() : Data1(0), Data2(0), Data3(0)
+  {
+    for (size_t i = 0; i < 8; i++)
+    {
+      Data4[i] = 0;
+    }
+  }
+
+  /// <summary>
+  /// A constructor that creates a UUID object from a hyphenated string as defined by
+  /// https://tools.ietf.org/html/rfc4122#page-4
+  /// </summary>
+  /// <param name="uuid_string">A hyphenated string that contains the UUID (curly braces
+  /// optional).</param>
+  UUID(const char *uuid_string)
+  {
+    const char *str = uuid_string;
+    // Skip curly brace
+    if (str[0] == '{')
+    {
+      str++;
+    }
+    // Convert to set of integer values
+    unsigned long p0;
+    unsigned int p1, p2, p3, p4, p5, p6, p7, p8, p9, p10;
+    if (
+        // Parse input with dashes
+        (11 == sscanf_s(str, "%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X", &p0, &p1, &p2,
+                        &p3, &p4, &p5, &p6, &p7, &p8, &p9, &p10)) ||
+        // Parse input without dashes
+        (11 == sscanf_s(str, "%08lX%04X%04X%02X%02X%02X%02X%02X%02X%02X%02X", &p0, &p1, &p2, &p3,
+                        &p4, &p5, &p6, &p7, &p8, &p9, &p10)))
+    {
+      Data1    = static_cast<uint32_t>(p0);
+      Data2    = static_cast<uint16_t>(p1);
+      Data3    = static_cast<uint16_t>(p2);
+      Data4[0] = static_cast<uint8_t>(p3);
+      Data4[1] = static_cast<uint8_t>(p4);
+      Data4[2] = static_cast<uint8_t>(p5);
+      Data4[3] = static_cast<uint8_t>(p6);
+      Data4[4] = static_cast<uint8_t>(p7);
+      Data4[5] = static_cast<uint8_t>(p8);
+      Data4[6] = static_cast<uint8_t>(p9);
+      Data4[7] = static_cast<uint8_t>(p10);
+    }
+    else  // Invalid input--use a safe default value
+    {
+      Data1    = 0;
+      Data2    = 0;
+      Data3    = 0;
+      Data4[0] = 0;
+      Data4[1] = 0;
+      Data4[2] = 0;
+      Data4[3] = 0;
+      Data4[4] = 0;
+      Data4[5] = 0;
+      Data4[6] = 0;
+      Data4[7] = 0;
+    }
+  }
+
+  /// <summary>
+  /// A constructor that creates a UUID object from a byte array.
+  /// </summary>
+  /// <param name="guid_bytes">A byte array.</param>
+  /// <param name="bigEndian">
+  /// A boolean value that specifies the byte order.<br>
+  /// A value of <i>true</i> specifies the more natural human-readable order.<br>
+  /// A value of <i>false</i> (the default) specifies the same order as the .NET GUID constructor.
+  /// </param>
+  UUID(const uint8_t guid_bytes[16], bool bigEndian = false)
+  {
+    if (bigEndian)
+    {
+      /* Use big endian - human-readable */
+      // Part 1
+      Data1 = guid_bytes[3];
+      Data1 |= ((uint32_t)(guid_bytes[2])) << 8;
+      Data1 |= ((uint32_t)(guid_bytes[1])) << 16;
+      Data1 |= ((uint32_t)(guid_bytes[0])) << 24;
+      // Part 2
+      Data2 = guid_bytes[5];
+      Data2 |= ((uint16_t)(guid_bytes[4])) << 8;
+      // Part 3
+      Data3 = guid_bytes[7];
+      Data3 |= ((uint16_t)(guid_bytes[6])) << 8;
+    }
+    else
+    {
+      /* Use little endian - the same order as .NET C# Guid() class uses */
+      // Part 1
+      Data1 = guid_bytes[0];
+      Data1 |= ((uint32_t)(guid_bytes[1])) << 8;
+      Data1 |= ((uint32_t)(guid_bytes[2])) << 16;
+      Data1 |= ((uint32_t)(guid_bytes[3])) << 24;
+      // Part 2
+      Data2 = guid_bytes[4];
+      Data2 |= ((uint16_t)(guid_bytes[5])) << 8;
+      // Part 3
+      Data3 = guid_bytes[6];
+      Data3 |= ((uint16_t)(guid_bytes[7])) << 8;
+    }
+    // Part 4
+    for (size_t i = 0; i < 8; i++)
+    {
+      Data4[i] = guid_bytes[8 + i];
+    }
+  }
+
+  /// <summary>
+  /// A constructor that creates a UUID object from three integers and a byte array.
+  /// </summary>
+  /// <param name="d1">An integer that specifies the first eight hexadecimal digits of the
+  /// UUID.</param> <param name="d2">An integer that specifies the first group of four hexadecimal
+  /// digits.</param> <param name="d3">An integer that specifies the second group of four
+  /// hexadecimal digits.</param> <param name="v">A reference to an array of eight bytes. The first
+  /// two bytes contain the third group of four hexadecimal digits. The remaining six bytes contain
+  /// the final 12 hexadecimal digits.</param>
+  UUID(int d1, int d2, int d3, const std::initializer_list<uint8_t> &v)
+      : Data1((uint32_t)d1), Data2((uint16_t)d2), Data3((uint16_t)d3)
+  {
+    size_t i = 0;
+    for (auto val : v)
+    {
+      Data4[i] = val;
+      i++;
+    }
+  }
+
+  /// <summary>
+  /// The UUID copy constructor.
+  /// </summary>
+  /// <param name="uuid">A UUID object.</param>
+  UUID(const UUID &uuid)
+  {
+    this->Data1 = uuid.Data1;
+    this->Data2 = uuid.Data2;
+    this->Data3 = uuid.Data3;
+    memcpy(&(this->Data4[0]), &(uuid.Data4[0]), sizeof(uuid.Data4));
+  }
+
+#ifdef _WIN32
+
+  /// <summary>
+  /// A constructor that creates a UUID object from a Windows GUID object.
+  /// </summary>
+  /// <param name="guid">A Windows GUID object.</param>
+  UUID(GUID guid)
+  {
+    this->Data1 = guid.Data1;
+    this->Data2 = guid.Data2;
+    this->Data3 = guid.Data3;
+    std::memcpy(&(this->Data4[0]), &(guid.Data4[0]), sizeof(guid.Data4));
+  }
+
+  /// <summary>
+  /// Converts a standard vector of bytes into a Windows GUID object.
+  /// </summary>
+  /// <param name="bytes">A standard vector of bytes.</param>
+  /// <returns>A GUID.</returns>
+  static GUID to_GUID(std::vector<uint8_t> const &bytes)
+  {
+    UUID temp_t = UUID(bytes.data());
+    GUID temp;
+    temp.Data1 = temp_t.Data1;
+    temp.Data2 = temp_t.Data2;
+    temp.Data3 = temp_t.Data3;
+    for (size_t i = 0; i < 8; i++)
+    {
+      temp.Data4[i] = temp_t.Data4[i];
+    }
+    return temp;
+  }
+
+  GUID to_GUID()
+  {
+    GUID temp;
+    temp.Data1 = Data1;
+    temp.Data2 = Data2;
+    temp.Data3 = Data3;
+    for (size_t i = 0; i < 8; i++)
+    {
+      temp.Data4[i] = Data4[i];
+    }
+    return temp;
+  }
+
+#endif
+
+  /// <summary>
+  /// Converts this UUID to an array of bytes.
+  /// </summary>
+  /// <param name="guid_bytes">A uint8_t array of 16 bytes.</param>
+  void to_bytes(uint8_t (&guid_bytes)[16]) const
+  {
+    // Part 1
+    guid_bytes[0] = (uint8_t)((Data1)&0xFF);
+    guid_bytes[1] = (uint8_t)((Data1 >> 8) & 0xFF);
+    guid_bytes[2] = (uint8_t)((Data1 >> 16) & 0xFF);
+    guid_bytes[3] = (uint8_t)((Data1 >> 24) & 0xFF);
+    // Part 2
+    guid_bytes[4] = (uint8_t)((Data2)&0xFF);
+    guid_bytes[5] = (uint8_t)((Data2 >> 8) & 0xFF);
+    // Part 3
+    guid_bytes[6] = (uint8_t)((Data3)&0xFF);
+    guid_bytes[7] = (uint8_t)((Data3 >> 8) & 0xFF);
+    // Part 4
+    for (size_t i = 0; i < 8; i++)
+    {
+      guid_bytes[8 + i] = Data4[i];
+    }
+  }
+
+  /// <summary>
+  /// Convert this UUID object to a string.
+  /// </summary>
+  /// <returns>This UUID object in a string.</returns>
+  std::string to_string() const
+  {
+    static char inttoHex[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
+                                '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
+
+    const unsigned buffSize = 36 + 1;  // 36 + null-terminator
+    char buf[buffSize]      = {0};
+
+    int test = (Data1 >> 28 & 0x0000000F);
+    buf[0]   = inttoHex[test];
+    test     = (int)(Data1 >> 24 & 0x0000000F);
+    buf[1]   = inttoHex[test];
+    test     = (int)(Data1 >> 20 & 0x0000000F);
+    buf[2]   = inttoHex[test];
+    test     = (int)(Data1 >> 16 & 0x0000000F);
+    buf[3]   = inttoHex[test];
+    test     = (int)(Data1 >> 12 & 0x0000000F);
+    buf[4]   = inttoHex[test];
+    test     = (int)(Data1 >> 8 & 0x0000000F);
+    buf[5]   = inttoHex[test];
+    test     = (int)(Data1 >> 4 & 0x0000000F);
+    buf[6]   = inttoHex[test];
+    test     = (int)(Data1 & 0x0000000F);
+    buf[7]   = inttoHex[test];
+    buf[8]   = '-';
+    test     = (int)(Data2 >> 12 & 0x000F);
+    buf[9]   = inttoHex[test];
+    test     = (int)(Data2 >> 8 & 0x000F);
+    buf[10]  = inttoHex[test];
+    test     = (int)(Data2 >> 4 & 0x000F);
+    buf[11]  = inttoHex[test];
+    test     = (int)(Data2 & 0x000F);
+    buf[12]  = inttoHex[test];
+    buf[13]  = '-';
+    test     = (int)(Data3 >> 12 & 0x000F);
+    buf[14]  = inttoHex[test];
+    test     = (int)(Data3 >> 8 & 0x000F);
+    buf[15]  = inttoHex[test];
+    test     = (int)(Data3 >> 4 & 0x000F);
+    buf[16]  = inttoHex[test];
+    test     = (int)(Data3 & 0x000F);
+    buf[17]  = inttoHex[test];
+    buf[18]  = '-';
+    test     = (int)(Data4[0] >> 4 & 0x0F);
+    buf[19]  = inttoHex[test];
+    test     = (int)(Data4[0] & 0x0F);
+    buf[20]  = inttoHex[test];
+    test     = (int)(Data4[1] >> 4 & 0x0F);
+    buf[21]  = inttoHex[test];
+    test     = (int)(Data4[1] & 0x0F);
+    buf[22]  = inttoHex[test];
+    buf[23]  = '-';
+    test     = (int)(Data4[2] >> 4 & 0x0F);
+    buf[24]  = inttoHex[test];
+    test     = (int)(Data4[2] & 0x0F);
+    buf[25]  = inttoHex[test];
+    test     = (int)(Data4[3] >> 4 & 0x0F);
+    buf[26]  = inttoHex[test];
+    test     = (int)(Data4[3] & 0x0F);
+    buf[27]  = inttoHex[test];
+    test     = (int)(Data4[4] >> 4 & 0x0F);
+    buf[28]  = inttoHex[test];
+    test     = (int)(Data4[4] & 0x0F);
+    buf[29]  = inttoHex[test];
+    test     = (int)(Data4[5] >> 4 & 0x0F);
+    buf[30]  = inttoHex[test];
+    test     = (int)(Data4[5] & 0x0F);
+    buf[31]  = inttoHex[test];
+    test     = (int)(Data4[6] >> 4 & 0x0F);
+    buf[32]  = inttoHex[test];
+    test     = (int)(Data4[6] & 0x0F);
+    buf[33]  = inttoHex[test];
+    test     = (int)(Data4[7] >> 4 & 0x0F);
+    buf[34]  = inttoHex[test];
+    test     = (int)(Data4[7] & 0x0F);
+    buf[35]  = inttoHex[test];
+    buf[36]  = 0;
+
+    return std::string(buf);
+  }
+
+  /// <summary>
+  /// Calculates the size of this UUID object.
+  /// The output from this method is compatible with std::unordered_map.
+  /// </summary>
+  /// <returns>The size of the UUID object in bytes.</returns>
+  size_t Hash() const
+  {
+    // Compute individual hash values for Data1, Data2, Data3, and parts of Data4
+    size_t res = 17;
+    res        = res * 31 + Data1;
+    res        = res * 31 + Data2;
+    res        = res * 31 + Data3;
+    res        = res * 31 + (Data4[0] << 24 | Data4[1] << 16 | Data4[6] << 8 | Data4[7]);
+    return res;
+  }
+
+  /// <summary>
+  /// Tests to determine whether two UUID objects are equivalent (needed for maps).
+  /// </summary>
+  /// <returns>A boolean value that indicates success or failure.</returns>
+  bool operator==(UUID const &other) const
+  {
+    return Data1 == other.Data1 && Data2 == other.Data2 && Data3 == other.Data3 &&
+           (0 == memcmp(Data4, other.Data4, sizeof(Data4)));
+  }
+
+  /// <summary>
+  /// Tests to determine how to sort 2 UUID objects
+  /// </summary>
+  /// <returns>A boolean value that indicates success or failure.</returns>
+  bool operator<(UUID const &other) const
+  {
+    return Data1 < other.Data1 || Data2 < other.Data2 || Data3 == other.Data3 ||
+           (memcmp(Data4, other.Data4, sizeof(Data4)) < 0);
+  }
+};
+#pragma pack(pop) /* restore original alignment from stack */
+
+/// <summary>
+/// Declare UUIDComparer as the Comparer when using UUID as a key in a map or set
+/// </summary>
+struct UUIDComparer : std::less<UUID>
+{
+  inline size_t operator()(UUID const &key) const { return key.Hash(); }
+
+  inline bool operator()(UUID const &lhs, UUID const &rhs) const { return lhs.Hash() < rhs.Hash(); }
+};
+
+}  // namespace utils
+
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/test/etw_logger_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/etw/test/etw_logger_test.cc
new file mode 100644
index 000000000..4e2210118
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/test/etw_logger_test.cc
@@ -0,0 +1,101 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_LOGS_PREVIEW
+#  ifdef _WIN32
+
+#    include <gtest/gtest.h>
+#    include <map>
+#    include <string>
+
+#    include "opentelemetry/exporters/etw/etw_logger_exporter.h"
+#    include "opentelemetry/sdk/trace/simple_processor.h"
+
+using namespace OPENTELEMETRY_NAMESPACE;
+
+using namespace opentelemetry::exporter::etw;
+
+const char *kGlobalProviderName = "OpenTelemetry-ETW-TLD";
+
+/**
+ * @brief Logger test with name and unstructured text
+ * {
+ * "Timestamp": "2021-09-30T16:40:40.0820563-07:00",
+ * "ProviderName": "OpenTelemetry-ETW-TLD",
+ * "Id": 2,
+ * "Message": null,
+ * "ProcessId": 23180,
+ * "Level": "Always",
+ * "Keywords": "0x0000000000000000",
+ * "EventName": "Log",
+ * "ActivityID": null,
+ * "RelatedActivityID": null,
+ * "Payload": {
+ *   "Name": "test",
+ *   "SpanId": "0000000000000000",
+ *   "Timestamp": "2021-09-30T23:40:40.081000Z",
+ *   "TraceId": "00000000000000000000000000000000",
+ *   "_name": "Log",
+ *   "body": "This is test message",
+ *   "severityNumber": 5,
+ *   "severityText": "DEBUG"
+ * }
+ * }
+ */
+
+TEST(ETWLogger, LoggerCheckWithBody)
+{
+  std::string providerName = kGlobalProviderName;  // supply unique instrumentation name here
+  exporter::etw::LoggerProvider lp;
+
+  const std::string schema_url{"https://opentelemetry.io/schemas/1.2.0"};
+  auto logger        = lp.GetLogger(providerName, "", schema_url);
+  Properties attribs = {{"attrib1", 1}, {"attrib2", 2}};
+  EXPECT_NO_THROW(logger->Log(opentelemetry::logs::Severity::kDebug, "This is test log body"));
+}
+
+/**
+ * @brief Logger Test with structured attributes
+ *
+ * Example Event for below test:
+ * {
+ *  "Timestamp": "2021-09-30T15:04:15.4227815-07:00",
+ *  "ProviderName": "OpenTelemetry-ETW-TLD",
+ * "Id": 1,
+ * "Message": null,
+ * "ProcessId": 33544,
+ * "Level": "Always",
+ * "Keywords": "0x0000000000000000",
+ * "EventName": "Log",
+ * "ActivityID": null,
+ * "RelatedActivityID": null,
+ * "Payload": {
+ *  "Name": "test",
+ *   "SpanId": "0000000000000000",
+ *  "Timestamp": "2021-09-30T22:04:15.422000Z",
+ *   "TraceId": "00000000000000000000000000000000",
+ *   "_name": "Log",
+ *  "attrib1": 1,
+ *   "attrib2": 2,
+ *   "body": "",
+ *   "severityNumber": 5,
+ *   "severityText": "DEBUG"
+ * }
+ * }
+ *
+ */
+
+TEST(ETWLogger, LoggerCheckWithAttributes)
+{
+  std::string providerName = kGlobalProviderName;  // supply unique instrumentation name here
+  exporter::etw::LoggerProvider lp;
+
+  const std::string schema_url{"https://opentelemetry.io/schemas/1.2.0"};
+  auto logger = lp.GetLogger(providerName, "", schema_url);
+  // Log attributes
+  Properties attribs = {{"attrib1", 1}, {"attrib2", 2}};
+  EXPECT_NO_THROW(logger->Log(opentelemetry::logs::Severity::kDebug, attribs));
+}
+
+#  endif  // _WIN32
+#endif    // ENABLE_LOGS_PREVIEW
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/test/etw_perf_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/etw/test/etw_perf_test.cc
new file mode 100644
index 000000000..79052464e
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/test/etw_perf_test.cc
@@ -0,0 +1,190 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef _WIN32
+
+#  include <benchmark/benchmark.h>
+#  include <gtest/gtest.h>
+#  include <map>
+#  include <string>
+#  include <unordered_map>
+
+#  include "opentelemetry/exporters/etw/etw_tracer_exporter.h"
+#  include "opentelemetry/sdk/trace/simple_processor.h"
+
+using namespace OPENTELEMETRY_NAMESPACE;
+
+using namespace opentelemetry::exporter::etw;
+
+namespace
+{
+static constexpr const char *providerName = "OpenTelemetry-ETW-StressTest";
+
+static exporter::etw::TelemetryProviderOptions providerOptions = {
+    {"enableTraceId", false},
+    {"enableSpanId", false},
+    {"enableActivityId", false},
+    {"enableRelatedActivityId", false},
+    {"enableAutoParent", false}};
+
+class ETWProviderStressTest
+{
+  exporter::etw::TracerProvider provider_;
+  std::string mode_;
+  nostd::shared_ptr<trace::Tracer> tracer_;
+  nostd::shared_ptr<trace::Span> span_;
+
+public:
+  /**
+   * @brief Construct ETW Provider stress test object
+   * @param mode Operational mode: "TLD" or "MsgPack"
+   */
+  ETWProviderStressTest(std::string mode = "TLD") : mode_(mode), provider_(providerOptions) {}
+
+  /**
+   * @brief Initializer tracer and start a Span
+   */
+  void Initialize()
+  {
+    tracer_ = provider_.GetTracer(providerName, mode_);
+    span_   = tracer_->StartSpan("Span");
+  }
+
+  /**
+   * @brief Obtain the tracer
+   */
+  nostd::shared_ptr<trace::Tracer> GetTracer() { return tracer_; }
+
+  /**
+   * @brief Add event using Properties container
+   */
+  bool AddProperties()
+  {
+    std::string eventName = "MyEvent";
+    Properties event      = {{"uint32Key", (uint32_t)1234},
+                        {"uint64Key", (uint64_t)1234567890},
+                        {"strKey", "someValue"}};
+    span_->AddEvent(eventName, event);
+    return true;
+  }
+
+  /**
+   * @brief Add event using static preallocated "reusable" Properties container.
+   * This approach works well for single-threaded flows, but may not be safe in
+   * some multithreaded scenarios in case if reusable `Properties` get concurrently
+   * modified by different threads (writes to Properties are not thread-safe).
+   */
+  bool AddPropertiesStatic()
+  {
+    std::string eventName   = "MyEvent";
+    static Properties event = {{"uint32Key", (uint32_t)1234},
+                               {"uint64Key", (uint64_t)1234567890},
+                               {"strKey", "someValue"}};
+    span_->AddEvent(eventName, event);
+    return true;
+  }
+
+  /**
+   * @brief Add event using initializer list
+   */
+  bool AddInitList()
+  {
+    std::string eventName = "MyEvent";
+    span_->AddEvent(eventName, {{"uint32Key", (uint32_t)1234},
+                                {"uint64Key", (uint64_t)1234567890},
+                                {"strKey", "someValue"}});
+    return true;
+  }
+
+  /**
+   * @brief Add event using unordered_map
+   */
+  bool AddMap()
+  {
+    std::string eventName                                      = "MyEvent";
+    std::unordered_map<const char *, common::AttributeValue> m = {
+        {"uint32Key", (uint32_t)1234},
+        {"uint64Key", (uint64_t)1234567890},
+        {"strKey", "someValue"}};
+    span_->AddEvent(eventName, m);
+    return true;
+  }
+
+  /**
+   * @brief End Span and close tracer.
+   */
+  void Teardown()
+  {
+    span_->End();
+    tracer_->CloseWithMicroseconds(0);
+  }
+};
+
+ETWProviderStressTest provider;
+
+/**
+ * @brief Create Properties and AddEvent(Properties) to Tracer
+ * @param state Benchmark state.
+ */
+void BM_AddPropertiesToTracer(benchmark::State &state)
+{
+  provider.Initialize();
+  while (state.KeepRunning())
+  {
+    benchmark::DoNotOptimize(provider.AddProperties());
+  }
+  provider.Teardown();
+}
+BENCHMARK(BM_AddPropertiesToTracer);
+
+/**
+ * @brief Create static Properties and AddEvent(Properties) to Tracer
+ * @param state Benchmark state.
+ */
+void BM_AddPropertiesStaticToTracer(benchmark::State &state)
+{
+  provider.Initialize();
+  while (state.KeepRunning())
+  {
+    benchmark::DoNotOptimize(provider.AddPropertiesStatic());
+  }
+  provider.Teardown();
+}
+BENCHMARK(BM_AddPropertiesStaticToTracer);
+
+/**
+ * @brief Create event via initializer list and AddEvent({...}) to Tracer
+ * @param state Benchmark state.
+ */
+void BM_AddInitListToTracer(benchmark::State &state)
+{
+  provider.Initialize();
+  while (state.KeepRunning())
+  {
+    benchmark::DoNotOptimize(provider.AddInitList());
+  }
+  provider.Teardown();
+}
+BENCHMARK(BM_AddInitListToTracer);
+
+/**
+ * @brief Create event as `std::map<std::string, common::AttributeValue>`
+ * and AddEvent(event) to Tracer.
+ * @param state Benchmark state.
+ */
+void BM_AddMapToTracer(benchmark::State &state)
+{
+  provider.Initialize();
+  while (state.KeepRunning())
+  {
+    benchmark::DoNotOptimize(provider.AddMap());
+  }
+  provider.Teardown();
+}
+BENCHMARK(BM_AddMapToTracer);
+
+}  // namespace
+
+BENCHMARK_MAIN();
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/test/etw_provider_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/etw/test/etw_provider_test.cc
new file mode 100644
index 000000000..d5ebbcad4
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/test/etw_provider_test.cc
@@ -0,0 +1,64 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef _WIN32
+
+#  include <gtest/gtest.h>
+#  include <string>
+
+#  include "opentelemetry/exporters/etw/etw_provider.h"
+
+using namespace OPENTELEMETRY_NAMESPACE;
+
+TEST(ETWProvider, ProviderIsRegisteredSuccessfully)
+{
+  std::string providerName = "OpenTelemetry-ETW-Provider";
+  static ETWProvider etw;
+  auto handle = etw.open(providerName.c_str());
+
+  bool registered = etw.is_registered(providerName);
+  ASSERT_TRUE(registered);
+  etw.close(handle);
+}
+
+TEST(ETWProvider, ProviderIsNotRegisteredSuccessfully)
+{
+  std::string providerName = "OpenTelemetry-ETW-Provider-NULL";
+  static ETWProvider etw;
+
+  bool registered = etw.is_registered(providerName);
+  ASSERT_FALSE(registered);
+}
+
+TEST(ETWProvider, CheckOpenGUIDDataSuccessfully)
+{
+  std::string providerName = "OpenTelemetry-ETW-Provider";
+
+  // get GUID from the handle returned
+  static ETWProvider etw;
+  auto handle = etw.open(providerName.c_str());
+
+  utils::UUID uuid_handle(handle.providerGuid);
+  auto guidStrHandle = uuid_handle.to_string();
+
+  // get GUID from the providerName
+  auto guid = utils::GetProviderGuid(providerName.c_str());
+  utils::UUID uuid_name(guid);
+  auto guidStrName = uuid_name.to_string();
+
+  ASSERT_STREQ(guidStrHandle.c_str(), guidStrName.c_str());
+  etw.close(handle);
+}
+
+TEST(ETWProvider, CheckCloseSuccess)
+{
+  std::string providerName = "OpenTelemetry-ETW-Provider";
+
+  static ETWProvider etw;
+  auto handle = etw.open(providerName.c_str(), ETWProvider::EventFormat::ETW_MANIFEST);
+  auto result = etw.close(handle);
+  ASSERT_NE(result, etw.STATUS_ERROR);
+  ASSERT_FALSE(etw.is_registered(providerName));
+}
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/etw/test/etw_tracer_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/etw/test/etw_tracer_test.cc
new file mode 100644
index 000000000..1c9c1f09b
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/etw/test/etw_tracer_test.cc
@@ -0,0 +1,388 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef _WIN32
+
+#  include <gtest/gtest.h>
+#  include <map>
+#  include <string>
+
+#  include "opentelemetry/exporters/etw/etw_tracer_exporter.h"
+#  include "opentelemetry/sdk/trace/simple_processor.h"
+
+using namespace OPENTELEMETRY_NAMESPACE;
+
+using namespace opentelemetry::exporter::etw;
+
+const char *kGlobalProviderName = "OpenTelemetry-ETW-TLD";
+
+std::string getTemporaryValue()
+{
+  return std::string("Value from Temporary std::string");
+}
+
+/* clang-format off */
+TEST(ETWTracer, TracerCheck)
+{
+  // SDK customer specifies their unique ETW ProviderName. Every component or library
+  // is assumed to have its own instrumentation name. Traces are routed to dedicated
+  // provider. Standard hash function maps from ProviderName to ProviderGUID.
+  //
+  // Prominent naming examples from `logman query providers` :
+  //
+  // [Docker]                                 {a3693192-9ed6-46d2-a981-f8226c8363bd}
+  // ...
+  // Intel-Autologger-iclsClient              {B8D7E9A0-65D5-40BE-AFEA-83593FC0164E}
+  // Intel-Autologger-iclsProxy                {301B773F-50F3-4C8E-83F0-53BA9590A13E}
+  // Intel-Autologger-PTTEKRecertification    {F33E9E07-8792-47E8-B3FA-2C92AB32C5B3}
+  // ...
+  // NodeJS-ETW-provider                      {77754E9B-264B-4D8D-B981-E4135C1ECB0C}
+  // ...
+  // OpenSSH                                  {C4B57D35-0636-4BC3-A262-370F249F9802}
+  // ...
+  // Windows Connect Now                      {C100BECE-D33A-4A4B-BF23-BBEF4663D017}
+  // Windows Defender Firewall API            {28C9F48F-D244-45A8-842F-DC9FBC9B6E92}
+  // Windows Defender Firewall API - GP       {0EFF663F-8B6E-4E6D-8182-087A8EAA29CB}
+  // Windows Defender Firewall Driver         {D5E09122-D0B2-4235-ADC1-C89FAAAF1069}
+
+  std::string providerName = kGlobalProviderName; // supply unique instrumentation name here
+  exporter::etw::TracerProvider tp;
+
+  auto tracer = tp.GetTracer(providerName);
+
+  // Span attributes
+  Properties attribs =
+  {
+    {"attrib1", 1},
+    {"attrib2", 2}
+  };
+  {
+    auto topSpan = tracer->StartSpan("MySpanTop");
+    auto topScope = tracer->WithActiveSpan(topSpan);
+    {
+      auto outerSpan = tracer->StartSpan("MySpanL2", attribs);
+      auto outerScope = tracer->WithActiveSpan(outerSpan);
+
+      // Create nested span. Note how we share the attributes here.
+      // It is Okay to either reuse/share or have your own attributes.
+      {
+        auto innerSpan = tracer->StartSpan("MySpanL3", attribs);
+        auto innerScope = tracer->WithActiveSpan(innerSpan);
+
+        // Add span attribute
+        EXPECT_NO_THROW(outerSpan->SetAttribute("AttrName1", "AttrValue1"));
+
+        // Add first event
+        std::string eventName1 = "MyEvent1";
+        Properties event1 =
+        {
+          {"uint32Key", (uint32_t)1234},
+          {"uint64Key", (uint64_t)1234567890},
+          {"strKey", "someValue"}
+        };
+        EXPECT_NO_THROW(outerSpan->AddEvent(eventName1, event1));
+
+        // Add second event
+        std::string eventName2 = "MyEvent2";
+        Properties event2 =
+        {
+          {"uint32Key", (uint32_t)9876},
+          {"uint64Key", (uint64_t)987654321},
+          {"strKey", "anotherValue"}
+        };
+        EXPECT_NO_THROW(outerSpan->AddEvent(eventName2, event2));
+
+        std::string eventName3= "MyEvent3";
+        Properties event3 =
+        {
+          /* Extra metadata that allows event to flow to A.I. pipeline */
+          {"metadata", "ai_event"},
+          {"uint32Key", (uint32_t)9876},
+          {"uint64Key", (uint64_t)987654321},
+          // {"int32array", {{-1,0,1,2,3}} },
+          {"tempString", getTemporaryValue() }
+        };
+        EXPECT_NO_THROW(innerSpan->AddEvent(eventName3, event3));
+        EXPECT_NO_THROW(innerSpan->End());
+
+      }
+      EXPECT_NO_THROW(outerSpan->End());
+
+    }
+    EXPECT_NO_THROW(topSpan->End());
+  }
+
+  EXPECT_NO_THROW(tracer->CloseWithMicroseconds(0));
+}
+
+// Lowest decoration level -> smaller ETW event size.
+// Expected output in C# listener on the other side:
+// no ActivityID GUID, no SpanId, no TraceId.
+/*
+{
+  "Timestamp": "2021-03-19T21:04:38.411193-07:00",
+  "ProviderName": "OpenTelemetry-ETW-TLD",
+  "Id": 13,
+  "Message": null,
+  "ProcessId": 15120,
+  "Level": "Always",
+  "Keywords": "0x0000000000000000",
+  "EventName": "C.min/Stop",
+  "ActivityID": null,
+  "RelatedActivityID": null,
+  "Payload": {}
+}
+*/
+TEST(ETWTracer, TracerCheckMinDecoration)
+{
+  std::string providerName = kGlobalProviderName;
+  exporter::etw::TracerProvider tp
+  ({
+      {"enableTraceId", false},
+      {"enableSpanId", false},
+      {"enableActivityId", false},
+      {"enableActivityTracking", true},
+      {"enableRelatedActivityId", false},
+      {"enableAutoParent", false}
+  });
+  auto tracer = tp.GetTracer(providerName);
+  {
+    auto aSpan = tracer->StartSpan("A.min");
+    auto aScope = tracer->WithActiveSpan(aSpan);
+    {
+      auto bSpan = tracer->StartSpan("B.min");
+      auto bScope = tracer->WithActiveSpan(bSpan);
+      {
+        auto cSpan = tracer->StartSpan("C.min");
+        auto cScope = tracer->WithActiveSpan(cSpan);
+        EXPECT_NO_THROW(cSpan->End());
+      }
+      EXPECT_NO_THROW(bSpan->End());
+    }
+    EXPECT_NO_THROW(aSpan->End());
+}
+  tracer->CloseWithMicroseconds(0);
+}
+
+// Highest decoration level -> larger ETW event size
+// Expected output in C# listener on the other side:
+// ActivityID GUID (==SpanId), SpanId, TraceId.
+/*
+{
+  "Timestamp": "2021-03-19T21:04:38.4120274-07:00",
+  "ProviderName": "OpenTelemetry-ETW-TLD",
+  "Id": 21,
+  "Message": null,
+  "ProcessId": 15120,
+  "Level": "Always",
+  "Keywords": "0x0000000000000000",
+  "EventName": "C.max/Stop",
+  "ActivityID": "d55a2c25-8033-40ab-0000-000000000000",
+  "RelatedActivityID": null,
+  "Payload": {
+    "SpanId": "252c5ad53380ab40",
+    "TraceId": "4dea2a63c188894ea5ab979e5cd7ec36"
+  }
+}
+*/
+TEST(ETWTracer, TracerCheckMaxDecoration)
+{
+  std::string providerName = kGlobalProviderName;
+  exporter::etw::TracerProvider tp
+  ({
+      {"enableTraceId", true},
+      {"enableSpanId", true},
+      {"enableActivityId", true},
+      {"enableRelatedActivityId", true},
+      {"enableAutoParent", true}
+  });
+  auto tracer = tp.GetTracer(providerName);
+  {
+    auto aSpan = tracer->StartSpan("A.max");
+    auto aScope = tracer->WithActiveSpan(aSpan);
+    {
+      auto bSpan = tracer->StartSpan("B.max");
+      auto bScope = tracer->WithActiveSpan(bSpan);
+      {
+        auto cSpan = tracer->StartSpan("C.max");
+        auto cScope = tracer->WithActiveSpan(cSpan);
+        EXPECT_NO_THROW(cSpan->End());
+      }
+      EXPECT_NO_THROW(bSpan->End());
+    }
+    EXPECT_NO_THROW(aSpan->End());
+  }
+  tracer->CloseWithMicroseconds(0);
+}
+
+TEST(ETWTracer, TracerCheckMsgPack)
+{
+  std::string providerName = "OpenTelemetry-ETW-MsgPack";
+  exporter::etw::TracerProvider tp
+  ({
+      {"enableTraceId", true},
+      {"enableSpanId", true},
+      {"enableActivityId", true},
+      {"enableRelatedActivityId", true},
+      {"enableAutoParent", true}
+  });
+  auto tracer = tp.GetTracer(providerName);
+  {
+      auto aSpan = tracer->StartSpan("A.max");
+      auto aScope = tracer->WithActiveSpan(aSpan);
+      {
+          auto bSpan = tracer->StartSpan("B.max");
+          auto bScope = tracer->WithActiveSpan(bSpan);
+          {
+              auto cSpan = tracer->StartSpan("C.max");
+              auto cScope = tracer->WithActiveSpan(cSpan);
+              std::string eventName = "MyMsgPackEvent";
+              Properties event =
+              {
+                  {"uint32Key", (uint32_t)1234},
+                  {"uint64Key", (uint64_t)1234567890},
+                  {"strKey", "someValue"}
+              };
+              cSpan->AddEvent(eventName, event);
+              EXPECT_NO_THROW(cSpan->End());
+          }
+          EXPECT_NO_THROW(bSpan->End());
+      }
+      EXPECT_NO_THROW(aSpan->End());
+  }
+  tracer->CloseWithMicroseconds(0);
+}
+
+/**
+ * @brief Global Tracer singleton may be placed in .h header and
+ * shared across different compilation units. All would get the
+ * same object.
+ *
+ * @return Single global tracer instance.
+*/
+static OPENTELEMETRY_NAMESPACE::trace::TracerProvider& GetGlobalTracerProvider()
+{
+    static exporter::etw::TracerProvider tp
+    ({
+      {"enableTraceId", true},
+      {"enableSpanId", true},
+      {"enableActivityId", true},
+      {"enableRelatedActivityId", true},
+      {"enableAutoParent", true}
+     });
+    return tp;
+}
+
+static OPENTELEMETRY_NAMESPACE::trace::Tracer& GetGlobalTracer()
+{
+    static auto tracer = GetGlobalTracerProvider().GetTracer(kGlobalProviderName);
+    return (*tracer.get());
+}
+
+TEST(ETWTracer, GlobalSingletonTracer)
+{
+  // Obtain a global tracer using C++11 magic static.
+  auto& globalTracer = GetGlobalTracer();
+  auto s1 = globalTracer.StartSpan("Span1");
+  auto traceId1 = s1->GetContext().trace_id();
+  s1->End();
+/* === Span 1 - "TraceId": "182a64258fb1864ca4e1a542eecbd9bf"
+{
+  "Timestamp": "2021-05-10T11:45:27.028827-07:00",
+  "ProviderName": "OpenTelemetry-ETW-TLD",
+  "Id": 5,
+  "Message": null,
+  "ProcessId": 23712,
+  "Level": "Always",
+  "Keywords": "0x0000000000000000",
+  "EventName": "Span",
+  "ActivityID": "6ed94703-6b0a-4e76-0000-000000000000",
+  "RelatedActivityID": null,
+  "Payload": {
+    "Duration": 0,
+    "Kind": 1,
+    "Name": "Span1",
+    "SpanId": "0347d96e0a6b764e",
+    "StartTime": "2021-05-10T18:45:27.028000Z",
+    "StatusCode": 0,
+    "StatusMessage": "",
+    "Success": "True",
+    "TraceId": "182a64258fb1864ca4e1a542eecbd9bf",
+    "_name": "Span"
+  }
+}
+*/
+
+  // Obtain a different tracer withs its own trace-id.
+  auto localTracer = GetGlobalTracerProvider().GetTracer(kGlobalProviderName);
+  auto s2 = localTracer->StartSpan("Span2");
+  auto traceId2 = s2->GetContext().trace_id();
+  s2->End();
+/* === Span 2 - "TraceId": "334bf9a1eed98d40a873a606295a9368"
+{
+  "Timestamp": "2021-05-10T11:45:27.0289654-07:00",
+  "ProviderName": "OpenTelemetry-ETW-TLD",
+  "Id": 5,
+  "Message": null,
+  "ProcessId": 23712,
+  "Level": "Always",
+  "Keywords": "0x0000000000000000",
+  "EventName": "Span",
+  "ActivityID": "3b7b2ecb-2e84-4903-0000-000000000000",
+  "RelatedActivityID": null,
+  "Payload": {
+    "Duration": 0,
+    "Kind": 1,
+    "Name": "Span2",
+    "SpanId": "cb2e7b3b842e0349",
+    "StartTime": "2021-05-10T18:45:27.028000Z",
+    "StatusCode": 0,
+    "StatusMessage": "",
+    "Success": "True",
+    "TraceId": "334bf9a1eed98d40a873a606295a9368",
+    "_name": "Span"
+  }
+}
+*/
+
+  // Obtain the same global tracer with the same trace-id as before.
+  auto& globalTracer2 = GetGlobalTracer();
+  auto s3 = globalTracer2.StartSpan("Span3");
+  auto traceId3 = s3->GetContext().trace_id();
+  s3->End();
+/* === Span 3 - "TraceId": "182a64258fb1864ca4e1a542eecbd9bf"
+{
+  "Timestamp": "2021-05-10T11:45:27.0290936-07:00",
+  "ProviderName": "OpenTelemetry-ETW-TLD",
+  "Id": 5,
+  "Message": null,
+  "ProcessId": 23712,
+  "Level": "Always",
+  "Keywords": "0x0000000000000000",
+  "EventName": "Span",
+  "ActivityID": "0a970247-ba0e-4d4b-0000-000000000000",
+  "RelatedActivityID": null,
+  "Payload": {
+    "Duration": 1,
+    "Kind": 1,
+    "Name": "Span3",
+    "SpanId": "4702970a0eba4b4d",
+    "StartTime": "2021-05-10T18:45:27.028000Z",
+    "StatusCode": 0,
+    "StatusMessage": "",
+    "Success": "True",
+    "TraceId": "182a64258fb1864ca4e1a542eecbd9bf",
+    "_name": "Span"
+  }
+}
+*/
+  EXPECT_NE(traceId1, traceId2);
+  EXPECT_EQ(traceId1, traceId3);
+
+  localTracer->CloseWithMicroseconds(0);
+  globalTracer.CloseWithMicroseconds(0);
+}
+
+/* clang-format on */
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/BUILD b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/BUILD
new file mode 100644
index 000000000..cc1babae0
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/BUILD
@@ -0,0 +1,217 @@
+package(default_visibility = ["//visibility:public"])
+
+load("@rules_foreign_cc//foreign_cc:defs.bzl", "cmake", "configure_make", "configure_make_variant")
+
+constraint_setting(
+    name = "incompatible_setting",
+)
+
+constraint_value(
+    name = "incompatible",
+    constraint_setting = ":incompatible_setting",
+)
+
+config_setting(
+    name = "windows",
+    constraint_values = [
+        "@bazel_tools//platforms:windows",
+    ],
+    tags = ["jaeger"],
+    visibility = ["//visibility:private"],
+)
+
+THRIFT_CACHE_ENTRIES = {
+    "CMAKE_BUILD_TYPE": "Release",
+    "BUILD_COMPILER": "OFF",
+    "BUILD_CPP": "ON",
+    "BUILD_LIBRARIES": "ON",
+    "BUILD_NODEJS": "OFF",
+    "BUILD_PYTHON": "OFF",
+    "BUILD_JAVASCRIPT": "OFF",
+    "BUILD_C_GLIB": "OFF",
+    "BUILD_JAVA": "OFF",
+    "BUILD_TESTING": "OFF",
+    "BUILD_TUTORIALS": "OFF",
+    "WITH_HASKELL": "OFF",
+}
+
+THRIFT_CACHE_ENTRIES_WIN = {
+    "CMAKE_BUILD_TYPE": "Release",
+    "BUILD_COMPILER": "OFF",
+    "BUILD_CPP": "ON",
+    "BUILD_LIBRARIES": "ON",
+    "BUILD_NODEJS": "OFF",
+    "BUILD_PYTHON": "OFF",
+    "BUILD_JAVASCRIPT": "OFF",
+    "BUILD_C_GLIB": "OFF",
+    "BUILD_JAVA": "OFF",
+    "BUILD_TESTING": "OFF",
+    "BUILD_TUTORIALS": "OFF",
+    "WITH_HASKELL": "OFF",
+    "WITH_STDTHREADS": "ON",
+    "WITH_BOOSTTHREADS": "OFF",
+    "WITH_BOOST_FUNCTIONAL": "OFF",
+    "WITH_BOOST_SMART_PTR": "OFF",
+    "BUILD_SHARED_LIBS": "OFF",
+    "CMAKE_TOOLCHAIN_FILE": "$VCPKG_DIR/scripts/buildsystems/vcpkg.cmake",
+}
+
+cmake(
+    name = "thrift",
+    cache_entries = select({
+        "@bazel_tools//platforms:osx": THRIFT_CACHE_ENTRIES,
+        "@bazel_tools//platforms:linux": THRIFT_CACHE_ENTRIES,
+        "@bazel_tools//platforms:windows": THRIFT_CACHE_ENTRIES_WIN,
+    }),
+    copts = [
+        "-Ilibs/exporters/jaeger/openssl/include",
+        "-fexceptions",
+    ],
+    generate_args = select({
+        "@bazel_tools//platforms:osx": [],
+        "@bazel_tools//platforms:linux": [],
+        "@bazel_tools//platforms:windows": [
+            "-G \"NMake Makefiles\"",
+        ],
+    }),
+    install = True,
+    lib_source = "@com_github_thrift//:all_srcs",
+    out_lib_dir = select({
+        "@bazel_tools//platforms:osx": "lib",
+        "@bazel_tools//platforms:linux": "lib",
+        "@bazel_tools//platforms:windows": "bin",
+    }),
+    out_static_libs = select({
+        "@bazel_tools//platforms:osx": [
+            "libthrift.a",
+            "libthriftz.a",
+        ],
+        "@bazel_tools//platforms:linux": [
+            "libthrift.a",
+            "libthriftz.a",
+        ],
+        "@bazel_tools//platforms:windows": [
+            "thriftmd.lib",
+        ],
+    }),
+    tags = ["jaeger"],
+    visibility = ["//visibility:private"],
+    deps = [],
+)
+
+THRIFT_GEN_DEPS = [
+    ":thrift",
+    "//ext/src/http/client/curl:http_client_curl",
+]
+
+THRIFT_GEN_DEPS_WIN = THRIFT_GEN_DEPS + [
+    "@boost_all_hdrs//:boost_all_hdrs",
+]
+
+cc_library(
+    name = "jaeger_thrift_gencpp",
+    srcs = [
+        "thrift-gen/Agent.cpp",
+        "thrift-gen/Collector.cpp",
+        "thrift-gen/ZipkinCollector.cpp",
+        "thrift-gen/jaeger_types.cpp",
+        "thrift-gen/zipkincore_constants.cpp",
+        "thrift-gen/zipkincore_types.cpp",
+    ],
+    hdrs = [
+        "thrift-gen/Agent.h",
+        "thrift-gen/Collector.h",
+        "thrift-gen/ZipkinCollector.h",
+        "thrift-gen/agent_types.h",
+        "thrift-gen/jaeger_types.h",
+        "thrift-gen/zipkincore_constants.h",
+        "thrift-gen/zipkincore_types.h",
+    ],
+    copts = [
+        "-fexceptions",
+    ],
+    strip_include_prefix = "thrift-gen",
+    tags = ["jaeger"],
+    deps = select({
+        "@bazel_tools//platforms:osx": THRIFT_GEN_DEPS,
+        "@bazel_tools//platforms:linux": THRIFT_GEN_DEPS,
+        "@bazel_tools//platforms:windows": THRIFT_GEN_DEPS_WIN,
+    }),
+)
+
+cc_library(
+    name = "jaeger_exporter",
+    srcs = [
+    ],
+    hdrs = [
+        "src/THttpTransport.h",
+        "src/TUDPTransport.h",
+        "src/http_transport.h",
+        "src/sender.h",
+        "src/thrift_sender.h",
+        "src/transport.h",
+        "src/udp_transport.h",
+    ],
+    copts = ["-fexceptions"],
+    strip_include_prefix = "src",
+    tags = ["jaeger"],
+    deps = [
+        ":jaeger_thrift_gencpp",
+    ],
+)
+
+cc_library(
+    name = "opentelemetry_exporter_jaeger_trace",
+    srcs = [
+        "src/THttpTransport.cc",
+        "src/TUDPTransport.cc",
+        "src/http_transport.cc",
+        "src/jaeger_exporter.cc",
+        "src/recordable.cc",
+        "src/thrift_sender.cc",
+        "src/udp_transport.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/jaeger/jaeger_exporter.h",
+        "include/opentelemetry/exporters/jaeger/recordable.h",
+    ],
+    copts = ["-fexceptions"],
+    strip_include_prefix = "include",
+    tags = ["jaeger"],
+    deps = [
+        ":jaeger_exporter",
+        "//sdk/src/common:global_log_handler",
+    ],
+)
+
+cc_test(
+    name = "jaeger_recordable_test",
+    srcs = ["test/jaeger_recordable_test.cc"],
+    copts = ["-fexceptions"],
+    tags = [
+        "jaeger",
+        "test",
+    ],
+    deps = [
+        ":opentelemetry_exporter_jaeger_trace",
+        "//sdk/src/resource",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "jaeger_exporter_test",
+    srcs = ["test/jaeger_exporter_test.cc"],
+    copts = ["-fexceptions"],
+    defines = ["BAZEL_BUILD"],
+    tags = [
+        "jaeger",
+        "test",
+    ],
+    deps = [
+        ":opentelemetry_exporter_jaeger_trace",
+        "//sdk/src/resource",
+        "//sdk/src/trace",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/CMakeLists.txt b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/CMakeLists.txt
new file mode 100644
index 000000000..a95c0cc94
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/CMakeLists.txt
@@ -0,0 +1,95 @@
+include_directories(thrift-gen)
+
+find_package(Thrift REQUIRED)
+# vcpkg config recipe points to THRIFT_INCLUDE_DIR=...\thrift . Ensure that the
+# include dir for thrift-gen code is 1 level-up from that:
+include_directories(SYSTEM ${THRIFT_INCLUDE_DIR}/..)
+
+set(JAEGER_THRIFT_GENCPP_SOURCES
+    thrift-gen/Agent.cpp thrift-gen/jaeger_types.cpp thrift-gen/Collector.cpp
+    thrift-gen/zipkincore_types.cpp)
+
+set(JAEGER_EXPORTER_SOURCES
+    src/jaeger_exporter.cc
+    src/thrift_sender.cc
+    src/udp_transport.cc
+    src/recordable.cc
+    src/TUDPTransport.cc
+    src/http_transport.cc
+    src/THttpTransport.cc)
+
+add_library(opentelemetry_exporter_jaeger_trace ${JAEGER_EXPORTER_SOURCES}
+                                                ${JAEGER_THRIFT_GENCPP_SOURCES})
+
+set_target_properties(opentelemetry_exporter_jaeger_trace
+                      PROPERTIES EXPORT_NAME jaeger_trace_exporter)
+
+target_include_directories(
+  opentelemetry_exporter_jaeger_trace
+  PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+         "$<INSTALL_INTERFACE:include>")
+
+target_link_libraries(
+  opentelemetry_exporter_jaeger_trace
+  PUBLIC opentelemetry_resources opentelemetry_http_client_curl
+  PRIVATE thrift::thrift)
+
+if(MSVC)
+  target_compile_definitions(opentelemetry_exporter_jaeger_trace
+                             PUBLIC NOMINMAX)
+  if(NOT BUILD_SHARED_LIBS)
+    target_compile_definitions(opentelemetry_exporter_jaeger_trace
+                               PUBLIC THRIFT_STATIC_DEFINE)
+  endif()
+endif()
+
+install(
+  TARGETS opentelemetry_exporter_jaeger_trace
+  EXPORT "${PROJECT_NAME}-target"
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+install(
+  DIRECTORY include/opentelemetry/exporters/jaeger
+  DESTINATION include/opentelemetry/exporters
+  FILES_MATCHING
+  PATTERN "*.h"
+  PATTERN "recordable.h" EXCLUDE)
+
+if(BUILD_TESTING)
+  add_definitions(-DGTEST_LINKED_AS_SHARED_LIBRARY=1)
+
+  add_executable(jaeger_recordable_test test/jaeger_recordable_test.cc)
+  target_link_libraries(
+    jaeger_recordable_test ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
+    opentelemetry_exporter_jaeger_trace)
+
+  gtest_add_tests(
+    TARGET jaeger_recordable_test
+    TEST_PREFIX exporter.
+    TEST_LIST jaeger_recordable_test)
+
+  add_executable(jaeger_exporter_test test/jaeger_exporter_test.cc)
+  if(MSVC)
+    if(GMOCK_LIB)
+      unset(GMOCK_LIB CACHE)
+    endif()
+  endif()
+  if(MSVC AND CMAKE_BUILD_TYPE STREQUAL "Debug")
+    find_library(GMOCK_LIB gmockd PATH_SUFFIXES lib)
+  else()
+    find_library(GMOCK_LIB gmock PATH_SUFFIXES lib)
+  endif()
+  target_link_libraries(
+    jaeger_exporter_test ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
+    ${GMOCK_LIB} opentelemetry_trace opentelemetry_exporter_jaeger_trace)
+
+  target_include_directories(jaeger_exporter_test
+                             PRIVATE ${CMAKE_CURRENT_LIST_DIR}/src)
+
+  gtest_add_tests(
+    TARGET jaeger_exporter_test
+    TEST_PREFIX exporter.
+    TEST_LIST jaeger_exporter_test)
+endif() # BUILD_TESTING
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/README.md b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/README.md
new file mode 100644
index 000000000..d4fa3b45b
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/README.md
@@ -0,0 +1,61 @@
+# Jaeger Exporter for OpenTelemetry C++
+
+## Prerequisite
+
+* [Get Jaeger](https://www.jaegertracing.io/docs/getting-started/) and run
+  Jaeger agent.
+
+## Installation
+
+### CMake Installation Instructions
+
+Refer to install instructions
+[INSTALL.md](../../INSTALL.md#building-as-standalone-cmake-project). Modify step
+2 to create `cmake` build configuration for compiling with Jaeger exporter as
+below:
+
+```console
+   $ cmake -DWITH_JAEGER=ON ..
+   -- The C compiler identification is GNU 9.3.0
+   -- The CXX compiler identification is GNU 9.3.0
+   ...
+   -- Configuring done
+   -- Generating done
+   -- Build files have been written to: /home/<user>/source/opentelemetry-cpp/build
+   $
+```
+
+### Bazel install Instructions
+
+Refer to install instructions
+[INSTALL.md](../../INSTALL.md#building-as-standalone-bazel-project).
+
+```console
+bazel build //exporters/jaeger:opentelemetry_exporter_jaeger_trace
+```
+
+## Usage
+
+Install the exporter in your application, initialize and pass the `options` to it.
+
+```cpp
+opentelemetry::exporter::jaeger::JaegerExporterOptions options;
+options.server_addr      = "localhost";
+options.server_port      = 6831;
+options.transport_format = opentelemetry::exporter::jaeger::TransportFormat::kThriftUdpCompact;
+
+auto exporter = std::unique_ptr<opentelemetry::sdk::trace::SpanExporter>(
+    new opentelemetry::exporter::jaeger::JaegerExporter(options));
+auto processor = std::shared_ptr<sdktrace::SpanProcessor>(
+    new sdktrace::SimpleSpanProcessor(std::move(exporter)));
+auto provider = nostd::shared_ptr<opentelemetry::trace::TracerProvider>(
+    new sdktrace::TracerProvider(processor));
+
+// Set the global trace provider
+opentelemetry::trace::Provider::SetTracerProvider(provider);
+
+```
+
+## Viewing your traces
+
+Please visit the Jaeger UI endpoint <http://localhost:16686>.
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/include/opentelemetry/exporters/jaeger/jaeger_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/include/opentelemetry/exporters/jaeger/jaeger_exporter.h
new file mode 100644
index 000000000..284bab2ca
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/include/opentelemetry/exporters/jaeger/jaeger_exporter.h
@@ -0,0 +1,93 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <opentelemetry/common/spin_lock_mutex.h>
+#include <opentelemetry/ext/http/client/http_client.h>
+#include <opentelemetry/sdk/trace/exporter.h>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+enum class TransportFormat
+{
+  kThriftUdp,
+  kThriftUdpCompact,
+  kThriftHttp,
+  kProtobufGrpc,
+};
+
+class ThriftSender;
+
+/**
+ * Struct to hold Jaeger exporter options.
+ */
+struct JaegerExporterOptions
+{
+  TransportFormat transport_format = TransportFormat::kThriftUdpCompact;
+  std::string endpoint             = "localhost";
+  uint16_t server_port             = 6831;
+  // Only applicable when using kThriftHttp transport.
+  ext::http::client::Headers headers;
+};
+
+class JaegerExporter final : public opentelemetry::sdk::trace::SpanExporter
+{
+public:
+  /**
+   * Create a JaegerExporter using all default options.
+   */
+  JaegerExporter();
+
+  /**
+   * Create a JaegerExporter using the given options.
+   */
+  explicit JaegerExporter(const JaegerExporterOptions &options);
+
+  /**
+   * Create a span recordable.
+   * @return a new initialized Recordable object.
+   */
+  std::unique_ptr<opentelemetry::sdk::trace::Recordable> MakeRecordable() noexcept override;
+
+  /**
+   * Export a batch of spans.
+   * @param spans a span of unique pointers to span recordables.
+   */
+  opentelemetry::sdk::common::ExportResult Export(
+      const nostd::span<std::unique_ptr<opentelemetry::sdk::trace::Recordable>> &spans) noexcept
+      override;
+
+  /**
+   * Shutdown the exporter.
+   * @param timeout an option timeout, default to max.
+   */
+  bool Shutdown(
+      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+
+private:
+  void InitializeEndpoint();
+
+private:
+  // The configuration options associated with this exporter.
+  bool is_shutdown_ = false;
+  JaegerExporterOptions options_;
+  std::unique_ptr<ThriftSender> sender_;
+  mutable opentelemetry::common::SpinLockMutex lock_;
+  bool isShutdown() const noexcept;
+  // For testing
+  friend class JaegerExporterTestPeer;
+  /**
+   * Create an JaegerExporter using the specified thrift sender.
+   * Only tests can call this constructor directly.
+   * @param sender the thrift sender to be used for exporting
+   */
+  JaegerExporter(std::unique_ptr<ThriftSender> sender);
+};
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/include/opentelemetry/exporters/jaeger/recordable.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/include/opentelemetry/exporters/jaeger/recordable.h
new file mode 100644
index 000000000..98e1e6131
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/include/opentelemetry/exporters/jaeger/recordable.h
@@ -0,0 +1,119 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <jaeger_types.h>
+#include <opentelemetry/sdk/trace/recordable.h>
+#include <opentelemetry/version.h>
+
+#if (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
+     __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#  define JAEGER_IS_LITTLE_ENDIAN 1
+#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
+    __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#  define JAEGER_IS_LITTLE_ENDIAN 0
+#elif defined(_WIN32)
+#  define JAEGER_IS_LITTLE_ENDIAN 1
+#else
+#  error "Endian detection needs to be set up for your compiler"
+#endif
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+#if JAEGER_IS_LITTLE_ENDIAN == 1
+
+#  if defined(__clang__) || \
+      (defined(__GNUC__) && ((__GNUC__ == 4 && __GNUC_MINOR__ >= 8) || __GNUC__ >= 5))
+inline uint64_t otel_bswap_64(uint64_t host_int)
+{
+  return __builtin_bswap64(host_int);
+}
+
+#  elif defined(_MSC_VER)
+inline uint64_t otel_bswap_64(uint64_t host_int)
+{
+  return _byteswap_uint64(host_int);
+}
+
+#  else
+#    error "Port need to support endianess conversion"
+
+#  endif
+
+#endif
+
+using namespace jaegertracing;
+
+class JaegerRecordable final : public sdk::trace::Recordable
+{
+public:
+  JaegerRecordable();
+
+  thrift::Span *Span() noexcept { return span_.release(); }
+  std::vector<thrift::Tag> Tags() noexcept { return std::move(tags_); }
+  std::vector<thrift::Tag> ResourceTags() noexcept { return std::move(resource_tags_); }
+  std::vector<thrift::Log> Logs() noexcept { return std::move(logs_); }
+  std::vector<thrift::SpanRef> References() noexcept { return std::move(references_); }
+  const std::string &ServiceName() const noexcept { return service_name_; }
+
+  void SetIdentity(const opentelemetry::trace::SpanContext &span_context,
+                   opentelemetry::trace::SpanId parent_span_id) noexcept override;
+
+  void SetAttribute(nostd::string_view key,
+                    const opentelemetry::common::AttributeValue &value) noexcept override;
+
+  void AddEvent(nostd::string_view key,
+                common::SystemTimestamp timestamp,
+                const common::KeyValueIterable &attributes) noexcept override;
+
+  void AddLink(const opentelemetry::trace::SpanContext &span_context,
+               const common::KeyValueIterable &attributes) noexcept override;
+
+  void SetStatus(trace::StatusCode code, nostd::string_view description) noexcept override;
+
+  void SetName(nostd::string_view name) noexcept override;
+
+  void SetStartTime(common::SystemTimestamp start_time) noexcept override;
+
+  void SetSpanKind(opentelemetry::trace::SpanKind span_kind) noexcept override;
+
+  void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept override;
+
+  void SetDuration(std::chrono::nanoseconds duration) noexcept override;
+
+  void SetInstrumentationLibrary(
+      const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary
+          &instrumentation_library) noexcept override;
+
+private:
+  void AddTag(const std::string &key, const std::string &value, std::vector<thrift::Tag> &tags);
+  void AddTag(const std::string &key, const char *value, std::vector<thrift::Tag> &tags);
+  void AddTag(const std::string &key, bool value, std::vector<thrift::Tag> &tags);
+  void AddTag(const std::string &key, int64_t value, std::vector<thrift::Tag> &tags);
+  void AddTag(const std::string &key, double value, std::vector<thrift::Tag> &tags);
+
+  void PopulateAttribute(nostd::string_view key,
+                         const opentelemetry::common::AttributeValue &value,
+                         std::vector<thrift::Tag> &tags);
+
+  void PopulateAttribute(nostd::string_view key,
+                         const sdk::common::OwnedAttributeValue &value,
+                         std::vector<thrift::Tag> &tags);
+
+private:
+  std::unique_ptr<thrift::Span> span_;
+  std::vector<thrift::Tag> tags_;
+  std::vector<thrift::Tag> resource_tags_;
+  std::vector<thrift::Log> logs_;
+  std::vector<thrift::SpanRef> references_;
+  std::string service_name_;
+};
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/THttpTransport.cc b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/THttpTransport.cc
new file mode 100644
index 000000000..cbb1b65cb
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/THttpTransport.cc
@@ -0,0 +1,61 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "THttpTransport.h"
+#include "opentelemetry/ext/http/client/http_client_factory.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+THttpTransport::THttpTransport(std::string endpoint, ext::http::client::Headers extra_headers)
+    : endpoint(std::move(endpoint)),
+      headers(std::move(extra_headers)),
+      client(ext::http::client::HttpClientFactory::CreateSync())
+{
+  headers.insert({{"Content-Type", "application/vnd.apache.thrift.binary"}});
+}
+
+THttpTransport::~THttpTransport() {}
+
+bool THttpTransport::isOpen() const
+{
+  return true;
+}
+
+uint32_t THttpTransport::read(uint8_t *buf, uint32_t len)
+{
+  (void)buf;
+  (void)len;
+  return 0;
+}
+
+void THttpTransport::write(const uint8_t *buf, uint32_t len)
+{
+  request_buffer.insert(request_buffer.end(), buf, buf + len);
+}
+
+bool THttpTransport::sendSpans()
+{
+  auto result = client->Post(endpoint, request_buffer, headers);
+  request_buffer.clear();
+
+  // TODO: Add logging once global log handling is available.
+  if (!result)
+  {
+    return false;
+  }
+
+  if (result.GetResponse().GetStatusCode() >= 400)
+  {
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/THttpTransport.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/THttpTransport.h
new file mode 100644
index 000000000..9c796e67a
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/THttpTransport.h
@@ -0,0 +1,40 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <opentelemetry/ext/http/client/http_client.h>
+#include <opentelemetry/version.h>
+
+#include <thrift/transport/TVirtualTransport.h>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+class THttpTransport : public apache::thrift::transport::TVirtualTransport<THttpTransport>
+{
+public:
+  THttpTransport(std::string endpoint, ext::http::client::Headers extra_headers);
+  ~THttpTransport() override;
+
+  bool isOpen() const override;
+
+  uint32_t read(uint8_t *buf, uint32_t len);
+
+  void write(const uint8_t *buf, uint32_t len);
+
+  bool sendSpans();
+
+private:
+  std::string endpoint;
+  ext::http::client::Headers headers;
+  std::shared_ptr<ext::http::client::HttpClientSync> client;
+  std::vector<uint8_t> request_buffer;
+};
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/TUDPTransport.cc b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/TUDPTransport.cc
new file mode 100644
index 000000000..e41112739
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/TUDPTransport.cc
@@ -0,0 +1,113 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <sstream>  // std::stringstream
+
+#include "TUDPTransport.h"
+#include "opentelemetry/sdk_config.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+TUDPTransport::TUDPTransport(const std::string &host, int port)
+    : host_(host), port_(port), socket_(THRIFT_INVALID_SOCKET)
+{}
+
+TUDPTransport::~TUDPTransport()
+{
+  if (server_addr_info_)
+  {
+    freeaddrinfo(server_addr_info_);
+    server_addr_info_ = nullptr;
+    sockaddr_len      = 0;
+  }
+  close();
+}
+
+bool TUDPTransport::isOpen() const
+{
+  return (socket_ != THRIFT_INVALID_SOCKET);
+}
+
+void TUDPTransport::open()
+{
+  if (isOpen())
+  {
+    return;
+  }
+
+  struct addrinfo hints;
+  int error;
+  char port[sizeof("65535") + 1];
+
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family   = AF_UNSPEC;
+  hints.ai_socktype = SOCK_DGRAM;
+  hints.ai_flags    = AI_PASSIVE | AI_ADDRCONFIG;
+
+  sprintf(port, "%d", port_);
+
+  error = getaddrinfo(host_.c_str(), port, &hints, &server_addr_info_);
+
+  if (error)
+  {
+    OTEL_INTERNAL_LOG_ERROR("Jaeger Exporter: getaddrinfo failed with error: " << error);
+    return;
+  }
+
+  socket_      = socket(server_addr_info_->ai_family, server_addr_info_->ai_socktype,
+                   server_addr_info_->ai_protocol);
+  sockaddr_len = server_addr_info_->ai_addr->sa_family == AF_INET ? sizeof(struct sockaddr_in)
+                                                                  : sizeof(struct sockaddr_in6);
+}
+
+void TUDPTransport::close()
+{
+  if (socket_ != THRIFT_INVALID_SOCKET)
+  {
+    ::THRIFT_CLOSESOCKET(socket_);
+  }
+  socket_ = THRIFT_INVALID_SOCKET;
+}
+
+uint32_t TUDPTransport::read(uint8_t *buf, uint32_t len)
+{
+  if (!server_addr_info_)
+  {
+    return 0;
+  }
+  uint32_t num_read = recvfrom(socket_,
+#if defined(_WIN32)
+                               reinterpret_cast<char *>(buf), len, 0, server_addr_info_->ai_addr,
+                               reinterpret_cast<int *>(&sockaddr_len)
+#else
+                               buf, len, 0, server_addr_info_->ai_addr, &sockaddr_len
+#endif
+  );
+
+  return num_read;
+}
+
+void TUDPTransport::write(const uint8_t *buf, uint32_t len)
+{
+  if (!server_addr_info_)
+  {
+    return;
+  }
+  sendto(socket_,
+#if defined(_WIN32)
+         reinterpret_cast<const char *>(buf),
+#else
+         buf,
+#endif
+         len, 0, server_addr_info_->ai_addr, sockaddr_len);
+}
+
+void TUDPTransport::flush() {}
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/TUDPTransport.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/TUDPTransport.h
new file mode 100644
index 000000000..df3151d11
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/TUDPTransport.h
@@ -0,0 +1,53 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#ifdef _WIN32
+#  include <winsock2.h>
+#else
+#  include <netdb.h>
+#  include <string.h>
+#  include <sys/socket.h>
+#  include <sys/types.h>
+#endif
+
+#include <opentelemetry/version.h>
+#include <thrift/transport/PlatformSocket.h>
+#include <thrift/transport/TVirtualTransport.h>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+class TUDPTransport : public apache::thrift::transport::TVirtualTransport<TUDPTransport>
+{
+public:
+  TUDPTransport(const std::string &host, int port);
+  ~TUDPTransport() override;
+
+  bool isOpen() const override;
+
+  void open() override;
+
+  void close() override;
+
+  uint32_t read(uint8_t *buf, uint32_t len);
+
+  void write(const uint8_t *buf, uint32_t len);
+
+  void flush() override;
+
+private:
+  std::string host_;
+  int port_;
+  THRIFT_SOCKET socket_;
+  struct addrinfo *server_addr_info_ = nullptr;
+  uint32_t sockaddr_len              = 0;
+};
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/http_transport.cc b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/http_transport.cc
new file mode 100644
index 000000000..f804ccc84
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/http_transport.cc
@@ -0,0 +1,37 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "http_transport.h"
+
+#include <thrift/protocol/TBinaryProtocol.h>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+using TBinaryProtocol = apache::thrift::protocol::TBinaryProtocol;
+using TTransport      = apache::thrift::transport::TTransport;
+
+HttpTransport::HttpTransport(std::string endpoint, ext::http::client::Headers headers)
+{
+  endpoint_transport_ = std::make_shared<THttpTransport>(std::move(endpoint), std::move(headers));
+  protocol_           = std::shared_ptr<TProtocol>(new TBinaryProtocol(endpoint_transport_));
+}
+
+int HttpTransport::EmitBatch(const thrift::Batch &batch)
+{
+  batch.write(protocol_.get());
+
+  if (!endpoint_transport_->sendSpans())
+  {
+    return 0;
+  }
+
+  return static_cast<int>(batch.spans.size());
+}
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/http_transport.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/http_transport.h
new file mode 100644
index 000000000..8f5c9c057
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/http_transport.h
@@ -0,0 +1,39 @@
+#pragma once
+
+#include "THttpTransport.h"
+#include "transport.h"
+
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+#include <memory>
+#include <string>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+using TProtocol = apache::thrift::protocol::TProtocol;
+
+class HttpTransport : public Transport
+{
+public:
+  HttpTransport(std::string endpoint, ext::http::client::Headers headers);
+
+  int EmitBatch(const thrift::Batch &batch) override;
+
+  uint32_t MaxPacketSize() const override
+  {
+    // Default to 4 MiB POST body size.
+    return 1 << 22;
+  }
+
+private:
+  std::shared_ptr<THttpTransport> endpoint_transport_;
+  std::shared_ptr<TProtocol> protocol_;
+};
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/jaeger_exporter.cc b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/jaeger_exporter.cc
new file mode 100644
index 000000000..c07f2f010
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/jaeger_exporter.cc
@@ -0,0 +1,111 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <agent_types.h>
+#include <opentelemetry/exporters/jaeger/jaeger_exporter.h>
+#include <opentelemetry/exporters/jaeger/recordable.h>
+#include "opentelemetry/sdk_config.h"
+
+#include "http_transport.h"
+#include "thrift_sender.h"
+#include "udp_transport.h"
+
+#include <mutex>
+#include <vector>
+
+namespace sdk_common = opentelemetry::sdk::common;
+namespace trace_sdk  = opentelemetry::sdk::trace;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+JaegerExporter::JaegerExporter(const JaegerExporterOptions &options) : options_(options)
+{
+  InitializeEndpoint();
+}
+
+JaegerExporter::JaegerExporter() : JaegerExporter(JaegerExporterOptions()) {}
+
+JaegerExporter::JaegerExporter(std::unique_ptr<ThriftSender> sender)
+    : options_(JaegerExporterOptions()), sender_(std::move(sender))
+{}
+
+std::unique_ptr<trace_sdk::Recordable> JaegerExporter::MakeRecordable() noexcept
+{
+  return std::unique_ptr<sdk::trace::Recordable>(new JaegerRecordable);
+}
+
+sdk_common::ExportResult JaegerExporter::Export(
+    const nostd::span<std::unique_ptr<sdk::trace::Recordable>> &spans) noexcept
+{
+  if (isShutdown())
+  {
+    OTEL_INTERNAL_LOG_ERROR("[Jaeger Trace Exporter] Exporting "
+                            << spans.size() << " span(s) failed, exporter is shutdown");
+    return sdk_common::ExportResult::kFailure;
+  }
+
+  std::size_t exported_size = 0;
+
+  for (auto &recordable : spans)
+  {
+    auto rec =
+        std::unique_ptr<JaegerRecordable>(static_cast<JaegerRecordable *>(recordable.release()));
+    if (rec != nullptr)
+    {
+      exported_size += sender_->Append(std::move(rec));
+    }
+  }
+
+  exported_size += sender_->Flush();
+
+  if (exported_size == 0)
+  {
+    return sdk_common::ExportResult::kFailure;
+  }
+
+  return sdk_common::ExportResult::kSuccess;
+}
+
+void JaegerExporter::InitializeEndpoint()
+{
+  if (options_.transport_format == TransportFormat::kThriftUdpCompact)
+  {
+    // TODO: do we need support any authentication mechanism?
+    auto transport = std::unique_ptr<Transport>(
+        static_cast<Transport *>(new UDPTransport(options_.endpoint, options_.server_port)));
+    sender_ = std::unique_ptr<ThriftSender>(new ThriftSender(std::move(transport)));
+    return;
+  }
+
+  if (options_.transport_format == TransportFormat::kThriftHttp)
+  {
+    auto transport =
+        std::unique_ptr<HttpTransport>(new HttpTransport(options_.endpoint, options_.headers));
+    sender_ = std::unique_ptr<ThriftSender>(new ThriftSender(std::move(transport)));
+    return;
+  }
+
+  // The transport format is not implemented.
+  assert(false);
+}
+
+bool JaegerExporter::Shutdown(std::chrono::microseconds timeout) noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  is_shutdown_ = true;
+  return true;
+}
+
+bool JaegerExporter::isShutdown() const noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  return is_shutdown_;
+}
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/recordable.cc b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/recordable.cc
new file mode 100644
index 000000000..c4a61a5d2
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/recordable.cc
@@ -0,0 +1,365 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/exporters/jaeger/recordable.h"
+#include "opentelemetry/sdk/common/global_log_handler.h"
+#include "opentelemetry/sdk/resource/experimental_semantic_conventions.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+using namespace opentelemetry::sdk::resource;
+namespace trace_api = opentelemetry::trace;
+
+JaegerRecordable::JaegerRecordable() : span_{new thrift::Span} {}
+
+void JaegerRecordable::PopulateAttribute(nostd::string_view key,
+                                         const common::AttributeValue &value,
+                                         std::vector<thrift::Tag> &tags)
+{
+  if (nostd::holds_alternative<int32_t>(value))
+  {
+    AddTag(std::string{key}, int64_t{nostd::get<int32_t>(value)}, tags);
+  }
+  else if (nostd::holds_alternative<uint32_t>(value))
+  {
+    AddTag(std::string{key}, int64_t{nostd::get<uint32_t>(value)}, tags);
+  }
+  else if (nostd::holds_alternative<int64_t>(value))
+  {
+    AddTag(std::string{key}, nostd::get<int64_t>(value), tags);
+  }
+  else if (nostd::holds_alternative<bool>(value))
+  {
+    AddTag(std::string{key}, nostd::get<bool>(value), tags);
+  }
+  else if (nostd::holds_alternative<double>(value))
+  {
+    AddTag(std::string{key}, nostd::get<double>(value), tags);
+  }
+  else if (nostd::holds_alternative<const char *>(value))
+  {
+    AddTag(std::string{key}, std::string{nostd::get<const char *>(value)}, tags);
+  }
+  else if (nostd::holds_alternative<nostd::string_view>(value))
+  {
+    AddTag(std::string{key}, std::string{nostd::get<nostd::string_view>(value)}, tags);
+  }
+  else if (nostd::holds_alternative<nostd::span<const bool>>(value))
+  {
+    for (const auto &val : nostd::get<nostd::span<const bool>>(value))
+    {
+      AddTag(std::string{key}, val, tags);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const int32_t>>(value))
+  {
+    for (const auto &val : nostd::get<nostd::span<const int32_t>>(value))
+    {
+      AddTag(std::string{key}, int64_t{val}, tags);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const int64_t>>(value))
+  {
+    for (const auto &val : nostd::get<nostd::span<const int64_t>>(value))
+    {
+      AddTag(std::string{key}, val, tags);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const uint32_t>>(value))
+  {
+    for (const auto &val : nostd::get<nostd::span<const uint32_t>>(value))
+    {
+      AddTag(std::string{key}, int64_t{val}, tags);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const double>>(value))
+  {
+    for (const auto &val : nostd::get<nostd::span<const double>>(value))
+    {
+      AddTag(std::string{key}, val, tags);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const nostd::string_view>>(value))
+  {
+    for (const auto &val : nostd::get<nostd::span<const nostd::string_view>>(value))
+    {
+      AddTag(std::string{key}, std::string{val}, tags);
+    }
+  }
+  else
+  {
+    OTEL_INTERNAL_LOG_ERROR(
+        "[TRACE JAEGER Exporter] SetAttribute() failed, attribute type not supported ");
+  }
+}
+
+void JaegerRecordable::PopulateAttribute(nostd::string_view key,
+                                         const sdk::common::OwnedAttributeValue &value,
+                                         std::vector<thrift::Tag> &tags)
+{
+  if (nostd::holds_alternative<int32_t>(value))
+  {
+    AddTag(std::string{key}, int64_t{nostd::get<int32_t>(value)}, tags);
+  }
+  else if (nostd::holds_alternative<uint32_t>(value))
+  {
+    AddTag(std::string{key}, int64_t{nostd::get<uint32_t>(value)}, tags);
+  }
+  else if (nostd::holds_alternative<int64_t>(value))
+  {
+    AddTag(std::string{key}, nostd::get<int64_t>(value), tags);
+  }
+  else if (nostd::holds_alternative<bool>(value))
+  {
+    AddTag(std::string{key}, nostd::get<bool>(value), tags);
+  }
+  else if (nostd::holds_alternative<double>(value))
+  {
+    AddTag(std::string{key}, nostd::get<double>(value), tags);
+  }
+  else if (nostd::holds_alternative<std::string>(value))
+  {
+    AddTag(std::string{key}, std::string{nostd::get<std::string>(value)}, tags);
+  }
+  else
+  {
+    OTEL_INTERNAL_LOG_ERROR(
+        "[TRACE JAEGER Exporter] SetAttribute() failed, attribute type not supported ");
+  }
+}
+
+void JaegerRecordable::SetIdentity(const trace::SpanContext &span_context,
+                                   trace::SpanId parent_span_id) noexcept
+{
+  // IDs should be converted to big endian before transmission.
+  // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/sdk_exporters/jaeger.md#ids
+#if JAEGER_IS_LITTLE_ENDIAN == 1
+  span_->__set_traceIdHigh(
+      otel_bswap_64(*(reinterpret_cast<const int64_t *>(span_context.trace_id().Id().data()))));
+  span_->__set_traceIdLow(
+      otel_bswap_64(*(reinterpret_cast<const int64_t *>(span_context.trace_id().Id().data()) + 1)));
+  span_->__set_spanId(
+      otel_bswap_64(*(reinterpret_cast<const int64_t *>(span_context.span_id().Id().data()))));
+  span_->__set_parentSpanId(
+      otel_bswap_64(*(reinterpret_cast<const int64_t *>(parent_span_id.Id().data()))));
+#else
+  span_->__set_traceIdLow(
+      *(reinterpret_cast<const int64_t *>(span_context.trace_id().Id().data())));
+  span_->__set_traceIdHigh(
+      *(reinterpret_cast<const int64_t *>(span_context.trace_id().Id().data()) + 1));
+  span_->__set_spanId(*(reinterpret_cast<const int64_t *>(span_context.span_id().Id().data())));
+  span_->__set_parentSpanId(*(reinterpret_cast<const int64_t *>(parent_span_id.Id().data())));
+#endif
+
+  // TODO: set trace_state.
+}
+
+void JaegerRecordable::SetAttribute(nostd::string_view key,
+                                    const common::AttributeValue &value) noexcept
+{
+  PopulateAttribute(key, value, tags_);
+}
+
+void JaegerRecordable::AddEvent(nostd::string_view name,
+                                common::SystemTimestamp timestamp,
+                                const common::KeyValueIterable &attributes) noexcept
+{
+  std::vector<thrift::Tag> tags;
+  PopulateAttribute("event", static_cast<common::AttributeValue>(name.data()), tags);
+
+  attributes.ForEachKeyValue([&](nostd::string_view key, common::AttributeValue value) noexcept {
+    PopulateAttribute(key, value, tags);
+    return true;
+  });
+  thrift::Log log;
+  log.__set_fields(tags);
+  log.__set_timestamp(
+      std::chrono::duration_cast<std::chrono::microseconds>(timestamp.time_since_epoch()).count());
+  logs_.push_back(log);
+}
+
+void JaegerRecordable::SetInstrumentationLibrary(
+    const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary
+        &instrumentation_library) noexcept
+{
+  AddTag("otel.library.name", instrumentation_library.GetName(), tags_);
+  AddTag("otel.library.version", instrumentation_library.GetVersion(), tags_);
+}
+
+void JaegerRecordable::AddLink(const trace::SpanContext &span_context,
+                               const common::KeyValueIterable &attributes) noexcept
+{
+  // Note: "The Link’s attributes cannot be represented in Jaeger explicitly."
+  // -- https://opentelemetry.io/docs/reference/specification/trace/sdk_exporters/jaeger/#links
+  //
+  // This implementation does not (currently) implement the optional conversion to span logs.
+
+  thrift::SpanRef reference;
+
+  reference.__set_refType(thrift::SpanRefType::FOLLOWS_FROM);
+
+  // IDs should be converted to big endian before transmission.
+  // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/trace/sdk_exporters/jaeger.md#ids
+#if JAEGER_IS_LITTLE_ENDIAN == 1
+  reference.__set_traceIdHigh(
+      otel_bswap_64(*(reinterpret_cast<const int64_t *>(span_context.trace_id().Id().data()))));
+  reference.__set_traceIdLow(
+      otel_bswap_64(*(reinterpret_cast<const int64_t *>(span_context.trace_id().Id().data()) + 1)));
+  reference.__set_spanId(
+      otel_bswap_64(*(reinterpret_cast<const int64_t *>(span_context.span_id().Id().data()))));
+#else
+  reference.__set_traceIdLow(
+      *(reinterpret_cast<const int64_t *>(span_context.trace_id().Id().data())));
+  reference.__set_traceIdHigh(
+      *(reinterpret_cast<const int64_t *>(span_context.trace_id().Id().data()) + 1));
+  reference.__set_spanId(*(reinterpret_cast<const int64_t *>(span_context.span_id().Id().data())));
+#endif
+
+  references_.push_back(reference);
+}
+
+void JaegerRecordable::SetStatus(trace::StatusCode code, nostd::string_view description) noexcept
+{
+  if (code == trace::StatusCode::kUnset)
+  {
+    return;
+  }
+
+  if (code == trace::StatusCode::kOk)
+  {
+    AddTag("otel.status_code", "OK", tags_);
+  }
+  else if (code == trace::StatusCode::kError)
+  {
+    AddTag("otel.status_code", "ERROR", tags_);
+    AddTag("error", true, tags_);
+  }
+
+  AddTag("otel.status_description", std::string{description}, tags_);
+}
+
+void JaegerRecordable::SetName(nostd::string_view name) noexcept
+{
+  span_->__set_operationName(static_cast<std::string>(name));
+}
+
+void JaegerRecordable::SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept
+{
+  for (const auto &attribute_iter : resource.GetAttributes())
+  {
+    if (attribute_iter.first != "service.name")
+    {
+      PopulateAttribute(nostd::string_view{attribute_iter.first}, attribute_iter.second,
+                        resource_tags_);
+    }
+    else
+    {
+      service_name_ = nostd::get<std::string>(attribute_iter.second);
+    }
+  }
+}
+
+void JaegerRecordable::SetStartTime(common::SystemTimestamp start_time) noexcept
+{
+  span_->__set_startTime(
+      std::chrono::duration_cast<std::chrono::microseconds>(start_time.time_since_epoch()).count());
+}
+
+void JaegerRecordable::SetDuration(std::chrono::nanoseconds duration) noexcept
+{
+  span_->__set_duration(std::chrono::duration_cast<std::chrono::microseconds>(duration).count());
+}
+
+void JaegerRecordable::SetSpanKind(trace::SpanKind span_kind) noexcept
+{
+  const char *span_kind_str = nullptr;
+
+  // map SpanKind to Jaeger tag span.kind.
+  switch (span_kind)
+  {
+    case trace_api::SpanKind::kClient: {
+      span_kind_str = "client";
+      break;
+    }
+    case trace_api::SpanKind::kServer: {
+      span_kind_str = "server";
+      break;
+    }
+    case trace_api::SpanKind::kConsumer: {
+      span_kind_str = "consumer";
+      break;
+    }
+    case trace_api::SpanKind::kProducer: {
+      span_kind_str = "producer";
+      break;
+    }
+    default:
+      break;
+  }
+
+  if (span_kind_str != nullptr)
+  {
+    AddTag("span.kind", span_kind_str, tags_);
+  }
+}
+
+void JaegerRecordable::AddTag(const std::string &key,
+                              const std::string &value,
+                              std::vector<thrift::Tag> &tags)
+{
+  thrift::Tag tag;
+
+  tag.__set_key(key);
+  tag.__set_vType(thrift::TagType::STRING);
+  tag.__set_vStr(value);
+
+  tags.push_back(tag);
+}
+
+void JaegerRecordable::AddTag(const std::string &key,
+                              const char *value,
+                              std::vector<thrift::Tag> &tags)
+{
+  AddTag(key, std::string{value}, tags);
+}
+
+void JaegerRecordable::AddTag(const std::string &key, bool value, std::vector<thrift::Tag> &tags)
+{
+  thrift::Tag tag;
+
+  tag.__set_key(key);
+  tag.__set_vType(thrift::TagType::BOOL);
+  tag.__set_vBool(value);
+
+  tags.push_back(tag);
+}
+
+void JaegerRecordable::AddTag(const std::string &key, int64_t value, std::vector<thrift::Tag> &tags)
+{
+  thrift::Tag tag;
+
+  tag.__set_key(key);
+  tag.__set_vType(thrift::TagType::LONG);
+  tag.__set_vLong(value);
+
+  tags.push_back(tag);
+}
+
+void JaegerRecordable::AddTag(const std::string &key, double value, std::vector<thrift::Tag> &tags)
+{
+  thrift::Tag tag;
+
+  tag.__set_key(key);
+  tag.__set_vType(thrift::TagType::DOUBLE);
+  tag.__set_vDouble(value);
+
+  tags.push_back(tag);
+}
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/sender.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/sender.h
new file mode 100644
index 000000000..f4827b550
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/sender.h
@@ -0,0 +1,32 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <opentelemetry/exporters/jaeger/recordable.h>
+#include <opentelemetry/version.h>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+using namespace jaegertracing;
+
+class Sender
+{
+public:
+  Sender()          = default;
+  virtual ~Sender() = default;
+
+  virtual int Append(std::unique_ptr<JaegerRecordable> &&span) = 0;
+
+  virtual int Flush() = 0;
+
+  virtual void Close() = 0;
+};
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/thrift_sender.cc b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/thrift_sender.cc
new file mode 100644
index 000000000..46f0dcd5a
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/thrift_sender.cc
@@ -0,0 +1,99 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "thrift_sender.h"
+#include <opentelemetry/exporters/jaeger/recordable.h>
+#include "opentelemetry/sdk/common/global_log_handler.h"
+#include "udp_transport.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+using namespace jaegertracing;
+
+ThriftSender::ThriftSender(std::unique_ptr<Transport> &&transport)
+    : transport_(std::move(transport)),
+      protocol_factory_(new apache::thrift::protocol::TCompactProtocolFactory()),
+      thrift_buffer_(new apache::thrift::transport::TMemoryBuffer(transport_->MaxPacketSize()))
+{}
+
+int ThriftSender::Append(std::unique_ptr<JaegerRecordable> &&span) noexcept
+{
+  if (span == nullptr)
+  {
+    return 0;
+  }
+
+  uint32_t max_span_bytes = transport_->MaxPacketSize() - kEmitBatchOverhead;
+  if (process_.serviceName.empty())
+  {
+    process_.serviceName = span->ServiceName();
+    process_.__set_tags(span->ResourceTags());
+
+    process_bytes_size_ = CalcSizeOfSerializedThrift(process_);
+    max_span_bytes -= process_bytes_size_;
+  }
+
+  auto jaeger_span = std::unique_ptr<thrift::Span>(span->Span());
+  jaeger_span->__set_tags(span->Tags());
+  jaeger_span->__set_logs(span->Logs());
+  jaeger_span->__set_references(span->References());
+
+  const uint32_t span_size = CalcSizeOfSerializedThrift(*jaeger_span);
+  if (span_size > max_span_bytes)
+  {
+    OTEL_INTERNAL_LOG_ERROR("[JAEGER TRACE Exporter] Append() failed: too large span");
+    return 0;
+  }
+
+  byte_buffer_size_ += span_size;
+  if (byte_buffer_size_ <= max_span_bytes)
+  {
+    span_buffer_.push_back(*jaeger_span);
+    if (byte_buffer_size_ < max_span_bytes)
+    {
+      return 0;
+    }
+    else
+    {
+      // byte buffer is full so flush it before appending new span.
+      return Flush();
+    }
+  }
+
+  const auto flushed = Flush();
+  span_buffer_.push_back(*jaeger_span);
+  byte_buffer_size_ = span_size + process_bytes_size_;
+
+  return flushed;
+}
+
+int ThriftSender::Flush()
+{
+  if (span_buffer_.empty())
+  {
+    return 0;
+  }
+
+  thrift::Batch batch;
+  batch.__set_process(process_);
+  batch.__set_spans(span_buffer_);
+
+  int spans_flushed = transport_->EmitBatch(batch);
+
+  ResetBuffers();
+
+  return spans_flushed;
+}
+
+void ThriftSender::Close()
+{
+  Flush();
+}
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/thrift_sender.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/thrift_sender.h
new file mode 100644
index 000000000..0ec8d47f1
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/thrift_sender.h
@@ -0,0 +1,78 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <Agent.h>
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <vector>
+
+#include <thrift/protocol/TCompactProtocol.h>
+#include <thrift/transport/TBufferTransports.h>
+
+#include "sender.h"
+#include "transport.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+using namespace jaegertracing;
+
+class ThriftSender : public Sender
+{
+public:
+  static constexpr uint32_t kEmitBatchOverhead = 30;
+
+  ThriftSender(std::unique_ptr<Transport> &&transport);
+  ~ThriftSender() override { Close(); }
+
+  int Append(std::unique_ptr<JaegerRecordable> &&span) noexcept override;
+  int Flush() override;
+  void Close() override;
+
+private:
+  void ResetBuffers()
+  {
+    span_buffer_.clear();
+    byte_buffer_size_ = process_bytes_size_;
+  }
+
+  template <typename ThriftType>
+  uint32_t CalcSizeOfSerializedThrift(const ThriftType &base)
+  {
+    uint8_t *data = nullptr;
+    uint32_t size = 0;
+
+    thrift_buffer_->resetBuffer();
+    auto protocol = protocol_factory_->getProtocol(thrift_buffer_);
+    base.write(protocol.get());
+    thrift_buffer_->getBuffer(&data, &size);
+    return size;
+  }
+
+private:
+  std::vector<std::unique_ptr<JaegerRecordable>> spans_;
+  std::vector<thrift::Span> span_buffer_;
+  std::unique_ptr<Transport> transport_;
+  std::unique_ptr<apache::thrift::protocol::TProtocolFactory> protocol_factory_;
+  std::shared_ptr<apache::thrift::transport::TMemoryBuffer> thrift_buffer_;
+  thrift::Process process_;
+
+  // Size in bytes of the serialization buffer.
+  uint32_t byte_buffer_size_   = 0;
+  uint32_t process_bytes_size_ = 0;
+  uint32_t max_span_bytes_     = 0;
+  friend class MockThriftSender;
+
+protected:
+  ThriftSender() = default;
+};
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/transport.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/transport.h
new file mode 100644
index 000000000..8121e3007
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/transport.h
@@ -0,0 +1,30 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <opentelemetry/version.h>
+
+#include <jaeger_types.h>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+using namespace jaegertracing;
+
+class Transport
+{
+public:
+  Transport()          = default;
+  virtual ~Transport() = default;
+
+  virtual int EmitBatch(const thrift::Batch &batch) = 0;
+  virtual uint32_t MaxPacketSize() const            = 0;
+};
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/udp_transport.cc b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/udp_transport.cc
new file mode 100644
index 000000000..9b1fe0caf
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/udp_transport.cc
@@ -0,0 +1,86 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <sstream>  // std::stringstream
+
+#include "opentelemetry/sdk_config.h"
+#include "udp_transport.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+UDPTransport::UDPTransport(const std::string &addr, uint16_t port)
+    : max_packet_size_(kUDPPacketMaxLength)
+{
+  InitSocket();
+
+  endpoint_transport_ = std::shared_ptr<TTransport>(new TUDPTransport(addr, port));
+  endpoint_transport_->open();
+  transport_ =
+      std::shared_ptr<TTransport>(new TBufferedTransport(endpoint_transport_, max_packet_size_));
+  protocol_ = std::shared_ptr<TProtocol>(new TCompactProtocol(transport_));
+  agent_    = std::unique_ptr<AgentClient>(new AgentClient(protocol_));
+}
+
+UDPTransport::~UDPTransport()
+{
+  CleanSocket();
+}
+
+void UDPTransport::InitSocket()
+{
+#if defined(_WIN32)
+  /* Use the MAKEWORD(lowbyte, highbyte) macro declared in Windef.h */
+  WORD wVersionRequested = MAKEWORD(2, 2);
+
+  WSADATA wsaData;
+  int err = WSAStartup(wVersionRequested, &wsaData);
+  if (err != 0)
+  {
+    OTEL_INTERNAL_LOG_ERROR("Jaeger Exporter: WSAStartup failed with error: " << err);
+    return;
+  }
+
+  /* Confirm that the WinSock DLL supports 2.2.        */
+  /* Note that if the DLL supports versions greater    */
+  /* than 2.2 in addition to 2.2, it will still return */
+  /* 2.2 in wVersion since that is the version we      */
+  /* requested.                                        */
+
+  if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2)
+  {
+    OTEL_INTERNAL_LOG_ERROR("Jaeger Exporter: winsock " << LOBYTE(wsaData.wVersion) << "."
+                                                        << HIBYTE(wsaData.wVersion)
+                                                        << " is not supported.");
+    WSACleanup();
+
+    return;
+  }
+#endif
+}
+
+void UDPTransport::CleanSocket()
+{
+#if defined(_WIN32)
+  WSACleanup();
+#endif
+}
+
+int UDPTransport::EmitBatch(const thrift::Batch &batch)
+{
+  try
+  {
+    agent_->emitBatch(batch);
+  }
+  catch (...)
+  {}
+
+  return static_cast<int>(batch.spans.size());
+}
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/udp_transport.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/udp_transport.h
new file mode 100644
index 000000000..0997a27c6
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/src/udp_transport.h
@@ -0,0 +1,57 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "TUDPTransport.h"
+#include "transport.h"
+
+#include <Agent.h>
+#include <thrift/protocol/TBinaryProtocol.h>
+#include <thrift/protocol/TCompactProtocol.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TBufferTransports.h>
+#include <thrift/transport/TSocket.h>
+#include <thrift/transport/TTransport.h>
+#include <memory>
+#include <string>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+using AgentClient        = jaegertracing::agent::thrift::AgentClient;
+using TBinaryProtocol    = apache::thrift::protocol::TBinaryProtocol;
+using TCompactProtocol   = apache::thrift::protocol::TCompactProtocol;
+using TBufferedTransport = apache::thrift::transport::TBufferedTransport;
+using TProtocol          = apache::thrift::protocol::TProtocol;
+using TTransport         = apache::thrift::transport::TTransport;
+
+class UDPTransport : public Transport
+{
+public:
+  static constexpr auto kUDPPacketMaxLength = 65000;
+
+  UDPTransport(const std::string &addr, uint16_t port);
+  virtual ~UDPTransport();
+
+  int EmitBatch(const thrift::Batch &batch) override;
+
+  uint32_t MaxPacketSize() const override { return max_packet_size_; }
+
+  void InitSocket();
+  void CleanSocket();
+
+private:
+  std::unique_ptr<AgentClient> agent_;
+  std::shared_ptr<TTransport> endpoint_transport_;
+  std::shared_ptr<TTransport> transport_;
+  std::shared_ptr<TProtocol> protocol_;
+  uint32_t max_packet_size_;
+};
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/test/jaeger_exporter_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/test/jaeger_exporter_test.cc
new file mode 100644
index 000000000..7f86f877b
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/test/jaeger_exporter_test.cc
@@ -0,0 +1,175 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <opentelemetry/exporters/jaeger/jaeger_exporter.h>
+#include <memory>
+#include <vector>
+#include "opentelemetry/sdk/trace/batch_span_processor.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
+
+#ifdef BAZEL_BUILD
+#  include "exporters/jaeger/src/thrift_sender.h"
+#else
+#  include "thrift_sender.h"
+#endif
+
+#include <gtest/gtest.h>
+#include "gmock/gmock.h"
+
+namespace trace      = opentelemetry::trace;
+namespace nostd      = opentelemetry::nostd;
+namespace sdktrace   = opentelemetry::sdk::trace;
+namespace common     = opentelemetry::common;
+namespace sdk_common = opentelemetry::sdk::common;
+
+using namespace testing;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace jaeger
+{
+
+namespace trace_api = opentelemetry::trace;
+namespace resource  = opentelemetry::sdk::resource;
+
+template <class T, size_t N>
+static nostd::span<T, N> MakeSpan(T (&array)[N])
+{
+  return nostd::span<T, N>(array);
+}
+
+class JaegerExporterTestPeer : public ::testing::Test
+{
+public:
+  std::unique_ptr<sdk::trace::SpanExporter> GetExporter(std::unique_ptr<ThriftSender> sender)
+  {
+    return std::unique_ptr<sdk::trace::SpanExporter>(new JaegerExporter(std::move(sender)));
+  }
+
+  // Get the options associated with the given exporter.
+  const JaegerExporterOptions &GetOptions(std::unique_ptr<JaegerExporter> &exporter)
+  {
+    return exporter->options_;
+  }
+};
+
+class MockThriftSender : public ThriftSender
+{
+public:
+  MOCK_METHOD(int, Append, (std::unique_ptr<JaegerRecordable> &&), (noexcept, override));
+};
+
+class MockTransport : public Transport
+{
+public:
+  MOCK_METHOD(int, EmitBatch, (const thrift::Batch &), (override));
+  MOCK_METHOD(uint32_t, MaxPacketSize, (), (const, override));
+};
+
+// Create spans, let processor call Export()
+TEST_F(JaegerExporterTestPeer, ExportIntegrationTest)
+{
+  auto mock_transport     = new MockTransport;
+  auto mock_thrift_sender = new ThriftSender(std::unique_ptr<MockTransport>{mock_transport});
+  auto exporter           = GetExporter(std::unique_ptr<ThriftSender>{mock_thrift_sender});
+
+  resource::ResourceAttributes resource_attributes = {{"service.name", "unit_test_service"},
+                                                      {"tenant.id", "test_user"}};
+  resource_attributes["bool_value"]                = true;
+  resource_attributes["int32_value"]               = static_cast<int32_t>(1);
+  resource_attributes["uint32_value"]              = static_cast<uint32_t>(2);
+  resource_attributes["int64_value"]               = static_cast<int64_t>(0x1100000000LL);
+  resource_attributes["double_value"]              = static_cast<double>(3.1);
+  auto resource = resource::Resource::Create(resource_attributes);
+
+  auto processor_opts                  = sdk::trace::BatchSpanProcessorOptions();
+  processor_opts.max_export_batch_size = 5;
+  processor_opts.max_queue_size        = 5;
+  processor_opts.schedule_delay_millis = std::chrono::milliseconds(256);
+  auto processor                       = std::unique_ptr<sdk::trace::SpanProcessor>(
+      new sdk::trace::BatchSpanProcessor(std::move(exporter), processor_opts));
+  auto provider = nostd::shared_ptr<trace::TracerProvider>(
+      new sdk::trace::TracerProvider(std::move(processor), resource));
+
+  EXPECT_CALL(*mock_transport, EmitBatch(_)).Times(Exactly(1)).WillOnce(Return(1));
+
+  auto tracer      = provider->GetTracer("test");
+  auto parent_span = tracer->StartSpan("Test parent span");
+
+  trace_api::StartSpanOptions child_span_opts = {};
+  child_span_opts.parent                      = parent_span->GetContext();
+  auto child_span = tracer->StartSpan("Test child span", child_span_opts);
+
+  child_span->End();
+  parent_span->End();
+
+  auto parent_ctx = parent_span->GetContext();
+  auto child_ctx  = child_span->GetContext();
+  EXPECT_EQ(parent_ctx.trace_id(), child_ctx.trace_id());
+  EXPECT_EQ(parent_ctx.trace_state(), child_ctx.trace_state());
+  ASSERT_TRUE(parent_ctx.IsValid());
+  ASSERT_TRUE(child_ctx.IsValid());
+}
+
+TEST_F(JaegerExporterTestPeer, ShutdownTest)
+{
+  auto mock_thrift_sender = new MockThriftSender;
+  auto exporter           = GetExporter(std::unique_ptr<ThriftSender>{mock_thrift_sender});
+
+  auto recordable_1 = exporter->MakeRecordable();
+  recordable_1->SetName("Test span 1");
+  auto recordable_2 = exporter->MakeRecordable();
+  recordable_2->SetName("Test span 2");
+
+  // exporter shuold not be shutdown by default
+  nostd::span<std::unique_ptr<sdk::trace::Recordable>> batch_1(&recordable_1, 1);
+  EXPECT_CALL(*mock_thrift_sender, Append(_)).Times(Exactly(1)).WillOnce(Return(1));
+  auto result = exporter->Export(batch_1);
+  EXPECT_EQ(sdk_common::ExportResult::kSuccess, result);
+
+  exporter->Shutdown();
+
+  nostd::span<std::unique_ptr<sdk::trace::Recordable>> batch_2(&recordable_2, 1);
+  result = exporter->Export(batch_2);
+  EXPECT_EQ(sdk_common::ExportResult::kFailure, result);
+}
+
+// Call Export() directly
+TEST_F(JaegerExporterTestPeer, ExportTest)
+{
+  auto mock_thrift_sender = new MockThriftSender;
+  auto exporter           = GetExporter(std::unique_ptr<ThriftSender>{mock_thrift_sender});
+
+  auto recordable_1 = exporter->MakeRecordable();
+  recordable_1->SetName("Test span 1");
+  auto recordable_2 = exporter->MakeRecordable();
+  recordable_2->SetName("Test span 2");
+
+  // Test successful send
+  nostd::span<std::unique_ptr<sdk::trace::Recordable>> batch_1(&recordable_1, 1);
+  EXPECT_CALL(*mock_thrift_sender, Append(_)).Times(Exactly(1)).WillOnce(Return(1));
+  auto result = exporter->Export(batch_1);
+  EXPECT_EQ(sdk_common::ExportResult::kSuccess, result);
+
+  // Test failed send
+  nostd::span<std::unique_ptr<sdk::trace::Recordable>> batch_2(&recordable_2, 1);
+  EXPECT_CALL(*mock_thrift_sender, Append(_)).Times(Exactly(1)).WillOnce(Return(0));
+  result = exporter->Export(batch_2);
+  EXPECT_EQ(sdk::common::ExportResult::kFailure, result);
+}
+
+// Test exporter configuration options
+TEST_F(JaegerExporterTestPeer, ConfigTest)
+{
+  JaegerExporterOptions opts;
+  opts.endpoint    = "localhost";
+  opts.server_port = 6851;
+  std::unique_ptr<JaegerExporter> exporter(new JaegerExporter(opts));
+  EXPECT_EQ(GetOptions(exporter).endpoint, "localhost");
+  EXPECT_EQ(GetOptions(exporter).server_port, 6851);
+}
+
+}  // namespace jaeger
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/test/jaeger_recordable_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/test/jaeger_recordable_test.cc
new file mode 100644
index 000000000..4a0a1f74b
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/test/jaeger_recordable_test.cc
@@ -0,0 +1,334 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <vector>
+#include "opentelemetry/exporters/jaeger/recordable.h"
+#include "opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h"
+#include "opentelemetry/sdk/trace/simple_processor.h"
+#include "opentelemetry/sdk/trace/span_data.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
+#include "opentelemetry/trace/provider.h"
+
+#include <gtest/gtest.h>
+
+namespace trace    = opentelemetry::trace;
+namespace nostd    = opentelemetry::nostd;
+namespace sdktrace = opentelemetry::sdk::trace;
+namespace common   = opentelemetry::common;
+
+using namespace jaegertracing;
+using namespace opentelemetry::exporter::jaeger;
+using namespace opentelemetry::sdk::instrumentationlibrary;
+using std::vector;
+
+using Attributes = std::initializer_list<std::pair<nostd::string_view, common::AttributeValue>>;
+
+TEST(JaegerSpanRecordable, SetIdentity)
+{
+  JaegerRecordable rec;
+
+  int64_t trace_id_val[2]    = {0x0000000000000000, 0x1000000000000000};
+  int64_t span_id_val        = 0x2000000000000000;
+  int64_t parent_span_id_val = 0x3000000000000000;
+
+  const trace::TraceId trace_id{
+      nostd::span<uint8_t, 16>(reinterpret_cast<uint8_t *>(trace_id_val), 16)};
+
+  const trace::SpanId span_id(
+      nostd::span<uint8_t, 8>(reinterpret_cast<uint8_t *>(&span_id_val), 8));
+
+  const trace::SpanId parent_span_id(
+      nostd::span<uint8_t, 8>(reinterpret_cast<uint8_t *>(&parent_span_id_val), 8));
+
+  const trace::SpanContext span_context{trace_id, span_id,
+                                        trace::TraceFlags{trace::TraceFlags::kIsSampled}, true};
+  rec.SetIdentity(span_context, parent_span_id);
+
+  std::unique_ptr<thrift::Span> span{rec.Span()};
+
+#if JAEGER_IS_LITTLE_ENDIAN == 1
+  EXPECT_EQ(span->traceIdLow, otel_bswap_64(trace_id_val[1]));
+  EXPECT_EQ(span->traceIdHigh, otel_bswap_64(trace_id_val[0]));
+  EXPECT_EQ(span->spanId, otel_bswap_64(span_id_val));
+  EXPECT_EQ(span->parentSpanId, otel_bswap_64(parent_span_id_val));
+#else
+  EXPECT_EQ(span->traceIdLow, trace_id_val[0]);
+  EXPECT_EQ(span->traceIdHigh, trace_id_val[1]);
+  EXPECT_EQ(span->spanId, span_id_val);
+  EXPECT_EQ(span->parentSpanId, parent_span_id_val);
+#endif
+}
+
+TEST(JaegerSpanRecordable, SetName)
+{
+  JaegerRecordable rec;
+
+  nostd::string_view name = "Test Span";
+  rec.SetName(name);
+
+  std::unique_ptr<thrift::Span> span{rec.Span()};
+
+  EXPECT_EQ(span->operationName, name);
+}
+
+TEST(JaegerSpanRecordable, SetStartTime)
+{
+  JaegerRecordable rec;
+
+  std::chrono::system_clock::time_point start_time = std::chrono::system_clock::now();
+  common::SystemTimestamp start_timestamp(start_time);
+  uint64_t unix_start =
+      std::chrono::duration_cast<std::chrono::microseconds>(start_time.time_since_epoch()).count();
+  rec.SetStartTime(start_timestamp);
+
+  std::unique_ptr<thrift::Span> span{rec.Span()};
+
+  EXPECT_EQ(span->startTime, unix_start);
+}
+
+TEST(JaegerSpanRecordable, SetDuration)
+{
+  JaegerRecordable rec;
+
+  common::SystemTimestamp start_timestamp;
+
+  std::chrono::microseconds duration(10);
+  uint64_t unix_end = duration.count();
+
+  rec.SetStartTime(start_timestamp);
+  rec.SetDuration(duration);
+
+  std::unique_ptr<thrift::Span> span{rec.Span()};
+
+  EXPECT_EQ(span->startTime, 0);
+  EXPECT_EQ(span->duration, unix_end);
+}
+
+TEST(JaegerSpanRecordable, SetStatus)
+{
+  JaegerRecordable rec;
+
+  const char *error_description = "Error test";
+  rec.SetStatus(trace::StatusCode::kError, error_description);
+
+  auto tags = rec.Tags();
+  EXPECT_EQ(tags.size(), 3);
+
+  EXPECT_EQ(tags[0].key, "otel.status_code");
+  EXPECT_EQ(tags[0].vType, thrift::TagType::STRING);
+  EXPECT_EQ(tags[0].vStr, "ERROR");
+
+  EXPECT_EQ(tags[1].key, "error");
+  EXPECT_EQ(tags[1].vType, thrift::TagType::BOOL);
+  EXPECT_EQ(tags[1].vBool, true);
+
+  EXPECT_EQ(tags[2].key, "otel.status_description");
+  EXPECT_EQ(tags[2].vType, thrift::TagType::STRING);
+  EXPECT_EQ(tags[2].vStr, error_description);
+}
+
+TEST(JaegerSpanRecordable, AddEvent)
+{
+  JaegerRecordable rec;
+
+  std::chrono::system_clock::time_point event_time = std::chrono::system_clock::now();
+  common::SystemTimestamp event_timestamp(event_time);
+  uint64_t epoch_us =
+      std::chrono::duration_cast<std::chrono::microseconds>(event_time.time_since_epoch()).count();
+
+  const int kNumAttributes                  = 3;
+  std::string keys[kNumAttributes]          = {"attr1", "attr2", "attr3"};
+  int64_t values[kNumAttributes]            = {4, 7, 23};
+  std::map<std::string, int64_t> attributes = {
+      {keys[0], values[0]}, {keys[1], values[1]}, {keys[2], values[2]}};
+
+  rec.AddEvent("Test Event", event_timestamp,
+               common::KeyValueIterableView<std::map<std::string, int64_t>>(attributes));
+  thrift::Log log = rec.Logs().at(0);
+  EXPECT_EQ(log.timestamp, epoch_us);
+  auto tags    = log.fields;
+  size_t index = 0;
+  EXPECT_EQ(tags[index].key, "event");
+  EXPECT_EQ(tags[index++].vStr, "Test Event");
+  while (index <= kNumAttributes)
+  {
+    EXPECT_EQ(tags[index].key, keys[index - 1]);
+    EXPECT_EQ(tags[index].vLong, values[index - 1]);
+    index++;
+  }
+}
+
+template <typename value_type>
+void addTag(thrift::TagType::type tag_type,
+            const std::string &key,
+            value_type value,
+            vector<thrift::Tag> &tags)
+{
+  thrift::Tag tag;
+
+  tag.__set_key(key);
+  tag.__set_vType(tag_type);
+  if (tag_type == thrift::TagType::LONG)
+  {
+    tag.__set_vLong(static_cast<int64_t>(value));
+  }
+  else if (tag_type == thrift::TagType::DOUBLE)
+  {
+    tag.__set_vDouble(static_cast<double>(value));
+  }
+  else if (tag_type == thrift::TagType::BOOL)
+  {
+    tag.__set_vBool(static_cast<bool>(value));
+  }
+
+  tags.push_back(tag);
+}
+
+void addTag(const std::string &key, std::string value, vector<thrift::Tag> &tags)
+{
+  thrift::Tag tag;
+
+  tag.__set_key(key);
+  tag.__set_vType(thrift::TagType::STRING);
+  tag.__set_vStr(value);
+
+  tags.push_back(tag);
+}
+
+TEST(JaegerSpanRecordable, SetAttributes)
+{
+  JaegerRecordable rec;
+  std::string string_val{"string_val"};
+  vector<common::AttributeValue> values{
+      bool{false},
+      int32_t{-32},
+      int64_t{-64},
+      uint32_t{32},
+      double{3.14},
+      string_val.c_str(),
+      nostd::string_view{"string_view"},
+  };
+  for (const auto &val : values)
+  {
+    rec.SetAttribute("key1", val);
+  }
+  rec.SetAttribute("key2", nostd::span<const bool>{{false, true}});
+  rec.SetAttribute("key3", nostd::span<const int32_t>{{-320, 320}});
+  rec.SetAttribute("key4", nostd::span<const int64_t>{{-640, 640}});
+  rec.SetAttribute("key5", nostd::span<const uint32_t>{{320, 322}});
+  rec.SetAttribute("key6", nostd::span<const double>{{4.15, 5.15}});
+  rec.SetAttribute("key7", nostd::span<const nostd::string_view>{{"string_v1", "string_v2"}});
+
+  auto tags = rec.Tags();
+  EXPECT_EQ(tags.size(), values.size() + 12);
+
+  vector<thrift::Tag> expected_tags;
+  addTag(thrift::TagType::BOOL, "key1", bool{false}, expected_tags);
+  addTag(thrift::TagType::LONG, "key1", int32_t{-32}, expected_tags);
+  addTag(thrift::TagType::LONG, "key1", int64_t{-64}, expected_tags);
+  addTag(thrift::TagType::LONG, "key1", int32_t{32}, expected_tags);
+  addTag(thrift::TagType::DOUBLE, "key1", double{3.14}, expected_tags);
+  addTag("key1", string_val, expected_tags);
+  addTag("key1", std::string{"string_view"}, expected_tags);
+
+  addTag(thrift::TagType::BOOL, "key2", bool{false}, expected_tags);
+  addTag(thrift::TagType::BOOL, "key2", bool{true}, expected_tags);
+  addTag(thrift::TagType::LONG, "key3", int32_t{-320}, expected_tags);
+  addTag(thrift::TagType::LONG, "key3", int32_t{320}, expected_tags);
+  addTag(thrift::TagType::LONG, "key4", int64_t{-640}, expected_tags);
+  addTag(thrift::TagType::LONG, "key4", int64_t{640}, expected_tags);
+  addTag(thrift::TagType::LONG, "key5", uint32_t{320}, expected_tags);
+  addTag(thrift::TagType::LONG, "key5", uint32_t{322}, expected_tags);
+  addTag(thrift::TagType::DOUBLE, "key6", double{4.15}, expected_tags);
+  addTag(thrift::TagType::DOUBLE, "key6", double{5.15}, expected_tags);
+  addTag("key7", std::string{"string_v1"}, expected_tags);
+  addTag("key7", std::string{"string_v2"}, expected_tags);
+
+  EXPECT_EQ(tags, expected_tags);
+}
+
+TEST(JaegerSpanRecordable, SetInstrumentationLibrary)
+{
+  JaegerRecordable rec;
+
+  std::string library_name     = "opentelemetry-cpp";
+  std::string library_version  = "0.1.0";
+  auto instrumentation_library = InstrumentationLibrary::Create(library_name, library_version);
+
+  rec.SetInstrumentationLibrary(*instrumentation_library);
+
+  auto tags = rec.Tags();
+  EXPECT_EQ(tags.size(), 2);
+
+  EXPECT_EQ(tags[0].key, "otel.library.name");
+  EXPECT_EQ(tags[0].vType, thrift::TagType::STRING);
+  EXPECT_EQ(tags[0].vStr, library_name);
+
+  EXPECT_EQ(tags[1].key, "otel.library.version");
+  EXPECT_EQ(tags[1].vType, thrift::TagType::STRING);
+  EXPECT_EQ(tags[1].vStr, library_version);
+}
+
+TEST(JaegerSpanRecordable, SetResource)
+{
+  JaegerRecordable rec;
+
+  const std::string service_name_key = "service.name";
+  std::string service_name_value     = "test-jaeger-service-name";
+  auto resource                      = opentelemetry::sdk::resource::Resource::Create(
+      {{service_name_key, service_name_value}, {"key1", "value1"}, {"key2", "value2"}});
+  rec.SetResource(resource);
+
+  auto service_name  = rec.ServiceName();
+  auto resource_tags = rec.ResourceTags();
+
+  EXPECT_GE(resource_tags.size(), 2);
+  EXPECT_EQ(service_name, service_name_value);
+
+  for (const auto &tag : resource_tags)
+  {
+    if (tag.key == "key1")
+    {
+      EXPECT_EQ(tag.vType, thrift::TagType::STRING);
+      EXPECT_EQ(tag.vStr, "value1");
+    }
+    else if (tag.key == "key2")
+    {
+      EXPECT_EQ(tag.vType, thrift::TagType::STRING);
+      EXPECT_EQ(tag.vStr, "value2");
+    }
+  }
+}
+
+TEST(JaegerSpanRecordable, AddLink)
+{
+  JaegerRecordable rec;
+
+  int64_t trace_id_val[2] = {0x0000000000000000, 0x1000000000000000};
+  int64_t span_id_val     = 0x2000000000000000;
+
+  const trace::TraceId trace_id{
+      nostd::span<uint8_t, 16>(reinterpret_cast<uint8_t *>(trace_id_val), 16)};
+
+  const trace::SpanId span_id(
+      nostd::span<uint8_t, 8>(reinterpret_cast<uint8_t *>(&span_id_val), 8));
+
+  const trace::SpanContext span_context{trace_id, span_id,
+                                        trace::TraceFlags{trace::TraceFlags::kIsSampled}, true};
+  rec.AddLink(span_context, common::KeyValueIterableView<Attributes>({{"attr1", "string"}}));
+
+  auto references = rec.References();
+  EXPECT_EQ(references.size(), 1);
+
+  auto reference = references.front();
+
+#if JAEGER_IS_LITTLE_ENDIAN == 1
+  EXPECT_EQ(reference.traceIdLow, otel_bswap_64(trace_id_val[1]));
+  EXPECT_EQ(reference.traceIdHigh, otel_bswap_64(trace_id_val[0]));
+  EXPECT_EQ(reference.spanId, otel_bswap_64(span_id_val));
+#else
+  EXPECT_EQ(reference.traceIdLow, trace_id_val[0]);
+  EXPECT_EQ(reference.traceIdHigh, trace_id_val[1]);
+  EXPECT_EQ(reference.spanId, span_id_val);
+#endif
+}
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Agent.cpp b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Agent.cpp
new file mode 100644
index 000000000..4ff023650
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Agent.cpp
@@ -0,0 +1,380 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "Agent.h"
+
+namespace jaegertracing { namespace agent { namespace thrift {
+
+
+Agent_emitZipkinBatch_args::~Agent_emitZipkinBatch_args() noexcept {
+}
+
+
+uint32_t Agent_emitZipkinBatch_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->spans.clear();
+            uint32_t _size0;
+            ::apache::thrift::protocol::TType _etype3;
+            xfer += iprot->readListBegin(_etype3, _size0);
+            this->spans.resize(_size0);
+            uint32_t _i4;
+            for (_i4 = 0; _i4 < _size0; ++_i4)
+            {
+              xfer += this->spans[_i4].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.spans = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Agent_emitZipkinBatch_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Agent_emitZipkinBatch_args");
+
+  xfer += oprot->writeFieldBegin("spans", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->spans.size()));
+    std::vector< ::twitter::zipkin::thrift::Span> ::const_iterator _iter5;
+    for (_iter5 = this->spans.begin(); _iter5 != this->spans.end(); ++_iter5)
+    {
+      xfer += (*_iter5).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Agent_emitZipkinBatch_pargs::~Agent_emitZipkinBatch_pargs() noexcept {
+}
+
+
+uint32_t Agent_emitZipkinBatch_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Agent_emitZipkinBatch_pargs");
+
+  xfer += oprot->writeFieldBegin("spans", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->spans)).size()));
+    std::vector< ::twitter::zipkin::thrift::Span> ::const_iterator _iter6;
+    for (_iter6 = (*(this->spans)).begin(); _iter6 != (*(this->spans)).end(); ++_iter6)
+    {
+      xfer += (*_iter6).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Agent_emitBatch_args::~Agent_emitBatch_args() noexcept {
+}
+
+
+uint32_t Agent_emitBatch_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->batch.read(iprot);
+          this->__isset.batch = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Agent_emitBatch_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Agent_emitBatch_args");
+
+  xfer += oprot->writeFieldBegin("batch", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->batch.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Agent_emitBatch_pargs::~Agent_emitBatch_pargs() noexcept {
+}
+
+
+uint32_t Agent_emitBatch_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Agent_emitBatch_pargs");
+
+  xfer += oprot->writeFieldBegin("batch", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += (*(this->batch)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void AgentClient::emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans)
+{
+  send_emitZipkinBatch(spans);
+}
+
+void AgentClient::send_emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("emitZipkinBatch", ::apache::thrift::protocol::T_ONEWAY, cseqid);
+
+  Agent_emitZipkinBatch_pargs args;
+  args.spans = &spans;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void AgentClient::emitBatch(const  ::jaegertracing::thrift::Batch& batch)
+{
+  send_emitBatch(batch);
+}
+
+void AgentClient::send_emitBatch(const  ::jaegertracing::thrift::Batch& batch)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("emitBatch", ::apache::thrift::protocol::T_ONEWAY, cseqid);
+
+  Agent_emitBatch_pargs args;
+  args.batch = &batch;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+bool AgentProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) {
+  ProcessMap::iterator pfn;
+  pfn = processMap_.find(fname);
+  if (pfn == processMap_.end()) {
+    iprot->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'");
+    oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return true;
+  }
+  (this->*(pfn->second))(seqid, iprot, oprot, callContext);
+  return true;
+}
+
+void AgentProcessor::process_emitZipkinBatch(int32_t, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol*, void* callContext)
+{
+  void* ctx = nullptr;
+  if (this->eventHandler_.get() != nullptr) {
+    ctx = this->eventHandler_->getContext("Agent.emitZipkinBatch", callContext);
+  }
+  ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Agent.emitZipkinBatch");
+
+  if (this->eventHandler_.get() != nullptr) {
+    this->eventHandler_->preRead(ctx, "Agent.emitZipkinBatch");
+  }
+
+  Agent_emitZipkinBatch_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != nullptr) {
+    this->eventHandler_->postRead(ctx, "Agent.emitZipkinBatch", bytes);
+  }
+
+  try {
+    iface_->emitZipkinBatch(args.spans);
+  } catch (const std::exception&) {
+    if (this->eventHandler_.get() != nullptr) {
+      this->eventHandler_->handlerError(ctx, "Agent.emitZipkinBatch");
+    }
+    return;
+  }
+
+  if (this->eventHandler_.get() != nullptr) {
+    this->eventHandler_->asyncComplete(ctx, "Agent.emitZipkinBatch");
+  }
+
+  return;
+}
+
+void AgentProcessor::process_emitBatch(int32_t, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol*, void* callContext)
+{
+  void* ctx = nullptr;
+  if (this->eventHandler_.get() != nullptr) {
+    ctx = this->eventHandler_->getContext("Agent.emitBatch", callContext);
+  }
+  ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Agent.emitBatch");
+
+  if (this->eventHandler_.get() != nullptr) {
+    this->eventHandler_->preRead(ctx, "Agent.emitBatch");
+  }
+
+  Agent_emitBatch_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != nullptr) {
+    this->eventHandler_->postRead(ctx, "Agent.emitBatch", bytes);
+  }
+
+  try {
+    iface_->emitBatch(args.batch);
+  } catch (const std::exception&) {
+    if (this->eventHandler_.get() != nullptr) {
+      this->eventHandler_->handlerError(ctx, "Agent.emitBatch");
+    }
+    return;
+  }
+
+  if (this->eventHandler_.get() != nullptr) {
+    this->eventHandler_->asyncComplete(ctx, "Agent.emitBatch");
+  }
+
+  return;
+}
+
+::std::shared_ptr< ::apache::thrift::TProcessor > AgentProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) {
+  ::apache::thrift::ReleaseHandler< AgentIfFactory > cleanup(handlerFactory_);
+  ::std::shared_ptr< AgentIf > handler(handlerFactory_->getHandler(connInfo), cleanup);
+  ::std::shared_ptr< ::apache::thrift::TProcessor > processor(new AgentProcessor(handler));
+  return processor;
+}
+
+void AgentConcurrentClient::emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans)
+{
+  send_emitZipkinBatch(spans);
+}
+
+void AgentConcurrentClient::send_emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans)
+{
+  int32_t cseqid = 0;
+  ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
+  oprot_->writeMessageBegin("emitZipkinBatch", ::apache::thrift::protocol::T_ONEWAY, cseqid);
+
+  Agent_emitZipkinBatch_pargs args;
+  args.spans = &spans;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+
+  sentry.commit();
+}
+
+void AgentConcurrentClient::emitBatch(const  ::jaegertracing::thrift::Batch& batch)
+{
+  send_emitBatch(batch);
+}
+
+void AgentConcurrentClient::send_emitBatch(const  ::jaegertracing::thrift::Batch& batch)
+{
+  int32_t cseqid = 0;
+  ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
+  oprot_->writeMessageBegin("emitBatch", ::apache::thrift::protocol::T_ONEWAY, cseqid);
+
+  Agent_emitBatch_pargs args;
+  args.batch = &batch;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+
+  sentry.commit();
+}
+
+}}} // namespace
+
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Agent.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Agent.h
new file mode 100644
index 000000000..49abaf54a
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Agent.h
@@ -0,0 +1,309 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef Agent_H
+#define Agent_H
+
+#include <thrift/TDispatchProcessor.h>
+#include <thrift/async/TConcurrentClientSyncInfo.h>
+#include <memory>
+#include "agent_types.h"
+
+namespace jaegertracing { namespace agent { namespace thrift {
+
+#ifdef _MSC_VER
+  #pragma warning( push )
+  #pragma warning (disable : 4250 ) //inheriting methods via dominance 
+#endif
+
+class AgentIf {
+ public:
+  virtual ~AgentIf() {}
+  virtual void emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans) = 0;
+  virtual void emitBatch(const  ::jaegertracing::thrift::Batch& batch) = 0;
+};
+
+class AgentIfFactory {
+ public:
+  typedef AgentIf Handler;
+
+  virtual ~AgentIfFactory() {}
+
+  virtual AgentIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
+  virtual void releaseHandler(AgentIf* /* handler */) = 0;
+};
+
+class AgentIfSingletonFactory : virtual public AgentIfFactory {
+ public:
+  AgentIfSingletonFactory(const ::std::shared_ptr<AgentIf>& iface) : iface_(iface) {}
+  virtual ~AgentIfSingletonFactory() {}
+
+  virtual AgentIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
+    return iface_.get();
+  }
+  virtual void releaseHandler(AgentIf* /* handler */) {}
+
+ protected:
+  ::std::shared_ptr<AgentIf> iface_;
+};
+
+class AgentNull : virtual public AgentIf {
+ public:
+  virtual ~AgentNull() {}
+  void emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & /* spans */) {
+    return;
+  }
+  void emitBatch(const  ::jaegertracing::thrift::Batch& /* batch */) {
+    return;
+  }
+};
+
+typedef struct _Agent_emitZipkinBatch_args__isset {
+  _Agent_emitZipkinBatch_args__isset() : spans(false) {}
+  bool spans :1;
+} _Agent_emitZipkinBatch_args__isset;
+
+class Agent_emitZipkinBatch_args {
+ public:
+
+  Agent_emitZipkinBatch_args(const Agent_emitZipkinBatch_args&);
+  Agent_emitZipkinBatch_args& operator=(const Agent_emitZipkinBatch_args&);
+  Agent_emitZipkinBatch_args() {
+  }
+
+  virtual ~Agent_emitZipkinBatch_args() noexcept;
+  std::vector< ::twitter::zipkin::thrift::Span>  spans;
+
+  _Agent_emitZipkinBatch_args__isset __isset;
+
+  void __set_spans(const std::vector< ::twitter::zipkin::thrift::Span> & val);
+
+  bool operator == (const Agent_emitZipkinBatch_args & rhs) const
+  {
+    if (!(spans == rhs.spans))
+      return false;
+    return true;
+  }
+  bool operator != (const Agent_emitZipkinBatch_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Agent_emitZipkinBatch_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Agent_emitZipkinBatch_pargs {
+ public:
+
+
+  virtual ~Agent_emitZipkinBatch_pargs() noexcept;
+  const std::vector< ::twitter::zipkin::thrift::Span> * spans;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Agent_emitBatch_args__isset {
+  _Agent_emitBatch_args__isset() : batch(false) {}
+  bool batch :1;
+} _Agent_emitBatch_args__isset;
+
+class Agent_emitBatch_args {
+ public:
+
+  Agent_emitBatch_args(const Agent_emitBatch_args&);
+  Agent_emitBatch_args& operator=(const Agent_emitBatch_args&);
+  Agent_emitBatch_args() {
+  }
+
+  virtual ~Agent_emitBatch_args() noexcept;
+   ::jaegertracing::thrift::Batch batch;
+
+  _Agent_emitBatch_args__isset __isset;
+
+  void __set_batch(const  ::jaegertracing::thrift::Batch& val);
+
+  bool operator == (const Agent_emitBatch_args & rhs) const
+  {
+    if (!(batch == rhs.batch))
+      return false;
+    return true;
+  }
+  bool operator != (const Agent_emitBatch_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Agent_emitBatch_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Agent_emitBatch_pargs {
+ public:
+
+
+  virtual ~Agent_emitBatch_pargs() noexcept;
+  const  ::jaegertracing::thrift::Batch* batch;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class AgentClient : virtual public AgentIf {
+ public:
+  AgentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+    setProtocol(prot);
+  }
+  AgentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    setProtocol(iprot,oprot);
+  }
+ private:
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+  setProtocol(prot,prot);
+  }
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    piprot_=iprot;
+    poprot_=oprot;
+    iprot_ = iprot.get();
+    oprot_ = oprot.get();
+  }
+ public:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+    return piprot_;
+  }
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+    return poprot_;
+  }
+  void emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans);
+  void send_emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans);
+  void emitBatch(const  ::jaegertracing::thrift::Batch& batch);
+  void send_emitBatch(const  ::jaegertracing::thrift::Batch& batch);
+ protected:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
+  ::apache::thrift::protocol::TProtocol* iprot_;
+  ::apache::thrift::protocol::TProtocol* oprot_;
+};
+
+class AgentProcessor : public ::apache::thrift::TDispatchProcessor {
+ protected:
+  ::std::shared_ptr<AgentIf> iface_;
+  virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
+ private:
+  typedef  void (AgentProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
+  typedef std::map<std::string, ProcessFunction> ProcessMap;
+  ProcessMap processMap_;
+  void process_emitZipkinBatch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_emitBatch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ public:
+  AgentProcessor(::std::shared_ptr<AgentIf> iface) :
+    iface_(iface) {
+    processMap_["emitZipkinBatch"] = &AgentProcessor::process_emitZipkinBatch;
+    processMap_["emitBatch"] = &AgentProcessor::process_emitBatch;
+  }
+
+  virtual ~AgentProcessor() {}
+};
+
+class AgentProcessorFactory : public ::apache::thrift::TProcessorFactory {
+ public:
+  AgentProcessorFactory(const ::std::shared_ptr< AgentIfFactory >& handlerFactory) :
+      handlerFactory_(handlerFactory) {}
+
+  ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
+
+ protected:
+  ::std::shared_ptr< AgentIfFactory > handlerFactory_;
+};
+
+class AgentMultiface : virtual public AgentIf {
+ public:
+  AgentMultiface(std::vector<std::shared_ptr<AgentIf> >& ifaces) : ifaces_(ifaces) {
+  }
+  virtual ~AgentMultiface() {}
+ protected:
+  std::vector<std::shared_ptr<AgentIf> > ifaces_;
+  AgentMultiface() {}
+  void add(::std::shared_ptr<AgentIf> iface) {
+    ifaces_.push_back(iface);
+  }
+ public:
+  void emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->emitZipkinBatch(spans);
+    }
+    ifaces_[i]->emitZipkinBatch(spans);
+  }
+
+  void emitBatch(const  ::jaegertracing::thrift::Batch& batch) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->emitBatch(batch);
+    }
+    ifaces_[i]->emitBatch(batch);
+  }
+
+};
+
+// The 'concurrent' client is a thread safe client that correctly handles
+// out of order responses.  It is slower than the regular client, so should
+// only be used when you need to share a connection among multiple threads
+class AgentConcurrentClient : virtual public AgentIf {
+ public:
+  AgentConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync)
+{
+    setProtocol(prot);
+  }
+  AgentConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync)
+{
+    setProtocol(iprot,oprot);
+  }
+ private:
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+  setProtocol(prot,prot);
+  }
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    piprot_=iprot;
+    poprot_=oprot;
+    iprot_ = iprot.get();
+    oprot_ = oprot.get();
+  }
+ public:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+    return piprot_;
+  }
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+    return poprot_;
+  }
+  void emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans);
+  void send_emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans);
+  void emitBatch(const  ::jaegertracing::thrift::Batch& batch);
+  void send_emitBatch(const  ::jaegertracing::thrift::Batch& batch);
+ protected:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
+  ::apache::thrift::protocol::TProtocol* iprot_;
+  ::apache::thrift::protocol::TProtocol* oprot_;
+  std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync_;
+};
+
+#ifdef _MSC_VER
+  #pragma warning( pop )
+#endif
+
+}}} // namespace
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Agent_server.skeleton.cpp b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Agent_server.skeleton.cpp
new file mode 100644
index 000000000..60fdd9436
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Agent_server.skeleton.cpp
@@ -0,0 +1,47 @@
+// This autogenerated skeleton file illustrates how to build a server.
+// You should copy it to another filename to avoid overwriting it.
+
+#include "Agent.h"
+#include <thrift/protocol/TBinaryProtocol.h>
+#include <thrift/server/TSimpleServer.h>
+#include <thrift/transport/TServerSocket.h>
+#include <thrift/transport/TBufferTransports.h>
+
+using namespace ::apache::thrift;
+using namespace ::apache::thrift::protocol;
+using namespace ::apache::thrift::transport;
+using namespace ::apache::thrift::server;
+
+using namespace  ::jaegertracing::agent::thrift;
+
+class AgentHandler : virtual public AgentIf {
+ public:
+  AgentHandler() {
+    // Your initialization goes here
+  }
+
+  void emitZipkinBatch(const std::vector< ::twitter::zipkin::thrift::Span> & spans) {
+    // Your implementation goes here
+    printf("emitZipkinBatch\n");
+  }
+
+  void emitBatch(const  ::jaegertracing::thrift::Batch& batch) {
+    // Your implementation goes here
+    printf("emitBatch\n");
+  }
+
+};
+
+int main(int argc, char **argv) {
+  int port = 9090;
+  ::std::shared_ptr<AgentHandler> handler(new AgentHandler());
+  ::std::shared_ptr<TProcessor> processor(new AgentProcessor(handler));
+  ::std::shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
+  ::std::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+  ::std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+
+  TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
+  server.serve();
+  return 0;
+}
+
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Collector.cpp b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Collector.cpp
new file mode 100644
index 000000000..f96b40f20
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Collector.cpp
@@ -0,0 +1,481 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "Collector.h"
+
+namespace jaegertracing { namespace thrift {
+
+
+Collector_submitBatches_args::~Collector_submitBatches_args() noexcept {
+}
+
+
+uint32_t Collector_submitBatches_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->batches.clear();
+            uint32_t _size52;
+            ::apache::thrift::protocol::TType _etype55;
+            xfer += iprot->readListBegin(_etype55, _size52);
+            this->batches.resize(_size52);
+            uint32_t _i56;
+            for (_i56 = 0; _i56 < _size52; ++_i56)
+            {
+              xfer += this->batches[_i56].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.batches = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Collector_submitBatches_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Collector_submitBatches_args");
+
+  xfer += oprot->writeFieldBegin("batches", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->batches.size()));
+    std::vector<Batch> ::const_iterator _iter57;
+    for (_iter57 = this->batches.begin(); _iter57 != this->batches.end(); ++_iter57)
+    {
+      xfer += (*_iter57).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Collector_submitBatches_pargs::~Collector_submitBatches_pargs() noexcept {
+}
+
+
+uint32_t Collector_submitBatches_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Collector_submitBatches_pargs");
+
+  xfer += oprot->writeFieldBegin("batches", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->batches)).size()));
+    std::vector<Batch> ::const_iterator _iter58;
+    for (_iter58 = (*(this->batches)).begin(); _iter58 != (*(this->batches)).end(); ++_iter58)
+    {
+      xfer += (*_iter58).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Collector_submitBatches_result::~Collector_submitBatches_result() noexcept {
+}
+
+
+uint32_t Collector_submitBatches_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size59;
+            ::apache::thrift::protocol::TType _etype62;
+            xfer += iprot->readListBegin(_etype62, _size59);
+            this->success.resize(_size59);
+            uint32_t _i63;
+            for (_i63 = 0; _i63 < _size59; ++_i63)
+            {
+              xfer += this->success[_i63].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Collector_submitBatches_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("Collector_submitBatches_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+      std::vector<BatchSubmitResponse> ::const_iterator _iter64;
+      for (_iter64 = this->success.begin(); _iter64 != this->success.end(); ++_iter64)
+      {
+        xfer += (*_iter64).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+Collector_submitBatches_presult::~Collector_submitBatches_presult() noexcept {
+}
+
+
+uint32_t Collector_submitBatches_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size65;
+            ::apache::thrift::protocol::TType _etype68;
+            xfer += iprot->readListBegin(_etype68, _size65);
+            (*(this->success)).resize(_size65);
+            uint32_t _i69;
+            for (_i69 = 0; _i69 < _size65; ++_i69)
+            {
+              xfer += (*(this->success))[_i69].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+void CollectorClient::submitBatches(std::vector<BatchSubmitResponse> & _return, const std::vector<Batch> & batches)
+{
+  send_submitBatches(batches);
+  recv_submitBatches(_return);
+}
+
+void CollectorClient::send_submitBatches(const std::vector<Batch> & batches)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("submitBatches", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Collector_submitBatches_pargs args;
+  args.batches = &batches;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void CollectorClient::recv_submitBatches(std::vector<BatchSubmitResponse> & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("submitBatches") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  Collector_submitBatches_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "submitBatches failed: unknown result");
+}
+
+bool CollectorProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) {
+  ProcessMap::iterator pfn;
+  pfn = processMap_.find(fname);
+  if (pfn == processMap_.end()) {
+    iprot->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'");
+    oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return true;
+  }
+  (this->*(pfn->second))(seqid, iprot, oprot, callContext);
+  return true;
+}
+
+void CollectorProcessor::process_submitBatches(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = nullptr;
+  if (this->eventHandler_.get() != nullptr) {
+    ctx = this->eventHandler_->getContext("Collector.submitBatches", callContext);
+  }
+  ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "Collector.submitBatches");
+
+  if (this->eventHandler_.get() != nullptr) {
+    this->eventHandler_->preRead(ctx, "Collector.submitBatches");
+  }
+
+  Collector_submitBatches_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != nullptr) {
+    this->eventHandler_->postRead(ctx, "Collector.submitBatches", bytes);
+  }
+
+  Collector_submitBatches_result result;
+  try {
+    iface_->submitBatches(result.success, args.batches);
+    result.__isset.success = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != nullptr) {
+      this->eventHandler_->handlerError(ctx, "Collector.submitBatches");
+    }
+
+    ::apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("submitBatches", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != nullptr) {
+    this->eventHandler_->preWrite(ctx, "Collector.submitBatches");
+  }
+
+  oprot->writeMessageBegin("submitBatches", ::apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != nullptr) {
+    this->eventHandler_->postWrite(ctx, "Collector.submitBatches", bytes);
+  }
+}
+
+::std::shared_ptr< ::apache::thrift::TProcessor > CollectorProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) {
+  ::apache::thrift::ReleaseHandler< CollectorIfFactory > cleanup(handlerFactory_);
+  ::std::shared_ptr< CollectorIf > handler(handlerFactory_->getHandler(connInfo), cleanup);
+  ::std::shared_ptr< ::apache::thrift::TProcessor > processor(new CollectorProcessor(handler));
+  return processor;
+}
+
+void CollectorConcurrentClient::submitBatches(std::vector<BatchSubmitResponse> & _return, const std::vector<Batch> & batches)
+{
+  int32_t seqid = send_submitBatches(batches);
+  recv_submitBatches(_return, seqid);
+}
+
+int32_t CollectorConcurrentClient::send_submitBatches(const std::vector<Batch> & batches)
+{
+  int32_t cseqid = this->sync_->generateSeqId();
+  ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
+  oprot_->writeMessageBegin("submitBatches", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  Collector_submitBatches_pargs args;
+  args.batches = &batches;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+
+  sentry.commit();
+  return cseqid;
+}
+
+void CollectorConcurrentClient::recv_submitBatches(std::vector<BatchSubmitResponse> & _return, const int32_t seqid)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  // the read mutex gets dropped and reacquired as part of waitForWork()
+  // The destructor of this sentry wakes up other clients
+  ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
+
+  while(true) {
+    if(!this->sync_->getPending(fname, mtype, rseqid)) {
+      iprot_->readMessageBegin(fname, mtype, rseqid);
+    }
+    if(seqid == rseqid) {
+      if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+        ::apache::thrift::TApplicationException x;
+        x.read(iprot_);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+        sentry.commit();
+        throw x;
+      }
+      if (mtype != ::apache::thrift::protocol::T_REPLY) {
+        iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+      }
+      if (fname.compare("submitBatches") != 0) {
+        iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+
+        // in a bad state, don't commit
+        using ::apache::thrift::protocol::TProtocolException;
+        throw TProtocolException(TProtocolException::INVALID_DATA);
+      }
+      Collector_submitBatches_presult result;
+      result.success = &_return;
+      result.read(iprot_);
+      iprot_->readMessageEnd();
+      iprot_->getTransport()->readEnd();
+
+      if (result.__isset.success) {
+        // _return pointer has now been filled
+        sentry.commit();
+        return;
+      }
+      // in a bad state, don't commit
+      throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "submitBatches failed: unknown result");
+    }
+    // seqid != rseqid
+    this->sync_->updatePending(fname, mtype, rseqid);
+
+    // this will temporarily unlock the readMutex, and let other clients get work done
+    this->sync_->waitForWork(seqid);
+  } // end while(true)
+}
+
+}} // namespace
+
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Collector.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Collector.h
new file mode 100644
index 000000000..75daa69a7
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Collector.h
@@ -0,0 +1,299 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef Collector_H
+#define Collector_H
+
+#include <thrift/TDispatchProcessor.h>
+#include <thrift/async/TConcurrentClientSyncInfo.h>
+#include <memory>
+#include "jaeger_types.h"
+
+namespace jaegertracing { namespace thrift {
+
+#ifdef _MSC_VER
+  #pragma warning( push )
+  #pragma warning (disable : 4250 ) //inheriting methods via dominance 
+#endif
+
+class CollectorIf {
+ public:
+  virtual ~CollectorIf() {}
+  virtual void submitBatches(std::vector<BatchSubmitResponse> & _return, const std::vector<Batch> & batches) = 0;
+};
+
+class CollectorIfFactory {
+ public:
+  typedef CollectorIf Handler;
+
+  virtual ~CollectorIfFactory() {}
+
+  virtual CollectorIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
+  virtual void releaseHandler(CollectorIf* /* handler */) = 0;
+};
+
+class CollectorIfSingletonFactory : virtual public CollectorIfFactory {
+ public:
+  CollectorIfSingletonFactory(const ::std::shared_ptr<CollectorIf>& iface) : iface_(iface) {}
+  virtual ~CollectorIfSingletonFactory() {}
+
+  virtual CollectorIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
+    return iface_.get();
+  }
+  virtual void releaseHandler(CollectorIf* /* handler */) {}
+
+ protected:
+  ::std::shared_ptr<CollectorIf> iface_;
+};
+
+class CollectorNull : virtual public CollectorIf {
+ public:
+  virtual ~CollectorNull() {}
+  void submitBatches(std::vector<BatchSubmitResponse> & /* _return */, const std::vector<Batch> & /* batches */) {
+    return;
+  }
+};
+
+typedef struct _Collector_submitBatches_args__isset {
+  _Collector_submitBatches_args__isset() : batches(false) {}
+  bool batches :1;
+} _Collector_submitBatches_args__isset;
+
+class Collector_submitBatches_args {
+ public:
+
+  Collector_submitBatches_args(const Collector_submitBatches_args&);
+  Collector_submitBatches_args& operator=(const Collector_submitBatches_args&);
+  Collector_submitBatches_args() {
+  }
+
+  virtual ~Collector_submitBatches_args() noexcept;
+  std::vector<Batch>  batches;
+
+  _Collector_submitBatches_args__isset __isset;
+
+  void __set_batches(const std::vector<Batch> & val);
+
+  bool operator == (const Collector_submitBatches_args & rhs) const
+  {
+    if (!(batches == rhs.batches))
+      return false;
+    return true;
+  }
+  bool operator != (const Collector_submitBatches_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Collector_submitBatches_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class Collector_submitBatches_pargs {
+ public:
+
+
+  virtual ~Collector_submitBatches_pargs() noexcept;
+  const std::vector<Batch> * batches;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Collector_submitBatches_result__isset {
+  _Collector_submitBatches_result__isset() : success(false) {}
+  bool success :1;
+} _Collector_submitBatches_result__isset;
+
+class Collector_submitBatches_result {
+ public:
+
+  Collector_submitBatches_result(const Collector_submitBatches_result&);
+  Collector_submitBatches_result& operator=(const Collector_submitBatches_result&);
+  Collector_submitBatches_result() {
+  }
+
+  virtual ~Collector_submitBatches_result() noexcept;
+  std::vector<BatchSubmitResponse>  success;
+
+  _Collector_submitBatches_result__isset __isset;
+
+  void __set_success(const std::vector<BatchSubmitResponse> & val);
+
+  bool operator == (const Collector_submitBatches_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const Collector_submitBatches_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Collector_submitBatches_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _Collector_submitBatches_presult__isset {
+  _Collector_submitBatches_presult__isset() : success(false) {}
+  bool success :1;
+} _Collector_submitBatches_presult__isset;
+
+class Collector_submitBatches_presult {
+ public:
+
+
+  virtual ~Collector_submitBatches_presult() noexcept;
+  std::vector<BatchSubmitResponse> * success;
+
+  _Collector_submitBatches_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+class CollectorClient : virtual public CollectorIf {
+ public:
+  CollectorClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+    setProtocol(prot);
+  }
+  CollectorClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    setProtocol(iprot,oprot);
+  }
+ private:
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+  setProtocol(prot,prot);
+  }
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    piprot_=iprot;
+    poprot_=oprot;
+    iprot_ = iprot.get();
+    oprot_ = oprot.get();
+  }
+ public:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+    return piprot_;
+  }
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+    return poprot_;
+  }
+  void submitBatches(std::vector<BatchSubmitResponse> & _return, const std::vector<Batch> & batches);
+  void send_submitBatches(const std::vector<Batch> & batches);
+  void recv_submitBatches(std::vector<BatchSubmitResponse> & _return);
+ protected:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
+  ::apache::thrift::protocol::TProtocol* iprot_;
+  ::apache::thrift::protocol::TProtocol* oprot_;
+};
+
+class CollectorProcessor : public ::apache::thrift::TDispatchProcessor {
+ protected:
+  ::std::shared_ptr<CollectorIf> iface_;
+  virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
+ private:
+  typedef  void (CollectorProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
+  typedef std::map<std::string, ProcessFunction> ProcessMap;
+  ProcessMap processMap_;
+  void process_submitBatches(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ public:
+  CollectorProcessor(::std::shared_ptr<CollectorIf> iface) :
+    iface_(iface) {
+    processMap_["submitBatches"] = &CollectorProcessor::process_submitBatches;
+  }
+
+  virtual ~CollectorProcessor() {}
+};
+
+class CollectorProcessorFactory : public ::apache::thrift::TProcessorFactory {
+ public:
+  CollectorProcessorFactory(const ::std::shared_ptr< CollectorIfFactory >& handlerFactory) :
+      handlerFactory_(handlerFactory) {}
+
+  ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
+
+ protected:
+  ::std::shared_ptr< CollectorIfFactory > handlerFactory_;
+};
+
+class CollectorMultiface : virtual public CollectorIf {
+ public:
+  CollectorMultiface(std::vector<std::shared_ptr<CollectorIf> >& ifaces) : ifaces_(ifaces) {
+  }
+  virtual ~CollectorMultiface() {}
+ protected:
+  std::vector<std::shared_ptr<CollectorIf> > ifaces_;
+  CollectorMultiface() {}
+  void add(::std::shared_ptr<CollectorIf> iface) {
+    ifaces_.push_back(iface);
+  }
+ public:
+  void submitBatches(std::vector<BatchSubmitResponse> & _return, const std::vector<Batch> & batches) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->submitBatches(_return, batches);
+    }
+    ifaces_[i]->submitBatches(_return, batches);
+    return;
+  }
+
+};
+
+// The 'concurrent' client is a thread safe client that correctly handles
+// out of order responses.  It is slower than the regular client, so should
+// only be used when you need to share a connection among multiple threads
+class CollectorConcurrentClient : virtual public CollectorIf {
+ public:
+  CollectorConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync)
+{
+    setProtocol(prot);
+  }
+  CollectorConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync)
+{
+    setProtocol(iprot,oprot);
+  }
+ private:
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+  setProtocol(prot,prot);
+  }
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    piprot_=iprot;
+    poprot_=oprot;
+    iprot_ = iprot.get();
+    oprot_ = oprot.get();
+  }
+ public:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+    return piprot_;
+  }
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+    return poprot_;
+  }
+  void submitBatches(std::vector<BatchSubmitResponse> & _return, const std::vector<Batch> & batches);
+  int32_t send_submitBatches(const std::vector<Batch> & batches);
+  void recv_submitBatches(std::vector<BatchSubmitResponse> & _return, const int32_t seqid);
+ protected:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
+  ::apache::thrift::protocol::TProtocol* iprot_;
+  ::apache::thrift::protocol::TProtocol* oprot_;
+  std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync_;
+};
+
+#ifdef _MSC_VER
+  #pragma warning( pop )
+#endif
+
+}} // namespace
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Collector_server.skeleton.cpp b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Collector_server.skeleton.cpp
new file mode 100644
index 000000000..c59c8aa49
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/Collector_server.skeleton.cpp
@@ -0,0 +1,42 @@
+// This autogenerated skeleton file illustrates how to build a server.
+// You should copy it to another filename to avoid overwriting it.
+
+#include "Collector.h"
+#include <thrift/protocol/TBinaryProtocol.h>
+#include <thrift/server/TSimpleServer.h>
+#include <thrift/transport/TServerSocket.h>
+#include <thrift/transport/TBufferTransports.h>
+
+using namespace ::apache::thrift;
+using namespace ::apache::thrift::protocol;
+using namespace ::apache::thrift::transport;
+using namespace ::apache::thrift::server;
+
+using namespace  ::jaegertracing::thrift;
+
+class CollectorHandler : virtual public CollectorIf {
+ public:
+  CollectorHandler() {
+    // Your initialization goes here
+  }
+
+  void submitBatches(std::vector<BatchSubmitResponse> & _return, const std::vector<Batch> & batches) {
+    // Your implementation goes here
+    printf("submitBatches\n");
+  }
+
+};
+
+int main(int argc, char **argv) {
+  int port = 9090;
+  ::std::shared_ptr<CollectorHandler> handler(new CollectorHandler());
+  ::std::shared_ptr<TProcessor> processor(new CollectorProcessor(handler));
+  ::std::shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
+  ::std::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+  ::std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+
+  TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
+  server.serve();
+  return 0;
+}
+
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/ZipkinCollector.cpp b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/ZipkinCollector.cpp
new file mode 100644
index 000000000..42d813dfd
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/ZipkinCollector.cpp
@@ -0,0 +1,481 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "ZipkinCollector.h"
+
+namespace twitter { namespace zipkin { namespace thrift {
+
+
+ZipkinCollector_submitZipkinBatch_args::~ZipkinCollector_submitZipkinBatch_args() noexcept {
+}
+
+
+uint32_t ZipkinCollector_submitZipkinBatch_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->spans.clear();
+            uint32_t _size23;
+            ::apache::thrift::protocol::TType _etype26;
+            xfer += iprot->readListBegin(_etype26, _size23);
+            this->spans.resize(_size23);
+            uint32_t _i27;
+            for (_i27 = 0; _i27 < _size23; ++_i27)
+            {
+              xfer += this->spans[_i27].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.spans = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t ZipkinCollector_submitZipkinBatch_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("ZipkinCollector_submitZipkinBatch_args");
+
+  xfer += oprot->writeFieldBegin("spans", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->spans.size()));
+    std::vector<Span> ::const_iterator _iter28;
+    for (_iter28 = this->spans.begin(); _iter28 != this->spans.end(); ++_iter28)
+    {
+      xfer += (*_iter28).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+ZipkinCollector_submitZipkinBatch_pargs::~ZipkinCollector_submitZipkinBatch_pargs() noexcept {
+}
+
+
+uint32_t ZipkinCollector_submitZipkinBatch_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("ZipkinCollector_submitZipkinBatch_pargs");
+
+  xfer += oprot->writeFieldBegin("spans", ::apache::thrift::protocol::T_LIST, 1);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->spans)).size()));
+    std::vector<Span> ::const_iterator _iter29;
+    for (_iter29 = (*(this->spans)).begin(); _iter29 != (*(this->spans)).end(); ++_iter29)
+    {
+      xfer += (*_iter29).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+ZipkinCollector_submitZipkinBatch_result::~ZipkinCollector_submitZipkinBatch_result() noexcept {
+}
+
+
+uint32_t ZipkinCollector_submitZipkinBatch_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size30;
+            ::apache::thrift::protocol::TType _etype33;
+            xfer += iprot->readListBegin(_etype33, _size30);
+            this->success.resize(_size30);
+            uint32_t _i34;
+            for (_i34 = 0; _i34 < _size30; ++_i34)
+            {
+              xfer += this->success[_i34].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t ZipkinCollector_submitZipkinBatch_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("ZipkinCollector_submitZipkinBatch_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+      std::vector<Response> ::const_iterator _iter35;
+      for (_iter35 = this->success.begin(); _iter35 != this->success.end(); ++_iter35)
+      {
+        xfer += (*_iter35).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+
+ZipkinCollector_submitZipkinBatch_presult::~ZipkinCollector_submitZipkinBatch_presult() noexcept {
+}
+
+
+uint32_t ZipkinCollector_submitZipkinBatch_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size36;
+            ::apache::thrift::protocol::TType _etype39;
+            xfer += iprot->readListBegin(_etype39, _size36);
+            (*(this->success)).resize(_size36);
+            uint32_t _i40;
+            for (_i40 = 0; _i40 < _size36; ++_i40)
+            {
+              xfer += (*(this->success))[_i40].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+void ZipkinCollectorClient::submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans)
+{
+  send_submitZipkinBatch(spans);
+  recv_submitZipkinBatch(_return);
+}
+
+void ZipkinCollectorClient::send_submitZipkinBatch(const std::vector<Span> & spans)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("submitZipkinBatch", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  ZipkinCollector_submitZipkinBatch_pargs args;
+  args.spans = &spans;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+}
+
+void ZipkinCollectorClient::recv_submitZipkinBatch(std::vector<Response> & _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+    ::apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != ::apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  if (fname.compare("submitZipkinBatch") != 0) {
+    iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+  }
+  ZipkinCollector_submitZipkinBatch_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "submitZipkinBatch failed: unknown result");
+}
+
+bool ZipkinCollectorProcessor::dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext) {
+  ProcessMap::iterator pfn;
+  pfn = processMap_.find(fname);
+  if (pfn == processMap_.end()) {
+    iprot->skip(::apache::thrift::protocol::T_STRUCT);
+    iprot->readMessageEnd();
+    iprot->getTransport()->readEnd();
+    ::apache::thrift::TApplicationException x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, "Invalid method name: '"+fname+"'");
+    oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return true;
+  }
+  (this->*(pfn->second))(seqid, iprot, oprot, callContext);
+  return true;
+}
+
+void ZipkinCollectorProcessor::process_submitZipkinBatch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext)
+{
+  void* ctx = nullptr;
+  if (this->eventHandler_.get() != nullptr) {
+    ctx = this->eventHandler_->getContext("ZipkinCollector.submitZipkinBatch", callContext);
+  }
+  ::apache::thrift::TProcessorContextFreer freer(this->eventHandler_.get(), ctx, "ZipkinCollector.submitZipkinBatch");
+
+  if (this->eventHandler_.get() != nullptr) {
+    this->eventHandler_->preRead(ctx, "ZipkinCollector.submitZipkinBatch");
+  }
+
+  ZipkinCollector_submitZipkinBatch_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  uint32_t bytes = iprot->getTransport()->readEnd();
+
+  if (this->eventHandler_.get() != nullptr) {
+    this->eventHandler_->postRead(ctx, "ZipkinCollector.submitZipkinBatch", bytes);
+  }
+
+  ZipkinCollector_submitZipkinBatch_result result;
+  try {
+    iface_->submitZipkinBatch(result.success, args.spans);
+    result.__isset.success = true;
+  } catch (const std::exception& e) {
+    if (this->eventHandler_.get() != nullptr) {
+      this->eventHandler_->handlerError(ctx, "ZipkinCollector.submitZipkinBatch");
+    }
+
+    ::apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("submitZipkinBatch", ::apache::thrift::protocol::T_EXCEPTION, seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->writeEnd();
+    oprot->getTransport()->flush();
+    return;
+  }
+
+  if (this->eventHandler_.get() != nullptr) {
+    this->eventHandler_->preWrite(ctx, "ZipkinCollector.submitZipkinBatch");
+  }
+
+  oprot->writeMessageBegin("submitZipkinBatch", ::apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  bytes = oprot->getTransport()->writeEnd();
+  oprot->getTransport()->flush();
+
+  if (this->eventHandler_.get() != nullptr) {
+    this->eventHandler_->postWrite(ctx, "ZipkinCollector.submitZipkinBatch", bytes);
+  }
+}
+
+::std::shared_ptr< ::apache::thrift::TProcessor > ZipkinCollectorProcessorFactory::getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) {
+  ::apache::thrift::ReleaseHandler< ZipkinCollectorIfFactory > cleanup(handlerFactory_);
+  ::std::shared_ptr< ZipkinCollectorIf > handler(handlerFactory_->getHandler(connInfo), cleanup);
+  ::std::shared_ptr< ::apache::thrift::TProcessor > processor(new ZipkinCollectorProcessor(handler));
+  return processor;
+}
+
+void ZipkinCollectorConcurrentClient::submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans)
+{
+  int32_t seqid = send_submitZipkinBatch(spans);
+  recv_submitZipkinBatch(_return, seqid);
+}
+
+int32_t ZipkinCollectorConcurrentClient::send_submitZipkinBatch(const std::vector<Span> & spans)
+{
+  int32_t cseqid = this->sync_->generateSeqId();
+  ::apache::thrift::async::TConcurrentSendSentry sentry(this->sync_.get());
+  oprot_->writeMessageBegin("submitZipkinBatch", ::apache::thrift::protocol::T_CALL, cseqid);
+
+  ZipkinCollector_submitZipkinBatch_pargs args;
+  args.spans = &spans;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->writeEnd();
+  oprot_->getTransport()->flush();
+
+  sentry.commit();
+  return cseqid;
+}
+
+void ZipkinCollectorConcurrentClient::recv_submitZipkinBatch(std::vector<Response> & _return, const int32_t seqid)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TMessageType mtype;
+
+  // the read mutex gets dropped and reacquired as part of waitForWork()
+  // The destructor of this sentry wakes up other clients
+  ::apache::thrift::async::TConcurrentRecvSentry sentry(this->sync_.get(), seqid);
+
+  while(true) {
+    if(!this->sync_->getPending(fname, mtype, rseqid)) {
+      iprot_->readMessageBegin(fname, mtype, rseqid);
+    }
+    if(seqid == rseqid) {
+      if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {
+        ::apache::thrift::TApplicationException x;
+        x.read(iprot_);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+        sentry.commit();
+        throw x;
+      }
+      if (mtype != ::apache::thrift::protocol::T_REPLY) {
+        iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+      }
+      if (fname.compare("submitZipkinBatch") != 0) {
+        iprot_->skip(::apache::thrift::protocol::T_STRUCT);
+        iprot_->readMessageEnd();
+        iprot_->getTransport()->readEnd();
+
+        // in a bad state, don't commit
+        using ::apache::thrift::protocol::TProtocolException;
+        throw TProtocolException(TProtocolException::INVALID_DATA);
+      }
+      ZipkinCollector_submitZipkinBatch_presult result;
+      result.success = &_return;
+      result.read(iprot_);
+      iprot_->readMessageEnd();
+      iprot_->getTransport()->readEnd();
+
+      if (result.__isset.success) {
+        // _return pointer has now been filled
+        sentry.commit();
+        return;
+      }
+      // in a bad state, don't commit
+      throw ::apache::thrift::TApplicationException(::apache::thrift::TApplicationException::MISSING_RESULT, "submitZipkinBatch failed: unknown result");
+    }
+    // seqid != rseqid
+    this->sync_->updatePending(fname, mtype, rseqid);
+
+    // this will temporarily unlock the readMutex, and let other clients get work done
+    this->sync_->waitForWork(seqid);
+  } // end while(true)
+}
+
+}}} // namespace
+
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/ZipkinCollector.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/ZipkinCollector.h
new file mode 100644
index 000000000..97e111d24
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/ZipkinCollector.h
@@ -0,0 +1,299 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef ZipkinCollector_H
+#define ZipkinCollector_H
+
+#include <thrift/TDispatchProcessor.h>
+#include <thrift/async/TConcurrentClientSyncInfo.h>
+#include <memory>
+#include "zipkincore_types.h"
+
+namespace twitter { namespace zipkin { namespace thrift {
+
+#ifdef _MSC_VER
+  #pragma warning( push )
+  #pragma warning (disable : 4250 ) //inheriting methods via dominance 
+#endif
+
+class ZipkinCollectorIf {
+ public:
+  virtual ~ZipkinCollectorIf() {}
+  virtual void submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans) = 0;
+};
+
+class ZipkinCollectorIfFactory {
+ public:
+  typedef ZipkinCollectorIf Handler;
+
+  virtual ~ZipkinCollectorIfFactory() {}
+
+  virtual ZipkinCollectorIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
+  virtual void releaseHandler(ZipkinCollectorIf* /* handler */) = 0;
+};
+
+class ZipkinCollectorIfSingletonFactory : virtual public ZipkinCollectorIfFactory {
+ public:
+  ZipkinCollectorIfSingletonFactory(const ::std::shared_ptr<ZipkinCollectorIf>& iface) : iface_(iface) {}
+  virtual ~ZipkinCollectorIfSingletonFactory() {}
+
+  virtual ZipkinCollectorIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
+    return iface_.get();
+  }
+  virtual void releaseHandler(ZipkinCollectorIf* /* handler */) {}
+
+ protected:
+  ::std::shared_ptr<ZipkinCollectorIf> iface_;
+};
+
+class ZipkinCollectorNull : virtual public ZipkinCollectorIf {
+ public:
+  virtual ~ZipkinCollectorNull() {}
+  void submitZipkinBatch(std::vector<Response> & /* _return */, const std::vector<Span> & /* spans */) {
+    return;
+  }
+};
+
+typedef struct _ZipkinCollector_submitZipkinBatch_args__isset {
+  _ZipkinCollector_submitZipkinBatch_args__isset() : spans(false) {}
+  bool spans :1;
+} _ZipkinCollector_submitZipkinBatch_args__isset;
+
+class ZipkinCollector_submitZipkinBatch_args {
+ public:
+
+  ZipkinCollector_submitZipkinBatch_args(const ZipkinCollector_submitZipkinBatch_args&);
+  ZipkinCollector_submitZipkinBatch_args& operator=(const ZipkinCollector_submitZipkinBatch_args&);
+  ZipkinCollector_submitZipkinBatch_args() {
+  }
+
+  virtual ~ZipkinCollector_submitZipkinBatch_args() noexcept;
+  std::vector<Span>  spans;
+
+  _ZipkinCollector_submitZipkinBatch_args__isset __isset;
+
+  void __set_spans(const std::vector<Span> & val);
+
+  bool operator == (const ZipkinCollector_submitZipkinBatch_args & rhs) const
+  {
+    if (!(spans == rhs.spans))
+      return false;
+    return true;
+  }
+  bool operator != (const ZipkinCollector_submitZipkinBatch_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ZipkinCollector_submitZipkinBatch_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ZipkinCollector_submitZipkinBatch_pargs {
+ public:
+
+
+  virtual ~ZipkinCollector_submitZipkinBatch_pargs() noexcept;
+  const std::vector<Span> * spans;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ZipkinCollector_submitZipkinBatch_result__isset {
+  _ZipkinCollector_submitZipkinBatch_result__isset() : success(false) {}
+  bool success :1;
+} _ZipkinCollector_submitZipkinBatch_result__isset;
+
+class ZipkinCollector_submitZipkinBatch_result {
+ public:
+
+  ZipkinCollector_submitZipkinBatch_result(const ZipkinCollector_submitZipkinBatch_result&);
+  ZipkinCollector_submitZipkinBatch_result& operator=(const ZipkinCollector_submitZipkinBatch_result&);
+  ZipkinCollector_submitZipkinBatch_result() {
+  }
+
+  virtual ~ZipkinCollector_submitZipkinBatch_result() noexcept;
+  std::vector<Response>  success;
+
+  _ZipkinCollector_submitZipkinBatch_result__isset __isset;
+
+  void __set_success(const std::vector<Response> & val);
+
+  bool operator == (const ZipkinCollector_submitZipkinBatch_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const ZipkinCollector_submitZipkinBatch_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ZipkinCollector_submitZipkinBatch_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ZipkinCollector_submitZipkinBatch_presult__isset {
+  _ZipkinCollector_submitZipkinBatch_presult__isset() : success(false) {}
+  bool success :1;
+} _ZipkinCollector_submitZipkinBatch_presult__isset;
+
+class ZipkinCollector_submitZipkinBatch_presult {
+ public:
+
+
+  virtual ~ZipkinCollector_submitZipkinBatch_presult() noexcept;
+  std::vector<Response> * success;
+
+  _ZipkinCollector_submitZipkinBatch_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ZipkinCollectorClient : virtual public ZipkinCollectorIf {
+ public:
+  ZipkinCollectorClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+    setProtocol(prot);
+  }
+  ZipkinCollectorClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    setProtocol(iprot,oprot);
+  }
+ private:
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+  setProtocol(prot,prot);
+  }
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    piprot_=iprot;
+    poprot_=oprot;
+    iprot_ = iprot.get();
+    oprot_ = oprot.get();
+  }
+ public:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+    return piprot_;
+  }
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+    return poprot_;
+  }
+  void submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans);
+  void send_submitZipkinBatch(const std::vector<Span> & spans);
+  void recv_submitZipkinBatch(std::vector<Response> & _return);
+ protected:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
+  ::apache::thrift::protocol::TProtocol* iprot_;
+  ::apache::thrift::protocol::TProtocol* oprot_;
+};
+
+class ZipkinCollectorProcessor : public ::apache::thrift::TDispatchProcessor {
+ protected:
+  ::std::shared_ptr<ZipkinCollectorIf> iface_;
+  virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
+ private:
+  typedef  void (ZipkinCollectorProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
+  typedef std::map<std::string, ProcessFunction> ProcessMap;
+  ProcessMap processMap_;
+  void process_submitZipkinBatch(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+ public:
+  ZipkinCollectorProcessor(::std::shared_ptr<ZipkinCollectorIf> iface) :
+    iface_(iface) {
+    processMap_["submitZipkinBatch"] = &ZipkinCollectorProcessor::process_submitZipkinBatch;
+  }
+
+  virtual ~ZipkinCollectorProcessor() {}
+};
+
+class ZipkinCollectorProcessorFactory : public ::apache::thrift::TProcessorFactory {
+ public:
+  ZipkinCollectorProcessorFactory(const ::std::shared_ptr< ZipkinCollectorIfFactory >& handlerFactory) :
+      handlerFactory_(handlerFactory) {}
+
+  ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
+
+ protected:
+  ::std::shared_ptr< ZipkinCollectorIfFactory > handlerFactory_;
+};
+
+class ZipkinCollectorMultiface : virtual public ZipkinCollectorIf {
+ public:
+  ZipkinCollectorMultiface(std::vector<std::shared_ptr<ZipkinCollectorIf> >& ifaces) : ifaces_(ifaces) {
+  }
+  virtual ~ZipkinCollectorMultiface() {}
+ protected:
+  std::vector<std::shared_ptr<ZipkinCollectorIf> > ifaces_;
+  ZipkinCollectorMultiface() {}
+  void add(::std::shared_ptr<ZipkinCollectorIf> iface) {
+    ifaces_.push_back(iface);
+  }
+ public:
+  void submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->submitZipkinBatch(_return, spans);
+    }
+    ifaces_[i]->submitZipkinBatch(_return, spans);
+    return;
+  }
+
+};
+
+// The 'concurrent' client is a thread safe client that correctly handles
+// out of order responses.  It is slower than the regular client, so should
+// only be used when you need to share a connection among multiple threads
+class ZipkinCollectorConcurrentClient : virtual public ZipkinCollectorIf {
+ public:
+  ZipkinCollectorConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync)
+{
+    setProtocol(prot);
+  }
+  ZipkinCollectorConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) : sync_(sync)
+{
+    setProtocol(iprot,oprot);
+  }
+ private:
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) {
+  setProtocol(prot,prot);
+  }
+  void setProtocol(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) {
+    piprot_=iprot;
+    poprot_=oprot;
+    iprot_ = iprot.get();
+    oprot_ = oprot.get();
+  }
+ public:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+    return piprot_;
+  }
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+    return poprot_;
+  }
+  void submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans);
+  int32_t send_submitZipkinBatch(const std::vector<Span> & spans);
+  void recv_submitZipkinBatch(std::vector<Response> & _return, const int32_t seqid);
+ protected:
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot_;
+  std::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot_;
+  ::apache::thrift::protocol::TProtocol* iprot_;
+  ::apache::thrift::protocol::TProtocol* oprot_;
+  std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync_;
+};
+
+#ifdef _MSC_VER
+  #pragma warning( pop )
+#endif
+
+}}} // namespace
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/ZipkinCollector_server.skeleton.cpp b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/ZipkinCollector_server.skeleton.cpp
new file mode 100644
index 000000000..cca6ef752
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/ZipkinCollector_server.skeleton.cpp
@@ -0,0 +1,42 @@
+// This autogenerated skeleton file illustrates how to build a server.
+// You should copy it to another filename to avoid overwriting it.
+
+#include "ZipkinCollector.h"
+#include <thrift/protocol/TBinaryProtocol.h>
+#include <thrift/server/TSimpleServer.h>
+#include <thrift/transport/TServerSocket.h>
+#include <thrift/transport/TBufferTransports.h>
+
+using namespace ::apache::thrift;
+using namespace ::apache::thrift::protocol;
+using namespace ::apache::thrift::transport;
+using namespace ::apache::thrift::server;
+
+using namespace  ::twitter::zipkin::thrift;
+
+class ZipkinCollectorHandler : virtual public ZipkinCollectorIf {
+ public:
+  ZipkinCollectorHandler() {
+    // Your initialization goes here
+  }
+
+  void submitZipkinBatch(std::vector<Response> & _return, const std::vector<Span> & spans) {
+    // Your implementation goes here
+    printf("submitZipkinBatch\n");
+  }
+
+};
+
+int main(int argc, char **argv) {
+  int port = 9090;
+  ::std::shared_ptr<ZipkinCollectorHandler> handler(new ZipkinCollectorHandler());
+  ::std::shared_ptr<TProcessor> processor(new ZipkinCollectorProcessor(handler));
+  ::std::shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
+  ::std::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
+  ::std::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());
+
+  TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
+  server.serve();
+  return 0;
+}
+
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/agent_types.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/agent_types.h
new file mode 100644
index 000000000..0b576e34f
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/agent_types.h
@@ -0,0 +1,28 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef agent_TYPES_H
+#define agent_TYPES_H
+
+#include <iosfwd>
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/TBase.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+#include <functional>
+#include <memory>
+#include "jaeger_types.h"
+#include "zipkincore_types.h"
+
+
+namespace jaegertracing { namespace agent { namespace thrift {
+
+}}} // namespace
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/jaeger_types.cpp b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/jaeger_types.cpp
new file mode 100644
index 000000000..5e4140cc9
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/jaeger_types.cpp
@@ -0,0 +1,1354 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "jaeger_types.h"
+
+#include <algorithm>
+#include <ostream>
+
+#include <thrift/TToString.h>
+
+namespace jaegertracing { namespace thrift {
+
+int _kTagTypeValues[] = {
+  TagType::STRING,
+  TagType::DOUBLE,
+  TagType::BOOL,
+  TagType::LONG,
+  TagType::BINARY
+};
+const char* _kTagTypeNames[] = {
+  "STRING",
+  "DOUBLE",
+  "BOOL",
+  "LONG",
+  "BINARY"
+};
+const std::map<int, const char*> _TagType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(5, _kTagTypeValues, _kTagTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr));
+
+std::ostream& operator<<(std::ostream& out, const TagType::type& val) {
+  std::map<int, const char*>::const_iterator it = _TagType_VALUES_TO_NAMES.find(val);
+  if (it != _TagType_VALUES_TO_NAMES.end()) {
+    out << it->second;
+  } else {
+    out << static_cast<int>(val);
+  }
+  return out;
+}
+
+std::string to_string(const TagType::type& val) {
+  std::map<int, const char*>::const_iterator it = _TagType_VALUES_TO_NAMES.find(val);
+  if (it != _TagType_VALUES_TO_NAMES.end()) {
+    return std::string(it->second);
+  } else {
+    return std::to_string(static_cast<int>(val));
+  }
+}
+
+int _kSpanRefTypeValues[] = {
+  SpanRefType::CHILD_OF,
+  SpanRefType::FOLLOWS_FROM
+};
+const char* _kSpanRefTypeNames[] = {
+  "CHILD_OF",
+  "FOLLOWS_FROM"
+};
+const std::map<int, const char*> _SpanRefType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(2, _kSpanRefTypeValues, _kSpanRefTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr));
+
+std::ostream& operator<<(std::ostream& out, const SpanRefType::type& val) {
+  std::map<int, const char*>::const_iterator it = _SpanRefType_VALUES_TO_NAMES.find(val);
+  if (it != _SpanRefType_VALUES_TO_NAMES.end()) {
+    out << it->second;
+  } else {
+    out << static_cast<int>(val);
+  }
+  return out;
+}
+
+std::string to_string(const SpanRefType::type& val) {
+  std::map<int, const char*>::const_iterator it = _SpanRefType_VALUES_TO_NAMES.find(val);
+  if (it != _SpanRefType_VALUES_TO_NAMES.end()) {
+    return std::string(it->second);
+  } else {
+    return std::to_string(static_cast<int>(val));
+  }
+}
+
+
+Tag::~Tag() noexcept {
+}
+
+
+void Tag::__set_key(const std::string& val) {
+  this->key = val;
+}
+
+void Tag::__set_vType(const TagType::type val) {
+  this->vType = val;
+}
+
+void Tag::__set_vStr(const std::string& val) {
+  this->vStr = val;
+__isset.vStr = true;
+}
+
+void Tag::__set_vDouble(const double val) {
+  this->vDouble = val;
+__isset.vDouble = true;
+}
+
+void Tag::__set_vBool(const bool val) {
+  this->vBool = val;
+__isset.vBool = true;
+}
+
+void Tag::__set_vLong(const int64_t val) {
+  this->vLong = val;
+__isset.vLong = true;
+}
+
+void Tag::__set_vBinary(const std::string& val) {
+  this->vBinary = val;
+__isset.vBinary = true;
+}
+std::ostream& operator<<(std::ostream& out, const Tag& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+uint32_t Tag::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_key = false;
+  bool isset_vType = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->key);
+          isset_key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast0;
+          xfer += iprot->readI32(ecast0);
+          this->vType = (TagType::type)ecast0;
+          isset_vType = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->vStr);
+          this->__isset.vStr = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_DOUBLE) {
+          xfer += iprot->readDouble(this->vDouble);
+          this->__isset.vDouble = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->vBool);
+          this->__isset.vBool = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->vLong);
+          this->__isset.vLong = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 7:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->vBinary);
+          this->__isset.vBinary = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_key)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_vType)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Tag::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Tag");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->key);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("vType", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32((int32_t)this->vType);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.vStr) {
+    xfer += oprot->writeFieldBegin("vStr", ::apache::thrift::protocol::T_STRING, 3);
+    xfer += oprot->writeString(this->vStr);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.vDouble) {
+    xfer += oprot->writeFieldBegin("vDouble", ::apache::thrift::protocol::T_DOUBLE, 4);
+    xfer += oprot->writeDouble(this->vDouble);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.vBool) {
+    xfer += oprot->writeFieldBegin("vBool", ::apache::thrift::protocol::T_BOOL, 5);
+    xfer += oprot->writeBool(this->vBool);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.vLong) {
+    xfer += oprot->writeFieldBegin("vLong", ::apache::thrift::protocol::T_I64, 6);
+    xfer += oprot->writeI64(this->vLong);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.vBinary) {
+    xfer += oprot->writeFieldBegin("vBinary", ::apache::thrift::protocol::T_STRING, 7);
+    xfer += oprot->writeBinary(this->vBinary);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Tag &a, Tag &b) {
+  using ::std::swap;
+  swap(a.key, b.key);
+  swap(a.vType, b.vType);
+  swap(a.vStr, b.vStr);
+  swap(a.vDouble, b.vDouble);
+  swap(a.vBool, b.vBool);
+  swap(a.vLong, b.vLong);
+  swap(a.vBinary, b.vBinary);
+  swap(a.__isset, b.__isset);
+}
+
+Tag::Tag(const Tag& other1) {
+  key = other1.key;
+  vType = other1.vType;
+  vStr = other1.vStr;
+  vDouble = other1.vDouble;
+  vBool = other1.vBool;
+  vLong = other1.vLong;
+  vBinary = other1.vBinary;
+  __isset = other1.__isset;
+}
+Tag& Tag::operator=(const Tag& other2) {
+  key = other2.key;
+  vType = other2.vType;
+  vStr = other2.vStr;
+  vDouble = other2.vDouble;
+  vBool = other2.vBool;
+  vLong = other2.vLong;
+  vBinary = other2.vBinary;
+  __isset = other2.__isset;
+  return *this;
+}
+void Tag::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "Tag(";
+  out << "key=" << to_string(key);
+  out << ", " << "vType=" << to_string(vType);
+  out << ", " << "vStr="; (__isset.vStr ? (out << to_string(vStr)) : (out << "<null>"));
+  out << ", " << "vDouble="; (__isset.vDouble ? (out << to_string(vDouble)) : (out << "<null>"));
+  out << ", " << "vBool="; (__isset.vBool ? (out << to_string(vBool)) : (out << "<null>"));
+  out << ", " << "vLong="; (__isset.vLong ? (out << to_string(vLong)) : (out << "<null>"));
+  out << ", " << "vBinary="; (__isset.vBinary ? (out << to_string(vBinary)) : (out << "<null>"));
+  out << ")";
+}
+
+
+Log::~Log() noexcept {
+}
+
+
+void Log::__set_timestamp(const int64_t val) {
+  this->timestamp = val;
+}
+
+void Log::__set_fields(const std::vector<Tag> & val) {
+  this->fields = val;
+}
+std::ostream& operator<<(std::ostream& out, const Log& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+uint32_t Log::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_timestamp = false;
+  bool isset_fields = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->timestamp);
+          isset_timestamp = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->fields.clear();
+            uint32_t _size3;
+            ::apache::thrift::protocol::TType _etype6;
+            xfer += iprot->readListBegin(_etype6, _size3);
+            this->fields.resize(_size3);
+            uint32_t _i7;
+            for (_i7 = 0; _i7 < _size3; ++_i7)
+            {
+              xfer += this->fields[_i7].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_fields = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_timestamp)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_fields)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Log::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Log");
+
+  xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 1);
+  xfer += oprot->writeI64(this->timestamp);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("fields", ::apache::thrift::protocol::T_LIST, 2);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->fields.size()));
+    std::vector<Tag> ::const_iterator _iter8;
+    for (_iter8 = this->fields.begin(); _iter8 != this->fields.end(); ++_iter8)
+    {
+      xfer += (*_iter8).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Log &a, Log &b) {
+  using ::std::swap;
+  swap(a.timestamp, b.timestamp);
+  swap(a.fields, b.fields);
+}
+
+Log::Log(const Log& other9) {
+  timestamp = other9.timestamp;
+  fields = other9.fields;
+}
+Log& Log::operator=(const Log& other10) {
+  timestamp = other10.timestamp;
+  fields = other10.fields;
+  return *this;
+}
+void Log::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "Log(";
+  out << "timestamp=" << to_string(timestamp);
+  out << ", " << "fields=" << to_string(fields);
+  out << ")";
+}
+
+
+SpanRef::~SpanRef() noexcept {
+}
+
+
+void SpanRef::__set_refType(const SpanRefType::type val) {
+  this->refType = val;
+}
+
+void SpanRef::__set_traceIdLow(const int64_t val) {
+  this->traceIdLow = val;
+}
+
+void SpanRef::__set_traceIdHigh(const int64_t val) {
+  this->traceIdHigh = val;
+}
+
+void SpanRef::__set_spanId(const int64_t val) {
+  this->spanId = val;
+}
+std::ostream& operator<<(std::ostream& out, const SpanRef& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+uint32_t SpanRef::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_refType = false;
+  bool isset_traceIdLow = false;
+  bool isset_traceIdHigh = false;
+  bool isset_spanId = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast11;
+          xfer += iprot->readI32(ecast11);
+          this->refType = (SpanRefType::type)ecast11;
+          isset_refType = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->traceIdLow);
+          isset_traceIdLow = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->traceIdHigh);
+          isset_traceIdHigh = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->spanId);
+          isset_spanId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_refType)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_traceIdLow)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_traceIdHigh)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_spanId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t SpanRef::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("SpanRef");
+
+  xfer += oprot->writeFieldBegin("refType", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->refType);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("traceIdLow", ::apache::thrift::protocol::T_I64, 2);
+  xfer += oprot->writeI64(this->traceIdLow);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("traceIdHigh", ::apache::thrift::protocol::T_I64, 3);
+  xfer += oprot->writeI64(this->traceIdHigh);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("spanId", ::apache::thrift::protocol::T_I64, 4);
+  xfer += oprot->writeI64(this->spanId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(SpanRef &a, SpanRef &b) {
+  using ::std::swap;
+  swap(a.refType, b.refType);
+  swap(a.traceIdLow, b.traceIdLow);
+  swap(a.traceIdHigh, b.traceIdHigh);
+  swap(a.spanId, b.spanId);
+}
+
+SpanRef::SpanRef(const SpanRef& other12) {
+  refType = other12.refType;
+  traceIdLow = other12.traceIdLow;
+  traceIdHigh = other12.traceIdHigh;
+  spanId = other12.spanId;
+}
+SpanRef& SpanRef::operator=(const SpanRef& other13) {
+  refType = other13.refType;
+  traceIdLow = other13.traceIdLow;
+  traceIdHigh = other13.traceIdHigh;
+  spanId = other13.spanId;
+  return *this;
+}
+void SpanRef::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "SpanRef(";
+  out << "refType=" << to_string(refType);
+  out << ", " << "traceIdLow=" << to_string(traceIdLow);
+  out << ", " << "traceIdHigh=" << to_string(traceIdHigh);
+  out << ", " << "spanId=" << to_string(spanId);
+  out << ")";
+}
+
+
+Span::~Span() noexcept {
+}
+
+
+void Span::__set_traceIdLow(const int64_t val) {
+  this->traceIdLow = val;
+}
+
+void Span::__set_traceIdHigh(const int64_t val) {
+  this->traceIdHigh = val;
+}
+
+void Span::__set_spanId(const int64_t val) {
+  this->spanId = val;
+}
+
+void Span::__set_parentSpanId(const int64_t val) {
+  this->parentSpanId = val;
+}
+
+void Span::__set_operationName(const std::string& val) {
+  this->operationName = val;
+}
+
+void Span::__set_references(const std::vector<SpanRef> & val) {
+  this->references = val;
+__isset.references = true;
+}
+
+void Span::__set_flags(const int32_t val) {
+  this->flags = val;
+}
+
+void Span::__set_startTime(const int64_t val) {
+  this->startTime = val;
+}
+
+void Span::__set_duration(const int64_t val) {
+  this->duration = val;
+}
+
+void Span::__set_tags(const std::vector<Tag> & val) {
+  this->tags = val;
+__isset.tags = true;
+}
+
+void Span::__set_logs(const std::vector<Log> & val) {
+  this->logs = val;
+__isset.logs = true;
+}
+std::ostream& operator<<(std::ostream& out, const Span& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+uint32_t Span::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_traceIdLow = false;
+  bool isset_traceIdHigh = false;
+  bool isset_spanId = false;
+  bool isset_parentSpanId = false;
+  bool isset_operationName = false;
+  bool isset_flags = false;
+  bool isset_startTime = false;
+  bool isset_duration = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->traceIdLow);
+          isset_traceIdLow = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->traceIdHigh);
+          isset_traceIdHigh = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->spanId);
+          isset_spanId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->parentSpanId);
+          isset_parentSpanId = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->operationName);
+          isset_operationName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->references.clear();
+            uint32_t _size14;
+            ::apache::thrift::protocol::TType _etype17;
+            xfer += iprot->readListBegin(_etype17, _size14);
+            this->references.resize(_size14);
+            uint32_t _i18;
+            for (_i18 = 0; _i18 < _size14; ++_i18)
+            {
+              xfer += this->references[_i18].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.references = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 7:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->flags);
+          isset_flags = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 8:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->startTime);
+          isset_startTime = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 9:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->duration);
+          isset_duration = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 10:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->tags.clear();
+            uint32_t _size19;
+            ::apache::thrift::protocol::TType _etype22;
+            xfer += iprot->readListBegin(_etype22, _size19);
+            this->tags.resize(_size19);
+            uint32_t _i23;
+            for (_i23 = 0; _i23 < _size19; ++_i23)
+            {
+              xfer += this->tags[_i23].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.tags = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 11:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->logs.clear();
+            uint32_t _size24;
+            ::apache::thrift::protocol::TType _etype27;
+            xfer += iprot->readListBegin(_etype27, _size24);
+            this->logs.resize(_size24);
+            uint32_t _i28;
+            for (_i28 = 0; _i28 < _size24; ++_i28)
+            {
+              xfer += this->logs[_i28].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.logs = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_traceIdLow)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_traceIdHigh)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_spanId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_parentSpanId)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_operationName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_flags)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_startTime)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_duration)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Span::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Span");
+
+  xfer += oprot->writeFieldBegin("traceIdLow", ::apache::thrift::protocol::T_I64, 1);
+  xfer += oprot->writeI64(this->traceIdLow);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("traceIdHigh", ::apache::thrift::protocol::T_I64, 2);
+  xfer += oprot->writeI64(this->traceIdHigh);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("spanId", ::apache::thrift::protocol::T_I64, 3);
+  xfer += oprot->writeI64(this->spanId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("parentSpanId", ::apache::thrift::protocol::T_I64, 4);
+  xfer += oprot->writeI64(this->parentSpanId);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("operationName", ::apache::thrift::protocol::T_STRING, 5);
+  xfer += oprot->writeString(this->operationName);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.references) {
+    xfer += oprot->writeFieldBegin("references", ::apache::thrift::protocol::T_LIST, 6);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->references.size()));
+      std::vector<SpanRef> ::const_iterator _iter29;
+      for (_iter29 = this->references.begin(); _iter29 != this->references.end(); ++_iter29)
+      {
+        xfer += (*_iter29).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldBegin("flags", ::apache::thrift::protocol::T_I32, 7);
+  xfer += oprot->writeI32(this->flags);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("startTime", ::apache::thrift::protocol::T_I64, 8);
+  xfer += oprot->writeI64(this->startTime);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("duration", ::apache::thrift::protocol::T_I64, 9);
+  xfer += oprot->writeI64(this->duration);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.tags) {
+    xfer += oprot->writeFieldBegin("tags", ::apache::thrift::protocol::T_LIST, 10);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->tags.size()));
+      std::vector<Tag> ::const_iterator _iter30;
+      for (_iter30 = this->tags.begin(); _iter30 != this->tags.end(); ++_iter30)
+      {
+        xfer += (*_iter30).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.logs) {
+    xfer += oprot->writeFieldBegin("logs", ::apache::thrift::protocol::T_LIST, 11);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->logs.size()));
+      std::vector<Log> ::const_iterator _iter31;
+      for (_iter31 = this->logs.begin(); _iter31 != this->logs.end(); ++_iter31)
+      {
+        xfer += (*_iter31).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Span &a, Span &b) {
+  using ::std::swap;
+  swap(a.traceIdLow, b.traceIdLow);
+  swap(a.traceIdHigh, b.traceIdHigh);
+  swap(a.spanId, b.spanId);
+  swap(a.parentSpanId, b.parentSpanId);
+  swap(a.operationName, b.operationName);
+  swap(a.references, b.references);
+  swap(a.flags, b.flags);
+  swap(a.startTime, b.startTime);
+  swap(a.duration, b.duration);
+  swap(a.tags, b.tags);
+  swap(a.logs, b.logs);
+  swap(a.__isset, b.__isset);
+}
+
+Span::Span(const Span& other32) {
+  traceIdLow = other32.traceIdLow;
+  traceIdHigh = other32.traceIdHigh;
+  spanId = other32.spanId;
+  parentSpanId = other32.parentSpanId;
+  operationName = other32.operationName;
+  references = other32.references;
+  flags = other32.flags;
+  startTime = other32.startTime;
+  duration = other32.duration;
+  tags = other32.tags;
+  logs = other32.logs;
+  __isset = other32.__isset;
+}
+Span& Span::operator=(const Span& other33) {
+  traceIdLow = other33.traceIdLow;
+  traceIdHigh = other33.traceIdHigh;
+  spanId = other33.spanId;
+  parentSpanId = other33.parentSpanId;
+  operationName = other33.operationName;
+  references = other33.references;
+  flags = other33.flags;
+  startTime = other33.startTime;
+  duration = other33.duration;
+  tags = other33.tags;
+  logs = other33.logs;
+  __isset = other33.__isset;
+  return *this;
+}
+void Span::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "Span(";
+  out << "traceIdLow=" << to_string(traceIdLow);
+  out << ", " << "traceIdHigh=" << to_string(traceIdHigh);
+  out << ", " << "spanId=" << to_string(spanId);
+  out << ", " << "parentSpanId=" << to_string(parentSpanId);
+  out << ", " << "operationName=" << to_string(operationName);
+  out << ", " << "references="; (__isset.references ? (out << to_string(references)) : (out << "<null>"));
+  out << ", " << "flags=" << to_string(flags);
+  out << ", " << "startTime=" << to_string(startTime);
+  out << ", " << "duration=" << to_string(duration);
+  out << ", " << "tags="; (__isset.tags ? (out << to_string(tags)) : (out << "<null>"));
+  out << ", " << "logs="; (__isset.logs ? (out << to_string(logs)) : (out << "<null>"));
+  out << ")";
+}
+
+
+Process::~Process() noexcept {
+}
+
+
+void Process::__set_serviceName(const std::string& val) {
+  this->serviceName = val;
+}
+
+void Process::__set_tags(const std::vector<Tag> & val) {
+  this->tags = val;
+__isset.tags = true;
+}
+std::ostream& operator<<(std::ostream& out, const Process& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+uint32_t Process::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_serviceName = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->serviceName);
+          isset_serviceName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->tags.clear();
+            uint32_t _size34;
+            ::apache::thrift::protocol::TType _etype37;
+            xfer += iprot->readListBegin(_etype37, _size34);
+            this->tags.resize(_size34);
+            uint32_t _i38;
+            for (_i38 = 0; _i38 < _size34; ++_i38)
+            {
+              xfer += this->tags[_i38].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.tags = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_serviceName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Process::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Process");
+
+  xfer += oprot->writeFieldBegin("serviceName", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->serviceName);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.tags) {
+    xfer += oprot->writeFieldBegin("tags", ::apache::thrift::protocol::T_LIST, 2);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->tags.size()));
+      std::vector<Tag> ::const_iterator _iter39;
+      for (_iter39 = this->tags.begin(); _iter39 != this->tags.end(); ++_iter39)
+      {
+        xfer += (*_iter39).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Process &a, Process &b) {
+  using ::std::swap;
+  swap(a.serviceName, b.serviceName);
+  swap(a.tags, b.tags);
+  swap(a.__isset, b.__isset);
+}
+
+Process::Process(const Process& other40) {
+  serviceName = other40.serviceName;
+  tags = other40.tags;
+  __isset = other40.__isset;
+}
+Process& Process::operator=(const Process& other41) {
+  serviceName = other41.serviceName;
+  tags = other41.tags;
+  __isset = other41.__isset;
+  return *this;
+}
+void Process::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "Process(";
+  out << "serviceName=" << to_string(serviceName);
+  out << ", " << "tags="; (__isset.tags ? (out << to_string(tags)) : (out << "<null>"));
+  out << ")";
+}
+
+
+Batch::~Batch() noexcept {
+}
+
+
+void Batch::__set_process(const Process& val) {
+  this->process = val;
+}
+
+void Batch::__set_spans(const std::vector<Span> & val) {
+  this->spans = val;
+}
+std::ostream& operator<<(std::ostream& out, const Batch& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+uint32_t Batch::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_process = false;
+  bool isset_spans = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->process.read(iprot);
+          isset_process = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->spans.clear();
+            uint32_t _size42;
+            ::apache::thrift::protocol::TType _etype45;
+            xfer += iprot->readListBegin(_etype45, _size42);
+            this->spans.resize(_size42);
+            uint32_t _i46;
+            for (_i46 = 0; _i46 < _size42; ++_i46)
+            {
+              xfer += this->spans[_i46].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_spans = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_process)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_spans)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Batch::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Batch");
+
+  xfer += oprot->writeFieldBegin("process", ::apache::thrift::protocol::T_STRUCT, 1);
+  xfer += this->process.write(oprot);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("spans", ::apache::thrift::protocol::T_LIST, 2);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->spans.size()));
+    std::vector<Span> ::const_iterator _iter47;
+    for (_iter47 = this->spans.begin(); _iter47 != this->spans.end(); ++_iter47)
+    {
+      xfer += (*_iter47).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Batch &a, Batch &b) {
+  using ::std::swap;
+  swap(a.process, b.process);
+  swap(a.spans, b.spans);
+}
+
+Batch::Batch(const Batch& other48) {
+  process = other48.process;
+  spans = other48.spans;
+}
+Batch& Batch::operator=(const Batch& other49) {
+  process = other49.process;
+  spans = other49.spans;
+  return *this;
+}
+void Batch::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "Batch(";
+  out << "process=" << to_string(process);
+  out << ", " << "spans=" << to_string(spans);
+  out << ")";
+}
+
+
+BatchSubmitResponse::~BatchSubmitResponse() noexcept {
+}
+
+
+void BatchSubmitResponse::__set_ok(const bool val) {
+  this->ok = val;
+}
+std::ostream& operator<<(std::ostream& out, const BatchSubmitResponse& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+uint32_t BatchSubmitResponse::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_ok = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->ok);
+          isset_ok = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_ok)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t BatchSubmitResponse::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("BatchSubmitResponse");
+
+  xfer += oprot->writeFieldBegin("ok", ::apache::thrift::protocol::T_BOOL, 1);
+  xfer += oprot->writeBool(this->ok);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(BatchSubmitResponse &a, BatchSubmitResponse &b) {
+  using ::std::swap;
+  swap(a.ok, b.ok);
+}
+
+BatchSubmitResponse::BatchSubmitResponse(const BatchSubmitResponse& other50) {
+  ok = other50.ok;
+}
+BatchSubmitResponse& BatchSubmitResponse::operator=(const BatchSubmitResponse& other51) {
+  ok = other51.ok;
+  return *this;
+}
+void BatchSubmitResponse::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "BatchSubmitResponse(";
+  out << "ok=" << to_string(ok);
+  out << ")";
+}
+
+}} // namespace
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/jaeger_types.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/jaeger_types.h
new file mode 100644
index 000000000..b30a3740b
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/jaeger_types.h
@@ -0,0 +1,481 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef jaeger_TYPES_H
+#define jaeger_TYPES_H
+
+#include <iosfwd>
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/TBase.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+#include <functional>
+#include <memory>
+
+
+namespace jaegertracing { namespace thrift {
+
+struct TagType {
+  enum type {
+    STRING = 0,
+    DOUBLE = 1,
+    BOOL = 2,
+    LONG = 3,
+    BINARY = 4
+  };
+};
+
+extern const std::map<int, const char*> _TagType_VALUES_TO_NAMES;
+
+std::ostream& operator<<(std::ostream& out, const TagType::type& val);
+
+std::string to_string(const TagType::type& val);
+
+struct SpanRefType {
+  enum type {
+    CHILD_OF = 0,
+    FOLLOWS_FROM = 1
+  };
+};
+
+extern const std::map<int, const char*> _SpanRefType_VALUES_TO_NAMES;
+
+std::ostream& operator<<(std::ostream& out, const SpanRefType::type& val);
+
+std::string to_string(const SpanRefType::type& val);
+
+class Tag;
+
+class Log;
+
+class SpanRef;
+
+class Span;
+
+class Process;
+
+class Batch;
+
+class BatchSubmitResponse;
+
+typedef struct _Tag__isset {
+  _Tag__isset() : vStr(false), vDouble(false), vBool(false), vLong(false), vBinary(false) {}
+  bool vStr :1;
+  bool vDouble :1;
+  bool vBool :1;
+  bool vLong :1;
+  bool vBinary :1;
+} _Tag__isset;
+
+class Tag : public virtual ::apache::thrift::TBase {
+ public:
+
+  Tag(const Tag&);
+  Tag& operator=(const Tag&);
+  Tag() : key(), vType((TagType::type)0), vStr(), vDouble(0), vBool(0), vLong(0), vBinary() {
+  }
+
+  virtual ~Tag() noexcept;
+  std::string key;
+  /**
+   * 
+   * @see TagType
+   */
+  TagType::type vType;
+  std::string vStr;
+  double vDouble;
+  bool vBool;
+  int64_t vLong;
+  std::string vBinary;
+
+  _Tag__isset __isset;
+
+  void __set_key(const std::string& val);
+
+  void __set_vType(const TagType::type val);
+
+  void __set_vStr(const std::string& val);
+
+  void __set_vDouble(const double val);
+
+  void __set_vBool(const bool val);
+
+  void __set_vLong(const int64_t val);
+
+  void __set_vBinary(const std::string& val);
+
+  bool operator == (const Tag & rhs) const
+  {
+    if (!(key == rhs.key))
+      return false;
+    if (!(vType == rhs.vType))
+      return false;
+    if (__isset.vStr != rhs.__isset.vStr)
+      return false;
+    else if (__isset.vStr && !(vStr == rhs.vStr))
+      return false;
+    if (__isset.vDouble != rhs.__isset.vDouble)
+      return false;
+    else if (__isset.vDouble && !(vDouble == rhs.vDouble))
+      return false;
+    if (__isset.vBool != rhs.__isset.vBool)
+      return false;
+    else if (__isset.vBool && !(vBool == rhs.vBool))
+      return false;
+    if (__isset.vLong != rhs.__isset.vLong)
+      return false;
+    else if (__isset.vLong && !(vLong == rhs.vLong))
+      return false;
+    if (__isset.vBinary != rhs.__isset.vBinary)
+      return false;
+    else if (__isset.vBinary && !(vBinary == rhs.vBinary))
+      return false;
+    return true;
+  }
+  bool operator != (const Tag &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Tag & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Tag &a, Tag &b);
+
+std::ostream& operator<<(std::ostream& out, const Tag& obj);
+
+
+class Log : public virtual ::apache::thrift::TBase {
+ public:
+
+  Log(const Log&);
+  Log& operator=(const Log&);
+  Log() : timestamp(0) {
+  }
+
+  virtual ~Log() noexcept;
+  int64_t timestamp;
+  std::vector<Tag>  fields;
+
+  void __set_timestamp(const int64_t val);
+
+  void __set_fields(const std::vector<Tag> & val);
+
+  bool operator == (const Log & rhs) const
+  {
+    if (!(timestamp == rhs.timestamp))
+      return false;
+    if (!(fields == rhs.fields))
+      return false;
+    return true;
+  }
+  bool operator != (const Log &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Log & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Log &a, Log &b);
+
+std::ostream& operator<<(std::ostream& out, const Log& obj);
+
+
+class SpanRef : public virtual ::apache::thrift::TBase {
+ public:
+
+  SpanRef(const SpanRef&);
+  SpanRef& operator=(const SpanRef&);
+  SpanRef() : refType((SpanRefType::type)0), traceIdLow(0), traceIdHigh(0), spanId(0) {
+  }
+
+  virtual ~SpanRef() noexcept;
+  /**
+   * 
+   * @see SpanRefType
+   */
+  SpanRefType::type refType;
+  int64_t traceIdLow;
+  int64_t traceIdHigh;
+  int64_t spanId;
+
+  void __set_refType(const SpanRefType::type val);
+
+  void __set_traceIdLow(const int64_t val);
+
+  void __set_traceIdHigh(const int64_t val);
+
+  void __set_spanId(const int64_t val);
+
+  bool operator == (const SpanRef & rhs) const
+  {
+    if (!(refType == rhs.refType))
+      return false;
+    if (!(traceIdLow == rhs.traceIdLow))
+      return false;
+    if (!(traceIdHigh == rhs.traceIdHigh))
+      return false;
+    if (!(spanId == rhs.spanId))
+      return false;
+    return true;
+  }
+  bool operator != (const SpanRef &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const SpanRef & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(SpanRef &a, SpanRef &b);
+
+std::ostream& operator<<(std::ostream& out, const SpanRef& obj);
+
+typedef struct _Span__isset {
+  _Span__isset() : references(false), tags(false), logs(false) {}
+  bool references :1;
+  bool tags :1;
+  bool logs :1;
+} _Span__isset;
+
+class Span : public virtual ::apache::thrift::TBase {
+ public:
+
+  Span(const Span&);
+  Span& operator=(const Span&);
+  Span() : traceIdLow(0), traceIdHigh(0), spanId(0), parentSpanId(0), operationName(), flags(0), startTime(0), duration(0) {
+  }
+
+  virtual ~Span() noexcept;
+  int64_t traceIdLow;
+  int64_t traceIdHigh;
+  int64_t spanId;
+  int64_t parentSpanId;
+  std::string operationName;
+  std::vector<SpanRef>  references;
+  int32_t flags;
+  int64_t startTime;
+  int64_t duration;
+  std::vector<Tag>  tags;
+  std::vector<Log>  logs;
+
+  _Span__isset __isset;
+
+  void __set_traceIdLow(const int64_t val);
+
+  void __set_traceIdHigh(const int64_t val);
+
+  void __set_spanId(const int64_t val);
+
+  void __set_parentSpanId(const int64_t val);
+
+  void __set_operationName(const std::string& val);
+
+  void __set_references(const std::vector<SpanRef> & val);
+
+  void __set_flags(const int32_t val);
+
+  void __set_startTime(const int64_t val);
+
+  void __set_duration(const int64_t val);
+
+  void __set_tags(const std::vector<Tag> & val);
+
+  void __set_logs(const std::vector<Log> & val);
+
+  bool operator == (const Span & rhs) const
+  {
+    if (!(traceIdLow == rhs.traceIdLow))
+      return false;
+    if (!(traceIdHigh == rhs.traceIdHigh))
+      return false;
+    if (!(spanId == rhs.spanId))
+      return false;
+    if (!(parentSpanId == rhs.parentSpanId))
+      return false;
+    if (!(operationName == rhs.operationName))
+      return false;
+    if (__isset.references != rhs.__isset.references)
+      return false;
+    else if (__isset.references && !(references == rhs.references))
+      return false;
+    if (!(flags == rhs.flags))
+      return false;
+    if (!(startTime == rhs.startTime))
+      return false;
+    if (!(duration == rhs.duration))
+      return false;
+    if (__isset.tags != rhs.__isset.tags)
+      return false;
+    else if (__isset.tags && !(tags == rhs.tags))
+      return false;
+    if (__isset.logs != rhs.__isset.logs)
+      return false;
+    else if (__isset.logs && !(logs == rhs.logs))
+      return false;
+    return true;
+  }
+  bool operator != (const Span &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Span & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Span &a, Span &b);
+
+std::ostream& operator<<(std::ostream& out, const Span& obj);
+
+typedef struct _Process__isset {
+  _Process__isset() : tags(false) {}
+  bool tags :1;
+} _Process__isset;
+
+class Process : public virtual ::apache::thrift::TBase {
+ public:
+
+  Process(const Process&);
+  Process& operator=(const Process&);
+  Process() : serviceName() {
+  }
+
+  virtual ~Process() noexcept;
+  std::string serviceName;
+  std::vector<Tag>  tags;
+
+  _Process__isset __isset;
+
+  void __set_serviceName(const std::string& val);
+
+  void __set_tags(const std::vector<Tag> & val);
+
+  bool operator == (const Process & rhs) const
+  {
+    if (!(serviceName == rhs.serviceName))
+      return false;
+    if (__isset.tags != rhs.__isset.tags)
+      return false;
+    else if (__isset.tags && !(tags == rhs.tags))
+      return false;
+    return true;
+  }
+  bool operator != (const Process &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Process & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Process &a, Process &b);
+
+std::ostream& operator<<(std::ostream& out, const Process& obj);
+
+
+class Batch : public virtual ::apache::thrift::TBase {
+ public:
+
+  Batch(const Batch&);
+  Batch& operator=(const Batch&);
+  Batch() {
+  }
+
+  virtual ~Batch() noexcept;
+  Process process;
+  std::vector<Span>  spans;
+
+  void __set_process(const Process& val);
+
+  void __set_spans(const std::vector<Span> & val);
+
+  bool operator == (const Batch & rhs) const
+  {
+    if (!(process == rhs.process))
+      return false;
+    if (!(spans == rhs.spans))
+      return false;
+    return true;
+  }
+  bool operator != (const Batch &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Batch & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Batch &a, Batch &b);
+
+std::ostream& operator<<(std::ostream& out, const Batch& obj);
+
+
+class BatchSubmitResponse : public virtual ::apache::thrift::TBase {
+ public:
+
+  BatchSubmitResponse(const BatchSubmitResponse&);
+  BatchSubmitResponse& operator=(const BatchSubmitResponse&);
+  BatchSubmitResponse() : ok(0) {
+  }
+
+  virtual ~BatchSubmitResponse() noexcept;
+  bool ok;
+
+  void __set_ok(const bool val);
+
+  bool operator == (const BatchSubmitResponse & rhs) const
+  {
+    if (!(ok == rhs.ok))
+      return false;
+    return true;
+  }
+  bool operator != (const BatchSubmitResponse &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const BatchSubmitResponse & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(BatchSubmitResponse &a, BatchSubmitResponse &b);
+
+std::ostream& operator<<(std::ostream& out, const BatchSubmitResponse& obj);
+
+}} // namespace
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/zipkincore_constants.cpp b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/zipkincore_constants.cpp
new file mode 100644
index 000000000..8dd451e48
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/zipkincore_constants.cpp
@@ -0,0 +1,49 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "zipkincore_constants.h"
+
+namespace twitter { namespace zipkin { namespace thrift {
+
+const zipkincoreConstants g_zipkincore_constants;
+
+zipkincoreConstants::zipkincoreConstants() {
+  CLIENT_SEND = "cs";
+
+  CLIENT_RECV = "cr";
+
+  SERVER_SEND = "ss";
+
+  SERVER_RECV = "sr";
+
+  MESSAGE_SEND = "ms";
+
+  MESSAGE_RECV = "mr";
+
+  WIRE_SEND = "ws";
+
+  WIRE_RECV = "wr";
+
+  CLIENT_SEND_FRAGMENT = "csf";
+
+  CLIENT_RECV_FRAGMENT = "crf";
+
+  SERVER_SEND_FRAGMENT = "ssf";
+
+  SERVER_RECV_FRAGMENT = "srf";
+
+  LOCAL_COMPONENT = "lc";
+
+  CLIENT_ADDR = "ca";
+
+  SERVER_ADDR = "sa";
+
+  MESSAGE_ADDR = "ma";
+
+}
+
+}}} // namespace
+
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/zipkincore_constants.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/zipkincore_constants.h
new file mode 100644
index 000000000..22b4b3b67
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/zipkincore_constants.h
@@ -0,0 +1,40 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef zipkincore_CONSTANTS_H
+#define zipkincore_CONSTANTS_H
+
+#include "zipkincore_types.h"
+
+namespace twitter { namespace zipkin { namespace thrift {
+
+class zipkincoreConstants {
+ public:
+  zipkincoreConstants();
+
+  std::string CLIENT_SEND;
+  std::string CLIENT_RECV;
+  std::string SERVER_SEND;
+  std::string SERVER_RECV;
+  std::string MESSAGE_SEND;
+  std::string MESSAGE_RECV;
+  std::string WIRE_SEND;
+  std::string WIRE_RECV;
+  std::string CLIENT_SEND_FRAGMENT;
+  std::string CLIENT_RECV_FRAGMENT;
+  std::string SERVER_SEND_FRAGMENT;
+  std::string SERVER_RECV_FRAGMENT;
+  std::string LOCAL_COMPONENT;
+  std::string CLIENT_ADDR;
+  std::string SERVER_ADDR;
+  std::string MESSAGE_ADDR;
+};
+
+extern const zipkincoreConstants g_zipkincore_constants;
+
+}}} // namespace
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/zipkincore_types.cpp b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/zipkincore_types.cpp
new file mode 100644
index 000000000..a8b52e902
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/zipkincore_types.cpp
@@ -0,0 +1,913 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#include "zipkincore_types.h"
+
+#include <algorithm>
+#include <ostream>
+
+#include <thrift/TToString.h>
+
+namespace twitter { namespace zipkin { namespace thrift {
+
+int _kAnnotationTypeValues[] = {
+  AnnotationType::BOOL,
+  AnnotationType::BYTES,
+  AnnotationType::I16,
+  AnnotationType::I32,
+  AnnotationType::I64,
+  AnnotationType::DOUBLE,
+  AnnotationType::STRING
+};
+const char* _kAnnotationTypeNames[] = {
+  "BOOL",
+  "BYTES",
+  "I16",
+  "I32",
+  "I64",
+  "DOUBLE",
+  "STRING"
+};
+const std::map<int, const char*> _AnnotationType_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(7, _kAnnotationTypeValues, _kAnnotationTypeNames), ::apache::thrift::TEnumIterator(-1, nullptr, nullptr));
+
+std::ostream& operator<<(std::ostream& out, const AnnotationType::type& val) {
+  std::map<int, const char*>::const_iterator it = _AnnotationType_VALUES_TO_NAMES.find(val);
+  if (it != _AnnotationType_VALUES_TO_NAMES.end()) {
+    out << it->second;
+  } else {
+    out << static_cast<int>(val);
+  }
+  return out;
+}
+
+std::string to_string(const AnnotationType::type& val) {
+  std::map<int, const char*>::const_iterator it = _AnnotationType_VALUES_TO_NAMES.find(val);
+  if (it != _AnnotationType_VALUES_TO_NAMES.end()) {
+    return std::string(it->second);
+  } else {
+    return std::to_string(static_cast<int>(val));
+  }
+}
+
+
+Endpoint::~Endpoint() noexcept {
+}
+
+
+void Endpoint::__set_ipv4(const int32_t val) {
+  this->ipv4 = val;
+}
+
+void Endpoint::__set_port(const int16_t val) {
+  this->port = val;
+}
+
+void Endpoint::__set_service_name(const std::string& val) {
+  this->service_name = val;
+}
+
+void Endpoint::__set_ipv6(const std::string& val) {
+  this->ipv6 = val;
+__isset.ipv6 = true;
+}
+std::ostream& operator<<(std::ostream& out, const Endpoint& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+uint32_t Endpoint::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->ipv4);
+          this->__isset.ipv4 = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I16) {
+          xfer += iprot->readI16(this->port);
+          this->__isset.port = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->service_name);
+          this->__isset.service_name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->ipv6);
+          this->__isset.ipv6 = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Endpoint::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Endpoint");
+
+  xfer += oprot->writeFieldBegin("ipv4", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32(this->ipv4);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("port", ::apache::thrift::protocol::T_I16, 2);
+  xfer += oprot->writeI16(this->port);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("service_name", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->service_name);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.ipv6) {
+    xfer += oprot->writeFieldBegin("ipv6", ::apache::thrift::protocol::T_STRING, 4);
+    xfer += oprot->writeBinary(this->ipv6);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Endpoint &a, Endpoint &b) {
+  using ::std::swap;
+  swap(a.ipv4, b.ipv4);
+  swap(a.port, b.port);
+  swap(a.service_name, b.service_name);
+  swap(a.ipv6, b.ipv6);
+  swap(a.__isset, b.__isset);
+}
+
+Endpoint::Endpoint(const Endpoint& other0) {
+  ipv4 = other0.ipv4;
+  port = other0.port;
+  service_name = other0.service_name;
+  ipv6 = other0.ipv6;
+  __isset = other0.__isset;
+}
+Endpoint& Endpoint::operator=(const Endpoint& other1) {
+  ipv4 = other1.ipv4;
+  port = other1.port;
+  service_name = other1.service_name;
+  ipv6 = other1.ipv6;
+  __isset = other1.__isset;
+  return *this;
+}
+void Endpoint::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "Endpoint(";
+  out << "ipv4=" << to_string(ipv4);
+  out << ", " << "port=" << to_string(port);
+  out << ", " << "service_name=" << to_string(service_name);
+  out << ", " << "ipv6="; (__isset.ipv6 ? (out << to_string(ipv6)) : (out << "<null>"));
+  out << ")";
+}
+
+
+Annotation::~Annotation() noexcept {
+}
+
+
+void Annotation::__set_timestamp(const int64_t val) {
+  this->timestamp = val;
+}
+
+void Annotation::__set_value(const std::string& val) {
+  this->value = val;
+}
+
+void Annotation::__set_host(const Endpoint& val) {
+  this->host = val;
+__isset.host = true;
+}
+std::ostream& operator<<(std::ostream& out, const Annotation& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+uint32_t Annotation::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->timestamp);
+          this->__isset.timestamp = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->value);
+          this->__isset.value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->host.read(iprot);
+          this->__isset.host = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Annotation::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Annotation");
+
+  xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 1);
+  xfer += oprot->writeI64(this->timestamp);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->value);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.host) {
+    xfer += oprot->writeFieldBegin("host", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->host.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Annotation &a, Annotation &b) {
+  using ::std::swap;
+  swap(a.timestamp, b.timestamp);
+  swap(a.value, b.value);
+  swap(a.host, b.host);
+  swap(a.__isset, b.__isset);
+}
+
+Annotation::Annotation(const Annotation& other2) {
+  timestamp = other2.timestamp;
+  value = other2.value;
+  host = other2.host;
+  __isset = other2.__isset;
+}
+Annotation& Annotation::operator=(const Annotation& other3) {
+  timestamp = other3.timestamp;
+  value = other3.value;
+  host = other3.host;
+  __isset = other3.__isset;
+  return *this;
+}
+void Annotation::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "Annotation(";
+  out << "timestamp=" << to_string(timestamp);
+  out << ", " << "value=" << to_string(value);
+  out << ", " << "host="; (__isset.host ? (out << to_string(host)) : (out << "<null>"));
+  out << ")";
+}
+
+
+BinaryAnnotation::~BinaryAnnotation() noexcept {
+}
+
+
+void BinaryAnnotation::__set_key(const std::string& val) {
+  this->key = val;
+}
+
+void BinaryAnnotation::__set_value(const std::string& val) {
+  this->value = val;
+}
+
+void BinaryAnnotation::__set_annotation_type(const AnnotationType::type val) {
+  this->annotation_type = val;
+}
+
+void BinaryAnnotation::__set_host(const Endpoint& val) {
+  this->host = val;
+__isset.host = true;
+}
+std::ostream& operator<<(std::ostream& out, const BinaryAnnotation& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+uint32_t BinaryAnnotation::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->key);
+          this->__isset.key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->value);
+          this->__isset.value = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast4;
+          xfer += iprot->readI32(ecast4);
+          this->annotation_type = (AnnotationType::type)ecast4;
+          this->__isset.annotation_type = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->host.read(iprot);
+          this->__isset.host = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t BinaryAnnotation::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("BinaryAnnotation");
+
+  xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->key);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("value", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeBinary(this->value);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("annotation_type", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32((int32_t)this->annotation_type);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.host) {
+    xfer += oprot->writeFieldBegin("host", ::apache::thrift::protocol::T_STRUCT, 4);
+    xfer += this->host.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(BinaryAnnotation &a, BinaryAnnotation &b) {
+  using ::std::swap;
+  swap(a.key, b.key);
+  swap(a.value, b.value);
+  swap(a.annotation_type, b.annotation_type);
+  swap(a.host, b.host);
+  swap(a.__isset, b.__isset);
+}
+
+BinaryAnnotation::BinaryAnnotation(const BinaryAnnotation& other5) {
+  key = other5.key;
+  value = other5.value;
+  annotation_type = other5.annotation_type;
+  host = other5.host;
+  __isset = other5.__isset;
+}
+BinaryAnnotation& BinaryAnnotation::operator=(const BinaryAnnotation& other6) {
+  key = other6.key;
+  value = other6.value;
+  annotation_type = other6.annotation_type;
+  host = other6.host;
+  __isset = other6.__isset;
+  return *this;
+}
+void BinaryAnnotation::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "BinaryAnnotation(";
+  out << "key=" << to_string(key);
+  out << ", " << "value=" << to_string(value);
+  out << ", " << "annotation_type=" << to_string(annotation_type);
+  out << ", " << "host="; (__isset.host ? (out << to_string(host)) : (out << "<null>"));
+  out << ")";
+}
+
+
+Span::~Span() noexcept {
+}
+
+
+void Span::__set_trace_id(const int64_t val) {
+  this->trace_id = val;
+}
+
+void Span::__set_name(const std::string& val) {
+  this->name = val;
+}
+
+void Span::__set_id(const int64_t val) {
+  this->id = val;
+}
+
+void Span::__set_parent_id(const int64_t val) {
+  this->parent_id = val;
+__isset.parent_id = true;
+}
+
+void Span::__set_annotations(const std::vector<Annotation> & val) {
+  this->annotations = val;
+}
+
+void Span::__set_binary_annotations(const std::vector<BinaryAnnotation> & val) {
+  this->binary_annotations = val;
+}
+
+void Span::__set_debug(const bool val) {
+  this->debug = val;
+__isset.debug = true;
+}
+
+void Span::__set_timestamp(const int64_t val) {
+  this->timestamp = val;
+__isset.timestamp = true;
+}
+
+void Span::__set_duration(const int64_t val) {
+  this->duration = val;
+__isset.duration = true;
+}
+
+void Span::__set_trace_id_high(const int64_t val) {
+  this->trace_id_high = val;
+__isset.trace_id_high = true;
+}
+std::ostream& operator<<(std::ostream& out, const Span& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+uint32_t Span::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->trace_id);
+          this->__isset.trace_id = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->name);
+          this->__isset.name = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->id);
+          this->__isset.id = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->parent_id);
+          this->__isset.parent_id = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->annotations.clear();
+            uint32_t _size7;
+            ::apache::thrift::protocol::TType _etype10;
+            xfer += iprot->readListBegin(_etype10, _size7);
+            this->annotations.resize(_size7);
+            uint32_t _i11;
+            for (_i11 = 0; _i11 < _size7; ++_i11)
+            {
+              xfer += this->annotations[_i11].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.annotations = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 8:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->binary_annotations.clear();
+            uint32_t _size12;
+            ::apache::thrift::protocol::TType _etype15;
+            xfer += iprot->readListBegin(_etype15, _size12);
+            this->binary_annotations.resize(_size12);
+            uint32_t _i16;
+            for (_i16 = 0; _i16 < _size12; ++_i16)
+            {
+              xfer += this->binary_annotations[_i16].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.binary_annotations = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 9:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->debug);
+          this->__isset.debug = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 10:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->timestamp);
+          this->__isset.timestamp = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 11:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->duration);
+          this->__isset.duration = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 12:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->trace_id_high);
+          this->__isset.trace_id_high = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t Span::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Span");
+
+  xfer += oprot->writeFieldBegin("trace_id", ::apache::thrift::protocol::T_I64, 1);
+  xfer += oprot->writeI64(this->trace_id);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 3);
+  xfer += oprot->writeString(this->name);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("id", ::apache::thrift::protocol::T_I64, 4);
+  xfer += oprot->writeI64(this->id);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.parent_id) {
+    xfer += oprot->writeFieldBegin("parent_id", ::apache::thrift::protocol::T_I64, 5);
+    xfer += oprot->writeI64(this->parent_id);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldBegin("annotations", ::apache::thrift::protocol::T_LIST, 6);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->annotations.size()));
+    std::vector<Annotation> ::const_iterator _iter17;
+    for (_iter17 = this->annotations.begin(); _iter17 != this->annotations.end(); ++_iter17)
+    {
+      xfer += (*_iter17).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("binary_annotations", ::apache::thrift::protocol::T_LIST, 8);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->binary_annotations.size()));
+    std::vector<BinaryAnnotation> ::const_iterator _iter18;
+    for (_iter18 = this->binary_annotations.begin(); _iter18 != this->binary_annotations.end(); ++_iter18)
+    {
+      xfer += (*_iter18).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.debug) {
+    xfer += oprot->writeFieldBegin("debug", ::apache::thrift::protocol::T_BOOL, 9);
+    xfer += oprot->writeBool(this->debug);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.timestamp) {
+    xfer += oprot->writeFieldBegin("timestamp", ::apache::thrift::protocol::T_I64, 10);
+    xfer += oprot->writeI64(this->timestamp);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.duration) {
+    xfer += oprot->writeFieldBegin("duration", ::apache::thrift::protocol::T_I64, 11);
+    xfer += oprot->writeI64(this->duration);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.trace_id_high) {
+    xfer += oprot->writeFieldBegin("trace_id_high", ::apache::thrift::protocol::T_I64, 12);
+    xfer += oprot->writeI64(this->trace_id_high);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Span &a, Span &b) {
+  using ::std::swap;
+  swap(a.trace_id, b.trace_id);
+  swap(a.name, b.name);
+  swap(a.id, b.id);
+  swap(a.parent_id, b.parent_id);
+  swap(a.annotations, b.annotations);
+  swap(a.binary_annotations, b.binary_annotations);
+  swap(a.debug, b.debug);
+  swap(a.timestamp, b.timestamp);
+  swap(a.duration, b.duration);
+  swap(a.trace_id_high, b.trace_id_high);
+  swap(a.__isset, b.__isset);
+}
+
+Span::Span(const Span& other19) {
+  trace_id = other19.trace_id;
+  name = other19.name;
+  id = other19.id;
+  parent_id = other19.parent_id;
+  annotations = other19.annotations;
+  binary_annotations = other19.binary_annotations;
+  debug = other19.debug;
+  timestamp = other19.timestamp;
+  duration = other19.duration;
+  trace_id_high = other19.trace_id_high;
+  __isset = other19.__isset;
+}
+Span& Span::operator=(const Span& other20) {
+  trace_id = other20.trace_id;
+  name = other20.name;
+  id = other20.id;
+  parent_id = other20.parent_id;
+  annotations = other20.annotations;
+  binary_annotations = other20.binary_annotations;
+  debug = other20.debug;
+  timestamp = other20.timestamp;
+  duration = other20.duration;
+  trace_id_high = other20.trace_id_high;
+  __isset = other20.__isset;
+  return *this;
+}
+void Span::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "Span(";
+  out << "trace_id=" << to_string(trace_id);
+  out << ", " << "name=" << to_string(name);
+  out << ", " << "id=" << to_string(id);
+  out << ", " << "parent_id="; (__isset.parent_id ? (out << to_string(parent_id)) : (out << "<null>"));
+  out << ", " << "annotations=" << to_string(annotations);
+  out << ", " << "binary_annotations=" << to_string(binary_annotations);
+  out << ", " << "debug="; (__isset.debug ? (out << to_string(debug)) : (out << "<null>"));
+  out << ", " << "timestamp="; (__isset.timestamp ? (out << to_string(timestamp)) : (out << "<null>"));
+  out << ", " << "duration="; (__isset.duration ? (out << to_string(duration)) : (out << "<null>"));
+  out << ", " << "trace_id_high="; (__isset.trace_id_high ? (out << to_string(trace_id_high)) : (out << "<null>"));
+  out << ")";
+}
+
+
+Response::~Response() noexcept {
+}
+
+
+void Response::__set_ok(const bool val) {
+  this->ok = val;
+}
+std::ostream& operator<<(std::ostream& out, const Response& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+uint32_t Response::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_ok = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->ok);
+          isset_ok = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_ok)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t Response::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("Response");
+
+  xfer += oprot->writeFieldBegin("ok", ::apache::thrift::protocol::T_BOOL, 1);
+  xfer += oprot->writeBool(this->ok);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(Response &a, Response &b) {
+  using ::std::swap;
+  swap(a.ok, b.ok);
+}
+
+Response::Response(const Response& other21) {
+  ok = other21.ok;
+}
+Response& Response::operator=(const Response& other22) {
+  ok = other22.ok;
+  return *this;
+}
+void Response::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "Response(";
+  out << "ok=" << to_string(ok);
+  out << ")";
+}
+
+}}} // namespace
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/zipkincore_types.h b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/zipkincore_types.h
new file mode 100644
index 000000000..c03421f43
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/jaeger/thrift-gen/zipkincore_types.h
@@ -0,0 +1,493 @@
+/**
+ * Autogenerated by Thrift Compiler (0.14.0)
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ *  @generated
+ */
+#ifndef zipkincore_TYPES_H
+#define zipkincore_TYPES_H
+
+#include <iosfwd>
+
+#include <thrift/Thrift.h>
+#include <thrift/TApplicationException.h>
+#include <thrift/TBase.h>
+#include <thrift/protocol/TProtocol.h>
+#include <thrift/transport/TTransport.h>
+
+#include <functional>
+#include <memory>
+
+
+namespace twitter { namespace zipkin { namespace thrift {
+
+struct AnnotationType {
+  enum type {
+    BOOL = 0,
+    BYTES = 1,
+    I16 = 2,
+    I32 = 3,
+    I64 = 4,
+    DOUBLE = 5,
+    STRING = 6
+  };
+};
+
+extern const std::map<int, const char*> _AnnotationType_VALUES_TO_NAMES;
+
+std::ostream& operator<<(std::ostream& out, const AnnotationType::type& val);
+
+std::string to_string(const AnnotationType::type& val);
+
+class Endpoint;
+
+class Annotation;
+
+class BinaryAnnotation;
+
+class Span;
+
+class Response;
+
+typedef struct _Endpoint__isset {
+  _Endpoint__isset() : ipv4(false), port(false), service_name(false), ipv6(false) {}
+  bool ipv4 :1;
+  bool port :1;
+  bool service_name :1;
+  bool ipv6 :1;
+} _Endpoint__isset;
+
+/**
+ * Indicates the network context of a service recording an annotation with two
+ * exceptions.
+ * 
+ * When a BinaryAnnotation, and key is CLIENT_ADDR or SERVER_ADDR,
+ * the endpoint indicates the source or destination of an RPC. This exception
+ * allows zipkin to display network context of uninstrumented services, or
+ * clients such as web browsers.
+ */
+class Endpoint : public virtual ::apache::thrift::TBase {
+ public:
+
+  Endpoint(const Endpoint&);
+  Endpoint& operator=(const Endpoint&);
+  Endpoint() : ipv4(0), port(0), service_name(), ipv6() {
+  }
+
+  virtual ~Endpoint() noexcept;
+  /**
+   * IPv4 host address packed into 4 bytes.
+   * 
+   * Ex for the ip 1.2.3.4, it would be (1 << 24) | (2 << 16) | (3 << 8) | 4
+   */
+  int32_t ipv4;
+  /**
+   * IPv4 port
+   * 
+   * Note: this is to be treated as an unsigned integer, so watch for negatives.
+   * 
+   * Conventionally, when the port isn't known, port = 0.
+   */
+  int16_t port;
+  /**
+   * Service name in lowercase, such as "memcache" or "zipkin-web"
+   * 
+   * Conventionally, when the service name isn't known, service_name = "unknown".
+   */
+  std::string service_name;
+  /**
+   * IPv6 host address packed into 16 bytes. Ex Inet6Address.getBytes()
+   */
+  std::string ipv6;
+
+  _Endpoint__isset __isset;
+
+  void __set_ipv4(const int32_t val);
+
+  void __set_port(const int16_t val);
+
+  void __set_service_name(const std::string& val);
+
+  void __set_ipv6(const std::string& val);
+
+  bool operator == (const Endpoint & rhs) const
+  {
+    if (!(ipv4 == rhs.ipv4))
+      return false;
+    if (!(port == rhs.port))
+      return false;
+    if (!(service_name == rhs.service_name))
+      return false;
+    if (__isset.ipv6 != rhs.__isset.ipv6)
+      return false;
+    else if (__isset.ipv6 && !(ipv6 == rhs.ipv6))
+      return false;
+    return true;
+  }
+  bool operator != (const Endpoint &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Endpoint & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Endpoint &a, Endpoint &b);
+
+std::ostream& operator<<(std::ostream& out, const Endpoint& obj);
+
+typedef struct _Annotation__isset {
+  _Annotation__isset() : timestamp(false), value(false), host(false) {}
+  bool timestamp :1;
+  bool value :1;
+  bool host :1;
+} _Annotation__isset;
+
+/**
+ * An annotation is similar to a log statement. It includes a host field which
+ * allows these events to be attributed properly, and also aggregatable.
+ */
+class Annotation : public virtual ::apache::thrift::TBase {
+ public:
+
+  Annotation(const Annotation&);
+  Annotation& operator=(const Annotation&);
+  Annotation() : timestamp(0), value() {
+  }
+
+  virtual ~Annotation() noexcept;
+  /**
+   * Microseconds from epoch.
+   * 
+   * This value should use the most precise value possible. For example,
+   * gettimeofday or syncing nanoTime against a tick of currentTimeMillis.
+   */
+  int64_t timestamp;
+  std::string value;
+  /**
+   * Always the host that recorded the event. By specifying the host you allow
+   * rollup of all events (such as client requests to a service) by IP address.
+   */
+  Endpoint host;
+
+  _Annotation__isset __isset;
+
+  void __set_timestamp(const int64_t val);
+
+  void __set_value(const std::string& val);
+
+  void __set_host(const Endpoint& val);
+
+  bool operator == (const Annotation & rhs) const
+  {
+    if (!(timestamp == rhs.timestamp))
+      return false;
+    if (!(value == rhs.value))
+      return false;
+    if (__isset.host != rhs.__isset.host)
+      return false;
+    else if (__isset.host && !(host == rhs.host))
+      return false;
+    return true;
+  }
+  bool operator != (const Annotation &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Annotation & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Annotation &a, Annotation &b);
+
+std::ostream& operator<<(std::ostream& out, const Annotation& obj);
+
+typedef struct _BinaryAnnotation__isset {
+  _BinaryAnnotation__isset() : key(false), value(false), annotation_type(false), host(false) {}
+  bool key :1;
+  bool value :1;
+  bool annotation_type :1;
+  bool host :1;
+} _BinaryAnnotation__isset;
+
+/**
+ * Binary annotations are tags applied to a Span to give it context. For
+ * example, a binary annotation of "http.uri" could the path to a resource in a
+ * RPC call.
+ * 
+ * Binary annotations of type STRING are always queryable, though more a
+ * historical implementation detail than a structural concern.
+ * 
+ * Binary annotations can repeat, and vary on the host. Similar to Annotation,
+ * the host indicates who logged the event. This allows you to tell the
+ * difference between the client and server side of the same key. For example,
+ * the key "http.uri" might be different on the client and server side due to
+ * rewriting, like "/api/v1/myresource" vs "/myresource. Via the host field,
+ * you can see the different points of view, which often help in debugging.
+ */
+class BinaryAnnotation : public virtual ::apache::thrift::TBase {
+ public:
+
+  BinaryAnnotation(const BinaryAnnotation&);
+  BinaryAnnotation& operator=(const BinaryAnnotation&);
+  BinaryAnnotation() : key(), value(), annotation_type((AnnotationType::type)0) {
+  }
+
+  virtual ~BinaryAnnotation() noexcept;
+  std::string key;
+  std::string value;
+  /**
+   * 
+   * @see AnnotationType
+   */
+  AnnotationType::type annotation_type;
+  /**
+   * The host that recorded tag, which allows you to differentiate between
+   * multiple tags with the same key. There are two exceptions to this.
+   * 
+   * When the key is CLIENT_ADDR or SERVER_ADDR, host indicates the source or
+   * destination of an RPC. This exception allows zipkin to display network
+   * context of uninstrumented services, or clients such as web browsers.
+   */
+  Endpoint host;
+
+  _BinaryAnnotation__isset __isset;
+
+  void __set_key(const std::string& val);
+
+  void __set_value(const std::string& val);
+
+  void __set_annotation_type(const AnnotationType::type val);
+
+  void __set_host(const Endpoint& val);
+
+  bool operator == (const BinaryAnnotation & rhs) const
+  {
+    if (!(key == rhs.key))
+      return false;
+    if (!(value == rhs.value))
+      return false;
+    if (!(annotation_type == rhs.annotation_type))
+      return false;
+    if (__isset.host != rhs.__isset.host)
+      return false;
+    else if (__isset.host && !(host == rhs.host))
+      return false;
+    return true;
+  }
+  bool operator != (const BinaryAnnotation &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const BinaryAnnotation & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(BinaryAnnotation &a, BinaryAnnotation &b);
+
+std::ostream& operator<<(std::ostream& out, const BinaryAnnotation& obj);
+
+typedef struct _Span__isset {
+  _Span__isset() : trace_id(false), name(false), id(false), parent_id(false), annotations(false), binary_annotations(false), debug(true), timestamp(false), duration(false), trace_id_high(false) {}
+  bool trace_id :1;
+  bool name :1;
+  bool id :1;
+  bool parent_id :1;
+  bool annotations :1;
+  bool binary_annotations :1;
+  bool debug :1;
+  bool timestamp :1;
+  bool duration :1;
+  bool trace_id_high :1;
+} _Span__isset;
+
+/**
+ * A trace is a series of spans (often RPC calls) which form a latency tree.
+ * 
+ * The root span is where trace_id = id and parent_id = Nil. The root span is
+ * usually the longest interval in the trace, starting with a SERVER_RECV
+ * annotation and ending with a SERVER_SEND.
+ */
+class Span : public virtual ::apache::thrift::TBase {
+ public:
+
+  Span(const Span&);
+  Span& operator=(const Span&);
+  Span() : trace_id(0), name(), id(0), parent_id(0), debug(false), timestamp(0), duration(0), trace_id_high(0) {
+  }
+
+  virtual ~Span() noexcept;
+  int64_t trace_id;
+  /**
+   * Span name in lowercase, rpc method for example
+   * 
+   * Conventionally, when the span name isn't known, name = "unknown".
+   */
+  std::string name;
+  int64_t id;
+  int64_t parent_id;
+  std::vector<Annotation>  annotations;
+  std::vector<BinaryAnnotation>  binary_annotations;
+  bool debug;
+  /**
+   * Microseconds from epoch of the creation of this span.
+   * 
+   * This value should be set directly by instrumentation, using the most
+   * precise value possible. For example, gettimeofday or syncing nanoTime
+   * against a tick of currentTimeMillis.
+   * 
+   * For compatibility with instrumentation that precede this field, collectors
+   * or span stores can derive this via Annotation.timestamp.
+   * For example, SERVER_RECV.timestamp or CLIENT_SEND.timestamp.
+   * 
+   * This field is optional for compatibility with old data: first-party span
+   * stores are expected to support this at time of introduction.
+   */
+  int64_t timestamp;
+  /**
+   * Measurement of duration in microseconds, used to support queries.
+   * 
+   * This value should be set directly, where possible. Doing so encourages
+   * precise measurement decoupled from problems of clocks, such as skew or NTP
+   * updates causing time to move backwards.
+   * 
+   * For compatibility with instrumentation that precede this field, collectors
+   * or span stores can derive this by subtracting Annotation.timestamp.
+   * For example, SERVER_SEND.timestamp - SERVER_RECV.timestamp.
+   * 
+   * If this field is persisted as unset, zipkin will continue to work, except
+   * duration query support will be implementation-specific. Similarly, setting
+   * this field non-atomically is implementation-specific.
+   * 
+   * This field is i64 vs i32 to support spans longer than 35 minutes.
+   */
+  int64_t duration;
+  /**
+   * Optional unique 8-byte additional identifier for a trace. If non zero, this
+   * means the trace uses 128 bit traceIds instead of 64 bit.
+   */
+  int64_t trace_id_high;
+
+  _Span__isset __isset;
+
+  void __set_trace_id(const int64_t val);
+
+  void __set_name(const std::string& val);
+
+  void __set_id(const int64_t val);
+
+  void __set_parent_id(const int64_t val);
+
+  void __set_annotations(const std::vector<Annotation> & val);
+
+  void __set_binary_annotations(const std::vector<BinaryAnnotation> & val);
+
+  void __set_debug(const bool val);
+
+  void __set_timestamp(const int64_t val);
+
+  void __set_duration(const int64_t val);
+
+  void __set_trace_id_high(const int64_t val);
+
+  bool operator == (const Span & rhs) const
+  {
+    if (!(trace_id == rhs.trace_id))
+      return false;
+    if (!(name == rhs.name))
+      return false;
+    if (!(id == rhs.id))
+      return false;
+    if (__isset.parent_id != rhs.__isset.parent_id)
+      return false;
+    else if (__isset.parent_id && !(parent_id == rhs.parent_id))
+      return false;
+    if (!(annotations == rhs.annotations))
+      return false;
+    if (!(binary_annotations == rhs.binary_annotations))
+      return false;
+    if (__isset.debug != rhs.__isset.debug)
+      return false;
+    else if (__isset.debug && !(debug == rhs.debug))
+      return false;
+    if (__isset.timestamp != rhs.__isset.timestamp)
+      return false;
+    else if (__isset.timestamp && !(timestamp == rhs.timestamp))
+      return false;
+    if (__isset.duration != rhs.__isset.duration)
+      return false;
+    else if (__isset.duration && !(duration == rhs.duration))
+      return false;
+    if (__isset.trace_id_high != rhs.__isset.trace_id_high)
+      return false;
+    else if (__isset.trace_id_high && !(trace_id_high == rhs.trace_id_high))
+      return false;
+    return true;
+  }
+  bool operator != (const Span &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Span & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Span &a, Span &b);
+
+std::ostream& operator<<(std::ostream& out, const Span& obj);
+
+
+class Response : public virtual ::apache::thrift::TBase {
+ public:
+
+  Response(const Response&);
+  Response& operator=(const Response&);
+  Response() : ok(0) {
+  }
+
+  virtual ~Response() noexcept;
+  bool ok;
+
+  void __set_ok(const bool val);
+
+  bool operator == (const Response & rhs) const
+  {
+    if (!(ok == rhs.ok))
+      return false;
+    return true;
+  }
+  bool operator != (const Response &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const Response & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(Response &a, Response &b);
+
+std::ostream& operator<<(std::ostream& out, const Response& obj);
+
+}}} // namespace
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/memory/BUILD b/src/jaegertracing/opentelemetry-cpp/exporters/memory/BUILD
new file mode 100644
index 000000000..b2dd48347
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/memory/BUILD
@@ -0,0 +1,57 @@
+package(default_visibility = ["//visibility:public"])
+
+cc_library(
+    name = "in_memory_span_data",
+    hdrs = [
+        "include/opentelemetry/exporters/memory/in_memory_span_data.h",
+    ],
+    strip_include_prefix = "include",
+    tags = ["memory"],
+    deps = [
+        "//api",
+        "//sdk/src/resource",
+        "//sdk/src/trace",
+    ],
+)
+
+cc_test(
+    name = "in_memory_span_data_test",
+    srcs = ["test/in_memory_span_data_test.cc"],
+    tags = [
+        "memory",
+        "test",
+    ],
+    deps = [
+        ":in_memory_span_data",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_library(
+    name = "in_memory_span_exporter",
+    hdrs = [
+        "include/opentelemetry/exporters/memory/in_memory_span_exporter.h",
+    ],
+    strip_include_prefix = "include",
+    tags = [
+        "memory",
+        "test",
+    ],
+    deps = [
+        ":in_memory_span_data",
+        "//sdk/src/trace",
+    ],
+)
+
+cc_test(
+    name = "in_memory_span_exporter_test",
+    srcs = ["test/in_memory_span_exporter_test.cc"],
+    tags = [
+        "memory",
+        "test",
+    ],
+    deps = [
+        ":in_memory_span_exporter",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/memory/CMakeLists.txt b/src/jaegertracing/opentelemetry-cpp/exporters/memory/CMakeLists.txt
new file mode 100644
index 000000000..d489ec160
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/memory/CMakeLists.txt
@@ -0,0 +1,46 @@
+add_library(opentelemetry_exporter_in_memory INTERFACE)
+
+target_include_directories(
+  opentelemetry_exporter_in_memory
+  INTERFACE "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+            "$<INSTALL_INTERFACE:include>")
+
+set_target_properties(opentelemetry_exporter_in_memory
+                      PROPERTIES EXPORT_NAME in_memory_span_exporter)
+
+install(
+  TARGETS opentelemetry_exporter_in_memory
+  EXPORT "${PROJECT_NAME}-target"
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+install(
+  DIRECTORY include/opentelemetry/exporters/memory
+  DESTINATION include/opentelemetry/exporters
+  FILES_MATCHING
+  PATTERN "*.h")
+
+if(BUILD_TESTING)
+  add_executable(in_memory_span_data_test test/in_memory_span_data_test.cc)
+  add_executable(in_memory_span_exporter_test
+                 test/in_memory_span_exporter_test.cc)
+
+  target_link_libraries(
+    in_memory_span_data_test ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
+    opentelemetry_exporter_in_memory opentelemetry_resources)
+
+  target_link_libraries(
+    in_memory_span_exporter_test ${GTEST_BOTH_LIBRARIES}
+    ${CMAKE_THREAD_LIBS_INIT} opentelemetry_exporter_in_memory
+    opentelemetry_resources)
+
+  gtest_add_tests(
+    TARGET in_memory_span_data_test
+    TEST_PREFIX exporter.
+    TEST_LIST in_memory_span_data_test)
+  gtest_add_tests(
+    TARGET in_memory_span_exporter_test
+    TEST_PREFIX exporter.
+    TEST_LIST in_memory_span_exporter_test)
+endif()
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/memory/include/opentelemetry/exporters/memory/in_memory_span_data.h b/src/jaegertracing/opentelemetry-cpp/exporters/memory/include/opentelemetry/exporters/memory/in_memory_span_data.h
new file mode 100644
index 000000000..df6d377b9
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/memory/include/opentelemetry/exporters/memory/in_memory_span_data.h
@@ -0,0 +1,74 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/sdk/common/circular_buffer.h"
+#include "opentelemetry/sdk/trace/recordable.h"
+#include "opentelemetry/sdk/trace/span_data.h"
+
+#include <vector>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace memory
+{
+/**
+ * A wrapper class holding in memory exporter data
+ */
+class InMemorySpanData final
+{
+public:
+  /**
+   * @param buffer_size a required value that sets the size of the CircularBuffer
+   */
+  InMemorySpanData(size_t buffer_size) : spans_received_(buffer_size) {}
+
+  /**
+   * @param data a required unique pointer to the data to add to the CircularBuffer
+   */
+  void Add(std::unique_ptr<opentelemetry::sdk::trace::SpanData> data) noexcept
+  {
+    std::unique_ptr<opentelemetry::sdk::trace::SpanData> span_data(
+        static_cast<opentelemetry::sdk::trace::SpanData *>(data.release()));
+    spans_received_.Add(span_data);
+  }
+
+  /**
+   * @return Returns a vector of unique pointers containing all the span data in the
+   * CircularBuffer. This operation will empty the Buffer, which is why the data
+   * is returned as unique pointers
+   */
+  std::vector<std::unique_ptr<opentelemetry::sdk::trace::SpanData>> GetSpans() noexcept
+  {
+    std::vector<std::unique_ptr<opentelemetry::sdk::trace::SpanData>> res;
+
+    // Pointer swap is required because the Consume function requires that the
+    // AtomicUniquePointer be set to null
+    spans_received_.Consume(
+        spans_received_.size(),
+        [&](opentelemetry::sdk::common::CircularBufferRange<
+            opentelemetry::sdk::common::AtomicUniquePtr<opentelemetry::sdk::trace::SpanData>>
+                range) noexcept {
+          range.ForEach(
+              [&](opentelemetry::sdk::common::AtomicUniquePtr<opentelemetry::sdk::trace::SpanData>
+                      &ptr) noexcept {
+                std::unique_ptr<opentelemetry::sdk::trace::SpanData> swap_ptr =
+                    std::unique_ptr<opentelemetry::sdk::trace::SpanData>(nullptr);
+                ptr.Swap(swap_ptr);
+                res.push_back(
+                    std::unique_ptr<opentelemetry::sdk::trace::SpanData>(swap_ptr.release()));
+                return true;
+              });
+        });
+
+    return res;
+  }
+
+private:
+  opentelemetry::sdk::common::CircularBuffer<opentelemetry::sdk::trace::SpanData> spans_received_;
+};
+}  // namespace memory
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/memory/include/opentelemetry/exporters/memory/in_memory_span_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/memory/include/opentelemetry/exporters/memory/in_memory_span_exporter.h
new file mode 100644
index 000000000..28b7bc34e
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/memory/include/opentelemetry/exporters/memory/in_memory_span_exporter.h
@@ -0,0 +1,100 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#include <mutex>
+#include "opentelemetry/common/spin_lock_mutex.h"
+#include "opentelemetry/exporters/memory/in_memory_span_data.h"
+#include "opentelemetry/sdk/trace/exporter.h"
+#include "opentelemetry/sdk_config.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace memory
+{
+const size_t MAX_BUFFER_SIZE = 100;
+
+/**
+ * A in memory exporter that switches a flag once a valid recordable was received
+ * and keeps track of all received spans in memory.
+ */
+class InMemorySpanExporter final : public opentelemetry::sdk::trace::SpanExporter
+{
+public:
+  /**
+   * @param buffer_size an optional value that sets the size of the InMemorySpanData
+   */
+  InMemorySpanExporter(size_t buffer_size = MAX_BUFFER_SIZE)
+      : data_(new opentelemetry::exporter::memory::InMemorySpanData(buffer_size))
+  {}
+
+  /**
+   * @return Returns a unique pointer to an empty recordable object
+   */
+  std::unique_ptr<sdk::trace::Recordable> MakeRecordable() noexcept override
+  {
+    return std::unique_ptr<sdk::trace::Recordable>(new sdk::trace::SpanData());
+  }
+
+  /**
+   * @param recordables a required span containing unique pointers to the data
+   * to add to the InMemorySpanData
+   * @return Returns the result of the operation
+   */
+  sdk::common::ExportResult Export(
+      const nostd::span<std::unique_ptr<sdk::trace::Recordable>> &recordables) noexcept override
+  {
+    if (isShutdown())
+    {
+      OTEL_INTERNAL_LOG_ERROR("[In Memory Span Exporter] Exporting "
+                              << recordables.size() << " span(s) failed, exporter is shutdown");
+      return sdk::common::ExportResult::kFailure;
+    }
+    for (auto &recordable : recordables)
+    {
+      auto span = std::unique_ptr<sdk::trace::SpanData>(
+          static_cast<sdk::trace::SpanData *>(recordable.release()));
+      if (span != nullptr)
+      {
+        data_->Add(std::move(span));
+      }
+    }
+
+    return sdk::common::ExportResult::kSuccess;
+  }
+
+  /**
+   * @param timeout an optional value containing the timeout of the exporter
+   * note: passing custom timeout values is not currently supported for this exporter
+   * @return Returns the status of the operation
+   */
+  bool Shutdown(
+      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override
+  {
+    const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+    is_shutdown_ = true;
+    return true;
+  };
+
+  /**
+   * @return Returns a shared pointer to this exporters InMemorySpanData
+   */
+  std::shared_ptr<opentelemetry::exporter::memory::InMemorySpanData> GetData() noexcept
+  {
+    return data_;
+  }
+
+private:
+  std::shared_ptr<opentelemetry::exporter::memory::InMemorySpanData> data_;
+  bool is_shutdown_ = false;
+  mutable opentelemetry::common::SpinLockMutex lock_;
+  const bool isShutdown() const noexcept
+  {
+    const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+    return is_shutdown_;
+  }
+};
+}  // namespace memory
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/memory/test/in_memory_span_data_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/memory/test/in_memory_span_data_test.cc
new file mode 100644
index 000000000..bc1955026
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/memory/test/in_memory_span_data_test.cc
@@ -0,0 +1,28 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/exporters/memory/in_memory_span_data.h"
+#include "opentelemetry/nostd/span.h"
+#include "opentelemetry/sdk/trace/span_data.h"
+
+#include <gtest/gtest.h>
+
+using opentelemetry::exporter::memory::InMemorySpanData;
+using opentelemetry::sdk::trace::Recordable;
+using opentelemetry::sdk::trace::SpanData;
+
+TEST(InMemorySpanData, AddRecordable)
+{
+  InMemorySpanData data(100);
+
+  ASSERT_EQ(0, data.GetSpans().size());
+
+  std::unique_ptr<SpanData> spandata(new SpanData());
+
+  data.Add(std::move(spandata));
+
+  // Consumes all spans in exporter
+  ASSERT_EQ(1, data.GetSpans().size());
+
+  ASSERT_EQ(0, data.GetSpans().size());
+}
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/memory/test/in_memory_span_exporter_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/memory/test/in_memory_span_exporter_test.cc
new file mode 100644
index 000000000..56a0ef779
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/memory/test/in_memory_span_exporter_test.cc
@@ -0,0 +1,29 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/exporters/memory/in_memory_span_exporter.h"
+#include "opentelemetry/nostd/span.h"
+#include "opentelemetry/sdk/trace/span_data.h"
+
+#include <gtest/gtest.h>
+
+using opentelemetry::exporter::memory::InMemorySpanExporter;
+using opentelemetry::sdk::trace::Recordable;
+using opentelemetry::sdk::trace::SpanData;
+
+TEST(InMemorySpanExporter, ExportBatch)
+{
+  InMemorySpanExporter exporter;
+
+  ASSERT_EQ(0, exporter.GetData().get()->GetSpans().size());
+
+  std::unique_ptr<Recordable> spandata(new SpanData());
+  opentelemetry::nostd::span<std::unique_ptr<Recordable>> batch(&spandata, 1);
+
+  exporter.Export(batch);
+
+  ASSERT_EQ(1, exporter.GetData().get()->GetSpans().size());
+
+  // Consumes all spans in exporter
+  ASSERT_EQ(0, exporter.GetData().get()->GetSpans().size());
+}
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/BUILD b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/BUILD
new file mode 100644
index 000000000..917b70450
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/BUILD
@@ -0,0 +1,131 @@
+package(default_visibility = ["//visibility:public"])
+
+cc_library(
+    name = "ostream_log_exporter",
+    srcs = [
+        "src/log_exporter.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/ostream/common_utils.h",
+        "include/opentelemetry/exporters/ostream/log_exporter.h",
+    ],
+    strip_include_prefix = "include",
+    tags = ["ostream"],
+    deps = [
+        "//sdk/src/logs",
+    ],
+)
+
+cc_test(
+    name = "ostream_log_test",
+    srcs = ["test/ostream_log_test.cc"],
+    tags = [
+        "ostream",
+        "test",
+    ],
+    deps = [
+        ":ostream_log_exporter",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_library(
+    name = "ostream_metrics_exporter_deprecated",
+    srcs = [
+        "src/metrics_exporter.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/ostream/metrics_exporter.h",
+    ],
+    strip_include_prefix = "include",
+    tags = ["ostream"],
+    deps = [
+        "//sdk/src/_metrics:metrics_deprecated",
+    ],
+)
+
+cc_library(
+    name = "ostream_metric_exporter",
+    srcs = [
+        "src/metric_exporter.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/ostream/common_utils.h",
+        "include/opentelemetry/exporters/ostream/metric_exporter.h",
+    ],
+    strip_include_prefix = "include",
+    tags = [
+        "metrics",
+        "ostream",
+    ],
+    deps = [
+        "//sdk/src/metrics",
+    ],
+)
+
+cc_test(
+    name = "ostream_metric_test",
+    srcs = ["test/ostream_metric_test.cc"],
+    tags = [
+        "ostream",
+        "test",
+    ],
+    deps = [
+        ":ostream_metric_exporter",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "ostream_metrics_test_deprecated",
+    srcs = ["test/ostream_metrics_test.cc"],
+    tags = [
+        "ostream",
+        "test",
+    ],
+    deps = [
+        ":ostream_metrics_exporter_deprecated",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_library(
+    name = "ostream_span_exporter",
+    srcs = [
+        "src/span_exporter.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/ostream/common_utils.h",
+        "include/opentelemetry/exporters/ostream/span_exporter.h",
+    ],
+    strip_include_prefix = "include",
+    tags = ["ostream"],
+    deps = [
+        "//sdk/src/trace",
+    ],
+)
+
+cc_library(
+    name = "ostream_capture",
+    hdrs = [
+        "test/ostream_capture.h",
+    ],
+    tags = ["ostream"],
+    deps = [
+        "//api",
+    ],
+)
+
+cc_test(
+    name = "ostream_span_test",
+    srcs = ["test/ostream_span_test.cc"],
+    tags = [
+        "ostream",
+        "test",
+    ],
+    deps = [
+        ":ostream_capture",
+        ":ostream_span_exporter",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/CMakeLists.txt b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/CMakeLists.txt
new file mode 100644
index 000000000..db2562ddd
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/CMakeLists.txt
@@ -0,0 +1,125 @@
+add_library(opentelemetry_exporter_ostream_span src/span_exporter.cc)
+
+set_target_properties(opentelemetry_exporter_ostream_span
+                      PROPERTIES EXPORT_NAME ostream_span_exporter)
+
+target_include_directories(
+  opentelemetry_exporter_ostream_span
+  PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>")
+
+target_link_libraries(opentelemetry_exporter_ostream_span
+                      PUBLIC opentelemetry_trace)
+
+install(
+  TARGETS opentelemetry_exporter_ostream_span
+  EXPORT "${PROJECT_NAME}-target"
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+install(
+  DIRECTORY include/opentelemetry/exporters/ostream
+  DESTINATION include/opentelemetry/exporters
+  PATTERN "*.h"
+  PATTERN "metrics_exporter.h" EXCLUDE
+  PATTERN "log_Exporter.h" EXCLUDE)
+
+if(BUILD_TESTING)
+  add_executable(ostream_span_test test/ostream_span_test.cc)
+  target_link_libraries(ostream_span_test ${GTEST_BOTH_LIBRARIES}
+                        opentelemetry_exporter_ostream_span)
+  gtest_add_tests(
+    TARGET ostream_span_test
+    TEST_PREFIX exporter.
+    TEST_LIST ostream_span_test)
+endif() # BUILD_TESTING
+
+if(WITH_METRICS_PREVIEW)
+  add_library(opentelemetry_exporter_ostream_metrics_deprecated
+              src/metrics_exporter.cc)
+  set_target_properties(opentelemetry_exporter_ostream_metrics_deprecated
+                        PROPERTIES EXPORT_NAME ostream_metrics_exporter)
+  target_include_directories(
+    opentelemetry_exporter_ostream_metrics_deprecated
+    PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>")
+  target_link_libraries(opentelemetry_exporter_ostream_metrics_deprecated
+                        PUBLIC opentelemetry_metrics_deprecated)
+  install(
+    TARGETS opentelemetry_exporter_ostream_metrics_deprecated
+    EXPORT "${PROJECT_NAME}-target"
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  install(
+    DIRECTORY include/opentelemetry/exporters/ostream
+    DESTINATION include/opentelemetry/exporters
+    PATTERN "metrics_exporter.h")
+  if(BUILD_TESTING)
+    add_executable(ostream_metrics_test test/ostream_metrics_test.cc)
+    target_link_libraries(ostream_metrics_test ${GTEST_BOTH_LIBRARIES}
+                          opentelemetry_exporter_ostream_metrics_deprecated)
+    gtest_add_tests(
+      TARGET ostream_metrics_test
+      TEST_PREFIX exporter.
+      TEST_LIST ostream_metrics_test)
+  endif()
+else()
+  add_library(opentelemetry_exporter_ostream_metrics src/metric_exporter.cc)
+  set_target_properties(opentelemetry_exporter_ostream_metrics
+                        PROPERTIES EXPORT_NAME ostream_metrics_exporter)
+  target_include_directories(
+    opentelemetry_exporter_ostream_metrics
+    PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>")
+  target_link_libraries(opentelemetry_exporter_ostream_metrics
+                        PUBLIC opentelemetry_metrics)
+  install(
+    TARGETS opentelemetry_exporter_ostream_metrics
+    EXPORT "${PROJECT_NAME}-target"
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  install(
+    DIRECTORY include/opentelemetry/exporters/ostream
+    DESTINATION include/opentelemetry/exporters
+    PATTERN "metric_exporter.h")
+  if(BUILD_TESTING)
+    add_executable(ostream_metric_test test/ostream_metric_test.cc)
+    target_link_libraries(
+      ostream_metric_test ${GTEST_BOTH_LIBRARIES}
+      opentelemetry_exporter_ostream_metrics opentelemetry_resources)
+    gtest_add_tests(
+      TARGET ostream_metric_test
+      TEST_PREFIX exporter.
+      TEST_LIST ostream_metric_test)
+  endif()
+endif()
+
+if(WITH_LOGS_PREVIEW)
+  add_library(opentelemetry_exporter_ostream_logs src/log_exporter.cc)
+  set_target_properties(opentelemetry_exporter_ostream_logs
+                        PROPERTIES EXPORT_NAME ostream_log_exporter)
+  target_include_directories(
+    opentelemetry_exporter_ostream_logs
+    PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>")
+  target_link_libraries(opentelemetry_exporter_ostream_logs
+                        PUBLIC opentelemetry_logs)
+  install(
+    TARGETS opentelemetry_exporter_ostream_logs
+    EXPORT "${PROJECT_NAME}-target"
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+  install(
+    DIRECTORY include/opentelemetry/exporters/ostream
+    DESTINATION include/opentelemetry/exporters
+    PATTERN "log_exporter.h")
+  if(BUILD_TESTING)
+    add_executable(ostream_log_test test/ostream_log_test.cc)
+    target_link_libraries(ostream_log_test ${GTEST_BOTH_LIBRARIES}
+                          opentelemetry_exporter_ostream_logs)
+    gtest_add_tests(
+      TARGET ostream_log_test
+      TEST_PREFIX exporter.
+      TEST_LIST ostream_log_test)
+  endif()
+endif()
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/common_utils.h b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/common_utils.h
new file mode 100644
index 000000000..cfebfe8fc
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/common_utils.h
@@ -0,0 +1,80 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <sstream>
+#include <string>
+#include <vector>
+#include "opentelemetry/nostd/variant.h"
+#include "opentelemetry/sdk/common/attribute_utils.h"
+
+#pragma once
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace ostream_common
+{
+/*
+  print_value is used to print out the value of an attribute within a vector.
+  These values are held in a variant which makes the process of printing them much more
+  complicated.
+*/
+
+template <typename T>
+void print_value(const T &item, std::ostream &sout)
+{
+  sout << item;
+}
+
+template <typename T>
+void print_value(const std::vector<T> &vec, std::ostream &sout)
+{
+  sout << '[';
+  size_t i  = 1;
+  size_t sz = vec.size();
+  for (auto v : vec)
+  {
+    sout << v;
+    if (i != sz)
+      sout << ',';
+    i++;
+  };
+  sout << ']';
+}
+
+// Prior to C++14, generic lambda is not available so fallback to functor.
+#if __cplusplus < 201402L
+
+class OwnedAttributeValueVisitor
+{
+public:
+  OwnedAttributeValueVisitor(std::ostream &sout) : sout_(sout) {}
+
+  template <typename T>
+  void operator()(T &&arg)
+  {
+    print_value(arg, sout_);
+  }
+
+private:
+  std::ostream &sout_;
+};
+
+#endif
+
+void print_value(const opentelemetry::sdk::common::OwnedAttributeValue &value, std::ostream &sout)
+{
+#if __cplusplus < 201402L
+  opentelemetry::nostd::visit(OwnedAttributeValueVisitor(sout), value);
+#else
+  opentelemetry::nostd::visit(
+      [&sout](auto &&arg) {
+        /* explicit this is needed by some gcc versions (observed with v5.4.0)*/
+        print_value(arg, sout);
+      },
+      value);
+#endif
+}
+
+}  // namespace ostream_common
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
\ No newline at end of file
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/log_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/log_exporter.h
new file mode 100644
index 000000000..2f6acbb48
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/log_exporter.h
@@ -0,0 +1,62 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifdef ENABLE_LOGS_PREVIEW
+
+#  include "opentelemetry/common/spin_lock_mutex.h"
+#  include "opentelemetry/nostd/type_traits.h"
+#  include "opentelemetry/sdk/logs/exporter.h"
+#  include "opentelemetry/sdk/logs/log_record.h"
+#  include "opentelemetry/version.h"
+
+#  include <iostream>
+#  include <sstream>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace logs
+{
+/**
+ * The OStreamLogExporter exports logs through an ostream (default set to std::cout)
+ */
+class OStreamLogExporter final : public opentelemetry::sdk::logs::LogExporter
+{
+public:
+  /**
+   * Create an OStreamLogExporter. This constructor takes in a reference to an ostream that the
+   * Export() method will send log data into. The default ostream is set to stdout.
+   */
+  explicit OStreamLogExporter(std::ostream &sout = std::cout) noexcept;
+
+  std::unique_ptr<sdk::logs::Recordable> MakeRecordable() noexcept override;
+
+  /**
+   * Exports a span of logs sent from the processor.
+   */
+  opentelemetry::sdk::common::ExportResult Export(
+      const opentelemetry::nostd::span<std::unique_ptr<sdk::logs::Recordable>> &records) noexcept
+      override;
+
+  /**
+   * Marks the OStream Log Exporter as shut down.
+   */
+  bool Shutdown(
+      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+
+private:
+  // The OStream to send the logs to
+  std::ostream &sout_;
+  // Whether this exporter has been shut down
+  bool is_shutdown_ = false;
+  mutable opentelemetry::common::SpinLockMutex lock_;
+  bool isShutdown() const noexcept;
+  void printAttributes(
+      const std::unordered_map<std::string, opentelemetry::sdk::common::OwnedAttributeValue> &map,
+      const std::string prefix = "\n\t");
+};
+}  // namespace logs
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/metric_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/metric_exporter.h
new file mode 100644
index 000000000..e34332d77
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/metric_exporter.h
@@ -0,0 +1,67 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifndef ENABLE_METRICS_PREVIEW
+
+#  include <iostream>
+#  include <string>
+#  include "opentelemetry/common/spin_lock_mutex.h"
+#  include "opentelemetry/sdk/metrics/data/metric_data.h"
+#  include "opentelemetry/sdk/metrics/instruments.h"
+#  include "opentelemetry/sdk/metrics/metric_exporter.h"
+#  include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace metrics
+{
+
+/**
+ * The OStreamMetricExporter exports record data through an ostream
+ */
+class OStreamMetricExporter final : public opentelemetry::sdk::metrics::MetricExporter
+{
+public:
+  /**
+   * Create an OStreamMetricExporter. This constructor takes in a reference to an ostream that the
+   * export() function will send metrics data into.
+   * The default ostream is set to stdout
+   */
+  explicit OStreamMetricExporter(std::ostream &sout = std::cout) noexcept;
+
+  /**
+   * Export
+   * @param data metrics data
+   */
+  sdk::common::ExportResult Export(const sdk::metrics::ResourceMetrics &data) noexcept override;
+
+  /**
+   * Force flush the exporter.
+   */
+  bool ForceFlush(
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override;
+
+  /**
+   * Shut down the exporter.
+   * @param timeout an optional timeout, the default timeout of 0 means that no
+   * timeout is applied.
+   * @return return the status of this operation
+   */
+  bool Shutdown(std::chrono::microseconds timeout = std::chrono::microseconds(0)) noexcept override;
+
+private:
+  std::ostream &sout_;
+  bool is_shutdown_ = false;
+  mutable opentelemetry::common::SpinLockMutex lock_;
+  bool isShutdown() const noexcept;
+  void printInstrumentationInfoMetricData(
+      const sdk::metrics::InstrumentationInfoMetrics &info_metrics);
+  void printPointData(const opentelemetry::sdk::metrics::PointType &point_data);
+  void printPointAttributes(const opentelemetry::sdk::metrics::PointAttributes &point_attributes);
+};
+}  // namespace metrics
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/metrics_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/metrics_exporter.h
new file mode 100644
index 000000000..5ae168aa0
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/metrics_exporter.h
@@ -0,0 +1,166 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifdef ENABLE_METRICS_PREVIEW
+
+#  include <iostream>
+#  include <string>
+#  include "opentelemetry/sdk/_metrics/aggregator/exact_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/gauge_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/histogram_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/exporter.h"
+#  include "opentelemetry/sdk/_metrics/record.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace metrics
+{
+
+/**
+ * The OStreamMetricsExporter exports record data through an ostream
+ */
+class OStreamMetricsExporter final : public opentelemetry::sdk::metrics::MetricsExporter
+{
+public:
+  /**
+   * Create an OStreamMetricsExporter. This constructor takes in a reference to an ostream that the
+   * export() function will send span data into.
+   * The default ostream is set to stdout
+   */
+  explicit OStreamMetricsExporter(std::ostream &sout = std::cout) noexcept;
+
+  sdk::common::ExportResult Export(
+      const std::vector<opentelemetry::sdk::metrics::Record> &records) noexcept override;
+
+private:
+  std::ostream &sout_;
+
+  /**
+   * Send specific data from the given AggregatorVariant based on what AggregatorKind
+   * it is holding. Each Aggregator holds data differently, so each have their own
+   * custom printing.
+   */
+  template <typename T>
+  void PrintAggregatorVariant(opentelemetry::sdk::metrics::AggregatorVariant value)
+  {
+    auto agg     = nostd::get<std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>>>(value);
+    auto aggKind = agg->get_aggregator_kind();
+
+    if (!agg)
+      return;
+    switch (aggKind)
+    {
+      case opentelemetry::sdk::metrics::AggregatorKind::Counter: {
+        sout_ << "\n  sum         : " << agg->get_checkpoint()[0];
+      }
+      break;
+      case opentelemetry::sdk::metrics::AggregatorKind::MinMaxSumCount: {
+        auto mmsc = agg->get_checkpoint();
+        sout_ << "\n  min         : " << mmsc[0] << "\n  max         : " << mmsc[1]
+              << "\n  sum         : " << mmsc[2] << "\n  count       : " << mmsc[3];
+      }
+      break;
+      case opentelemetry::sdk::metrics::AggregatorKind::Gauge: {
+        auto timestamp = agg->get_checkpoint_timestamp();
+
+        sout_ << "\n  last value  : " << agg->get_checkpoint()[0]
+              << "\n  timestamp   : " << std::to_string(timestamp.time_since_epoch().count());
+      }
+      break;
+      case opentelemetry::sdk::metrics::AggregatorKind::Exact: {
+        // TODO: Find better way to print quantiles
+        if (agg->get_quant_estimation())
+        {
+          sout_ << "\n  quantiles   : "
+                << "[0: " << agg->get_quantiles(0) << ", "
+                << ".25: " << agg->get_quantiles(.25) << ", "
+                << ".50: " << agg->get_quantiles(.50) << ", "
+                << ".75: " << agg->get_quantiles(.75) << ", "
+                << "1: " << agg->get_quantiles(1) << ']';
+        }
+        else
+        {
+          auto vec    = agg->get_checkpoint();
+          size_t size = vec.size();
+          size_t i    = 1;
+
+          sout_ << "\n  values      : " << '[';
+
+          for (auto val : vec)
+          {
+            sout_ << val;
+            if (i != size)
+              sout_ << ", ";
+            i++;
+          }
+          sout_ << ']';
+        }
+      }
+      break;
+      case opentelemetry::sdk::metrics::AggregatorKind::Histogram: {
+        auto boundaries = agg->get_boundaries();
+        auto counts     = agg->get_counts();
+
+        size_t boundaries_size = boundaries.size();
+        size_t counts_size     = counts.size();
+
+        sout_ << "\n  buckets     : " << '[';
+
+        for (size_t i = 0; i < boundaries_size; i++)
+        {
+          sout_ << boundaries[i];
+
+          if (i != boundaries_size - 1)
+            sout_ << ", ";
+        }
+        sout_ << ']';
+
+        sout_ << "\n  counts      : " << '[';
+        for (size_t i = 0; i < counts_size; i++)
+        {
+          sout_ << counts[i];
+
+          if (i != counts_size - 1)
+            sout_ << ", ";
+        }
+        sout_ << ']';
+      }
+      break;
+      case opentelemetry::sdk::metrics::AggregatorKind::Sketch: {
+        auto boundaries = agg->get_boundaries();
+        auto counts     = agg->get_counts();
+
+        size_t boundaries_size = boundaries.size();
+        size_t counts_size     = counts.size();
+
+        sout_ << "\n  buckets     : " << '[';
+
+        for (size_t i = 0; i < boundaries_size; i++)
+        {
+          sout_ << boundaries[i];
+
+          if (i != boundaries_size - 1)
+            sout_ << ", ";
+        }
+        sout_ << ']';
+
+        sout_ << "\n  counts      : " << '[';
+        for (size_t i = 0; i < counts_size; i++)
+        {
+          sout_ << counts[i];
+
+          if (i != counts_size - 1)
+            sout_ << ", ";
+        }
+        sout_ << ']';
+      }
+      break;
+    }
+  }
+};
+}  // namespace metrics
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/span_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/span_exporter.h
new file mode 100644
index 000000000..c8603db02
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/include/opentelemetry/exporters/ostream/span_exporter.h
@@ -0,0 +1,70 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/common/spin_lock_mutex.h"
+#include "opentelemetry/nostd/type_traits.h"
+#include "opentelemetry/sdk/trace/exporter.h"
+#include "opentelemetry/sdk/trace/span_data.h"
+#include "opentelemetry/version.h"
+
+#include <iostream>
+#include <map>
+#include <sstream>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace trace
+{
+
+/**
+ * The OStreamSpanExporter exports span data through an ostream
+ */
+class OStreamSpanExporter final : public opentelemetry::sdk::trace::SpanExporter
+{
+public:
+  /**
+   * Create an OStreamSpanExporter. This constructor takes in a reference to an ostream that the
+   * export() function will send span data into.
+   * The default ostream is set to stdout
+   */
+  explicit OStreamSpanExporter(std::ostream &sout = std::cout) noexcept;
+
+  std::unique_ptr<opentelemetry::sdk::trace::Recordable> MakeRecordable() noexcept override;
+
+  sdk::common::ExportResult Export(
+      const opentelemetry::nostd::span<std::unique_ptr<opentelemetry::sdk::trace::Recordable>>
+          &spans) noexcept override;
+
+  bool Shutdown(
+      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+
+private:
+  std::ostream &sout_;
+  bool is_shutdown_ = false;
+  mutable opentelemetry::common::SpinLockMutex lock_;
+  bool isShutdown() const noexcept;
+
+  // Mapping status number to the string from api/include/opentelemetry/trace/canonical_code.h
+  std::map<int, std::string> statusMap{{0, "Unset"}, {1, "Ok"}, {2, "Error"}};
+
+  // various print helpers
+  void printAttributes(
+      const std::unordered_map<std::string, opentelemetry::sdk::common::OwnedAttributeValue> &map,
+      const std::string prefix = "\n\t");
+
+  void printEvents(const std::vector<opentelemetry::sdk::trace::SpanDataEvent> &events);
+
+  void printLinks(const std::vector<opentelemetry::sdk::trace::SpanDataLink> &links);
+
+  void printResources(const opentelemetry::sdk::resource::Resource &resources);
+
+  void printInstrumentationLibrary(
+      const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary
+          &instrumentation_library);
+};
+}  // namespace trace
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/src/log_exporter.cc b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/src/log_exporter.cc
new file mode 100644
index 000000000..e6ddd4c9f
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/src/log_exporter.cc
@@ -0,0 +1,132 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_LOGS_PREVIEW
+#  include "opentelemetry/exporters/ostream/log_exporter.h"
+#  include <mutex>
+#  include "opentelemetry/exporters/ostream/common_utils.h"
+#  include "opentelemetry/sdk_config.h"
+
+#  include <iostream>
+#  include <type_traits>
+
+namespace nostd     = opentelemetry::nostd;
+namespace sdklogs   = opentelemetry::sdk::logs;
+namespace sdkcommon = opentelemetry::sdk::common;
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace logs
+{
+
+/*********************** Constructor ***********************/
+
+OStreamLogExporter::OStreamLogExporter(std::ostream &sout) noexcept : sout_(sout) {}
+
+/*********************** Exporter methods ***********************/
+
+std::unique_ptr<sdklogs::Recordable> OStreamLogExporter::MakeRecordable() noexcept
+{
+  return std::unique_ptr<sdklogs::Recordable>(new sdklogs::LogRecord());
+}
+
+sdk::common::ExportResult OStreamLogExporter::Export(
+    const nostd::span<std::unique_ptr<sdklogs::Recordable>> &records) noexcept
+{
+  if (isShutdown())
+  {
+    OTEL_INTERNAL_LOG_ERROR("[Ostream Log Exporter] Exporting "
+                            << records.size() << " log(s) failed, exporter is shutdown");
+    return sdk::common::ExportResult::kFailure;
+  }
+
+  for (auto &record : records)
+  {
+    // Convert recordable to a LogRecord so that the getters of the LogRecord can be used
+    auto log_record =
+        std::unique_ptr<sdklogs::LogRecord>(static_cast<sdklogs::LogRecord *>(record.release()));
+
+    if (log_record == nullptr)
+    {
+      // TODO: Log Internal SDK error "recordable data was lost"
+      continue;
+    }
+
+    // Convert trace, spanid, traceflags into exportable representation
+    constexpr int trace_id_len    = 32;
+    constexpr int span_id__len    = 16;
+    constexpr int trace_flags_len = 2;
+
+    char trace_id[trace_id_len]       = {0};
+    char span_id[span_id__len]        = {0};
+    char trace_flags[trace_flags_len] = {0};
+
+    log_record->GetTraceId().ToLowerBase16(trace_id);
+    log_record->GetSpanId().ToLowerBase16(span_id);
+    log_record->GetTraceFlags().ToLowerBase16(trace_flags);
+
+    // Print out each field of the log record, noting that severity is separated
+    // into severity_num and severity_text
+    sout_ << "{\n"
+          << "  timestamp     : " << log_record->GetTimestamp().time_since_epoch().count() << "\n"
+          << "  severity_num  : " << static_cast<std::uint32_t>(log_record->GetSeverity()) << "\n"
+          << "  severity_text : ";
+
+    std::uint32_t severity_index = static_cast<std::uint32_t>(log_record->GetSeverity());
+    if (severity_index >= std::extent<decltype(opentelemetry::logs::SeverityNumToText)>::value)
+    {
+      sout_ << "Invalid severity(" << severity_index << ")\n";
+    }
+    else
+    {
+      sout_ << opentelemetry::logs::SeverityNumToText[severity_index] << "\n";
+    }
+
+    sout_ << "  body          : " << log_record->GetBody() << "\n"
+          << "  resource      : ";
+
+    printAttributes(log_record->GetResource().GetAttributes());
+
+    sout_ << "\n"
+          << "  attributes    : ";
+
+    printAttributes(log_record->GetAttributes());
+
+    sout_ << "\n"
+          << "  trace_id      : " << std::string(trace_id, trace_id_len) << "\n"
+          << "  span_id       : " << std::string(span_id, span_id__len) << "\n"
+          << "  trace_flags   : " << std::string(trace_flags, trace_flags_len) << "\n"
+          << "}\n";
+  }
+
+  return sdk::common::ExportResult::kSuccess;
+}
+
+bool OStreamLogExporter::Shutdown(std::chrono::microseconds timeout) noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  is_shutdown_ = true;
+  return true;
+}
+
+bool OStreamLogExporter::isShutdown() const noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  return is_shutdown_;
+}
+
+void OStreamLogExporter::printAttributes(
+    const std::unordered_map<std::string, sdkcommon::OwnedAttributeValue> &map,
+    const std::string prefix)
+{
+  for (const auto &kv : map)
+  {
+    sout_ << prefix << kv.first << ": ";
+    opentelemetry::exporter::ostream_common::print_value(kv.second, sout_);
+  }
+}
+
+}  // namespace logs
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/src/metric_exporter.cc b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/src/metric_exporter.cc
new file mode 100644
index 000000000..2e90e0845
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/src/metric_exporter.cc
@@ -0,0 +1,214 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <chrono>
+#ifndef ENABLE_METRICS_PREVIEW
+#  include <algorithm>
+#  include "opentelemetry/exporters/ostream/common_utils.h"
+#  include "opentelemetry/exporters/ostream/metric_exporter.h"
+#  include "opentelemetry/sdk/metrics/aggregation/default_aggregation.h"
+#  include "opentelemetry/sdk/metrics/aggregation/histogram_aggregation.h"
+#  include "opentelemetry/sdk_config.h"
+
+namespace
+{
+std::string timeToString(opentelemetry::common::SystemTimestamp time_stamp)
+{
+  std::time_t epoch_time = std::chrono::system_clock::to_time_t(time_stamp);
+
+  struct tm *tm_ptr = nullptr;
+#  if defined(_MSC_VER)
+  struct tm buf_tm;
+  if (!gmtime_s(&buf_tm, &epoch_time))
+  {
+    tm_ptr = &buf_tm;
+  }
+#  else
+  tm_ptr = std::gmtime(&epoch_time);
+#  endif
+
+  char buf[100];
+  char *date_str = nullptr;
+  if (tm_ptr == nullptr)
+  {
+    OTEL_INTERNAL_LOG_ERROR("[OStream Metric] gmtime failed for " << epoch_time);
+  }
+  else if (std::strftime(buf, sizeof(buf), "%c", tm_ptr) > 0)
+  {
+    date_str = buf;
+  }
+  else
+  {
+    OTEL_INTERNAL_LOG_ERROR("[OStream Metric] strftime failed for " << epoch_time);
+  }
+
+  return std::string{date_str};
+}
+}  // namespace
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace metrics
+{
+
+template <typename Container>
+inline void printVec(std::ostream &os, Container &vec)
+{
+  using T = typename std::decay<decltype(*vec.begin())>::type;
+  os << '[';
+  if (vec.size() > 1)
+  {
+    std::copy(vec.begin(), vec.end(), std::ostream_iterator<T>(os, ", "));
+  }
+  os << ']';
+}
+
+OStreamMetricExporter::OStreamMetricExporter(std::ostream &sout) noexcept : sout_(sout) {}
+
+sdk::common::ExportResult OStreamMetricExporter::Export(
+    const sdk::metrics::ResourceMetrics &data) noexcept
+{
+  if (isShutdown())
+  {
+    OTEL_INTERNAL_LOG_ERROR("[OStream Metric] Exporting "
+                            << data.instrumentation_info_metric_data_.size()
+                            << " records(s) failed, exporter is shutdown");
+    return sdk::common::ExportResult::kFailure;
+  }
+
+  for (auto &record : data.instrumentation_info_metric_data_)
+  {
+    printInstrumentationInfoMetricData(record);
+  }
+  return sdk::common::ExportResult::kSuccess;
+}
+
+void OStreamMetricExporter::printInstrumentationInfoMetricData(
+    const sdk::metrics::InstrumentationInfoMetrics &info_metric)
+{
+  // sout_ is shared
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  sout_ << "{";
+  sout_ << "\n  name\t\t: " << info_metric.instrumentation_library_->GetName()
+        << "\n  schema url\t: " << info_metric.instrumentation_library_->GetSchemaURL()
+        << "\n  version\t: " << info_metric.instrumentation_library_->GetVersion();
+  for (const auto &record : info_metric.metric_data_)
+  {
+    sout_ << "\n  start time\t: " << timeToString(record.start_ts)
+          << "\n  end time\t: " << timeToString(record.end_ts)
+          << "\n  name\t\t: " << record.instrument_descriptor.name_
+          << "\n  description\t: " << record.instrument_descriptor.description_
+          << "\n  unit\t\t: " << record.instrument_descriptor.unit_;
+
+    for (const auto &pd : record.point_data_attr_)
+    {
+      if (!nostd::holds_alternative<sdk::metrics::DropPointData>(pd.point_data))
+      {
+        printPointData(pd.point_data);
+        printPointAttributes(pd.attributes);
+      }
+    }
+  }
+  sout_ << "\n}\n";
+}
+
+void OStreamMetricExporter::printPointData(const opentelemetry::sdk::metrics::PointType &point_data)
+{
+  if (nostd::holds_alternative<sdk::metrics::SumPointData>(point_data))
+  {
+    auto sum_point_data = nostd::get<sdk::metrics::SumPointData>(point_data);
+    sout_ << "\n  type\t\t: SumPointData";
+    sout_ << "\n  value\t\t: ";
+    if (nostd::holds_alternative<double>(sum_point_data.value_))
+    {
+      sout_ << nostd::get<double>(sum_point_data.value_);
+    }
+    else if (nostd::holds_alternative<long>(sum_point_data.value_))
+    {
+      sout_ << nostd::get<long>(sum_point_data.value_);
+    }
+  }
+  else if (nostd::holds_alternative<sdk::metrics::HistogramPointData>(point_data))
+  {
+    auto histogram_point_data = nostd::get<sdk::metrics::HistogramPointData>(point_data);
+    sout_ << "\n  type     : HistogramPointData";
+    sout_ << "\n  count     : " << histogram_point_data.count_;
+    sout_ << "\n  sum     : ";
+    if (nostd::holds_alternative<double>(histogram_point_data.sum_))
+    {
+      sout_ << nostd::get<double>(histogram_point_data.sum_);
+    }
+    else if (nostd::holds_alternative<long>(histogram_point_data.sum_))
+    {
+      sout_ << nostd::get<long>(histogram_point_data.sum_);
+    }
+
+    sout_ << "\n  buckets     : ";
+    if (nostd::holds_alternative<std::list<double>>(histogram_point_data.boundaries_))
+    {
+      auto &double_boundaries = nostd::get<std::list<double>>(histogram_point_data.boundaries_);
+      printVec(sout_, double_boundaries);
+    }
+    else if (nostd::holds_alternative<std::list<long>>(histogram_point_data.boundaries_))
+    {
+      auto &long_boundaries = nostd::get<std::list<long>>(histogram_point_data.boundaries_);
+      printVec(sout_, long_boundaries);
+    }
+
+    sout_ << "\n  counts     : ";
+    printVec(sout_, histogram_point_data.counts_);
+  }
+  else if (nostd::holds_alternative<sdk::metrics::LastValuePointData>(point_data))
+  {
+    auto last_point_data = nostd::get<sdk::metrics::LastValuePointData>(point_data);
+    sout_ << "\n  type     : LastValuePointData";
+    sout_ << "\n  timestamp     : "
+          << std::to_string(last_point_data.sample_ts_.time_since_epoch().count()) << std::boolalpha
+          << "\n  valid     : " << last_point_data.is_lastvalue_valid_;
+    sout_ << "\n  value     : ";
+    if (nostd::holds_alternative<double>(last_point_data.value_))
+    {
+      sout_ << nostd::get<double>(last_point_data.value_);
+    }
+    else if (nostd::holds_alternative<long>(last_point_data.value_))
+    {
+      sout_ << nostd::get<long>(last_point_data.value_);
+    }
+  }
+}
+
+void OStreamMetricExporter::printPointAttributes(
+    const opentelemetry::sdk::metrics::PointAttributes &point_attributes)
+{
+  sout_ << "\n  attributes\t\t: ";
+  for (const auto &kv : point_attributes)
+  {
+    sout_ << "\n\t" << kv.first << ": ";
+    opentelemetry::exporter::ostream_common::print_value(kv.second, sout_);
+  }
+}
+
+bool OStreamMetricExporter::ForceFlush(std::chrono::microseconds timeout) noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  return true;
+}
+
+bool OStreamMetricExporter::Shutdown(std::chrono::microseconds timeout) noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  is_shutdown_ = true;
+  return true;
+}
+
+bool OStreamMetricExporter::isShutdown() const noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  return is_shutdown_;
+}
+
+}  // namespace metrics
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/src/metrics_exporter.cc b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/src/metrics_exporter.cc
new file mode 100644
index 000000000..4f4bbfd06
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/src/metrics_exporter.cc
@@ -0,0 +1,59 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_METRICS_PREVIEW
+#  include "opentelemetry/exporters/ostream/metrics_exporter.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace metrics
+{
+
+OStreamMetricsExporter::OStreamMetricsExporter(std::ostream &sout) noexcept : sout_(sout) {}
+
+sdk::common::ExportResult OStreamMetricsExporter::Export(
+    const std::vector<sdk::metrics::Record> &records) noexcept
+{
+  for (auto record : records)
+  {
+    sout_ << "{"
+          << "\n  name        : " << record.GetName()
+          << "\n  description : " << record.GetDescription()
+          << "\n  labels      : " << record.GetLabels();
+
+    auto aggregator = record.GetAggregator();
+
+    /**
+     * Unpack the AggregatorVariant from the record so we can pass the data type to
+     * PrintAggregatorVariant to unpack the Aggregator from the variant.
+     */
+    if (nostd::holds_alternative<std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<int>>>(
+            aggregator))
+    {
+      PrintAggregatorVariant<int>(aggregator);
+    }
+    else if (nostd::holds_alternative<
+                 std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<short>>>(aggregator))
+    {
+      PrintAggregatorVariant<short>(aggregator);
+    }
+    else if (nostd::holds_alternative<
+                 std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<double>>>(aggregator))
+    {
+      PrintAggregatorVariant<double>(aggregator);
+    }
+    else if (nostd::holds_alternative<
+                 std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<float>>>(aggregator))
+    {
+      PrintAggregatorVariant<float>(aggregator);
+    }
+    sout_ << "\n}\n";
+  }
+  return sdk::common::ExportResult::kSuccess;
+}
+
+}  // namespace metrics
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/src/span_exporter.cc b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/src/span_exporter.cc
new file mode 100644
index 000000000..226f98737
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/src/span_exporter.cc
@@ -0,0 +1,178 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/exporters/ostream/span_exporter.h"
+#include "opentelemetry/exporters/ostream/common_utils.h"
+
+#include <iostream>
+#include <mutex>
+#include "opentelemetry/sdk_config.h"
+
+namespace nostd     = opentelemetry::nostd;
+namespace trace_sdk = opentelemetry::sdk::trace;
+namespace trace_api = opentelemetry::trace;
+namespace sdkcommon = opentelemetry::sdk::common;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace trace
+{
+
+std::ostream &operator<<(std::ostream &os, trace_api::SpanKind span_kind)
+{
+  switch (span_kind)
+  {
+    case trace_api::SpanKind::kClient:
+      return os << "Client";
+    case trace_api::SpanKind::kInternal:
+      return os << "Internal";
+    case trace_api::SpanKind::kServer:
+      return os << "Server";
+    case trace_api::SpanKind::kProducer:
+      return os << "Producer";
+    case trace_api::SpanKind::kConsumer:
+      return os << "Consumer";
+  };
+  return os << "";
+}
+
+OStreamSpanExporter::OStreamSpanExporter(std::ostream &sout) noexcept : sout_(sout) {}
+
+std::unique_ptr<trace_sdk::Recordable> OStreamSpanExporter::MakeRecordable() noexcept
+{
+  return std::unique_ptr<trace_sdk::Recordable>(new trace_sdk::SpanData);
+}
+
+sdk::common::ExportResult OStreamSpanExporter::Export(
+    const nostd::span<std::unique_ptr<trace_sdk::Recordable>> &spans) noexcept
+{
+  if (isShutdown())
+  {
+    OTEL_INTERNAL_LOG_ERROR("[Ostream Trace Exporter] Exporting "
+                            << spans.size() << " span(s) failed, exporter is shutdown");
+    return sdk::common::ExportResult::kFailure;
+  }
+
+  for (auto &recordable : spans)
+  {
+    auto span = std::unique_ptr<trace_sdk::SpanData>(
+        static_cast<trace_sdk::SpanData *>(recordable.release()));
+
+    if (span != nullptr)
+    {
+
+      char trace_id[32]       = {0};
+      char span_id[16]        = {0};
+      char parent_span_id[16] = {0};
+
+      span->GetTraceId().ToLowerBase16(trace_id);
+      span->GetSpanId().ToLowerBase16(span_id);
+      span->GetParentSpanId().ToLowerBase16(parent_span_id);
+
+      sout_ << "{"
+            << "\n  name          : " << span->GetName()
+            << "\n  trace_id      : " << std::string(trace_id, 32)
+            << "\n  span_id       : " << std::string(span_id, 16)
+            << "\n  tracestate    : " << span->GetSpanContext().trace_state()->ToHeader()
+            << "\n  parent_span_id: " << std::string(parent_span_id, 16)
+            << "\n  start         : " << span->GetStartTime().time_since_epoch().count()
+            << "\n  duration      : " << span->GetDuration().count()
+            << "\n  description   : " << span->GetDescription()
+            << "\n  span kind     : " << span->GetSpanKind()
+            << "\n  status        : " << statusMap[int(span->GetStatus())]
+            << "\n  attributes    : ";
+      printAttributes(span->GetAttributes());
+      sout_ << "\n  events        : ";
+      printEvents(span->GetEvents());
+      sout_ << "\n  links         : ";
+      printLinks(span->GetLinks());
+      sout_ << "\n  resources     : ";
+      printResources(span->GetResource());
+      sout_ << "\n  instr-lib     : ";
+      printInstrumentationLibrary(span->GetInstrumentationLibrary());
+      sout_ << "\n}\n";
+    }
+  }
+
+  return sdk::common::ExportResult::kSuccess;
+}
+
+bool OStreamSpanExporter::Shutdown(std::chrono::microseconds timeout) noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  is_shutdown_ = true;
+  return true;
+}
+
+bool OStreamSpanExporter::isShutdown() const noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  return is_shutdown_;
+}
+void OStreamSpanExporter::printAttributes(
+    const std::unordered_map<std::string, sdkcommon::OwnedAttributeValue> &map,
+    const std::string prefix)
+{
+  for (const auto &kv : map)
+  {
+    sout_ << prefix << kv.first << ": ";
+    opentelemetry::exporter::ostream_common::print_value(kv.second, sout_);
+  }
+}
+
+void OStreamSpanExporter::printEvents(const std::vector<trace_sdk::SpanDataEvent> &events)
+{
+  for (const auto &event : events)
+  {
+    sout_ << "\n\t{"
+          << "\n\t  name          : " << event.GetName()
+          << "\n\t  timestamp     : " << event.GetTimestamp().time_since_epoch().count()
+          << "\n\t  attributes    : ";
+    printAttributes(event.GetAttributes(), "\n\t\t");
+    sout_ << "\n\t}";
+  }
+}
+
+void OStreamSpanExporter::printLinks(const std::vector<trace_sdk::SpanDataLink> &links)
+{
+  for (const auto &link : links)
+  {
+    char trace_id[32] = {0};
+    char span_id[16]  = {0};
+    link.GetSpanContext().trace_id().ToLowerBase16(trace_id);
+    link.GetSpanContext().span_id().ToLowerBase16(span_id);
+    sout_ << "\n\t{"
+          << "\n\t  trace_id      : " << std::string(trace_id, 32)
+          << "\n\t  span_id       : " << std::string(span_id, 16)
+          << "\n\t  tracestate    : " << link.GetSpanContext().trace_state()->ToHeader()
+          << "\n\t  attributes    : ";
+    printAttributes(link.GetAttributes(), "\n\t\t");
+    sout_ << "\n\t}";
+  }
+}
+
+void OStreamSpanExporter::printResources(const opentelemetry::sdk::resource::Resource &resources)
+{
+  auto attributes = resources.GetAttributes();
+  if (attributes.size())
+  {
+    printAttributes(attributes, "\n\t");
+  }
+}
+
+void OStreamSpanExporter::printInstrumentationLibrary(
+    const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary
+        &instrumentation_library)
+{
+  sout_ << instrumentation_library.GetName();
+  auto version = instrumentation_library.GetVersion();
+  if (version.size())
+  {
+    sout_ << "-" << version;
+  }
+}
+
+}  // namespace trace
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_capture.h b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_capture.h
new file mode 100644
index 000000000..6c61c7152
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_capture.h
@@ -0,0 +1,60 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <iostream>
+#include <sstream>
+#include <string>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace ostream
+{
+namespace test
+{
+/**
+ * The OStreamCapture captures from the specified stream for its lifetime
+ */
+class OStreamCapture
+{
+public:
+  /**
+   * Create a OStreamCapture which will capture the output of the ostream that it was constructed
+   * with for the lifetime of the instance.
+   */
+  OStreamCapture(std::ostream &ostream) : stream_(ostream), buf_(ostream.rdbuf())
+  {
+    stream_.rdbuf(captured_.rdbuf());
+  }
+
+  ~OStreamCapture() { stream_.rdbuf(buf_); }
+
+  /**
+   * Returns the captured data from the stream.
+   */
+  std::string GetCaptured() const { return captured_.str(); }
+
+private:
+  std::ostream &stream_;
+  std::streambuf *buf_;
+  std::stringstream captured_;
+};
+
+/**
+ * Helper method to invoke the passed func while recording the output of the specified stream and
+ * return the output afterwards.
+ */
+template <typename Func>
+std::string WithOStreamCapture(std::ostream &stream, Func func)
+{
+  OStreamCapture capture(stream);
+  func();
+  return capture.GetCaptured();
+}
+
+}  // namespace test
+}  // namespace ostream
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_log_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_log_test.cc
new file mode 100644
index 000000000..91d8fbf24
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_log_test.cc
@@ -0,0 +1,330 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_LOGS_PREVIEW
+
+#  include <array>
+#  include "opentelemetry/exporters/ostream/log_exporter.h"
+#  include "opentelemetry/logs/provider.h"
+#  include "opentelemetry/nostd/span.h"
+#  include "opentelemetry/sdk/logs/logger_provider.h"
+#  include "opentelemetry/sdk/logs/simple_log_processor.h"
+
+#  include <gtest/gtest.h>
+#  include <iostream>
+
+namespace sdklogs      = opentelemetry::sdk::logs;
+namespace logs_api     = opentelemetry::logs;
+namespace nostd        = opentelemetry::nostd;
+namespace exporterlogs = opentelemetry::exporter::logs;
+namespace common       = opentelemetry::common;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace logs
+{
+
+// Test that when OStream Log exporter is shutdown, no logs should be sent to stream
+TEST(OStreamLogExporter, Shutdown)
+{
+  auto exporter = std::unique_ptr<sdklogs::LogExporter>(new exporterlogs::OStreamLogExporter);
+
+  // Save cout's original buffer here
+  std::streambuf *original = std::cout.rdbuf();
+
+  // Redirect cout to our stringstream buffer
+  std::stringstream output;
+  std::cout.rdbuf(output.rdbuf());
+
+  EXPECT_TRUE(exporter->Shutdown());
+
+  // After processor/exporter is shutdown, no logs should be sent to stream
+  auto record = exporter->MakeRecordable();
+  record->SetBody("Log record not empty");
+  exporter->Export(nostd::span<std::unique_ptr<sdklogs::Recordable>>(&record, 1));
+
+  // Restore original stringstream buffer
+  std::cout.rdbuf(original);
+  std::string err_message =
+      "[Ostream Log Exporter] Exporting 1 log(s) failed, exporter is shutdown";
+  EXPECT_TRUE(output.str().find(err_message) != std::string::npos);
+}
+
+// ---------------------------------- Print to cout -------------------------
+
+// Testing what a default log record that has no values changed will print out
+// This function tests MakeRecordable() as well as Export().
+TEST(OstreamLogExporter, DefaultLogRecordToCout)
+{
+  auto exporter =
+      std::unique_ptr<sdklogs::LogExporter>(new exporterlogs::OStreamLogExporter(std::cout));
+
+  // Save cout's original buffer here
+  std::streambuf *original = std::cout.rdbuf();
+
+  // Redirect cout to our stringstream buffer
+  std::stringstream output;
+  std::cout.rdbuf(output.rdbuf());
+
+  // Pass a default recordable created by the exporter to be exported
+  auto log_record = exporter->MakeRecordable();
+  exporter->Export(nostd::span<std::unique_ptr<sdklogs::Recordable>>(&log_record, 1));
+
+  // Restore cout's original stringstream
+  std::cout.rdbuf(original);
+
+  std::vector<std::string> expected_output{
+      "{\n"
+      "  timestamp     : 0\n"
+      "  severity_num  : 0\n"
+      "  severity_text : INVALID\n"
+      "  body          : \n",
+      "  resource      : \n",
+      "telemetry.sdk.version: " OPENTELEMETRY_VERSION "\n",
+      "telemetry.sdk.name: opentelemetry\n",
+      "telemetry.sdk.language: cpp\n",
+      "  attributes    : \n"
+      "  trace_id      : 00000000000000000000000000000000\n"
+      "  span_id       : 0000000000000000\n"
+      "  trace_flags   : 00\n"
+      "}\n"};
+
+  for (auto &expected : expected_output)
+  {
+    ASSERT_NE(output.str().find(expected), std::string::npos);
+  }
+}
+
+// Testing what a log record with only the "timestamp", "severity", "name" and "message" fields set,
+// will print out
+TEST(OStreamLogExporter, SimpleLogToCout)
+{
+  // Initialize an Ostream exporter to std::cout
+  auto exporter =
+      std::unique_ptr<sdklogs::LogExporter>(new exporterlogs::OStreamLogExporter(std::cout));
+
+  // Save original stream buffer, then redirect cout to our new stream buffer
+  std::streambuf *original = std::cout.rdbuf();
+  std::stringstream output;
+  std::cout.rdbuf(output.rdbuf());
+
+  // Pass a default recordable created by the exporter to be exported
+  // Create a log record and manually timestamp, severity, name, message
+  common::SystemTimestamp now(std::chrono::system_clock::now());
+
+  auto record = std::unique_ptr<sdklogs::Recordable>(new sdklogs::LogRecord());
+  record->SetTimestamp(now);
+  record->SetSeverity(logs_api::Severity::kTrace);  // kTrace has enum value of 1
+  record->SetBody("Message");
+
+  // Log a record to cout
+  exporter->Export(nostd::span<std::unique_ptr<sdklogs::Recordable>>(&record, 1));
+
+  // Reset cout's original stringstream buffer
+  std::cout.rdbuf(original);
+
+  std::vector<std::string> expected_output{
+      "{\n"
+      "  timestamp     : " +
+          std::to_string(now.time_since_epoch().count()) +
+          "\n"
+          "  severity_num  : 1\n"
+          "  severity_text : TRACE\n"
+          "  body          : Message\n",
+      "  resource      : \n",
+      "telemetry.sdk.version: " OPENTELEMETRY_VERSION "\n",
+      "telemetry.sdk.name: opentelemetry\n",
+      "telemetry.sdk.language: cpp\n",
+      "  attributes    : \n"
+      "  trace_id      : 00000000000000000000000000000000\n"
+      "  span_id       : 0000000000000000\n"
+      "  trace_flags   : 00\n"
+      "}\n"};
+
+  for (auto &expected : expected_output)
+  {
+    ASSERT_NE(output.str().find(expected), std::string::npos);
+  }
+}
+
+// ---------------------------------- Print to cerr --------------------------
+
+// Testing what a log record with only the "resource" and "attributes" fields
+// (i.e. KeyValueIterable types) set with primitive types, will print out
+TEST(OStreamLogExporter, LogWithStringAttributesToCerr)
+{
+  // Initialize an Ostream exporter to cerr
+  auto exporter =
+      std::unique_ptr<sdklogs::LogExporter>(new exporterlogs::OStreamLogExporter(std::cerr));
+
+  // Save original stream buffer, then redirect cout to our new stream buffer
+  std::streambuf *original = std::cerr.rdbuf();
+  std::stringstream stdcerrOutput;
+  std::cerr.rdbuf(stdcerrOutput.rdbuf());
+
+  // Pass a recordable created by the exporter to be exported
+  auto record = exporter->MakeRecordable();
+
+  // Set resources for this log record only of type <string, string>
+  auto resource = opentelemetry::sdk::resource::Resource::Create({{"key1", "val1"}});
+  record->SetResource(resource);
+
+  // Set attributes to this log record of type <string, AttributeValue>
+  record->SetAttribute("a", true);
+
+  // Log record to cerr
+  exporter->Export(nostd::span<std::unique_ptr<sdklogs::Recordable>>(&record, 1));
+
+  // Reset cerr's original stringstream buffer
+  std::cerr.rdbuf(original);
+
+  std::vector<std::string> expected_output{
+      "{\n"
+      "  timestamp     : 0\n"
+      "  severity_num  : 0\n"
+      "  severity_text : INVALID\n"
+      "  body          : \n",
+      "  resource      : \n",
+      "telemetry.sdk.version: " OPENTELEMETRY_VERSION "\n",
+      "telemetry.sdk.name: opentelemetry\n",
+      "telemetry.sdk.language: cpp\n",
+      "service.name: unknown_service\n",
+      "key1: val1\n",
+      "  attributes    : \n",
+      "\ta: 1\n",
+      "  trace_id      : 00000000000000000000000000000000\n"
+      "  span_id       : 0000000000000000\n"
+      "  trace_flags   : 00\n"
+      "}\n"};
+
+  for (auto &expected : expected_output)
+  {
+    ASSERT_NE(stdcerrOutput.str().find(expected), std::string::npos);
+  }
+}
+
+// ---------------------------------- Print to clog -------------------------
+
+// Testing what a log record with only the "resource", and "attributes" fields
+// (i.e. KeyValueIterable types), set with 2D arrays as values, will print out
+TEST(OStreamLogExporter, LogWithVariantTypesToClog)
+{
+
+  // Initialize an Ostream exporter to cerr
+  auto exporter =
+      std::unique_ptr<sdklogs::LogExporter>(new exporterlogs::OStreamLogExporter(std::clog));
+
+  // Save original stream buffer, then redirect cout to our new stream buffer
+  std::streambuf *original = std::clog.rdbuf();
+  std::stringstream stdclogOutput;
+  std::clog.rdbuf(stdclogOutput.rdbuf());
+
+  // Pass a recordable created by the exporter to be exported
+  auto record = exporter->MakeRecordable();
+
+  // Set resources for this log record of only integer types as the value
+  std::array<int, 3> array1 = {1, 2, 3};
+  nostd::span<int> data1{array1.data(), array1.size()};
+
+  auto resource = opentelemetry::sdk::resource::Resource::Create({{"res1", data1}});
+  record->SetResource(resource);
+
+  // Set resources for this log record of bool types as the value
+  // e.g. key/value is a par of type <string, array of bools>
+  std::array<bool, 3> array = {false, true, false};
+  record->SetAttribute("attr1", nostd::span<bool>{array.data(), array.size()});
+
+  // Log a record to clog
+  exporter->Export(nostd::span<std::unique_ptr<sdklogs::Recordable>>(&record, 1));
+
+  // Reset clog's original stringstream buffer
+  std::clog.rdbuf(original);
+
+  std::vector<std::string> expected_output{
+      "{\n"
+      "  timestamp     : 0\n"
+      "  severity_num  : 0\n"
+      "  severity_text : INVALID\n"
+      "  body          : \n",
+      "  resource      : \n",
+      "service.name: unknown_service\n",
+      "telemetry.sdk.version: " OPENTELEMETRY_VERSION "\n",
+      "telemetry.sdk.name: opentelemetry\n",
+      "telemetry.sdk.language: cpp\n",
+      "res1: [1,2,3]\n",
+      "attributes    : \n",
+      "\tattr1: [0,1,0]\n"
+      "  trace_id      : 00000000000000000000000000000000\n"
+      "  span_id       : 0000000000000000\n"
+      "  trace_flags   : 00\n"
+      "}\n"};
+
+  for (auto &expected : expected_output)
+  {
+    ASSERT_NE(stdclogOutput.str().find(expected), std::string::npos);
+  }
+}
+
+// // ---------------------------------- Integration Tests -------------------------
+
+// Test using the simple log processor and ostream exporter to cout
+// and use the rest of the logging pipeline (Logger, LoggerProvider, Provider) as well
+TEST(OStreamLogExporter, IntegrationTest)
+{
+  // Initialize a logger
+  auto exporter    = std::unique_ptr<sdklogs::LogExporter>(new exporterlogs::OStreamLogExporter);
+  auto sdkProvider = std::shared_ptr<sdklogs::LoggerProvider>(new sdklogs::LoggerProvider());
+  sdkProvider->AddProcessor(
+      std::unique_ptr<sdklogs::LogProcessor>(new sdklogs::SimpleLogProcessor(std::move(exporter))));
+  auto apiProvider = nostd::shared_ptr<logs_api::LoggerProvider>(sdkProvider);
+  auto provider    = nostd::shared_ptr<logs_api::LoggerProvider>(apiProvider);
+  logs_api::Provider::SetLoggerProvider(provider);
+  const std::string schema_url{"https://opentelemetry.io/schemas/1.11.0"};
+  auto logger = logs_api::Provider::GetLoggerProvider()->GetLogger(
+      "Logger", "", "opentelelemtry_library", "", schema_url);
+
+  // Back up cout's streambuf
+  std::streambuf *original = std::cout.rdbuf();
+
+  // Redirect cout to our string stream
+  std::stringstream stdcoutOutput;
+  std::cout.rdbuf(stdcoutOutput.rdbuf());
+
+  // Write a log to ostream exporter
+  common::SystemTimestamp now(std::chrono::system_clock::now());
+  logger->Log(logs_api::Severity::kDebug, "Hello", {}, {}, {}, {}, now);
+
+  // Restore cout's original streambuf
+  std::cout.rdbuf(original);
+
+  // Compare actual vs expected outputs
+  std::vector<std::string> expected_output{
+      "{\n"
+      "  timestamp     : " +
+          std::to_string(now.time_since_epoch().count()) +
+          "\n"
+          "  severity_num  : 5\n"
+          "  severity_text : DEBUG\n"
+          "  body          : Hello\n",
+      "  resource      : \n",
+      "telemetry.sdk.version: " OPENTELEMETRY_VERSION "\n",
+      "service.name: unknown_service\n",
+      "telemetry.sdk.name: opentelemetry\n",
+      "telemetry.sdk.language: cpp\n",
+      "  attributes    : \n"
+      "  trace_id      : 00000000000000000000000000000000\n"
+      "  span_id       : 0000000000000000\n"
+      "  trace_flags   : 00\n"
+      "}\n"};
+
+  for (auto &expected : expected_output)
+  {
+    ASSERT_NE(stdcoutOutput.str().find(expected), std::string::npos);
+  }
+}
+
+}  // namespace logs
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_metric_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_metric_test.cc
new file mode 100644
index 000000000..45d6d8f88
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_metric_test.cc
@@ -0,0 +1,269 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+#ifndef ENABLE_METRICS_PREVIEW
+
+#  include <gtest/gtest.h>
+#  include <memory>
+#  include <vector>
+#  include "opentelemetry/sdk/metrics/instruments.h"
+#  include "opentelemetry/sdk/resource/resource_detector.h"
+
+#  include <iostream>
+#  include "opentelemetry/exporters/ostream/metric_exporter.h"
+#  include "opentelemetry/sdk/metrics/aggregation/default_aggregation.h"
+#  include "opentelemetry/sdk/metrics/aggregation/histogram_aggregation.h"
+#  include "opentelemetry/sdk/metrics/data/metric_data.h"
+#  include "opentelemetry/sdk/resource/resource.h"
+
+namespace metric_sdk      = opentelemetry::sdk::metrics;
+namespace nostd           = opentelemetry::nostd;
+namespace exportermetrics = opentelemetry::exporter::metrics;
+
+TEST(OStreamMetricsExporter, Shutdown)
+{
+  auto exporter =
+      std::unique_ptr<metric_sdk::MetricExporter>(new exportermetrics::OStreamMetricExporter);
+  ASSERT_TRUE(exporter->Shutdown());
+  auto result = exporter->Export(metric_sdk::ResourceMetrics{});
+  EXPECT_EQ(result, opentelemetry::sdk::common::ExportResult::kFailure);
+}
+
+TEST(OStreamMetricsExporter, ExportSumPointData)
+{
+  auto exporter =
+      std::unique_ptr<metric_sdk::MetricExporter>(new exportermetrics::OStreamMetricExporter);
+
+  metric_sdk::SumPointData sum_point_data{};
+  sum_point_data.value_ = 10.0;
+  metric_sdk::SumPointData sum_point_data2{};
+  sum_point_data2.value_ = 20.0;
+  metric_sdk::ResourceMetrics data;
+  auto resource = opentelemetry::sdk::resource::Resource::Create(
+      opentelemetry::sdk::resource::ResourceAttributes{});
+  data.resource_ = &resource;
+  auto instrumentation_library =
+      opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary::Create("library_name",
+                                                                                 "1.2.0");
+  metric_sdk::MetricData metric_data{
+      metric_sdk::InstrumentDescriptor{"library_name", "description", "unit",
+                                       metric_sdk::InstrumentType::kCounter,
+                                       metric_sdk::InstrumentValueType::kDouble},
+      opentelemetry::common::SystemTimestamp{}, opentelemetry::common::SystemTimestamp{},
+      std::vector<metric_sdk::PointDataAttributes>{
+          {metric_sdk::PointAttributes{{"a1", "b1"}}, sum_point_data},
+          {metric_sdk::PointAttributes{{"a1", "b1"}}, sum_point_data2}}};
+  data.instrumentation_info_metric_data_ = std::vector<metric_sdk::InstrumentationInfoMetrics>{
+      {instrumentation_library.get(), std::vector<metric_sdk::MetricData>{metric_data}}};
+
+  std::stringstream stdoutOutput;
+  std::streambuf *sbuf = std::cout.rdbuf();
+  std::cout.rdbuf(stdoutOutput.rdbuf());
+
+  auto result = exporter->Export(data);
+  EXPECT_EQ(result, opentelemetry::sdk::common::ExportResult::kSuccess);
+  std::cout.rdbuf(sbuf);
+
+  std::string expected_output =
+      "{"
+      "\n  name\t\t: library_name"
+      "\n  schema url\t: "
+      "\n  version\t: 1.2.0"
+      "\n  start time\t: Thu Jan  1 00:00:00 1970"
+      "\n  end time\t: Thu Jan  1 00:00:00 1970"
+      "\n  name\t\t: library_name"
+      "\n  description\t: description"
+      "\n  unit\t\t: unit"
+      "\n  type\t\t: SumPointData"
+      "\n  value\t\t: 10"
+      "\n  attributes\t\t: "
+      "\n\ta1: b1"
+      "\n  type\t\t: SumPointData"
+      "\n  value\t\t: 20"
+      "\n  attributes\t\t: "
+      "\n\ta1: b1"
+      "\n}\n";
+  ASSERT_EQ(stdoutOutput.str(), expected_output);
+}
+
+TEST(OStreamMetricsExporter, ExportHistogramPointData)
+{
+  auto exporter =
+      std::unique_ptr<metric_sdk::MetricExporter>(new exportermetrics::OStreamMetricExporter);
+
+  metric_sdk::HistogramPointData histogram_point_data{};
+  histogram_point_data.boundaries_ = std::list<double>{10.1, 20.2, 30.2};
+  histogram_point_data.count_      = 3;
+  histogram_point_data.counts_     = {200, 300, 400, 500};
+  histogram_point_data.sum_        = 900.5;
+  metric_sdk::HistogramPointData histogram_point_data2{};
+  histogram_point_data2.boundaries_ = std::list<long>{10, 20, 30};
+  histogram_point_data2.count_      = 3;
+  histogram_point_data2.counts_     = {200, 300, 400, 500};
+  histogram_point_data2.sum_        = 900l;
+  metric_sdk::ResourceMetrics data;
+  auto resource = opentelemetry::sdk::resource::Resource::Create(
+      opentelemetry::sdk::resource::ResourceAttributes{});
+  data.resource_ = &resource;
+  auto instrumentation_library =
+      opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary::Create("library_name",
+                                                                                 "1.2.0");
+  metric_sdk::MetricData metric_data{
+      metric_sdk::InstrumentDescriptor{"library_name", "description", "unit",
+                                       metric_sdk::InstrumentType::kCounter,
+                                       metric_sdk::InstrumentValueType::kDouble},
+      opentelemetry::common::SystemTimestamp{}, opentelemetry::common::SystemTimestamp{},
+      std::vector<metric_sdk::PointDataAttributes>{
+          {metric_sdk::PointAttributes{{"a1", "b1"}, {"a2", "b2"}}, histogram_point_data},
+          {metric_sdk::PointAttributes{{"a1", "b1"}}, histogram_point_data2}}};
+  data.instrumentation_info_metric_data_ = std::vector<metric_sdk::InstrumentationInfoMetrics>{
+      {instrumentation_library.get(), std::vector<metric_sdk::MetricData>{metric_data}}};
+
+  std::stringstream stdoutOutput;
+  std::streambuf *sbuf = std::cout.rdbuf();
+  std::cout.rdbuf(stdoutOutput.rdbuf());
+
+  auto result = exporter->Export(data);
+  EXPECT_EQ(result, opentelemetry::sdk::common::ExportResult::kSuccess);
+  std::cout.rdbuf(sbuf);
+
+  std::string expected_output =
+      "{"
+      "\n  name\t\t: library_name"
+      "\n  schema url\t: "
+      "\n  version\t: 1.2.0"
+      "\n  start time\t: Thu Jan  1 00:00:00 1970"
+      "\n  end time\t: Thu Jan  1 00:00:00 1970"
+      "\n  name\t\t: library_name"
+      "\n  description\t: description"
+      "\n  unit\t\t: unit"
+      "\n  type     : HistogramPointData"
+      "\n  count     : 3"
+      "\n  sum     : 900.5"
+      "\n  buckets     : [10.1, 20.2, 30.2, ]"
+      "\n  counts     : [200, 300, 400, 500, ]"
+      "\n  attributes\t\t: "
+      "\n\ta1: b1"
+      "\n\ta2: b2"
+      "\n  type     : HistogramPointData"
+      "\n  count     : 3"
+      "\n  sum     : 900"
+      "\n  buckets     : [10, 20, 30, ]"
+      "\n  counts     : [200, 300, 400, 500, ]"
+      "\n  attributes\t\t: "
+      "\n\ta1: b1"
+      "\n}\n";
+  ASSERT_EQ(stdoutOutput.str(), expected_output);
+}
+
+TEST(OStreamMetricsExporter, ExportLastValuePointData)
+{
+  auto exporter =
+      std::unique_ptr<metric_sdk::MetricExporter>(new exportermetrics::OStreamMetricExporter);
+
+  metric_sdk::ResourceMetrics data;
+  auto resource = opentelemetry::sdk::resource::Resource::Create(
+      opentelemetry::sdk::resource::ResourceAttributes{});
+  data.resource_ = &resource;
+  auto instrumentation_library =
+      opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary::Create("library_name",
+                                                                                 "1.2.0");
+  metric_sdk::LastValuePointData last_value_point_data{};
+  last_value_point_data.value_              = 10.0;
+  last_value_point_data.is_lastvalue_valid_ = true;
+  last_value_point_data.sample_ts_          = opentelemetry::common::SystemTimestamp{};
+  metric_sdk::LastValuePointData last_value_point_data2{};
+  last_value_point_data2.value_              = 20l;
+  last_value_point_data2.is_lastvalue_valid_ = true;
+  last_value_point_data2.sample_ts_          = opentelemetry::common::SystemTimestamp{};
+  metric_sdk::MetricData metric_data{
+      metric_sdk::InstrumentDescriptor{"library_name", "description", "unit",
+                                       metric_sdk::InstrumentType::kCounter,
+                                       metric_sdk::InstrumentValueType::kDouble},
+      opentelemetry::common::SystemTimestamp{}, opentelemetry::common::SystemTimestamp{},
+      std::vector<metric_sdk::PointDataAttributes>{
+          {metric_sdk::PointAttributes{}, last_value_point_data},
+          {metric_sdk::PointAttributes{}, last_value_point_data2}}};
+  data.instrumentation_info_metric_data_ = std::vector<metric_sdk::InstrumentationInfoMetrics>{
+      {instrumentation_library.get(), std::vector<metric_sdk::MetricData>{metric_data}}};
+
+  std::stringstream stdoutOutput;
+  std::streambuf *sbuf = std::cout.rdbuf();
+  std::cout.rdbuf(stdoutOutput.rdbuf());
+
+  auto result = exporter->Export(data);
+  EXPECT_EQ(result, opentelemetry::sdk::common::ExportResult::kSuccess);
+  std::cout.rdbuf(sbuf);
+
+  std::string expected_output =
+      "{"
+      "\n  name\t\t: library_name"
+      "\n  schema url\t: "
+      "\n  version\t: 1.2.0"
+      "\n  start time\t: Thu Jan  1 00:00:00 1970"
+      "\n  end time\t: Thu Jan  1 00:00:00 1970"
+      "\n  name\t\t: library_name"
+      "\n  description\t: description"
+      "\n  unit\t\t: unit"
+      "\n  type     : LastValuePointData"
+      "\n  timestamp     : 0"
+      "\n  valid     : true"
+      "\n  value     : 10"
+      "\n  attributes\t\t: "
+      "\n  type     : LastValuePointData"
+      "\n  timestamp     : 0"
+      "\n  valid     : true"
+      "\n  value     : 20"
+      "\n  attributes\t\t: "
+      "\n}\n";
+  ASSERT_EQ(stdoutOutput.str(), expected_output);
+}
+
+TEST(OStreamMetricsExporter, ExportDropPointData)
+{
+  auto exporter =
+      std::unique_ptr<metric_sdk::MetricExporter>(new exportermetrics::OStreamMetricExporter);
+
+  metric_sdk::ResourceMetrics data;
+  auto resource = opentelemetry::sdk::resource::Resource::Create(
+      opentelemetry::sdk::resource::ResourceAttributes{});
+  data.resource_ = &resource;
+  auto instrumentation_library =
+      opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary::Create("library_name",
+                                                                                 "1.2.0");
+  metric_sdk::DropPointData drop_point_data{};
+  metric_sdk::DropPointData drop_point_data2{};
+  metric_sdk::MetricData metric_data{
+      metric_sdk::InstrumentDescriptor{"library_name", "description", "unit",
+                                       metric_sdk::InstrumentType::kCounter,
+                                       metric_sdk::InstrumentValueType::kDouble},
+      opentelemetry::common::SystemTimestamp{}, opentelemetry::common::SystemTimestamp{},
+      std::vector<metric_sdk::PointDataAttributes>{
+          {metric_sdk::PointAttributes{}, drop_point_data},
+          {metric_sdk::PointAttributes{}, drop_point_data2}}};
+  data.instrumentation_info_metric_data_ = std::vector<metric_sdk::InstrumentationInfoMetrics>{
+      {instrumentation_library.get(), std::vector<metric_sdk::MetricData>{metric_data}}};
+
+  std::stringstream stdoutOutput;
+  std::streambuf *sbuf = std::cout.rdbuf();
+  std::cout.rdbuf(stdoutOutput.rdbuf());
+
+  auto result = exporter->Export(data);
+  EXPECT_EQ(result, opentelemetry::sdk::common::ExportResult::kSuccess);
+  std::cout.rdbuf(sbuf);
+
+  std::string expected_output =
+      "{"
+      "\n  name\t\t: library_name"
+      "\n  schema url\t: "
+      "\n  version\t: 1.2.0"
+      "\n  start time\t: Thu Jan  1 00:00:00 1970"
+      "\n  end time\t: Thu Jan  1 00:00:00 1970"
+      "\n  name\t\t: library_name"
+      "\n  description\t: description"
+      "\n  unit\t\t: unit"
+      "\n}\n";
+
+  ASSERT_EQ(stdoutOutput.str(), expected_output);
+}
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_metrics_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_metrics_test.cc
new file mode 100644
index 000000000..f5539c3d4
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_metrics_test.cc
@@ -0,0 +1,295 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <gtest/gtest.h>
+#ifdef ENABLE_METRICS_PREVIEW
+
+#  include "opentelemetry/exporters/ostream/metrics_exporter.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/counter_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/exact_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/gauge_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/min_max_sum_count_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/sketch_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/exporter.h"
+#  include "opentelemetry/sdk/_metrics/record.h"
+
+#  include <iostream>
+
+namespace metric_sdk      = opentelemetry::sdk::metrics;
+namespace metrics_api     = opentelemetry::metrics;
+namespace nostd           = opentelemetry::nostd;
+namespace exportermetrics = opentelemetry::exporter::metrics;
+
+TEST(OStreamMetricsExporter, PrintCounter)
+{
+  auto exporter =
+      std::unique_ptr<metric_sdk::MetricsExporter>(new exportermetrics::OStreamMetricsExporter);
+
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<double>>(
+      new metric_sdk::CounterAggregator<double>(metrics_api::InstrumentKind::Counter));
+
+  aggregator->update(5.5);
+  aggregator->checkpoint();
+
+  metric_sdk::Record r("name", "description", "labels", aggregator);
+  std::vector<metric_sdk::Record> records;
+  records.push_back(r);
+
+  // Create stringstream to redirect to
+  std::stringstream stdoutOutput;
+
+  // Save cout's buffer here
+  std::streambuf *sbuf = std::cout.rdbuf();
+
+  // Redirect cout to our stringstream buffer
+  std::cout.rdbuf(stdoutOutput.rdbuf());
+
+  exporter->Export(records);
+
+  std::cout.rdbuf(sbuf);
+
+  std::string expectedOutput =
+      "{\n"
+      "  name        : name\n"
+      "  description : description\n"
+      "  labels      : labels\n"
+      "  sum         : 5.5\n"
+      "}\n";
+
+  ASSERT_EQ(stdoutOutput.str(), expectedOutput);
+}
+
+TEST(OStreamMetricsExporter, PrintMinMaxSumCount)
+{
+  auto exporter =
+      std::unique_ptr<metric_sdk::MetricsExporter>(new exportermetrics::OStreamMetricsExporter);
+
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<int>>(
+      new metric_sdk::MinMaxSumCountAggregator<int>(metrics_api::InstrumentKind::Counter));
+
+  aggregator->update(1);
+  aggregator->update(2);
+  aggregator->checkpoint();
+
+  metric_sdk::Record r("name", "description", "labels", aggregator);
+  std::vector<metric_sdk::Record> records;
+  records.push_back(r);
+
+  // Create stringstream to redirect to
+  std::stringstream stdoutOutput;
+
+  // Save cout's buffer here
+  std::streambuf *sbuf = std::cout.rdbuf();
+
+  // Redirect cout to our stringstream buffer
+  std::cout.rdbuf(stdoutOutput.rdbuf());
+
+  exporter->Export(records);
+
+  std::cout.rdbuf(sbuf);
+
+  std::string expectedOutput =
+      "{\n"
+      "  name        : name\n"
+      "  description : description\n"
+      "  labels      : labels\n"
+      "  min         : 1\n"
+      "  max         : 2\n"
+      "  sum         : 3\n"
+      "  count       : 2\n"
+      "}\n";
+
+  ASSERT_EQ(stdoutOutput.str(), expectedOutput);
+}
+
+TEST(OStreamMetricsExporter, PrintGauge)
+{
+  auto exporter =
+      std::unique_ptr<metric_sdk::MetricsExporter>(new exportermetrics::OStreamMetricsExporter);
+
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<short>>(
+      new metric_sdk::GaugeAggregator<short>(metrics_api::InstrumentKind::Counter));
+
+  aggregator->update(1);
+  aggregator->update(9);
+  aggregator->checkpoint();
+
+  metric_sdk::Record r("name", "description", "labels", aggregator);
+  std::vector<metric_sdk::Record> records;
+  records.push_back(r);
+
+  // Create stringstream to redirect to
+  std::stringstream stdoutOutput;
+
+  // Save cout's buffer here
+  std::streambuf *sbuf = std::cout.rdbuf();
+
+  // Redirect cout to our stringstream buffer
+  std::cout.rdbuf(stdoutOutput.rdbuf());
+
+  exporter->Export(records);
+
+  std::cout.rdbuf(sbuf);
+
+  std::string expectedOutput =
+      "{\n"
+      "  name        : name\n"
+      "  description : description\n"
+      "  labels      : labels\n"
+      "  last value  : 9\n"
+      "  timestamp   : " +
+      std::to_string(aggregator->get_checkpoint_timestamp().time_since_epoch().count()) +
+      "\n"
+      "}\n";
+
+  ASSERT_EQ(stdoutOutput.str(), expectedOutput);
+}
+
+TEST(OStreamMetricsExporter, PrintExact)
+{
+  auto exporter =
+      std::unique_ptr<metric_sdk::MetricsExporter>(new exportermetrics::OStreamMetricsExporter);
+
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<short>>(
+      new metric_sdk::ExactAggregator<short>(metrics_api::InstrumentKind::Counter, true));
+
+  auto aggregator2 = std::shared_ptr<metric_sdk::Aggregator<short>>(
+      new metric_sdk::ExactAggregator<short>(metrics_api::InstrumentKind::Counter, false));
+
+  for (int i = 0; i < 10; i++)
+  {
+    aggregator->update(i);
+    aggregator2->update(i);
+  }
+  aggregator->checkpoint();
+  aggregator2->checkpoint();
+
+  metric_sdk::Record r("name", "description", "labels", aggregator);
+  metric_sdk::Record r2("name", "description", "labels", aggregator2);
+  std::vector<metric_sdk::Record> records;
+  records.push_back(r);
+  records.push_back(r2);
+
+  // Create stringstream to redirect to
+  std::stringstream stdoutOutput;
+
+  // Save cout's buffer here
+  std::streambuf *sbuf = std::cout.rdbuf();
+
+  // Redirect cout to our stringstream buffer
+  std::cout.rdbuf(stdoutOutput.rdbuf());
+
+  exporter->Export(records);
+
+  std::cout.rdbuf(sbuf);
+
+  std::string expectedOutput =
+      "{\n"
+      "  name        : name\n"
+      "  description : description\n"
+      "  labels      : labels\n"
+      "  quantiles   : [0: 0, .25: 3, .50: 5, .75: 7, 1: 9]\n"
+      "}\n"
+      "{\n"
+      "  name        : name\n"
+      "  description : description\n"
+      "  labels      : labels\n"
+      "  values      : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n"
+      "}\n";
+
+  ASSERT_EQ(stdoutOutput.str(), expectedOutput);
+}
+
+TEST(OStreamMetricsExporter, PrintHistogram)
+{
+  auto exporter =
+      std::unique_ptr<metric_sdk::MetricsExporter>(new exportermetrics::OStreamMetricsExporter);
+
+  std::vector<double> boundaries{10, 20, 30, 40, 50};
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<float>>(
+      new metric_sdk::HistogramAggregator<float>(metrics_api::InstrumentKind::Counter, boundaries));
+
+  for (float i = 0; i < 60; i++)
+  {
+    aggregator->update(i);
+  }
+  aggregator->checkpoint();
+
+  metric_sdk::Record r("name", "description", "labels", aggregator);
+  std::vector<metric_sdk::Record> records;
+  records.push_back(r);
+
+  // Create stringstream to redirect to
+  std::stringstream stdoutOutput;
+
+  // Save cout's buffer here
+  std::streambuf *sbuf = std::cout.rdbuf();
+
+  // Redirect cout to our stringstream buffer
+  std::cout.rdbuf(stdoutOutput.rdbuf());
+
+  exporter->Export(records);
+
+  std::cout.rdbuf(sbuf);
+
+  std::string expectedOutput =
+      "{\n"
+      "  name        : name\n"
+      "  description : description\n"
+      "  labels      : labels\n"
+      "  buckets     : [10, 20, 30, 40, 50]\n"
+      "  counts      : [10, 10, 10, 10, 10, 10]\n"
+      "}\n";
+
+  ASSERT_EQ(stdoutOutput.str(), expectedOutput);
+}
+
+TEST(OStreamMetricsExporter, PrintSketch)
+{
+  auto exporter =
+      std::unique_ptr<metric_sdk::MetricsExporter>(new exportermetrics::OStreamMetricsExporter);
+
+  std::vector<double> boundaries{1, 3, 5, 7, 9};
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<int>>(
+      new metric_sdk::SketchAggregator<int>(metrics_api::InstrumentKind::Counter, .000005));
+
+  for (int i = 0; i < 10; i++)
+  {
+    aggregator->update(i);
+  }
+  aggregator->checkpoint();
+
+  metric_sdk::Record r("name", "description", "labels", aggregator);
+  std::vector<metric_sdk::Record> records;
+  records.push_back(r);
+
+  // Create stringstream to redirect to
+  std::stringstream stdoutOutput;
+
+  // Save cout's buffer here
+  std::streambuf *sbuf = std::cout.rdbuf();
+
+  // Redirect cout to our stringstream buffer
+  std::cout.rdbuf(stdoutOutput.rdbuf());
+
+  exporter->Export(records);
+
+  std::cout.rdbuf(sbuf);
+
+  std::string expectedOutput =
+      "{\n"
+      "  name        : name\n"
+      "  description : description\n"
+      "  labels      : labels\n"
+      "  buckets     : [0, 0.999995, 2, 3.00001, 4, 4.99999, 5.99997, 7.00003, 8.00003, 9]\n"
+      "  counts      : [1, 1, 1, 1, 1, 1, 1, 1, 1, 1]\n"
+      "}\n";
+
+  ASSERT_EQ(stdoutOutput.str(), expectedOutput);
+}
+#else
+TEST(OStreamMetricsExporter, DummyTest)
+{
+  // empty
+}
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_span_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_span_test.cc
new file mode 100644
index 000000000..edfd66505
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/ostream/test/ostream_span_test.cc
@@ -0,0 +1,398 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/common/key_value_iterable_view.h"
+#include "opentelemetry/sdk/trace/recordable.h"
+#include "opentelemetry/sdk/trace/simple_processor.h"
+#include "opentelemetry/sdk/trace/span_data.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
+#include "opentelemetry/trace/provider.h"
+
+#include "opentelemetry/sdk/trace/exporter.h"
+
+#include "opentelemetry/exporters/ostream/span_exporter.h"
+
+#include "ostream_capture.h"
+
+#include <gtest/gtest.h>
+#include <iostream>
+
+using namespace opentelemetry::exporter::ostream::test;
+
+namespace trace         = opentelemetry::trace;
+namespace common        = opentelemetry::common;
+namespace nostd         = opentelemetry::nostd;
+namespace trace_sdk     = opentelemetry::sdk::trace;
+namespace resource      = opentelemetry::sdk::resource;
+namespace exportertrace = opentelemetry::exporter::trace;
+
+using Attributes = std::initializer_list<std::pair<nostd::string_view, common::AttributeValue>>;
+
+class TestResource : public resource::Resource
+{
+public:
+  TestResource(resource::ResourceAttributes attributes = resource::ResourceAttributes())
+      : resource::Resource(attributes)
+  {}
+};
+
+// Testing Shutdown functionality of OStreamSpanExporter, should expect no data to be sent to Stream
+TEST(OStreamSpanExporter, Shutdown)
+{
+  auto exporter  = std::unique_ptr<trace_sdk::SpanExporter>(new exportertrace::OStreamSpanExporter);
+  auto processor = std::shared_ptr<trace_sdk::SpanProcessor>(
+      new trace_sdk::SimpleSpanProcessor(std::move(exporter)));
+
+  auto recordable = processor->MakeRecordable();
+  recordable->SetName("Test Span");
+
+  // Capture the output of cout
+  const auto captured = WithOStreamCapture(std::cout, [&]() {
+    EXPECT_TRUE(processor->Shutdown());
+    processor->OnEnd(std::move(recordable));
+  });
+  std::string err_message =
+      "[Ostream Trace Exporter] Exporting 1 span(s) failed, exporter is shutdown";
+  EXPECT_TRUE(captured.find(err_message) != std::string::npos);
+}
+
+constexpr const char *kDefaultSpanPrinted =
+    "{\n"
+    "  name          : \n"
+    "  trace_id      : 00000000000000000000000000000000\n"
+    "  span_id       : 0000000000000000\n"
+    "  tracestate    : \n"
+    "  parent_span_id: 0000000000000000\n"
+    "  start         : 0\n"
+    "  duration      : 0\n"
+    "  description   : \n"
+    "  span kind     : Internal\n"
+    "  status        : Unset\n"
+    "  attributes    : \n"
+    "  events        : \n"
+    "  links         : \n"
+    "  resources     : \n"
+    "  instr-lib     : unknown_service\n"
+    "}\n";
+
+// Testing what a default span that is not changed will print out, either all 0's or empty values
+TEST(OStreamSpanExporter, PrintDefaultSpan)
+{
+  std::stringstream output;
+  auto exporter =
+      std::unique_ptr<trace_sdk::SpanExporter>(new exportertrace::OStreamSpanExporter(output));
+  auto processor = std::shared_ptr<trace_sdk::SpanProcessor>(
+      new trace_sdk::SimpleSpanProcessor(std::move(exporter)));
+
+  auto recordable = processor->MakeRecordable();
+
+  processor->OnEnd(std::move(recordable));
+
+  EXPECT_EQ(output.str(), kDefaultSpanPrinted);
+}
+
+TEST(OStreamSpanExporter, PrintSpanWithBasicFields)
+{
+  std::stringstream output;
+  auto exporter =
+      std::unique_ptr<trace_sdk::SpanExporter>(new exportertrace::OStreamSpanExporter(output));
+  auto processor = std::shared_ptr<trace_sdk::SpanProcessor>(
+      new trace_sdk::SimpleSpanProcessor(std::move(exporter)));
+
+  auto recordable = processor->MakeRecordable();
+
+  constexpr uint8_t trace_id_buf[]       = {1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8};
+  constexpr uint8_t span_id_buf[]        = {1, 2, 3, 4, 5, 6, 7, 8};
+  constexpr uint8_t parent_span_id_buf[] = {8, 7, 6, 5, 4, 3, 2, 1};
+  trace::TraceId trace_id{trace_id_buf};
+  trace::SpanId span_id{span_id_buf};
+  trace::SpanId parent_span_id{parent_span_id_buf};
+  const auto trace_state = trace::TraceState::GetDefault()->Set("state1", "value");
+  const trace::SpanContext span_context{
+      trace_id, span_id, trace::TraceFlags{trace::TraceFlags::kIsSampled}, true, trace_state};
+
+  recordable->SetIdentity(span_context, parent_span_id);
+  recordable->SetName("Test Span");
+  common::SystemTimestamp now(std::chrono::system_clock::now());
+  recordable->SetStartTime(now);
+  recordable->SetDuration(std::chrono::nanoseconds(100));
+  recordable->SetStatus(trace::StatusCode::kOk, "Test Description");
+  recordable->SetSpanKind(trace::SpanKind::kClient);
+
+  TestResource resource1(resource::ResourceAttributes({{"key1", "val1"}}));
+  recordable->SetResource(resource1);
+
+  processor->OnEnd(std::move(recordable));
+
+  std::string start = std::to_string(now.time_since_epoch().count());
+
+  std::string expectedOutput =
+      "{\n"
+      "  name          : Test Span\n"
+      "  trace_id      : 01020304050607080102030405060708\n"
+      "  span_id       : 0102030405060708\n"
+      "  tracestate    : state1=value\n"
+      "  parent_span_id: 0807060504030201\n"
+      "  start         : " +
+      start +
+      "\n"
+      "  duration      : 100\n"
+      "  description   : Test Description\n"
+      "  span kind     : Client\n"
+      "  status        : Ok\n"
+      "  attributes    : \n"
+      "  events        : \n"
+      "  links         : \n"
+      "  resources     : \n"
+      "\tkey1: val1\n"
+      "  instr-lib     : unknown_service\n"
+      "}\n";
+  EXPECT_EQ(output.str(), expectedOutput);
+}
+
+TEST(OStreamSpanExporter, PrintSpanWithAttribute)
+{
+  std::stringstream output;
+  auto exporter =
+      std::unique_ptr<trace_sdk::SpanExporter>(new exportertrace::OStreamSpanExporter(output));
+  auto processor = std::shared_ptr<trace_sdk::SpanProcessor>(
+      new trace_sdk::SimpleSpanProcessor(std::move(exporter)));
+
+  auto recordable = processor->MakeRecordable();
+
+  recordable->SetAttribute("attr1", "string");
+
+  processor->OnEnd(std::move(recordable));
+
+  std::string expectedOutput =
+      "{\n"
+      "  name          : \n"
+      "  trace_id      : 00000000000000000000000000000000\n"
+      "  span_id       : 0000000000000000\n"
+      "  tracestate    : \n"
+      "  parent_span_id: 0000000000000000\n"
+      "  start         : 0\n"
+      "  duration      : 0\n"
+      "  description   : \n"
+      "  span kind     : Internal\n"
+      "  status        : Unset\n"
+      "  attributes    : \n"
+      "\tattr1: string\n"
+      "  events        : \n"
+      "  links         : \n"
+      "  resources     : \n"
+      "  instr-lib     : unknown_service\n"
+      "}\n";
+  EXPECT_EQ(output.str(), expectedOutput);
+}
+
+TEST(OStreamSpanExporter, PrintSpanWithArrayAttribute)
+{
+  std::stringstream output;
+  auto exporter =
+      std::unique_ptr<trace_sdk::SpanExporter>(new exportertrace::OStreamSpanExporter(output));
+  auto processor = std::shared_ptr<trace_sdk::SpanProcessor>(
+      new trace_sdk::SimpleSpanProcessor(std::move(exporter)));
+
+  auto recordable = processor->MakeRecordable();
+
+  std::array<int, 3> array1 = {1, 2, 3};
+  nostd::span<int> span1{array1.data(), array1.size()};
+  recordable->SetAttribute("array1", span1);
+
+  processor->OnEnd(std::move(recordable));
+
+  std::string expectedOutput =
+      "{\n"
+      "  name          : \n"
+      "  trace_id      : 00000000000000000000000000000000\n"
+      "  span_id       : 0000000000000000\n"
+      "  tracestate    : \n"
+      "  parent_span_id: 0000000000000000\n"
+      "  start         : 0\n"
+      "  duration      : 0\n"
+      "  description   : \n"
+      "  span kind     : Internal\n"
+      "  status        : Unset\n"
+      "  attributes    : \n"
+      "\tarray1: [1,2,3]\n"
+      "  events        : \n"
+      "  links         : \n"
+      "  resources     : \n"
+      "  instr-lib     : unknown_service\n"
+      "}\n";
+  EXPECT_EQ(output.str(), expectedOutput);
+}
+
+TEST(OStreamSpanExporter, PrintSpanWithEvents)
+{
+  std::stringstream output;
+  auto exporter =
+      std::unique_ptr<trace_sdk::SpanExporter>(new exportertrace::OStreamSpanExporter(output));
+  auto processor = std::shared_ptr<trace_sdk::SpanProcessor>(
+      new trace_sdk::SimpleSpanProcessor(std::move(exporter)));
+
+  auto recordable = processor->MakeRecordable();
+  common::SystemTimestamp now(std::chrono::system_clock::now());
+  common::SystemTimestamp next(std::chrono::system_clock::now() + std::chrono::seconds(1));
+
+  std::string now_str  = std::to_string(now.time_since_epoch().count());
+  std::string next_str = std::to_string(next.time_since_epoch().count());
+
+  recordable->AddEvent("hello", now);
+  recordable->AddEvent("world", next,
+                       common::KeyValueIterableView<Attributes>({{"attr1", "string"}}));
+
+  processor->OnEnd(std::move(recordable));
+
+  std::string expectedOutput =
+      "{\n"
+      "  name          : \n"
+      "  trace_id      : 00000000000000000000000000000000\n"
+      "  span_id       : 0000000000000000\n"
+      "  tracestate    : \n"
+      "  parent_span_id: 0000000000000000\n"
+      "  start         : 0\n"
+      "  duration      : 0\n"
+      "  description   : \n"
+      "  span kind     : Internal\n"
+      "  status        : Unset\n"
+      "  attributes    : \n"
+      "  events        : \n"
+      "\t{\n"
+      "\t  name          : hello\n"
+      "\t  timestamp     : " +
+      now_str +
+      "\n"
+      "\t  attributes    : \n"
+      "\t}\n"
+      "\t{\n"
+      "\t  name          : world\n"
+      "\t  timestamp     : " +
+      next_str +
+      "\n"
+      "\t  attributes    : \n"
+      "\t\tattr1: string\n"
+      "\t}\n"
+      "  links         : \n"
+      "  resources     : \n"
+      "  instr-lib     : unknown_service\n"
+      "}\n";
+  EXPECT_EQ(output.str(), expectedOutput);
+}
+
+TEST(OStreamSpanExporter, PrintSpanWithLinks)
+{
+  std::stringstream output;
+  auto exporter =
+      std::unique_ptr<trace_sdk::SpanExporter>(new exportertrace::OStreamSpanExporter(output));
+  auto processor = std::shared_ptr<trace_sdk::SpanProcessor>(
+      new trace_sdk::SimpleSpanProcessor(std::move(exporter)));
+
+  auto recordable = processor->MakeRecordable();
+
+  // produce valid SpanContext with pseudo span and trace Id.
+  uint8_t span_id_buf[trace::SpanId::kSize] = {
+      1,
+  };
+  trace::SpanId span_id{span_id_buf};
+  uint8_t trace_id_buf[trace::TraceId::kSize] = {
+      2,
+  };
+  trace::TraceId trace_id{trace_id_buf};
+  const auto span_context =
+      trace::SpanContext(trace_id, span_id, trace::TraceFlags{trace::TraceFlags::kIsSampled}, true);
+
+  // and another to check preserving order.
+  uint8_t span_id_buf2[trace::SpanId::kSize] = {
+      3,
+  };
+  trace::SpanId span_id2{span_id_buf2};
+  const auto span_context2 =
+      trace::SpanContext(trace_id, span_id2, trace::TraceFlags{trace::TraceFlags::kIsSampled}, true,
+                         trace::TraceState::FromHeader("state1=value"));
+
+  recordable->AddLink(span_context);
+  recordable->AddLink(span_context2,
+                      common::KeyValueIterableView<Attributes>({{"attr1", "string"}}));
+
+  processor->OnEnd(std::move(recordable));
+
+  std::string expectedOutput =
+      "{\n"
+      "  name          : \n"
+      "  trace_id      : 00000000000000000000000000000000\n"
+      "  span_id       : 0000000000000000\n"
+      "  tracestate    : \n"
+      "  parent_span_id: 0000000000000000\n"
+      "  start         : 0\n"
+      "  duration      : 0\n"
+      "  description   : \n"
+      "  span kind     : Internal\n"
+      "  status        : Unset\n"
+      "  attributes    : \n"
+      "  events        : \n"
+      "  links         : \n"
+      "\t{\n"
+      "\t  trace_id      : 02000000000000000000000000000000\n"
+      "\t  span_id       : 0100000000000000\n"
+      "\t  tracestate    : \n"
+      "\t  attributes    : \n"
+      "\t}\n"
+      "\t{\n"
+      "\t  trace_id      : 02000000000000000000000000000000\n"
+      "\t  span_id       : 0300000000000000\n"
+      "\t  tracestate    : state1=value\n"
+      "\t  attributes    : \n"
+      "\t\tattr1: string\n"
+      "\t}\n"
+      "  resources     : \n"
+      "  instr-lib     : unknown_service\n"
+      "}\n";
+  EXPECT_EQ(output.str(), expectedOutput);
+}
+
+// Test with the three common ostreams, tests are more of a sanity check and usage examples.
+TEST(OStreamSpanExporter, PrintSpanToCout)
+{
+  auto exporter  = std::unique_ptr<trace_sdk::SpanExporter>(new exportertrace::OStreamSpanExporter);
+  auto processor = std::shared_ptr<trace_sdk::SpanProcessor>(
+      new trace_sdk::SimpleSpanProcessor(std::move(exporter)));
+
+  auto recordable = processor->MakeRecordable();
+
+  const auto captured =
+      WithOStreamCapture(std::cout, [&]() { processor->OnEnd(std::move(recordable)); });
+
+  EXPECT_EQ(captured, kDefaultSpanPrinted);
+}
+
+TEST(OStreamSpanExporter, PrintSpanToCerr)
+{
+  auto exporter =
+      std::unique_ptr<trace_sdk::SpanExporter>(new exportertrace::OStreamSpanExporter(std::cerr));
+  auto processor = std::shared_ptr<trace_sdk::SpanProcessor>(
+      new trace_sdk::SimpleSpanProcessor(std::move(exporter)));
+
+  auto recordable = processor->MakeRecordable();
+
+  const auto captured =
+      WithOStreamCapture(std::cerr, [&]() { processor->OnEnd(std::move(recordable)); });
+
+  EXPECT_EQ(captured, kDefaultSpanPrinted);
+}
+
+TEST(OStreamSpanExporter, PrintSpanToClog)
+{
+  auto exporter =
+      std::unique_ptr<trace_sdk::SpanExporter>(new exportertrace::OStreamSpanExporter(std::clog));
+  auto processor = std::shared_ptr<trace_sdk::SpanProcessor>(
+      new trace_sdk::SimpleSpanProcessor(std::move(exporter)));
+
+  auto recordable = processor->MakeRecordable();
+
+  const auto captured =
+      WithOStreamCapture(std::clog, [&]() { processor->OnEnd(std::move(recordable)); });
+
+  EXPECT_EQ(captured, kDefaultSpanPrinted);
+}
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/BUILD b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/BUILD
new file mode 100644
index 000000000..496819138
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/BUILD
@@ -0,0 +1,286 @@
+# Copyright 2020, OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+package(default_visibility = ["//visibility:public"])
+
+load("//bazel:otel_cc_benchmark.bzl", "otel_cc_benchmark")
+
+cc_library(
+    name = "otlp_recordable",
+    srcs = [
+        "src/otlp_log_recordable.cc",
+        "src/otlp_recordable.cc",
+        "src/otlp_recordable_utils.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/otlp/otlp_log_recordable.h",
+        "include/opentelemetry/exporters/otlp/otlp_recordable.h",
+        "include/opentelemetry/exporters/otlp/otlp_recordable_utils.h",
+        "include/opentelemetry/exporters/otlp/protobuf_include_prefix.h",
+        "include/opentelemetry/exporters/otlp/protobuf_include_suffix.h",
+    ],
+    strip_include_prefix = "include",
+    tags = ["otlp"],
+    deps = [
+        "//sdk/src/logs",
+        "//sdk/src/resource",
+        "//sdk/src/trace",
+        "@com_github_opentelemetry_proto//:logs_service_proto_cc",
+        "@com_github_opentelemetry_proto//:trace_service_proto_cc",
+    ],
+)
+
+cc_library(
+    name = "otlp_grpc_exporter",
+    srcs = [
+        "src/otlp_grpc_exporter.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/otlp/otlp_environment.h",
+        "include/opentelemetry/exporters/otlp/otlp_grpc_exporter.h",
+        "include/opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h",
+        "include/opentelemetry/exporters/otlp/protobuf_include_prefix.h",
+        "include/opentelemetry/exporters/otlp/protobuf_include_suffix.h",
+    ],
+    strip_include_prefix = "include",
+    tags = [
+        "otlp",
+        "otlp_grpc",
+    ],
+    deps = [
+        ":otlp_recordable",
+        "//ext:headers",
+        "//sdk/src/trace",
+
+        # For gRPC
+        "@com_github_opentelemetry_proto//:trace_service_grpc_cc",
+        "@com_github_grpc_grpc//:grpc++",
+    ],
+)
+
+cc_library(
+    name = "otlp_http_client",
+    srcs = [
+        "src/otlp_http_client.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/otlp/otlp_environment.h",
+        "include/opentelemetry/exporters/otlp/otlp_http_client.h",
+        "include/opentelemetry/exporters/otlp/protobuf_include_prefix.h",
+        "include/opentelemetry/exporters/otlp/protobuf_include_suffix.h",
+    ],
+    copts = [
+        "-DCURL_STATICLIB",
+    ],
+    linkopts = select({
+        "//bazel:windows": [
+            "-DEFAULTLIB:advapi32.lib",
+            "-DEFAULTLIB:crypt32.lib",
+        ],
+        "//conditions:default": [],
+    }),
+    strip_include_prefix = "include",
+    tags = [
+        "otlp",
+        "otlp_http",
+        "otlp_http_log",
+    ],
+    deps = [
+        "//api",
+        "//ext/src/http/client/curl:http_client_curl",
+        "//sdk:headers",
+        "@com_github_opentelemetry_proto//:common_proto_cc",
+        "@github_nlohmann_json//:json",
+    ],
+)
+
+cc_library(
+    name = "otlp_http_exporter",
+    srcs = [
+        "src/otlp_http_exporter.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/otlp/otlp_environment.h",
+        "include/opentelemetry/exporters/otlp/otlp_http_exporter.h",
+        "include/opentelemetry/exporters/otlp/protobuf_include_prefix.h",
+        "include/opentelemetry/exporters/otlp/protobuf_include_suffix.h",
+    ],
+    strip_include_prefix = "include",
+    tags = [
+        "otlp",
+        "otlp_http",
+    ],
+    deps = [
+        ":otlp_http_client",
+        ":otlp_recordable",
+        "//sdk/src/trace",
+        "@com_github_opentelemetry_proto//:trace_service_proto_cc",
+    ],
+)
+
+cc_library(
+    name = "otlp_http_log_exporter",
+    srcs = [
+        "src/otlp_http_log_exporter.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/otlp/otlp_environment.h",
+        "include/opentelemetry/exporters/otlp/otlp_http_log_exporter.h",
+        "include/opentelemetry/exporters/otlp/protobuf_include_prefix.h",
+        "include/opentelemetry/exporters/otlp/protobuf_include_suffix.h",
+    ],
+    strip_include_prefix = "include",
+    tags = [
+        "otlp",
+        "otlp_http_log",
+    ],
+    deps = [
+        ":otlp_http_client",
+        ":otlp_recordable",
+        "//sdk/src/logs",
+        "@com_github_opentelemetry_proto//:logs_service_proto_cc",
+    ],
+)
+
+cc_library(
+    name = "otlp_grpc_log_exporter",
+    srcs = [
+        "src/otlp_grpc_log_exporter.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/otlp/otlp_environment.h",
+        "include/opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h",
+        "include/opentelemetry/exporters/otlp/otlp_grpc_log_exporter.h",
+        "include/opentelemetry/exporters/otlp/protobuf_include_prefix.h",
+        "include/opentelemetry/exporters/otlp/protobuf_include_suffix.h",
+    ],
+    strip_include_prefix = "include",
+    tags = [
+        "otlp",
+        "otlp_grpc_log",
+    ],
+    deps = [
+        ":otlp_recordable",
+        "//ext:headers",
+        "//sdk/src/logs",
+        "@com_github_opentelemetry_proto//:logs_service_proto_cc",
+        # For gRPC
+        "@com_github_opentelemetry_proto//:logs_service_grpc_cc",
+        "@com_github_grpc_grpc//:grpc++",
+    ],
+)
+
+cc_test(
+    name = "otlp_recordable_test",
+    srcs = ["test/otlp_recordable_test.cc"],
+    tags = [
+        "otlp",
+        "test",
+    ],
+    deps = [
+        ":otlp_recordable",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "otlp_log_recordable_test",
+    srcs = ["test/otlp_log_recordable_test.cc"],
+    tags = [
+        "otlp",
+        "test",
+    ],
+    deps = [
+        ":otlp_recordable",
+        "@com_github_opentelemetry_proto//:logs_service_proto_cc",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "otlp_grpc_exporter_test",
+    srcs = ["test/otlp_grpc_exporter_test.cc"],
+    tags = [
+        "otlp",
+        "otlp_grpc",
+        "test",
+    ],
+    deps = [
+        ":otlp_grpc_exporter",
+        "//api",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "otlp_http_exporter_test",
+    srcs = ["test/otlp_http_exporter_test.cc"],
+    tags = [
+        "otlp",
+        "otlp_http",
+        "test",
+    ],
+    deps = [
+        ":otlp_http_exporter",
+        "//api",
+        "//ext/src/http/client/nosend:http_client_nosend",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "otlp_http_log_exporter_test",
+    srcs = ["test/otlp_http_log_exporter_test.cc"],
+    tags = [
+        "otlp",
+        "otlp_http_log",
+        "test",
+    ],
+    deps = [
+        ":otlp_http_log_exporter",
+        "//api",
+        "//ext/src/http/client/nosend:http_client_nosend",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "otlp_grpc_log_exporter_test",
+    srcs = ["test/otlp_grpc_log_exporter_test.cc"],
+    tags = [
+        "otlp",
+        "otlp_grpc_log",
+        "test",
+    ],
+    deps = [
+        ":otlp_grpc_log_exporter",
+        "//api",
+        "//sdk/src/logs",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+otel_cc_benchmark(
+    name = "otlp_grpc_exporter_benchmark",
+    srcs = ["test/otlp_grpc_exporter_benchmark.cc"],
+    tags = [
+        "otlp",
+        "otlp_grpc",
+        "test",
+    ],
+    deps = [
+        ":otlp_grpc_exporter",
+        "//examples/common/foo_library:common_foo_library",
+    ],
+)
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/CMakeLists.txt b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/CMakeLists.txt
new file mode 100755
index 000000000..b5dfa1e1a
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/CMakeLists.txt
@@ -0,0 +1,195 @@
+add_library(
+  opentelemetry_otlp_recordable
+  src/otlp_log_recordable.cc src/otlp_recordable.cc
+  src/otlp_recordable_utils.cc)
+set_target_properties(opentelemetry_otlp_recordable PROPERTIES EXPORT_NAME
+                                                               otlp_recordable)
+
+target_include_directories(
+  opentelemetry_otlp_recordable
+  PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+         "$<INSTALL_INTERFACE:include>")
+
+set(OPENTELEMETRY_OTLP_TARGETS opentelemetry_otlp_recordable)
+target_link_libraries(
+  opentelemetry_otlp_recordable
+  PUBLIC opentelemetry_trace opentelemetry_resources opentelemetry_proto)
+
+if(WITH_OTLP_GRPC)
+  find_package(gRPC REQUIRED)
+  add_library(opentelemetry_exporter_otlp_grpc src/otlp_grpc_exporter.cc)
+
+  set_target_properties(opentelemetry_exporter_otlp_grpc
+                        PROPERTIES EXPORT_NAME otlp_grpc_exporter)
+
+  target_link_libraries(opentelemetry_exporter_otlp_grpc
+                        PUBLIC opentelemetry_otlp_recordable gRPC::grpc++)
+
+  list(APPEND OPENTELEMETRY_OTLP_TARGETS opentelemetry_exporter_otlp_grpc)
+
+  add_library(opentelemetry_exporter_otlp_grpc_log
+              src/otlp_grpc_log_exporter.cc)
+
+  set_target_properties(opentelemetry_exporter_otlp_grpc_log
+                        PROPERTIES EXPORT_NAME otlp_grpc_log_exporter)
+
+  target_link_libraries(opentelemetry_exporter_otlp_grpc_log
+                        PUBLIC opentelemetry_otlp_recordable gRPC::grpc++)
+
+  list(APPEND OPENTELEMETRY_OTLP_TARGETS opentelemetry_exporter_otlp_grpc_log)
+endif()
+
+if(WITH_OTLP_HTTP)
+  find_package(CURL REQUIRED)
+  add_library(opentelemetry_exporter_otlp_http_client src/otlp_http_client.cc)
+  set_target_properties(opentelemetry_exporter_otlp_http_client
+                        PROPERTIES EXPORT_NAME otlp_http_client)
+  target_link_libraries(
+    opentelemetry_exporter_otlp_http_client
+    PUBLIC opentelemetry_sdk opentelemetry_proto opentelemetry_http_client_curl
+           nlohmann_json::nlohmann_json)
+  if(nlohmann_json_clone)
+    add_dependencies(opentelemetry_exporter_otlp_http_client
+                     nlohmann_json::nlohmann_json)
+  endif()
+  target_include_directories(
+    opentelemetry_exporter_otlp_http_client
+    PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+           "$<INSTALL_INTERFACE:include>")
+
+  list(APPEND OPENTELEMETRY_OTLP_TARGETS
+       opentelemetry_exporter_otlp_http_client)
+
+  add_library(opentelemetry_exporter_otlp_http src/otlp_http_exporter.cc)
+
+  set_target_properties(opentelemetry_exporter_otlp_http
+                        PROPERTIES EXPORT_NAME otlp_http_exporter)
+
+  target_link_libraries(
+    opentelemetry_exporter_otlp_http
+    PUBLIC opentelemetry_otlp_recordable
+           opentelemetry_exporter_otlp_http_client)
+
+  list(APPEND OPENTELEMETRY_OTLP_TARGETS opentelemetry_exporter_otlp_http)
+
+  if(WITH_LOGS_PREVIEW)
+    add_library(opentelemetry_exporter_otlp_http_log
+                src/otlp_http_log_exporter.cc)
+
+    set_target_properties(opentelemetry_exporter_otlp_http_log
+                          PROPERTIES EXPORT_NAME otlp_http_log_exporter)
+
+    target_link_libraries(
+      opentelemetry_exporter_otlp_http_log
+      PUBLIC opentelemetry_otlp_recordable
+             opentelemetry_exporter_otlp_http_client)
+
+    list(APPEND OPENTELEMETRY_OTLP_TARGETS opentelemetry_exporter_otlp_http_log)
+
+  endif()
+endif()
+
+install(
+  TARGETS ${OPENTELEMETRY_OTLP_TARGETS}
+  EXPORT "${PROJECT_NAME}-target"
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+install(
+  DIRECTORY include/opentelemetry/exporters/otlp
+  DESTINATION include/opentelemetry/exporters
+  FILES_MATCHING
+  PATTERN "*.h")
+
+if(BUILD_TESTING)
+  add_executable(otlp_recordable_test test/otlp_recordable_test.cc)
+  target_link_libraries(otlp_recordable_test ${GTEST_BOTH_LIBRARIES}
+                        ${CMAKE_THREAD_LIBS_INIT} opentelemetry_otlp_recordable)
+  gtest_add_tests(
+    TARGET otlp_recordable_test
+    TEST_PREFIX exporter.otlp.
+    TEST_LIST otlp_recordable_test)
+
+  if(WITH_LOGS_PREVIEW)
+    add_executable(otlp_log_recordable_test test/otlp_log_recordable_test.cc)
+    target_link_libraries(
+      otlp_log_recordable_test ${GTEST_BOTH_LIBRARIES}
+      ${CMAKE_THREAD_LIBS_INIT} opentelemetry_otlp_recordable)
+    gtest_add_tests(
+      TARGET otlp_log_recordable_test
+      TEST_PREFIX exporter.otlp.
+      TEST_LIST otlp_log_recordable_test)
+  endif()
+
+  if(MSVC)
+    # Explicitly specify that we consume GTest from shared library. The rest of
+    # code logic below determines whether we link Release or Debug flavor of the
+    # library. These flavors have different prefix on Windows, gmock and gmockd
+    # respectively.
+    add_definitions(-DGTEST_LINKED_AS_SHARED_LIBRARY=1)
+    if(GMOCK_LIB)
+      # unset GMOCK_LIB to force find_library to redo the lookup, as the cached
+      # entry could cause linking to incorrect flavor of gmock and leading to
+      # runtime error.
+      unset(GMOCK_LIB CACHE)
+    endif()
+  endif()
+  if(MSVC AND CMAKE_BUILD_TYPE STREQUAL "Debug")
+    find_library(GMOCK_LIB gmockd PATH_SUFFIXES lib)
+  else()
+    find_library(GMOCK_LIB gmock PATH_SUFFIXES lib)
+  endif()
+
+  if(WITH_OTLP_GRPC)
+    add_executable(otlp_grpc_exporter_test test/otlp_grpc_exporter_test.cc)
+    target_link_libraries(
+      otlp_grpc_exporter_test ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
+      ${GMOCK_LIB} opentelemetry_exporter_otlp_grpc)
+    gtest_add_tests(
+      TARGET otlp_grpc_exporter_test
+      TEST_PREFIX exporter.otlp.
+      TEST_LIST otlp_grpc_exporter_test)
+
+    if(WITH_LOGS_PREVIEW)
+      add_executable(otlp_grpc_log_exporter_test
+                     test/otlp_grpc_log_exporter_test.cc)
+      target_link_libraries(
+        otlp_grpc_log_exporter_test ${GTEST_BOTH_LIBRARIES}
+        ${CMAKE_THREAD_LIBS_INIT} ${GMOCK_LIB}
+        opentelemetry_exporter_otlp_grpc_log opentelemetry_logs)
+      gtest_add_tests(
+        TARGET otlp_grpc_log_exporter_test
+        TEST_PREFIX exporter.otlp.
+        TEST_LIST otlp_grpc_log_exporter_test)
+    endif()
+  endif()
+
+  if(WITH_OTLP_HTTP)
+    add_executable(otlp_http_exporter_test test/otlp_http_exporter_test.cc)
+    target_link_libraries(
+      otlp_http_exporter_test ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
+      ${GMOCK_LIB} opentelemetry_exporter_otlp_http http_client_nosend)
+    gtest_add_tests(
+      TARGET otlp_http_exporter_test
+      TEST_PREFIX exporter.otlp.
+      TEST_LIST otlp_http_exporter_test)
+
+    if(WITH_LOGS_PREVIEW)
+      add_executable(otlp_http_log_exporter_test
+                     test/otlp_http_log_exporter_test.cc)
+      target_link_libraries(
+        otlp_http_log_exporter_test
+        ${GTEST_BOTH_LIBRARIES}
+        ${CMAKE_THREAD_LIBS_INIT}
+        ${GMOCK_LIB}
+        opentelemetry_exporter_otlp_http_log
+        opentelemetry_logs
+        http_client_nosend)
+      gtest_add_tests(
+        TARGET otlp_http_log_exporter_test
+        TEST_PREFIX exporter.otlp.
+        TEST_LIST otlp_http_log_exporter_test)
+    endif()
+  endif()
+endif() # BUILD_TESTING
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/README.md b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/README.md
new file mode 100644
index 000000000..9ac6918ba
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/README.md
@@ -0,0 +1,79 @@
+# OTLP Exporter
+
+The [OpenTelemetry
+Protocol](https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/README.md)
+(OTLP) is a vendor-agnostic protocol designed as part of the OpenTelemetry
+project. The OTLP exporter can be used to export to any backend that supports
+OTLP.
+
+The [OpenTelemetry
+Collector](https://github.com/open-telemetry/opentelemetry-collector) is a
+reference implementation of an OTLP backend. The Collector can be configured to
+export to many other backends, such as Zipkin and Jaegar.
+
+For a full list of backends supported by the Collector, see the [main Collector
+repo](https://github.com/open-telemetry/opentelemetry-collector/tree/main/exporter)
+and [Collector
+contributions](https://github.com/open-telemetry/opentelemetry-collector-contrib/tree/main/exporter).
+
+## Configuration
+
+The OTLP exporter offers some configuration options. To configure the exporter,
+create an `OtlpGrpcExporterOptions` struct (defined in
+[otlp_grpc_exporter.h](https://github.com/open-telemetry/opentelemetry-cpp/blob/main/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter.h)),
+set the options inside, and pass the struct to the `OtlpGrpcExporter` constructor,
+like so:
+
+```cpp
+OtlpGrpcExporterOptions options;
+options.endpoint = "localhost:12345";
+auto exporter = std::unique_ptr<sdktrace::SpanExporter>(new otlp::OtlpGrpcExporter(options));
+```
+
+The OTLP HTTP exporter offers some configuration options. To configure the exporter,
+create an `OtlpHttpExporterOptions` struct (defined in
+[otlp_http_exporter.h](https://github.com/open-telemetry/opentelemetry-cpp/blob/main/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_http_exporter.h)),
+set the options inside, and pass the struct to the `OtlpHttpExporter` constructor,
+like so:
+
+```cpp
+OtlpHttpExporterOptions options;
+options.url = "localhost:12345";
+auto exporter = std::unique_ptr<sdktrace::SpanExporter>(new otlp::OtlpHttpExporter(options));
+```
+
+### Configuration options ( OTLP GRPC Exporter )
+
+| Option       | Env Variable |Default          |   Description  |
+| ------------ |---------------|------------ |----------------|
+| `endpoint` | `OTEL_EXPORTER_OTLP_ENDPOINT` | `http://localhost:4317`| The OTLP GRPC endpoint to connect to |
+|              |   `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`  |  | |
+| `use_ssl_credentials` | `OTEL_EXPORTER_OTLP_SSL_ENABLE`| `false` | Whether the endpoint is SSL enabled |
+|    | `OTEL_EXPORTER_OTLP_TRACES_SSL_ENABLE` | | |
+| `ssl_credentials_cacert_path`  |  `OTEL_EXPORTER_OTLP_CERTIFICATE` | `""`  | SSL Certificate file path |
+|    | `OTEL_EXPORTER_OTLP_TRACES_CERTIFICATE` | | |
+| `ssl_credentials_cacert_as_string` | `OTEL_EXPORTER_OTLP_CERTIFICATE_STRING` | `""`  |   SSL Certifcate as in-memory string |
+|  | `OTEL_EXPORTER_OTLP_TRACES_CERTIFICATE_STRING` | | | |
+| `timeout`    | `OTEL_EXPORTER_OTLP_TIMEOUT` | `10s` | GRPC deadline |
+|              |   `OTEL_EXPORTER_OTLP_TRACES_TIMEOUT`  |  | |
+| `metadata`   | `OTEL_EXPORTER_OTLP_HEADERS` |  | Custom metadata for GRPC |
+|              |   `OTEL_EXPORTER_OTLP_TRACES_HEADERS`  |  | |
+
+### Configuration options ( OTLP HTTP Exporter )
+
+| Option       | Env Variable |Default          | Description |
+| ------------ |-----|------------ |------|
+| `url`   | `OTEL_EXPORTER_OTLP_ENDPOINT` | `http://localhost:4318/v1/traces`  | The OTLP HTTP endpoint to connect to |
+|              |   `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`  |  | |
+| `content_type` | n/a  | `application/json`  |   Data format used - JSON or Binary |
+| `json_bytes_mapping`  |  n/a | `JsonBytesMappingKind::kHexId` | Encoding used for trace_id and span_id |
+| `use_json_name` | n/a | `false`  | Whether to use json name of protobuf field to set the key of json |
+| `timeout`    | `OTEL_EXPORTER_OTLP_TIMEOUT` | `10s` | http timeout |
+|              |   `OTEL_EXPORTER_OTLP_TRACES_TIMEOUT`  |  |
+| `http_headers` | `OTEL_EXPORTER_OTLP_HEADERS` |  | http headers |
+|              |   `OTEL_EXPORTER_OTLP_TRACES_HEADERS`  |  | |
+
+## Example
+
+For a complete example demonstrating how to use the OTLP exporter, see
+[examples/otlp](https://github.com/open-telemetry/opentelemetry-cpp/blob/main/examples/otlp/).
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h
new file mode 100644
index 000000000..bf7ea6a61
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_environment.h
@@ -0,0 +1,272 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/common/kv_properties.h"
+#include "opentelemetry/nostd/string_view.h"
+
+#include "opentelemetry/sdk/common/attribute_utils.h"
+#include "opentelemetry/sdk/common/env_variables.h"
+
+#include <algorithm>
+#include <chrono>
+#include <map>
+#include <string>
+#include <unordered_set>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+inline const std::string GetOtlpDefaultGrpcEndpoint()
+{
+  constexpr char kOtlpTracesEndpointEnv[] = "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT";
+  constexpr char kOtlpEndpointEnv[]       = "OTEL_EXPORTER_OTLP_ENDPOINT";
+  constexpr char kOtlpEndpointDefault[]   = "http://localhost:4317";
+
+  auto endpoint = opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpTracesEndpointEnv);
+  if (endpoint.empty())
+  {
+    endpoint = opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpEndpointEnv);
+  }
+  return endpoint.size() ? endpoint : kOtlpEndpointDefault;
+}
+
+inline const std::string GetOtlpDefaultHttpEndpoint()
+{
+  constexpr char kOtlpTracesEndpointEnv[] = "OTEL_EXPORTER_OTLP_TRACES_ENDPOINT";
+  constexpr char kOtlpEndpointEnv[]       = "OTEL_EXPORTER_OTLP_ENDPOINT";
+  constexpr char kOtlpEndpointDefault[]   = "http://localhost:4318/v1/traces";
+
+  auto endpoint = opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpTracesEndpointEnv);
+  if (endpoint.empty())
+  {
+    endpoint = opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpEndpointEnv);
+    if (!endpoint.empty())
+    {
+      endpoint += "/v1/traces";
+    }
+  }
+  return endpoint.size() ? endpoint : kOtlpEndpointDefault;
+}
+
+inline bool GetOtlpDefaultIsSslEnable()
+{
+  constexpr char kOtlpTracesIsSslEnableEnv[] = "OTEL_EXPORTER_OTLP_TRACES_SSL_ENABLE";
+  constexpr char kOtlpIsSslEnableEnv[]       = "OTEL_EXPORTER_OTLP_SSL_ENABLE";
+
+  auto ssl_enable = opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpTracesIsSslEnableEnv);
+  if (ssl_enable.empty())
+  {
+    ssl_enable = opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpIsSslEnableEnv);
+  }
+  if (ssl_enable == "True" || ssl_enable == "TRUE" || ssl_enable == "true" || ssl_enable == "1")
+  {
+    return true;
+  }
+  return false;
+}
+
+inline const std::string GetOtlpDefaultSslCertificatePath()
+{
+  constexpr char kOtlpTracesSslCertificate[] = "OTEL_EXPORTER_OTLP_TRACES_CERTIFICATE";
+  constexpr char kOtlpSslCertificate[]       = "OTEL_EXPORTER_OTLP_CERTIFICATE ";
+  auto ssl_cert_path =
+      opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpTracesSslCertificate);
+  if (ssl_cert_path.empty())
+  {
+    ssl_cert_path = opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpSslCertificate);
+  }
+  return ssl_cert_path.size() ? ssl_cert_path : "";
+}
+
+inline const std::string GetOtlpDefaultSslCertificateString()
+{
+  constexpr char kOtlpTracesSslCertificateString[] = "OTEL_EXPORTER_OTLP_CERTIFICATE_STRING";
+  constexpr char kOtlpSslCertificateString[] = "OTEL_EXPORTER_OTLP_TRACES_CERTIFICATE_STRING ";
+  auto ssl_cert =
+      opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpTracesSslCertificateString);
+  if (ssl_cert.empty())
+  {
+    ssl_cert = opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpSslCertificateString);
+  }
+  return ssl_cert.size() ? ssl_cert : "";
+}
+
+inline const std::chrono::system_clock::duration GetOtlpTimeoutFromString(const char *input)
+{
+  if (nullptr == input || 0 == *input)
+  {
+    return std::chrono::duration_cast<std::chrono::system_clock::duration>(
+        std::chrono::seconds{10});
+  }
+
+  std::chrono::system_clock::duration::rep result = 0;
+  // Skip spaces
+  for (; *input && (' ' == *input || '\t' == *input || '\r' == *input || '\n' == *input); ++input)
+    ;
+
+  for (; *input && (*input >= '0' && *input <= '9'); ++input)
+  {
+    result = result * 10 + (*input - '0');
+  }
+
+  opentelemetry::nostd::string_view unit{input};
+  if ("ns" == unit)
+  {
+    return std::chrono::duration_cast<std::chrono::system_clock::duration>(
+        std::chrono::nanoseconds{result});
+  }
+  else if ("us" == unit)
+  {
+    return std::chrono::duration_cast<std::chrono::system_clock::duration>(
+        std::chrono::microseconds{result});
+  }
+  else if ("ms" == unit)
+  {
+    return std::chrono::duration_cast<std::chrono::system_clock::duration>(
+        std::chrono::milliseconds{result});
+  }
+  else if ("m" == unit)
+  {
+    return std::chrono::duration_cast<std::chrono::system_clock::duration>(
+        std::chrono::minutes{result});
+  }
+  else if ("h" == unit)
+  {
+    return std::chrono::duration_cast<std::chrono::system_clock::duration>(
+        std::chrono::hours{result});
+  }
+  else
+  {
+    return std::chrono::duration_cast<std::chrono::system_clock::duration>(
+        std::chrono::seconds{result});
+  }
+}
+
+inline const std::chrono::system_clock::duration GetOtlpDefaultTimeout()
+{
+  constexpr char kOtlpTracesTimeoutEnv[] = "OTEL_EXPORTER_OTLP_TRACES_TIMEOUT";
+  constexpr char kOtlpTimeoutEnv[]       = "OTEL_EXPORTER_OTLP_TIMEOUT";
+
+  auto timeout = opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpTracesTimeoutEnv);
+  if (timeout.empty())
+  {
+    timeout = opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpTimeoutEnv);
+  }
+  return GetOtlpTimeoutFromString(timeout.c_str());
+}
+
+struct cmp_ic
+{
+  bool operator()(const std::string &s1, const std::string &s2) const
+  {
+    return std::lexicographical_compare(
+        s1.begin(), s1.end(), s2.begin(), s2.end(),
+        [](char c1, char c2) { return ::tolower(c1) < ::tolower(c2); });
+  }
+};
+using OtlpHeaders = std::multimap<std::string, std::string, cmp_ic>;
+
+inline void DumpOtlpHeaders(OtlpHeaders &output,
+                            const char *env_var_name,
+                            std::unordered_set<std::string> &remove_cache)
+{
+  auto value = opentelemetry::sdk::common::GetEnvironmentVariable(env_var_name);
+  if (value.empty())
+  {
+    return;
+  }
+
+  opentelemetry::common::KeyValueStringTokenizer tokenizer{value};
+  opentelemetry::nostd::string_view header_key;
+  opentelemetry::nostd::string_view header_value;
+  bool header_valid = true;
+
+  while (tokenizer.next(header_valid, header_key, header_value))
+  {
+    if (header_valid)
+    {
+      std::string key = static_cast<std::string>(header_key);
+      if (remove_cache.end() == remove_cache.find(key))
+      {
+        remove_cache.insert(key);
+        auto range = output.equal_range(key);
+        if (range.first != range.second)
+        {
+          output.erase(range.first, range.second);
+        }
+      }
+
+      output.emplace(std::make_pair(std::move(key), static_cast<std::string>(header_value)));
+    }
+  }
+}
+
+inline OtlpHeaders GetOtlpDefaultHeaders()
+{
+  constexpr char kOtlpTracesHeadersEnv[] = "OTEL_EXPORTER_OTLP_TRACES_HEADERS";
+  constexpr char kOtlpHeadersEnv[]       = "OTEL_EXPORTER_OTLP_HEADERS";
+
+  OtlpHeaders result;
+  std::unordered_set<std::string> trace_remove_cache;
+  DumpOtlpHeaders(result, kOtlpHeadersEnv, trace_remove_cache);
+
+  trace_remove_cache.clear();
+  DumpOtlpHeaders(result, kOtlpTracesHeadersEnv, trace_remove_cache);
+
+  return result;
+}
+
+inline const std::string GetOtlpDefaultHttpLogEndpoint()
+{
+  constexpr char kOtlpLogsEndpointEnv[] = "OTEL_EXPORTER_OTLP_LOGS_ENDPOINT";
+  constexpr char kOtlpEndpointEnv[]     = "OTEL_EXPORTER_OTLP_ENDPOINT";
+  constexpr char kOtlpEndpointDefault[] = "http://localhost:4318/v1/logs";
+
+  auto endpoint = opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpLogsEndpointEnv);
+  if (endpoint.empty())
+  {
+    endpoint = opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpEndpointEnv);
+    if (!endpoint.empty())
+    {
+      endpoint += "/v1/logs";
+    }
+  }
+  return endpoint.size() ? endpoint : kOtlpEndpointDefault;
+}
+
+inline const std::chrono::system_clock::duration GetOtlpDefaultLogTimeout()
+{
+  constexpr char kOtlpLogsTimeoutEnv[] = "OTEL_EXPORTER_OTLP_LOGS_TIMEOUT";
+  constexpr char kOtlpTimeoutEnv[]     = "OTEL_EXPORTER_OTLP_TIMEOUT";
+
+  auto timeout = opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpLogsTimeoutEnv);
+  if (timeout.empty())
+  {
+    timeout = opentelemetry::sdk::common::GetEnvironmentVariable(kOtlpTimeoutEnv);
+  }
+  return GetOtlpTimeoutFromString(timeout.c_str());
+}
+
+inline OtlpHeaders GetOtlpDefaultLogHeaders()
+{
+  constexpr char kOtlpLogsHeadersEnv[] = "OTEL_EXPORTER_OTLP_LOGS_HEADERS";
+  constexpr char kOtlpHeadersEnv[]     = "OTEL_EXPORTER_OTLP_HEADERS";
+
+  OtlpHeaders result;
+  std::unordered_set<std::string> log_remove_cache;
+  DumpOtlpHeaders(result, kOtlpHeadersEnv, log_remove_cache);
+
+  log_remove_cache.clear();
+  DumpOtlpHeaders(result, kOtlpLogsHeadersEnv, log_remove_cache);
+
+  return result;
+}
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter.h
new file mode 100644
index 000000000..a28e6fca8
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter.h
@@ -0,0 +1,86 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <chrono>
+
+#include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+
+#include "opentelemetry/common/spin_lock_mutex.h"
+#include "opentelemetry/proto/collector/trace/v1/trace_service.grpc.pb.h"
+
+#include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+
+#include "opentelemetry/sdk/trace/exporter.h"
+
+#include "opentelemetry/exporters/otlp/otlp_environment.h"
+#include "opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+/**
+ * The OTLP exporter exports span data in OpenTelemetry Protocol (OTLP) format.
+ */
+class OtlpGrpcExporter final : public opentelemetry::sdk::trace::SpanExporter
+{
+public:
+  /**
+   * Create an OtlpGrpcExporter using all default options.
+   */
+  OtlpGrpcExporter();
+
+  /**
+   * Create an OtlpGrpcExporter using the given options.
+   */
+  explicit OtlpGrpcExporter(const OtlpGrpcExporterOptions &options);
+
+  /**
+   * Create a span recordable.
+   * @return a newly initialized Recordable object
+   */
+  std::unique_ptr<sdk::trace::Recordable> MakeRecordable() noexcept override;
+
+  /**
+   * Export a batch of span recordables in OTLP format.
+   * @param spans a span of unique pointers to span recordables
+   */
+  sdk::common::ExportResult Export(
+      const nostd::span<std::unique_ptr<sdk::trace::Recordable>> &spans) noexcept override;
+
+  /**
+   * Shut down the exporter.
+   * @param timeout an optional timeout, the default timeout of 0 means that no
+   * timeout is applied.
+   * @return return the status of this operation
+   */
+  bool Shutdown(
+      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+
+private:
+  // The configuration options associated with this exporter.
+  const OtlpGrpcExporterOptions options_;
+
+  // For testing
+  friend class OtlpGrpcExporterTestPeer;
+
+  // Store service stub internally. Useful for testing.
+  std::unique_ptr<proto::collector::trace::v1::TraceService::StubInterface> trace_service_stub_;
+
+  /**
+   * Create an OtlpGrpcExporter using the specified service stub.
+   * Only tests can call this constructor directly.
+   * @param stub the service stub to be used for exporting
+   */
+  OtlpGrpcExporter(std::unique_ptr<proto::collector::trace::v1::TraceService::StubInterface> stub);
+  bool is_shutdown_ = false;
+  mutable opentelemetry::common::SpinLockMutex lock_;
+  bool isShutdown() const noexcept;
+};
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h
new file mode 100644
index 000000000..c62a0f0af
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h
@@ -0,0 +1,39 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/exporters/otlp/otlp_environment.h"
+
+#include <memory>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+/**
+ * Struct to hold OTLP exporter options.
+ */
+struct OtlpGrpcExporterOptions
+{
+  // The endpoint to export to. By default the OpenTelemetry Collector's default endpoint.
+  std::string endpoint = GetOtlpDefaultGrpcEndpoint();
+  // By default when false, uses grpc::InsecureChannelCredentials(); If true,
+  // uses ssl_credentials_cacert_path if non-empty, else uses ssl_credentials_cacert_as_string
+  bool use_ssl_credentials = GetOtlpDefaultIsSslEnable();
+  // ssl_credentials_cacert_path specifies path to .pem file to be used for SSL encryption.
+  std::string ssl_credentials_cacert_path = GetOtlpDefaultSslCertificatePath();
+  // ssl_credentials_cacert_as_string in-memory string representation of .pem file to be used for
+  // SSL encryption.
+  std::string ssl_credentials_cacert_as_string = GetOtlpDefaultSslCertificateString();
+  // Timeout for grpc deadline
+  std::chrono::system_clock::duration timeout = GetOtlpDefaultTimeout();
+  // Additional HTTP headers
+  OtlpHeaders metadata = GetOtlpDefaultHeaders();
+};
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_log_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_log_exporter.h
new file mode 100644
index 000000000..a8aeda85b
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_grpc_log_exporter.h
@@ -0,0 +1,90 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifdef ENABLE_LOGS_PREVIEW
+
+// clang-format off
+
+#  include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+#  include "opentelemetry/proto/collector/logs/v1/logs_service.grpc.pb.h"
+#  include "opentelemetry/common/spin_lock_mutex.h"
+#  include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+
+// clang-format on
+
+#  include "opentelemetry/exporters/otlp/otlp_environment.h"
+#  include "opentelemetry/exporters/otlp/otlp_grpc_exporter_options.h"
+#  include "opentelemetry/sdk/logs/exporter.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+/**
+ * The OTLP exporter exports log data in OpenTelemetry Protocol (OTLP) format in gRPC.
+ */
+class OtlpGrpcLogExporter : public opentelemetry::sdk::logs::LogExporter
+{
+public:
+  /**
+   * Create an OtlpGrpcLogExporter with default exporter options.
+   */
+  OtlpGrpcLogExporter();
+
+  /**
+   * Create an OtlpGrpcLogExporter with user specified options.
+   * @param options An object containing the user's configuration options.
+   */
+  OtlpGrpcLogExporter(const OtlpGrpcExporterOptions &options);
+
+  /**
+   * Creates a recordable that stores the data in protobuf.
+   * @return a newly initialized Recordable object.
+   */
+  std::unique_ptr<opentelemetry::sdk::logs::Recordable> MakeRecordable() noexcept override;
+
+  /**
+   * Exports a vector of log records to the configured gRPC endpoint. Guaranteed to return after a
+   * timeout specified from the options passed to the constructor.
+   * @param records A list of log records.
+   */
+  opentelemetry::sdk::common::ExportResult Export(
+      const nostd::span<std::unique_ptr<opentelemetry::sdk::logs::Recordable>> &records) noexcept
+      override;
+
+  /**
+   * Shutdown this exporter.
+   * @param timeout The maximum time to wait for the shutdown method to return.
+   */
+  bool Shutdown(
+      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+
+private:
+  // Configuration options for the exporter
+  const OtlpGrpcExporterOptions options_;
+
+  // For testing
+  friend class OtlpGrpcLogExporterTestPeer;
+
+  // Store service stub internally. Useful for testing.
+  std::unique_ptr<proto::collector::logs::v1::LogsService::StubInterface> log_service_stub_;
+
+  /**
+   * Create an OtlpGrpcLogExporter using the specified service stub.
+   * Only tests can call this constructor directly.
+   * @param stub the service stub to be used for exporting
+   */
+  OtlpGrpcLogExporter(std::unique_ptr<proto::collector::logs::v1::LogsService::StubInterface> stub);
+  bool is_shutdown_ = false;
+  mutable opentelemetry::common::SpinLockMutex lock_;
+  bool isShutdown() const noexcept;
+};
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_http_client.h b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_http_client.h
new file mode 100644
index 000000000..1a199bed4
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_http_client.h
@@ -0,0 +1,144 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+
+#include "google/protobuf/message.h"
+
+#include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+
+#include "opentelemetry/common/spin_lock_mutex.h"
+#include "opentelemetry/ext/http/client/http_client.h"
+#include "opentelemetry/sdk/common/exporter_utils.h"
+
+#include "opentelemetry/exporters/otlp/otlp_environment.h"
+
+#include <chrono>
+#include <memory>
+#include <mutex>
+#include <string>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+// The default URL path to post metric data.
+constexpr char kDefaultMetricsPath[] = "/v1/metrics";
+// The HTTP header "Content-Type"
+constexpr char kHttpJsonContentType[]   = "application/json";
+constexpr char kHttpBinaryContentType[] = "application/x-protobuf";
+
+enum class JsonBytesMappingKind
+{
+  kHexId,
+  kHex,
+  kBase64,
+};
+
+enum class HttpRequestContentType
+{
+  kJson,
+  kBinary,
+};
+
+/**
+ * Struct to hold OTLP HTTP client options.
+ */
+struct OtlpHttpClientOptions
+{
+  std::string url;
+
+  // By default, post json data
+  HttpRequestContentType content_type = HttpRequestContentType::kJson;
+
+  // If convert bytes into hex. By default, we will convert all bytes but id into base64
+  // This option is ignored if content_type is not kJson
+  JsonBytesMappingKind json_bytes_mapping = JsonBytesMappingKind::kHexId;
+
+  // If using the json name of protobuf field to set the key of json. By default, we will use the
+  // field name just like proto files.
+  bool use_json_name = false;
+
+  // Whether to print the status of the HTTP client in the console
+  bool console_debug = false;
+
+  // TODO: Enable/disable to verify SSL certificate
+  std::chrono::system_clock::duration timeout = GetOtlpDefaultTimeout();
+
+  // Additional HTTP headers
+  OtlpHeaders http_headers = GetOtlpDefaultHeaders();
+
+  inline OtlpHttpClientOptions(nostd::string_view input_url,
+                               HttpRequestContentType input_content_type,
+                               JsonBytesMappingKind input_json_bytes_mapping,
+                               bool input_use_json_name,
+                               bool input_console_debug,
+                               std::chrono::system_clock::duration input_timeout,
+                               const OtlpHeaders &input_http_headers)
+      : url(input_url),
+        content_type(input_content_type),
+        json_bytes_mapping(input_json_bytes_mapping),
+        use_json_name(input_use_json_name),
+        console_debug(input_console_debug),
+        timeout(input_timeout),
+        http_headers(input_http_headers)
+  {}
+};
+
+/**
+ * The OTLP HTTP client exports span data in OpenTelemetry Protocol (OTLP) format.
+ */
+class OtlpHttpClient
+{
+public:
+  /**
+   * Create an OtlpHttpClient using the given options.
+   */
+  explicit OtlpHttpClient(OtlpHttpClientOptions &&options);
+
+  /**
+   * Export
+   * @param message message to export, it should be ExportTraceServiceRequest,
+   * ExportMetricsServiceRequest or ExportLogsServiceRequest
+   */
+  sdk::common::ExportResult Export(const google::protobuf::Message &message) noexcept;
+
+  /**
+   * Shut down the HTTP client.
+   * @param timeout an optional timeout, the default timeout of 0 means that no
+   * timeout is applied.
+   * @return return the status of this operation
+   */
+  bool Shutdown(std::chrono::microseconds timeout = std::chrono::microseconds(0)) noexcept;
+
+private:
+  // Stores if this HTTP client had its Shutdown() method called
+  bool is_shutdown_ = false;
+
+  // The configuration options associated with this HTTP client.
+  const OtlpHttpClientOptions options_;
+
+  // Object that stores the HTTP sessions that have been created
+  std::shared_ptr<ext::http::client::HttpClient> http_client_;
+  // Cached parsed URI
+  std::string http_uri_;
+  mutable opentelemetry::common::SpinLockMutex lock_;
+  bool isShutdown() const noexcept;
+  // For testing
+  friend class OtlpHttpExporterTestPeer;
+  friend class OtlpHttpLogExporterTestPeer;
+  /**
+   * Create an OtlpHttpClient using the specified http client.
+   * Only tests can call this constructor directly.
+   * @param options the Otlp http client options to be used for exporting
+   * @param http_client the http client to be used for exporting
+   */
+  OtlpHttpClient(OtlpHttpClientOptions &&options,
+                 std::shared_ptr<ext::http::client::HttpClient> http_client);
+};
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_http_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_http_exporter.h
new file mode 100644
index 000000000..3e6a52119
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_http_exporter.h
@@ -0,0 +1,110 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+// We need include exporter.h first, which will include Windows.h with NOMINMAX on Windows
+#include "opentelemetry/sdk/trace/exporter.h"
+
+#include "opentelemetry/exporters/otlp/otlp_http_client.h"
+
+#include "opentelemetry/exporters/otlp/otlp_environment.h"
+
+#include <chrono>
+#include <memory>
+#include <string>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+/**
+ * Struct to hold OTLP exporter options.
+ */
+struct OtlpHttpExporterOptions
+{
+  // The endpoint to export to. By default
+  // @see
+  // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/otlp.md
+  // @see https://github.com/open-telemetry/opentelemetry-collector/tree/main/receiver/otlpreceiver
+  std::string url = GetOtlpDefaultHttpEndpoint();
+
+  // By default, post json data
+  HttpRequestContentType content_type = HttpRequestContentType::kJson;
+
+  // If convert bytes into hex. By default, we will convert all bytes but id into base64
+  // This option is ignored if content_type is not kJson
+  JsonBytesMappingKind json_bytes_mapping = JsonBytesMappingKind::kHexId;
+
+  // If using the json name of protobuf field to set the key of json. By default, we will use the
+  // field name just like proto files.
+  bool use_json_name = false;
+
+  // Whether to print the status of the exporter in the console
+  bool console_debug = false;
+
+  // TODO: Enable/disable to verify SSL certificate
+  std::chrono::system_clock::duration timeout = GetOtlpDefaultTimeout();
+
+  // Additional HTTP headers
+  OtlpHeaders http_headers = GetOtlpDefaultHeaders();
+};
+
+/**
+ * The OTLP exporter exports span data in OpenTelemetry Protocol (OTLP) format.
+ */
+class OtlpHttpExporter final : public opentelemetry::sdk::trace::SpanExporter
+{
+public:
+  /**
+   * Create an OtlpHttpExporter using all default options.
+   */
+  OtlpHttpExporter();
+
+  /**
+   * Create an OtlpHttpExporter using the given options.
+   */
+  explicit OtlpHttpExporter(const OtlpHttpExporterOptions &options);
+
+  /**
+   * Create a span recordable.
+   * @return a newly initialized Recordable object
+   */
+  std::unique_ptr<opentelemetry::sdk::trace::Recordable> MakeRecordable() noexcept override;
+
+  /**
+   * Export
+   * @param spans a span of unique pointers to span recordables
+   */
+  opentelemetry::sdk::common::ExportResult Export(
+      const nostd::span<std::unique_ptr<opentelemetry::sdk::trace::Recordable>> &spans) noexcept
+      override;
+
+  /**
+   * Shut down the exporter.
+   * @param timeout an optional timeout, the default timeout of 0 means that no
+   * timeout is applied.
+   * @return return the status of this operation
+   */
+  bool Shutdown(std::chrono::microseconds timeout = std::chrono::microseconds(0)) noexcept override;
+
+private:
+  // The configuration options associated with this exporter.
+  const OtlpHttpExporterOptions options_;
+
+  // Object that stores the HTTP sessions that have been created
+  std::unique_ptr<OtlpHttpClient> http_client_;
+  // For testing
+  friend class OtlpHttpExporterTestPeer;
+  /**
+   * Create an OtlpHttpExporter using the specified http client.
+   * Only tests can call this constructor directly.
+   * @param http_client the http client to be used for exporting
+   */
+  OtlpHttpExporter(std::unique_ptr<OtlpHttpClient> http_client);
+};
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_http_log_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_http_log_exporter.h
new file mode 100644
index 000000000..d330e62be
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_http_log_exporter.h
@@ -0,0 +1,110 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifdef ENABLE_LOGS_PREVIEW
+
+#  include "opentelemetry/sdk/logs/exporter.h"
+
+#  include "opentelemetry/exporters/otlp/otlp_http_client.h"
+
+#  include "opentelemetry/exporters/otlp/otlp_environment.h"
+
+#  include <chrono>
+#  include <memory>
+#  include <string>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+/**
+ * Struct to hold OTLP exporter options.
+ */
+struct OtlpHttpLogExporterOptions
+{
+  // The endpoint to export to. By default
+  // @see
+  // https://github.com/open-telemetry/opentelemetry-specification/blob/main/specification/protocol/otlp.md
+  // @see https://github.com/open-telemetry/opentelemetry-collector/tree/main/receiver/otlpreceiver
+  std::string url = GetOtlpDefaultHttpLogEndpoint();
+
+  // By default, post json data
+  HttpRequestContentType content_type = HttpRequestContentType::kJson;
+
+  // If convert bytes into hex. By default, we will convert all bytes but id into base64
+  // This option is ignored if content_type is not kJson
+  JsonBytesMappingKind json_bytes_mapping = JsonBytesMappingKind::kHexId;
+
+  // If using the json name of protobuf field to set the key of json. By default, we will use the
+  // field name just like proto files.
+  bool use_json_name = false;
+
+  // Whether to print the status of the exporter in the console
+  bool console_debug = false;
+
+  // TODO: Enable/disable to verify SSL certificate
+  std::chrono::system_clock::duration timeout = GetOtlpDefaultLogTimeout();
+
+  // Additional HTTP headers
+  OtlpHeaders http_headers = GetOtlpDefaultLogHeaders();
+};
+
+/**
+ * The OTLP exporter exports log data in OpenTelemetry Protocol (OTLP) format.
+ */
+class OtlpHttpLogExporter final : public opentelemetry::sdk::logs::LogExporter
+{
+public:
+  /**
+   * Create an OtlpHttpLogExporter with default exporter options.
+   */
+  OtlpHttpLogExporter();
+
+  /**
+   * Create an OtlpHttpLogExporter with user specified options.
+   * @param options An object containing the user's configuration options.
+   */
+  OtlpHttpLogExporter(const OtlpHttpLogExporterOptions &options);
+
+  /**
+   * Creates a recordable that stores the data in a JSON object
+   */
+  std::unique_ptr<opentelemetry::sdk::logs::Recordable> MakeRecordable() noexcept override;
+
+  /**
+   * Exports a vector of log records to the Elasticsearch instance. Guaranteed to return after a
+   * timeout specified from the options passed from the constructor.
+   * @param records A list of log records to send to Elasticsearch.
+   */
+  opentelemetry::sdk::common::ExportResult Export(
+      const nostd::span<std::unique_ptr<opentelemetry::sdk::logs::Recordable>> &records) noexcept
+      override;
+
+  /**
+   * Shutdown this exporter.
+   * @param timeout The maximum time to wait for the shutdown method to return
+   */
+  bool Shutdown(std::chrono::microseconds timeout = std::chrono::microseconds(0)) noexcept override;
+
+private:
+  // Configuration options for the exporter
+  const OtlpHttpLogExporterOptions options_;
+
+  // Object that stores the HTTP sessions that have been created
+  std::unique_ptr<OtlpHttpClient> http_client_;
+  // For testing
+  friend class OtlpHttpLogExporterTestPeer;
+  /**
+   * Create an OtlpHttpLogExporter using the specified http client.
+   * Only tests can call this constructor directly.
+   * @param http_client the http client to be used for exporting
+   */
+  OtlpHttpLogExporter(std::unique_ptr<OtlpHttpClient> http_client);
+};
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_log_recordable.h b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_log_recordable.h
new file mode 100644
index 000000000..57ae94ea0
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_log_recordable.h
@@ -0,0 +1,118 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifdef ENABLE_LOGS_PREVIEW
+
+// clang-format off
+#  include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+
+#  include "opentelemetry/proto/logs/v1/logs.pb.h"
+#  include "opentelemetry/proto/resource/v1/resource.pb.h"
+#  include "opentelemetry/sdk/instrumentationlibrary/instrumentation_library.h"
+
+#  include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+// clang-format on
+
+#  include "opentelemetry/sdk/common/attribute_utils.h"
+#  include "opentelemetry/sdk/logs/recordable.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+/**
+ * An OTLP Recordable implemenation for Logs.
+ */
+class OtlpLogRecordable final : public opentelemetry::sdk::logs::Recordable
+{
+public:
+  virtual ~OtlpLogRecordable() = default;
+
+  proto::logs::v1::LogRecord &log_record() noexcept { return log_record_; }
+  const proto::logs::v1::LogRecord &log_record() const noexcept { return log_record_; }
+
+  /** Dynamically converts the resource of this log into a proto. */
+  proto::resource::v1::Resource ProtoResource() const noexcept;
+
+  /**
+   * Set the timestamp for this log.
+   * @param timestamp the timestamp to set
+   */
+  void SetTimestamp(opentelemetry::common::SystemTimestamp timestamp) noexcept override;
+
+  /**
+   * Set the severity for this log.
+   * @param severity the severity of the event
+   */
+  void SetSeverity(opentelemetry::logs::Severity severity) noexcept override;
+
+  /**
+   * Set body field for this log.
+   * @param message the body to set
+   */
+  void SetBody(nostd::string_view message) noexcept override;
+
+  /**
+   * Set Resource of this log
+   * @param Resource the resource to set
+   */
+  void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept override;
+
+  /** Returns the associated resource */
+  const opentelemetry::sdk::resource::Resource &GetResource() const noexcept;
+
+  /**
+   * Set an attribute of a log.
+   * @param key the name of the attribute
+   * @param value the attribute value
+   */
+  void SetAttribute(nostd::string_view key,
+                    const opentelemetry::common::AttributeValue &value) noexcept override;
+
+  /**
+   * Set the trace id for this log.
+   * @param trace_id the trace id to set
+   */
+  void SetTraceId(opentelemetry::trace::TraceId trace_id) noexcept override;
+
+  /**
+   * Set the span id for this log.
+   * @param span_id the span id to set
+   */
+  void SetSpanId(opentelemetry::trace::SpanId span_id) noexcept override;
+
+  /**
+   * Inject trace_flags for this log.
+   * @param trace_flags the trace flags to set
+   */
+  void SetTraceFlags(opentelemetry::trace::TraceFlags trace_flags) noexcept override;
+
+  /**
+   * Set instrumentation_library for this log.
+   * @param instrumentation_library the instrumentation library to set
+   */
+  void SetInstrumentationLibrary(
+      const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary
+          &instrumentation_library) noexcept override;
+
+  /** Returns the associated instruementation library */
+  const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary &
+  GetInstrumentationLibrary() const noexcept;
+
+private:
+  proto::logs::v1::LogRecord log_record_;
+  const opentelemetry::sdk::resource::Resource *resource_ = nullptr;
+  // TODO shared resource
+  // const opentelemetry::sdk::resource::Resource *resource_ = nullptr;
+  const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary
+      *instrumentation_library_ = nullptr;
+};
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_recordable.h b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_recordable.h
new file mode 100644
index 000000000..a29d063a9
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_recordable.h
@@ -0,0 +1,72 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+
+#include "opentelemetry/proto/resource/v1/resource.pb.h"
+#include "opentelemetry/proto/trace/v1/trace.pb.h"
+
+#include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+
+#include "opentelemetry/sdk/trace/recordable.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+class OtlpRecordable final : public opentelemetry::sdk::trace::Recordable
+{
+public:
+  proto::trace::v1::Span &span() noexcept { return span_; }
+  const proto::trace::v1::Span &span() const noexcept { return span_; }
+
+  /** Dynamically converts the resource of this span into a proto. */
+  proto::resource::v1::Resource ProtoResource() const noexcept;
+
+  const std::string GetResourceSchemaURL() const noexcept;
+  const std::string GetInstrumentationLibrarySchemaURL() const noexcept;
+
+  proto::common::v1::InstrumentationLibrary GetProtoInstrumentationLibrary() const noexcept;
+
+  void SetIdentity(const opentelemetry::trace::SpanContext &span_context,
+                   opentelemetry::trace::SpanId parent_span_id) noexcept override;
+
+  void SetAttribute(nostd::string_view key,
+                    const opentelemetry::common::AttributeValue &value) noexcept override;
+
+  void AddEvent(nostd::string_view name,
+                common::SystemTimestamp timestamp,
+                const common::KeyValueIterable &attributes) noexcept override;
+
+  void AddLink(const opentelemetry::trace::SpanContext &span_context,
+               const common::KeyValueIterable &attributes) noexcept override;
+
+  void SetStatus(trace::StatusCode code, nostd::string_view description) noexcept override;
+
+  void SetName(nostd::string_view name) noexcept override;
+
+  void SetSpanKind(opentelemetry::trace::SpanKind span_kind) noexcept override;
+
+  void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept override;
+
+  void SetStartTime(opentelemetry::common::SystemTimestamp start_time) noexcept override;
+
+  void SetDuration(std::chrono::nanoseconds duration) noexcept override;
+
+  void SetInstrumentationLibrary(
+      const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary
+          &instrumentation_library) noexcept override;
+
+private:
+  proto::trace::v1::Span span_;
+  const opentelemetry::sdk::resource::Resource *resource_ = nullptr;
+  const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary
+      *instrumentation_library_ = nullptr;
+};
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_recordable_utils.h b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_recordable_utils.h
new file mode 100644
index 000000000..0c09bc871
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/otlp_recordable_utils.h
@@ -0,0 +1,63 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+
+#include "opentelemetry/proto/collector/logs/v1/logs_service.pb.h"
+#include "opentelemetry/proto/collector/trace/v1/trace_service.pb.h"
+#include "opentelemetry/proto/resource/v1/resource.pb.h"
+
+#include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+
+#include "opentelemetry/common/attribute_value.h"
+#include "opentelemetry/nostd/string_view.h"
+#include "opentelemetry/version.h"
+
+#include "opentelemetry/sdk/common/attribute_utils.h"
+#include "opentelemetry/sdk/resource/resource.h"
+#include "opentelemetry/sdk/trace/recordable.h"
+
+#ifdef ENABLE_LOGS_PREVIEW
+#  include "opentelemetry/sdk/logs/recordable.h"
+#endif
+
+#include <memory>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+/**
+ * The OtlpRecordableUtils contains utility functions for OTLP recordable
+ */
+class OtlpRecordableUtils
+{
+public:
+  static void PopulateAttribute(opentelemetry::proto::common::v1::KeyValue *attribute,
+                                nostd::string_view key,
+                                const opentelemetry::common::AttributeValue &value) noexcept;
+
+  static void PopulateAttribute(
+      opentelemetry::proto::common::v1::KeyValue *attribute,
+      nostd::string_view key,
+      const opentelemetry::sdk::common::OwnedAttributeValue &value) noexcept;
+
+  static void PopulateAttribute(opentelemetry::proto::resource::v1::Resource *proto,
+                                const opentelemetry::sdk::resource::Resource &resource) noexcept;
+
+  static void PopulateRequest(
+      const nostd::span<std::unique_ptr<opentelemetry::sdk::trace::Recordable>> &spans,
+      proto::collector::trace::v1::ExportTraceServiceRequest *request) noexcept;
+
+#ifdef ENABLE_LOGS_PREVIEW
+  static void PopulateRequest(
+      const nostd::span<std::unique_ptr<opentelemetry::sdk::logs::Recordable>> &logs,
+      proto::collector::logs::v1::ExportLogsServiceRequest *request) noexcept;
+#endif
+};
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/protobuf_include_prefix.h b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/protobuf_include_prefix.h
new file mode 100644
index 000000000..ae103b017
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/protobuf_include_prefix.h
@@ -0,0 +1,37 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// This file may be include multiple times, do not add #pragma once here
+
+#if defined(_MSC_VER)
+#  pragma warning(push)
+#  if ((defined(__cplusplus) && __cplusplus >= 201704L) || \
+       (defined(_MSVC_LANG) && _MSVC_LANG >= 201704L))
+#    pragma warning(disable : 4996)
+#    pragma warning(disable : 4309)
+#    if _MSC_VER >= 1922
+#      pragma warning(disable : 5054)
+#    endif
+#  endif
+
+#  if _MSC_VER < 1910
+#    pragma warning(disable : 4800)
+#  endif
+#  pragma warning(disable : 4244)
+#  pragma warning(disable : 4251)
+#  pragma warning(disable : 4267)
+#  pragma warning(disable : 4668)
+#  pragma warning(disable : 4946)
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__apple_build_version__)
+#  if (__GNUC__ * 100 + __GNUC_MINOR__ * 10) >= 460
+#    pragma GCC diagnostic push
+#  endif
+#  pragma GCC diagnostic ignored "-Wunused-parameter"
+#  pragma GCC diagnostic ignored "-Wtype-limits"
+#elif defined(__clang__) || defined(__apple_build_version__)
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wunused-parameter"
+#  pragma clang diagnostic ignored "-Wtype-limits"
+#endif
\ No newline at end of file
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/protobuf_include_suffix.h b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/protobuf_include_suffix.h
new file mode 100644
index 000000000..26e7a2913
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/include/opentelemetry/exporters/otlp/protobuf_include_suffix.h
@@ -0,0 +1,16 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+// This file may be include multiple times, do not add #pragma once here
+
+#if defined(__GNUC__) && !defined(__clang__) && !defined(__apple_build_version__)
+#  if (__GNUC__ * 100 + __GNUC_MINOR__ * 10) >= 460
+#    pragma GCC diagnostic pop
+#  endif
+#elif defined(__clang__) || defined(__apple_build_version__)
+#  pragma clang diagnostic pop
+#endif
+
+#if defined(_MSC_VER)
+#  pragma warning(pop)
+#endif
\ No newline at end of file
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_grpc_exporter.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_grpc_exporter.cc
new file mode 100644
index 000000000..32f4a60a5
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_grpc_exporter.cc
@@ -0,0 +1,161 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/exporters/otlp/otlp_grpc_exporter.h"
+#include <mutex>
+#include "opentelemetry/exporters/otlp/otlp_recordable.h"
+#include "opentelemetry/exporters/otlp/otlp_recordable_utils.h"
+#include "opentelemetry/ext/http/common/url_parser.h"
+#include "opentelemetry/sdk_config.h"
+
+#include <grpcpp/grpcpp.h>
+#include <fstream>
+#include <sstream>  // std::stringstream
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+// ----------------------------- Helper functions ------------------------------
+static std::string get_file_contents(const char *fpath)
+{
+  std::ifstream finstream(fpath);
+  std::string contents;
+  contents.assign((std::istreambuf_iterator<char>(finstream)), std::istreambuf_iterator<char>());
+  finstream.close();
+  return contents;
+}
+
+/**
+ * Create gRPC channel from the exporter options.
+ */
+std::shared_ptr<grpc::Channel> MakeGrpcChannel(const OtlpGrpcExporterOptions &options)
+{
+  std::shared_ptr<grpc::Channel> channel;
+
+  //
+  // Scheme is allowed in OTLP endpoint definition, but is not allowed for creating gRPC channel.
+  // Passing URI with scheme to grpc::CreateChannel could resolve the endpoint to some unexpected
+  // address.
+  //
+
+  ext::http::common::UrlParser url(options.endpoint);
+  if (!url.success_)
+  {
+    OTEL_INTERNAL_LOG_ERROR("[OTLP Exporter] invalid endpoint: " << options.endpoint);
+
+    return nullptr;
+  }
+
+  std::string grpc_target = url.host_ + ":" + std::to_string(static_cast<int>(url.port_));
+
+  if (options.use_ssl_credentials)
+  {
+    grpc::SslCredentialsOptions ssl_opts;
+    if (options.ssl_credentials_cacert_path.empty())
+    {
+      ssl_opts.pem_root_certs = options.ssl_credentials_cacert_as_string;
+    }
+    else
+    {
+      ssl_opts.pem_root_certs = get_file_contents((options.ssl_credentials_cacert_path).c_str());
+    }
+    channel = grpc::CreateChannel(grpc_target, grpc::SslCredentials(ssl_opts));
+  }
+  else
+  {
+    channel = grpc::CreateChannel(grpc_target, grpc::InsecureChannelCredentials());
+  }
+
+  return channel;
+}
+
+/**
+ * Create service stub to communicate with the OpenTelemetry Collector.
+ */
+std::unique_ptr<proto::collector::trace::v1::TraceService::Stub> MakeTraceServiceStub(
+    const OtlpGrpcExporterOptions &options)
+{
+  return proto::collector::trace::v1::TraceService::NewStub(MakeGrpcChannel(options));
+}
+
+// -------------------------------- Constructors --------------------------------
+
+OtlpGrpcExporter::OtlpGrpcExporter() : OtlpGrpcExporter(OtlpGrpcExporterOptions()) {}
+
+OtlpGrpcExporter::OtlpGrpcExporter(const OtlpGrpcExporterOptions &options)
+    : options_(options), trace_service_stub_(MakeTraceServiceStub(options))
+{}
+
+OtlpGrpcExporter::OtlpGrpcExporter(
+    std::unique_ptr<proto::collector::trace::v1::TraceService::StubInterface> stub)
+    : options_(OtlpGrpcExporterOptions()), trace_service_stub_(std::move(stub))
+{}
+
+// ----------------------------- Exporter methods ------------------------------
+
+std::unique_ptr<sdk::trace::Recordable> OtlpGrpcExporter::MakeRecordable() noexcept
+{
+  return std::unique_ptr<sdk::trace::Recordable>(new OtlpRecordable);
+}
+
+sdk::common::ExportResult OtlpGrpcExporter::Export(
+    const nostd::span<std::unique_ptr<sdk::trace::Recordable>> &spans) noexcept
+{
+  if (isShutdown())
+  {
+    OTEL_INTERNAL_LOG_ERROR("[OTLP gRPC] Exporting " << spans.size()
+                                                     << " span(s) failed, exporter is shutdown");
+    return sdk::common::ExportResult::kFailure;
+  }
+  if (spans.empty())
+  {
+    return sdk::common::ExportResult::kSuccess;
+  }
+
+  proto::collector::trace::v1::ExportTraceServiceRequest request;
+  OtlpRecordableUtils::PopulateRequest(spans, &request);
+
+  grpc::ClientContext context;
+  proto::collector::trace::v1::ExportTraceServiceResponse response;
+
+  if (options_.timeout.count() > 0)
+  {
+    context.set_deadline(std::chrono::system_clock::now() + options_.timeout);
+  }
+
+  for (auto &header : options_.metadata)
+  {
+    context.AddMetadata(header.first, header.second);
+  }
+
+  grpc::Status status = trace_service_stub_->Export(&context, request, &response);
+
+  if (!status.ok())
+  {
+
+    OTEL_INTERNAL_LOG_ERROR(
+        "[OTLP TRACE GRPC Exporter] Export() failed: " << status.error_message());
+    return sdk::common::ExportResult::kFailure;
+  }
+  return sdk::common::ExportResult::kSuccess;
+}
+
+bool OtlpGrpcExporter::Shutdown(std::chrono::microseconds timeout) noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  is_shutdown_ = true;
+  return true;
+}
+
+bool OtlpGrpcExporter::isShutdown() const noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  return is_shutdown_;
+}
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_grpc_log_exporter.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_grpc_log_exporter.cc
new file mode 100644
index 000000000..38bfb0a5b
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_grpc_log_exporter.cc
@@ -0,0 +1,181 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_LOGS_PREVIEW
+
+#  include "opentelemetry/exporters/otlp/otlp_grpc_log_exporter.h"
+#  include "opentelemetry/exporters/otlp/otlp_log_recordable.h"
+#  include "opentelemetry/exporters/otlp/otlp_recordable_utils.h"
+
+// clang-format off
+
+#  include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+
+#  include "opentelemetry/proto/collector/logs/v1/logs_service.pb.h"
+#  include "opentelemetry/proto/collector/logs/v1/logs_service.grpc.pb.h"
+
+#  include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+
+// clang-format on
+
+#  include "opentelemetry/ext/http/common/url_parser.h"
+#  include "opentelemetry/sdk/common/global_log_handler.h"
+
+#  include <chrono>
+#  include <fstream>
+#  include <memory>
+
+#  include <grpcpp/grpcpp.h>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+// ----------------------------- Helper functions ------------------------------
+// TODO: move exporters shared function to OTLP common library.
+static std::string get_file_contents(const char *fpath)
+{
+  std::ifstream finstream(fpath);
+  std::string contents;
+  contents.assign((std::istreambuf_iterator<char>(finstream)), std::istreambuf_iterator<char>());
+  finstream.close();
+  return contents;
+}
+
+struct OtlpGrpcExporterOptions;
+
+/**
+ * Create gRPC channel from the exporter options.
+ */
+static std::shared_ptr<grpc::Channel> MakeGrpcChannel(const OtlpGrpcExporterOptions &options)
+{
+  std::shared_ptr<grpc::Channel> channel;
+
+  //
+  // Scheme is allowed in OTLP endpoint definition, but is not allowed for creating gRPC channel.
+  // Passing URI with scheme to grpc::CreateChannel could resolve the endpoint to some unexpected
+  // address.
+  //
+
+  ext::http::common::UrlParser url(options.endpoint);
+  if (!url.success_)
+  {
+    OTEL_INTERNAL_LOG_ERROR("[OTLP Exporter] invalid endpoint: " << options.endpoint);
+
+    return nullptr;
+  }
+
+  std::string grpc_target = url.host_ + ":" + std::to_string(static_cast<int>(url.port_));
+
+  if (options.use_ssl_credentials)
+  {
+    grpc::SslCredentialsOptions ssl_opts;
+    if (options.ssl_credentials_cacert_path.empty())
+    {
+      ssl_opts.pem_root_certs = options.ssl_credentials_cacert_as_string;
+    }
+    else
+    {
+      ssl_opts.pem_root_certs = get_file_contents((options.ssl_credentials_cacert_path).c_str());
+    }
+    channel = grpc::CreateChannel(grpc_target, grpc::SslCredentials(ssl_opts));
+  }
+  else
+  {
+    channel = grpc::CreateChannel(grpc_target, grpc::InsecureChannelCredentials());
+  }
+
+  return channel;
+}
+
+// ----------------------------- Helper functions ------------------------------
+
+/**
+ * Create log service stub to communicate with the OpenTelemetry Collector.
+ */
+std::unique_ptr<::opentelemetry::proto::collector::logs::v1::LogsService::Stub> MakeLogServiceStub(
+    const OtlpGrpcExporterOptions &options)
+{
+  return proto::collector::logs::v1::LogsService::NewStub(MakeGrpcChannel(options));
+}
+
+// -------------------------------- Constructors --------------------------------
+
+OtlpGrpcLogExporter::OtlpGrpcLogExporter() : OtlpGrpcLogExporter(OtlpGrpcExporterOptions()) {}
+
+OtlpGrpcLogExporter::OtlpGrpcLogExporter(const OtlpGrpcExporterOptions &options)
+    : options_(options), log_service_stub_(MakeLogServiceStub(options))
+{}
+
+OtlpGrpcLogExporter::OtlpGrpcLogExporter(
+    std::unique_ptr<proto::collector::logs::v1::LogsService::StubInterface> stub)
+    : options_(OtlpGrpcExporterOptions()), log_service_stub_(std::move(stub))
+{}
+
+// ----------------------------- Exporter methods ------------------------------
+
+std::unique_ptr<opentelemetry::sdk::logs::Recordable> OtlpGrpcLogExporter::MakeRecordable() noexcept
+{
+  return std::unique_ptr<opentelemetry::sdk::logs::Recordable>(
+      new exporter::otlp::OtlpLogRecordable());
+}
+
+opentelemetry::sdk::common::ExportResult OtlpGrpcLogExporter::Export(
+    const nostd::span<std::unique_ptr<opentelemetry::sdk::logs::Recordable>> &logs) noexcept
+{
+  if (isShutdown())
+  {
+    OTEL_INTERNAL_LOG_ERROR("[OTLP gRPC log] Exporting " << logs.size()
+                                                         << " log(s) failed, exporter is shutdown");
+    return sdk::common::ExportResult::kFailure;
+  }
+  if (logs.empty())
+  {
+    return sdk::common::ExportResult::kSuccess;
+  }
+
+  proto::collector::logs::v1::ExportLogsServiceRequest request;
+  OtlpRecordableUtils::PopulateRequest(logs, &request);
+
+  grpc::ClientContext context;
+  proto::collector::logs::v1::ExportLogsServiceResponse response;
+
+  if (options_.timeout.count() > 0)
+  {
+    context.set_deadline(std::chrono::system_clock::now() + options_.timeout);
+  }
+
+  for (auto &header : options_.metadata)
+  {
+    context.AddMetadata(header.first, header.second);
+  }
+  grpc::Status status = log_service_stub_->Export(&context, request, &response);
+
+  if (!status.ok())
+  {
+    OTEL_INTERNAL_LOG_ERROR("[OTLP LOG GRPC Exporter] Export() failed: " << status.error_message());
+    return sdk::common::ExportResult::kFailure;
+  }
+  return sdk::common::ExportResult::kSuccess;
+}
+
+bool OtlpGrpcLogExporter::Shutdown(std::chrono::microseconds timeout) noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  is_shutdown_ = true;
+  return true;
+}
+
+bool OtlpGrpcLogExporter::isShutdown() const noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  return is_shutdown_;
+}
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_http_client.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_http_client.cc
new file mode 100644
index 000000000..e3e1a8c46
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_http_client.cc
@@ -0,0 +1,721 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/exporters/otlp/otlp_http_client.h"
+
+#if defined(HAVE_GSL)
+#  include <gsl/gsl>
+#else
+#  include <assert.h>
+#endif
+
+#include "opentelemetry/ext/http/client/http_client_factory.h"
+#include "opentelemetry/ext/http/common/url_parser.h"
+
+#include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+
+#include <mutex>
+#include "google/protobuf/message.h"
+#include "google/protobuf/reflection.h"
+#include "google/protobuf/stubs/common.h"
+#include "google/protobuf/stubs/stringpiece.h"
+#include "nlohmann/json.hpp"
+
+#if defined(GOOGLE_PROTOBUF_VERSION) && GOOGLE_PROTOBUF_VERSION >= 3007000
+#  include "google/protobuf/stubs/strutil.h"
+#else
+#  include "google/protobuf/stubs/port.h"
+namespace google
+{
+namespace protobuf
+{
+LIBPROTOBUF_EXPORT void Base64Escape(StringPiece src, std::string *dest);
+}  // namespace protobuf
+}  // namespace google
+#endif
+
+#include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+
+#include "opentelemetry/sdk/common/global_log_handler.h"
+#include "opentelemetry/sdk_config.h"
+
+#include <condition_variable>
+#include <fstream>
+#include <mutex>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#ifdef GetMessage
+#  undef GetMessage
+#endif
+
+namespace nostd       = opentelemetry::nostd;
+namespace http_client = opentelemetry::ext::http::client;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+namespace
+{
+
+/**
+ * This class handles the response message from the Elasticsearch request
+ */
+class ResponseHandler : public http_client::EventHandler
+{
+public:
+  /**
+   * Creates a response handler, that by default doesn't display to console
+   */
+  ResponseHandler(bool console_debug = false) : console_debug_{console_debug} {}
+
+  /**
+   * Automatically called when the response is received, store the body into a string and notify any
+   * threads blocked on this result
+   */
+  void OnResponse(http_client::Response &response) noexcept override
+  {
+    // Lock the private members so they can't be read while being modified
+    {
+      std::unique_lock<std::mutex> lk(mutex_);
+
+      // Store the body of the request
+      body_ = std::string(response.GetBody().begin(), response.GetBody().end());
+
+      if (console_debug_)
+      {
+        std::stringstream ss;
+        ss << "[OTLP HTTP Client] Status:" << response.GetStatusCode() << "Header:";
+        response.ForEachHeader([&ss](opentelemetry::nostd::string_view header_name,
+                                     opentelemetry::nostd::string_view header_value) {
+          ss << "\t" << header_name.data() << " : " << header_value.data() << ",";
+          return true;
+        });
+        ss << "Body:" << body_;
+        OTEL_INTERNAL_LOG_DEBUG(ss.str());
+      }
+
+      // Set the response_received_ flag to true and notify any threads waiting on this result
+      response_received_ = true;
+      stop_waiting_      = true;
+    }
+    cv_.notify_all();
+  }
+
+  /**resource
+   * A method the user calls to block their thread until the response is received. The longest
+   * duration is the timeout of the request, set by SetTimeoutMs()
+   */
+  bool waitForResponse()
+  {
+    std::unique_lock<std::mutex> lk(mutex_);
+    cv_.wait(lk, [this] { return stop_waiting_; });
+    return response_received_;
+  }
+
+  /**
+   * Returns the body of the response
+   */
+  std::string GetResponseBody()
+  {
+    // Lock so that body_ can't be written to while returning it
+    std::unique_lock<std::mutex> lk(mutex_);
+    return body_;
+  }
+
+  // Callback method when an http event occurs
+  void OnEvent(http_client::SessionState state,
+               opentelemetry::nostd::string_view reason) noexcept override
+  {
+    // need to modify stop_waiting_ under lock before calling notify_all
+    switch (state)
+    {
+      case http_client::SessionState::CreateFailed:
+      case http_client::SessionState::ConnectFailed:
+      case http_client::SessionState::SendFailed:
+      case http_client::SessionState::SSLHandshakeFailed:
+      case http_client::SessionState::TimedOut:
+      case http_client::SessionState::NetworkError:
+      case http_client::SessionState::Cancelled: {
+        std::unique_lock<std::mutex> lk(mutex_);
+        stop_waiting_ = true;
+      }
+      break;
+
+      default:
+        break;
+    }
+
+    // If any failure event occurs, release the condition variable to unblock main thread
+    switch (state)
+    {
+      case http_client::SessionState::CreateFailed:
+        OTEL_INTERNAL_LOG_ERROR("[OTLP HTTP Client] Session state: session create failed");
+        cv_.notify_all();
+        break;
+
+      case http_client::SessionState::Created:
+        if (console_debug_)
+        {
+          OTEL_INTERNAL_LOG_DEBUG("[OTLP HTTP Client] Session state: session created");
+        }
+        break;
+
+      case http_client::SessionState::Destroyed:
+        if (console_debug_)
+        {
+          OTEL_INTERNAL_LOG_DEBUG("[OTLP HTTP Client] Session state: session destroyed");
+        }
+        break;
+
+      case http_client::SessionState::Connecting:
+        if (console_debug_)
+        {
+          OTEL_INTERNAL_LOG_DEBUG("[OTLP HTTP Client] Session state: connecting to peer");
+        }
+        break;
+
+      case http_client::SessionState::ConnectFailed:
+        OTEL_INTERNAL_LOG_ERROR("[OTLP HTTP Client] Session state: connection failed");
+        cv_.notify_all();
+        break;
+
+      case http_client::SessionState::Connected:
+        if (console_debug_)
+        {
+          OTEL_INTERNAL_LOG_DEBUG("[OTLP HTTP Client] Session state: connected");
+        }
+        break;
+
+      case http_client::SessionState::Sending:
+        if (console_debug_)
+        {
+          OTEL_INTERNAL_LOG_DEBUG("[OTLP HTTP Client] Session state: sending request");
+        }
+        break;
+
+      case http_client::SessionState::SendFailed:
+        OTEL_INTERNAL_LOG_ERROR("[OTLP HTTP Client] Session state: request send failed");
+        cv_.notify_all();
+        break;
+
+      case http_client::SessionState::Response:
+        if (console_debug_)
+        {
+          OTEL_INTERNAL_LOG_DEBUG("[OTLP HTTP Client] Session state: response received");
+        }
+        break;
+
+      case http_client::SessionState::SSLHandshakeFailed:
+        OTEL_INTERNAL_LOG_ERROR("[OTLP HTTP Client] Session state: SSL handshake failed");
+        cv_.notify_all();
+        break;
+
+      case http_client::SessionState::TimedOut:
+        OTEL_INTERNAL_LOG_ERROR("[OTLP HTTP Client] Session state: request time out");
+        cv_.notify_all();
+        break;
+
+      case http_client::SessionState::NetworkError:
+        OTEL_INTERNAL_LOG_ERROR("[OTLP HTTP Client] Session state: network error");
+        cv_.notify_all();
+        break;
+
+      case http_client::SessionState::ReadError:
+        if (console_debug_)
+        {
+          OTEL_INTERNAL_LOG_DEBUG("[OTLP HTTP Client] Session state: error reading response");
+        }
+        break;
+
+      case http_client::SessionState::WriteError:
+        if (console_debug_)
+        {
+          OTEL_INTERNAL_LOG_DEBUG("[OTLP HTTP Client] DEBUG:Session state: error writing request");
+        }
+        break;
+
+      case http_client::SessionState::Cancelled:
+        OTEL_INTERNAL_LOG_ERROR("[OTLP HTTP Client] Session state: (manually) cancelled\n");
+        cv_.notify_all();
+        break;
+
+      default:
+        break;
+    }
+  }
+
+private:
+  // Define a condition variable and mutex
+  std::condition_variable cv_;
+  std::mutex mutex_;
+
+  // Whether notify has been called
+  bool stop_waiting_ = false;
+
+  // Whether the response has been received
+  bool response_received_ = false;
+
+  // A string to store the response body
+  std::string body_ = "";
+
+  // Whether to print the results from the callback
+  bool console_debug_ = false;
+};
+
+static inline char HexEncode(unsigned char byte)
+{
+#if defined(HAVE_GSL)
+  Expects(byte <= 16);
+#else
+  assert(byte <= 16);
+#endif
+  if (byte >= 10)
+  {
+    return byte - 10 + 'a';
+  }
+  else
+  {
+    return byte + '0';
+  }
+}
+
+static std::string HexEncode(const std::string &bytes)
+{
+  std::string ret;
+  ret.reserve(bytes.size() * 2);
+  for (std::string::size_type i = 0; i < bytes.size(); ++i)
+  {
+    unsigned char byte = static_cast<unsigned char>(bytes[i]);
+    ret.push_back(HexEncode(byte >> 4));
+    ret.push_back(HexEncode(byte & 0x0f));
+  }
+  return ret;
+}
+
+static std::string BytesMapping(const std::string &bytes,
+                                const google::protobuf::FieldDescriptor *field_descriptor,
+                                JsonBytesMappingKind kind)
+{
+  switch (kind)
+  {
+    case JsonBytesMappingKind::kHexId: {
+      if (field_descriptor->lowercase_name() == "trace_id" ||
+          field_descriptor->lowercase_name() == "span_id" ||
+          field_descriptor->lowercase_name() == "parent_span_id")
+      {
+        return HexEncode(bytes);
+      }
+      else
+      {
+        std::string base64_value;
+        google::protobuf::Base64Escape(bytes, &base64_value);
+        return base64_value;
+      }
+    }
+    case JsonBytesMappingKind::kBase64: {
+      // Base64 is the default bytes mapping of protobuf
+      std::string base64_value;
+      google::protobuf::Base64Escape(bytes, &base64_value);
+      return base64_value;
+    }
+    case JsonBytesMappingKind::kHex:
+      return HexEncode(bytes);
+    default:
+      return bytes;
+  }
+}
+
+static void ConvertGenericFieldToJson(nlohmann::json &value,
+                                      const google::protobuf::Message &message,
+                                      const google::protobuf::FieldDescriptor *field_descriptor,
+                                      const OtlpHttpClientOptions &options);
+
+static void ConvertListFieldToJson(nlohmann::json &value,
+                                   const google::protobuf::Message &message,
+                                   const google::protobuf::FieldDescriptor *field_descriptor,
+                                   const OtlpHttpClientOptions &options);
+
+static void ConvertGenericMessageToJson(nlohmann::json &value,
+                                        const google::protobuf::Message &message,
+                                        const OtlpHttpClientOptions &options)
+{
+  std::vector<const google::protobuf::FieldDescriptor *> fields_with_data;
+  message.GetReflection()->ListFields(message, &fields_with_data);
+  for (std::size_t i = 0; i < fields_with_data.size(); ++i)
+  {
+    const google::protobuf::FieldDescriptor *field_descriptor = fields_with_data[i];
+    nlohmann::json &child_value = options.use_json_name ? value[field_descriptor->json_name()]
+                                                        : value[field_descriptor->name()];
+    if (field_descriptor->is_repeated())
+    {
+      ConvertListFieldToJson(child_value, message, field_descriptor, options);
+    }
+    else
+    {
+      ConvertGenericFieldToJson(child_value, message, field_descriptor, options);
+    }
+  }
+}
+
+bool SerializeToHttpBody(http_client::Body &output, const google::protobuf::Message &message)
+{
+  auto body_size = message.ByteSizeLong();
+  if (body_size > 0)
+  {
+    output.resize(body_size);
+    return message.SerializeWithCachedSizesToArray(
+        reinterpret_cast<google::protobuf::uint8 *>(&output[0]));
+  }
+  return true;
+}
+
+void ConvertGenericFieldToJson(nlohmann::json &value,
+                               const google::protobuf::Message &message,
+                               const google::protobuf::FieldDescriptor *field_descriptor,
+                               const OtlpHttpClientOptions &options)
+{
+  switch (field_descriptor->cpp_type())
+  {
+    case google::protobuf::FieldDescriptor::CPPTYPE_INT32: {
+      value = message.GetReflection()->GetInt32(message, field_descriptor);
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_INT64: {
+      // According to Protobuf specs 64-bit integer numbers in JSON-encoded payloads are encoded as
+      // decimal strings, and either numbers or strings are accepted when decoding.
+      value = std::to_string(message.GetReflection()->GetInt64(message, field_descriptor));
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_UINT32: {
+      value = message.GetReflection()->GetUInt32(message, field_descriptor);
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_UINT64: {
+      // According to Protobuf specs 64-bit integer numbers in JSON-encoded payloads are encoded as
+      // decimal strings, and either numbers or strings are accepted when decoding.
+      value = std::to_string(message.GetReflection()->GetUInt64(message, field_descriptor));
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_STRING: {
+      std::string empty;
+      if (field_descriptor->type() == google::protobuf::FieldDescriptor::TYPE_BYTES)
+      {
+        value = BytesMapping(
+            message.GetReflection()->GetStringReference(message, field_descriptor, &empty),
+            field_descriptor, options.json_bytes_mapping);
+      }
+      else
+      {
+        value = message.GetReflection()->GetStringReference(message, field_descriptor, &empty);
+      }
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE: {
+      ConvertGenericMessageToJson(
+          value, message.GetReflection()->GetMessage(message, field_descriptor, nullptr), options);
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE: {
+      value = message.GetReflection()->GetDouble(message, field_descriptor);
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT: {
+      value = message.GetReflection()->GetFloat(message, field_descriptor);
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_BOOL: {
+      value = message.GetReflection()->GetBool(message, field_descriptor);
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_ENUM: {
+      value = message.GetReflection()->GetEnumValue(message, field_descriptor);
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+}
+
+void ConvertListFieldToJson(nlohmann::json &value,
+                            const google::protobuf::Message &message,
+                            const google::protobuf::FieldDescriptor *field_descriptor,
+                            const OtlpHttpClientOptions &options)
+{
+  auto field_size = message.GetReflection()->FieldSize(message, field_descriptor);
+
+  switch (field_descriptor->cpp_type())
+  {
+    case google::protobuf::FieldDescriptor::CPPTYPE_INT32: {
+      for (int i = 0; i < field_size; ++i)
+      {
+        value.push_back(message.GetReflection()->GetRepeatedInt32(message, field_descriptor, i));
+      }
+
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_INT64: {
+      for (int i = 0; i < field_size; ++i)
+      {
+        // According to Protobuf specs 64-bit integer numbers in JSON-encoded payloads are encoded
+        // as decimal strings, and either numbers or strings are accepted when decoding.
+        value.push_back(std::to_string(
+            message.GetReflection()->GetRepeatedInt64(message, field_descriptor, i)));
+      }
+
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_UINT32: {
+      for (int i = 0; i < field_size; ++i)
+      {
+        value.push_back(message.GetReflection()->GetRepeatedUInt32(message, field_descriptor, i));
+      }
+
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_UINT64: {
+      for (int i = 0; i < field_size; ++i)
+      {
+        // According to Protobuf specs 64-bit integer numbers in JSON-encoded payloads are encoded
+        // as decimal strings, and either numbers or strings are accepted when decoding.
+        value.push_back(std::to_string(
+            message.GetReflection()->GetRepeatedUInt64(message, field_descriptor, i)));
+      }
+
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_STRING: {
+      std::string empty;
+      if (field_descriptor->type() == google::protobuf::FieldDescriptor::TYPE_BYTES)
+      {
+        for (int i = 0; i < field_size; ++i)
+        {
+          value.push_back(BytesMapping(message.GetReflection()->GetRepeatedStringReference(
+                                           message, field_descriptor, i, &empty),
+                                       field_descriptor, options.json_bytes_mapping));
+        }
+      }
+      else
+      {
+        for (int i = 0; i < field_size; ++i)
+        {
+          value.push_back(message.GetReflection()->GetRepeatedStringReference(
+              message, field_descriptor, i, &empty));
+        }
+      }
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE: {
+      for (int i = 0; i < field_size; ++i)
+      {
+        nlohmann::json sub_value;
+        ConvertGenericMessageToJson(
+            sub_value, message.GetReflection()->GetRepeatedMessage(message, field_descriptor, i),
+            options);
+        value.push_back(std::move(sub_value));
+      }
+
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE: {
+      for (int i = 0; i < field_size; ++i)
+      {
+        value.push_back(message.GetReflection()->GetRepeatedDouble(message, field_descriptor, i));
+      }
+
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT: {
+      for (int i = 0; i < field_size; ++i)
+      {
+        value.push_back(message.GetReflection()->GetRepeatedFloat(message, field_descriptor, i));
+      }
+
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_BOOL: {
+      for (int i = 0; i < field_size; ++i)
+      {
+        value.push_back(message.GetReflection()->GetRepeatedBool(message, field_descriptor, i));
+      }
+
+      break;
+    }
+    case google::protobuf::FieldDescriptor::CPPTYPE_ENUM: {
+      for (int i = 0; i < field_size; ++i)
+      {
+        value.push_back(
+            message.GetReflection()->GetRepeatedEnumValue(message, field_descriptor, i));
+      }
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+}
+
+}  // namespace
+
+OtlpHttpClient::OtlpHttpClient(OtlpHttpClientOptions &&options)
+    : options_(options), http_client_(http_client::HttpClientFactory::Create())
+{}
+
+OtlpHttpClient::OtlpHttpClient(OtlpHttpClientOptions &&options,
+                               std::shared_ptr<ext::http::client::HttpClient> http_client)
+    : options_(options), http_client_(http_client)
+{}
+
+// ----------------------------- HTTP Client methods ------------------------------
+opentelemetry::sdk::common::ExportResult OtlpHttpClient::Export(
+    const google::protobuf::Message &message) noexcept
+{
+  // Return failure if this exporter has been shutdown
+  if (isShutdown())
+  {
+    const char *error_message = "[OTLP HTTP Client] Export failed, exporter is shutdown";
+    if (options_.console_debug)
+    {
+      std::cerr << error_message << std::endl;
+    }
+    OTEL_INTERNAL_LOG_ERROR(error_message);
+
+    return opentelemetry::sdk::common::ExportResult::kFailure;
+  }
+
+  // Parse uri and store it to cache
+  if (http_uri_.empty())
+  {
+    auto parse_url = opentelemetry::ext::http::common::UrlParser(std::string(options_.url));
+    if (!parse_url.success_)
+    {
+      std::string error_message = "[OTLP HTTP Client] Export failed, invalid url: " + options_.url;
+      if (options_.console_debug)
+      {
+        std::cerr << error_message << std::endl;
+      }
+      OTEL_INTERNAL_LOG_ERROR(error_message.c_str());
+
+      return opentelemetry::sdk::common::ExportResult::kFailure;
+    }
+
+    if (!parse_url.path_.empty() && parse_url.path_[0] == '/')
+    {
+      http_uri_ = parse_url.path_.substr(1);
+    }
+    else
+    {
+      http_uri_ = parse_url.path_;
+    }
+  }
+
+  http_client::Body body_vec;
+  std::string content_type;
+  if (options_.content_type == HttpRequestContentType::kBinary)
+  {
+    if (SerializeToHttpBody(body_vec, message))
+    {
+      if (options_.console_debug)
+      {
+        OTEL_INTERNAL_LOG_DEBUG(
+            "[OTLP HTTP Client] Request body(Binary): " << message.Utf8DebugString());
+      }
+    }
+    else
+    {
+      if (options_.console_debug)
+      {
+        OTEL_INTERNAL_LOG_DEBUG("[OTLP HTTP Client] Serialize body failed(Binary):"
+                                << message.InitializationErrorString());
+      }
+      return opentelemetry::sdk::common::ExportResult::kFailure;
+    }
+    content_type = kHttpBinaryContentType;
+  }
+  else
+  {
+    nlohmann::json json_request;
+
+    // Convert from proto into json object
+    ConvertGenericMessageToJson(json_request, message, options_);
+
+    std::string post_body_json =
+        json_request.dump(-1, ' ', false, nlohmann::detail::error_handler_t::replace);
+    if (options_.console_debug)
+    {
+      OTEL_INTERNAL_LOG_DEBUG("[OTLP HTTP Client] Request body(Json)" << post_body_json);
+    }
+    body_vec.assign(post_body_json.begin(), post_body_json.end());
+    content_type = kHttpJsonContentType;
+  }
+
+  // Send the request
+  auto session = http_client_->CreateSession(options_.url);
+  auto request = session->CreateRequest();
+
+  for (auto &header : options_.http_headers)
+  {
+    request->AddHeader(header.first, header.second);
+  }
+  request->SetUri(http_uri_);
+  request->SetTimeoutMs(std::chrono::duration_cast<std::chrono::milliseconds>(options_.timeout));
+  request->SetMethod(http_client::Method::Post);
+  request->SetBody(body_vec);
+  request->ReplaceHeader("Content-Type", content_type);
+
+  // Send the request
+  std::unique_ptr<ResponseHandler> handler(new ResponseHandler(options_.console_debug));
+  session->SendRequest(*handler);
+
+  // Wait for the response to be received
+  if (options_.console_debug)
+  {
+    OTEL_INTERNAL_LOG_DEBUG(
+        "[OTLP HTTP Client] DEBUG: Waiting for response from "
+        << options_.url << " (timeout = "
+        << std::chrono::duration_cast<std::chrono::milliseconds>(options_.timeout).count()
+        << " milliseconds)");
+  }
+  bool write_successful = handler->waitForResponse();
+
+  // End the session
+  session->FinishSession();
+
+  // If an error occurred with the HTTP request
+  if (!write_successful)
+  {
+    // TODO: retry logic
+    return opentelemetry::sdk::common::ExportResult::kFailure;
+  }
+
+  return opentelemetry::sdk::common::ExportResult::kSuccess;
+}
+
+bool OtlpHttpClient::Shutdown(std::chrono::microseconds) noexcept
+{
+  {
+    const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+    is_shutdown_ = true;
+  }
+
+  // Shutdown the session manager
+  http_client_->CancelAllSessions();
+  http_client_->FinishAllSessions();
+
+  return true;
+}
+
+bool OtlpHttpClient::isShutdown() const noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  return is_shutdown_;
+}
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_http_exporter.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_http_exporter.cc
new file mode 100644
index 000000000..92155dd00
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_http_exporter.cc
@@ -0,0 +1,66 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/exporters/otlp/otlp_http_exporter.h"
+#include "opentelemetry/exporters/otlp/otlp_recordable.h"
+#include "opentelemetry/exporters/otlp/otlp_recordable_utils.h"
+
+#include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+
+#include "opentelemetry/proto/collector/trace/v1/trace_service.pb.h"
+
+#include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+
+namespace nostd = opentelemetry::nostd;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+OtlpHttpExporter::OtlpHttpExporter() : OtlpHttpExporter(OtlpHttpExporterOptions()) {}
+
+OtlpHttpExporter::OtlpHttpExporter(const OtlpHttpExporterOptions &options)
+    : options_(options),
+      http_client_(new OtlpHttpClient(OtlpHttpClientOptions(options.url,
+                                                            options.content_type,
+                                                            options.json_bytes_mapping,
+                                                            options.use_json_name,
+                                                            options.console_debug,
+                                                            options.timeout,
+                                                            options.http_headers)))
+{}
+
+OtlpHttpExporter::OtlpHttpExporter(std::unique_ptr<OtlpHttpClient> http_client)
+    : options_(OtlpHttpExporterOptions()), http_client_(std::move(http_client))
+{}
+// ----------------------------- Exporter methods ------------------------------
+
+std::unique_ptr<opentelemetry::sdk::trace::Recordable> OtlpHttpExporter::MakeRecordable() noexcept
+{
+  return std::unique_ptr<opentelemetry::sdk::trace::Recordable>(
+      new exporter::otlp::OtlpRecordable());
+}
+
+opentelemetry::sdk::common::ExportResult OtlpHttpExporter::Export(
+    const nostd::span<std::unique_ptr<opentelemetry::sdk::trace::Recordable>> &spans) noexcept
+{
+  if (spans.empty())
+  {
+    return opentelemetry::sdk::common::ExportResult::kSuccess;
+  }
+
+  proto::collector::trace::v1::ExportTraceServiceRequest service_request;
+  OtlpRecordableUtils::PopulateRequest(spans, &service_request);
+  return http_client_->Export(service_request);
+}
+
+bool OtlpHttpExporter::Shutdown(std::chrono::microseconds timeout) noexcept
+{
+  return http_client_->Shutdown(timeout);
+}
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_http_log_exporter.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_http_log_exporter.cc
new file mode 100644
index 000000000..436c77bea
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_http_log_exporter.cc
@@ -0,0 +1,69 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_LOGS_PREVIEW
+
+#  include "opentelemetry/exporters/otlp/otlp_http_log_exporter.h"
+#  include "opentelemetry/exporters/otlp/otlp_log_recordable.h"
+#  include "opentelemetry/exporters/otlp/otlp_recordable_utils.h"
+
+#  include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+
+#  include "opentelemetry/proto/collector/logs/v1/logs_service.pb.h"
+
+#  include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+
+namespace nostd = opentelemetry::nostd;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+OtlpHttpLogExporter::OtlpHttpLogExporter() : OtlpHttpLogExporter(OtlpHttpLogExporterOptions()) {}
+
+OtlpHttpLogExporter::OtlpHttpLogExporter(const OtlpHttpLogExporterOptions &options)
+    : options_(options),
+      http_client_(new OtlpHttpClient(OtlpHttpClientOptions(options.url,
+                                                            options.content_type,
+                                                            options.json_bytes_mapping,
+                                                            options.use_json_name,
+                                                            options.console_debug,
+                                                            options.timeout,
+                                                            options.http_headers)))
+{}
+
+OtlpHttpLogExporter::OtlpHttpLogExporter(std::unique_ptr<OtlpHttpClient> http_client)
+    : options_(OtlpHttpLogExporterOptions()), http_client_(std::move(http_client))
+{}
+// ----------------------------- Exporter methods ------------------------------
+
+std::unique_ptr<opentelemetry::sdk::logs::Recordable> OtlpHttpLogExporter::MakeRecordable() noexcept
+{
+  return std::unique_ptr<opentelemetry::sdk::logs::Recordable>(
+      new exporter::otlp::OtlpLogRecordable());
+}
+
+opentelemetry::sdk::common::ExportResult OtlpHttpLogExporter::Export(
+    const nostd::span<std::unique_ptr<opentelemetry::sdk::logs::Recordable>> &logs) noexcept
+{
+  if (logs.empty())
+  {
+    return opentelemetry::sdk::common::ExportResult::kSuccess;
+  }
+  proto::collector::logs::v1::ExportLogsServiceRequest service_request;
+  OtlpRecordableUtils::PopulateRequest(logs, &service_request);
+  return http_client_->Export(service_request);
+}
+
+bool OtlpHttpLogExporter::Shutdown(std::chrono::microseconds timeout) noexcept
+{
+  return http_client_->Shutdown(timeout);
+}
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_log_recordable.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_log_recordable.cc
new file mode 100644
index 000000000..d38fe241f
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_log_recordable.cc
@@ -0,0 +1,235 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_LOGS_PREVIEW
+
+#  include "opentelemetry/common/macros.h"
+
+#  include "opentelemetry/exporters/otlp/otlp_log_recordable.h"
+
+#  include "opentelemetry/exporters/otlp/otlp_recordable_utils.h"
+
+namespace nostd = opentelemetry::nostd;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+proto::resource::v1::Resource OtlpLogRecordable::ProtoResource() const noexcept
+{
+  proto::resource::v1::Resource proto;
+  if (nullptr == resource_)
+  {
+    OtlpRecordableUtils::PopulateAttribute(&proto, sdk::resource::Resource::GetDefault());
+  }
+  else
+  {
+    OtlpRecordableUtils::PopulateAttribute(&proto, *resource_);
+  }
+
+  return proto;
+}
+
+void OtlpLogRecordable::SetTimestamp(opentelemetry::common::SystemTimestamp timestamp) noexcept
+{
+  log_record_.set_time_unix_nano(timestamp.time_since_epoch().count());
+}
+
+void OtlpLogRecordable::SetSeverity(opentelemetry::logs::Severity severity) noexcept
+{
+  switch (severity)
+  {
+    case opentelemetry::logs::Severity::kTrace: {
+      log_record_.set_severity_text("TRACE");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_TRACE);
+      break;
+    }
+    case opentelemetry::logs::Severity::kTrace2: {
+      log_record_.set_severity_text("TRACE2");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_TRACE2);
+      break;
+    }
+    case opentelemetry::logs::Severity::kTrace3: {
+      log_record_.set_severity_text("TRACE3");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_TRACE3);
+      break;
+    }
+    case opentelemetry::logs::Severity::kTrace4: {
+      log_record_.set_severity_text("TRACE4");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_TRACE4);
+      break;
+    }
+    case opentelemetry::logs::Severity::kDebug: {
+      log_record_.set_severity_text("DEBUG");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_DEBUG);
+      break;
+    }
+    case opentelemetry::logs::Severity::kDebug2: {
+      log_record_.set_severity_text("DEBUG2");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_DEBUG2);
+      break;
+    }
+    case opentelemetry::logs::Severity::kDebug3: {
+      log_record_.set_severity_text("DEBUG3");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_DEBUG3);
+      break;
+    }
+    case opentelemetry::logs::Severity::kDebug4: {
+      log_record_.set_severity_text("DEBUG4");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_DEBUG4);
+      break;
+    }
+    case opentelemetry::logs::Severity::kInfo: {
+      log_record_.set_severity_text("INFO");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_INFO);
+      break;
+    }
+    case opentelemetry::logs::Severity::kInfo2: {
+      log_record_.set_severity_text("INFO2");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_INFO2);
+      break;
+    }
+    case opentelemetry::logs::Severity::kInfo3: {
+      log_record_.set_severity_text("INFO3");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_INFO3);
+      break;
+    }
+    case opentelemetry::logs::Severity::kInfo4: {
+      log_record_.set_severity_text("INFO4");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_INFO4);
+      break;
+    }
+    case opentelemetry::logs::Severity::kWarn: {
+      log_record_.set_severity_text("WARN");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_WARN);
+      break;
+    }
+    case opentelemetry::logs::Severity::kWarn2: {
+      log_record_.set_severity_text("WARN2");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_WARN2);
+      break;
+    }
+    case opentelemetry::logs::Severity::kWarn3: {
+      log_record_.set_severity_text("WARN3");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_WARN3);
+      break;
+    }
+    case opentelemetry::logs::Severity::kWarn4: {
+      log_record_.set_severity_text("WARN4");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_WARN4);
+      break;
+    }
+    case opentelemetry::logs::Severity::kError: {
+      log_record_.set_severity_text("ERROR");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_ERROR);
+      break;
+    }
+    case opentelemetry::logs::Severity::kError2: {
+      log_record_.set_severity_text("ERROR2");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_ERROR2);
+      break;
+    }
+    case opentelemetry::logs::Severity::kError3: {
+      log_record_.set_severity_text("ERROR3");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_ERROR3);
+      break;
+    }
+    case opentelemetry::logs::Severity::kError4: {
+      log_record_.set_severity_text("ERROR4");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_ERROR4);
+      break;
+    }
+    case opentelemetry::logs::Severity::kFatal: {
+      log_record_.set_severity_text("FATAL");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_FATAL);
+      break;
+    }
+    case opentelemetry::logs::Severity::kFatal2: {
+      log_record_.set_severity_text("FATAL2");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_FATAL2);
+      break;
+    }
+    case opentelemetry::logs::Severity::kFatal3: {
+      log_record_.set_severity_text("FATAL3");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_FATAL3);
+      break;
+    }
+    case opentelemetry::logs::Severity::kFatal4: {
+      log_record_.set_severity_text("FATAL4");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_FATAL4);
+      break;
+    }
+    default: {
+      log_record_.set_severity_text("INVALID");
+      log_record_.set_severity_number(proto::logs::v1::SEVERITY_NUMBER_UNSPECIFIED);
+      break;
+    }
+  }
+}
+
+void OtlpLogRecordable::SetBody(nostd::string_view message) noexcept
+{
+  log_record_.mutable_body()->set_string_value(message.data(), message.size());
+}
+
+void OtlpLogRecordable::SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept
+{
+  resource_ = &resource;
+}
+
+const opentelemetry::sdk::resource::Resource &OtlpLogRecordable::GetResource() const noexcept
+{
+  OPENTELEMETRY_LIKELY_IF(nullptr != resource_) { return *resource_; }
+
+  return opentelemetry::sdk::resource::Resource::GetDefault();
+}
+
+void OtlpLogRecordable::SetAttribute(nostd::string_view key,
+                                     const opentelemetry::common::AttributeValue &value) noexcept
+{
+  OtlpRecordableUtils::PopulateAttribute(log_record_.add_attributes(), key, value);
+}
+
+void OtlpLogRecordable::SetTraceId(opentelemetry::trace::TraceId trace_id) noexcept
+{
+  log_record_.set_trace_id(reinterpret_cast<const char *>(trace_id.Id().data()),
+                           trace::TraceId::kSize);
+}
+
+void OtlpLogRecordable::SetSpanId(opentelemetry::trace::SpanId span_id) noexcept
+{
+  log_record_.set_span_id(reinterpret_cast<const char *>(span_id.Id().data()),
+                          trace::SpanId::kSize);
+}
+
+void OtlpLogRecordable::SetTraceFlags(opentelemetry::trace::TraceFlags trace_flags) noexcept
+{
+  log_record_.set_flags(trace_flags.flags());
+}
+
+void OtlpLogRecordable::SetInstrumentationLibrary(
+    const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary
+        &instrumentation_library) noexcept
+{
+  instrumentation_library_ = &instrumentation_library;
+}
+
+const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary &
+OtlpLogRecordable::GetInstrumentationLibrary() const noexcept
+{
+  OPENTELEMETRY_LIKELY_IF(nullptr != instrumentation_library_) { return *instrumentation_library_; }
+
+  static opentelemetry::nostd::unique_ptr<
+      opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary>
+      default_instrumentation =
+          opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary::Create(
+              "default", "1.0.0", "https://opentelemetry.io/schemas/1.11.0");
+  return *default_instrumentation;
+}
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_recordable.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_recordable.cc
new file mode 100644
index 000000000..0e6aa8f8a
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_recordable.cc
@@ -0,0 +1,187 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/exporters/otlp/otlp_recordable.h"
+
+#include "opentelemetry/exporters/otlp/otlp_recordable_utils.h"
+
+namespace nostd = opentelemetry::nostd;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+void OtlpRecordable::SetIdentity(const opentelemetry::trace::SpanContext &span_context,
+                                 opentelemetry::trace::SpanId parent_span_id) noexcept
+{
+  span_.set_trace_id(reinterpret_cast<const char *>(span_context.trace_id().Id().data()),
+                     trace::TraceId::kSize);
+  span_.set_span_id(reinterpret_cast<const char *>(span_context.span_id().Id().data()),
+                    trace::SpanId::kSize);
+  if (parent_span_id.IsValid())
+  {
+    span_.set_parent_span_id(reinterpret_cast<const char *>(parent_span_id.Id().data()),
+                             trace::SpanId::kSize);
+  }
+  span_.set_trace_state(span_context.trace_state()->ToHeader());
+}
+
+proto::resource::v1::Resource OtlpRecordable::ProtoResource() const noexcept
+{
+  proto::resource::v1::Resource proto;
+  if (resource_)
+  {
+    OtlpRecordableUtils::PopulateAttribute(&proto, *resource_);
+  }
+
+  return proto;
+}
+
+const std::string OtlpRecordable::GetResourceSchemaURL() const noexcept
+{
+  std::string schema_url;
+  if (resource_)
+  {
+    schema_url = resource_->GetSchemaURL();
+  }
+
+  return schema_url;
+}
+
+const std::string OtlpRecordable::GetInstrumentationLibrarySchemaURL() const noexcept
+{
+  std::string schema_url;
+  if (instrumentation_library_)
+  {
+    schema_url = instrumentation_library_->GetSchemaURL();
+  }
+
+  return schema_url;
+}
+
+proto::common::v1::InstrumentationLibrary OtlpRecordable::GetProtoInstrumentationLibrary()
+    const noexcept
+{
+  proto::common::v1::InstrumentationLibrary instrumentation_library;
+  if (instrumentation_library_)
+  {
+    instrumentation_library.set_name(instrumentation_library_->GetName());
+    instrumentation_library.set_version(instrumentation_library_->GetVersion());
+  }
+  return instrumentation_library;
+}
+
+void OtlpRecordable::SetResource(const sdk::resource::Resource &resource) noexcept
+{
+  resource_ = &resource;
+};
+
+void OtlpRecordable::SetAttribute(nostd::string_view key,
+                                  const common::AttributeValue &value) noexcept
+{
+  auto *attribute = span_.add_attributes();
+  OtlpRecordableUtils::PopulateAttribute(attribute, key, value);
+}
+
+void OtlpRecordable::AddEvent(nostd::string_view name,
+                              common::SystemTimestamp timestamp,
+                              const common::KeyValueIterable &attributes) noexcept
+{
+  auto *event = span_.add_events();
+  event->set_name(name.data(), name.size());
+  event->set_time_unix_nano(timestamp.time_since_epoch().count());
+
+  attributes.ForEachKeyValue([&](nostd::string_view key, common::AttributeValue value) noexcept {
+    OtlpRecordableUtils::PopulateAttribute(event->add_attributes(), key, value);
+    return true;
+  });
+}
+
+void OtlpRecordable::AddLink(const trace::SpanContext &span_context,
+                             const common::KeyValueIterable &attributes) noexcept
+{
+  auto *link = span_.add_links();
+  link->set_trace_id(reinterpret_cast<const char *>(span_context.trace_id().Id().data()),
+                     trace::TraceId::kSize);
+  link->set_span_id(reinterpret_cast<const char *>(span_context.span_id().Id().data()),
+                    trace::SpanId::kSize);
+  link->set_trace_state(span_context.trace_state()->ToHeader());
+  attributes.ForEachKeyValue([&](nostd::string_view key, common::AttributeValue value) noexcept {
+    OtlpRecordableUtils::PopulateAttribute(link->add_attributes(), key, value);
+    return true;
+  });
+}
+
+void OtlpRecordable::SetStatus(trace::StatusCode code, nostd::string_view description) noexcept
+{
+  span_.mutable_status()->set_code(proto::trace::v1::Status_StatusCode(code));
+  if (code == trace::StatusCode::kError)
+  {
+    span_.mutable_status()->set_message(description.data(), description.size());
+  }
+}
+
+void OtlpRecordable::SetName(nostd::string_view name) noexcept
+{
+  span_.set_name(name.data(), name.size());
+}
+
+void OtlpRecordable::SetSpanKind(trace::SpanKind span_kind) noexcept
+{
+  proto::trace::v1::Span_SpanKind proto_span_kind =
+      proto::trace::v1::Span_SpanKind::Span_SpanKind_SPAN_KIND_UNSPECIFIED;
+
+  switch (span_kind)
+  {
+
+    case trace::SpanKind::kInternal:
+      proto_span_kind = proto::trace::v1::Span_SpanKind::Span_SpanKind_SPAN_KIND_INTERNAL;
+      break;
+
+    case trace::SpanKind::kServer:
+      proto_span_kind = proto::trace::v1::Span_SpanKind::Span_SpanKind_SPAN_KIND_SERVER;
+      break;
+
+    case trace::SpanKind::kClient:
+      proto_span_kind = proto::trace::v1::Span_SpanKind::Span_SpanKind_SPAN_KIND_CLIENT;
+      break;
+
+    case trace::SpanKind::kProducer:
+      proto_span_kind = proto::trace::v1::Span_SpanKind::Span_SpanKind_SPAN_KIND_PRODUCER;
+      break;
+
+    case trace::SpanKind::kConsumer:
+      proto_span_kind = proto::trace::v1::Span_SpanKind::Span_SpanKind_SPAN_KIND_CONSUMER;
+      break;
+
+    default:
+      // shouldn't reach here.
+      proto_span_kind = proto::trace::v1::Span_SpanKind::Span_SpanKind_SPAN_KIND_UNSPECIFIED;
+  }
+
+  span_.set_kind(proto_span_kind);
+}
+
+void OtlpRecordable::SetStartTime(common::SystemTimestamp start_time) noexcept
+{
+  span_.set_start_time_unix_nano(start_time.time_since_epoch().count());
+}
+
+void OtlpRecordable::SetDuration(std::chrono::nanoseconds duration) noexcept
+{
+  const uint64_t unix_end_time = span_.start_time_unix_nano() + duration.count();
+  span_.set_end_time_unix_nano(unix_end_time);
+}
+
+void OtlpRecordable::SetInstrumentationLibrary(
+    const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary
+        &instrumentation_library) noexcept
+{
+  instrumentation_library_ = &instrumentation_library;
+}
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_recordable_utils.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_recordable_utils.cc
new file mode 100644
index 000000000..bb3c84604
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/src/otlp_recordable_utils.cc
@@ -0,0 +1,362 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/exporters/otlp/otlp_recordable_utils.h"
+
+#include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+
+#include "opentelemetry/proto/logs/v1/logs.pb.h"
+#include "opentelemetry/proto/trace/v1/trace.pb.h"
+
+#include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+
+#include "opentelemetry/exporters/otlp/otlp_log_recordable.h"
+#include "opentelemetry/exporters/otlp/otlp_recordable.h"
+
+#include <list>
+#include <unordered_map>
+
+namespace nostd = opentelemetry::nostd;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+namespace
+{
+struct InstrumentationLibraryPointerHasher
+{
+  std::size_t operator()(const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary
+                             *instrumentation) const noexcept
+  {
+    return instrumentation->HashCode();
+  }
+};
+
+struct InstrumentationLibraryPointerEqual
+{
+  std::size_t operator()(
+      const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary *left,
+      const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary *right)
+      const noexcept
+  {
+    return *left == *right;
+  }
+};
+}  // namespace
+
+//
+// See `attribute_value.h` for details.
+//
+const int kAttributeValueSize      = 16;
+const int kOwnedAttributeValueSize = 15;
+
+void OtlpRecordableUtils::PopulateAttribute(
+    opentelemetry::proto::common::v1::KeyValue *attribute,
+    nostd::string_view key,
+    const opentelemetry::common::AttributeValue &value) noexcept
+{
+  if (nullptr == attribute)
+  {
+    return;
+  }
+
+  // Assert size of variant to ensure that this method gets updated if the variant
+  // definition changes
+  static_assert(
+      nostd::variant_size<opentelemetry::common::AttributeValue>::value == kAttributeValueSize,
+      "AttributeValue contains unknown type");
+
+  attribute->set_key(key.data(), key.size());
+
+  if (nostd::holds_alternative<bool>(value))
+  {
+    attribute->mutable_value()->set_bool_value(nostd::get<bool>(value));
+  }
+  else if (nostd::holds_alternative<int>(value))
+  {
+    attribute->mutable_value()->set_int_value(nostd::get<int>(value));
+  }
+  else if (nostd::holds_alternative<int64_t>(value))
+  {
+    attribute->mutable_value()->set_int_value(nostd::get<int64_t>(value));
+  }
+  else if (nostd::holds_alternative<unsigned int>(value))
+  {
+    attribute->mutable_value()->set_int_value(nostd::get<unsigned int>(value));
+  }
+  else if (nostd::holds_alternative<uint64_t>(value))
+  {
+    attribute->mutable_value()->set_int_value(nostd::get<uint64_t>(value));
+  }
+  else if (nostd::holds_alternative<double>(value))
+  {
+    attribute->mutable_value()->set_double_value(nostd::get<double>(value));
+  }
+  else if (nostd::holds_alternative<const char *>(value))
+  {
+    attribute->mutable_value()->set_string_value(nostd::get<const char *>(value));
+  }
+  else if (nostd::holds_alternative<nostd::string_view>(value))
+  {
+    attribute->mutable_value()->set_string_value(nostd::get<nostd::string_view>(value).data(),
+                                                 nostd::get<nostd::string_view>(value).size());
+  }
+  else if (nostd::holds_alternative<nostd::span<const uint8_t>>(value))
+  {
+    for (const auto &val : nostd::get<nostd::span<const uint8_t>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_int_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const bool>>(value))
+  {
+    for (const auto &val : nostd::get<nostd::span<const bool>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_bool_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const int>>(value))
+  {
+    for (const auto &val : nostd::get<nostd::span<const int>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_int_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const int64_t>>(value))
+  {
+    for (const auto &val : nostd::get<nostd::span<const int64_t>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_int_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const unsigned int>>(value))
+  {
+    for (const auto &val : nostd::get<nostd::span<const unsigned int>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_int_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const uint64_t>>(value))
+  {
+    for (const auto &val : nostd::get<nostd::span<const uint64_t>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_int_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const double>>(value))
+  {
+    for (const auto &val : nostd::get<nostd::span<const double>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_double_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const nostd::string_view>>(value))
+  {
+    for (const auto &val : nostd::get<nostd::span<const nostd::string_view>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_string_value(val.data(),
+                                                                                        val.size());
+    }
+  }
+}
+
+/** Maps from C++ attribute into OTLP proto attribute. */
+void OtlpRecordableUtils::PopulateAttribute(
+    opentelemetry::proto::common::v1::KeyValue *attribute,
+    nostd::string_view key,
+    const opentelemetry::sdk::common::OwnedAttributeValue &value) noexcept
+{
+  if (nullptr == attribute)
+  {
+    return;
+  }
+
+  // Assert size of variant to ensure that this method gets updated if the variant
+  // definition changes
+  static_assert(nostd::variant_size<opentelemetry::sdk::common::OwnedAttributeValue>::value ==
+                    kOwnedAttributeValueSize,
+                "OwnedAttributeValue contains unknown type");
+
+  attribute->set_key(key.data(), key.size());
+
+  if (nostd::holds_alternative<bool>(value))
+  {
+    attribute->mutable_value()->set_bool_value(nostd::get<bool>(value));
+  }
+  else if (nostd::holds_alternative<int32_t>(value))
+  {
+    attribute->mutable_value()->set_int_value(nostd::get<int32_t>(value));
+  }
+  else if (nostd::holds_alternative<int64_t>(value))
+  {
+    attribute->mutable_value()->set_int_value(nostd::get<int64_t>(value));
+  }
+  else if (nostd::holds_alternative<uint32_t>(value))
+  {
+    attribute->mutable_value()->set_int_value(nostd::get<uint32_t>(value));
+  }
+  else if (nostd::holds_alternative<uint64_t>(value))
+  {
+    attribute->mutable_value()->set_int_value(nostd::get<uint64_t>(value));
+  }
+  else if (nostd::holds_alternative<double>(value))
+  {
+    attribute->mutable_value()->set_double_value(nostd::get<double>(value));
+  }
+  else if (nostd::holds_alternative<std::string>(value))
+  {
+    attribute->mutable_value()->set_string_value(nostd::get<std::string>(value));
+  }
+  else if (nostd::holds_alternative<std::vector<bool>>(value))
+  {
+    for (const auto &val : nostd::get<std::vector<bool>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_bool_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<std::vector<int32_t>>(value))
+  {
+    for (const auto &val : nostd::get<std::vector<int32_t>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_int_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<std::vector<uint32_t>>(value))
+  {
+    for (const auto &val : nostd::get<std::vector<uint32_t>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_int_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<std::vector<int64_t>>(value))
+  {
+    for (const auto &val : nostd::get<std::vector<int64_t>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_int_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<std::vector<uint64_t>>(value))
+  {
+    for (const auto &val : nostd::get<std::vector<uint64_t>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_int_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<std::vector<double>>(value))
+  {
+    for (const auto &val : nostd::get<std::vector<double>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_double_value(val);
+    }
+  }
+  else if (nostd::holds_alternative<std::vector<std::string>>(value))
+  {
+    for (const auto &val : nostd::get<std::vector<std::string>>(value))
+    {
+      attribute->mutable_value()->mutable_array_value()->add_values()->set_string_value(val);
+    }
+  }
+}
+
+void OtlpRecordableUtils::PopulateAttribute(
+    opentelemetry::proto::resource::v1::Resource *proto,
+    const opentelemetry::sdk::resource::Resource &resource) noexcept
+{
+  if (nullptr == proto)
+  {
+    return;
+  }
+
+  for (const auto &kv : resource.GetAttributes())
+  {
+    OtlpRecordableUtils::PopulateAttribute(proto->add_attributes(), kv.first, kv.second);
+  }
+}
+
+void OtlpRecordableUtils::PopulateRequest(
+    const nostd::span<std::unique_ptr<opentelemetry::sdk::trace::Recordable>> &spans,
+    proto::collector::trace::v1::ExportTraceServiceRequest *request) noexcept
+{
+  if (nullptr == request)
+  {
+    return;
+  }
+
+  for (auto &recordable : spans)
+  {
+    auto rec = std::unique_ptr<OtlpRecordable>(static_cast<OtlpRecordable *>(recordable.release()));
+    auto resource_span       = request->add_resource_spans();
+    auto instrumentation_lib = resource_span->add_instrumentation_library_spans();
+
+    *instrumentation_lib->add_spans()                       = std::move(rec->span());
+    *instrumentation_lib->mutable_instrumentation_library() = rec->GetProtoInstrumentationLibrary();
+
+    instrumentation_lib->set_schema_url(rec->GetInstrumentationLibrarySchemaURL());
+
+    *resource_span->mutable_resource() = rec->ProtoResource();
+    resource_span->set_schema_url(rec->GetResourceSchemaURL());
+  }
+}
+
+#ifdef ENABLE_LOGS_PREVIEW
+void OtlpRecordableUtils::PopulateRequest(
+    const nostd::span<std::unique_ptr<opentelemetry::sdk::logs::Recordable>> &logs,
+    proto::collector::logs::v1::ExportLogsServiceRequest *request) noexcept
+{
+  if (nullptr == request)
+  {
+    return;
+  }
+
+  using logs_index_by_instrumentation_type =
+      std::unordered_map<const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary *,
+                         std::list<std::unique_ptr<OtlpLogRecordable>>,
+                         InstrumentationLibraryPointerHasher, InstrumentationLibraryPointerEqual>;
+  std::unordered_map<const opentelemetry::sdk::resource::Resource *,
+                     logs_index_by_instrumentation_type>
+      logs_index_by_resource;
+
+  for (auto &recordable : logs)
+  {
+    auto rec =
+        std::unique_ptr<OtlpLogRecordable>(static_cast<OtlpLogRecordable *>(recordable.release()));
+    auto instrumentation = &rec->GetInstrumentationLibrary();
+    auto resource        = &rec->GetResource();
+
+    logs_index_by_resource[resource][instrumentation].emplace_back(std::move(rec));
+  }
+
+  for (auto &input_resource_log : logs_index_by_resource)
+  {
+    auto output_resource_log = request->add_resource_logs();
+    for (auto &input_scope_log : input_resource_log.second)
+    {
+      auto output_scope_log = output_resource_log->add_scope_logs();
+      for (auto &input_log_record : input_scope_log.second)
+      {
+        if (!output_resource_log->has_resource())
+        {
+          *output_resource_log->mutable_resource() = input_log_record->ProtoResource();
+          output_resource_log->set_schema_url(input_resource_log.first->GetSchemaURL());
+        }
+
+        if (!output_scope_log->has_scope())
+        {
+          output_scope_log->mutable_scope()->set_name(input_scope_log.first->GetName());
+          output_scope_log->mutable_scope()->set_version(input_scope_log.first->GetVersion());
+          output_scope_log->set_schema_url(input_scope_log.first->GetSchemaURL());
+        }
+
+        *output_scope_log->add_log_records() = std::move(input_log_record->log_record());
+      }
+    }
+  }
+}
+#endif
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_grpc_exporter_benchmark.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_grpc_exporter_benchmark.cc
new file mode 100644
index 000000000..c86f5e53b
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_grpc_exporter_benchmark.cc
@@ -0,0 +1,216 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/exporters/otlp/otlp_grpc_exporter.h"
+#include "opentelemetry/exporters/otlp/otlp_recordable.h"
+
+#include <benchmark/benchmark.h>
+#include "opentelemetry/sdk/trace/simple_processor.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
+#include "opentelemetry/trace/provider.h"
+
+#ifdef BAZEL_BUILD
+#  include "examples/common/foo_library/foo_library.h"
+#else
+#  include "foo_library/foo_library.h"
+#endif
+
+namespace trace     = opentelemetry::trace;
+namespace nostd     = opentelemetry::nostd;
+namespace trace_sdk = opentelemetry::sdk::trace;
+namespace otlp      = opentelemetry::exporter::otlp;
+
+#include <benchmark/benchmark.h>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+namespace trace_api = opentelemetry::trace;
+
+const int kBatchSize     = 200;
+const int kNumAttributes = 5;
+const int kNumIterations = 1000;
+
+const trace::TraceId kTraceId(std::array<const uint8_t, trace::TraceId::kSize>(
+    {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}));
+const trace::SpanId kSpanId(std::array<const uint8_t, trace::SpanId::kSize>({0, 0, 0, 0, 0, 0, 0,
+                                                                             2}));
+const trace::SpanId kParentSpanId(std::array<const uint8_t, trace::SpanId::kSize>({0, 0, 0, 0, 0, 0,
+                                                                                   0, 3}));
+const auto kTraceState = trace_api::TraceState::GetDefault() -> Set("key1", "value");
+const trace_api::SpanContext kSpanContext{
+    kTraceId, kSpanId, trace_api::TraceFlags{trace_api::TraceFlags::kIsSampled}, true, kTraceState};
+
+// ----------------------- Helper classes and functions ------------------------
+
+// Create a fake service stub to avoid dependency on gmock
+class FakeServiceStub : public proto::collector::trace::v1::TraceService::StubInterface
+{
+  grpc::Status Export(grpc::ClientContext *,
+                      const proto::collector::trace::v1::ExportTraceServiceRequest &,
+                      proto::collector::trace::v1::ExportTraceServiceResponse *) override
+  {
+    return grpc::Status::OK;
+  }
+
+  grpc::ClientAsyncResponseReaderInterface<proto::collector::trace::v1::ExportTraceServiceResponse>
+      *AsyncExportRaw(grpc::ClientContext *,
+                      const proto::collector::trace::v1::ExportTraceServiceRequest &,
+                      grpc::CompletionQueue *) override
+  {
+    return nullptr;
+  }
+
+  grpc::ClientAsyncResponseReaderInterface<proto::collector::trace::v1::ExportTraceServiceResponse>
+      *PrepareAsyncExportRaw(grpc::ClientContext *,
+                             const proto::collector::trace::v1::ExportTraceServiceRequest &,
+                             grpc::CompletionQueue *) override
+  {
+    return nullptr;
+  }
+};
+
+// OtlpGrpcExporterTestPeer is a friend class of OtlpGrpcExporter
+class OtlpGrpcExporterTestPeer
+{
+public:
+  std::unique_ptr<sdk::trace::SpanExporter> GetExporter()
+  {
+    auto mock_stub = new FakeServiceStub();
+    std::unique_ptr<proto::collector::trace::v1::TraceService::StubInterface> stub_interface(
+        mock_stub);
+    return std::unique_ptr<sdk::trace::SpanExporter>(
+        new exporter::otlp::OtlpGrpcExporter(std::move(stub_interface)));
+  }
+};
+
+// Helper function to create empty spans
+void CreateEmptySpans(std::array<std::unique_ptr<sdk::trace::Recordable>, kBatchSize> &recordables)
+{
+  for (int i = 0; i < kBatchSize; i++)
+  {
+    auto recordable = std::unique_ptr<sdk::trace::Recordable>(new OtlpRecordable);
+    recordables[i]  = std::move(recordable);
+  }
+}
+
+// Helper function to create sparse spans
+void CreateSparseSpans(std::array<std::unique_ptr<sdk::trace::Recordable>, kBatchSize> &recordables)
+{
+  for (int i = 0; i < kBatchSize; i++)
+  {
+    auto recordable = std::unique_ptr<sdk::trace::Recordable>(new OtlpRecordable);
+
+    recordable->SetIdentity(kSpanContext, kParentSpanId);
+    recordable->SetName("TestSpan");
+    recordable->SetStartTime(common::SystemTimestamp(std::chrono::system_clock::now()));
+    recordable->SetDuration(std::chrono::nanoseconds(10));
+
+    recordables[i] = std::move(recordable);
+  }
+}
+
+// Helper function to create dense spans
+void CreateDenseSpans(std::array<std::unique_ptr<sdk::trace::Recordable>, kBatchSize> &recordables)
+{
+  for (int i = 0; i < kBatchSize; i++)
+  {
+    auto recordable = std::unique_ptr<sdk::trace::Recordable>(new OtlpRecordable);
+
+    recordable->SetIdentity(kSpanContext, kParentSpanId);
+    recordable->SetName("TestSpan");
+    recordable->SetStartTime(common::SystemTimestamp(std::chrono::system_clock::now()));
+    recordable->SetDuration(std::chrono::nanoseconds(10));
+
+    for (int i = 0; i < kNumAttributes; i++)
+    {
+      recordable->SetAttribute("int_key_" + i, static_cast<int64_t>(i));
+      recordable->SetAttribute("str_key_" + i, "string_val_" + i);
+      recordable->SetAttribute("bool_key_" + i, true);
+    }
+
+    recordables[i] = std::move(recordable);
+  }
+}
+
+// ------------------------------ Benchmark tests ------------------------------
+
+// Benchmark Export() with empty spans
+void BM_OtlpExporterEmptySpans(benchmark::State &state)
+{
+  std::unique_ptr<OtlpGrpcExporterTestPeer> testpeer(new OtlpGrpcExporterTestPeer());
+  auto exporter = testpeer->GetExporter();
+
+  while (state.KeepRunningBatch(kNumIterations))
+  {
+    std::array<std::unique_ptr<sdk::trace::Recordable>, kBatchSize> recordables;
+    CreateEmptySpans(recordables);
+    exporter->Export(nostd::span<std::unique_ptr<sdk::trace::Recordable>>(recordables));
+  }
+}
+BENCHMARK(BM_OtlpExporterEmptySpans);
+
+// Benchmark Export() with sparse spans
+void BM_OtlpExporterSparseSpans(benchmark::State &state)
+{
+  std::unique_ptr<OtlpGrpcExporterTestPeer> testpeer(new OtlpGrpcExporterTestPeer());
+  auto exporter = testpeer->GetExporter();
+
+  while (state.KeepRunningBatch(kNumIterations))
+  {
+    std::array<std::unique_ptr<sdk::trace::Recordable>, kBatchSize> recordables;
+    CreateSparseSpans(recordables);
+    exporter->Export(nostd::span<std::unique_ptr<sdk::trace::Recordable>>(recordables));
+  }
+}
+BENCHMARK(BM_OtlpExporterSparseSpans);
+
+// Benchmark Export() with dense spans
+void BM_OtlpExporterDenseSpans(benchmark::State &state)
+{
+  std::unique_ptr<OtlpGrpcExporterTestPeer> testpeer(new OtlpGrpcExporterTestPeer());
+  auto exporter = testpeer->GetExporter();
+
+  while (state.KeepRunningBatch(kNumIterations))
+  {
+    std::array<std::unique_ptr<sdk::trace::Recordable>, kBatchSize> recordables;
+    CreateDenseSpans(recordables);
+    exporter->Export(nostd::span<std::unique_ptr<sdk::trace::Recordable>>(recordables));
+  }
+}
+BENCHMARK(BM_OtlpExporterDenseSpans);
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+
+namespace
+{
+opentelemetry::exporter::otlp::OtlpGrpcExporterOptions opts;
+void InitTracer()
+{
+  // Create OTLP exporter instance
+  auto exporter  = std::unique_ptr<trace_sdk::SpanExporter>(new otlp::OtlpGrpcExporter(opts));
+  auto processor = std::unique_ptr<trace_sdk::SpanProcessor>(
+      new trace_sdk::SimpleSpanProcessor(std::move(exporter)));
+  auto provider =
+      nostd::shared_ptr<trace::TracerProvider>(new trace_sdk::TracerProvider(std::move(processor)));
+  // Set the global trace provider
+  trace::Provider::SetTracerProvider(provider);
+}
+
+void BM_otlp_grpc_with_collector(benchmark::State &state)
+{
+  InitTracer();
+  while (state.KeepRunning())
+  {
+    foo_library();
+  }
+}
+BENCHMARK(BM_otlp_grpc_with_collector);
+}  // namespace
+
+BENCHMARK_MAIN();
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_grpc_exporter_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_grpc_exporter_test.cc
new file mode 100755
index 000000000..091cb0d0c
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_grpc_exporter_test.cc
@@ -0,0 +1,217 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef HAVE_CPP_STDLIB
+// Unfortunately as of 04/27/2021 the fix is NOT in the vcpkg snapshot of Google Test.
+// Remove above `#ifdef` once the GMock fix for C++20 is in the mainline.
+//
+// Please refer to this GitHub issue for additional details:
+// https://github.com/google/googletest/issues/2914
+// https://github.com/google/googletest/commit/61f010d703b32de9bfb20ab90ece38ab2f25977f
+//
+// If we compile using Visual Studio 2019 with `c++latest` (C++20) without the GMock fix,
+// then the compilation here fails in `gmock-actions.h` from:
+//   .\tools\vcpkg\installed\x64-windows\include\gmock\gmock-actions.h(819):
+//   error C2653: 'result_of': is not a class or namespace name
+//
+// That is because `std::result_of` has been removed in C++20.
+
+#  include "opentelemetry/exporters/otlp/otlp_grpc_exporter.h"
+
+#  include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+
+// Problematic code that pulls in Gmock and breaks with vs2019/c++latest :
+#  include "opentelemetry/proto/collector/trace/v1/trace_service_mock.grpc.pb.h"
+
+#  include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+
+#  include "opentelemetry/sdk/trace/simple_processor.h"
+#  include "opentelemetry/sdk/trace/tracer_provider.h"
+#  include "opentelemetry/trace/provider.h"
+
+#  include <gtest/gtest.h>
+
+#  if defined(_MSC_VER)
+#    include "opentelemetry/sdk/common/env_variables.h"
+using opentelemetry::sdk::common::setenv;
+using opentelemetry::sdk::common::unsetenv;
+#  endif
+
+using namespace testing;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+class OtlpGrpcExporterTestPeer : public ::testing::Test
+{
+public:
+  std::unique_ptr<sdk::trace::SpanExporter> GetExporter(
+      std::unique_ptr<proto::collector::trace::v1::TraceService::StubInterface> &stub_interface)
+  {
+    return std::unique_ptr<sdk::trace::SpanExporter>(
+        new OtlpGrpcExporter(std::move(stub_interface)));
+  }
+
+  // Get the options associated with the given exporter.
+  const OtlpGrpcExporterOptions &GetOptions(std::unique_ptr<OtlpGrpcExporter> &exporter)
+  {
+    return exporter->options_;
+  }
+};
+
+TEST_F(OtlpGrpcExporterTestPeer, ShutdownTest)
+{
+  auto mock_stub = new proto::collector::trace::v1::MockTraceServiceStub();
+  std::unique_ptr<proto::collector::trace::v1::TraceService::StubInterface> stub_interface(
+      mock_stub);
+  auto exporter = GetExporter(stub_interface);
+
+  auto recordable_1 = exporter->MakeRecordable();
+  recordable_1->SetName("Test span 1");
+  auto recordable_2 = exporter->MakeRecordable();
+  recordable_2->SetName("Test span 2");
+
+  // exporter shuold not be shutdown by default
+  nostd::span<std::unique_ptr<sdk::trace::Recordable>> batch_1(&recordable_1, 1);
+  EXPECT_CALL(*mock_stub, Export(_, _, _)).Times(Exactly(1)).WillOnce(Return(grpc::Status::OK));
+  auto result = exporter->Export(batch_1);
+  EXPECT_EQ(sdk::common::ExportResult::kSuccess, result);
+
+  exporter->Shutdown();
+
+  nostd::span<std::unique_ptr<sdk::trace::Recordable>> batch_2(&recordable_2, 1);
+  result = exporter->Export(batch_2);
+  EXPECT_EQ(sdk::common::ExportResult::kFailure, result);
+}
+
+// Call Export() directly
+TEST_F(OtlpGrpcExporterTestPeer, ExportUnitTest)
+{
+  auto mock_stub = new proto::collector::trace::v1::MockTraceServiceStub();
+  std::unique_ptr<proto::collector::trace::v1::TraceService::StubInterface> stub_interface(
+      mock_stub);
+  auto exporter = GetExporter(stub_interface);
+
+  auto recordable_1 = exporter->MakeRecordable();
+  recordable_1->SetName("Test span 1");
+  auto recordable_2 = exporter->MakeRecordable();
+  recordable_2->SetName("Test span 2");
+
+  // Test successful RPC
+  nostd::span<std::unique_ptr<sdk::trace::Recordable>> batch_1(&recordable_1, 1);
+  EXPECT_CALL(*mock_stub, Export(_, _, _)).Times(Exactly(1)).WillOnce(Return(grpc::Status::OK));
+  auto result = exporter->Export(batch_1);
+  EXPECT_EQ(sdk::common::ExportResult::kSuccess, result);
+
+  // Test failed RPC
+  nostd::span<std::unique_ptr<sdk::trace::Recordable>> batch_2(&recordable_2, 1);
+  EXPECT_CALL(*mock_stub, Export(_, _, _))
+      .Times(Exactly(1))
+      .WillOnce(Return(grpc::Status::CANCELLED));
+  result = exporter->Export(batch_2);
+  EXPECT_EQ(sdk::common::ExportResult::kFailure, result);
+}
+
+// Create spans, let processor call Export()
+TEST_F(OtlpGrpcExporterTestPeer, ExportIntegrationTest)
+{
+  auto mock_stub = new proto::collector::trace::v1::MockTraceServiceStub();
+  std::unique_ptr<proto::collector::trace::v1::TraceService::StubInterface> stub_interface(
+      mock_stub);
+
+  auto exporter = GetExporter(stub_interface);
+
+  auto processor = std::unique_ptr<sdk::trace::SpanProcessor>(
+      new sdk::trace::SimpleSpanProcessor(std::move(exporter)));
+  auto provider = nostd::shared_ptr<trace::TracerProvider>(
+      new sdk::trace::TracerProvider(std::move(processor)));
+  auto tracer = provider->GetTracer("test");
+
+  EXPECT_CALL(*mock_stub, Export(_, _, _))
+      .Times(AtLeast(1))
+      .WillRepeatedly(Return(grpc::Status::OK));
+
+  auto parent_span = tracer->StartSpan("Test parent span");
+  auto child_span  = tracer->StartSpan("Test child span");
+  child_span->End();
+  parent_span->End();
+}
+
+// Test exporter configuration options
+TEST_F(OtlpGrpcExporterTestPeer, ConfigTest)
+{
+  OtlpGrpcExporterOptions opts;
+  opts.endpoint = "localhost:45454";
+  std::unique_ptr<OtlpGrpcExporter> exporter(new OtlpGrpcExporter(opts));
+  EXPECT_EQ(GetOptions(exporter).endpoint, "localhost:45454");
+}
+
+// Test exporter configuration options with use_ssl_credentials
+TEST_F(OtlpGrpcExporterTestPeer, ConfigSslCredentialsTest)
+{
+  std::string cacert_str = "--begin and end fake cert--";
+  OtlpGrpcExporterOptions opts;
+  opts.use_ssl_credentials              = true;
+  opts.ssl_credentials_cacert_as_string = cacert_str;
+  std::unique_ptr<OtlpGrpcExporter> exporter(new OtlpGrpcExporter(opts));
+  EXPECT_EQ(GetOptions(exporter).ssl_credentials_cacert_as_string, cacert_str);
+  EXPECT_EQ(GetOptions(exporter).use_ssl_credentials, true);
+}
+
+#  ifndef NO_GETENV
+// Test exporter configuration options with use_ssl_credentials
+TEST_F(OtlpGrpcExporterTestPeer, ConfigFromEnv)
+{
+  const std::string cacert_str = "--begin and end fake cert--";
+  setenv("OTEL_EXPORTER_OTLP_CERTIFICATE_STRING", cacert_str.c_str(), 1);
+  setenv("OTEL_EXPORTER_OTLP_SSL_ENABLE", "True", 1);
+  const std::string endpoint = "http://localhost:9999";
+  setenv("OTEL_EXPORTER_OTLP_ENDPOINT", endpoint.c_str(), 1);
+  setenv("OTEL_EXPORTER_OTLP_TIMEOUT", "20050ms", 1);
+  setenv("OTEL_EXPORTER_OTLP_HEADERS", "k1=v1,k2=v2", 1);
+  setenv("OTEL_EXPORTER_OTLP_TRACES_HEADERS", "k1=v3,k1=v4", 1);
+
+  std::unique_ptr<OtlpGrpcExporter> exporter(new OtlpGrpcExporter());
+  EXPECT_EQ(GetOptions(exporter).ssl_credentials_cacert_as_string, cacert_str);
+  EXPECT_EQ(GetOptions(exporter).use_ssl_credentials, true);
+  EXPECT_EQ(GetOptions(exporter).endpoint, endpoint);
+  EXPECT_EQ(GetOptions(exporter).timeout.count(),
+            std::chrono::duration_cast<std::chrono::system_clock::duration>(
+                std::chrono::milliseconds{20050})
+                .count());
+  EXPECT_EQ(GetOptions(exporter).metadata.size(), 3);
+  {
+    // Test k2
+    auto range = GetOptions(exporter).metadata.equal_range("k2");
+    EXPECT_TRUE(range.first != range.second);
+    EXPECT_EQ(range.first->second, std::string("v2"));
+    ++range.first;
+    EXPECT_TRUE(range.first == range.second);
+  }
+  {
+    // Test k1
+    auto range = GetOptions(exporter).metadata.equal_range("k1");
+    EXPECT_TRUE(range.first != range.second);
+    EXPECT_EQ(range.first->second, std::string("v3"));
+    ++range.first;
+    EXPECT_EQ(range.first->second, std::string("v4"));
+    ++range.first;
+    EXPECT_TRUE(range.first == range.second);
+  }
+
+  unsetenv("OTEL_EXPORTER_OTLP_ENDPOINT");
+  unsetenv("OTEL_EXPORTER_OTLP_CERTIFICATE_STRING");
+  unsetenv("OTEL_EXPORTER_OTLP_SSL_ENABLE");
+  unsetenv("OTEL_EXPORTER_OTLP_TIMEOUT");
+  unsetenv("OTEL_EXPORTER_OTLP_HEADERS");
+  unsetenv("OTEL_EXPORTER_OTLP_TRACES_HEADERS");
+}
+#  endif
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_grpc_log_exporter_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_grpc_log_exporter_test.cc
new file mode 100644
index 000000000..b60aac61a
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_grpc_log_exporter_test.cc
@@ -0,0 +1,163 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_LOGS_PREVIEW
+
+#  include "opentelemetry/exporters/otlp/otlp_grpc_log_exporter.h"
+
+#  include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+
+#  include "opentelemetry/proto/collector/logs/v1/logs_service_mock.grpc.pb.h"
+
+#  include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+
+#  include "opentelemetry/logs/provider.h"
+#  include "opentelemetry/sdk/logs/batch_log_processor.h"
+#  include "opentelemetry/sdk/logs/exporter.h"
+#  include "opentelemetry/sdk/logs/log_record.h"
+#  include "opentelemetry/sdk/logs/logger_provider.h"
+#  include "opentelemetry/sdk/resource/resource.h"
+
+#  include <gtest/gtest.h>
+
+#  if defined(_MSC_VER)
+#    include "opentelemetry/sdk/common/env_variables.h"
+using opentelemetry::sdk::common::setenv;
+using opentelemetry::sdk::common::unsetenv;
+#  endif
+
+using namespace testing;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+class OtlpGrpcLogExporterTestPeer : public ::testing::Test
+{
+public:
+  std::unique_ptr<sdk::logs::LogExporter> GetExporter(
+      std::unique_ptr<proto::collector::logs::v1::LogsService::StubInterface> &stub_interface)
+  {
+    return std::unique_ptr<sdk::logs::LogExporter>(
+        new OtlpGrpcLogExporter(std::move(stub_interface)));
+  }
+
+  // Get the options associated with the given exporter.
+  const OtlpGrpcExporterOptions &GetOptions(std::unique_ptr<OtlpGrpcLogExporter> &exporter)
+  {
+    return exporter->options_;
+  }
+};
+
+TEST_F(OtlpGrpcLogExporterTestPeer, ShutdownTest)
+{
+  auto mock_stub = new proto::collector::logs::v1::MockLogsServiceStub();
+  std::unique_ptr<proto::collector::logs::v1::LogsService::StubInterface> stub_interface(mock_stub);
+  auto exporter = GetExporter(stub_interface);
+
+  auto recordable_1 = exporter->MakeRecordable();
+  auto recordable_2 = exporter->MakeRecordable();
+
+  // exporter shuold not be shutdown by default
+  nostd::span<std::unique_ptr<sdk::logs::Recordable>> batch_1(&recordable_1, 1);
+  EXPECT_CALL(*mock_stub, Export(_, _, _))
+      .Times(Exactly(1))
+      .WillOnce(Return(grpc::Status::OK))
+      .WillOnce(Return(grpc::Status::CANCELLED));
+
+  auto result = exporter->Export(batch_1);
+  EXPECT_EQ(sdk::common::ExportResult::kSuccess, result);
+
+  exporter->Shutdown();
+
+  nostd::span<std::unique_ptr<sdk::logs::Recordable>> batch_2(&recordable_2, 1);
+  result = exporter->Export(batch_2);
+  EXPECT_EQ(sdk::common::ExportResult::kFailure, result);
+}
+
+// Call Export() directly
+TEST_F(OtlpGrpcLogExporterTestPeer, ExportUnitTest)
+{
+  auto mock_stub = new proto::collector::logs::v1::MockLogsServiceStub();
+  std::unique_ptr<proto::collector::logs::v1::LogsService::StubInterface> stub_interface(mock_stub);
+  auto exporter = GetExporter(stub_interface);
+
+  auto recordable_1 = exporter->MakeRecordable();
+  auto recordable_2 = exporter->MakeRecordable();
+
+  // Test successful RPC
+  nostd::span<std::unique_ptr<sdk::logs::Recordable>> batch_1(&recordable_1, 1);
+  EXPECT_CALL(*mock_stub, Export(_, _, _)).Times(Exactly(1)).WillOnce(Return(grpc::Status::OK));
+  auto result = exporter->Export(batch_1);
+  EXPECT_EQ(sdk::common::ExportResult::kSuccess, result);
+
+  // Test failed RPC
+  nostd::span<std::unique_ptr<sdk::logs::Recordable>> batch_2(&recordable_2, 1);
+  EXPECT_CALL(*mock_stub, Export(_, _, _))
+      .Times(Exactly(1))
+      .WillOnce(Return(grpc::Status::CANCELLED));
+  result = exporter->Export(batch_2);
+  EXPECT_EQ(sdk::common::ExportResult::kFailure, result);
+}
+
+// Create spans, let processor call Export()
+TEST_F(OtlpGrpcLogExporterTestPeer, ExportIntegrationTest)
+{
+  auto mock_stub = new proto::collector::logs::v1::MockLogsServiceStub();
+  std::unique_ptr<proto::collector::logs::v1::LogsService::StubInterface> stub_interface(mock_stub);
+
+  auto exporter = GetExporter(stub_interface);
+
+  bool attribute_storage_bool_value[]          = {true, false, true};
+  int32_t attribute_storage_int32_value[]      = {1, 2};
+  uint32_t attribute_storage_uint32_value[]    = {3, 4};
+  int64_t attribute_storage_int64_value[]      = {5, 6};
+  uint64_t attribute_storage_uint64_value[]    = {7, 8};
+  double attribute_storage_double_value[]      = {3.2, 3.3};
+  std::string attribute_storage_string_value[] = {"vector", "string"};
+
+  auto provider = nostd::shared_ptr<sdk::logs::LoggerProvider>(new sdk::logs::LoggerProvider());
+  provider->AddProcessor(std::unique_ptr<sdk::logs::LogProcessor>(
+      new sdk::logs::BatchLogProcessor(std::move(exporter), 5, std::chrono::milliseconds(256), 1)));
+
+  EXPECT_CALL(*mock_stub, Export(_, _, _))
+      .Times(AtLeast(1))
+      .WillRepeatedly(Return(grpc::Status::OK));
+
+  uint8_t trace_id_bin[opentelemetry::trace::TraceId::kSize] = {
+      '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+  opentelemetry::trace::TraceId trace_id{trace_id_bin};
+  uint8_t span_id_bin[opentelemetry::trace::SpanId::kSize] = {'7', '6', '5', '4',
+                                                              '3', '2', '1', '0'};
+  opentelemetry::trace::SpanId span_id{span_id_bin};
+
+  const std::string schema_url{"https://opentelemetry.io/schemas/1.11.0"};
+  auto logger = provider->GetLogger("test", "", "opentelelemtry_library", "", schema_url);
+  logger->Log(opentelemetry::logs::Severity::kInfo, "Log message",
+              {{"service.name", "unit_test_service"},
+               {"tenant.id", "test_user"},
+               {"bool_value", true},
+               {"int32_value", static_cast<int32_t>(1)},
+               {"uint32_value", static_cast<uint32_t>(2)},
+               {"int64_value", static_cast<int64_t>(0x1100000000LL)},
+               {"uint64_value", static_cast<uint64_t>(0x1200000000ULL)},
+               {"double_value", static_cast<double>(3.1)},
+               {"vec_bool_value", attribute_storage_bool_value},
+               {"vec_int32_value", attribute_storage_int32_value},
+               {"vec_uint32_value", attribute_storage_uint32_value},
+               {"vec_int64_value", attribute_storage_int64_value},
+               {"vec_uint64_value", attribute_storage_uint64_value},
+               {"vec_double_value", attribute_storage_double_value},
+               {"vec_string_value", attribute_storage_string_value}},
+              trace_id, span_id,
+              opentelemetry::trace::TraceFlags{opentelemetry::trace::TraceFlags::kIsSampled},
+              std::chrono::system_clock::now());
+}
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+
+#endif  // ENABLE_LOGS_PREVIEW
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_http_exporter_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_http_exporter_test.cc
new file mode 100644
index 000000000..ef0b5a509
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_http_exporter_test.cc
@@ -0,0 +1,357 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef HAVE_CPP_STDLIB
+
+#  include "opentelemetry/exporters/otlp/otlp_http_exporter.h"
+
+#  include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+
+#  include "opentelemetry/proto/collector/trace/v1/trace_service.pb.h"
+
+#  include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+
+#  include "opentelemetry/ext/http/client/http_client_factory.h"
+#  include "opentelemetry/ext/http/client/nosend/http_client_nosend.h"
+#  include "opentelemetry/ext/http/server/http_server.h"
+#  include "opentelemetry/sdk/trace/batch_span_processor.h"
+#  include "opentelemetry/sdk/trace/tracer_provider.h"
+#  include "opentelemetry/trace/provider.h"
+
+#  include <gtest/gtest.h>
+#  include "gmock/gmock.h"
+
+#  include "nlohmann/json.hpp"
+
+#  if defined(_MSC_VER)
+#    include "opentelemetry/sdk/common/env_variables.h"
+using opentelemetry::sdk::common::setenv;
+using opentelemetry::sdk::common::unsetenv;
+#  endif
+using namespace testing;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+namespace trace_api = opentelemetry::trace;
+namespace resource  = opentelemetry::sdk::resource;
+
+template <class T, size_t N>
+static nostd::span<T, N> MakeSpan(T (&array)[N])
+{
+  return nostd::span<T, N>(array);
+}
+
+OtlpHttpClientOptions MakeOtlpHttpClientOptions(HttpRequestContentType content_type)
+{
+  OtlpHttpExporterOptions options;
+  options.content_type  = content_type;
+  options.console_debug = true;
+  options.timeout       = std::chrono::system_clock::duration::zero();
+  options.http_headers.insert(
+      std::make_pair<const std::string, std::string>("Custom-Header-Key", "Custom-Header-Value"));
+  OtlpHttpClientOptions otlp_http_client_options(
+      options.url, options.content_type, options.json_bytes_mapping, options.use_json_name,
+      options.console_debug, options.timeout, options.http_headers);
+  return otlp_http_client_options;
+}
+
+namespace http_client = opentelemetry::ext::http::client;
+
+class OtlpHttpExporterTestPeer : public ::testing::Test
+{
+public:
+  std::unique_ptr<sdk::trace::SpanExporter> GetExporter(std::unique_ptr<OtlpHttpClient> http_client)
+  {
+    return std::unique_ptr<sdk::trace::SpanExporter>(new OtlpHttpExporter(std::move(http_client)));
+  }
+
+  // Get the options associated with the given exporter.
+  const OtlpHttpExporterOptions &GetOptions(std::unique_ptr<OtlpHttpExporter> &exporter)
+  {
+    return exporter->options_;
+  }
+
+  static std::pair<OtlpHttpClient *, std::shared_ptr<http_client::HttpClient>>
+  GetMockOtlpHttpClient(HttpRequestContentType content_type)
+  {
+    auto http_client = http_client::HttpClientFactory::CreateNoSend();
+    return {new OtlpHttpClient(MakeOtlpHttpClientOptions(content_type), http_client), http_client};
+  }
+};
+
+// Create spans, let processor call Export()
+TEST_F(OtlpHttpExporterTestPeer, ExportJsonIntegrationTest)
+{
+  auto mock_otlp_client =
+      OtlpHttpExporterTestPeer::GetMockOtlpHttpClient(HttpRequestContentType::kJson);
+  auto mock_otlp_http_client = mock_otlp_client.first;
+  auto client                = mock_otlp_client.second;
+  auto exporter              = GetExporter(std::unique_ptr<OtlpHttpClient>{mock_otlp_http_client});
+
+  resource::ResourceAttributes resource_attributes = {{"service.name", "unit_test_service"},
+                                                      {"tenant.id", "test_user"}};
+  resource_attributes["bool_value"]                = true;
+  resource_attributes["int32_value"]               = static_cast<int32_t>(1);
+  resource_attributes["uint32_value"]              = static_cast<uint32_t>(2);
+  resource_attributes["int64_value"]               = static_cast<int64_t>(0x1100000000LL);
+  resource_attributes["uint64_value"]              = static_cast<uint64_t>(0x1200000000ULL);
+  resource_attributes["double_value"]              = static_cast<double>(3.1);
+  resource_attributes["vec_bool_value"]            = std::vector<bool>{true, false, true};
+  resource_attributes["vec_int32_value"]           = std::vector<int32_t>{1, 2};
+  resource_attributes["vec_uint32_value"]          = std::vector<uint32_t>{3, 4};
+  resource_attributes["vec_int64_value"]           = std::vector<int64_t>{5, 6};
+  resource_attributes["vec_uint64_value"]          = std::vector<uint64_t>{7, 8};
+  resource_attributes["vec_double_value"]          = std::vector<double>{3.2, 3.3};
+  resource_attributes["vec_string_value"]          = std::vector<std::string>{"vector", "string"};
+  auto resource = resource::Resource::Create(resource_attributes);
+
+  auto processor_opts                  = sdk::trace::BatchSpanProcessorOptions();
+  processor_opts.max_export_batch_size = 5;
+  processor_opts.max_queue_size        = 5;
+  processor_opts.schedule_delay_millis = std::chrono::milliseconds(256);
+  auto processor                       = std::unique_ptr<sdk::trace::SpanProcessor>(
+      new sdk::trace::BatchSpanProcessor(std::move(exporter), processor_opts));
+  auto provider = nostd::shared_ptr<trace::TracerProvider>(
+      new sdk::trace::TracerProvider(std::move(processor), resource));
+
+  std::string report_trace_id;
+
+  char trace_id_hex[2 * trace_api::TraceId::kSize] = {0};
+  auto tracer                                      = provider->GetTracer("test");
+  auto parent_span                                 = tracer->StartSpan("Test parent span");
+
+  trace_api::StartSpanOptions child_span_opts = {};
+  child_span_opts.parent                      = parent_span->GetContext();
+
+  auto child_span = tracer->StartSpan("Test child span", child_span_opts);
+
+  nostd::get<trace_api::SpanContext>(child_span_opts.parent)
+      .trace_id()
+      .ToLowerBase16(MakeSpan(trace_id_hex));
+  report_trace_id.assign(trace_id_hex, sizeof(trace_id_hex));
+
+  auto no_send_client = std::static_pointer_cast<http_client::nosend::HttpClient>(client);
+  auto mock_session =
+      std::static_pointer_cast<http_client::nosend::Session>(no_send_client->session_);
+  EXPECT_CALL(*mock_session, SendRequest)
+      .WillOnce([&mock_session,
+                 report_trace_id](opentelemetry::ext::http::client::EventHandler &callback) {
+        auto check_json = nlohmann::json::parse(mock_session->GetRequest()->body_, nullptr, false);
+        auto resource_span                = *check_json["resource_spans"].begin();
+        auto instrumentation_library_span = *resource_span["instrumentation_library_spans"].begin();
+        auto span                         = *instrumentation_library_span["spans"].begin();
+        auto received_trace_id            = span["trace_id"].get<std::string>();
+        EXPECT_EQ(received_trace_id, report_trace_id);
+
+        auto custom_header = mock_session->GetRequest()->headers_.find("Custom-Header-Key");
+        ASSERT_TRUE(custom_header != mock_session->GetRequest()->headers_.end());
+        if (custom_header != mock_session->GetRequest()->headers_.end())
+        {
+          EXPECT_EQ("Custom-Header-Value", custom_header->second);
+        }
+        // let the otlp_http_client to continue
+        http_client::nosend::Response response;
+        callback.OnResponse(response);
+      });
+
+  child_span->End();
+  parent_span->End();
+}
+
+// Create spans, let processor call Export()
+TEST_F(OtlpHttpExporterTestPeer, ExportBinaryIntegrationTest)
+{
+  auto mock_otlp_client =
+      OtlpHttpExporterTestPeer::GetMockOtlpHttpClient(HttpRequestContentType::kBinary);
+  auto mock_otlp_http_client = mock_otlp_client.first;
+  auto client                = mock_otlp_client.second;
+  auto exporter              = GetExporter(std::unique_ptr<OtlpHttpClient>{mock_otlp_http_client});
+
+  resource::ResourceAttributes resource_attributes = {{"service.name", "unit_test_service"},
+                                                      {"tenant.id", "test_user"}};
+  resource_attributes["bool_value"]                = true;
+  resource_attributes["int32_value"]               = static_cast<int32_t>(1);
+  resource_attributes["uint32_value"]              = static_cast<uint32_t>(2);
+  resource_attributes["int64_value"]               = static_cast<int64_t>(0x1100000000LL);
+  resource_attributes["uint64_value"]              = static_cast<uint64_t>(0x1200000000ULL);
+  resource_attributes["double_value"]              = static_cast<double>(3.1);
+  resource_attributes["vec_bool_value"]            = std::vector<bool>{true, false, true};
+  resource_attributes["vec_int32_value"]           = std::vector<int32_t>{1, 2};
+  resource_attributes["vec_uint32_value"]          = std::vector<uint32_t>{3, 4};
+  resource_attributes["vec_int64_value"]           = std::vector<int64_t>{5, 6};
+  resource_attributes["vec_uint64_value"]          = std::vector<uint64_t>{7, 8};
+  resource_attributes["vec_double_value"]          = std::vector<double>{3.2, 3.3};
+  resource_attributes["vec_string_value"]          = std::vector<std::string>{"vector", "string"};
+  auto resource = resource::Resource::Create(resource_attributes);
+
+  auto processor_opts                  = sdk::trace::BatchSpanProcessorOptions();
+  processor_opts.max_export_batch_size = 5;
+  processor_opts.max_queue_size        = 5;
+  processor_opts.schedule_delay_millis = std::chrono::milliseconds(256);
+
+  auto processor = std::unique_ptr<sdk::trace::SpanProcessor>(
+      new sdk::trace::BatchSpanProcessor(std::move(exporter), processor_opts));
+  auto provider = nostd::shared_ptr<trace::TracerProvider>(
+      new sdk::trace::TracerProvider(std::move(processor), resource));
+
+  std::string report_trace_id;
+
+  uint8_t trace_id_binary[trace_api::TraceId::kSize] = {0};
+  auto tracer                                        = provider->GetTracer("test");
+  auto parent_span                                   = tracer->StartSpan("Test parent span");
+
+  trace_api::StartSpanOptions child_span_opts = {};
+  child_span_opts.parent                      = parent_span->GetContext();
+
+  auto child_span = tracer->StartSpan("Test child span", child_span_opts);
+  nostd::get<trace_api::SpanContext>(child_span_opts.parent)
+      .trace_id()
+      .CopyBytesTo(MakeSpan(trace_id_binary));
+  report_trace_id.assign(reinterpret_cast<char *>(trace_id_binary), sizeof(trace_id_binary));
+
+  auto no_send_client = std::static_pointer_cast<http_client::nosend::HttpClient>(client);
+  auto mock_session =
+      std::static_pointer_cast<http_client::nosend::Session>(no_send_client->session_);
+  EXPECT_CALL(*mock_session, SendRequest)
+      .WillOnce([&mock_session,
+                 report_trace_id](opentelemetry::ext::http::client::EventHandler &callback) {
+        opentelemetry::proto::collector::trace::v1::ExportTraceServiceRequest request_body;
+        request_body.ParseFromArray(&mock_session->GetRequest()->body_[0],
+                                    static_cast<int>(mock_session->GetRequest()->body_.size()));
+        auto received_trace_id =
+            request_body.resource_spans(0).instrumentation_library_spans(0).spans(0).trace_id();
+        EXPECT_EQ(received_trace_id, report_trace_id);
+
+        auto custom_header = mock_session->GetRequest()->headers_.find("Custom-Header-Key");
+        ASSERT_TRUE(custom_header != mock_session->GetRequest()->headers_.end());
+        if (custom_header != mock_session->GetRequest()->headers_.end())
+        {
+          EXPECT_EQ("Custom-Header-Value", custom_header->second);
+        }
+        // let the otlp_http_client to continue
+        http_client::nosend::Response response;
+        callback.OnResponse(response);
+      });
+
+  child_span->End();
+  parent_span->End();
+}
+
+// Test exporter configuration options
+TEST_F(OtlpHttpExporterTestPeer, ConfigTest)
+{
+  OtlpHttpExporterOptions opts;
+  opts.url = "http://localhost:45455/v1/traces";
+  std::unique_ptr<OtlpHttpExporter> exporter(new OtlpHttpExporter(opts));
+  EXPECT_EQ(GetOptions(exporter).url, "http://localhost:45455/v1/traces");
+}
+
+// Test exporter configuration options with use_json_name
+TEST_F(OtlpHttpExporterTestPeer, ConfigUseJsonNameTest)
+{
+  OtlpHttpExporterOptions opts;
+  opts.use_json_name = true;
+  std::unique_ptr<OtlpHttpExporter> exporter(new OtlpHttpExporter(opts));
+  EXPECT_EQ(GetOptions(exporter).use_json_name, true);
+}
+
+// Test exporter configuration options with json_bytes_mapping=JsonBytesMappingKind::kHex
+TEST_F(OtlpHttpExporterTestPeer, ConfigJsonBytesMappingTest)
+{
+  OtlpHttpExporterOptions opts;
+  opts.json_bytes_mapping = JsonBytesMappingKind::kHex;
+  std::unique_ptr<OtlpHttpExporter> exporter(new OtlpHttpExporter(opts));
+  EXPECT_EQ(GetOptions(exporter).json_bytes_mapping, JsonBytesMappingKind::kHex);
+}
+
+#  ifndef NO_GETENV
+// Test exporter configuration options with use_ssl_credentials
+TEST_F(OtlpHttpExporterTestPeer, ConfigFromEnv)
+{
+  const std::string url = "http://localhost:9999/v1/traces";
+  setenv("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:9999", 1);
+  setenv("OTEL_EXPORTER_OTLP_TIMEOUT", "20s", 1);
+  setenv("OTEL_EXPORTER_OTLP_HEADERS", "k1=v1,k2=v2", 1);
+  setenv("OTEL_EXPORTER_OTLP_TRACES_HEADERS", "k1=v3,k1=v4", 1);
+
+  std::unique_ptr<OtlpHttpExporter> exporter(new OtlpHttpExporter());
+  EXPECT_EQ(GetOptions(exporter).url, url);
+  EXPECT_EQ(
+      GetOptions(exporter).timeout.count(),
+      std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::seconds{20})
+          .count());
+  EXPECT_EQ(GetOptions(exporter).http_headers.size(), 3);
+  {
+    // Test k2
+    auto range = GetOptions(exporter).http_headers.equal_range("k2");
+    EXPECT_TRUE(range.first != range.second);
+    EXPECT_EQ(range.first->second, std::string("v2"));
+    ++range.first;
+    EXPECT_TRUE(range.first == range.second);
+  }
+  {
+    // k1
+    auto range = GetOptions(exporter).http_headers.equal_range("k1");
+    EXPECT_TRUE(range.first != range.second);
+    EXPECT_EQ(range.first->second, std::string("v3"));
+    ++range.first;
+    EXPECT_EQ(range.first->second, std::string("v4"));
+    ++range.first;
+    EXPECT_TRUE(range.first == range.second);
+  }
+
+  unsetenv("OTEL_EXPORTER_OTLP_ENDPOINT");
+  unsetenv("OTEL_EXPORTER_OTLP_TIMEOUT");
+  unsetenv("OTEL_EXPORTER_OTLP_HEADERS");
+  unsetenv("OTEL_EXPORTER_OTLP_TRACES_HEADERS");
+}
+
+TEST_F(OtlpHttpExporterTestPeer, ConfigFromTracesEnv)
+{
+  const std::string url = "http://localhost:9999/v1/traces";
+  setenv("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT", url.c_str(), 1);
+  setenv("OTEL_EXPORTER_OTLP_TIMEOUT", "20s", 1);
+  setenv("OTEL_EXPORTER_OTLP_HEADERS", "k1=v1,k2=v2", 1);
+  setenv("OTEL_EXPORTER_OTLP_TRACES_HEADERS", "k1=v3,k1=v4", 1);
+
+  std::unique_ptr<OtlpHttpExporter> exporter(new OtlpHttpExporter());
+  EXPECT_EQ(GetOptions(exporter).url, url);
+  EXPECT_EQ(
+      GetOptions(exporter).timeout.count(),
+      std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::seconds{20})
+          .count());
+  EXPECT_EQ(GetOptions(exporter).http_headers.size(), 3);
+  {
+    // Test k2
+    auto range = GetOptions(exporter).http_headers.equal_range("k2");
+    EXPECT_TRUE(range.first != range.second);
+    EXPECT_EQ(range.first->second, std::string("v2"));
+    ++range.first;
+    EXPECT_TRUE(range.first == range.second);
+  }
+  {
+    // k1
+    auto range = GetOptions(exporter).http_headers.equal_range("k1");
+    EXPECT_TRUE(range.first != range.second);
+    EXPECT_EQ(range.first->second, std::string("v3"));
+    ++range.first;
+    EXPECT_EQ(range.first->second, std::string("v4"));
+    ++range.first;
+    EXPECT_TRUE(range.first == range.second);
+  }
+
+  unsetenv("OTEL_EXPORTER_OTLP_TRACES_ENDPOINT");
+  unsetenv("OTEL_EXPORTER_OTLP_TIMEOUT");
+  unsetenv("OTEL_EXPORTER_OTLP_HEADERS");
+  unsetenv("OTEL_EXPORTER_OTLP_TRACES_HEADERS");
+}
+#  endif
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_http_log_exporter_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_http_log_exporter_test.cc
new file mode 100644
index 000000000..7e2c0808e
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_http_log_exporter_test.cc
@@ -0,0 +1,381 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef HAVE_CPP_STDLIB
+#  ifdef ENABLE_LOGS_PREVIEW
+
+#    include "opentelemetry/exporters/otlp/otlp_http_log_exporter.h"
+
+#    include "opentelemetry/exporters/otlp/protobuf_include_prefix.h"
+
+#    include "opentelemetry/proto/collector/logs/v1/logs_service.pb.h"
+
+#    include "opentelemetry/exporters/otlp/protobuf_include_suffix.h"
+
+#    include "opentelemetry/common/key_value_iterable_view.h"
+#    include "opentelemetry/ext/http/client/http_client_factory.h"
+#    include "opentelemetry/ext/http/client/nosend/http_client_nosend.h"
+#    include "opentelemetry/ext/http/server/http_server.h"
+#    include "opentelemetry/logs/provider.h"
+#    include "opentelemetry/sdk/logs/batch_log_processor.h"
+#    include "opentelemetry/sdk/logs/exporter.h"
+#    include "opentelemetry/sdk/logs/log_record.h"
+#    include "opentelemetry/sdk/logs/logger_provider.h"
+#    include "opentelemetry/sdk/resource/resource.h"
+
+#    include <gtest/gtest.h>
+#    include "gmock/gmock.h"
+
+#    include "nlohmann/json.hpp"
+
+#    if defined(_MSC_VER)
+#      include "opentelemetry/sdk/common/env_variables.h"
+using opentelemetry::sdk::common::setenv;
+using opentelemetry::sdk::common::unsetenv;
+#    endif
+
+using namespace testing;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+
+template <class T, size_t N>
+static nostd::span<T, N> MakeSpan(T (&array)[N])
+{
+  return nostd::span<T, N>(array);
+}
+
+OtlpHttpClientOptions MakeOtlpHttpClientOptions(HttpRequestContentType content_type)
+{
+  OtlpHttpLogExporterOptions options;
+  options.content_type  = content_type;
+  options.console_debug = true;
+  options.http_headers.insert(
+      std::make_pair<const std::string, std::string>("Custom-Header-Key", "Custom-Header-Value"));
+  OtlpHttpClientOptions otlp_http_client_options(
+      options.url, options.content_type, options.json_bytes_mapping, options.use_json_name,
+      options.console_debug, options.timeout, options.http_headers);
+  return otlp_http_client_options;
+}
+
+namespace http_client = opentelemetry::ext::http::client;
+
+class OtlpHttpLogExporterTestPeer : public ::testing::Test
+{
+public:
+  std::unique_ptr<sdk::logs::LogExporter> GetExporter(std::unique_ptr<OtlpHttpClient> http_client)
+  {
+    return std::unique_ptr<sdk::logs::LogExporter>(new OtlpHttpLogExporter(std::move(http_client)));
+  }
+
+  // Get the options associated with the given exporter.
+  const OtlpHttpLogExporterOptions &GetOptions(std::unique_ptr<OtlpHttpLogExporter> &exporter)
+  {
+    return exporter->options_;
+  }
+  static std::pair<OtlpHttpClient *, std::shared_ptr<http_client::HttpClient>>
+  GetMockOtlpHttpClient(HttpRequestContentType content_type)
+  {
+    auto http_client = http_client::HttpClientFactory::CreateNoSend();
+    return {new OtlpHttpClient(MakeOtlpHttpClientOptions(content_type), http_client), http_client};
+  }
+};
+
+// Create log records, let processor call Export()
+TEST_F(OtlpHttpLogExporterTestPeer, ExportJsonIntegrationTest)
+{
+  auto mock_otlp_client =
+      OtlpHttpLogExporterTestPeer::GetMockOtlpHttpClient(HttpRequestContentType::kJson);
+  auto mock_otlp_http_client = mock_otlp_client.first;
+  auto client                = mock_otlp_client.second;
+  auto exporter              = GetExporter(std::unique_ptr<OtlpHttpClient>{mock_otlp_http_client});
+
+  bool attribute_storage_bool_value[]          = {true, false, true};
+  int32_t attribute_storage_int32_value[]      = {1, 2};
+  uint32_t attribute_storage_uint32_value[]    = {3, 4};
+  int64_t attribute_storage_int64_value[]      = {5, 6};
+  uint64_t attribute_storage_uint64_value[]    = {7, 8};
+  double attribute_storage_double_value[]      = {3.2, 3.3};
+  std::string attribute_storage_string_value[] = {"vector", "string"};
+
+  auto provider = nostd::shared_ptr<sdk::logs::LoggerProvider>(new sdk::logs::LoggerProvider());
+  provider->AddProcessor(std::unique_ptr<sdk::logs::LogProcessor>(
+      new sdk::logs::BatchLogProcessor(std::move(exporter), 5, std::chrono::milliseconds(256), 5)));
+
+  std::string report_trace_id;
+  std::string report_span_id;
+  uint8_t trace_id_bin[opentelemetry::trace::TraceId::kSize] = {
+      '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+  char trace_id_hex[2 * opentelemetry::trace::TraceId::kSize] = {0};
+  opentelemetry::trace::TraceId trace_id{trace_id_bin};
+  uint8_t span_id_bin[opentelemetry::trace::SpanId::kSize]  = {'7', '6', '5', '4',
+                                                              '3', '2', '1', '0'};
+  char span_id_hex[2 * opentelemetry::trace::SpanId::kSize] = {0};
+  opentelemetry::trace::SpanId span_id{span_id_bin};
+
+  const std::string schema_url{"https://opentelemetry.io/schemas/1.2.0"};
+  auto logger = provider->GetLogger("test", "", "opentelelemtry_library", "", schema_url);
+  logger->Log(opentelemetry::logs::Severity::kInfo, "Log message",
+              {{"service.name", "unit_test_service"},
+               {"tenant.id", "test_user"},
+               {"bool_value", true},
+               {"int32_value", static_cast<int32_t>(1)},
+               {"uint32_value", static_cast<uint32_t>(2)},
+               {"int64_value", static_cast<int64_t>(0x1100000000LL)},
+               {"uint64_value", static_cast<uint64_t>(0x1200000000ULL)},
+               {"double_value", static_cast<double>(3.1)},
+               {"vec_bool_value", attribute_storage_bool_value},
+               {"vec_int32_value", attribute_storage_int32_value},
+               {"vec_uint32_value", attribute_storage_uint32_value},
+               {"vec_int64_value", attribute_storage_int64_value},
+               {"vec_uint64_value", attribute_storage_uint64_value},
+               {"vec_double_value", attribute_storage_double_value},
+               {"vec_string_value", attribute_storage_string_value}},
+              trace_id, span_id,
+              opentelemetry::trace::TraceFlags{opentelemetry::trace::TraceFlags::kIsSampled},
+              std::chrono::system_clock::now());
+
+  trace_id.ToLowerBase16(MakeSpan(trace_id_hex));
+  report_trace_id.assign(trace_id_hex, sizeof(trace_id_hex));
+
+  span_id.ToLowerBase16(MakeSpan(span_id_hex));
+  report_span_id.assign(span_id_hex, sizeof(span_id_hex));
+
+  auto no_send_client = std::static_pointer_cast<http_client::nosend::HttpClient>(client);
+  auto mock_session =
+      std::static_pointer_cast<http_client::nosend::Session>(no_send_client->session_);
+  EXPECT_CALL(*mock_session, SendRequest)
+      .WillOnce([&mock_session, report_trace_id,
+                 report_span_id](opentelemetry::ext::http::client::EventHandler &callback) {
+        auto check_json = nlohmann::json::parse(mock_session->GetRequest()->body_, nullptr, false);
+        auto resource_logs     = *check_json["resource_logs"].begin();
+        auto scope_logs        = *resource_logs["scope_logs"].begin();
+        auto log               = *scope_logs["log_records"].begin();
+        auto received_trace_id = log["trace_id"].get<std::string>();
+        auto received_span_id  = log["span_id"].get<std::string>();
+        EXPECT_EQ(received_trace_id, report_trace_id);
+        EXPECT_EQ(received_span_id, report_span_id);
+        EXPECT_EQ("Log message", log["body"]["string_value"].get<std::string>());
+        EXPECT_LE(15, log["attributes"].size());
+        auto custom_header = mock_session->GetRequest()->headers_.find("Custom-Header-Key");
+        ASSERT_TRUE(custom_header != mock_session->GetRequest()->headers_.end());
+        if (custom_header != mock_session->GetRequest()->headers_.end())
+        {
+          EXPECT_EQ("Custom-Header-Value", custom_header->second);
+        }
+        // let the otlp_http_client to continue
+        http_client::nosend::Response response;
+        callback.OnResponse(response);
+      });
+}
+
+// Create log records, let processor call Export()
+TEST_F(OtlpHttpLogExporterTestPeer, ExportBinaryIntegrationTest)
+{
+  auto mock_otlp_client =
+      OtlpHttpLogExporterTestPeer::GetMockOtlpHttpClient(HttpRequestContentType::kBinary);
+  auto mock_otlp_http_client = mock_otlp_client.first;
+  auto client                = mock_otlp_client.second;
+  auto exporter              = GetExporter(std::unique_ptr<OtlpHttpClient>{mock_otlp_http_client});
+
+  bool attribute_storage_bool_value[]          = {true, false, true};
+  int32_t attribute_storage_int32_value[]      = {1, 2};
+  uint32_t attribute_storage_uint32_value[]    = {3, 4};
+  int64_t attribute_storage_int64_value[]      = {5, 6};
+  uint64_t attribute_storage_uint64_value[]    = {7, 8};
+  double attribute_storage_double_value[]      = {3.2, 3.3};
+  std::string attribute_storage_string_value[] = {"vector", "string"};
+
+  auto provider = nostd::shared_ptr<sdk::logs::LoggerProvider>(new sdk::logs::LoggerProvider());
+  provider->AddProcessor(std::unique_ptr<sdk::logs::LogProcessor>(
+      new sdk::logs::BatchLogProcessor(std::move(exporter), 5, std::chrono::milliseconds(256), 5)));
+
+  std::string report_trace_id;
+  std::string report_span_id;
+  uint8_t trace_id_bin[opentelemetry::trace::TraceId::kSize] = {
+      '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+  opentelemetry::trace::TraceId trace_id{trace_id_bin};
+  uint8_t span_id_bin[opentelemetry::trace::SpanId::kSize] = {'7', '6', '5', '4',
+                                                              '3', '2', '1', '0'};
+  opentelemetry::trace::SpanId span_id{span_id_bin};
+
+  const std::string schema_url{"https://opentelemetry.io/schemas/1.2.0"};
+  auto logger = provider->GetLogger("test", "", "opentelelemtry_library", "", schema_url);
+  logger->Log(opentelemetry::logs::Severity::kInfo, "Log message",
+              {{"service.name", "unit_test_service"},
+               {"tenant.id", "test_user"},
+               {"bool_value", true},
+               {"int32_value", static_cast<int32_t>(1)},
+               {"uint32_value", static_cast<uint32_t>(2)},
+               {"int64_value", static_cast<int64_t>(0x1100000000LL)},
+               {"uint64_value", static_cast<uint64_t>(0x1200000000ULL)},
+               {"double_value", static_cast<double>(3.1)},
+               {"vec_bool_value", attribute_storage_bool_value},
+               {"vec_int32_value", attribute_storage_int32_value},
+               {"vec_uint32_value", attribute_storage_uint32_value},
+               {"vec_int64_value", attribute_storage_int64_value},
+               {"vec_uint64_value", attribute_storage_uint64_value},
+               {"vec_double_value", attribute_storage_double_value},
+               {"vec_string_value", attribute_storage_string_value}},
+              trace_id, span_id,
+              opentelemetry::trace::TraceFlags{opentelemetry::trace::TraceFlags::kIsSampled},
+              std::chrono::system_clock::now());
+
+  report_trace_id.assign(reinterpret_cast<const char *>(trace_id_bin), sizeof(trace_id_bin));
+  report_span_id.assign(reinterpret_cast<const char *>(span_id_bin), sizeof(span_id_bin));
+
+  auto no_send_client = std::static_pointer_cast<http_client::nosend::HttpClient>(client);
+  auto mock_session =
+      std::static_pointer_cast<http_client::nosend::Session>(no_send_client->session_);
+  EXPECT_CALL(*mock_session, SendRequest)
+      .WillOnce([&mock_session, report_trace_id,
+                 report_span_id](opentelemetry::ext::http::client::EventHandler &callback) {
+        opentelemetry::proto::collector::logs::v1::ExportLogsServiceRequest request_body;
+        request_body.ParseFromArray(&mock_session->GetRequest()->body_[0],
+                                    static_cast<int>(mock_session->GetRequest()->body_.size()));
+        auto &received_log = request_body.resource_logs(0).scope_logs(0).log_records(0);
+        EXPECT_EQ(received_log.trace_id(), report_trace_id);
+        EXPECT_EQ(received_log.span_id(), report_span_id);
+        EXPECT_EQ("Log message", received_log.body().string_value());
+        EXPECT_LE(15, received_log.attributes_size());
+        bool check_service_name = false;
+        for (auto &attribute : received_log.attributes())
+        {
+          if ("service.name" == attribute.key())
+          {
+            check_service_name = true;
+            EXPECT_EQ("unit_test_service", attribute.value().string_value());
+          }
+        }
+        ASSERT_TRUE(check_service_name);
+        http_client::nosend::Response response;
+        callback.OnResponse(response);
+      });
+}
+
+// Test exporter configuration options
+TEST_F(OtlpHttpLogExporterTestPeer, ConfigTest)
+{
+  OtlpHttpLogExporterOptions opts;
+  opts.url = "http://localhost:45456/v1/logs";
+  std::unique_ptr<OtlpHttpLogExporter> exporter(new OtlpHttpLogExporter(opts));
+  EXPECT_EQ(GetOptions(exporter).url, "http://localhost:45456/v1/logs");
+}
+
+// Test exporter configuration options with use_json_name
+TEST_F(OtlpHttpLogExporterTestPeer, ConfigUseJsonNameTest)
+{
+  OtlpHttpLogExporterOptions opts;
+  opts.use_json_name = true;
+  std::unique_ptr<OtlpHttpLogExporter> exporter(new OtlpHttpLogExporter(opts));
+  EXPECT_EQ(GetOptions(exporter).use_json_name, true);
+}
+
+// Test exporter configuration options with json_bytes_mapping=JsonBytesMappingKind::kHex
+TEST_F(OtlpHttpLogExporterTestPeer, ConfigJsonBytesMappingTest)
+{
+  OtlpHttpLogExporterOptions opts;
+  opts.json_bytes_mapping = JsonBytesMappingKind::kHex;
+  std::unique_ptr<OtlpHttpLogExporter> exporter(new OtlpHttpLogExporter(opts));
+  EXPECT_EQ(GetOptions(exporter).json_bytes_mapping, JsonBytesMappingKind::kHex);
+}
+
+#    ifndef NO_GETENV
+// Test exporter configuration options with use_ssl_credentials
+TEST_F(OtlpHttpLogExporterTestPeer, ConfigFromEnv)
+{
+  const std::string url = "http://localhost:9999/v1/logs";
+  setenv("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:9999", 1);
+  setenv("OTEL_EXPORTER_OTLP_TIMEOUT", "20s", 1);
+  setenv("OTEL_EXPORTER_OTLP_HEADERS", "k1=v1,k2=v2", 1);
+  setenv("OTEL_EXPORTER_OTLP_LOGS_HEADERS", "k1=v3,k1=v4", 1);
+
+  std::unique_ptr<OtlpHttpLogExporter> exporter(new OtlpHttpLogExporter());
+  EXPECT_EQ(GetOptions(exporter).url, url);
+  EXPECT_EQ(
+      GetOptions(exporter).timeout.count(),
+      std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::seconds{20})
+          .count());
+  EXPECT_EQ(GetOptions(exporter).http_headers.size(), 3);
+  {
+    // Test k2
+    auto range = GetOptions(exporter).http_headers.equal_range("k2");
+    EXPECT_TRUE(range.first != range.second);
+    EXPECT_EQ(range.first->second, std::string("v2"));
+    ++range.first;
+    EXPECT_TRUE(range.first == range.second);
+  }
+  {
+    // k1
+    auto range = GetOptions(exporter).http_headers.equal_range("k1");
+    EXPECT_TRUE(range.first != range.second);
+    EXPECT_EQ(range.first->second, std::string("v3"));
+    ++range.first;
+    EXPECT_EQ(range.first->second, std::string("v4"));
+    ++range.first;
+    EXPECT_TRUE(range.first == range.second);
+  }
+
+  unsetenv("OTEL_EXPORTER_OTLP_ENDPOINT");
+  unsetenv("OTEL_EXPORTER_OTLP_TIMEOUT");
+  unsetenv("OTEL_EXPORTER_OTLP_HEADERS");
+  unsetenv("OTEL_EXPORTER_OTLP_LOGS_HEADERS");
+}
+
+TEST_F(OtlpHttpLogExporterTestPeer, ConfigFromLogsEnv)
+{
+  const std::string url = "http://localhost:9999/v1/logs";
+  setenv("OTEL_EXPORTER_OTLP_LOGS_ENDPOINT", url.c_str(), 1);
+  setenv("OTEL_EXPORTER_OTLP_TIMEOUT", "20s", 1);
+  setenv("OTEL_EXPORTER_OTLP_HEADERS", "k1=v1,k2=v2", 1);
+  setenv("OTEL_EXPORTER_OTLP_LOGS_HEADERS", "k1=v3,k1=v4", 1);
+
+  std::unique_ptr<OtlpHttpLogExporter> exporter(new OtlpHttpLogExporter());
+  EXPECT_EQ(GetOptions(exporter).url, url);
+  EXPECT_EQ(
+      GetOptions(exporter).timeout.count(),
+      std::chrono::duration_cast<std::chrono::system_clock::duration>(std::chrono::seconds{20})
+          .count());
+  EXPECT_EQ(GetOptions(exporter).http_headers.size(), 3);
+  {
+    // Test k2
+    auto range = GetOptions(exporter).http_headers.equal_range("k2");
+    EXPECT_TRUE(range.first != range.second);
+    EXPECT_EQ(range.first->second, std::string("v2"));
+    ++range.first;
+    EXPECT_TRUE(range.first == range.second);
+  }
+  {
+    // k1
+    auto range = GetOptions(exporter).http_headers.equal_range("k1");
+    EXPECT_TRUE(range.first != range.second);
+    EXPECT_EQ(range.first->second, std::string("v3"));
+    ++range.first;
+    EXPECT_EQ(range.first->second, std::string("v4"));
+    ++range.first;
+    EXPECT_TRUE(range.first == range.second);
+  }
+
+  unsetenv("OTEL_EXPORTER_OTLP_LOGS_ENDPOINT");
+  unsetenv("OTEL_EXPORTER_OTLP_TIMEOUT");
+  unsetenv("OTEL_EXPORTER_OTLP_HEADERS");
+  unsetenv("OTEL_EXPORTER_OTLP_LOGS_HEADERS");
+}
+
+TEST_F(OtlpHttpLogExporterTestPeer, DefaultEndpoint)
+{
+  EXPECT_EQ("http://localhost:4318/v1/logs", GetOtlpDefaultHttpLogEndpoint());
+  EXPECT_EQ("http://localhost:4318/v1/traces", GetOtlpDefaultHttpEndpoint());
+  EXPECT_EQ("http://localhost:4317", GetOtlpDefaultGrpcEndpoint());
+}
+
+#    endif
+
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#  endif
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_log_recordable_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_log_recordable_test.cc
new file mode 100644
index 000000000..bb48fd54e
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_log_recordable_test.cc
@@ -0,0 +1,240 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_LOGS_PREVIEW
+
+#  include <gtest/gtest.h>
+
+#  include "opentelemetry/exporters/otlp/otlp_log_recordable.h"
+#  include "opentelemetry/sdk/resource/experimental_semantic_conventions.h"
+#  include "opentelemetry/sdk/resource/resource.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+namespace resource = opentelemetry::sdk::resource;
+namespace proto    = opentelemetry::proto;
+
+TEST(OtlpLogRecordable, SetTimestamp)
+{
+  OtlpLogRecordable rec;
+  std::chrono::system_clock::time_point now = std::chrono::system_clock::now();
+  common::SystemTimestamp start_timestamp(now);
+
+  uint64_t unix_start =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(now.time_since_epoch()).count();
+
+  rec.SetTimestamp(start_timestamp);
+  EXPECT_EQ(rec.log_record().time_unix_nano(), unix_start);
+}
+
+TEST(OtlpLogRecordable, SetSeverity)
+{
+  OtlpLogRecordable rec;
+  rec.SetSeverity(opentelemetry::logs::Severity::kError);
+
+  EXPECT_EQ(rec.log_record().severity_number(), proto::logs::v1::SEVERITY_NUMBER_ERROR);
+  EXPECT_EQ(rec.log_record().severity_text(), "ERROR");
+}
+
+TEST(OtlpLogRecordable, SetBody)
+{
+  OtlpLogRecordable rec;
+  nostd::string_view name = "Test Log Message";
+  rec.SetBody(name);
+  EXPECT_EQ(rec.log_record().body().string_value(), name);
+}
+
+TEST(OtlpLogRecordable, SetTraceId)
+{
+  OtlpLogRecordable rec;
+  uint8_t trace_id_bin[opentelemetry::trace::TraceId::kSize] = {
+      '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};
+  std::string expected_bytes;
+  expected_bytes.assign(
+      reinterpret_cast<char *>(trace_id_bin),
+      reinterpret_cast<char *>(trace_id_bin) + opentelemetry::trace::TraceId::kSize);
+  rec.SetTraceId(opentelemetry::trace::TraceId{trace_id_bin});
+  EXPECT_EQ(rec.log_record().trace_id(), expected_bytes);
+}
+
+TEST(OtlpLogRecordable, SetSpanId)
+{
+  OtlpLogRecordable rec;
+  uint8_t span_id_bin[opentelemetry::trace::SpanId::kSize] = {'7', '6', '5', '4',
+                                                              '3', '2', '1', '0'};
+  std::string expected_bytes;
+  expected_bytes.assign(
+      reinterpret_cast<char *>(span_id_bin),
+      reinterpret_cast<char *>(span_id_bin) + opentelemetry::trace::SpanId::kSize);
+  rec.SetSpanId(opentelemetry::trace::SpanId{span_id_bin});
+  EXPECT_EQ(rec.log_record().span_id(), expected_bytes);
+}
+
+TEST(OtlpLogRecordable, SetResource)
+{
+  OtlpLogRecordable rec;
+  const std::string service_name_key = "service.name";
+  std::string service_name           = "test-otlp";
+  auto resource =
+      opentelemetry::sdk::resource::Resource::Create({{service_name_key, service_name}});
+  rec.SetResource(resource);
+
+  auto proto_resource     = rec.ProtoResource();
+  bool found_service_name = false;
+  for (int i = 0; i < proto_resource.attributes_size(); i++)
+  {
+    auto attr = proto_resource.attributes(static_cast<int>(i));
+    if (attr.key() == service_name_key && attr.value().string_value() == service_name)
+    {
+      found_service_name = true;
+    }
+  }
+  EXPECT_TRUE(found_service_name);
+}
+
+TEST(OtlpLogRecordable, DefaultResource)
+{
+  OtlpLogRecordable rec;
+
+  auto proto_resource      = rec.ProtoResource();
+  int found_resource_count = 0;
+  for (int i = 0; i < proto_resource.attributes_size(); i++)
+  {
+    auto attr = proto_resource.attributes(static_cast<int>(i));
+    if (attr.key() ==
+        opentelemetry::sdk::resource::attr(OTEL_CPP_CONST_HASHCODE(AttrTelemetrySdkLanguage)))
+    {
+      EXPECT_EQ(attr.value().string_value(), "cpp");
+      ++found_resource_count;
+    }
+    else if (attr.key() ==
+             opentelemetry::sdk::resource::attr(OTEL_CPP_CONST_HASHCODE(AttrTelemetrySdkName)))
+    {
+      EXPECT_EQ(attr.value().string_value(), "opentelemetry");
+      ++found_resource_count;
+    }
+    else if (attr.key() ==
+             opentelemetry::sdk::resource::attr(OTEL_CPP_CONST_HASHCODE(AttrTelemetrySdkVersion)))
+    {
+      EXPECT_EQ(attr.value().string_value(), OPENTELEMETRY_SDK_VERSION);
+      ++found_resource_count;
+    }
+  }
+  EXPECT_EQ(3, found_resource_count);
+}
+
+// Test non-int single types. Int single types are tested using templates (see IntAttributeTest)
+TEST(OtlpLogRecordable, SetSingleAttribute)
+{
+  OtlpLogRecordable rec;
+  nostd::string_view bool_key = "bool_attr";
+  common::AttributeValue bool_val(true);
+  rec.SetAttribute(bool_key, bool_val);
+
+  nostd::string_view double_key = "double_attr";
+  common::AttributeValue double_val(3.3);
+  rec.SetAttribute(double_key, double_val);
+
+  nostd::string_view str_key = "str_attr";
+  common::AttributeValue str_val(nostd::string_view("Test"));
+  rec.SetAttribute(str_key, str_val);
+
+  EXPECT_EQ(rec.log_record().attributes(0).key(), bool_key);
+  EXPECT_EQ(rec.log_record().attributes(0).value().bool_value(), nostd::get<bool>(bool_val));
+
+  EXPECT_EQ(rec.log_record().attributes(1).key(), double_key);
+  EXPECT_EQ(rec.log_record().attributes(1).value().double_value(), nostd::get<double>(double_val));
+
+  EXPECT_EQ(rec.log_record().attributes(2).key(), str_key);
+  EXPECT_EQ(rec.log_record().attributes(2).value().string_value(),
+            nostd::get<nostd::string_view>(str_val).data());
+}
+
+// Test non-int array types. Int array types are tested using templates (see IntAttributeTest)
+TEST(OtlpLogRecordable, SetArrayAttribute)
+{
+  OtlpLogRecordable rec;
+  const int kArraySize = 3;
+
+  bool bool_arr[kArraySize] = {true, false, true};
+  nostd::span<const bool> bool_span(bool_arr);
+  rec.SetAttribute("bool_arr_attr", bool_span);
+
+  double double_arr[kArraySize] = {22.3, 33.4, 44.5};
+  nostd::span<const double> double_span(double_arr);
+  rec.SetAttribute("double_arr_attr", double_span);
+
+  nostd::string_view str_arr[kArraySize] = {"Hello", "World", "Test"};
+  nostd::span<const nostd::string_view> str_span(str_arr);
+  rec.SetAttribute("str_arr_attr", str_span);
+
+  for (int i = 0; i < kArraySize; i++)
+  {
+    EXPECT_EQ(rec.log_record().attributes(0).value().array_value().values(i).bool_value(),
+              bool_span[i]);
+    EXPECT_EQ(rec.log_record().attributes(1).value().array_value().values(i).double_value(),
+              double_span[i]);
+    EXPECT_EQ(rec.log_record().attributes(2).value().array_value().values(i).string_value(),
+              str_span[i]);
+  }
+}
+
+TEST(OtlpLogRecordable, SetInstrumentationLibrary)
+{
+  OtlpLogRecordable rec;
+  auto inst_lib =
+      opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary::Create("test", "v1");
+  rec.SetInstrumentationLibrary(*inst_lib);
+  EXPECT_EQ(rec.GetInstrumentationLibrary(), *inst_lib);
+}
+
+/**
+ * AttributeValue can contain different int types, such as int, int64_t,
+ * unsigned int, and uint64_t. To avoid writing test cases for each, we can
+ * use a template approach to test all int types.
+ */
+template <typename T>
+struct OtlpLogRecordableIntAttributeTest : public testing::Test
+{
+  using IntParamType = T;
+};
+
+using IntTypes = testing::Types<int, int64_t, unsigned int, uint64_t>;
+TYPED_TEST_SUITE(OtlpLogRecordableIntAttributeTest, IntTypes);
+
+TYPED_TEST(OtlpLogRecordableIntAttributeTest, SetIntSingleAttribute)
+{
+  using IntType = typename TestFixture::IntParamType;
+  IntType i     = 2;
+  common::AttributeValue int_val(i);
+
+  OtlpLogRecordable rec;
+  rec.SetAttribute("int_attr", int_val);
+  EXPECT_EQ(rec.log_record().attributes(0).value().int_value(), nostd::get<IntType>(int_val));
+}
+
+TYPED_TEST(OtlpLogRecordableIntAttributeTest, SetIntArrayAttribute)
+{
+  using IntType = typename TestFixture::IntParamType;
+
+  const int kArraySize        = 3;
+  IntType int_arr[kArraySize] = {4, 5, 6};
+  nostd::span<const IntType> int_span(int_arr);
+
+  OtlpLogRecordable rec;
+  rec.SetAttribute("int_arr_attr", int_span);
+
+  for (int i = 0; i < kArraySize; i++)
+  {
+    EXPECT_EQ(rec.log_record().attributes(0).value().array_value().values(i).int_value(),
+              int_span[i]);
+  }
+}
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_recordable_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_recordable_test.cc
new file mode 100644
index 000000000..b46802d87
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/otlp/test/otlp_recordable_test.cc
@@ -0,0 +1,321 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/exporters/otlp/otlp_recordable.h"
+#include <gtest/gtest.h>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace otlp
+{
+namespace trace_api = opentelemetry::trace;
+namespace trace_sdk = opentelemetry::sdk::trace;
+namespace resource  = opentelemetry::sdk::resource;
+namespace proto     = opentelemetry::proto;
+
+TEST(OtlpRecordable, SetIdentity)
+{
+  constexpr uint8_t trace_id_buf[]       = {1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8};
+  constexpr uint8_t span_id_buf[]        = {1, 2, 3, 4, 5, 6, 7, 8};
+  constexpr uint8_t parent_span_id_buf[] = {8, 7, 6, 5, 4, 3, 2, 1};
+  trace_api::TraceId trace_id{trace_id_buf};
+  trace_api::SpanId span_id{span_id_buf};
+  trace_api::SpanId parent_span_id{parent_span_id_buf};
+  const auto trace_state = trace_api::TraceState::GetDefault()->Set("key1", "value");
+  const trace_api::SpanContext span_context{
+      trace_id, span_id, trace_api::TraceFlags{trace_api::TraceFlags::kIsSampled}, true,
+      trace_state};
+
+  OtlpRecordable rec;
+
+  rec.SetIdentity(span_context, parent_span_id);
+
+  EXPECT_EQ(rec.span().trace_id(), std::string(reinterpret_cast<const char *>(trace_id.Id().data()),
+                                               trace::TraceId::kSize));
+  EXPECT_EQ(rec.span().span_id(),
+            std::string(reinterpret_cast<const char *>(span_id.Id().data()), trace::SpanId::kSize));
+  EXPECT_EQ(rec.span().trace_state(), "key1=value");
+  EXPECT_EQ(rec.span().parent_span_id(),
+            std::string(reinterpret_cast<const char *>(parent_span_id.Id().data()),
+                        trace::SpanId::kSize));
+
+  OtlpRecordable rec_invalid_parent;
+
+  constexpr uint8_t invalid_parent_span_id_buf[] = {0, 0, 0, 0, 0, 0, 0, 0};
+  trace_api::SpanId invalid_parent_span_id{invalid_parent_span_id_buf};
+  rec_invalid_parent.SetIdentity(span_context, invalid_parent_span_id);
+
+  EXPECT_EQ(rec_invalid_parent.span().parent_span_id(), std::string{});
+}
+
+TEST(OtlpRecordable, SetSpanKind)
+{
+  OtlpRecordable rec;
+  trace_api::SpanKind span_kind = trace_api::SpanKind::kServer;
+  rec.SetSpanKind(span_kind);
+  EXPECT_EQ(rec.span().kind(), proto::trace::v1::Span_SpanKind::Span_SpanKind_SPAN_KIND_SERVER);
+}
+
+TEST(OtlpRecordable, SetInstrumentationLibrary)
+{
+  OtlpRecordable rec;
+  auto inst_lib = trace_sdk::InstrumentationLibrary::Create("test", "v1");
+  rec.SetInstrumentationLibrary(*inst_lib);
+  auto proto_instr_libr = rec.GetProtoInstrumentationLibrary();
+  EXPECT_EQ(proto_instr_libr.name(), inst_lib->GetName());
+  EXPECT_EQ(proto_instr_libr.version(), inst_lib->GetVersion());
+}
+
+TEST(OtlpRecordable, SetInstrumentationLibraryWithSchemaURL)
+{
+  OtlpRecordable rec;
+  const std::string expected_schema_url{"https://opentelemetry.io/schemas/1.11.0"};
+  auto inst_lib = trace_sdk::InstrumentationLibrary::Create("test", "v1", expected_schema_url);
+  rec.SetInstrumentationLibrary(*inst_lib);
+  EXPECT_EQ(expected_schema_url, rec.GetInstrumentationLibrarySchemaURL());
+}
+
+TEST(OtlpRecordable, SetStartTime)
+{
+  OtlpRecordable rec;
+  std::chrono::system_clock::time_point start_time = std::chrono::system_clock::now();
+  common::SystemTimestamp start_timestamp(start_time);
+
+  uint64_t unix_start =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(start_time.time_since_epoch()).count();
+
+  rec.SetStartTime(start_timestamp);
+  EXPECT_EQ(rec.span().start_time_unix_nano(), unix_start);
+}
+
+TEST(OtlpRecordable, SetDuration)
+{
+  OtlpRecordable rec;
+  // Start time is 0
+  common::SystemTimestamp start_timestamp;
+
+  std::chrono::nanoseconds duration(10);
+  uint64_t unix_end = duration.count();
+
+  rec.SetStartTime(start_timestamp);
+  rec.SetDuration(duration);
+
+  EXPECT_EQ(rec.span().end_time_unix_nano(), unix_end);
+}
+
+TEST(OtlpRecordable, SetStatus)
+{
+  OtlpRecordable rec1;
+  trace::StatusCode code_error(trace::StatusCode::kError);
+  nostd::string_view description = "For test";
+  rec1.SetStatus(code_error, description);
+
+  EXPECT_EQ(rec1.span().status().code(), proto::trace::v1::Status_StatusCode(code_error));
+  EXPECT_EQ(rec1.span().status().message(), description);
+
+  OtlpRecordable rec2;
+  trace::StatusCode code_ok(trace::StatusCode::kOk);
+  rec2.SetStatus(code_ok, description);
+  EXPECT_EQ(rec2.span().status().code(), proto::trace::v1::Status_StatusCode(code_ok));
+  EXPECT_EQ(rec2.span().status().message(), "");
+}
+
+TEST(OtlpRecordable, AddEventDefault)
+{
+  OtlpRecordable rec;
+  nostd::string_view name = "Test Event";
+
+  std::chrono::system_clock::time_point event_time = std::chrono::system_clock::now();
+  common::SystemTimestamp event_timestamp(event_time);
+
+  rec.sdk::trace::Recordable::AddEvent(name, event_timestamp);
+
+  uint64_t unix_event_time =
+      std::chrono::duration_cast<std::chrono::nanoseconds>(event_time.time_since_epoch()).count();
+
+  EXPECT_EQ(rec.span().events(0).name(), name);
+  EXPECT_EQ(rec.span().events(0).time_unix_nano(), unix_event_time);
+  EXPECT_EQ(rec.span().events(0).attributes().size(), 0);
+}
+
+TEST(OtlpRecordable, AddEventWithAttributes)
+{
+  OtlpRecordable rec;
+  const int kNumAttributes              = 3;
+  std::string keys[kNumAttributes]      = {"attr1", "attr2", "attr3"};
+  int values[kNumAttributes]            = {4, 7, 23};
+  std::map<std::string, int> attributes = {
+      {keys[0], values[0]}, {keys[1], values[1]}, {keys[2], values[2]}};
+
+  rec.AddEvent("Test Event", std::chrono::system_clock::now(),
+               common::KeyValueIterableView<std::map<std::string, int>>(attributes));
+
+  for (int i = 0; i < kNumAttributes; i++)
+  {
+    EXPECT_EQ(rec.span().events(0).attributes(i).key(), keys[i]);
+    EXPECT_EQ(rec.span().events(0).attributes(i).value().int_value(), values[i]);
+  }
+}
+
+TEST(OtlpRecordable, AddLink)
+{
+  OtlpRecordable rec;
+  const int kNumAttributes              = 3;
+  std::string keys[kNumAttributes]      = {"attr1", "attr2", "attr3"};
+  int values[kNumAttributes]            = {5, 12, 40};
+  std::map<std::string, int> attributes = {
+      {keys[0], values[0]}, {keys[1], values[1]}, {keys[2], values[2]}};
+
+  auto trace_id = rec.span().trace_id();
+  auto span_id  = rec.span().span_id();
+
+  trace::TraceFlags flags;
+  std::string trace_state_header = "k1=v1,k2=v2";
+  auto ts                        = trace::TraceState::FromHeader(trace_state_header);
+
+  rec.AddLink(trace::SpanContext(trace::TraceId(), trace::SpanId(), flags, false, ts),
+              common::KeyValueIterableView<std::map<std::string, int>>(attributes));
+
+  EXPECT_EQ(rec.span().trace_id(), trace_id);
+  EXPECT_EQ(rec.span().span_id(), span_id);
+  EXPECT_EQ(rec.span().links(0).trace_state(), trace_state_header);
+  for (int i = 0; i < kNumAttributes; i++)
+  {
+    EXPECT_EQ(rec.span().links(0).attributes(i).key(), keys[i]);
+    EXPECT_EQ(rec.span().links(0).attributes(i).value().int_value(), values[i]);
+  }
+}
+
+TEST(OtlpRecordable, SetResource)
+{
+  OtlpRecordable rec;
+  const std::string service_name_key = "service.name";
+  std::string service_name           = "test-otlp";
+  auto resource = resource::Resource::Create({{service_name_key, service_name}});
+  rec.SetResource(resource);
+
+  auto proto_resource     = rec.ProtoResource();
+  bool found_service_name = false;
+  for (int i = 0; i < proto_resource.attributes_size(); i++)
+  {
+    auto attr = proto_resource.attributes(static_cast<int>(i));
+    if (attr.key() == service_name_key && attr.value().string_value() == service_name)
+    {
+      found_service_name = true;
+    }
+  }
+  EXPECT_TRUE(found_service_name);
+}
+
+TEST(OtlpRecordable, SetResourceWithSchemaURL)
+{
+  OtlpRecordable rec;
+  const std::string service_name_key    = "service.name";
+  const std::string service_name        = "test-otlp";
+  const std::string expected_schema_url = "https://opentelemetry.io/schemas/1.11.0";
+  auto resource =
+      resource::Resource::Create({{service_name_key, service_name}}, expected_schema_url);
+  rec.SetResource(resource);
+
+  EXPECT_EQ(expected_schema_url, rec.GetResourceSchemaURL());
+}
+
+// Test non-int single types. Int single types are tested using templates (see IntAttributeTest)
+TEST(OtlpRecordable, SetSingleAttribute)
+{
+  OtlpRecordable rec;
+  nostd::string_view bool_key = "bool_attr";
+  common::AttributeValue bool_val(true);
+  rec.SetAttribute(bool_key, bool_val);
+
+  nostd::string_view double_key = "double_attr";
+  common::AttributeValue double_val(3.3);
+  rec.SetAttribute(double_key, double_val);
+
+  nostd::string_view str_key = "str_attr";
+  common::AttributeValue str_val(nostd::string_view("Test"));
+  rec.SetAttribute(str_key, str_val);
+
+  EXPECT_EQ(rec.span().attributes(0).key(), bool_key);
+  EXPECT_EQ(rec.span().attributes(0).value().bool_value(), nostd::get<bool>(bool_val));
+
+  EXPECT_EQ(rec.span().attributes(1).key(), double_key);
+  EXPECT_EQ(rec.span().attributes(1).value().double_value(), nostd::get<double>(double_val));
+
+  EXPECT_EQ(rec.span().attributes(2).key(), str_key);
+  EXPECT_EQ(rec.span().attributes(2).value().string_value(),
+            nostd::get<nostd::string_view>(str_val).data());
+}
+
+// Test non-int array types. Int array types are tested using templates (see IntAttributeTest)
+TEST(OtlpRecordable, SetArrayAttribute)
+{
+  OtlpRecordable rec;
+  const int kArraySize = 3;
+
+  bool bool_arr[kArraySize] = {true, false, true};
+  nostd::span<const bool> bool_span(bool_arr);
+  rec.SetAttribute("bool_arr_attr", bool_span);
+
+  double double_arr[kArraySize] = {22.3, 33.4, 44.5};
+  nostd::span<const double> double_span(double_arr);
+  rec.SetAttribute("double_arr_attr", double_span);
+
+  nostd::string_view str_arr[kArraySize] = {"Hello", "World", "Test"};
+  nostd::span<const nostd::string_view> str_span(str_arr);
+  rec.SetAttribute("str_arr_attr", str_span);
+
+  for (int i = 0; i < kArraySize; i++)
+  {
+    EXPECT_EQ(rec.span().attributes(0).value().array_value().values(i).bool_value(), bool_span[i]);
+    EXPECT_EQ(rec.span().attributes(1).value().array_value().values(i).double_value(),
+              double_span[i]);
+    EXPECT_EQ(rec.span().attributes(2).value().array_value().values(i).string_value(), str_span[i]);
+  }
+}
+
+/**
+ * AttributeValue can contain different int types, such as int, int64_t,
+ * unsigned int, and uint64_t. To avoid writing test cases for each, we can
+ * use a template approach to test all int types.
+ */
+template <typename T>
+struct IntAttributeTest : public testing::Test
+{
+  using IntParamType = T;
+};
+
+using IntTypes = testing::Types<int, int64_t, unsigned int, uint64_t>;
+TYPED_TEST_SUITE(IntAttributeTest, IntTypes);
+
+TYPED_TEST(IntAttributeTest, SetIntSingleAttribute)
+{
+  using IntType = typename TestFixture::IntParamType;
+  IntType i     = 2;
+  common::AttributeValue int_val(i);
+
+  OtlpRecordable rec;
+  rec.SetAttribute("int_attr", int_val);
+  EXPECT_EQ(rec.span().attributes(0).value().int_value(), nostd::get<IntType>(int_val));
+}
+
+TYPED_TEST(IntAttributeTest, SetIntArrayAttribute)
+{
+  using IntType = typename TestFixture::IntParamType;
+
+  const int kArraySize        = 3;
+  IntType int_arr[kArraySize] = {4, 5, 6};
+  nostd::span<const IntType> int_span(int_arr);
+
+  OtlpRecordable rec;
+  rec.SetAttribute("int_arr_attr", int_span);
+
+  for (int i = 0; i < kArraySize; i++)
+  {
+    EXPECT_EQ(rec.span().attributes(0).value().array_value().values(i).int_value(), int_span[i]);
+  }
+}
+}  // namespace otlp
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/BUILD b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/BUILD
new file mode 100644
index 000000000..47c9bbab1
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/BUILD
@@ -0,0 +1,144 @@
+# Copyright 2020, OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+package(default_visibility = ["//visibility:public"])
+
+cc_library(
+    name = "prometheus_exporter_deprecated",
+    srcs = [
+        "src/prometheus_exporter.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/prometheus/prometheus_exporter.h",
+    ],
+    strip_include_prefix = "include",
+    tags = ["prometheus"],
+    deps = [
+        ":prometheus_collector_deprecated",
+        ":prometheus_exporter_utils_deprecated",
+        "//api",
+        "//sdk:headers",
+        "@com_github_jupp0r_prometheus_cpp//core",
+        "@com_github_jupp0r_prometheus_cpp//pull",
+    ],
+)
+
+cc_library(
+    name = "prometheus_exporter_utils_deprecated",
+    srcs = [
+        "src/prometheus_exporter_utils.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/prometheus/prometheus_exporter_utils.h",
+    ],
+    strip_include_prefix = "include",
+    tags = ["prometheus"],
+    deps = [
+        "//api",
+        "//sdk:headers",
+        "@com_github_jupp0r_prometheus_cpp//core",
+        "@com_github_jupp0r_prometheus_cpp//pull",
+    ],
+)
+
+cc_library(
+    name = "prometheus_collector_deprecated",
+    srcs = [
+        "src/prometheus_collector.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/prometheus/prometheus_collector.h",
+    ],
+    strip_include_prefix = "include",
+    tags = ["prometheus"],
+    deps = [
+        ":prometheus_exporter_utils_deprecated",
+        "//api",
+        "//sdk:headers",
+        "@com_github_jupp0r_prometheus_cpp//core",
+        "@com_github_jupp0r_prometheus_cpp//pull",
+    ],
+)
+
+cc_test(
+    name = "prometheus_exporter_test_deprecated",
+    srcs = [
+        "test/prometheus_exporter_test.cc",
+    ],
+    tags = [
+        "prometheus",
+        "test",
+    ],
+    deps = [
+        ":prometheus_exporter_deprecated",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_library(
+    name = "prometheus_exporter",
+    srcs = [
+        "src/exporter.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/prometheus/exporter.h",
+    ],
+    strip_include_prefix = "include",
+    tags = ["prometheus"],
+    deps = [
+        ":prometheus_collector",
+        ":prometheus_exporter_utils",
+        "//api",
+        "//sdk:headers",
+        "@com_github_jupp0r_prometheus_cpp//core",
+        "@com_github_jupp0r_prometheus_cpp//pull",
+    ],
+)
+
+cc_library(
+    name = "prometheus_exporter_utils",
+    srcs = [
+        "src/exporter_utils.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/prometheus/exporter_utils.h",
+    ],
+    strip_include_prefix = "include",
+    tags = ["prometheus"],
+    deps = [
+        "//api",
+        "//sdk:headers",
+        "@com_github_jupp0r_prometheus_cpp//core",
+        "@com_github_jupp0r_prometheus_cpp//pull",
+    ],
+)
+
+cc_library(
+    name = "prometheus_collector",
+    srcs = [
+        "src/collector.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/prometheus/collector.h",
+    ],
+    strip_include_prefix = "include",
+    tags = ["prometheus"],
+    deps = [
+        ":prometheus_exporter_utils",
+        "//api",
+        "//sdk:headers",
+        "@com_github_jupp0r_prometheus_cpp//core",
+        "@com_github_jupp0r_prometheus_cpp//pull",
+    ],
+)
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/CMakeLists.txt b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/CMakeLists.txt
new file mode 100755
index 000000000..56523ec84
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/CMakeLists.txt
@@ -0,0 +1,90 @@
+# Copyright 2020, OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+include_directories(include)
+if(NOT TARGET prometheus-cpp::core)
+  find_package(prometheus-cpp CONFIG REQUIRED)
+endif()
+if(WITH_METRICS_PREVIEW)
+  add_library(
+    prometheus_exporter_deprecated
+    src/prometheus_exporter.cc src/prometheus_collector.cc
+    src/prometheus_exporter_utils.cc)
+  target_include_directories(
+    prometheus_exporter_deprecated
+    PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+           "$<INSTALL_INTERFACE:include>")
+
+  set(PROMETHEUS_EXPORTER_TARGETS_DEPRECATED prometheus_exporter_deprecated)
+  if(TARGET pull)
+    list(APPEND PROMETHEUS_EXPORTER_TARGETS_DEPRECATED pull)
+  endif()
+  if(TARGET core)
+    list(APPEND PROMETHEUS_EXPORTER_TARGETS_DEPRECATED core)
+  endif()
+  target_link_libraries(
+    prometheus_exporter_deprecated
+    PUBLIC opentelemetry_metrics_deprecated prometheus-cpp::pull
+           prometheus-cpp::core)
+  install(
+    TARGETS ${PROMETHEUS_EXPORTER_TARGETS_DEPRECATED}
+    EXPORT "${PROJECT_NAME}-target"
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+  install(
+    DIRECTORY include/opentelemetry/exporters/prometheus
+    DESTINATION include/opentelemetry/exporters/
+    FILES_MATCHING
+    PATTERN "*.h")
+  if(BUILD_TESTING)
+    add_subdirectory(test)
+  endif()
+else()
+
+  add_library(prometheus_exporter src/exporter.cc src/collector.cc
+                                  src/exporter_utils.cc)
+  target_include_directories(
+    prometheus_exporter
+    PUBLIC "$<BUILD_INTERFACE:${CMAKE_CURRENT_LIST_DIR}/include>"
+           "$<INSTALL_INTERFACE:include>")
+
+  set(PROMETHEUS_EXPORTER_TARGETS prometheus_exporter)
+  if(TARGET pull)
+    list(APPEND PROMETHEUS_EXPORTER_TARGETS pull)
+  endif()
+  if(TARGET core)
+    list(APPEND PROMETHEUS_EXPORTER_TARGETS core)
+  endif()
+  target_link_libraries(
+    prometheus_exporter PUBLIC opentelemetry_metrics prometheus-cpp::pull
+                               prometheus-cpp::core)
+  install(
+    TARGETS ${PROMETHEUS_EXPORTER_TARGETS}
+    EXPORT "${PROJECT_NAME}-target"
+    RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+    LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+  install(
+    DIRECTORY include/opentelemetry/exporters/prometheus
+    DESTINATION include/opentelemetry/exporters/
+    FILES_MATCHING
+    PATTERN "*.h")
+
+  if(BUILD_TESTING)
+    add_subdirectory(test)
+  endif()
+endif()
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/collector.h b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/collector.h
new file mode 100644
index 000000000..68f50d29f
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/collector.h
@@ -0,0 +1,87 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifndef ENABLE_METRICS_PREVIEW
+
+#  include <memory>
+#  include <mutex>
+#  include <vector>
+
+#  include <prometheus/collectable.h>
+#  include <prometheus/metric_family.h>
+#  include "opentelemetry/exporters/prometheus/exporter_utils.h"
+
+namespace prometheus_client = ::prometheus;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace metrics
+{
+/**
+ * The Prometheus Collector maintains the intermediate collection in Prometheus Exporter
+ */
+class PrometheusCollector : public prometheus_client::Collectable
+{
+public:
+  /**
+   * Default Constructor.
+   *
+   * This constructor initializes the collection for metrics to export
+   * in this class with default capacity
+   */
+  explicit PrometheusCollector(size_t max_collection_size = 2048);
+
+  /**
+   * Collects all metrics data from metricsToCollect collection.
+   *
+   * @return all metrics in the metricsToCollect snapshot
+   */
+  std::vector<prometheus_client::MetricFamily> Collect() const override;
+
+  /**
+   * This function is called by export() function and add the collection of
+   * records to the metricsToCollect collection
+   *
+   * @param records a collection of records to add to the metricsToCollect collection
+   */
+  void AddMetricData(const sdk::metrics::ResourceMetrics &data);
+
+  /**
+   * Get the current collection in the collector.
+   *
+   * @return the current metricsToCollect collection
+   */
+  std::vector<std::unique_ptr<sdk::metrics::ResourceMetrics>> &GetCollection();
+
+  /**
+   * Gets the maximum size of the collection.
+   *
+   * @return max collection size
+   */
+  int GetMaxCollectionSize() const;
+
+private:
+  /**
+   * Collection of metrics data from the export() function, and to be export
+   * to user when they send a pull request. This collection is a pointer
+   * to a collection so Collect() is able to clear the collection, even
+   * though it is a const function.
+   */
+  mutable std::vector<std::unique_ptr<sdk::metrics::ResourceMetrics>> metrics_to_collect_;
+
+  /**
+   * Maximum size of the metricsToCollect collection.
+   */
+  size_t max_collection_size_;
+
+  /*
+   * Lock when operating the metricsToCollect collection
+   */
+  mutable std::mutex collection_lock_;
+};
+}  // namespace metrics
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/exporter.h
new file mode 100644
index 000000000..59ef1a11a
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/exporter.h
@@ -0,0 +1,126 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifndef ENABLE_METRICS_PREVIEW
+#  include <memory>
+#  include <string>
+#  include <vector>
+
+#  include <prometheus/exposer.h>
+#  include "opentelemetry/common/spin_lock_mutex.h"
+#  include "opentelemetry/exporters/prometheus/collector.h"
+#  include "opentelemetry/nostd/span.h"
+#  include "opentelemetry/sdk/common/env_variables.h"
+#  include "opentelemetry/sdk/metrics/metric_exporter.h"
+#  include "opentelemetry/version.h"
+
+/**
+ * This class is an implementation of the MetricsExporter interface and
+ * exports Prometheus metrics data. Functions in this class should be
+ * called by the Controller in our data pipeline.
+ */
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+
+namespace exporter
+{
+namespace metrics
+{
+
+inline const std::string GetPrometheusDefaultHttpEndpoint()
+{
+  constexpr char kPrometheusEndpointEnv[]     = "PROMETHEUS_EXPORTER_ENDPOINT";
+  constexpr char kPrometheusEndpointDefault[] = "localhost:9464";
+
+  auto endpoint = opentelemetry::sdk::common::GetEnvironmentVariable(kPrometheusEndpointEnv);
+  return endpoint.size() ? endpoint : kPrometheusEndpointDefault;
+}
+
+/**
+ * Struct to hold Prometheus exporter options.
+ */
+struct PrometheusExporterOptions
+{
+  // The endpoint the Prometheus backend can collect metrics from
+  std::string url = GetPrometheusDefaultHttpEndpoint();
+};
+
+class PrometheusExporter : public sdk::metrics::MetricExporter
+{
+public:
+  /**
+   * Constructor - binds an exposer and collector to the exporter
+   * @param options: options for an exposer that exposes
+   *  an HTTP endpoint for the exporter to connect to
+   */
+  PrometheusExporter(const PrometheusExporterOptions &options);
+
+  /**
+   * Exports a batch of Metric Records.
+   * @param records: a collection of records to export
+   * @return: returns a ReturnCode detailing a success, or type of failure
+   */
+  sdk::common::ExportResult Export(const sdk::metrics::ResourceMetrics &data) noexcept override;
+
+  /**
+   * Force flush the exporter.
+   */
+  bool ForceFlush(
+      std::chrono::microseconds timeout = (std::chrono::microseconds::max)()) noexcept override;
+
+  /**
+   * Shuts down the exporter and does cleanup.
+   * Since Prometheus is a pull based interface,
+   * we cannot serve data remaining in the intermediate
+   * collection to to client an HTTP request being sent,
+   * so we flush the data.
+   */
+  bool Shutdown(std::chrono::microseconds timeout = std::chrono::microseconds(0)) noexcept override;
+
+  /**
+   * @return: returns a shared_ptr to
+   * the PrometheusCollector instance
+   */
+  std::shared_ptr<PrometheusCollector> &GetCollector();
+
+  /**
+   * @return: Gets the shutdown status of the exporter
+   */
+  bool IsShutdown() const;
+
+private:
+  // The configuration options associated with this exporter.
+  const PrometheusExporterOptions options_;
+  /**
+   * exporter shutdown status
+   */
+  bool is_shutdown_;
+
+  /**
+   * Pointer to a
+   * PrometheusCollector instance
+   */
+  std::shared_ptr<PrometheusCollector> collector_;
+
+  /**
+   * Pointer to an
+   * Exposer instance
+   */
+  std::unique_ptr<::prometheus::Exposer> exposer_;
+
+  /**
+   * friend class for testing
+   */
+  friend class PrometheusExporterTest;
+
+  /**
+   * PrometheusExporter constructor with no parameters
+   * Used for testing only
+   */
+  PrometheusExporter();
+};
+}  // namespace metrics
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif  // ENABLE_METRICS_PREVIEW
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/exporter_utils.h b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/exporter_utils.h
new file mode 100644
index 000000000..c8df4f6cf
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/exporter_utils.h
@@ -0,0 +1,115 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#ifndef ENABLE_METRICS_PREVIEW
+
+#  include <prometheus/metric_family.h>
+#  include <string>
+#  include <vector>
+#  include "opentelemetry/metrics/provider.h"
+#  include "opentelemetry/sdk/metrics/meter.h"
+#  include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace metrics
+{
+/**
+ * The Prometheus Utils contains utility functions for Prometheus Exporter
+ */
+class PrometheusExporterUtils
+{
+public:
+  /**
+   * Helper function to convert OpenTelemetry metrics data collection
+   * to Prometheus metrics data collection
+   *
+   * @param records a collection of metrics in OpenTelemetry
+   * @return a collection of translated metrics that is acceptable by Prometheus
+   */
+  static std::vector<::prometheus::MetricFamily> TranslateToPrometheus(
+      const std::vector<std::unique_ptr<sdk::metrics::ResourceMetrics>> &data);
+
+private:
+  /**
+   * Sanitize the given metric name or label according to Prometheus rule.
+   *
+   * This function is needed because names in OpenTelemetry can contain
+   * alphanumeric characters, '_', '.', and '-', whereas in Prometheus the
+   * name should only contain alphanumeric characters and '_'.
+   */
+  static std::string SanitizeNames(std::string name);
+
+  static opentelemetry::sdk::metrics::AggregationType getAggregationType(
+      const opentelemetry::sdk::metrics::PointType &point_type);
+
+  /**
+   * Translate the OTel metric type to Prometheus metric type
+   */
+  static ::prometheus::MetricType TranslateType(opentelemetry::sdk::metrics::AggregationType kind);
+
+  /**
+   * Set metric data for:
+   * Counter => Prometheus Counter
+   */
+  template <typename T>
+  static void SetData(std::vector<T> values,
+                      const opentelemetry::sdk::metrics::PointAttributes &labels,
+                      ::prometheus::MetricType type,
+                      std::chrono::nanoseconds time,
+                      ::prometheus::MetricFamily *metric_family);
+
+  /**
+   * Set metric data for:
+   * Histogram => Prometheus Histogram
+   */
+  template <typename T>
+  static void SetData(std::vector<T> values,
+                      const opentelemetry::sdk::metrics::ListType &boundaries,
+                      const std::vector<uint64_t> &counts,
+                      const opentelemetry::sdk::metrics::PointAttributes &labels,
+                      std::chrono::nanoseconds time,
+                      ::prometheus::MetricFamily *metric_family);
+
+  /**
+   * Set time and labels to metric data
+   */
+  static void SetMetricBasic(::prometheus::ClientMetric &metric,
+                             std::chrono::nanoseconds time,
+                             const opentelemetry::sdk::metrics::PointAttributes &labels);
+
+  /**
+   * Convert attribute value to string
+   */
+  static std::string AttributeValueToString(
+      const opentelemetry::sdk::common::OwnedAttributeValue &value);
+
+  /**
+   * Handle Counter and Gauge.
+   */
+  template <typename T>
+  static void SetValue(std::vector<T> values,
+                       ::prometheus::MetricType type,
+                       ::prometheus::ClientMetric *metric);
+
+  /**
+   * Handle Gauge from MinMaxSumCount
+   */
+  static void SetValue(double value, ::prometheus::ClientMetric *metric);
+
+  /**
+   * Handle Histogram
+   */
+  template <typename T, typename U>
+  static void SetValue(std::vector<T> values,
+                       const std::list<U> &boundaries,
+                       const std::vector<uint64_t> &counts,
+                       ::prometheus::ClientMetric *metric);
+};
+}  // namespace metrics
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/prometheus_collector.h b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/prometheus_collector.h
new file mode 100644
index 000000000..4be748385
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/prometheus_collector.h
@@ -0,0 +1,88 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifdef ENABLE_METRICS_PREVIEW
+
+#  include <memory>
+#  include <mutex>
+#  include <vector>
+
+#  include "opentelemetry/exporters/prometheus/prometheus_exporter_utils.h"
+#  include "opentelemetry/sdk/_metrics/record.h"
+#  include "prometheus/collectable.h"
+#  include "prometheus/metric_family.h"
+
+namespace prometheus_client = ::prometheus;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace prometheus
+{
+/**
+ * The Prometheus Collector maintains the intermediate collection in Prometheus Exporter
+ */
+class PrometheusCollector : public prometheus_client::Collectable
+{
+public:
+  /**
+   * Default Constructor.
+   *
+   * This constructor initializes the collection for metrics to export
+   * in this class with default capacity
+   */
+  explicit PrometheusCollector(size_t max_collection_size = 2048);
+
+  /**
+   * Collects all metrics data from metricsToCollect collection.
+   *
+   * @return all metrics in the metricsToCollect snapshot
+   */
+  std::vector<prometheus_client::MetricFamily> Collect() const override;
+
+  /**
+   * This function is called by export() function and add the collection of
+   * records to the metricsToCollect collection
+   *
+   * @param records a collection of records to add to the metricsToCollect collection
+   */
+  void AddMetricData(const std::vector<opentelemetry::sdk::metrics::Record> &records);
+
+  /**
+   * Get the current collection in the collector.
+   *
+   * @return the current metricsToCollect collection
+   */
+  std::vector<opentelemetry::sdk::metrics::Record> GetCollection();
+
+  /**
+   * Gets the maximum size of the collection.
+   *
+   * @return max collection size
+   */
+  int GetMaxCollectionSize() const;
+
+private:
+  /**
+   * Collection of metrics data from the export() function, and to be export
+   * to user when they send a pull request. This collection is a pointer
+   * to a collection so Collect() is able to clear the collection, even
+   * though it is a const function.
+   */
+  std::unique_ptr<std::vector<opentelemetry::sdk::metrics::Record>> metrics_to_collect_;
+
+  /**
+   * Maximum size of the metricsToCollect collection.
+   */
+  size_t max_collection_size_;
+
+  /*
+   * Lock when operating the metricsToCollect collection
+   */
+  mutable std::mutex collection_lock_;
+};
+}  // namespace prometheus
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/prometheus_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/prometheus_exporter.h
new file mode 100644
index 000000000..7c1f99a75
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/prometheus_exporter.h
@@ -0,0 +1,98 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifdef ENABLE_METRICS_PREVIEW
+#  include <memory>
+#  include <string>
+#  include <vector>
+
+#  include "opentelemetry/exporters/prometheus/prometheus_collector.h"
+#  include "opentelemetry/sdk/_metrics/exporter.h"
+#  include "opentelemetry/sdk/_metrics/record.h"
+#  include "opentelemetry/version.h"
+#  include "prometheus/exposer.h"
+
+/**
+ * This class is an implementation of the MetricsExporter interface and
+ * exports Prometheus metrics data. Functions in this class should be
+ * called by the Controller in our data pipeline.
+ */
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+
+namespace exporter
+{
+namespace prometheus
+{
+class PrometheusExporter : public sdk::metrics::MetricsExporter
+{
+public:
+  /**
+   * Constructor - binds an exposer and collector to the exporter
+   * @param address: an address for an exposer that exposes
+   *  an HTTP endpoint for the exporter to connect to
+   */
+  PrometheusExporter(std::string &address);
+
+  /**
+   * Exports a batch of Metric Records.
+   * @param records: a collection of records to export
+   * @return: returns a ReturnCode detailing a success, or type of failure
+   */
+  sdk::common::ExportResult Export(
+      const std::vector<sdk::metrics::Record> &records) noexcept override;
+
+  /**
+   * Shuts down the exporter and does cleanup.
+   * Since Prometheus is a pull based interface,
+   * we cannot serve data remaining in the intermediate
+   * collection to to client an HTTP request being sent,
+   * so we flush the data.
+   */
+  void Shutdown() noexcept;
+
+  /**
+   * @return: returns a shared_ptr to
+   * the PrometheusCollector instance
+   */
+  std::shared_ptr<PrometheusCollector> &GetCollector();
+
+  /**
+   * @return: Gets the shutdown status of the exporter
+   */
+  bool IsShutdown() const;
+
+private:
+  /**
+   * exporter shutdown status
+   */
+  bool is_shutdown_;
+
+  /**
+   * Pointer to a
+   * PrometheusCollector instance
+   */
+  std::shared_ptr<PrometheusCollector> collector_;
+
+  /**
+   * Pointer to an
+   * Exposer instance
+   */
+  std::unique_ptr<::prometheus::Exposer> exposer_;
+
+  /**
+   * friend class for testing
+   */
+  friend class PrometheusExporterTest;
+
+  /**
+   * PrometheusExporter constructor with no parameters
+   * Used for testing only
+   */
+  PrometheusExporter();
+};
+}  // namespace prometheus
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif  // ENABLE_METRICS_PREVIEW
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/prometheus_exporter_utils.h b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/prometheus_exporter_utils.h
new file mode 100644
index 000000000..7efea9d39
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/include/opentelemetry/exporters/prometheus/prometheus_exporter_utils.h
@@ -0,0 +1,171 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+#ifdef ENABLE_METRICS_PREVIEW
+
+#  include <string>
+#  include <vector>
+
+#  include "opentelemetry/sdk/_metrics/record.h"
+#  include "prometheus/metric_family.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace prometheus
+{
+/**
+ * The Prometheus Utils contains utility functions for Prometheus Exporter
+ */
+class PrometheusExporterUtils
+{
+public:
+  /**
+   * Helper function to convert OpenTelemetry metrics data collection
+   * to Prometheus metrics data collection
+   *
+   * @param records a collection of metrics in OpenTelemetry
+   * @return a collection of translated metrics that is acceptable by Prometheus
+   */
+  static std::vector<::prometheus::MetricFamily> TranslateToPrometheus(
+      const std::vector<opentelemetry::sdk::metrics::Record> &records);
+
+private:
+  /**
+   * Set value to metric family according to record
+   */
+  static void SetMetricFamily(opentelemetry::sdk::metrics::Record &record,
+                              ::prometheus::MetricFamily *metric_family);
+
+  /**
+   * Sanitize the given metric name or label according to Prometheus rule.
+   *
+   * This function is needed because names in OpenTelemetry can contain
+   * alphanumeric characters, '_', '.', and '-', whereas in Prometheus the
+   * name should only contain alphanumeric characters and '_'.
+   */
+  static std::string SanitizeNames(std::string name);
+
+  /**
+   * Set value to metric family for different aggregator
+   */
+  template <typename T>
+  static void SetMetricFamilyByAggregator(
+      std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>> aggregator,
+      std::string labels_str,
+      ::prometheus::MetricFamily *metric_family);
+
+  /**
+   * Translate the OTel metric type to Prometheus metric type
+   */
+  static ::prometheus::MetricType TranslateType(opentelemetry::sdk::metrics::AggregatorKind kind);
+
+  /**
+   * Set metric data for:
+   * Counter => Prometheus Counter
+   * Gauge => Prometheus Gauge
+   */
+  template <typename T>
+  static void SetData(std::vector<T> values,
+                      const std::string &labels,
+                      ::prometheus::MetricType type,
+                      std::chrono::nanoseconds time,
+                      ::prometheus::MetricFamily *metric_family);
+
+  /**
+   * Set metric data for:
+   * Histogram => Prometheus Histogram
+   */
+  template <typename T>
+  static void SetData(std::vector<T> values,
+                      const std::vector<double> &boundaries,
+                      const std::vector<int> &counts,
+                      const std::string &labels,
+                      std::chrono::nanoseconds time,
+                      ::prometheus::MetricFamily *metric_family);
+
+  /**
+   * Set metric data for:
+   * MinMaxSumCount => Prometheus Gauge
+   * Use Average (sum / count) as the gauge metric
+   */
+  static void SetData(double value,
+                      const std::string &labels,
+                      std::chrono::nanoseconds time,
+                      ::prometheus::MetricFamily *metric_family);
+
+  /**
+   * Set metric data for:
+   * Exact => Prometheus Summary
+   * Sketch => Prometheus Summary
+   */
+  template <typename T>
+  static void SetData(std::vector<T> values,
+                      opentelemetry::sdk::metrics::AggregatorKind kind,
+                      const std::vector<T> &quantiles,
+                      const std::string &labels,
+                      std::chrono::nanoseconds time,
+                      ::prometheus::MetricFamily *metric_family,
+                      bool do_quantile,
+                      std::vector<double> quantile_points);
+
+  /**
+   * Set time and labels to metric data
+   */
+  static void SetMetricBasic(::prometheus::ClientMetric &metric,
+                             std::chrono::nanoseconds time,
+                             const std::string &labels);
+
+  /**
+   * Parse a string of labels (key:value) into a vector of pairs
+   * {,}
+   * {l1:v1,l2:v2,...,}
+   */
+  static std::vector<std::pair<std::string, std::string>> ParseLabel(std::string labels);
+
+  /**
+   * Build a quantiles vector from aggregator
+   */
+  template <typename T>
+  static std::vector<T> GetQuantilesVector(
+      std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<T>> aggregator,
+      const std::vector<double> &quantile_points);
+
+  /**
+   * Handle Counter and Gauge.
+   */
+  template <typename T>
+  static void SetValue(std::vector<T> values,
+                       ::prometheus::MetricType type,
+                       ::prometheus::ClientMetric *metric);
+
+  /**
+   * Handle Gauge from MinMaxSumCount
+   */
+  static void SetValue(double value, ::prometheus::ClientMetric *metric);
+
+  /**
+   * Handle Histogram
+   */
+  template <typename T>
+  static void SetValue(std::vector<T> values,
+                       std::vector<double> boundaries,
+                       std::vector<int> counts,
+                       ::prometheus::ClientMetric *metric);
+
+  /**
+   * Handle Exact and Sketch
+   */
+  template <typename T>
+  static void SetValue(std::vector<T> values,
+                       opentelemetry::sdk::metrics::AggregatorKind kind,
+                       std::vector<T> quantiles,
+                       ::prometheus::ClientMetric *metric,
+                       bool do_quantile,
+                       const std::vector<double> &quantile_points);
+};
+}  // namespace prometheus
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/collector.cc b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/collector.cc
new file mode 100644
index 000000000..03793a8ee
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/collector.cc
@@ -0,0 +1,89 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef ENABLE_METRICS_PREVIEW
+
+#  include "opentelemetry/exporters/prometheus/collector.h"
+
+namespace metric_sdk = opentelemetry::sdk::metrics;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace metrics
+{
+/**
+ * Default Constructor.
+ *
+ * This constructor initializes the collection for metrics to export
+ * in this class with default capacity
+ */
+PrometheusCollector::PrometheusCollector(size_t max_collection_size)
+    : max_collection_size_(max_collection_size)
+{}
+
+/**
+ * Collects all metrics data from metricsToCollect collection.
+ *
+ * @return all metrics in the metricsToCollect snapshot
+ */
+std::vector<prometheus_client::MetricFamily> PrometheusCollector::Collect() const
+{
+  this->collection_lock_.lock();
+  if (metrics_to_collect_.empty())
+  {
+    this->collection_lock_.unlock();
+    return {};
+  }
+
+  std::vector<prometheus_client::MetricFamily> result;
+
+  // copy the intermediate collection, and then clear it
+  std::vector<std::unique_ptr<sdk::metrics::ResourceMetrics>> copied_data;
+  copied_data.swap(metrics_to_collect_);
+  this->collection_lock_.unlock();
+
+  result = PrometheusExporterUtils::TranslateToPrometheus(copied_data);
+  return result;
+}
+
+/**
+ * This function is called by export() function and add the collection of
+ * records to the metricsToCollect collection
+ *
+ * @param records a collection of records to add to the metricsToCollect collection
+ */
+void PrometheusCollector::AddMetricData(const sdk::metrics::ResourceMetrics &data)
+{
+  collection_lock_.lock();
+  if (metrics_to_collect_.size() + 1 <= max_collection_size_)
+  {
+    metrics_to_collect_.emplace_back(new sdk::metrics::ResourceMetrics{data});
+  }
+  collection_lock_.unlock();
+}
+
+/**
+ * Get the current collection in the collector.
+ *
+ * @return the current metrics_to_collect collection
+ */
+std::vector<std::unique_ptr<sdk::metrics::ResourceMetrics>> &PrometheusCollector::GetCollection()
+{
+  return metrics_to_collect_;
+}
+
+/**
+ * Gets the maximum size of the collection.
+ *
+ * @return max collection size
+ */
+int PrometheusCollector::GetMaxCollectionSize() const
+{
+  return max_collection_size_;
+}
+
+}  // namespace metrics
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/exporter.cc b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/exporter.cc
new file mode 100644
index 000000000..a0bd9e27a
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/exporter.cc
@@ -0,0 +1,100 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef ENABLE_METRICS_PREVIEW
+#  include "opentelemetry/exporters/prometheus/exporter.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+
+namespace exporter
+{
+namespace metrics
+{
+/**
+ * Constructor - binds an exposer and collector to the exporter
+ * @param address: an address for an exposer that exposes
+ *  an HTTP endpoint for the exporter to connect to
+ */
+PrometheusExporter::PrometheusExporter(const PrometheusExporterOptions &options)
+    : options_(options), is_shutdown_(false)
+{
+  exposer_   = std::unique_ptr<::prometheus::Exposer>(new ::prometheus::Exposer{options_.url});
+  collector_ = std::shared_ptr<PrometheusCollector>(new PrometheusCollector);
+
+  exposer_->RegisterCollectable(collector_);
+}
+
+/**
+ * PrometheusExporter constructor with no parameters
+ * Used for testing only
+ */
+PrometheusExporter::PrometheusExporter() : is_shutdown_(false)
+{
+  collector_ = std::unique_ptr<PrometheusCollector>(new PrometheusCollector);
+}
+
+/**
+ * Exports a batch of Metric Records.
+ * @param records: a collection of records to export
+ * @return: returns a ReturnCode detailing a success, or type of failure
+ */
+sdk::common::ExportResult PrometheusExporter::Export(
+    const sdk::metrics::ResourceMetrics &data) noexcept
+{
+  if (is_shutdown_)
+  {
+    return sdk::common::ExportResult::kFailure;
+  }
+  else if (collector_->GetCollection().size() + 1 > (size_t)collector_->GetMaxCollectionSize())
+  {
+    return sdk::common::ExportResult::kFailureFull;
+  }
+  else
+  {
+    collector_->AddMetricData(data);
+    return sdk::common::ExportResult::kSuccess;
+  }
+  return sdk::common::ExportResult::kSuccess;
+}
+
+bool PrometheusExporter::ForceFlush(std::chrono::microseconds timeout) noexcept
+{
+  return true;
+}
+
+/**
+ * Shuts down the exporter and does cleanup.
+ * Since Prometheus is a pull based interface,
+ * we cannot serve data remaining in the intermediate
+ * collection to to client an HTTP request being sent,
+ * so we flush the data.
+ */
+bool PrometheusExporter::Shutdown(std::chrono::microseconds timeout) noexcept
+{
+  is_shutdown_ = true;
+  return true;
+
+  collector_->GetCollection().clear();
+}
+
+/**
+ * @return: returns a shared_ptr to
+ * the PrometheusCollector instance
+ */
+std::shared_ptr<PrometheusCollector> &PrometheusExporter::GetCollector()
+{
+  return collector_;
+}
+
+/**
+ * @return: Gets the shutdown status of the exporter
+ */
+bool PrometheusExporter::IsShutdown() const
+{
+  return is_shutdown_;
+}
+
+}  // namespace metrics
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif  // ENABLE_METRICS_PREVIEW
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/exporter_utils.cc b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/exporter_utils.cc
new file mode 100644
index 000000000..383925f98
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/exporter_utils.cc
@@ -0,0 +1,314 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef ENABLE_METRICS_PREVIEW
+#  include <sstream>
+#  include <utility>
+#  include <vector>
+
+#  include <prometheus/metric_type.h>
+#  include "opentelemetry/exporters/prometheus/exporter_utils.h"
+#  include "opentelemetry/sdk/metrics/export/metric_producer.h"
+
+#  include "opentelemetry/sdk/common/global_log_handler.h"
+
+namespace prometheus_client = ::prometheus;
+namespace metric_sdk        = opentelemetry::sdk::metrics;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace metrics
+{
+/**
+ * Helper function to convert OpenTelemetry metrics data collection
+ * to Prometheus metrics data collection
+ *
+ * @param records a collection of metrics in OpenTelemetry
+ * @return a collection of translated metrics that is acceptable by Prometheus
+ */
+std::vector<prometheus_client::MetricFamily> PrometheusExporterUtils::TranslateToPrometheus(
+    const std::vector<std::unique_ptr<sdk::metrics::ResourceMetrics>> &data)
+{
+  if (data.empty())
+  {
+    return {};
+  }
+
+  // initialize output vector
+  std::vector<prometheus_client::MetricFamily> output;
+
+  // iterate through the vector and set result data into it
+  for (const auto &r : data)
+  {
+    for (const auto &instrumentation_info : r->instrumentation_info_metric_data_)
+    {
+      for (const auto &metric_data : instrumentation_info.metric_data_)
+      {
+        auto origin_name = metric_data.instrument_descriptor.name_;
+        auto sanitized   = SanitizeNames(origin_name);
+        prometheus_client::MetricFamily metric_family;
+        metric_family.name = sanitized;
+        metric_family.help = metric_data.instrument_descriptor.description_;
+        auto time          = metric_data.start_ts.time_since_epoch();
+        for (const auto &point_data_attr : metric_data.point_data_attr_)
+        {
+          auto kind                                = getAggregationType(point_data_attr.point_data);
+          const prometheus_client::MetricType type = TranslateType(kind);
+          metric_family.type                       = type;
+          if (type == prometheus_client::MetricType::Histogram)  // Histogram
+          {
+            auto histogram_point_data =
+                nostd::get<sdk::metrics::HistogramPointData>(point_data_attr.point_data);
+            auto boundaries = histogram_point_data.boundaries_;
+            auto counts     = histogram_point_data.counts_;
+            SetData(std::vector<double>{nostd::get<double>(histogram_point_data.sum_),
+                                        (double)histogram_point_data.count_},
+                    boundaries, counts, point_data_attr.attributes, time, &metric_family);
+          }
+          else  // Counter, Untyped
+          {
+            auto sum_point_data =
+                nostd::get<sdk::metrics::SumPointData>(point_data_attr.point_data);
+            std::vector<metric_sdk::ValueType> values{sum_point_data.value_};
+            SetData(values, point_data_attr.attributes, type, time, &metric_family);
+          }
+        }
+        output.emplace_back(metric_family);
+      }
+    }
+  }
+  return output;
+}
+
+/**
+ * Sanitize the given metric name or label according to Prometheus rule.
+ *
+ * This function is needed because names in OpenTelemetry can contain
+ * alphanumeric characters, '_', '.', and '-', whereas in Prometheus the
+ * name should only contain alphanumeric characters and '_'.
+ */
+std::string PrometheusExporterUtils::SanitizeNames(std::string name)
+{
+  // replace all '.' and '-' with '_'
+  std::replace(name.begin(), name.end(), '.', '_');
+  std::replace(name.begin(), name.end(), '-', '_');
+
+  return name;
+}
+
+metric_sdk::AggregationType PrometheusExporterUtils::getAggregationType(
+    const metric_sdk::PointType &point_type)
+{
+
+  if (nostd::holds_alternative<sdk::metrics::SumPointData>(point_type))
+  {
+    return metric_sdk::AggregationType::kSum;
+  }
+  else if (nostd::holds_alternative<sdk::metrics::DropPointData>(point_type))
+  {
+    return metric_sdk::AggregationType::kDrop;
+  }
+  else if (nostd::holds_alternative<sdk::metrics::HistogramPointData>(point_type))
+  {
+    return metric_sdk::AggregationType::kHistogram;
+  }
+  else if (nostd::holds_alternative<sdk::metrics::LastValuePointData>(point_type))
+  {
+    return metric_sdk::AggregationType::kLastValue;
+  }
+  return metric_sdk::AggregationType::kDefault;
+}
+
+/**
+ * Translate the OTel metric type to Prometheus metric type
+ */
+prometheus_client::MetricType PrometheusExporterUtils::TranslateType(
+    metric_sdk::AggregationType kind)
+{
+  switch (kind)
+  {
+    case metric_sdk::AggregationType::kSum:
+      return prometheus_client::MetricType::Counter;
+    case metric_sdk::AggregationType::kHistogram:
+      return prometheus_client::MetricType::Histogram;
+    default:
+      return prometheus_client::MetricType::Untyped;
+  }
+}
+
+/**
+ * Set metric data for:
+ * sum => Prometheus Counter
+ */
+template <typename T>
+void PrometheusExporterUtils::SetData(std::vector<T> values,
+                                      const metric_sdk::PointAttributes &labels,
+                                      prometheus_client::MetricType type,
+                                      std::chrono::nanoseconds time,
+                                      prometheus_client::MetricFamily *metric_family)
+{
+  metric_family->metric.emplace_back();
+  prometheus_client::ClientMetric &metric = metric_family->metric.back();
+  SetMetricBasic(metric, time, labels);
+  SetValue(values, type, &metric);
+}
+
+/**
+ * Set metric data for:
+ * Histogram => Prometheus Histogram
+ */
+template <typename T>
+void PrometheusExporterUtils::SetData(std::vector<T> values,
+                                      const opentelemetry::sdk::metrics::ListType &boundaries,
+                                      const std::vector<uint64_t> &counts,
+                                      const metric_sdk::PointAttributes &labels,
+                                      std::chrono::nanoseconds time,
+                                      prometheus_client::MetricFamily *metric_family)
+{
+  metric_family->metric.emplace_back();
+  prometheus_client::ClientMetric &metric = metric_family->metric.back();
+  SetMetricBasic(metric, time, labels);
+  if (nostd::holds_alternative<std::list<long>>(boundaries))
+  {
+    SetValue(values, nostd::get<std::list<long>>(boundaries), counts, &metric);
+  }
+  else
+  {
+    SetValue(values, nostd::get<std::list<double>>(boundaries), counts, &metric);
+  }
+}
+
+/**
+ * Set time and labels to metric data
+ */
+void PrometheusExporterUtils::SetMetricBasic(prometheus_client::ClientMetric &metric,
+                                             std::chrono::nanoseconds time,
+                                             const metric_sdk::PointAttributes &labels)
+{
+  metric.timestamp_ms = time.count() / 1000000;
+
+  // auto label_pairs = ParseLabel(labels);
+  if (!labels.empty())
+  {
+    metric.label.resize(labels.size());
+    size_t i = 0;
+    for (auto const &label : labels)
+    {
+      auto sanitized          = SanitizeNames(label.first);
+      metric.label[i].name    = sanitized;
+      metric.label[i++].value = AttributeValueToString(label.second);
+    }
+  }
+};
+
+std::string PrometheusExporterUtils::AttributeValueToString(
+    const opentelemetry::sdk::common::OwnedAttributeValue &value)
+{
+  std::string result;
+  if (nostd::holds_alternative<bool>(value))
+  {
+    result = nostd::get<bool>(value) ? "true" : "false";
+  }
+  else if (nostd::holds_alternative<int>(value))
+  {
+    result = std::to_string(nostd::get<int>(value));
+  }
+  else if (nostd::holds_alternative<int64_t>(value))
+  {
+    result = std::to_string(nostd::get<int64_t>(value));
+  }
+  else if (nostd::holds_alternative<unsigned int>(value))
+  {
+    result = std::to_string(nostd::get<unsigned int>(value));
+  }
+  else if (nostd::holds_alternative<uint64_t>(value))
+  {
+    result = std::to_string(nostd::get<uint64_t>(value));
+  }
+  else if (nostd::holds_alternative<double>(value))
+  {
+    result = std::to_string(nostd::get<double>(value));
+  }
+  else if (nostd::holds_alternative<std::string>(value))
+  {
+    result = nostd::get<std::string>(value);
+  }
+  else
+  {
+    OTEL_INTERNAL_LOG_WARN(
+        "[Prometheus Exporter] AttributeValueToString - "
+        " Nested attributes not supported - ignored");
+  }
+  return result;
+}
+
+/**
+ * Handle Counter.
+ */
+template <typename T>
+void PrometheusExporterUtils::SetValue(std::vector<T> values,
+                                       prometheus_client::MetricType type,
+                                       prometheus_client::ClientMetric *metric)
+{
+  double value          = 0.0;
+  const auto &value_var = values[0];
+  if (nostd::holds_alternative<long>(value_var))
+  {
+    value = nostd::get<long>(value_var);
+  }
+  else
+  {
+    value = nostd::get<double>(value_var);
+  }
+
+  switch (type)
+  {
+    case prometheus_client::MetricType::Counter: {
+      metric->counter.value = value;
+      break;
+    }
+    case prometheus_client::MetricType::Untyped: {
+      metric->untyped.value = value;
+      break;
+    }
+    default:
+      return;
+  }
+}
+
+/**
+ * Handle Histogram
+ */
+template <typename T, typename U>
+void PrometheusExporterUtils::SetValue(std::vector<T> values,
+                                       const std::list<U> &boundaries,
+                                       const std::vector<uint64_t> &counts,
+                                       prometheus_client::ClientMetric *metric)
+{
+  metric->histogram.sample_sum   = values[0];
+  metric->histogram.sample_count = values[1];
+  int cumulative                 = 0;
+  std::vector<prometheus_client::ClientMetric::Bucket> buckets;
+  uint32_t idx = 0;
+  for (const auto &boundary : boundaries)
+  {
+    prometheus_client::ClientMetric::Bucket bucket;
+    cumulative += counts[idx];
+    bucket.cumulative_count = cumulative;
+    bucket.upper_bound      = boundary;
+    buckets.emplace_back(bucket);
+    ++idx;
+  }
+  prometheus_client::ClientMetric::Bucket bucket;
+  cumulative += counts[idx];
+  bucket.cumulative_count = cumulative;
+  bucket.upper_bound      = std::numeric_limits<double>::infinity();
+  buckets.emplace_back(bucket);
+  metric->histogram.bucket = buckets;
+}
+
+}  // namespace metrics
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/prometheus_collector.cc b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/prometheus_collector.cc
new file mode 100644
index 000000000..53b7913de
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/prometheus_collector.cc
@@ -0,0 +1,166 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_METRICS_PREVIEW
+#  include <iostream>
+
+#  include "opentelemetry/exporters/prometheus/prometheus_collector.h"
+
+namespace metric_sdk = opentelemetry::sdk::metrics;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace prometheus
+{
+/**
+ * Default Constructor.
+ *
+ * This constructor initializes the collection for metrics to export
+ * in this class with default capacity
+ */
+PrometheusCollector::PrometheusCollector(size_t max_collection_size)
+    : max_collection_size_(max_collection_size)
+{
+  metrics_to_collect_ =
+      std::unique_ptr<std::vector<metric_sdk::Record>>(new std::vector<metric_sdk::Record>);
+}
+
+/**
+ * Collects all metrics data from metricsToCollect collection.
+ *
+ * @return all metrics in the metricsToCollect snapshot
+ */
+std::vector<prometheus_client::MetricFamily> PrometheusCollector::Collect() const
+{
+  this->collection_lock_.lock();
+  if (metrics_to_collect_->empty())
+  {
+    this->collection_lock_.unlock();
+    return {};
+  }
+  this->collection_lock_.unlock();
+
+  std::vector<prometheus_client::MetricFamily> result;
+
+  // copy the intermediate collection, and then clear it
+  std::vector<metric_sdk::Record> copied_data;
+
+  this->collection_lock_.lock();
+  copied_data = std::vector<metric_sdk::Record>(*metrics_to_collect_);
+  metrics_to_collect_->clear();
+  this->collection_lock_.unlock();
+
+  result = PrometheusExporterUtils::TranslateToPrometheus(copied_data);
+  return result;
+}
+
+/**
+ * This function is called by export() function and add the collection of
+ * records to the metricsToCollect collection
+ *
+ * @param records a collection of records to add to the metricsToCollect collection
+ */
+void PrometheusCollector::AddMetricData(const std::vector<sdk::metrics::Record> &records)
+{
+  if (records.empty())
+  {
+    return;
+  }
+
+  collection_lock_.lock();
+  if (metrics_to_collect_->size() + records.size() <= max_collection_size_)
+  {
+    /**
+     *  ValidAggregator is a lambda that checks a Record to see if its
+     *  Aggregator is a valid nostd::shared_ptr and not a nullptr.
+     */
+    auto ValidAggregator = [](sdk::metrics::Record record) {
+      auto aggregator_variant = record.GetAggregator();
+      if (nostd::holds_alternative<std::shared_ptr<metric_sdk::Aggregator<int>>>(
+              aggregator_variant))
+      {
+        auto aggregator =
+            nostd::get<std::shared_ptr<metric_sdk::Aggregator<int>>>(aggregator_variant);
+        if (!aggregator)
+        {
+          return false;
+        }
+      }
+      else if (nostd::holds_alternative<std::shared_ptr<metric_sdk::Aggregator<short>>>(
+                   aggregator_variant))
+      {
+        auto aggregator =
+            nostd::get<std::shared_ptr<metric_sdk::Aggregator<short>>>(aggregator_variant);
+        if (!aggregator)
+        {
+          return false;
+        }
+      }
+      else if (nostd::holds_alternative<std::shared_ptr<metric_sdk::Aggregator<float>>>(
+                   aggregator_variant))
+      {
+        auto aggregator =
+            nostd::get<std::shared_ptr<metric_sdk::Aggregator<float>>>(aggregator_variant);
+        if (!aggregator)
+        {
+          return false;
+        }
+      }
+      else if (nostd::holds_alternative<std::shared_ptr<metric_sdk::Aggregator<double>>>(
+                   aggregator_variant))
+      {
+        auto aggregator =
+            nostd::get<std::shared_ptr<metric_sdk::Aggregator<double>>>(aggregator_variant);
+        if (!aggregator)
+        {
+          return false;
+        }
+      }
+
+      return true;
+    };
+
+    for (auto &r : records)
+    {
+      if (ValidAggregator(r))
+      {
+        metrics_to_collect_->emplace_back(r);
+      }
+      // Drop the record and write to std::cout
+      else
+      {
+        // Cannot call non const functions on const Record r
+        sdk::metrics::Record c = r;
+        std::cout << "Dropped Record containing invalid aggregator with name: " + c.GetName()
+                  << std::endl;
+      }
+    }
+  }
+  collection_lock_.unlock();
+}
+
+/**
+ * Get the current collection in the collector.
+ *
+ * @return the current metrics_to_collect collection
+ */
+std::vector<sdk::metrics::Record> PrometheusCollector::GetCollection()
+{
+  return *metrics_to_collect_;
+}
+
+/**
+ * Gets the maximum size of the collection.
+ *
+ * @return max collection size
+ */
+int PrometheusCollector::GetMaxCollectionSize() const
+{
+  return max_collection_size_;
+}
+
+}  // namespace prometheus
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/prometheus_exporter.cc b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/prometheus_exporter.cc
new file mode 100644
index 000000000..b64af1e90
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/prometheus_exporter.cc
@@ -0,0 +1,110 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifdef ENABLE_METRICS_PREVIEW
+#  include "opentelemetry/exporters/prometheus/prometheus_exporter.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+
+namespace exporter
+{
+namespace prometheus
+{
+/**
+ * Constructor - binds an exposer and collector to the exporter
+ * @param address: an address for an exposer that exposes
+ *  an HTTP endpoint for the exporter to connect to
+ */
+PrometheusExporter::PrometheusExporter(std::string &address) : is_shutdown_(false)
+{
+  exposer_   = std::unique_ptr<::prometheus::Exposer>(new ::prometheus::Exposer{address});
+  collector_ = std::shared_ptr<PrometheusCollector>(new PrometheusCollector);
+
+  exposer_->RegisterCollectable(collector_);
+}
+
+/**
+ * PrometheusExporter constructor with no parameters
+ * Used for testing only
+ */
+PrometheusExporter::PrometheusExporter() : is_shutdown_(false)
+{
+  collector_ = std::unique_ptr<PrometheusCollector>(new PrometheusCollector);
+}
+
+/**
+ * Exports a batch of Metric Records.
+ * @param records: a collection of records to export
+ * @return: returns a ReturnCode detailing a success, or type of failure
+ */
+sdk::common::ExportResult PrometheusExporter::Export(
+    const std::vector<sdk::metrics::Record> &records) noexcept
+{
+  if (is_shutdown_)
+  {
+    return sdk::common::ExportResult::kFailure;
+  }
+  else if (records.empty())
+  {
+    return sdk::common::ExportResult::kFailureInvalidArgument;
+  }
+  else if (collector_->GetCollection().size() + records.size() >
+           (size_t)collector_->GetMaxCollectionSize())
+  {
+    return sdk::common::ExportResult::kFailureFull;
+  }
+  else
+  {
+    collector_->AddMetricData(records);
+    return sdk::common::ExportResult::kSuccess;
+  }
+}
+
+/**
+ * Shuts down the exporter and does cleanup.
+ * Since Prometheus is a pull based interface,
+ * we cannot serve data remaining in the intermediate
+ * collection to to client an HTTP request being sent,
+ * so we flush the data.
+ */
+void PrometheusExporter::Shutdown() noexcept
+{
+  is_shutdown_ = true;
+
+  collector_->GetCollection().clear();
+}
+
+/**
+ * @return: returns a shared_ptr to
+ * the PrometheusCollector instance
+ */
+std::shared_ptr<PrometheusCollector> &PrometheusExporter::GetCollector()
+{
+  return collector_;
+}
+
+/**
+ * @return: Gets the shutdown status of the exporter
+ */
+bool PrometheusExporter::IsShutdown() const
+{
+  return is_shutdown_;
+}
+
+}  // namespace prometheus
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif  // ENABLE_METRICS_PREVIEW
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/prometheus_exporter_utils.cc b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/prometheus_exporter_utils.cc
new file mode 100644
index 000000000..5eec9e3e8
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/src/prometheus_exporter_utils.cc
@@ -0,0 +1,446 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_METRICS_PREVIEW
+#  include <iostream>
+#  include <sstream>
+#  include <utility>
+#  include <vector>
+
+#  include "opentelemetry/exporters/prometheus/prometheus_exporter_utils.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/aggregator.h"
+#  include "prometheus/metric_type.h"
+
+namespace prometheus_client = ::prometheus;
+namespace metric_sdk        = opentelemetry::sdk::metrics;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace prometheus
+{
+/**
+ * Helper function to convert OpenTelemetry metrics data collection
+ * to Prometheus metrics data collection
+ *
+ * @param records a collection of metrics in OpenTelemetry
+ * @return a collection of translated metrics that is acceptable by Prometheus
+ */
+std::vector<prometheus_client::MetricFamily> PrometheusExporterUtils::TranslateToPrometheus(
+    const std::vector<metric_sdk::Record> &records)
+{
+  if (records.empty())
+  {
+    return {};
+  }
+
+  // initialize output vector
+  std::vector<prometheus_client::MetricFamily> output(records.size());
+
+  // iterate through the vector and set result data into it
+  int i = 0;
+  for (auto r : records)
+  {
+    SetMetricFamily(r, &output[i]);
+    i++;
+  }
+
+  return output;
+}
+
+// ======================= private helper functions =========================
+/**
+ * Set value to metric family according to record
+ */
+void PrometheusExporterUtils::SetMetricFamily(metric_sdk::Record &record,
+                                              prometheus_client::MetricFamily *metric_family)
+{
+
+  auto origin_name    = record.GetName();
+  auto sanitized      = SanitizeNames(origin_name);
+  metric_family->name = sanitized;
+  metric_family->help = record.GetDescription();
+
+  // unpack the variant and set the metric data to metric family struct
+  auto agg_var    = record.GetAggregator();
+  auto labels_str = record.GetLabels();
+  if (nostd::holds_alternative<std::shared_ptr<metric_sdk::Aggregator<int>>>(agg_var))
+  {
+    auto aggregator = nostd::get<std::shared_ptr<metric_sdk::Aggregator<int>>>(agg_var);
+    SetMetricFamilyByAggregator(aggregator, labels_str, metric_family);
+  }
+  else if (nostd::holds_alternative<std::shared_ptr<metric_sdk::Aggregator<short>>>(agg_var))
+  {
+    auto aggregator = nostd::get<std::shared_ptr<metric_sdk::Aggregator<short>>>(agg_var);
+    SetMetricFamilyByAggregator(aggregator, labels_str, metric_family);
+  }
+  else if (nostd::holds_alternative<std::shared_ptr<metric_sdk::Aggregator<float>>>(
+               record.GetAggregator()))
+  {
+    auto aggregator = nostd::get<std::shared_ptr<metric_sdk::Aggregator<float>>>(agg_var);
+    SetMetricFamilyByAggregator(aggregator, labels_str, metric_family);
+  }
+  else if (nostd::holds_alternative<std::shared_ptr<metric_sdk::Aggregator<double>>>(
+               record.GetAggregator()))
+  {
+    auto aggregator = nostd::get<std::shared_ptr<metric_sdk::Aggregator<double>>>(agg_var);
+    SetMetricFamilyByAggregator(aggregator, labels_str, metric_family);
+  }
+}
+
+/**
+ * Sanitize the given metric name or label according to Prometheus rule.
+ *
+ * This function is needed because names in OpenTelemetry can contain
+ * alphanumeric characters, '_', '.', and '-', whereas in Prometheus the
+ * name should only contain alphanumeric characters and '_'.
+ */
+std::string PrometheusExporterUtils::SanitizeNames(std::string name)
+{
+  // replace all '.' and '-' with '_'
+  std::replace(name.begin(), name.end(), '.', '_');
+  std::replace(name.begin(), name.end(), '-', '_');
+
+  return name;
+}
+
+/**
+ * Set value to metric family for different aggregator
+ */
+template <typename T>
+void PrometheusExporterUtils::SetMetricFamilyByAggregator(
+    std::shared_ptr<metric_sdk::Aggregator<T>> aggregator,
+    std::string labels_str,
+    prometheus_client::MetricFamily *metric_family)
+{
+  // get aggregator kind and translate to Prometheus metric type
+  auto kind                                = aggregator->get_aggregator_kind();
+  const prometheus_client::MetricType type = TranslateType(kind);
+  metric_family->type                      = type;
+  // get check-pointed values, label string and check-pointed time
+  auto checkpointed_values = aggregator->get_checkpoint();
+  auto time                = aggregator->get_checkpoint_timestamp().time_since_epoch();
+
+  if (type == prometheus_client::MetricType::Histogram)  // Histogram
+  {
+    auto boundaries = aggregator->get_boundaries();
+    auto counts     = aggregator->get_counts();
+    SetData(checkpointed_values, boundaries, counts, labels_str, time, metric_family);
+  }
+  else if (type == prometheus_client::MetricType::Summary)  // Sketch, Exact
+  {
+    std::vector<double> quantile_points = {0, 0.5, 0.9, 0.95, 0.99, 1};
+    if (kind == metric_sdk::AggregatorKind::Exact)
+    {
+      std::vector<T> quantiles;
+      bool do_quantile = aggregator->get_quant_estimation();
+      if (do_quantile)
+      {
+        quantiles = GetQuantilesVector(aggregator, quantile_points);
+      }
+      SetData(checkpointed_values, kind, quantiles, labels_str, time, metric_family, do_quantile,
+              quantile_points);
+    }
+    else if (kind == metric_sdk::AggregatorKind::Sketch)
+    {
+      auto quantiles = GetQuantilesVector(aggregator, quantile_points);
+      SetData(checkpointed_values, kind, quantiles, labels_str, time, metric_family, true,
+              quantile_points);
+    }
+  }
+  else  // Counter, Gauge, MinMaxSumCount, Untyped
+  {
+    // Handle MinMaxSumCount: https://github.com/open-telemetry/opentelemetry-cpp/issues/228
+    // Use sum/count is ok.
+    if (kind == metric_sdk::AggregatorKind::MinMaxSumCount)
+    {
+      double avg = (double)checkpointed_values[2] / checkpointed_values[3];
+      SetData(avg, labels_str, time, metric_family);
+    }
+    else
+    {
+      SetData(checkpointed_values, labels_str, type, time, metric_family);
+    }
+  }
+}
+
+/**
+ * Translate the OTel metric type to Prometheus metric type
+ */
+prometheus_client::MetricType PrometheusExporterUtils::TranslateType(
+    metric_sdk::AggregatorKind kind)
+{
+  switch (kind)
+  {
+    case metric_sdk::AggregatorKind::Counter:
+      return prometheus_client::MetricType::Counter;
+    case metric_sdk::AggregatorKind::Gauge:
+    case metric_sdk::AggregatorKind::MinMaxSumCount:
+      return prometheus_client::MetricType::Gauge;
+    case metric_sdk::AggregatorKind::Histogram:
+      return prometheus_client::MetricType::Histogram;
+    case metric_sdk::AggregatorKind::Sketch:
+    case metric_sdk::AggregatorKind::Exact:
+      return prometheus_client::MetricType::Summary;
+    default:
+      return prometheus_client::MetricType::Untyped;
+  }
+}
+
+/**
+ * Set metric data for:
+ * Counter => Prometheus Counter
+ * Gauge => Prometheus Gauge
+ */
+template <typename T>
+void PrometheusExporterUtils::SetData(std::vector<T> values,
+                                      const std::string &labels,
+                                      prometheus_client::MetricType type,
+                                      std::chrono::nanoseconds time,
+                                      prometheus_client::MetricFamily *metric_family)
+{
+  metric_family->metric.emplace_back();
+  prometheus_client::ClientMetric &metric = metric_family->metric.back();
+  SetMetricBasic(metric, time, labels);
+  SetValue(values, type, &metric);
+}
+
+/**
+ * Set metric data for:
+ * Histogram => Prometheus Histogram
+ */
+template <typename T>
+void PrometheusExporterUtils::SetData(std::vector<T> values,
+                                      const std::vector<double> &boundaries,
+                                      const std::vector<int> &counts,
+                                      const std::string &labels,
+                                      std::chrono::nanoseconds time,
+                                      prometheus_client::MetricFamily *metric_family)
+{
+  metric_family->metric.emplace_back();
+  prometheus_client::ClientMetric &metric = metric_family->metric.back();
+  SetMetricBasic(metric, time, labels);
+  SetValue(values, boundaries, counts, &metric);
+}
+
+/**
+ * Set metric data for:
+ * MinMaxSumCount => Prometheus Gauge
+ * Use Average (sum / count) as the gauge metric
+ */
+void PrometheusExporterUtils::SetData(double value,
+                                      const std::string &labels,
+                                      std::chrono::nanoseconds time,
+                                      prometheus_client::MetricFamily *metric_family)
+{
+  metric_family->metric.emplace_back();
+  prometheus_client::ClientMetric &metric = metric_family->metric.back();
+  SetMetricBasic(metric, time, labels);
+  SetValue(value, &metric);
+}
+
+/**
+ * Set metric data for:
+ * Exact => Prometheus Summary
+ * Sketch => Prometheus Summary
+ */
+template <typename T>
+void PrometheusExporterUtils::SetData(std::vector<T> values,
+                                      metric_sdk::AggregatorKind kind,
+                                      const std::vector<T> &quantiles,
+                                      const std::string &labels,
+                                      std::chrono::nanoseconds time,
+                                      prometheus_client::MetricFamily *metric_family,
+                                      bool do_quantile,
+                                      std::vector<double> quantile_points)
+{
+  metric_family->metric.emplace_back();
+  prometheus_client::ClientMetric &metric = metric_family->metric.back();
+  SetMetricBasic(metric, time, labels);
+  SetValue(values, kind, quantiles, &metric, do_quantile, quantile_points);
+}
+
+/**
+ * Set time and labels to metric data
+ */
+void PrometheusExporterUtils::SetMetricBasic(prometheus_client::ClientMetric &metric,
+                                             std::chrono::nanoseconds time,
+                                             const std::string &labels)
+{
+  metric.timestamp_ms = time.count() / 1000000;
+
+  auto label_pairs = ParseLabel(labels);
+  if (!label_pairs.empty())
+  {
+    metric.label.resize(label_pairs.size());
+    for (size_t i = 0; i < label_pairs.size(); ++i)
+    {
+      auto origin_name      = label_pairs[i].first;
+      auto sanitized        = SanitizeNames(origin_name);
+      metric.label[i].name  = sanitized;
+      metric.label[i].value = label_pairs[i].second;
+    }
+  }
+};
+
+/**
+ * Parse a string of labels (key:value) into a vector of pairs
+ * {,}
+ * {l1:v1,l2:v2,...,}
+ */
+std::vector<std::pair<std::string, std::string>> PrometheusExporterUtils::ParseLabel(
+    std::string labels)
+{
+  labels = labels.substr(1, labels.size() - 2);
+
+  std::vector<std::string> paired_labels;
+  std::stringstream s_stream(labels);
+  while (s_stream.good())
+  {
+    std::string substr;
+    getline(s_stream, substr, ',');  // get first string delimited by comma
+    if (!substr.empty())
+    {
+      paired_labels.push_back(substr);
+    }
+  }
+
+  std::vector<std::pair<std::string, std::string>> result;
+  for (auto &paired : paired_labels)
+  {
+    std::size_t split_index = paired.find(':');
+    std::string label       = paired.substr(0, split_index);
+    std::string value       = paired.substr(split_index + 1);
+    result.emplace_back(std::pair<std::string, std::string>(label, value));
+  }
+
+  return result;
+}
+
+/**
+ * Build a quantiles vector from aggregator
+ */
+template <typename T>
+std::vector<T> PrometheusExporterUtils::GetQuantilesVector(
+    std::shared_ptr<metric_sdk::Aggregator<T>> aggregator,
+    const std::vector<double> &quantile_points)
+{
+  std::vector<T> quantiles;
+  for (double q : quantile_points)
+  {
+    T quantile = aggregator->get_quantiles(q);
+    quantiles.emplace_back(quantile);
+  }
+  return quantiles;
+}
+
+/**
+ * Handle Counter and Gauge.
+ */
+template <typename T>
+void PrometheusExporterUtils::SetValue(std::vector<T> values,
+                                       prometheus_client::MetricType type,
+                                       prometheus_client::ClientMetric *metric)
+{
+  switch (type)
+  {
+    case prometheus_client::MetricType::Counter: {
+      metric->counter.value = values[0];
+      break;
+    }
+    case prometheus_client::MetricType::Gauge: {
+      metric->gauge.value = values[0];
+      break;
+    }
+    case prometheus_client::MetricType::Untyped: {
+      metric->untyped.value = values[0];
+      break;
+    }
+    default:
+      return;
+  }
+}
+
+/**
+ * Handle Gauge from MinMaxSumCount
+ */
+void PrometheusExporterUtils::SetValue(double value, prometheus_client::ClientMetric *metric)
+{
+  metric->gauge.value = value;
+}
+
+/**
+ * Handle Histogram
+ */
+template <typename T>
+void PrometheusExporterUtils::SetValue(std::vector<T> values,
+                                       std::vector<double> boundaries,
+                                       std::vector<int> counts,
+                                       prometheus_client::ClientMetric *metric)
+{
+  metric->histogram.sample_sum   = values[0];
+  metric->histogram.sample_count = values[1];
+  int cumulative                 = 0;
+  std::vector<prometheus_client::ClientMetric::Bucket> buckets;
+  for (size_t i = 0; i < boundaries.size() + 1; i++)
+  {
+    prometheus_client::ClientMetric::Bucket bucket;
+    cumulative += counts[i];
+    bucket.cumulative_count = cumulative;
+    if (i != boundaries.size())
+    {
+      bucket.upper_bound = boundaries[i];
+    }
+    else
+    {
+      bucket.upper_bound = std::numeric_limits<double>::infinity();
+    }
+    buckets.emplace_back(bucket);
+  }
+  metric->histogram.bucket = buckets;
+}
+
+/**
+ * Handle Exact and Sketch
+ */
+template <typename T>
+void PrometheusExporterUtils::SetValue(std::vector<T> values,
+                                       metric_sdk::AggregatorKind kind,
+                                       std::vector<T> quantiles,
+                                       prometheus_client::ClientMetric *metric,
+                                       bool do_quantile,
+                                       const std::vector<double> &quantile_points)
+{
+  if (kind == metric_sdk::AggregatorKind::Exact)
+  {
+    metric->summary.sample_count = values.size();
+    auto sum                     = 0;
+    for (auto val : values)
+    {
+      sum += val;
+    }
+    metric->summary.sample_sum = sum;
+  }
+  else if (kind == metric_sdk::AggregatorKind::Sketch)
+  {
+    metric->summary.sample_sum   = values[0];
+    metric->summary.sample_count = values[1];
+  }
+
+  if (do_quantile)
+  {
+    std::vector<prometheus_client::ClientMetric::Quantile> prometheus_quantiles;
+    for (size_t i = 0; i < quantiles.size(); i++)
+    {
+      prometheus_client::ClientMetric::Quantile quantile;
+      quantile.quantile = quantile_points[i];
+      quantile.value    = quantiles[i];
+      prometheus_quantiles.emplace_back(quantile);
+    }
+    metric->summary.quantile = prometheus_quantiles;
+  }
+}
+}  // namespace prometheus
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/test/CMakeLists.txt b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/test/CMakeLists.txt
new file mode 100644
index 000000000..1a2246979
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/test/CMakeLists.txt
@@ -0,0 +1,13 @@
+if(WITH_METRICS_PREVIEW)
+  foreach(testname prometheus_exporter_test prometheus_collector_test
+                   prometheus_exporter_utils_test)
+    add_executable(${testname} "${testname}.cc")
+    target_link_libraries(
+      ${testname} ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
+      prometheus_exporter_deprecated prometheus-cpp::pull)
+    gtest_add_tests(
+      TARGET ${testname}
+      TEST_PREFIX exporter.
+      TEST_LIST ${testname})
+  endforeach()
+endif()
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/test/prometheus_collector_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/test/prometheus_collector_test.cc
new file mode 100644
index 000000000..d1aff1b0f
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/test/prometheus_collector_test.cc
@@ -0,0 +1,756 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_METRICS_PREVIEW
+#  include <gtest/gtest.h>
+#  include <future>
+#  include <map>
+#  include <thread>
+
+#  include "opentelemetry/_metrics/instrument.h"
+#  include "opentelemetry/exporters/prometheus/prometheus_collector.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/counter_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/exact_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/gauge_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/histogram_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/min_max_sum_count_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/sketch_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/record.h"
+#  include "opentelemetry/version.h"
+
+using opentelemetry::exporter::prometheus::PrometheusCollector;
+namespace metric_api = opentelemetry::metrics;
+namespace metric_sdk = opentelemetry::sdk::metrics;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+
+/**
+ * CreateAgg() is a helper function that returns a
+ * nostd::shared_ptr given an AggregatorKind
+ */
+template <typename T>
+std::shared_ptr<metric_sdk::Aggregator<T>> CreateAgg(metric_sdk::AggregatorKind kind,
+                                                     bool exactMode = true)
+{
+  std::shared_ptr<metric_sdk::Aggregator<T>> aggregator;
+  switch (kind)
+  {
+    case metric_sdk::AggregatorKind::Counter: {
+      aggregator = std::shared_ptr<metric_sdk::Aggregator<T>>(
+          new metric_sdk::CounterAggregator<T>(metric_api::InstrumentKind::Counter));
+      break;
+    }
+    case metric_sdk::AggregatorKind::MinMaxSumCount: {
+      aggregator = std::shared_ptr<metric_sdk::Aggregator<T>>(
+          new metric_sdk::MinMaxSumCountAggregator<T>(metric_api::InstrumentKind::Counter));
+      break;
+    }
+    case metric_sdk::AggregatorKind::Gauge: {
+      aggregator = std::shared_ptr<metric_sdk::Aggregator<T>>(
+          new metric_sdk::GaugeAggregator<T>(metric_api::InstrumentKind::Counter));
+      break;
+    }
+    case metric_sdk::AggregatorKind::Sketch: {
+      aggregator = std::shared_ptr<metric_sdk::Aggregator<T>>(
+          new metric_sdk::SketchAggregator<T>(metric_api::InstrumentKind::Counter, 0.000005));
+      break;
+    }
+    case metric_sdk::AggregatorKind::Histogram: {
+      std::vector<double> boundaries{10, 20};
+      aggregator = std::shared_ptr<metric_sdk::Aggregator<T>>(
+          new metric_sdk::HistogramAggregator<T>(metric_api::InstrumentKind::Counter, boundaries));
+      break;
+    }
+    case metric_sdk::AggregatorKind::Exact: {
+      aggregator = std::shared_ptr<metric_sdk::Aggregator<T>>(
+          new metric_sdk::ExactAggregator<T>(metric_api::InstrumentKind::Counter, exactMode));
+      break;
+    }
+    default:
+      aggregator = nullptr;
+  }
+  return aggregator;
+}
+
+/**
+ * Populate() updates the aggregator with values and checkpoints it based
+ * on what its AggregatorKind is
+ */
+template <typename T>
+void Populate(std::shared_ptr<metric_sdk::Aggregator<T>> &aggregator)
+{
+  if (aggregator->get_aggregator_kind() == metric_sdk::AggregatorKind::Counter)
+  {
+    aggregator->update(10.0);
+    aggregator->update(5.0);
+    aggregator->checkpoint();
+  }
+  else if (aggregator->get_aggregator_kind() == metric_sdk::AggregatorKind::MinMaxSumCount)
+  {
+    aggregator->update(10);
+    aggregator->update(2);
+    aggregator->update(5);
+    aggregator->checkpoint();
+  }
+  else if (aggregator->get_aggregator_kind() == metric_sdk::AggregatorKind::Gauge)
+  {
+    aggregator->update(10);
+    aggregator->update(5);
+    aggregator->checkpoint();
+  }
+  else if (aggregator->get_aggregator_kind() == metric_sdk::AggregatorKind::Sketch)
+  {
+    for (double i = 0; i < 10.0; i++)
+    {
+      aggregator->update(i);
+    }
+    aggregator->checkpoint();
+  }
+  else if (aggregator->get_aggregator_kind() == metric_sdk::AggregatorKind::Histogram)
+  {
+    for (float i = 0; i < 30.0; i++)
+    {
+      aggregator->update(i);
+    }
+    aggregator->checkpoint();
+  }
+  else if (aggregator->get_aggregator_kind() == metric_sdk::AggregatorKind::Exact)
+  {
+    for (double i = 0; i < 10.0; i++)
+    {
+      aggregator->update(i);
+    }
+    aggregator->checkpoint();
+  }
+}
+
+/**
+ * Helper function to create a collection of records taken from
+ * a aggregator of specified AggregatorKind
+ */
+template <typename T>
+std::vector<metric_sdk::Record> CreateRecords(int num,
+                                              metric_sdk::AggregatorKind kind,
+                                              bool exactMode = true)
+{
+  std::vector<metric_sdk::Record> records;
+
+  for (int i = 0; i < num; i++)
+  {
+    std::string name        = "record-" + std::to_string(i);
+    std::string description = "record " + std::to_string(i) + " for test purpose";
+    std::string labels      = "{label1:v1,label2:v2,}";
+    std::shared_ptr<metric_sdk::Aggregator<T>> aggregator = CreateAgg<T>(kind, exactMode);
+    Populate(aggregator);
+
+    metric_sdk::Record r{name, description, labels, aggregator};
+    records.push_back(r);
+  }
+  return records;
+}
+
+// ==================== Test for addMetricsData() function ======================
+
+/**
+ * AddMetricData() should be able to successfully add a collection
+ * of Records with Counter Aggregators. It checks that the cumulative
+ * sum of updates to the aggregator of a record before and after AddMetricData()
+ * is called are equal.
+ */
+TEST(PrometheusCollector, AddMetricDataWithCounterRecordsSuccessfully)
+{
+  PrometheusCollector collector;
+
+  // number of records to create
+  int num_records = 2;
+
+  // construct a collection of records with CounterAggregators and double
+  std::vector<metric_sdk::Record> records =
+      CreateRecords<double>(num_records, metric_sdk::AggregatorKind::Counter);
+
+  // add records to collection
+  collector.AddMetricData(records);
+
+  // Collection size should be the same as the size
+  // of the records collection passed to addMetricData()
+  ASSERT_EQ(collector.GetCollection().size(), records.size());
+
+  // check values of records created vs records from metricsToCollect,
+  // accessed by getCollection()
+
+  for (int i = 0; i < num_records; i++)
+  {
+    metric_sdk::Record before = records[i];
+    metric_sdk::Record after  = collector.GetCollection()[i];
+
+    ASSERT_EQ(before.GetName(), after.GetName());
+
+    ASSERT_EQ(before.GetDescription(), after.GetDescription());
+
+    ASSERT_EQ(before.GetLabels(), after.GetLabels());
+
+    auto before_agg_var = before.GetAggregator();
+    auto before_agg = nostd::get<std::shared_ptr<metric_sdk::Aggregator<double>>>(before_agg_var);
+
+    auto after_agg_var = after.GetAggregator();
+    auto after_agg     = nostd::get<std::shared_ptr<metric_sdk::Aggregator<double>>>(after_agg_var);
+
+    ASSERT_EQ(before_agg->get_checkpoint().size(), after_agg->get_checkpoint().size());
+    for (size_t i = 0; i < before_agg->get_checkpoint().size(); i++)
+    {
+      ASSERT_EQ(before_agg->get_checkpoint()[i], after_agg->get_checkpoint()[i]);
+    }
+  }
+}
+
+/**
+ * AddMetricData() should be able to successfully add a collection
+ * of Records with MinMaxSumCount Aggregators. It checks that the min, max,
+ * sum, and count of updates to the aggregator of a record before and after AddMetricData()
+ * is called are equal.
+ */
+TEST(PrometheusCollector, AddMetricDataWithMinMaxSumCountRecordsSuccessfully)
+{
+  PrometheusCollector collector;
+
+  // number of records to create
+  int num_records = 2;
+
+  // construct a collection of records with MinMaxSumCountAggregators and short
+  std::vector<metric_sdk::Record> records =
+      CreateRecords<short>(num_records, metric_sdk::AggregatorKind::MinMaxSumCount);
+
+  // add records to collection
+  collector.AddMetricData(records);
+
+  // Collection size should be the same as the size
+  // of the records collection passed to addMetricData()
+  ASSERT_EQ(collector.GetCollection().size(), records.size());
+
+  // check values of records created vs records from metricsToCollect,
+  // accessed by getCollection()
+
+  for (int i = 0; i < num_records; i++)
+  {
+    metric_sdk::Record before = records[i];
+    metric_sdk::Record after  = collector.GetCollection()[i];
+
+    ASSERT_EQ(before.GetName(), after.GetName());
+
+    ASSERT_EQ(before.GetDescription(), after.GetDescription());
+
+    ASSERT_EQ(before.GetLabels(), after.GetLabels());
+
+    auto before_agg_var = before.GetAggregator();
+    auto before_agg = nostd::get<std::shared_ptr<metric_sdk::Aggregator<short>>>(before_agg_var);
+
+    auto after_agg_var = after.GetAggregator();
+    auto after_agg     = nostd::get<std::shared_ptr<metric_sdk::Aggregator<short>>>(after_agg_var);
+
+    ASSERT_EQ(before_agg->get_checkpoint().size(), after_agg->get_checkpoint().size());
+    for (size_t i = 0; i < before_agg->get_checkpoint().size(); i++)
+    {
+      ASSERT_EQ(before_agg->get_checkpoint()[i], after_agg->get_checkpoint()[i]);
+    }
+  }
+}
+
+/**
+ * AddMetricData() should be able to successfully add a collection
+ * of Records with Gauge Aggregators. It checks that the last update
+ * to the aggregator of a record before and after AddMetricData()
+ * is called are equal.
+ */
+TEST(PrometheusCollector, AddMetricDataWithGaugeRecordsSuccessfully)
+{
+  PrometheusCollector collector;
+
+  // number of records to create
+  int num_records = 2;
+
+  // construct a collection of records with GaugeAggregators and int
+  std::vector<metric_sdk::Record> records =
+      CreateRecords<int>(num_records, metric_sdk::AggregatorKind::Gauge);
+
+  // add records to collection
+  collector.AddMetricData(records);
+
+  // Collection size should be the same as the size
+  // of the records collection passed to addMetricData()
+  ASSERT_EQ(collector.GetCollection().size(), records.size());
+
+  // check values of records created vs records from metricsToCollect,
+  // accessed by getCollection()
+
+  for (int i = 0; i < num_records; i++)
+  {
+    metric_sdk::Record before = records[i];
+    metric_sdk::Record after  = collector.GetCollection()[i];
+
+    ASSERT_EQ(before.GetName(), after.GetName());
+
+    ASSERT_EQ(before.GetDescription(), after.GetDescription());
+
+    ASSERT_EQ(before.GetLabels(), after.GetLabels());
+
+    auto before_agg_var = before.GetAggregator();
+    auto before_agg     = nostd::get<std::shared_ptr<metric_sdk::Aggregator<int>>>(before_agg_var);
+
+    auto after_agg_var = after.GetAggregator();
+    auto after_agg     = nostd::get<std::shared_ptr<metric_sdk::Aggregator<int>>>(after_agg_var);
+
+    ASSERT_EQ(before_agg->get_checkpoint().size(), after_agg->get_checkpoint().size());
+    for (size_t i = 0; i < before_agg->get_checkpoint().size(); i++)
+    {
+      ASSERT_EQ(before_agg->get_checkpoint()[i], after_agg->get_checkpoint()[i]);
+    }
+  }
+}
+
+/**
+ * AddMetricData() should be able to successfully add a collection
+ * of Records with Sketch Aggregators. It checks that the sum of updates
+ * and count of values added for a record before and after being added are
+ * equal using get_checkpoint(). It also checks the same for buckets, in
+ * get_boundaries(), and counts for buckets, in get_counts().
+ */
+TEST(PrometheusCollector, AddMetricDataWithSketchRecordsSuccessfully)
+{
+  PrometheusCollector collector;
+
+  // number of records to create
+  int num_records = 2;
+
+  // construct a collection of records with SketchAggregators and double
+  std::vector<metric_sdk::Record> records =
+      CreateRecords<double>(num_records, metric_sdk::AggregatorKind::Sketch);
+
+  // add records to collection
+  collector.AddMetricData(records);
+
+  // Collection size should be the same as the size
+  // of the records collection passed to addMetricData()
+  ASSERT_EQ(collector.GetCollection().size(), records.size());
+
+  // check values of records created vs records from metricsToCollect,
+  // accessed by getCollection()
+
+  for (int i = 0; i < num_records; i++)
+  {
+    metric_sdk::Record before = records[i];
+    metric_sdk::Record after  = collector.GetCollection()[i];
+
+    ASSERT_EQ(before.GetName(), after.GetName());
+
+    ASSERT_EQ(before.GetDescription(), after.GetDescription());
+
+    ASSERT_EQ(before.GetLabels(), after.GetLabels());
+
+    auto before_agg_var = before.GetAggregator();
+    auto before_agg = nostd::get<std::shared_ptr<metric_sdk::Aggregator<double>>>(before_agg_var);
+
+    auto after_agg_var = after.GetAggregator();
+    auto after_agg     = nostd::get<std::shared_ptr<metric_sdk::Aggregator<double>>>(after_agg_var);
+
+    ASSERT_EQ(before_agg->get_checkpoint().size(), after_agg->get_checkpoint().size());
+    for (size_t i = 0; i < before_agg->get_checkpoint().size(); i++)
+    {
+      ASSERT_EQ(before_agg->get_checkpoint()[i], after_agg->get_checkpoint()[i]);
+    }
+    for (size_t i = 0; i < before_agg->get_boundaries().size(); i++)
+    {
+      ASSERT_EQ(before_agg->get_boundaries()[i], after_agg->get_boundaries()[i]);
+    }
+    for (size_t i = 0; i < before_agg->get_counts().size(); i++)
+    {
+      ASSERT_EQ(before_agg->get_counts()[i], after_agg->get_counts()[i]);
+    }
+  }
+}
+
+/**
+ * AddMetricData() should be able to successfully add a collection
+ * of Records with Histogram Aggregators. It checks that the sum of
+ * updates, number of updates, boundaries, and counts for each bucket
+ * for the aggregator of a record before and after AddMetricData()
+ * is called are equal.
+ */
+TEST(PrometheusCollector, AddMetricDataWithHistogramRecordsSuccessfully)
+{
+  PrometheusCollector collector;
+
+  // number of records to create
+  int num_records = 2;
+
+  // construct a collection of records with HistogramAggregators and float
+  std::vector<metric_sdk::Record> records =
+      CreateRecords<float>(num_records, metric_sdk::AggregatorKind::Histogram);
+
+  // add records to collection
+  collector.AddMetricData(records);
+
+  // Collection size should be the same as the size
+  // of the records collection passed to addMetricData()
+  ASSERT_EQ(collector.GetCollection().size(), records.size());
+
+  // check values of records created vs records from metricsToCollect,
+  // accessed by getCollection()
+
+  for (int i = 0; i < num_records; i++)
+  {
+    metric_sdk::Record before = records[i];
+    metric_sdk::Record after  = collector.GetCollection()[i];
+
+    ASSERT_EQ(before.GetName(), after.GetName());
+
+    ASSERT_EQ(before.GetDescription(), after.GetDescription());
+
+    ASSERT_EQ(before.GetLabels(), after.GetLabels());
+
+    auto before_agg_var = before.GetAggregator();
+    auto before_agg = nostd::get<std::shared_ptr<metric_sdk::Aggregator<float>>>(before_agg_var);
+
+    auto after_agg_var = after.GetAggregator();
+    auto after_agg     = nostd::get<std::shared_ptr<metric_sdk::Aggregator<float>>>(after_agg_var);
+
+    ASSERT_EQ(before_agg->get_checkpoint().size(), after_agg->get_checkpoint().size());
+    for (size_t i = 0; i < before_agg->get_checkpoint().size(); i++)
+    {
+      ASSERT_EQ(before_agg->get_checkpoint()[i], after_agg->get_checkpoint()[i]);
+    }
+    for (size_t i = 0; i < before_agg->get_boundaries().size(); i++)
+    {
+      ASSERT_EQ(before_agg->get_boundaries()[i], after_agg->get_boundaries()[i]);
+    }
+    for (size_t i = 0; i < before_agg->get_counts().size(); i++)
+    {
+      ASSERT_EQ(before_agg->get_counts()[i], after_agg->get_counts()[i]);
+    }
+  }
+}
+
+/**
+ * AddMetricData() should be able to successfully add a collection
+ * of Records with Exact Aggregators. If the Exact Aggregator is in
+ * quantile mode, it will check quantiles at selected values of 0, 0.25,
+ * 0.5, 0.75, and 1. If not, it will check the vector of checkpointed
+ * values in get_checkpoint().
+ */
+TEST(PrometheusCollector, AddMetricDataWithExactRecordsSuccessfully)
+{
+  PrometheusCollector collector;
+
+  // number of records to create
+  int num_records = 1;
+
+  // construct a collection of a single record with a quantile
+  // estimation ExactAggregator and double
+  std::vector<metric_sdk::Record> records =
+      CreateRecords<double>(num_records, metric_sdk::AggregatorKind::Exact, true);
+
+  // add records to collection
+  collector.AddMetricData(records);
+
+  // construct a collection of a single record with an in-order
+  // ExactAggregator and double
+  records = CreateRecords<double>(num_records, metric_sdk::AggregatorKind::Exact, false);
+
+  // add records to collection
+  collector.AddMetricData(records);
+
+  // Collection size should be the same as the size
+  // of the records collection passed to addMetricData()
+  ASSERT_EQ(collector.GetCollection().size(), records.size() * 2);
+
+  // check values of records created vs records from metricsToCollect,
+  // accessed by getCollection()
+
+  for (int i = 0; i < num_records; i++)
+  {
+    metric_sdk::Record before = records[i];
+    metric_sdk::Record after  = collector.GetCollection()[i];
+
+    ASSERT_EQ(before.GetName(), after.GetName());
+
+    ASSERT_EQ(before.GetDescription(), after.GetDescription());
+
+    ASSERT_EQ(before.GetLabels(), after.GetLabels());
+
+    auto before_agg_var = before.GetAggregator();
+    auto before_agg = nostd::get<std::shared_ptr<metric_sdk::Aggregator<double>>>(before_agg_var);
+
+    auto after_agg_var = after.GetAggregator();
+    auto after_agg     = nostd::get<std::shared_ptr<metric_sdk::Aggregator<double>>>(after_agg_var);
+
+    if (before_agg->get_quant_estimation() && after_agg->get_quant_estimation())
+    {
+      for (double i = 0; i <= 1;)
+      {
+        ASSERT_EQ(before_agg->get_quantiles(i), after_agg->get_quantiles(i));
+        i += 0.25;
+      }
+    }
+    else
+    {
+      ASSERT_EQ(before_agg->get_checkpoint().size(), after_agg->get_checkpoint().size());
+      for (size_t i = 0; i < before_agg->get_checkpoint().size(); i++)
+      {
+        ASSERT_EQ(before_agg->get_checkpoint()[i], after_agg->get_checkpoint()[i]);
+      }
+    }
+  }
+}
+
+TEST(PrometheusCollector, AddMetricDataDoesNotAddWithInsufficentSpace)
+{
+  PrometheusCollector collector;
+
+  // number of records to create
+  int num_records = collector.GetMaxCollectionSize() - 5;
+
+  // construct a collection close to max capacity
+  std::vector<metric_sdk::Record> records =
+      CreateRecords<double>(num_records, metric_sdk::AggregatorKind::Counter);
+
+  collector.AddMetricData(records);
+
+  // Check if all the records have been added
+  ASSERT_EQ(collector.GetCollection().size(), num_records);
+
+  // Try adding the same collection of records again to
+  // metricsToCollect.
+  collector.AddMetricData(records);
+
+  // Check that the number of records in metricsToCollect
+  // has not changed.
+  ASSERT_EQ(collector.GetCollection().size(), num_records);
+}
+
+TEST(PrometheusCollector, AddMetricDataDoesNotAddBadIndividualRecords)
+{
+  PrometheusCollector collector;
+
+  // number of records to create
+  int num_records = 5;
+
+  // construct a collection with the specified number of records
+  std::vector<metric_sdk::Record> records =
+      CreateRecords<double>(num_records, metric_sdk::AggregatorKind::Counter);
+
+  // add records to collection
+  collector.AddMetricData(records);
+
+  // Check if all the records have been added
+  ASSERT_EQ(collector.GetCollection().size(), num_records);
+
+  // Creates a bad record, with a nullptr aggregator and adds
+  // it to the colelction of records
+  std::string name        = "bad_record";
+  std::string description = "nullptr_agg";
+  std::string labels      = "{label1:v1}";
+  std::shared_ptr<metric_sdk::Aggregator<int>> aggregator;
+  metric_sdk::Record bad_record{name, description, labels, aggregator};
+
+  records.push_back(bad_record);
+
+  // add records to collection
+  collector.AddMetricData(records);
+
+  // Check if all the records except the bad
+  // record have been added; the number of records added
+  // should be twice the original number of records
+  // epecified to be created
+  ASSERT_EQ(collector.GetCollection().size(), num_records * 2);
+}
+
+// ==================== Test for Constructor ======================
+TEST(PrometheusCollector, ConstructorInitializesCollector)
+{
+  PrometheusCollector collector;
+
+  // current size should be 0, capacity should be set to default
+  ASSERT_EQ(collector.GetCollection().size(), 0);
+}
+
+// ==================== Tests for collect() function ======================
+
+/**
+ * When collector is initialized, the collection inside is should also be initialized
+ */
+TEST(PrometheusCollector, CollectInitializesMetricFamilyCollection)
+{
+  PrometheusCollector collector;
+  auto c1 = collector.Collect();
+  ASSERT_EQ(c1.size(), 0);
+}
+
+/**
+ * Collect function should collect all data and clear the intermediate collection
+ */
+TEST(PrometheusCollector, CollectClearsTheCollection)
+{
+  PrometheusCollector collector;
+
+  // construct a collection to add metric records
+  int num_records = 2;
+  auto records    = CreateRecords<int>(num_records, metric_sdk::AggregatorKind::Counter);
+  collector.AddMetricData(records);
+
+  // the collection should not be empty now
+  ASSERT_EQ(collector.GetCollection().size(), num_records);
+
+  // don't care the collected result in this test
+  collector.Collect();
+
+  // after the collect() call, the collection should be empty
+  ASSERT_EQ(collector.GetCollection().size(), 0);
+}
+
+/**
+ * Collected data should be already be parsed to Prometheus Metric format
+ */
+TEST(PrometheusCollector, CollectParsesDataToMetricFamily)
+{
+  PrometheusCollector collector;
+
+  // construct a collection to add metric records
+  int num_records = 1;
+  auto records    = CreateRecords<int>(num_records, metric_sdk::AggregatorKind::Counter);
+  collector.AddMetricData(records);
+
+  // the collection should not be empty now
+  ASSERT_EQ(collector.GetCollection().size(), num_records);
+  auto collected = collector.Collect();
+
+  ASSERT_EQ(collected.size(), num_records);
+
+  auto metric_family = collected[0];
+
+  // Collect function really collects a vector of MetricFamily
+  ASSERT_EQ(metric_family.name, "record_0");
+  ASSERT_EQ(metric_family.help, "record 0 for test purpose");
+  ASSERT_EQ(metric_family.type, prometheus_client::MetricType::Counter);
+  ASSERT_EQ(metric_family.metric.size(), 1);
+  ASSERT_DOUBLE_EQ(metric_family.metric[0].counter.value, 15);
+}
+
+/**
+ * Concurrency Test 1: After adding data concurrently, the intermediate collection should
+ * contain all data from all threads.
+ */
+TEST(PrometheusCollector, ConcurrencyAddingRecords)
+{
+  PrometheusCollector collector;
+
+  // construct a collection to add metric records
+  int num_records = 2;
+  std::vector<metric_sdk::Record> records1 =
+      CreateRecords<int>(num_records, metric_sdk::AggregatorKind::Counter);
+
+  std::vector<metric_sdk::Record> records2 =
+      CreateRecords<int>(num_records, metric_sdk::AggregatorKind::Gauge);
+
+  std::thread first(&PrometheusCollector::AddMetricData, std::ref(collector), std::ref(records1));
+  std::thread second(&PrometheusCollector::AddMetricData, std::ref(collector), std::ref(records2));
+
+  first.join();
+  second.join();
+
+  ASSERT_EQ(collector.GetCollection().size(), 4);
+}
+
+/**
+ * Concurrency Test 2: After adding data concurrently and collecting, the intermediate collection
+ * should be empty, and all data are collected in the result vector.
+ */
+TEST(PrometheusCollector, ConcurrentlyAddingAndThenCollecting)
+{
+  PrometheusCollector collector;
+
+  // construct a collection to add metric records
+  int num_records = 2;
+  std::vector<metric_sdk::Record> records1 =
+      CreateRecords<int>(num_records, metric_sdk::AggregatorKind::Counter);
+
+  std::vector<metric_sdk::Record> records2 =
+      CreateRecords<int>(num_records, metric_sdk::AggregatorKind::Gauge);
+
+  std::thread first(&PrometheusCollector::AddMetricData, std::ref(collector), std::ref(records1));
+  std::thread second(&PrometheusCollector::AddMetricData, std::ref(collector), std::ref(records2));
+  first.join();
+  second.join();
+
+  auto collect_future = std::async(&PrometheusCollector::Collect, std::ref(collector));
+  auto res            = collect_future.get();
+
+  ASSERT_EQ(collector.GetCollection().size(), 0);
+  ASSERT_EQ(res.size(), 4);
+}
+
+/**
+ * Concurrency Test 3: Concurrently adding and collecting. We don't know when the collect function
+ * is called, but all data entries are either collected or left in the collection.
+ */
+TEST(PrometheusCollector, ConcurrentlyAddingAndCollecting)
+{
+  PrometheusCollector collector;
+
+  // construct a collection to add metric records
+  int num_records = 2;
+  std::vector<metric_sdk::Record> records1 =
+      CreateRecords<int>(num_records, metric_sdk::AggregatorKind::Counter);
+
+  std::vector<metric_sdk::Record> records2 =
+      CreateRecords<int>(num_records, metric_sdk::AggregatorKind::Gauge);
+
+  std::thread first(&PrometheusCollector::AddMetricData, std::ref(collector), std::ref(records1));
+  std::thread second(&PrometheusCollector::AddMetricData, std::ref(collector), std::ref(records2));
+  auto collect_future = std::async(&PrometheusCollector::Collect, std::ref(collector));
+
+  first.join();
+  second.join();
+
+  auto res = collect_future.get();
+
+  // the size of collection can be 0, 2, 4, because we don't know when the collect()
+  // is really called. However, we claim that if the data in the collection is collected,
+  // they must be in the res. So res.size() + collection.size() must be the total number
+  // of data records we generated.
+  ASSERT_EQ(res.size() + collector.GetCollection().size(), 4);
+}
+
+/**
+ * Concurrency Test 4: Concurrently adding then concurrently collecting. We don't know which
+ * collecting thread fetches all data, but either one should succeed.
+ */
+TEST(PrometheusCollector, ConcurrentlyAddingAndConcurrentlyCollecting)
+{
+  PrometheusCollector collector;
+
+  // construct a collection to add metric records
+  int num_records = 2;
+  std::vector<metric_sdk::Record> records1 =
+      CreateRecords<int>(num_records, metric_sdk::AggregatorKind::Counter);
+
+  std::vector<metric_sdk::Record> records2 =
+      CreateRecords<int>(num_records, metric_sdk::AggregatorKind::Gauge);
+
+  // concurrently adding
+  std::thread first(&PrometheusCollector::AddMetricData, std::ref(collector), std::ref(records1));
+  std::thread second(&PrometheusCollector::AddMetricData, std::ref(collector), std::ref(records2));
+  first.join();
+  second.join();
+
+  // after adding, then concurrently consuming
+  auto collect_future1 = std::async(&PrometheusCollector::Collect, std::ref(collector));
+  auto collect_future2 = std::async(&PrometheusCollector::Collect, std::ref(collector));
+  auto res1            = collect_future1.get();
+  auto res2            = collect_future2.get();
+
+  // all added data must be collected in either res1 or res2
+  ASSERT_EQ(res1.size() + res2.size(), 4);
+}
+
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/test/prometheus_exporter_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/test/prometheus_exporter_test.cc
new file mode 100644
index 000000000..564880c26
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/test/prometheus_exporter_test.cc
@@ -0,0 +1,218 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifdef ENABLE_METRICS_PREVIEW
+
+#  include <gtest/gtest.h>
+#  include <typeinfo>
+
+#  include "opentelemetry/exporters/prometheus/prometheus_collector.h"
+#  include "opentelemetry/exporters/prometheus/prometheus_exporter.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/counter_aggregator.h"
+#  include "opentelemetry/version.h"
+
+/**
+ * PrometheusExporterTest is a friend class of PrometheusExporter.
+ * It has access to a private constructor that does not take in
+ * an exposer as an argument, and instead takes no arguments; this
+ * private constructor is only to be used here for testing
+ */
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace prometheus
+{
+class PrometheusExporterTest  // : public ::testing::Test
+{
+public:
+  PrometheusExporter GetExporter() { return PrometheusExporter(); }
+};
+}  // namespace prometheus
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+
+using opentelemetry::exporter::prometheus::PrometheusCollector;
+using opentelemetry::exporter::prometheus::PrometheusExporter;
+using opentelemetry::exporter::prometheus::PrometheusExporterTest;
+using opentelemetry::sdk::common::ExportResult;
+using opentelemetry::sdk::metrics::CounterAggregator;
+using opentelemetry::sdk::metrics::Record;
+
+/**
+ * Helper function to create a collection of records taken from
+ * a counter aggregator
+ */
+std::vector<Record> CreateRecords(int num)
+{
+
+  std::vector<Record> records;
+
+  for (int i = 0; i < num; i++)
+  {
+    std::string name        = "record-" + std::to_string(i);
+    std::string description = "record-" + std::to_string(i);
+    std::string labels      = "record-" + std::to_string(i) + "-label-1.0";
+    auto aggregator         = std::shared_ptr<opentelemetry::sdk::metrics::Aggregator<int>>(
+        new opentelemetry::sdk::metrics::CounterAggregator<int>(
+            opentelemetry::metrics::InstrumentKind::Counter));
+    aggregator->update(10);
+    aggregator->checkpoint();
+
+    Record r{name, description, labels, aggregator};
+    records.push_back(r);
+  }
+  return records;
+}
+
+/**
+ * When a PrometheusExporter is initialized,
+ * isShutdown should be false.
+ */
+TEST(PrometheusExporter, InitializeConstructorIsNotShutdown)
+{
+  PrometheusExporterTest p;
+  PrometheusExporter exporter = p.GetExporter();
+
+  // // Asserts that the exporter is not shutdown.
+  ASSERT_TRUE(!exporter.IsShutdown());
+}
+
+/**
+ * The shutdown() function should set the isShutdown field to true.
+ */
+TEST(PrometheusExporter, ShutdownSetsIsShutdownToTrue)
+{
+  PrometheusExporterTest p;
+  PrometheusExporter exporter = p.GetExporter();
+
+  // exporter shuold not be shutdown by default
+  ASSERT_TRUE(!exporter.IsShutdown());
+
+  exporter.Shutdown();
+
+  // the exporter shuold be shutdown
+  ASSERT_TRUE(exporter.IsShutdown());
+
+  // shutdown function should be idempotent
+  exporter.Shutdown();
+  ASSERT_TRUE(exporter.IsShutdown());
+}
+
+/**
+ * The Export() function should return kSuccess = 0
+ *  when data is exported successfully.
+ */
+TEST(PrometheusExporter, ExportSuccessfully)
+{
+  PrometheusExporterTest p;
+  PrometheusExporter exporter = p.GetExporter();
+
+  int num_records = 2;
+
+  std::vector<Record> records = CreateRecords(num_records);
+
+  auto res = exporter.Export(records);
+
+  // result should be kSuccess = 0
+  ExportResult code = ExportResult::kSuccess;
+  ASSERT_EQ(res, code);
+}
+
+/**
+ * If the exporter is shutdown, it cannot process
+ * any more export requests and returns kFailure = 1.
+ */
+TEST(PrometheusExporter, ExporterIsShutdown)
+{
+  PrometheusExporterTest p;
+  PrometheusExporter exporter = p.GetExporter();
+
+  int num_records = 1;
+
+  std::vector<Record> records = CreateRecords(num_records);
+
+  exporter.Shutdown();
+
+  // send export request after shutdown
+  auto res = exporter.Export(records);
+
+  // result code should be kFailure = 1
+  ExportResult code = ExportResult::kFailure;
+  ASSERT_EQ(res, code);
+}
+
+/**
+ * The Export() function should return
+ * kFailureFull = 2 when the collection is full,
+ * or when the collection is not full but does not have enough
+ * space to hold the batch data.
+ */
+TEST(PrometheusExporter, CollectionNotEnoughSpace)
+{
+  PrometheusExporterTest p;
+  PrometheusExporter exporter = p.GetExporter();
+
+  int num_records = 2;
+
+  // prepare two collections of records to export,
+  // one close to max size and another one that, when added
+  // to the first, will exceed the size of the collection
+
+  int max_collection_size = exporter.GetCollector()->GetMaxCollectionSize();
+
+  std::vector<Record> full_records = CreateRecords(max_collection_size - 1);
+  std::vector<Record> records      = CreateRecords(num_records);
+
+  // send export request to fill the
+  // collection in the collector
+  auto res = exporter.Export(full_records);
+
+  // the result code should be kSuccess = 0
+  ExportResult code = ExportResult::kSuccess;
+  ASSERT_EQ(res, code);
+
+  // send export request that does not complete
+  // due to not enough space in the collection
+  res = exporter.Export(records);
+
+  // the result code should be kFailureFull = 2
+  code = ExportResult::kFailureFull;
+  ASSERT_EQ(res, code);
+}
+
+/**
+ *  The Export() function should return
+ *  kFailureInvalidArgument = 3 when an empty collection
+ *  of records is passed to the Export() function.
+ */
+TEST(PrometheusExporter, InvalidArgumentWhenPassedEmptyRecordCollection)
+{
+  PrometheusExporterTest p;
+  PrometheusExporter exporter = p.GetExporter();
+
+  // Initializes an empty colelction of records
+  std::vector<Record> records;
+
+  // send export request to fill the
+  // collection in the collector
+  auto res = exporter.Export(records);
+
+  // the result code should be kFailureInvalidArgument = 3
+  ExportResult code = ExportResult::kFailureInvalidArgument;
+  ASSERT_EQ(res, code);
+}
+
+#endif  // ENABLE_METRICS_PREVIEW
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/test/prometheus_exporter_utils_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/test/prometheus_exporter_utils_test.cc
new file mode 100644
index 000000000..22ce3f5fd
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/prometheus/test/prometheus_exporter_utils_test.cc
@@ -0,0 +1,460 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifdef ENABLE_METRICS_PREVIEW
+#  include <gtest/gtest.h>
+#  include <map>
+#  include <numeric>
+#  include <string>
+#  include <typeinfo>
+
+#  include <opentelemetry/version.h>
+#  include "opentelemetry/exporters/prometheus/prometheus_exporter_utils.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/counter_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/exact_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/gauge_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/histogram_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/min_max_sum_count_aggregator.h"
+#  include "opentelemetry/sdk/_metrics/aggregator/sketch_aggregator.h"
+
+using opentelemetry::exporter::prometheus::PrometheusExporterUtils;
+namespace metric_sdk        = opentelemetry::sdk::metrics;
+namespace metric_api        = opentelemetry::metrics;
+namespace prometheus_client = ::prometheus;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+template <typename T>
+void assert_basic(prometheus_client::MetricFamily &metric,
+                  const std::string &sanitized_name,
+                  const std::string &description,
+                  prometheus_client::MetricType type,
+                  int label_num,
+                  std::vector<T> vals)
+{
+  ASSERT_EQ(metric.name, sanitized_name);  // name sanitized
+  ASSERT_EQ(metric.help, description);     // description not changed
+  ASSERT_EQ(metric.type, type);            // type translated
+
+  auto metric_data = metric.metric[0];
+  ASSERT_EQ(metric_data.label.size(), label_num);
+
+  switch (type)
+  {
+    case prometheus_client::MetricType::Counter: {
+      ASSERT_DOUBLE_EQ(metric_data.counter.value, vals[0]);
+      break;
+    }
+    case prometheus_client::MetricType::Gauge: {
+      ASSERT_EQ(metric_data.gauge.value, vals[0]);
+      break;
+    }
+    case prometheus_client::MetricType::Histogram: {
+      ASSERT_DOUBLE_EQ(metric_data.histogram.sample_count, vals[0]);
+      ASSERT_DOUBLE_EQ(metric_data.histogram.sample_sum, vals[1]);
+      auto buckets = metric_data.histogram.bucket;
+      ASSERT_EQ(buckets.size(), vals[2]);
+      break;
+    }
+    case prometheus_client::MetricType::Summary: {
+      ASSERT_DOUBLE_EQ(metric_data.summary.sample_count, vals[0]);
+      ASSERT_DOUBLE_EQ(metric_data.summary.sample_sum, vals[1]);
+      break;
+    }
+    case prometheus::MetricType::Untyped:
+      break;
+  }
+}
+
+void assert_histogram(prometheus_client::MetricFamily &metric,
+                      std::vector<double> boundaries,
+                      std::vector<int> correct)
+{
+  int cumulative_count = 0;
+  auto buckets         = metric.metric[0].histogram.bucket;
+  for (size_t i = 0; i < buckets.size(); i++)
+  {
+    auto bucket = buckets[i];
+    if (i != buckets.size() - 1)
+    {
+      ASSERT_DOUBLE_EQ(boundaries[i], bucket.upper_bound);
+    }
+    else
+    {
+      ASSERT_DOUBLE_EQ(std::numeric_limits<double>::infinity(), bucket.upper_bound);
+    }
+    cumulative_count += correct[i];
+    ASSERT_EQ(cumulative_count, bucket.cumulative_count);
+  }
+}
+
+template <typename T>
+metric_sdk::Record get_record(const std::string &type,
+                              int version,
+                              const std::string &label,
+                              std::shared_ptr<metric_sdk::Aggregator<T>> aggregator)
+{
+  std::string name = "test-" + type + "-metric-record-v_" + std::to_string(version) + ".0";
+  std::string desc = "this is a test " + type + " metric record";
+  metric_sdk::Record record(name, desc, label, aggregator);
+  return record;
+}
+
+TEST(PrometheusExporterUtils, TranslateToPrometheusEmptyInputReturnsEmptyCollection)
+{
+  std::vector<metric_sdk::Record> collection;
+  auto translated2 = PrometheusExporterUtils::TranslateToPrometheus(collection);
+  ASSERT_EQ(translated2.size(), 0);
+}
+
+TEST(PrometheusExporterUtils, TranslateToPrometheusIntegerCounter)
+{
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<int>>(
+      new metric_sdk::CounterAggregator<int>(metric_api::InstrumentKind::Counter));
+
+  std::vector<metric_sdk::Record> collection;
+
+  auto record1 = get_record("int-counter", 1, "{label1:v1,label2:v2,label3:v3,}", aggregator);
+  aggregator->update(10);
+  aggregator->checkpoint();
+  collection.emplace_back(record1);
+
+  auto translated = PrometheusExporterUtils::TranslateToPrometheus(collection);
+  ASSERT_EQ(translated.size(), collection.size());
+
+  auto metric1          = translated[0];
+  std::vector<int> vals = {10};
+  assert_basic(metric1, "test_int_counter_metric_record_v_1_0", record1.GetDescription(),
+               prometheus_client::MetricType::Counter, 3, vals);
+
+  auto record2 = get_record("int-counter", 2, "{,}", aggregator);
+  aggregator->update(20);
+  aggregator->update(30);
+  aggregator->checkpoint();
+  collection.emplace_back(record2);
+
+  translated = PrometheusExporterUtils::TranslateToPrometheus(collection);
+  ASSERT_EQ(translated.size(), collection.size());
+
+  auto metric2 = translated[1];
+  vals         = {50};
+  assert_basic(metric2, "test_int_counter_metric_record_v_2_0", record2.GetDescription(),
+               prometheus_client::MetricType::Counter, 0, vals);
+}
+
+TEST(PrometheusExporterUtils, TranslateToPrometheusDoubleCounter)
+{
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<double>>(
+      new metric_sdk::CounterAggregator<double>(metric_api::InstrumentKind::Counter));
+
+  std::vector<metric_sdk::Record> collection;
+  aggregator->update(10.5);
+  aggregator->checkpoint();
+  auto record1 = get_record("double-counter", 1, "{label1:v1,label2:v2,label3:v3,}", aggregator);
+  aggregator->update(22.4);
+  aggregator->update(31.2);
+  aggregator->checkpoint();
+  auto record2 = get_record("double-counter", 2, "{,}", aggregator);
+  collection.emplace_back(record1);
+  collection.emplace_back(record2);
+
+  auto translated = PrometheusExporterUtils::TranslateToPrometheus(collection);
+  ASSERT_EQ(translated.size(), collection.size());
+
+  auto metric1             = translated[0];
+  std::vector<double> vals = {53.6};
+  assert_basic(metric1, "test_double_counter_metric_record_v_1_0", record1.GetDescription(),
+               prometheus_client::MetricType::Counter, 3, vals);
+  auto metric2 = translated[1];
+  assert_basic(metric2, "test_double_counter_metric_record_v_2_0", record2.GetDescription(),
+               prometheus_client::MetricType::Counter, 0, vals);
+}
+
+TEST(PrometheusExporterUtils, TranslateToPrometheusShortCounter)
+{
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<short>>(
+      new metric_sdk::CounterAggregator<short>(metric_api::InstrumentKind::Counter));
+
+  std::vector<metric_sdk::Record> collection;
+  aggregator->update(10);
+  aggregator->checkpoint();
+  auto record1 = get_record("short-counter", 1, "{label1:v1,label2:v2,label3:v3,}", aggregator);
+  aggregator->update(20);
+  aggregator->update(30);
+  aggregator->checkpoint();
+  auto record2 = get_record("short-counter", 2, "{,}", aggregator);
+  collection.emplace_back(record1);
+  collection.emplace_back(record2);
+
+  auto translated = PrometheusExporterUtils::TranslateToPrometheus(collection);
+  ASSERT_EQ(translated.size(), collection.size());
+
+  auto metric1            = translated[0];
+  std::vector<short> vals = {50};
+  assert_basic(metric1, "test_short_counter_metric_record_v_1_0", record1.GetDescription(),
+               prometheus_client::MetricType::Counter, 3, vals);
+  auto metric2 = translated[1];
+  assert_basic(metric2, "test_short_counter_metric_record_v_2_0", record2.GetDescription(),
+               prometheus_client::MetricType::Counter, 0, vals);
+}
+
+TEST(PrometheusExporterUtils, TranslateToPrometheusFloatCounter)
+{
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<float>>(
+      new metric_sdk::CounterAggregator<float>(metric_api::InstrumentKind::Counter));
+
+  std::vector<metric_sdk::Record> collection;
+  aggregator->update(10.5f);
+  aggregator->checkpoint();
+  auto record1 = get_record("float-counter", 1, "{label1:v1,label2:v2,label3:v3,}", aggregator);
+  aggregator->update(22.4f);
+  aggregator->update(31.2f);
+  aggregator->checkpoint();
+  auto record2 = get_record("float-counter", 2, "{,}", aggregator);
+  collection.emplace_back(record1);
+  collection.emplace_back(record2);
+
+  auto translated = PrometheusExporterUtils::TranslateToPrometheus(collection);
+  ASSERT_EQ(translated.size(), collection.size());
+
+  auto metric1            = translated[0];
+  std::vector<float> vals = {53.6f};
+  assert_basic(metric1, "test_float_counter_metric_record_v_1_0", record1.GetDescription(),
+               prometheus_client::MetricType::Counter, 3, vals);
+  auto metric2 = translated[1];
+  assert_basic(metric2, "test_float_counter_metric_record_v_2_0", record2.GetDescription(),
+               prometheus_client::MetricType::Counter, 0, vals);
+}
+
+TEST(PrometheusExporterUtils, TranslateToPrometheusGauge)
+{
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<int>>(
+      new metric_sdk::GaugeAggregator<int>(metric_api::InstrumentKind::Counter));
+
+  std::vector<metric_sdk::Record> collection;
+  aggregator->update(10);
+  aggregator->checkpoint();
+  auto record1 = get_record("gauge", 1, "{label1:v1,label2:v2,label3:v3,}", aggregator);
+  aggregator->update(20);
+  aggregator->update(30);
+  aggregator->checkpoint();
+  auto record2 = get_record("gauge", 2, "{,}", aggregator);
+  collection.emplace_back(record1);
+  collection.emplace_back(record2);
+
+  auto translated = PrometheusExporterUtils::TranslateToPrometheus(collection);
+  ASSERT_EQ(translated.size(), collection.size());
+
+  auto metric1          = translated[0];
+  std::vector<int> vals = {30};
+  assert_basic(metric1, "test_gauge_metric_record_v_1_0", record1.GetDescription(),
+               prometheus_client::MetricType::Gauge, 3, vals);
+  auto metric2 = translated[1];
+  assert_basic(metric2, "test_gauge_metric_record_v_2_0", record2.GetDescription(),
+               prometheus_client::MetricType::Gauge, 0, vals);
+}
+
+TEST(PrometheusExporterUtils, TranslateToPrometheusHistogramUniform)
+{
+  std::vector<double> boundaries{10, 20, 30, 40, 50};
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<int>>(
+      new metric_sdk::HistogramAggregator<int>(metric_api::InstrumentKind::Counter, boundaries));
+
+  std::vector<metric_sdk::Record> collection;
+  auto record = get_record("histogram-uniform", 1, "{label1:v1,label2:v2,label3:v3,}", aggregator);
+  int count_num = 60;
+  for (int i = 0; i < count_num; i++)
+  {
+    aggregator->update(i);
+  }
+  aggregator->checkpoint();
+  collection.emplace_back(record);
+
+  auto translated = PrometheusExporterUtils::TranslateToPrometheus(collection);
+  ASSERT_EQ(translated.size(), collection.size());
+
+  auto metric           = translated[0];
+  std::vector<int> vals = {aggregator->get_checkpoint()[1], aggregator->get_checkpoint()[0],
+                           (int)boundaries.size() + 1};
+  assert_basic(metric, "test_histogram_uniform_metric_record_v_1_0", record.GetDescription(),
+               prometheus_client::MetricType::Histogram, 3, vals);
+  std::vector<int> correct = aggregator->get_counts();
+  assert_histogram(metric, boundaries, correct);
+}
+
+TEST(PrometheusExporterUtils, TranslateToPrometheusHistogramNormal)
+{
+  std::vector<double> boundaries{2, 4, 6, 8, 10, 12};
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<int>>(
+      new metric_sdk::HistogramAggregator<int>(metric_api::InstrumentKind::Counter, boundaries));
+
+  std::vector<metric_sdk::Record> collection;
+  auto record = get_record("histogram-normal", 1, "{label1:v1,label2:v2,label3:v3,}", aggregator);
+  std::vector<int> values{1, 3, 3, 5, 5, 5, 7, 7, 7, 7, 9, 9, 9, 11, 11, 13};
+  for (int i : values)
+  {
+    aggregator->update(i);
+  }
+  aggregator->checkpoint();
+  collection.emplace_back(record);
+
+  auto translated = PrometheusExporterUtils::TranslateToPrometheus(collection);
+  ASSERT_EQ(translated.size(), collection.size());
+
+  auto metric           = translated[0];
+  std::vector<int> vals = {aggregator->get_checkpoint()[1], aggregator->get_checkpoint()[0],
+                           (int)boundaries.size() + 1};
+  assert_basic(metric, "test_histogram_normal_metric_record_v_1_0", record.GetDescription(),
+               prometheus_client::MetricType::Histogram, 3, vals);
+  std::vector<int> correct = aggregator->get_counts();
+  assert_histogram(metric, boundaries, correct);
+}
+
+TEST(PrometheusExporterUtils, TranslateToPrometheusExact)
+{
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<int>>(
+      new metric_sdk::ExactAggregator<int>(metric_api::InstrumentKind::Counter, true));
+
+  std::vector<metric_sdk::Record> collection;
+  int count_num = 100;
+  for (int i = 0; i <= count_num; i++)
+  {
+    aggregator->update(i);
+  }
+  aggregator->checkpoint();
+  auto record = get_record("exact", 1, "{label-1:v1,label_2:v2,label3:v3,}", aggregator);
+  collection.emplace_back(record);
+
+  auto translated = PrometheusExporterUtils::TranslateToPrometheus(collection);
+  ASSERT_EQ(translated.size(), collection.size());
+
+  auto metric           = translated[0];
+  std::vector<int> vals = {101, 5050};
+  assert_basic(metric, "test_exact_metric_record_v_1_0", record.GetDescription(),
+               prometheus_client::MetricType::Summary, 3, vals);
+  auto quantile = metric.metric[0].summary.quantile;
+  ASSERT_EQ(quantile.size(), 6);
+  ASSERT_DOUBLE_EQ(quantile[0].value, 0);
+  ASSERT_DOUBLE_EQ(quantile[1].value, 50);
+  ASSERT_DOUBLE_EQ(quantile[2].value, 90);
+  ASSERT_DOUBLE_EQ(quantile[3].value, 95);
+  ASSERT_DOUBLE_EQ(quantile[4].value, 99);
+  ASSERT_DOUBLE_EQ(quantile[5].value, 100);
+}
+
+TEST(PrometheusExporterUtils, TranslateToPrometheusExactNoQuantile)
+{
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<int>>(
+      new metric_sdk::ExactAggregator<int>(metric_api::InstrumentKind::Counter, false));
+
+  std::vector<metric_sdk::Record> collection;
+  int count_num = 10;
+  for (int i = 0; i < count_num; i++)
+  {
+    aggregator->update(i);
+  }
+  aggregator->checkpoint();
+  auto record = get_record("exact-no-quantile", 1, "{label1:v1,label2:v2,}", aggregator);
+  collection.emplace_back(record);
+
+  auto translated = PrometheusExporterUtils::TranslateToPrometheus(collection);
+  ASSERT_EQ(translated.size(), collection.size());
+
+  auto metric           = translated[0];
+  std::vector<int> vals = {count_num, 45};
+  assert_basic(metric, "test_exact_no_quantile_metric_record_v_1_0", record.GetDescription(),
+               prometheus_client::MetricType::Summary, 2, vals);
+  auto quantile = metric.metric[0].summary.quantile;
+  ASSERT_EQ(quantile.size(), 0);
+}
+
+TEST(PrometheusExporterUtils, TranslateToPrometheusMinMaxSumCount)
+{
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<int>>(
+      new metric_sdk::MinMaxSumCountAggregator<int>(metric_api::InstrumentKind::Counter));
+
+  std::vector<metric_sdk::Record> collection;
+  // min: 1, max: 10, sum: 55, count: 10
+  for (int i = 1; i <= 10; i++)
+  {
+    aggregator->update(i);
+  }
+  aggregator->checkpoint();
+  auto record = get_record("mmsc", 1, "{label1:v1,label2:v2,label3:v3,}", aggregator);
+  collection.emplace_back(record);
+
+  auto translated = PrometheusExporterUtils::TranslateToPrometheus(collection);
+  ASSERT_EQ(translated.size(), collection.size());
+
+  auto metric = translated[0];
+  // in this version of implementation, we use the sum/count as a gauge
+  std::vector<double> vals = {5.5};
+  assert_basic(metric, "test_mmsc_metric_record_v_1_0", record.GetDescription(),
+               prometheus_client::MetricType::Gauge, 3, vals);
+}
+
+TEST(PrometheusExporterUtils, TranslateToPrometheusSketch)
+{
+  auto aggregator = std::shared_ptr<metric_sdk::Aggregator<int>>(
+      new metric_sdk::SketchAggregator<int>(metric_api::InstrumentKind::Counter, 0.0005));
+
+  std::vector<metric_sdk::Record> collection;
+  for (int i = 0; i <= 100; i++)
+  {
+    aggregator->update(i);
+  }
+  aggregator->checkpoint();
+  auto record = get_record("sketch", 1, "{label1:v1,label2:v2,}", aggregator);
+  collection.emplace_back(record);
+
+  auto translated = PrometheusExporterUtils::TranslateToPrometheus(collection);
+  ASSERT_EQ(translated.size(), collection.size());
+
+  auto metric           = translated[0];
+  std::vector<int> vals = {aggregator->get_checkpoint()[1], aggregator->get_checkpoint()[0]};
+  assert_basic(metric, "test_sketch_metric_record_v_1_0", record.GetDescription(),
+               prometheus_client::MetricType::Summary, 2, vals);
+
+  auto quantile = metric.metric[0].summary.quantile;
+  ASSERT_EQ(quantile.size(), 6);
+  ASSERT_DOUBLE_EQ(quantile[0].value, 0);
+  ASSERT_DOUBLE_EQ(quantile[1].value, 49);
+  ASSERT_DOUBLE_EQ(quantile[2].value, 89);
+  ASSERT_DOUBLE_EQ(quantile[3].value, 94);
+  ASSERT_DOUBLE_EQ(quantile[4].value, 98);
+  ASSERT_DOUBLE_EQ(quantile[5].value, 99);
+}
+
+TEST(PrometheusExporterUtils, TranslateToPrometheusMultipleAggregators)
+{
+  auto counter_aggregator = std::shared_ptr<metric_sdk::Aggregator<double>>(
+      new metric_sdk::CounterAggregator<double>(metric_api::InstrumentKind::Counter));
+  auto gauge_aggregator = std::shared_ptr<metric_sdk::Aggregator<int>>(
+      new metric_sdk::GaugeAggregator<int>(metric_api::InstrumentKind::Counter));
+
+  std::vector<metric_sdk::Record> collection;
+  counter_aggregator->update(10);
+  counter_aggregator->update(20);
+  counter_aggregator->checkpoint();
+  auto record1 = get_record("counter", 1, "{label1:v1,label2:v2,label3:v3,}", counter_aggregator);
+  gauge_aggregator->update(10);
+  gauge_aggregator->update(30);
+  gauge_aggregator->update(20);
+  gauge_aggregator->checkpoint();
+  auto record2 = get_record("gauge", 1, "{label1:v1,}", gauge_aggregator);
+  collection.emplace_back(record1);
+  collection.emplace_back(record2);
+
+  auto translated = PrometheusExporterUtils::TranslateToPrometheus(collection);
+  ASSERT_EQ(translated.size(), collection.size());
+
+  auto metric1          = translated[0];
+  std::vector<int> vals = {30};
+  assert_basic(metric1, "test_counter_metric_record_v_1_0", record1.GetDescription(),
+               prometheus_client::MetricType::Counter, 3, vals);
+  auto metric2 = translated[1];
+  vals         = {20};
+  assert_basic(metric2, "test_gauge_metric_record_v_1_0", record2.GetDescription(),
+               prometheus_client::MetricType::Gauge, 1, vals);
+}
+OPENTELEMETRY_END_NAMESPACE
+#endif
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/BUILD b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/BUILD
new file mode 100644
index 000000000..6cd52b2d0
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/BUILD
@@ -0,0 +1,64 @@
+package(default_visibility = ["//visibility:public"])
+
+cc_library(
+    name = "zipkin_recordable",
+    srcs = [
+        "src/recordable.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/zipkin/recordable.h",
+    ],
+    strip_include_prefix = "include",
+    tags = ["zipkin"],
+    deps = [
+        "//sdk/src/resource",
+        "//sdk/src/trace",
+        "@github_nlohmann_json//:json",
+    ],
+)
+
+cc_library(
+    name = "zipkin_exporter",
+    srcs = [
+        "src/zipkin_exporter.cc",
+    ],
+    hdrs = [
+        "include/opentelemetry/exporters/zipkin/zipkin_exporter.h",
+    ],
+    copts = [
+        "-DCURL_STATICLIB",
+    ],
+    strip_include_prefix = "include",
+    tags = ["zipkin"],
+    deps = [
+        ":zipkin_recordable",
+        "//ext/src/http/client/curl:http_client_curl",
+    ],
+)
+
+cc_test(
+    name = "zipkin_recordable_test",
+    srcs = ["test/zipkin_recordable_test.cc"],
+    tags = [
+        "test",
+        "zipkin",
+    ],
+    deps = [
+        ":zipkin_recordable",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
+
+cc_test(
+    name = "zipkin_exporter_test",
+    srcs = ["test/zipkin_exporter_test.cc"],
+    tags = [
+        "test",
+        "zipkin",
+    ],
+    deps = [
+        ":zipkin_exporter",
+        ":zipkin_recordable",
+        "@com_google_googletest//:gtest_main",
+    ],
+)
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/CMakeLists.txt b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/CMakeLists.txt
new file mode 100644
index 000000000..559e8d500
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/CMakeLists.txt
@@ -0,0 +1,75 @@
+# Copyright 2021, OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+include_directories(include)
+find_package(CURL REQUIRED)
+add_definitions(-DWITH_CURL)
+add_library(opentelemetry_exporter_zipkin_trace src/zipkin_exporter.cc
+                                                src/recordable.cc)
+
+target_link_libraries(
+  opentelemetry_exporter_zipkin_trace
+  PUBLIC opentelemetry_trace opentelemetry_http_client_curl
+         nlohmann_json::nlohmann_json)
+
+install(
+  TARGETS opentelemetry_exporter_zipkin_trace
+  EXPORT "${PROJECT_NAME}-target"
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
+
+install(
+  DIRECTORY include/opentelemetry/exporters/zipkin
+  DESTINATION include/opentelemetry/exporters
+  FILES_MATCHING
+  PATTERN "*.h"
+  PATTERN "recordable.h" EXCLUDE)
+
+if(BUILD_TESTING)
+  add_definitions(-DGTEST_LINKED_AS_SHARED_LIBRARY=1)
+
+  add_executable(zipkin_recordable_test test/zipkin_recordable_test.cc)
+
+  target_link_libraries(
+    zipkin_recordable_test ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
+    opentelemetry_exporter_zipkin_trace opentelemetry_resources)
+
+  gtest_add_tests(
+    TARGET zipkin_recordable_test
+    TEST_PREFIX exporter.
+    TEST_LIST zipkin_recordable_test)
+
+  if(MSVC)
+    if(GMOCK_LIB)
+      unset(GMOCK_LIB CACHE)
+    endif()
+  endif()
+  if(MSVC AND CMAKE_BUILD_TYPE STREQUAL "Debug")
+    find_library(GMOCK_LIB gmockd PATH_SUFFIXES lib)
+  else()
+    find_library(GMOCK_LIB gmock PATH_SUFFIXES lib)
+  endif()
+
+  add_executable(zipkin_exporter_test test/zipkin_exporter_test.cc)
+
+  target_link_libraries(
+    zipkin_exporter_test ${GTEST_BOTH_LIBRARIES} ${CMAKE_THREAD_LIBS_INIT}
+    ${GMOCK_LIB} opentelemetry_exporter_zipkin_trace opentelemetry_resources)
+
+  gtest_add_tests(
+    TARGET zipkin_exporter_test
+    TEST_PREFIX exporter.
+    TEST_LIST zipkin_exporter_test)
+endif() # BUILD_TESTING
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/README.md b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/README.md
new file mode 100644
index 000000000..40bb1f061
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/README.md
@@ -0,0 +1,56 @@
+# Zipkin Exporter for OpenTelemetry C++
+
+## Prerequisite
+
+* [Get Zipkin](https://zipkin.io/pages/quickstart.html)
+
+## Installation
+
+### CMake Install Instructions
+
+Refer to install instructions [INSTALL.md](../../INSTALL.md#building-as-standalone-cmake-project).
+Modify step 2 to create `cmake` build configuration for compiling Zipkin as below:
+
+```console
+   $ cmake -DWITH_ZIPKIN=ON ..
+   -- The C compiler identification is GNU 9.3.0
+   -- The CXX compiler identification is GNU 9.3.0
+   ...
+   -- Configuring done
+   -- Generating done
+   -- Build files have been written to: /home/<user>/source/opentelemetry-cpp/build
+   $
+```
+
+### Bazel Install Instructions
+
+TODO
+
+## Usage
+
+Install the exporter on your application and pass the options. `service_name`
+is an optional string. If omitted, the exporter will first try to get the
+service name from the Resource. If no service name can be detected on the
+Resource, a fallback name of "unknown_service" will be used.
+
+```cpp
+
+opentelemetry::exporter::zipkin::ZipkinExporterOptions options;
+options.endpoint = "http://localhost:9411/api/v2/spans";
+options.service_name = "my_service";
+
+auto exporter = std::unique_ptr<opentelemetry::sdk::trace::SpanExporter>(
+    new opentelemetry::exporter::zipkin::ZipkinExporter(options));
+auto processor = std::shared_ptr<sdktrace::SpanProcessor>(
+    new sdktrace::SimpleSpanProcessor(std::move(exporter)));
+auto provider = nostd::shared_ptr<opentelemetry::trace::TracerProvider>(
+    new sdktrace::TracerProvider(processor, opentelemetry::sdk::resource::Resource::Create({}),
+                std::make_shared<opentelemetry::sdk::trace::AlwaysOnSampler>()));
+
+// Set the global trace provider
+opentelemetry::trace::Provider::SetTracerProvider(provider);
+```
+
+## Viewing your traces
+
+Please visit the Zipkin UI endpoint <http://localhost:9411>
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/include/opentelemetry/exporters/zipkin/recordable.h b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/include/opentelemetry/exporters/zipkin/recordable.h
new file mode 100644
index 000000000..51f83211f
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/include/opentelemetry/exporters/zipkin/recordable.h
@@ -0,0 +1,60 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "nlohmann/json.hpp"
+#include "opentelemetry/sdk/trace/recordable.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace zipkin
+{
+using ZipkinSpan = nlohmann::json;
+
+class Recordable final : public sdk::trace::Recordable
+{
+public:
+  const ZipkinSpan &span() const noexcept { return span_; }
+
+  const std::string &GetServiceName() const noexcept { return service_name_; }
+
+  void SetIdentity(const opentelemetry::trace::SpanContext &span_context,
+                   opentelemetry::trace::SpanId parent_span_id) noexcept override;
+
+  void SetAttribute(nostd::string_view key,
+                    const opentelemetry::common::AttributeValue &value) noexcept override;
+
+  void AddEvent(nostd::string_view name,
+                common::SystemTimestamp timestamp,
+                const common::KeyValueIterable &attributes) noexcept override;
+
+  void AddLink(const opentelemetry::trace::SpanContext &span_context,
+               const common::KeyValueIterable &attributes) noexcept override;
+
+  void SetStatus(opentelemetry::trace::StatusCode code,
+                 nostd::string_view description) noexcept override;
+
+  void SetName(nostd::string_view name) noexcept override;
+
+  void SetStartTime(opentelemetry::common::SystemTimestamp start_time) noexcept override;
+
+  void SetSpanKind(opentelemetry::trace::SpanKind span_kind) noexcept override;
+
+  void SetResource(const opentelemetry::sdk::resource::Resource &resource) noexcept override;
+
+  void SetDuration(std::chrono::nanoseconds duration) noexcept override;
+
+  void SetInstrumentationLibrary(
+      const opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary
+          &instrumentation_library) noexcept override;
+
+private:
+  ZipkinSpan span_;
+  std::string service_name_;
+};
+}  // namespace zipkin
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/include/opentelemetry/exporters/zipkin/zipkin_exporter.h b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/include/opentelemetry/exporters/zipkin/zipkin_exporter.h
new file mode 100644
index 000000000..ae0e8173f
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/include/opentelemetry/exporters/zipkin/zipkin_exporter.h
@@ -0,0 +1,113 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/common/spin_lock_mutex.h"
+#include "opentelemetry/ext/http/client/http_client_factory.h"
+#include "opentelemetry/ext/http/common/url_parser.h"
+#include "opentelemetry/sdk/common/env_variables.h"
+#include "opentelemetry/sdk/trace/exporter.h"
+#include "opentelemetry/sdk/trace/span_data.h"
+
+#include "nlohmann/json.hpp"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace zipkin
+{
+
+inline const std::string GetDefaultZipkinEndpoint()
+{
+  const char *otel_exporter_zipkin_endpoint_env = "OTEL_EXPORTER_ZIPKIN_ENDPOINT";
+  const char *kZipkinEndpointDefault            = "http://localhost:9411/api/v2/spans";
+
+  auto endpoint =
+      opentelemetry::sdk::common::GetEnvironmentVariable(otel_exporter_zipkin_endpoint_env);
+  return endpoint.size() ? endpoint : kZipkinEndpointDefault;
+}
+
+enum class TransportFormat
+{
+  kJson,
+  kProtobuf
+};
+
+/**
+ * Struct to hold Zipkin  exporter options.
+ */
+struct ZipkinExporterOptions
+{
+  // The endpoint to export to. By default the OpenTelemetry Collector's default endpoint.
+  std::string endpoint     = GetDefaultZipkinEndpoint();
+  TransportFormat format   = TransportFormat::kJson;
+  std::string service_name = "default-service";
+  std::string ipv4;
+  std::string ipv6;
+  ext::http::client::Headers headers = {{"content-type", "application/json"}};
+};
+
+/**
+ * The Zipkin exporter exports span data in JSON format as expected by Zipkin
+ */
+class ZipkinExporter final : public opentelemetry::sdk::trace::SpanExporter
+{
+public:
+  /**
+   * Create a ZipkinExporter using all default options.
+   */
+  ZipkinExporter();
+
+  /**
+   * Create a ZipkinExporter using the given options.
+   */
+  explicit ZipkinExporter(const ZipkinExporterOptions &options);
+
+  /**
+   * Create a span recordable.
+   * @return a newly initialized Recordable object
+   */
+  std::unique_ptr<opentelemetry::sdk::trace::Recordable> MakeRecordable() noexcept override;
+
+  /**
+   * Export a batch of span recordables in JSON format.
+   * @param spans a span of unique pointers to span recordables
+   */
+  sdk::common::ExportResult Export(
+      const nostd::span<std::unique_ptr<opentelemetry::sdk::trace::Recordable>> &spans) noexcept
+      override;
+
+  /**
+   * Shut down the exporter.
+   * @param timeout an optional timeout, default to max.
+   */
+  bool Shutdown(
+      std::chrono::microseconds timeout = std::chrono::microseconds::max()) noexcept override;
+
+private:
+  void InitializeLocalEndpoint();
+
+private:
+  // The configuration options associated with this exporter.
+  bool is_shutdown_ = false;
+  ZipkinExporterOptions options_;
+  std::shared_ptr<opentelemetry::ext::http::client::HttpClientSync> http_client_;
+  opentelemetry::ext::http::common::UrlParser url_parser_;
+  nlohmann::json local_end_point_;
+
+  // For testing
+  friend class ZipkinExporterTestPeer;
+  /**
+   * Create an ZipkinExporter using the specified thrift sender.
+   * Only tests can call this constructor directly.
+   * @param http_client the http client to be used for exporting
+   */
+  ZipkinExporter(std::shared_ptr<opentelemetry::ext::http::client::HttpClientSync> http_client);
+
+  mutable opentelemetry::common::SpinLockMutex lock_;
+  bool isShutdown() const noexcept;
+};
+}  // namespace zipkin
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/src/recordable.cc b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/src/recordable.cc
new file mode 100644
index 000000000..700d6a964
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/src/recordable.cc
@@ -0,0 +1,254 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/exporters/zipkin/recordable.h"
+#include "opentelemetry/sdk/resource/experimental_semantic_conventions.h"
+
+#include <map>
+#include <string>
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace zipkin
+{
+
+using namespace opentelemetry::sdk::resource;
+namespace trace_api = opentelemetry::trace;
+namespace common    = opentelemetry::common;
+namespace sdk       = opentelemetry::sdk;
+
+// constexpr needs keys to be constexpr, const is next best to use.
+static const std::map<trace_api::SpanKind, std::string> kSpanKindMap = {
+    {trace_api::SpanKind::kClient, "CLIENT"},
+    {trace_api::SpanKind::kServer, "SERVER"},
+    {trace_api::SpanKind::kConsumer, "CONSUMER"},
+    {trace_api::SpanKind::kProducer, "PRODUCER"},
+};
+
+//
+// See `attribute_value.h` for details.
+//
+const int kAttributeValueSize = 16;
+
+void Recordable::SetIdentity(const trace_api::SpanContext &span_context,
+                             trace_api::SpanId parent_span_id) noexcept
+{
+  char trace_id_lower_base16[trace::TraceId::kSize * 2] = {0};
+  span_context.trace_id().ToLowerBase16(trace_id_lower_base16);
+  char span_id_lower_base16[trace::SpanId::kSize * 2] = {0};
+  span_context.span_id().ToLowerBase16(span_id_lower_base16);
+  if (parent_span_id.IsValid())
+  {
+    char parent_span_id_lower_base16[trace::SpanId::kSize * 2] = {0};
+    parent_span_id.ToLowerBase16(parent_span_id_lower_base16);
+    span_["parentId"] = std::string(parent_span_id_lower_base16, 16);
+  }
+
+  span_["id"]      = std::string(span_id_lower_base16, 16);
+  span_["traceId"] = std::string(trace_id_lower_base16, 32);
+}
+
+void PopulateAttribute(nlohmann::json &attribute,
+                       nostd::string_view key,
+                       const common::AttributeValue &value)
+{
+  // Assert size of variant to ensure that this method gets updated if the variant
+  // definition changes
+  static_assert(nostd::variant_size<common::AttributeValue>::value == kAttributeValueSize,
+                "AttributeValue contains unknown type");
+
+  if (nostd::holds_alternative<bool>(value))
+  {
+    attribute[key.data()] = nostd::get<bool>(value);
+  }
+  else if (nostd::holds_alternative<int>(value))
+  {
+    attribute[key.data()] = nostd::get<int>(value);
+  }
+  else if (nostd::holds_alternative<int64_t>(value))
+  {
+    attribute[key.data()] = nostd::get<int64_t>(value);
+  }
+  else if (nostd::holds_alternative<unsigned int>(value))
+  {
+    attribute[key.data()] = nostd::get<unsigned int>(value);
+  }
+  else if (nostd::holds_alternative<uint64_t>(value))
+  {
+    attribute[key.data()] = nostd::get<uint64_t>(value);
+  }
+  else if (nostd::holds_alternative<double>(value))
+  {
+    attribute[key.data()] = nostd::get<double>(value);
+  }
+  else if (nostd::holds_alternative<const char *>(value))
+  {
+    attribute[key.data()] = nostd::get<const char *>(value);
+  }
+  else if (nostd::holds_alternative<nostd::string_view>(value))
+  {
+    attribute[key.data()] = nostd::string_view(nostd::get<nostd::string_view>(value).data(),
+                                               nostd::get<nostd::string_view>(value).size());
+  }
+  else if (nostd::holds_alternative<nostd::span<const uint8_t>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const uint8_t>>(value))
+    {
+      attribute[key.data()].push_back(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const bool>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const bool>>(value))
+    {
+      attribute[key.data()].push_back(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const int>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const int>>(value))
+    {
+      attribute[key.data()].push_back(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const int64_t>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const int64_t>>(value))
+    {
+      attribute[key.data()].push_back(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const unsigned int>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const unsigned int>>(value))
+    {
+      attribute[key.data()].push_back(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const uint64_t>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const uint64_t>>(value))
+    {
+      attribute[key.data()].push_back(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const double>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const double>>(value))
+    {
+      attribute[key.data()].push_back(val);
+    }
+  }
+  else if (nostd::holds_alternative<nostd::span<const nostd::string_view>>(value))
+  {
+    attribute[key.data()] = {};
+    for (const auto &val : nostd::get<nostd::span<const nostd::string_view>>(value))
+    {
+      attribute[key.data()].push_back(std::string(val.data(), val.size()));
+    }
+  }
+}
+
+void Recordable::SetAttribute(nostd::string_view key, const common::AttributeValue &value) noexcept
+{
+  if (!span_.contains("tags"))
+  {
+    span_["tags"] = nlohmann::json::object();
+  }
+  PopulateAttribute(span_["tags"], key, value);
+}
+
+void Recordable::AddEvent(nostd::string_view name,
+                          common::SystemTimestamp timestamp,
+                          const common::KeyValueIterable &attributes) noexcept
+{
+  nlohmann::json attrs = nlohmann::json::object();  // empty object
+  attributes.ForEachKeyValue([&](nostd::string_view key, common::AttributeValue value) noexcept {
+    PopulateAttribute(attrs, key, value);
+    return true;
+  });
+
+  nlohmann::json annotation = {{"value", nlohmann::json::object({{name.data(), attrs}}).dump()},
+                               {"timestamp", std::chrono::duration_cast<std::chrono::microseconds>(
+                                                 timestamp.time_since_epoch())
+                                                 .count()}};
+
+  if (!span_.contains("annotations"))
+  {
+    span_["annotations"] = nlohmann::json::array();
+  }
+  span_["annotations"].push_back(annotation);
+}
+
+void Recordable::AddLink(const trace_api::SpanContext &span_context,
+                         const common::KeyValueIterable &attributes) noexcept
+{
+  // TODO: Currently not supported by specs:
+  // https://github.com/open-telemetry/opentelemetry-specification/blob/master/specification/trace/sdk_exporters/zipkin.md
+}
+
+void Recordable::SetStatus(trace::StatusCode code, nostd::string_view description) noexcept
+{
+  if (code != trace::StatusCode::kUnset)
+  {
+    span_["tags"]["otel.status_code"] = code;
+    if (code == trace::StatusCode::kError)
+    {
+      span_["tags"]["error"] = description;
+    }
+  }
+}
+
+void Recordable::SetName(nostd::string_view name) noexcept
+{
+  span_["name"] = name.data();
+}
+
+void Recordable::SetResource(const sdk::resource::Resource &resource) noexcept
+{
+  // only service.name attribute is supported by specs as of now.
+  auto attributes = resource.GetAttributes();
+  if (attributes.find(OTEL_GET_RESOURCE_ATTR(AttrServiceName)) != attributes.end())
+  {
+    service_name_ = nostd::get<std::string>(attributes[OTEL_GET_RESOURCE_ATTR(AttrServiceName)]);
+  }
+}
+
+void Recordable::SetStartTime(common::SystemTimestamp start_time) noexcept
+{
+  span_["timestamp"] =
+      std::chrono::duration_cast<std::chrono::microseconds>(start_time.time_since_epoch()).count();
+}
+
+void Recordable::SetDuration(std::chrono::nanoseconds duration) noexcept
+{
+  span_["duration"] = std::chrono::duration_cast<std::chrono::microseconds>(duration).count();
+}
+
+void Recordable::SetSpanKind(trace_api::SpanKind span_kind) noexcept
+{
+  auto span_iter = kSpanKindMap.find(span_kind);
+  if (span_iter != kSpanKindMap.end())
+  {
+    span_["kind"] = span_iter->second;
+  }
+}
+
+void Recordable::SetInstrumentationLibrary(
+    const sdk::instrumentationlibrary::InstrumentationLibrary &instrumentation_library) noexcept
+{
+  span_["tags"]["otel.library.name"]    = instrumentation_library.GetName();
+  span_["tags"]["otel.library.version"] = instrumentation_library.GetVersion();
+}
+
+}  // namespace zipkin
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/src/zipkin_exporter.cc b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/src/zipkin_exporter.cc
new file mode 100644
index 000000000..240144599
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/src/zipkin_exporter.cc
@@ -0,0 +1,128 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#define _WINSOCKAPI_  // stops including winsock.h
+#include "opentelemetry/exporters/zipkin/zipkin_exporter.h"
+#include <mutex>
+#include "opentelemetry/exporters/zipkin/recordable.h"
+#include "opentelemetry/ext/http/client/http_client_factory.h"
+#include "opentelemetry/ext/http/common/url_parser.h"
+#include "opentelemetry/sdk_config.h"
+
+namespace http_client = opentelemetry::ext::http::client;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace zipkin
+{
+
+// -------------------------------- Constructors --------------------------------
+
+ZipkinExporter::ZipkinExporter(const ZipkinExporterOptions &options)
+    : options_(options), url_parser_(options_.endpoint)
+{
+  http_client_ = ext::http::client::HttpClientFactory::CreateSync();
+  InitializeLocalEndpoint();
+}
+
+ZipkinExporter::ZipkinExporter() : options_(ZipkinExporterOptions()), url_parser_(options_.endpoint)
+{
+  http_client_ = ext::http::client::HttpClientFactory::CreateSync();
+  InitializeLocalEndpoint();
+}
+
+ZipkinExporter::ZipkinExporter(
+    std::shared_ptr<opentelemetry::ext::http::client::HttpClientSync> http_client)
+    : options_(ZipkinExporterOptions()), url_parser_(options_.endpoint)
+{
+  http_client_ = http_client;
+  InitializeLocalEndpoint();
+}
+
+// ----------------------------- Exporter methods ------------------------------
+
+std::unique_ptr<sdk::trace::Recordable> ZipkinExporter::MakeRecordable() noexcept
+{
+  return std::unique_ptr<sdk::trace::Recordable>(new Recordable);
+}
+
+sdk::common::ExportResult ZipkinExporter::Export(
+    const nostd::span<std::unique_ptr<sdk::trace::Recordable>> &spans) noexcept
+{
+  if (isShutdown())
+  {
+    OTEL_INTERNAL_LOG_ERROR("[Zipkin Trace Exporter] Exporting "
+                            << spans.size() << " span(s) failed, exporter is shutdown");
+    return sdk::common::ExportResult::kFailure;
+  }
+  exporter::zipkin::ZipkinSpan json_spans = {};
+  for (auto &recordable : spans)
+  {
+    auto rec = std::unique_ptr<Recordable>(static_cast<Recordable *>(recordable.release()));
+    if (rec != nullptr)
+    {
+      auto json_span = rec->span();
+      // add localEndPoint
+      json_span["localEndpoint"] = local_end_point_;
+      // check service.name
+      auto service_name = rec->GetServiceName();
+      if (service_name.size())
+      {
+        json_span["localEndpoint"]["serviceName"] = service_name;
+      }
+      json_spans.push_back(json_span);
+    }
+  }
+  auto body_s = json_spans.dump();
+  http_client::Body body_v(body_s.begin(), body_s.end());
+  auto result = http_client_->Post(url_parser_.url_, body_v, options_.headers);
+  if (result &&
+      (result.GetResponse().GetStatusCode() == 200 || result.GetResponse().GetStatusCode() == 202))
+  {
+    return sdk::common::ExportResult::kSuccess;
+  }
+  else
+  {
+    if (result.GetSessionState() == http_client::SessionState::ConnectFailed)
+    {
+      OTEL_INTERNAL_LOG_ERROR("ZIPKIN EXPORTER] Zipkin Exporter: Connection failed");
+    }
+    return sdk::common::ExportResult::kFailure;
+  }
+  return sdk::common::ExportResult::kSuccess;
+}
+
+void ZipkinExporter::InitializeLocalEndpoint()
+{
+  if (options_.service_name.length())
+  {
+    local_end_point_["serviceName"] = options_.service_name;
+  }
+  if (options_.ipv4.length())
+  {
+    local_end_point_["ipv4"] = options_.ipv4;
+  }
+  if (options_.ipv6.length())
+  {
+    local_end_point_["ipv6"] = options_.ipv6;
+  }
+  local_end_point_["port"] = url_parser_.port_;
+}
+
+bool ZipkinExporter::Shutdown(std::chrono::microseconds timeout) noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  is_shutdown_ = true;
+  return true;
+}
+
+bool ZipkinExporter::isShutdown() const noexcept
+{
+  const std::lock_guard<opentelemetry::common::SpinLockMutex> locked(lock_);
+  return is_shutdown_;
+}
+
+}  // namespace zipkin
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/test/zipkin_exporter_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/test/zipkin_exporter_test.cc
new file mode 100644
index 000000000..eec71f43d
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/test/zipkin_exporter_test.cc
@@ -0,0 +1,215 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#ifndef HAVE_CPP_STDLIB
+
+#  include "opentelemetry/exporters/zipkin/zipkin_exporter.h"
+#  include <string>
+#  include "opentelemetry/ext/http/client/curl/http_client_curl.h"
+#  include "opentelemetry/ext/http/server/http_server.h"
+#  include "opentelemetry/sdk/trace/batch_span_processor.h"
+#  include "opentelemetry/sdk/trace/tracer_provider.h"
+#  include "opentelemetry/trace/provider.h"
+
+#  include <gtest/gtest.h>
+#  include "gmock/gmock.h"
+
+#  include "nlohmann/json.hpp"
+
+#  if defined(_MSC_VER)
+#    include "opentelemetry/sdk/common/env_variables.h"
+using opentelemetry::sdk::common::setenv;
+using opentelemetry::sdk::common::unsetenv;
+#  endif
+namespace sdk_common = opentelemetry::sdk::common;
+using namespace testing;
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace exporter
+{
+namespace zipkin
+{
+
+namespace trace_api = opentelemetry::trace;
+namespace resource  = opentelemetry::sdk::resource;
+
+template <class T, size_t N>
+static nostd::span<T, N> MakeSpan(T (&array)[N])
+{
+  return nostd::span<T, N>(array);
+}
+
+class ZipkinExporterTestPeer : public ::testing::Test
+{
+public:
+  std::unique_ptr<sdk::trace::SpanExporter> GetExporter(
+      std::shared_ptr<opentelemetry::ext::http::client::HttpClientSync> http_client)
+  {
+    return std::unique_ptr<sdk::trace::SpanExporter>(new ZipkinExporter(http_client));
+  }
+
+  // Get the options associated with the given exporter.
+  const ZipkinExporterOptions &GetOptions(std::unique_ptr<ZipkinExporter> &exporter)
+  {
+    return exporter->options_;
+  }
+};
+
+class MockHttpClient : public opentelemetry::ext::http::client::HttpClientSync
+{
+public:
+  MOCK_METHOD(ext::http::client::Result,
+              Post,
+              (const nostd::string_view &,
+               const ext::http::client::Body &,
+               const ext::http::client::Headers &),
+              (noexcept, override));
+  MOCK_METHOD(ext::http::client::Result,
+              Get,
+              (const nostd::string_view &, const ext::http::client::Headers &),
+              (noexcept, override));
+};
+
+class IsValidMessageMatcher
+{
+public:
+  IsValidMessageMatcher(const std::string &trace_id) : trace_id_(trace_id) {}
+  template <typename T>
+  bool MatchAndExplain(const T &p, MatchResultListener * /* listener */) const
+  {
+    auto body                 = std::string(p.begin(), p.end());
+    nlohmann::json check_json = nlohmann::json::parse(body);
+    auto trace_id_kv          = check_json.at(0).find("traceId");
+    auto received_trace_id    = trace_id_kv.value().get<std::string>();
+    return trace_id_ == received_trace_id;
+  }
+
+  void DescribeTo(std::ostream *os) const { *os << "received trace_id matches"; }
+
+  void DescribeNegationTo(std::ostream *os) const { *os << "received trace_id does not matche"; }
+
+private:
+  std::string trace_id_;
+};
+
+PolymorphicMatcher<IsValidMessageMatcher> IsValidMessage(const std::string &trace_id)
+{
+  return MakePolymorphicMatcher(IsValidMessageMatcher(trace_id));
+}
+
+// Create spans, let processor call Export()
+TEST_F(ZipkinExporterTestPeer, ExportJsonIntegrationTest)
+{
+  auto mock_http_client = new MockHttpClient;
+  // Leave a comment line here or different version of clang-format has a different result here
+  auto exporter = GetExporter(
+      std::shared_ptr<opentelemetry::ext::http::client::HttpClientSync>{mock_http_client});
+
+  resource::ResourceAttributes resource_attributes = {{"service.name", "unit_test_service"},
+                                                      {"tenant.id", "test_user"}};
+  resource_attributes["bool_value"]                = true;
+  resource_attributes["int32_value"]               = static_cast<int32_t>(1);
+  resource_attributes["uint32_value"]              = static_cast<uint32_t>(2);
+  resource_attributes["int64_value"]               = static_cast<int64_t>(0x1100000000LL);
+  resource_attributes["uint64_value"]              = static_cast<uint64_t>(0x1200000000ULL);
+  resource_attributes["double_value"]              = static_cast<double>(3.1);
+  resource_attributes["vec_bool_value"]            = std::vector<bool>{true, false, true};
+  resource_attributes["vec_int32_value"]           = std::vector<int32_t>{1, 2};
+  resource_attributes["vec_uint32_value"]          = std::vector<uint32_t>{3, 4};
+  resource_attributes["vec_int64_value"]           = std::vector<int64_t>{5, 6};
+  resource_attributes["vec_uint64_value"]          = std::vector<uint64_t>{7, 8};
+  resource_attributes["vec_double_value"]          = std::vector<double>{3.2, 3.3};
+  resource_attributes["vec_string_value"]          = std::vector<std::string>{"vector", "string"};
+  auto resource = resource::Resource::Create(resource_attributes);
+
+  auto processor_opts                  = sdk::trace::BatchSpanProcessorOptions();
+  processor_opts.max_export_batch_size = 5;
+  processor_opts.max_queue_size        = 5;
+  processor_opts.schedule_delay_millis = std::chrono::milliseconds(256);
+  auto processor                       = std::unique_ptr<sdk::trace::SpanProcessor>(
+      new sdk::trace::BatchSpanProcessor(std::move(exporter), processor_opts));
+  auto provider = nostd::shared_ptr<trace::TracerProvider>(
+      new sdk::trace::TracerProvider(std::move(processor), resource));
+
+  std::string report_trace_id;
+  char trace_id_hex[2 * trace_api::TraceId::kSize] = {0};
+  auto tracer                                      = provider->GetTracer("test");
+  auto parent_span                                 = tracer->StartSpan("Test parent span");
+
+  trace_api::StartSpanOptions child_span_opts = {};
+  child_span_opts.parent                      = parent_span->GetContext();
+  auto child_span = tracer->StartSpan("Test child span", child_span_opts);
+
+  nostd::get<trace_api::SpanContext>(child_span_opts.parent)
+      .trace_id()
+      .ToLowerBase16(MakeSpan(trace_id_hex));
+  report_trace_id.assign(trace_id_hex, sizeof(trace_id_hex));
+
+  auto expected_url = nostd::string_view{"http://localhost:9411/api/v2/spans"};
+  EXPECT_CALL(*mock_http_client, Post(expected_url, IsValidMessage(report_trace_id), _))
+      .Times(Exactly(1))
+      .WillOnce(Return(ByMove(std::move(ext::http::client::Result{
+          std::unique_ptr<ext::http::client::Response>{new ext::http::client::curl::Response()},
+          ext::http::client::SessionState::Response}))));
+
+  child_span->End();
+  parent_span->End();
+}
+
+// Create spans, let processor call Export()
+TEST_F(ZipkinExporterTestPeer, ShutdownTest)
+{
+  auto mock_http_client = new MockHttpClient;
+  // Leave a comment line here or different version of clang-format has a different result here
+  auto exporter = GetExporter(
+      std::shared_ptr<opentelemetry::ext::http::client::HttpClientSync>{mock_http_client});
+  auto recordable_1 = exporter->MakeRecordable();
+  recordable_1->SetName("Test span 1");
+  auto recordable_2 = exporter->MakeRecordable();
+  recordable_2->SetName("Test span 2");
+
+  // exporter shuold not be shutdown by default
+  nostd::span<std::unique_ptr<sdk::trace::Recordable>> batch_1(&recordable_1, 1);
+  EXPECT_CALL(*mock_http_client, Post(_, _, _))
+      .Times(Exactly(1))
+      .WillOnce(Return(ByMove(std::move(ext::http::client::Result{
+          std::unique_ptr<ext::http::client::Response>{new ext::http::client::curl::Response()},
+          ext::http::client::SessionState::Response}))));
+  auto result = exporter->Export(batch_1);
+  EXPECT_EQ(sdk_common::ExportResult::kSuccess, result);
+
+  exporter->Shutdown();
+
+  nostd::span<std::unique_ptr<sdk::trace::Recordable>> batch_2(&recordable_2, 1);
+  result = exporter->Export(batch_2);
+  EXPECT_EQ(sdk_common::ExportResult::kFailure, result);
+}
+
+// Test exporter configuration options
+TEST_F(ZipkinExporterTestPeer, ConfigTest)
+{
+  ZipkinExporterOptions opts;
+  opts.endpoint = "http://localhost:45455/v1/traces";
+  std::unique_ptr<ZipkinExporter> exporter(new ZipkinExporter(opts));
+  EXPECT_EQ(GetOptions(exporter).endpoint, "http://localhost:45455/v1/traces");
+}
+
+#  ifndef NO_GETENV
+// Test exporter configuration options from env
+TEST_F(ZipkinExporterTestPeer, ConfigFromEnv)
+{
+  const std::string endpoint = "http://localhost:9999/v1/traces";
+  setenv("OTEL_EXPORTER_ZIPKIN_ENDPOINT", endpoint.c_str(), 1);
+
+  std::unique_ptr<ZipkinExporter> exporter(new ZipkinExporter());
+  EXPECT_EQ(GetOptions(exporter).endpoint, endpoint);
+
+  unsetenv("OTEL_EXPORTER_ZIPKIN_ENDPOINT");
+}
+
+#  endif  // NO_GETENV
+
+}  // namespace zipkin
+}  // namespace exporter
+OPENTELEMETRY_END_NAMESPACE
+#endif  // HAVE_CPP_STDLIB
diff --git a/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/test/zipkin_recordable_test.cc b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/test/zipkin_recordable_test.cc
new file mode 100644
index 000000000..967aebaab
--- /dev/null
+++ b/src/jaegertracing/opentelemetry-cpp/exporters/zipkin/test/zipkin_recordable_test.cc
@@ -0,0 +1,285 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include "opentelemetry/sdk/trace/recordable.h"
+#include "opentelemetry/sdk/trace/simple_processor.h"
+#include "opentelemetry/sdk/trace/span_data.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
+#include "opentelemetry/trace/provider.h"
+
+#include "opentelemetry/sdk/trace/exporter.h"
+
+#include "opentelemetry/common/timestamp.h"
+#include "opentelemetry/exporters/zipkin/recordable.h"
+
+#include <gtest/gtest.h>
+
+namespace trace    = opentelemetry::trace;
+namespace nostd    = opentelemetry::nostd;
+namespace sdktrace = opentelemetry::sdk::trace;
+namespace common   = opentelemetry::common;
+namespace zipkin   = opentelemetry::exporter::zipkin;
+using json         = nlohmann::json;
+
+// Testing Shutdown functionality of OStreamSpanExporter, should expect no data to be sent to Stream
+TEST(ZipkinSpanRecordable, SetIdentity)
+{
+  json j_span = {{"id", "0000000000000002"},
+                 {"parentId", "0000000000000003"},
+                 {"traceId", "00000000000000000000000000000001"}};
+  zipkin::Recordable rec;
+  const trace::TraceId trace_id(std::array<const uint8_t, trace::TraceId::kSize>(
+      {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}));
+
+  const trace::SpanId span_id(
+      std::array<const uint8_t, trace::SpanId::kSize>({0, 0, 0, 0, 0, 0, 0, 2}));
+
+  const trace::SpanId parent_span_id(
+      std::array<const uint8_t, trace::SpanId::kSize>({0, 0, 0, 0, 0, 0, 0, 3}));
+
+  const trace::SpanContext span_context{trace_id, span_id,
+                                        trace::TraceFlags{trace::TraceFlags::kIsSampled}, true};
+
+  rec.SetIdentity(span_context, parent_span_id);
+  EXPECT_EQ(rec.span(), j_span);
+}
+
+// according to https://zipkin.io/zipkin-api/#/ in case root span is created
+// the parentId filed should be absent.
+TEST(ZipkinSpanRecordable, SetIdentityEmptyParent)
+{
+  json j_span = {{"id", "0000000000000002"}, {"traceId", "00000000000000000000000000000001"}};
+  zipkin::Recordable rec;
+  const trace::TraceId trace_id(std::array<const uint8_t, trace::TraceId::kSize>(
+      {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1}));
+
+  const trace::SpanId span_id(
+      std::array<const uint8_t, trace::SpanId::kSize>({0, 0, 0, 0, 0, 0, 0, 2}));
+
+  const trace::SpanId parent_span_id(
+      std::array<const uint8_t, trace::SpanId::kSize>({0, 0, 0, 0, 0, 0, 0, 0}));
+
+  const trace::SpanContext span_context{trace_id, span_id,
+                                        trace::TraceFlags{trace::TraceFlags::kIsSampled}, true};
+
+  rec.SetIdentity(span_context, parent_span_id);
+  EXPECT_EQ(rec.span(), j_span);
+}
+
+TEST(ZipkinSpanRecordable, SetName)
+{
+  nostd::string_view name = "Test Span";
+  json j_span             = {{"name", name}};
+  zipkin::Recordable rec;
+  rec.SetName(name);
+  EXPECT_EQ(rec.span(), j_span);
+}
+
+TEST(ZipkinSpanRecordable, SetStartTime)
+{
+  zipkin::Recordable rec;
+  std::chrono::system_clock::time_point start_time = std::chrono::system_clock::now();
+  common::SystemTimestamp start_timestamp(start_time);
+
+  uint64_t unix_start =
+      std::chrono::duration_cast<std::chrono::microseconds>(start_time.time_since_epoch()).count();
+  json j_span = {{"timestamp", unix_start}};
+  rec.SetStartTime(start_timestamp);
+  EXPECT_EQ(rec.span(), j_span);
+}
+
+TEST(ZipkinSpanRecordable, SetDuration)
+{
+  std::chrono::nanoseconds durationNS(1000000000);  // in ns
+  std::chrono::microseconds durationMS =
+      std::chrono::duration_cast<std::chrono::microseconds>(durationNS);  // in ms
+  json j_span = {{"duration", durationMS.count()}, {"timestamp", 0}};
+  zipkin::Recordable rec;
+  // Start time is 0
+  common::SystemTimestamp start_timestamp;
+
+  rec.SetStartTime(start_timestamp);
+  rec.SetDuration(durationNS);
+  EXPECT_EQ(rec.span(), j_span);
+}
+
+TEST(ZipkinSpanRecordable, SetInstrumentationLibrary)
+{
+  using InstrumentationLibrary = opentelemetry::sdk::instrumentationlibrary::InstrumentationLibrary;
+
+  const char *library_name    = "otel-cpp";
+  const char *library_version = "0.5.0";
+  json j_span                 = {
+      {"tags", {{"otel.library.name", library_name}, {"otel.library.version", library_version}}}};
+  zipkin::Recordable rec;
+
+  rec.SetInstrumentationLibrary(*InstrumentationLibrary::Create(library_name, library_version));
+
+  EXPECT_EQ(rec.span(), j_span);
+}
+
+TEST(ZipkinSpanRecordable, SetStatus)
+{
+  std::string description                     = "Error description";
+  std::vector<trace::StatusCode> status_codes = {trace::StatusCode::kError, trace::StatusCode::kOk};
+  for (auto &status_code : status_codes)
+  {
+    zipkin::Recordable rec;
+    trace::StatusCode code(status_code);
+    json j_span;
+    if (status_code == trace::StatusCode::kError)
+      j_span = {{"tags", {{"otel.status_code", status_code}, {"error", description}}}};
+    else
+      j_span = {{"tags", {{"otel.status_code", status_code}}}};
+
+    rec.SetStatus(code, description);
+    EXPECT_EQ(rec.span(), j_span);
+  }
+}
+
+TEST(ZipkinSpanRecordable, SetSpanKind)
+{
+  json j_json_client = {{"kind", "CLIENT"}};
+  zipkin::Recordable rec;
+  rec.SetSpanKind(trace::SpanKind::kClient);
+  EXPECT_EQ(rec.span(), j_json_client);
+}
+
+TEST(ZipkinSpanRecordable, AddEventDefault)
+{
+  zipkin::Recordable rec;
+  nostd::string_view name = "Test Event";
+
+  std::chrono::system_clock::time_point event_time = std::chrono::system_clock::now();
+  common::SystemTimestamp event_timestamp(event_time);
+
+  rec.sdktrace::Recordable::AddEvent(name, event_timestamp);
+
+  uint64_t unix_event_time =
+      std::chrono::duration_cast<std::chrono::microseconds>(event_time.time_since_epoch()).count();
+
+  json j_span = {
+      {"annotations",
+       {{{"value", json({{name, json::object()}}).dump()}, {"timestamp", unix_event_time}}}}};
+  EXPECT_EQ(rec.span(), j_span);
+}
+
+TEST(ZipkinSpanRecordable, AddEventWithAttributes)
+{
+  zipkin::Recordable rec;
+
+  std::chrono::system_clock::time_point event_time = std::chrono::system_clock::now();
+  common::SystemTimestamp event_timestamp(event_time);
+  uint64_t unix_event_time =
+      std::chrono::duration_cast<std::chrono::microseconds>(event_time.time_since_epoch()).count();
+
+  const int kNumAttributes              = 3;
+  std::string keys[kNumAttributes]      = {"attr1", "attr2", "attr3"};
+  int values[kNumAttributes]            = {4, 7, 23};
+  std::map<std::string, int> attributes = {
+      {keys[0], values[0]}, {keys[1], values[1]}, {keys[2], values[2]}};
+
+  rec.AddEvent("Test Event", event_timestamp,
+               common::KeyValueIterableView<std::map<std::string, int>>(attributes));
+
+  nlohmann::json j_span = {
+      {"annotations",
+       {{{"value", json({{"Test Event", {{"attr1", 4}, {"attr2", 7}, {"attr3", 23}}}}).dump()},
+         {"timestamp", unix_event_time}}}}};
+  EXPECT_EQ(rec.span(), j_span);
+}
+
+// Test non-int single types. Int single types are tested using templates (see IntAttributeTest)
+TEST(ZipkinSpanRecordable, SetSingleAtrribute)
+{
+  zipkin::Recordable rec;
+  nostd::string_view bool_key = "bool_attr";
+  common::AttributeValue bool_val(true);
+  rec.SetAttribute(bool_key, bool_val);
+
+  nostd::string_view double_key = "double_attr";
+  common::AttributeValue double_val(3.3);
+  rec.SetAttribute(double_key, double_val);
+
+  nostd::string_view str_key = "str_attr";
+  common::AttributeValue str_val(nostd::string_view("Test"));
+  rec.SetAttribute(str_key, str_val);
+  nlohmann::json j_span = {
+      {"tags", {{"bool_attr", true}, {"double_attr", 3.3}, {"str_attr", "Test"}}}};
+
+  EXPECT_EQ(rec.span(), j_span);
+}
+
+// Test non-int array types. Int array types are tested using templates (see IntAttributeTest)
+TEST(ZipkinSpanRecordable, SetArrayAtrribute)
+{
+  zipkin::Recordable rec;
+  nlohmann::json j_span = {{"tags",
+                            {{"bool_arr_attr", {true, false, true}},
+                             {"double_arr_attr", {22.3, 33.4, 44.5}},
+                             {"str_arr_attr", {"Hello", "World", "Test"}}}}};
+  const int kArraySize  = 3;
+
+  bool bool_arr[kArraySize] = {true, false, true};
+  nostd::span<const bool> bool_span(bool_arr);
+  rec.SetAttribute("bool_arr_attr", bool_span);
+
+  double double_arr[kArraySize] = {22.3, 33.4, 44.5};
+  nostd::span<const double> double_span(double_arr);
+  rec.SetAttribute("double_arr_attr", double_span);
+
+  nostd::string_view str_arr[kArraySize] = {"Hello", "World", "Test"};
+  nostd::span<const nostd::string_view> str_span(str_arr);
+  rec.SetAttribute("str_arr_attr", str_span);
+
+  EXPECT_EQ(rec.span(), j_span);
+}
+
+TEST(ZipkinSpanRecordable, SetResource)
+{
+  zipkin::Recordable rec;
+  std::string service_name = "test";
+  auto resource = opentelemetry::sdk::resource::Resource::Create({{"service.name", service_name}});
+  rec.SetResource(resource);
+  EXPECT_EQ(rec.GetServiceName(), service_name);
+}
+
+/**
+ * AttributeValue can contain different int types, such as int, int64_t,
+ * unsigned int, and uint64_t. To avoid writing test cases for each, we can
+ * use a template approach to test all int types.
+ */
+template <typename T>
+struct ZipkinIntAttributeTest : public testing::Test
+{
+  using IntParamType = T;
+};
+
+using IntTypes = testing::Types<int, int64_t, unsigned int, uint64_t>;
+TYPED_TEST_SUITE(ZipkinIntAttributeTest, IntTypes);
+
+TYPED_TEST(ZipkinIntAttributeTest, SetIntSingleAttribute)
+{
+  using IntType = typename TestFixture::IntParamType;
+  IntType i     = 2;
+  common::AttributeValue int_val(i);
+
+  zipkin::Recordable rec;
+  rec.SetAttribute("int_attr", int_val);
+  nlohmann::json j_span = {{"tags", {{"int_attr", 2}}}};
+  EXPECT_EQ(rec.span(), j_span);
+}
+
+TYPED_TEST(ZipkinIntAttributeTest, SetIntArrayAttribute)
+{
+  using IntType = typename TestFixture::IntParamType;
+
+  const int kArraySize        = 3;
+  IntType int_arr[kArraySize] = {4, 5, 6};
+  nostd::span<const IntType> int_span(int_arr);
+
+  zipkin::Recordable rec;
+  rec.SetAttribute("int_arr_attr", int_span);
+  nlohmann::json j_span = {{"tags", {{"int_arr_attr", {4, 5, 6}}}}};
+  EXPECT_EQ(rec.span(), j_span);
+}