[EXPORTER] Add custom HTTP client

CMakeLists.txt

@@ -274,15 +274,13 @@ include(GNUInstallDirs)
 # Do we need HTTP CLIENT CURL ?
 #
 
-if(WITH_OTLP_HTTP
-   OR WITH_ELASTICSEARCH
-   OR WITH_ZIPKIN
-   OR BUILD_W3CTRACECONTEXT_TEST
-   OR WITH_EXAMPLES_HTTP)
-  set(WITH_HTTP_CLIENT_CURL ON)
-else()
-  set(WITH_HTTP_CLIENT_CURL OFF)
-endif()
+include(CMakeDependentOption)
+cmake_dependent_option(
+  WITH_HTTP_CLIENT_CURL
+  "Use the curl HTTP client backend. Defaults to ON when any HTTP exporter is enabled; set OFF to supply a custom transport."
+  ON
+  "WITH_OTLP_HTTP OR WITH_ELASTICSEARCH OR WITH_ZIPKIN OR BUILD_W3CTRACECONTEXT_TEST OR WITH_EXAMPLES_HTTP"
+  OFF)
 
 #
 # Do we need ZLIB ?

ci/do_ci.sh

@@ -489,6 +489,7 @@ elif [[ "$1" == "cmake.install.test" ]]; then
     "sdk"
     "configuration"
     "ext_common"
+    "ext_http"
     "ext_http_curl"
     "exporters_in_memory"
     "exporters_ostream"

examples/CMakeLists.txt

@@ -38,3 +38,7 @@ endif()
 if(WITH_CONFIGURATION)
   add_subdirectory(configuration)
 endif()
+
+if(WITH_OTLP_HTTP)
+  add_subdirectory(custom_http_client)
+endif()

examples/custom_http_client/CMakeLists.txt

@@ -0,0 +1,16 @@
+# Copyright The OpenTelemetry Authors
+# SPDX-License-Identifier: Apache-2.0
+
+add_library(custom_http_client_stub STATIC custom_http_client.cc)
+target_link_libraries(custom_http_client_stub PUBLIC opentelemetry-cpp::ext
+                                                     opentelemetry-cpp::sdk)
+
+add_executable(example_custom_http_client main.cc)
+target_link_libraries(
+  example_custom_http_client PRIVATE custom_http_client_stub
+                                     opentelemetry-cpp::otlp_http_exporter)
+
+if(BUILD_TESTING)
+  add_test(NAME examples.custom_http_client
+           COMMAND "$<TARGET_FILE:example_custom_http_client>")
+endif()

examples/custom_http_client/custom_http_client.cc

@@ -0,0 +1,145 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <chrono>
+#include <cstddef>
+#include <iostream>
+#include <memory>
+#include <string>
+
+#include "opentelemetry/ext/http/client/http_client.h"
+#include "opentelemetry/nostd/string_view.h"
+
+#include "custom_http_client.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace ext
+{
+namespace http
+{
+namespace client
+{
+
+namespace
+{
+
+class LoggingRequest : public Request
+{
+public:
+  void SetMethod(Method method) noexcept override
+  {
+    switch (method)
+    {
+      case Method::Get:
+        method_ = "GET";
+        break;
+      case Method::Post:
+        method_ = "POST";
+        break;
+      case Method::Put:
+        method_ = "PUT";
+        break;
+      default:
+        method_ = "OTHER";
+        break;
+    }
+  }
+
+  void SetUri(nostd::string_view uri) noexcept override { uri_ = std::string(uri); }
+
+  void SetBody(Body &body) noexcept override { body_size_ = body.size(); }
+
+  void SetSslOptions(const HttpSslOptions &) noexcept override {}
+  void AddHeader(nostd::string_view, nostd::string_view) noexcept override {}
+  void ReplaceHeader(nostd::string_view, nostd::string_view) noexcept override {}
+  void SetTimeoutMs(std::chrono::milliseconds) noexcept override {}
+  void SetCompression(const Compression &) noexcept override {}
+  void EnableLogging(bool) noexcept override {}
+  void SetRetryPolicy(const RetryPolicy &) noexcept override {}
+
+  const std::string &GetMethod() const { return method_; }
+  const std::string &GetUri() const { return uri_; }
+  std::size_t GetBodySize() const { return body_size_; }
+
+private:
+  std::string method_;
+  std::string uri_;
+  std::size_t body_size_ = 0;
+};
+
+class OkResponse : public NoopResponse
+{
+public:
+  StatusCode GetStatusCode() const noexcept override { return 200; }
+};
+
+class LoggingSession : public Session
+{
+public:
+  std::shared_ptr<Request> CreateRequest() noexcept override
+  {
+    request_ = std::make_shared<LoggingRequest>();
+    return request_;
+  }
+
+  void SendRequest(std::shared_ptr<EventHandler> handler) noexcept override
+  {
+    if (request_)
+    {
+      std::cout << "Custom HTTP client: " << request_->GetMethod() << " " << request_->GetUri()
+                << " (" << request_->GetBodySize() << " bytes)\n";
+    }
+    if (!handler)
+    {
+      return;
+    }
+    OkResponse response;
+    handler->OnResponse(response);
+    handler->OnEvent(SessionState::Response, {});
+    std::cout << "Custom HTTP client: export acknowledged\n";
+  }
+
+  bool IsSessionActive() noexcept override { return false; }
+  bool CancelSession() noexcept override { return true; }
+  bool FinishSession() noexcept override { return true; }
+
+private:
+  std::shared_ptr<LoggingRequest> request_;
+};
+
+class LoggingHttpClient : public HttpClient
+{
+public:
+  std::shared_ptr<Session> CreateSession(nostd::string_view url) noexcept override
+  {
+    std::cout << "Custom HTTP client: creating session for " << std::string(url) << "\n";
+    return std::make_shared<LoggingSession>();
+  }
+
+  bool CancelAllSessions() noexcept override { return true; }
+  bool FinishAllSessions() noexcept override { return true; }
+  void SetMaxSessionsPerConnection(std::size_t) noexcept override {}
+};
+
+}  // namespace
+
+std::shared_ptr<HttpClient> LoggingHttpClientFactory::Create()
+{
+  return std::make_shared<LoggingHttpClient>();
+}
+
+std::shared_ptr<HttpClient> LoggingHttpClientFactory::Create(
+    const std::shared_ptr<sdk::common::ThreadInstrumentation> &)
+{
+  return std::make_shared<LoggingHttpClient>();
+}
+
+std::shared_ptr<HttpClientSync> LoggingHttpClientFactory::CreateSync()
+{
+  return nullptr;
+}
+
+}  // namespace client
+}  // namespace http
+}  // namespace ext
+OPENTELEMETRY_END_NAMESPACE

examples/custom_http_client/custom_http_client.h

@@ -0,0 +1,29 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include "opentelemetry/ext/http/client/http_client_factory.h"
+#include "opentelemetry/version.h"
+
+OPENTELEMETRY_BEGIN_NAMESPACE
+namespace ext
+{
+namespace http
+{
+namespace client
+{
+
+class LoggingHttpClientFactory : public HttpClientFactory
+{
+public:
+  std::shared_ptr<HttpClientSync> CreateSync() override;
+  std::shared_ptr<HttpClient> Create() override;
+  std::shared_ptr<HttpClient> Create(
+      const std::shared_ptr<sdk::common::ThreadInstrumentation> &thread_instrumentation) override;
+};
+
+}  // namespace client
+}  // namespace http
+}  // namespace ext
+OPENTELEMETRY_END_NAMESPACE

examples/custom_http_client/main.cc

@@ -0,0 +1,42 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "custom_http_client.h"
+#include "opentelemetry/exporters/otlp/otlp_http_exporter_factory.h"
+#include "opentelemetry/exporters/otlp/otlp_http_exporter_options.h"
+#include "opentelemetry/sdk/trace/exporter.h"
+#include "opentelemetry/sdk/trace/processor.h"
+#include "opentelemetry/sdk/trace/simple_processor_factory.h"
+#include "opentelemetry/sdk/trace/tracer_provider.h"
+#include "opentelemetry/sdk/trace/tracer_provider_factory.h"
+#include "opentelemetry/trace/span.h"
+#include "opentelemetry/trace/tracer.h"
+
+namespace trace_sdk   = opentelemetry::sdk::trace;
+namespace otlp        = opentelemetry::exporter::otlp;
+namespace http_client = opentelemetry::ext::http::client;
+
+int main()
+{
+  otlp::OtlpHttpExporterOptions options;
+  options.url = "http://localhost:4318/v1/traces";
+
+  auto factory   = std::make_shared<http_client::LoggingHttpClientFactory>();
+  auto exporter  = otlp::OtlpHttpExporterFactory::Create(options, factory);
+  auto processor = trace_sdk::SimpleSpanProcessorFactory::Create(std::move(exporter));
+
+  std::shared_ptr<trace_sdk::TracerProvider> provider =
+      trace_sdk::TracerProviderFactory::Create(std::move(processor));
+
+  auto tracer = provider->GetTracer("custom-http-client-example");
+  auto span   = tracer->StartSpan("custom-span");
+  span->SetAttribute("example.key", "value");
+  span->End();
+
+  provider->ForceFlush();
+  return 0;
+}

examples/http/CMakeLists.txt

@@ -1,15 +1,17 @@
 # Copyright The OpenTelemetry Authors
 # SPDX-License-Identifier: Apache-2.0
 
-add_executable(http_client client.cc)
-add_executable(http_server server.cc)
+if(WITH_HTTP_CLIENT_CURL)
+  add_executable(http_client client.cc)
+  add_executable(http_server server.cc)
 
-target_link_libraries(
-  http_client
-  PRIVATE opentelemetry-cpp::trace opentelemetry-cpp::http_client_curl
-          opentelemetry-cpp::ostream_span_exporter CURL::libcurl)
+  target_link_libraries(
+    http_client
+    PRIVATE opentelemetry-cpp::trace opentelemetry-cpp::http_client_curl
+            opentelemetry-cpp::ostream_span_exporter CURL::libcurl)
 
-target_link_libraries(
-  http_server
-  PRIVATE opentelemetry-cpp::trace opentelemetry-cpp::http_client_curl
-          opentelemetry-cpp::ostream_span_exporter)
+  target_link_libraries(
+    http_server
+    PRIVATE opentelemetry-cpp::trace opentelemetry-cpp::http_client_curl
+            opentelemetry-cpp::ostream_span_exporter)
+endif()

examples/http/client.cc

@@ -5,8 +5,8 @@
 #include "opentelemetry/context/propagation/global_propagator.h"
 #include "opentelemetry/context/propagation/text_map_propagator.h"
 #include "opentelemetry/context/runtime_context.h"
+#include "opentelemetry/ext/http/client/curl/http_client_factory_curl.h"
 #include "opentelemetry/ext/http/client/http_client.h"
-#include "opentelemetry/ext/http/client/http_client_factory.h"
 #include "opentelemetry/ext/http/common/url_parser.h"
 #include "opentelemetry/nostd/function_ref.h"
 #include "opentelemetry/nostd/shared_ptr.h"
@@ -40,7 +40,7 @@ namespace semconv     = opentelemetry::semconv;
 
 void sendRequest(const std::string &url)
 {
-  auto http_client = http_client::HttpClientFactory::CreateSync();
+  auto http_client = std::make_shared<http_client::curl::HttpCurlClientFactory>()->CreateSync();
 
   // start active span
   StartSpanOptions options;

exporters/elasticsearch/CMakeLists.txt

@@ -17,7 +17,7 @@ target_include_directories(
 
 target_link_libraries(
   opentelemetry_exporter_elasticsearch_logs
-  PUBLIC opentelemetry_trace opentelemetry_logs opentelemetry_http_client_curl
+  PUBLIC opentelemetry_trace opentelemetry_logs opentelemetry_http_client
          nlohmann_json::nlohmann_json)
 
 otel_add_component(

exporters/elasticsearch/include/opentelemetry/exporters/elasticsearch/es_log_record_exporter.h

@@ -9,6 +9,7 @@
 #include <string>
 
 #include "opentelemetry/ext/http/client/http_client.h"
+#include "opentelemetry/ext/http/client/http_client_factory.h"
 #include "opentelemetry/nostd/shared_ptr.h"
 #include "opentelemetry/sdk/logs/exporter.h"
 #include "opentelemetry/version.h"
@@ -87,6 +88,23 @@ class ElasticsearchLogRecordExporter final : public opentelemetry::sdk::logs::Lo
    */
   ElasticsearchLogRecordExporter(const ElasticsearchExporterOptions &options);
 
+  /**
+   * Create an ElasticsearchLogRecordExporter with user specified options and HTTP client factory.
+   * @param options An object containing the user's configuration options.
+   * @param factory the HTTP client factory used to create the underlying HTTP client
+   */
+  ElasticsearchLogRecordExporter(
+      const ElasticsearchExporterOptions &options,
+      const std::shared_ptr<ext::http::client::HttpClientFactory> &factory);
+
+  /**
+   * Create an ElasticsearchLogRecordExporter with user specified options and HTTP client.
+   * @param options An object containing the user's configuration options.
+   * @param http_client the HTTP client to be used for exporting
+   */
+  ElasticsearchLogRecordExporter(const ElasticsearchExporterOptions &options,
+                                 std::shared_ptr<ext::http::client::HttpClient> http_client);
+
   /**
    * Creates a recordable that stores the data in a JSON object
    * @return a newly initialized Recordable object.

exporters/elasticsearch/src/es_log_record_exporter.cc

@@ -16,6 +16,7 @@
 
 #include "opentelemetry/exporters/elasticsearch/es_log_record_exporter.h"
 #include "opentelemetry/exporters/elasticsearch/es_log_recordable.h"
+#include "opentelemetry/ext/http/client/detail/default_factory.h"
 #include "opentelemetry/ext/http/client/http_client.h"
 #include "opentelemetry/ext/http/client/http_client_factory.h"
 #include "opentelemetry/nostd/function_ref.h"
@@ -320,8 +321,21 @@ ElasticsearchLogRecordExporter::ElasticsearchLogRecordExporter()
 
 ElasticsearchLogRecordExporter::ElasticsearchLogRecordExporter(
     const ElasticsearchExporterOptions &options)
+    : ElasticsearchLogRecordExporter(options,
+                                     ext::http::client::detail::GetDefaultHttpClientFactory())
+{}
+
+ElasticsearchLogRecordExporter::ElasticsearchLogRecordExporter(
+    const ElasticsearchExporterOptions &options,
+    const std::shared_ptr<ext::http::client::HttpClientFactory> &factory)
+    : ElasticsearchLogRecordExporter(options, factory->Create())
+{}
+
+ElasticsearchLogRecordExporter::ElasticsearchLogRecordExporter(
+    const ElasticsearchExporterOptions &options,
+    std::shared_ptr<ext::http::client::HttpClient> http_client)
     : options_{options},
-      http_client_{ext::http::client::HttpClientFactory::Create()}
+      http_client_{std::move(http_client)}
 #ifdef ENABLE_ASYNC_EXPORT
       ,
       synchronization_data_(new SynchronizationData())