opentelemetry tracer: add OTLP/HTTP exporter

api/envoy/config/core/v3/http_service.proto

@@ -0,0 +1,48 @@
+syntax = "proto3";
+
+package envoy.config.core.v3;
+
+import "envoy/config/core/v3/base.proto";
+
+import "google/protobuf/duration.proto";
+
+import "udpa/annotations/status.proto";
+import "validate/validate.proto";
+
+option java_package = "io.envoyproxy.envoy.config.core.v3";
+option java_outer_classname = "HttpServiceProto";
+option java_multiple_files = true;
+option go_package = "github.com/envoyproxy/go-control-plane/envoy/config/core/v3;corev3";
+option (udpa.annotations.file_status).package_version_status = ACTIVE;
+
+// [#protodoc-title: HTTP services]
+
+// HTTP service configuration.
+// [#next-free-field: 6]
+message HttpService {
+  // The name of the upstream HTTP cluster. SSL credentials will be supplied
+  // in the :ref:`Cluster <envoy_v3_api_msg_config.cluster.v3.Cluster>` :ref:`transport_socket
+  // <envoy_v3_api_field_config.cluster.v3.Cluster.transport_socket>`.
+  string cluster_name = 1 [(validate.rules).string = {min_len: 1}];
+
+  // The path to use for the service.
+  // The default is an empty string.
+  string path = 2;
+
+  // Specifies a list of HTTP headers that should be added to each request
+  // handled by this virtual host.
+  repeated HeaderValueOption request_headers_to_add = 3
+      [(validate.rules).repeated = {max_items: 1000}];
+
+  // The timeout for the HTTP request. This is the timeout for a specific
+  // request.
+  // Sets the maximum duration in milliseconds that a response can take to arrive upon request.
+  google.protobuf.Duration timeout = 4 [(validate.rules).duration = {
+    required: true
+    gte {}
+  }];
+
+  // Specifies the hostname that should be added to the Host header to each request.
+  // The default is an empty string.
+  string hostname = 5;
+}

api/envoy/config/trace/v3/opentelemetry.proto

@@ -3,6 +3,7 @@ syntax = "proto3";
 package envoy.config.trace.v3;
 
 import "envoy/config/core/v3/grpc_service.proto";
+import "envoy/config/core/v3/http_service.proto";
 
 import "udpa/annotations/status.proto";
 
@@ -19,9 +20,15 @@ option (udpa.annotations.file_status).package_version_status = ACTIVE;
 message OpenTelemetryConfig {
   // The upstream gRPC cluster that will receive OTLP traces.
   // Note that the tracer drops traces if the server does not read data fast enough.
-  // This field can be left empty to disable reporting traces to the collector.
+  // This field can be left empty to disable reporting traces to the upstream cluster.
+  // Only one of ``grpc_service``, ``http_service`` may be used.
   core.v3.GrpcService grpc_service = 1;
 
+  // The upstream HTTP cluster that will receive OTLP traces.
+  // This field can be left empty to disable reporting traces to the upstream cluster.
+  // Only one of ``grpc_service``, ``http_service`` may be used.
+  core.v3.HttpService http_service = 3;
+
   // The name for the service. This will be populated in the ResourceSpan Resource attributes.
   // If it is not provided, it will default to "unknown_service:envoy".
   string service_name = 2;

docs/root/api-v3/common_messages/common_messages.rst

@@ -23,6 +23,7 @@ Common messages
   ../extensions/filters/common/dependency/v3/dependency.proto
   ../extensions/regex_engines/v3/google_re2.proto
   ../config/core/v3/grpc_method_list.proto
+  ../config/core/v3/http_service.proto
   ../config/core/v3/grpc_service.proto
   ../extensions/key_value/file_based/v3/config.proto
   ../config/common/key_value/v3/config.proto

source/extensions/tracers/opentelemetry/BUILD

@@ -34,9 +34,10 @@ envoy_cc_library(
         "span_context.h",
         "span_context_extractor.h",
         "tracer.h",
+        "tracer_stats.h",
     ],
     deps = [
-        ":grpc_trace_exporter",
+        ":trace_exporter",
         "//envoy/thread_local:thread_local_interface",
         "//source/common/config:utility_lib",
         "//source/common/tracing:http_tracer_lib",
@@ -47,13 +48,27 @@ envoy_cc_library(
 )
 
 envoy_cc_library(
-    name = "grpc_trace_exporter",
-    srcs = ["grpc_trace_exporter.cc"],
-    hdrs = ["grpc_trace_exporter.h"],
+    name = "trace_exporter",
+    srcs = [
+        "grpc_trace_exporter.cc",
+        "http_trace_exporter.cc",
+    ],
+    hdrs = [
+        "grpc_trace_exporter.h",
+        "http_trace_exporter.h",
+        "trace_exporter.h",
+        "tracer_stats.h",
+    ],
     deps = [
         "//envoy/grpc:async_client_manager_interface",
+        "//envoy/upstream:cluster_manager_interface",
         "//source/common/grpc:typed_async_client_lib",
+        "//source/common/http:async_client_utility_lib",
+        "//source/common/http:header_map_lib",
+        "//source/common/http:message_lib",
+        "//source/common/http:utility_lib",
         "//source/common/protobuf",
+        "@envoy_api//envoy/config/core/v3:pkg_cc_proto",
         "@opentelemetry_proto//:trace_cc_proto",
     ],
 )

source/extensions/tracers/opentelemetry/grpc_trace_exporter.h

@@ -6,6 +6,7 @@
 #include "source/common/grpc/typed_async_client.h"
 
 #include "opentelemetry/proto/collector/trace/v1/trace_service.pb.h"
+#include "trace_exporter.h"
 
 namespace Envoy {
 namespace Extensions {
@@ -80,18 +81,16 @@ class OpenTelemetryGrpcTraceExporterClient : Logger::Loggable<Logger::Id::tracin
   const Protobuf::MethodDescriptor& service_method_;
 };
 
-class OpenTelemetryGrpcTraceExporter : Logger::Loggable<Logger::Id::tracing> {
+class OpenTelemetryGrpcTraceExporter : public OpenTelemetryTraceExporter {
 public:
   OpenTelemetryGrpcTraceExporter(const Grpc::RawAsyncClientSharedPtr& client);
 
-  bool log(const ExportTraceServiceRequest& request);
+  bool log(const ExportTraceServiceRequest& request) override;
 
 private:
   OpenTelemetryGrpcTraceExporterClient client_;
 };
 
-using OpenTelemetryGrpcTraceExporterPtr = std::unique_ptr<OpenTelemetryGrpcTraceExporter>;
-
 } // namespace OpenTelemetry
 } // namespace Tracers
 } // namespace Extensions

source/extensions/tracers/opentelemetry/http_trace_exporter.cc

@@ -0,0 +1,86 @@
+#include "http_trace_exporter.h"
+
+#include <chrono>
+#include <memory>
+#include <string>
+
+#include "source/common/common/logger.h"
+#include "source/common/protobuf/protobuf.h"
+
+namespace Envoy {
+namespace Extensions {
+namespace Tracers {
+namespace OpenTelemetry {
+
+OpenTelemetryHttpTraceExporter::OpenTelemetryHttpTraceExporter(
+    Upstream::ClusterManager& cluster_manager, envoy::config::core::v3::HttpService http_service,
+    OpenTelemetryTracerStats& tracing_stats)
+    : cluster_manager_(cluster_manager), http_service_(http_service),
+      tracing_stats_(tracing_stats) {}
+
+bool OpenTelemetryHttpTraceExporter::log(const ExportTraceServiceRequest& request) {
+
+  std::string request_body;
+
+  const auto ok = request.SerializeToString(&request_body);
+  if (!ok) {
+    ENVOY_LOG(warn, "Error while serializing the binary proto ExportTraceServiceRequest.");
+    return false;
+  }
+
+  Http::RequestMessagePtr message = std::make_unique<Http::RequestMessageImpl>();
+  message->headers().setReferenceMethod(Http::Headers::get().MethodValues.Post);
+  message->headers().setReferenceContentType(Http::Headers::get().ContentTypeValues.Protobuf);
+
+  // If traces_path is omitted, send to /v1/traces by default
+  if (http_service_.path().empty()) {
+    message->headers().setPath(TRACES_PATH);
+  } else {
+    message->headers().setPath(http_service_.path());
+  }
+
+  message->headers().setHost(http_service_.hostname());
+
+  // add all custom headers to the request
+  for (const auto& header_value_option : http_service_.request_headers_to_add()) {
+    message->headers().setCopy(Http::LowerCaseString(header_value_option.header().key()),
+                               header_value_option.header().value());
+  }
+
+  message->body().add(request_body);
+
+  const auto thread_local_cluster =
+      cluster_manager_.getThreadLocalCluster(http_service_.cluster_name());
+  if (thread_local_cluster == nullptr) {
+    ENVOY_LOG(warn, "Thread local cluster not found for collector.");
+    return false;
+  }
+
+  std::chrono::milliseconds timeout = std::chrono::duration_cast<std::chrono::milliseconds>(
+      std::chrono::nanoseconds(http_service_.timeout().nanos()));
+  Http::AsyncClient::Request* http_request = thread_local_cluster->httpAsyncClient().send(
+      std::move(message), *this, Http::AsyncClient::RequestOptions().setTimeout(timeout));
+  tracing_stats_.http_reports_sent_.inc();
+
+  return http_request;
+}
+
+void OpenTelemetryHttpTraceExporter::onSuccess(const Http::AsyncClient::Request&,
+                                               Http::ResponseMessagePtr&& message) {
+  tracing_stats_.http_reports_success_.inc();
+  const auto response_code = message->headers().Status()->value().getStringView();
+  if (response_code != "200") {
+    ENVOY_LOG(warn, "response code: {}", response_code);
+  }
+}
+
+void OpenTelemetryHttpTraceExporter::onFailure(const Http::AsyncClient::Request&,
+                                               Http::AsyncClient::FailureReason) {
+  ENVOY_LOG(debug, "Request failed.");
+  tracing_stats_.http_reports_failed_.inc();
+}
+
+} // namespace OpenTelemetry
+} // namespace Tracers
+} // namespace Extensions
+} // namespace Envoy

source/extensions/tracers/opentelemetry/http_trace_exporter.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include "envoy/config/core/v3/http_service.pb.h"
+#include "envoy/upstream/cluster_manager.h"
+
+#include "source/common/common/logger.h"
+#include "source/common/http/async_client_impl.h"
+#include "source/common/http/async_client_utility.h"
+#include "source/common/http/headers.h"
+#include "source/common/http/message_impl.h"
+#include "source/common/http/utility.h"
+
+#include "opentelemetry/proto/collector/trace/v1/trace_service.pb.h"
+#include "trace_exporter.h"
+#include "tracer_stats.h"
+
+namespace Envoy {
+namespace Extensions {
+namespace Tracers {
+namespace OpenTelemetry {
+
+/**
+ * Exporter for OTLP traces over HTTP.
+ */
+class OpenTelemetryHttpTraceExporter : public OpenTelemetryTraceExporter,
+                                       public Http::AsyncClient::Callbacks {
+public:
+  OpenTelemetryHttpTraceExporter(Upstream::ClusterManager& cluster_manager,
+                                 envoy::config::core::v3::HttpService http_service,
+                                 OpenTelemetryTracerStats& tracing_stats);
+
+  // The default path to use when OpenTelemetryConfig::HttpConfig::traces_path is empty
+  const Http::LowerCaseString TRACES_PATH{"/v1/traces"};
+
+  bool log(const ExportTraceServiceRequest& request) override;
+
+  // Http::AsyncClient::Callbacks.
+  void onSuccess(const Http::AsyncClient::Request&, Http::ResponseMessagePtr&&) override;
+  void onFailure(const Http::AsyncClient::Request&, Http::AsyncClient::FailureReason) override;
+  void onBeforeFinalizeUpstreamSpan(Tracing::Span&, const Http::ResponseHeaderMap*) override {}
+
+private:
+  Upstream::ClusterManager& cluster_manager_;
+  envoy::config::core::v3::HttpService http_service_;
+  OpenTelemetryTracerStats& tracing_stats_;
+};
+
+} // namespace OpenTelemetry
+} // namespace Tracers
+} // namespace Extensions
+} // namespace Envoy

source/extensions/tracers/opentelemetry/opentelemetry_tracer_impl.cc

@@ -9,10 +9,13 @@
 #include "source/common/config/utility.h"
 #include "source/common/tracing/http_tracer_impl.h"
 
+#include "grpc_trace_exporter.h"
+#include "http_trace_exporter.h"
 #include "opentelemetry/proto/collector/trace/v1/trace_service.pb.h"
 #include "opentelemetry/proto/trace/v1/trace.pb.h"
 #include "span_context.h"
 #include "span_context_extractor.h"
+#include "trace_exporter.h"
 #include "tracer.h"
 
 namespace Envoy {
@@ -26,16 +29,26 @@ Driver::Driver(const envoy::config::trace::v3::OpenTelemetryConfig& opentelemetr
       tracing_stats_{OPENTELEMETRY_TRACER_STATS(
           POOL_COUNTER_PREFIX(context.serverFactoryContext().scope(), "tracing.opentelemetry"))} {
   auto& factory_context = context.serverFactoryContext();
+
+  if (opentelemetry_config.has_grpc_service() && opentelemetry_config.has_http_service()) {
+    throw EnvoyException(
+        "OpenTelemetry Tracer cannot have both gRPC and HTTP exporters configured. "
+        "OpenTelemetry tracer will be disabled.");
+  }
+
   // Create the tracer in Thread Local Storage.
   tls_slot_ptr_->set([opentelemetry_config, &factory_context, this](Event::Dispatcher& dispatcher) {
-    OpenTelemetryGrpcTraceExporterPtr exporter;
+    OpenTelemetryTraceExporterPtr exporter;
     if (opentelemetry_config.has_grpc_service()) {
       Grpc::AsyncClientFactoryPtr&& factory =
           factory_context.clusterManager().grpcAsyncClientManager().factoryForGrpcService(
               opentelemetry_config.grpc_service(), factory_context.scope(), true);
       const Grpc::RawAsyncClientSharedPtr& async_client_shared_ptr =
           factory->createUncachedRawAsyncClient();
       exporter = std::make_unique<OpenTelemetryGrpcTraceExporter>(async_client_shared_ptr);
+    } else if (opentelemetry_config.has_http_service()) {
+      exporter = std::make_unique<OpenTelemetryHttpTraceExporter>(
+          factory_context.clusterManager(), opentelemetry_config.http_service(), tracing_stats_);
     }
     TracerPtr tracer = std::make_unique<Tracer>(
         std::move(exporter), factory_context.timeSource(), factory_context.api().randomGenerator(),

source/extensions/tracers/opentelemetry/opentelemetry_tracer_impl.h

@@ -8,8 +8,8 @@
 #include "source/common/common/logger.h"
 #include "source/common/singleton/const_singleton.h"
 #include "source/extensions/tracers/common/factory_base.h"
-#include "source/extensions/tracers/opentelemetry/grpc_trace_exporter.h"
-#include "source/extensions/tracers/opentelemetry/tracer.h"
+
+#include "tracer.h"
 
 namespace Envoy {
 namespace Extensions {

source/extensions/tracers/opentelemetry/trace_exporter.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "source/common/common/logger.h"
+
+#include "opentelemetry/proto/collector/trace/v1/trace_service.pb.h"
+
+using opentelemetry::proto::collector::trace::v1::ExportTraceServiceRequest;
+
+namespace Envoy {
+namespace Extensions {
+namespace Tracers {
+namespace OpenTelemetry {
+
+class OpenTelemetryTraceExporter : public Logger::Loggable<Logger::Id::tracing> {
+public:
+  virtual ~OpenTelemetryTraceExporter() = default;
+
+  virtual bool log(const ExportTraceServiceRequest& request) = 0;
+};
+
+using OpenTelemetryTraceExporterPtr = std::unique_ptr<OpenTelemetryTraceExporter>;
+
+} // namespace OpenTelemetry
+} // namespace Tracers
+} // namespace Extensions
+} // namespace Envoy

source/extensions/tracers/opentelemetry/tracer.cc

@@ -91,7 +91,7 @@ void Span::setTag(absl::string_view name, absl::string_view value) {
   *span_.add_attributes() = key_value;
 }
 
-Tracer::Tracer(OpenTelemetryGrpcTraceExporterPtr exporter, Envoy::TimeSource& time_source,
+Tracer::Tracer(OpenTelemetryTraceExporterPtr exporter, Envoy::TimeSource& time_source,
                Random::RandomGenerator& random, Runtime::Loader& runtime,
                Event::Dispatcher& dispatcher, OpenTelemetryTracerStats tracing_stats,
                const std::string& service_name)