datadog 2.17.0 → 2.37.0

data/lib/datadog/opentelemetry/api/baggage.rb

@@ -26,7 +26,7 @@ module Datadog
         # to ::OpenTelemetry::Context.current
         # @return [Context]
         def clear(context: ::OpenTelemetry::Context.current)
-          context.ensure_trace.baggage.clear
+          context.ensure_trace&.baggage&.clear
           context
         end
 
@@ -69,7 +69,7 @@ module Datadog
         def set_value(key, value, metadata: nil, context: ::OpenTelemetry::Context.current)
           # Delegate to the context to set the value because an active trace is not guaranteed
           # set_values handles this logic
-          context.set_values({ ::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY) => { key => value } })
+          context.set_values({::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY) => {key => value}})
         end
 
         # Returns a new context with value at key removed
@@ -81,7 +81,7 @@ module Datadog
         def remove_value(key, context: ::OpenTelemetry::Context.current)
           # Delegate to the context to remove the value because an active trace is not guaranteed
           # set_values handles this logic
-          context.set_values({ Context::BAGGAGE_REMOVE_KEY => key })
+          context.set_values({Context::BAGGAGE_REMOVE_KEY => key})
         end
         ::OpenTelemetry::Baggage.singleton_class.prepend(self)
       end

data/lib/datadog/opentelemetry/api/context.rb

@@ -50,7 +50,8 @@ module Datadog
           @trace.otel_value(key)
         end
 
-        alias [] value
+        # `alias` performed to match {::OpenTelemetry::Context} aliasing upstream
+        alias [] value # rubocop:disable Style/Alias
 
         # Returns a new Context where entries contains the newly added key and value
         #
@@ -80,8 +81,8 @@ module Datadog
             )
           end
 
-          existing_values = @trace && @trace.otel_values || {}
-          existing_baggage = @trace && @trace.baggage || {}
+          existing_values = @trace&.otel_values || {}
+          existing_baggage = @trace&.baggage || {}
 
           # Retrieve the baggage removal sentinel and remove it from the values hash
           existing_baggage.delete(values[BAGGAGE_REMOVE_KEY]) if values.key?(BAGGAGE_REMOVE_KEY)
@@ -89,10 +90,10 @@ module Datadog
           # If the values hash contains a BAGGAGE_KEY, merge its contents with existing baggage
           # Otherwise, keep the existing baggage unchanged
           new_baggage = if values.key?(::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY))
-                          existing_baggage.merge(values[::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY)])
-                        else
-                          existing_baggage
-                        end
+            existing_baggage.merge(values[::OpenTelemetry::Baggage.const_get(:BAGGAGE_KEY)])
+          else
+            existing_baggage
+          end
 
           ::OpenTelemetry::Context.new(existing_values.merge(values), trace: trace, baggage: new_baggage)
         end
@@ -125,7 +126,7 @@ module Datadog
             previous_trace = Tracing.active_trace
             continue_trace!(context)
 
-            stack.push(previous_trace && previous_trace.otel_context || ::OpenTelemetry::Context::ROOT)
+            stack.push(previous_trace&.otel_context || ::OpenTelemetry::Context::ROOT)
             stack.size
           end
 
@@ -168,7 +169,7 @@ module Datadog
 
           def continue_trace!(context, &block)
             call_context = Tracing.send(:tracer).send(:call_context)
-            if context && context.trace
+            if context&.trace
               call_context.activate!(context.ensure_trace, &block)
             else
               call_context.activate!(nil)

data/lib/datadog/opentelemetry/configuration/settings.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative '../../core/configuration/ext'
+
+module Datadog
+  module OpenTelemetry
+    module Configuration
+      module Settings
+        def self.extended(base)
+          base = base.singleton_class unless base.is_a?(Class)
+          add_settings!(base)
+        end
+
+        def self.normalize_temporality_preference(env_var_name)
+          proc do |value|
+            if value && value.to_s.downcase != 'delta' && value.to_s.downcase != 'cumulative'
+              Datadog.logger.warn("#{env_var_name}=#{value} is not supported. Using delta instead.")
+              'delta'
+            else
+              value
+            end
+          end
+        end
+
+        def self.normalize_protocol(env_var_name)
+          proc do |value|
+            if value && value.to_s.downcase != 'http/protobuf'
+              Datadog.logger.warn("#{env_var_name}=#{value} is not supported. Using http/protobuf instead.")
+            end
+            'http/protobuf'
+          end
+        end
+
+        def self.headers_parser(env_var_name)
+          lambda do |value|
+            return {} if value.nil? || value.empty?
+
+            headers = {}
+            header_items = value.split(',')
+            header_items.each do |key_value|
+              key, header_value = key_value.split('=', 2)
+              # If header is malformed, return an empty hash
+              if key.nil? || header_value.nil?
+                Datadog.logger.warn("#{env_var_name} has malformed header: #{key_value.inspect}")
+                return {}
+              end
+
+              key.strip!
+              header_value.strip!
+              if key.empty? || header_value.empty?
+                Datadog.logger.warn("#{env_var_name} has empty key or value in: #{key_value.inspect}")
+                return {}
+              end
+
+              headers[key] = header_value
+            end
+            headers
+          end
+        end
+
+        def self.add_settings!(base)
+          base.class_eval do
+            settings :opentelemetry do
+              settings :exporter do
+                option :protocol do |o|
+                  o.type :string
+                  o.setter(&Settings.normalize_protocol('OTEL_EXPORTER_OTLP_PROTOCOL'))
+                  o.env 'OTEL_EXPORTER_OTLP_PROTOCOL'
+                  o.default 'http/protobuf'
+                end
+
+                option :timeout_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_EXPORTER_OTLP_TIMEOUT'
+                  o.default 10_000
+                end
+
+                option :headers do |o|
+                  o.skip_telemetry true
+                  o.type :hash
+                  o.env 'OTEL_EXPORTER_OTLP_HEADERS'
+                  o.default { {} }
+                  o.env_parser(&Settings.headers_parser('OTEL_EXPORTER_OTLP_HEADERS'))
+                end
+
+                option :endpoint do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_ENDPOINT'
+                  o.default nil
+                end
+              end
+
+              settings :metrics do
+                # Metrics-specific options default to nil to detect unset state.
+                # If a metrics-specific env var (e.g., OTEL_EXPORTER_OTLP_METRICS_TIMEOUT) is not set,
+                # we fall back to the general OTLP env var (e.g., OTEL_EXPORTER_OTLP_TIMEOUT) per OpenTelemetry spec.
+                option :enabled do |o|
+                  o.type :bool
+                  o.env 'DD_METRICS_OTEL_ENABLED'
+                  o.default false
+                end
+
+                option :exporter do |o|
+                  o.type :string
+                  o.env 'OTEL_METRICS_EXPORTER'
+                  o.default 'otlp'
+                end
+
+                option :export_interval_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_METRIC_EXPORT_INTERVAL'
+                  o.default 10_000
+                end
+
+                option :export_timeout_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_METRIC_EXPORT_TIMEOUT'
+                  o.default 7_500
+                end
+
+                option :temporality_preference do |o|
+                  o.type :string
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'
+                  o.default 'delta'
+                  o.setter(&Settings.normalize_temporality_preference('OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'))
+                end
+
+                option :endpoint do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_ENDPOINT'
+                  o.default nil
+                end
+
+                option :headers do |o|
+                  o.skip_telemetry true
+                  o.type :hash, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_HEADERS'
+                  o.default nil
+                  o.env_parser(&Settings.headers_parser('OTEL_EXPORTER_OTLP_METRICS_HEADERS'))
+                end
+
+                option :timeout_millis do |o|
+                  o.type :int, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_TIMEOUT'
+                  o.default 10000
+                end
+
+                option :protocol do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_METRICS_PROTOCOL'
+                  o.default "http/protobuf"
+                  o.setter(&Settings.normalize_protocol('OTEL_EXPORTER_OTLP_METRICS_PROTOCOL'))
+                end
+              end
+
+              settings :logs do
+                option :enabled do |o|
+                  o.type :bool
+                  o.env 'DD_LOGS_OTEL_ENABLED'
+                  o.default false
+                end
+
+                option :exporter do |o|
+                  o.type :string
+                  o.env 'OTEL_LOGS_EXPORTER'
+                  o.default 'otlp'
+                end
+
+                option :endpoint do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_LOGS_ENDPOINT'
+                  o.default nil
+                end
+
+                option :headers do |o|
+                  o.skip_telemetry true
+                  o.type :hash, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_LOGS_HEADERS'
+                  o.default nil
+                  o.env_parser(&Settings.headers_parser('OTEL_EXPORTER_OTLP_LOGS_HEADERS'))
+                end
+
+                option :timeout_millis do |o|
+                  o.type :int, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_LOGS_TIMEOUT'
+                  o.default 10_000
+                end
+
+                option :protocol do |o|
+                  o.type :string, nilable: true
+                  o.env 'OTEL_EXPORTER_OTLP_LOGS_PROTOCOL'
+                  o.default "http/protobuf"
+                  o.setter(&Settings.normalize_protocol('OTEL_EXPORTER_OTLP_LOGS_PROTOCOL'))
+                end
+
+                option :max_queue_size do |o|
+                  o.type :int
+                  o.env 'OTEL_BLRP_MAX_QUEUE_SIZE'
+                  o.default 2048
+                end
+
+                option :schedule_delay_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_BLRP_SCHEDULE_DELAY'
+                  o.default 1000
+                end
+
+                option :export_timeout_millis do |o|
+                  o.type :int
+                  o.env 'OTEL_BLRP_EXPORT_TIMEOUT'
+                  o.default 30_000
+                end
+
+                option :max_export_batch_size do |o|
+                  o.type :int
+                  o.env 'OTEL_BLRP_MAX_EXPORT_BATCH_SIZE'
+                  o.default 512
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/ext.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenTelemetry
+    module Ext
+      EXPORTER_NONE = 'none'
+    end
+  end
+end

data/lib/datadog/opentelemetry/logs.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+require_relative 'signal_configuration'
+
+module Datadog
+  module OpenTelemetry
+    class Logs
+      include SignalConfiguration
+
+      def self.initialize!(components)
+        new(components).configure_logs_sdk
+        true
+      rescue => exc
+        components.logger.warn(
+          "Failed to initialize OpenTelemetry logs: #{exc.class}: #{exc.message}\n#{(exc.backtrace || []).join("\n")}"
+        )
+        false
+      end
+
+      def initialize(components)
+        @logger = components.logger
+        @settings = components.settings
+        @agent_host = components.agent_settings.hostname
+        @agent_ssl = components.agent_settings.ssl
+      end
+
+      def configure_logs_sdk
+        provider = ::OpenTelemetry.logger_provider
+        provider.shutdown if provider.is_a?(::OpenTelemetry::SDK::Logs::LoggerProvider)
+
+        resource = create_resource
+        provider = ::OpenTelemetry::SDK::Logs::LoggerProvider.new(resource: resource)
+        processor_configured = configure_log_record_processor(provider)
+        ::OpenTelemetry.logger_provider = provider
+
+        disable_log_injection if processor_configured
+      end
+
+      private
+
+      def disable_log_injection
+        @logger.warn('OTel logs enabled: disabling Datadog log injection to prevent duplicate trace correlation fields')
+        Datadog.configure do |c|
+          c.tracing.log_injection = false # steep:ignore
+        end
+      end
+
+      def configure_log_record_processor(provider)
+        exporter_name = @settings.opentelemetry.logs.exporter
+        return false if exporter_name == Ext::EXPORTER_NONE
+
+        configure_otlp_exporter(provider)
+      rescue => e
+        @logger.warn("Failed to configure OTLP logs exporter: #{e.class}: #{e.message}")
+        false
+      end
+
+      def default_logs_endpoint
+        "#{@agent_ssl ? 'https' : 'http'}://#{@agent_host}:4318/v1/logs"
+      end
+
+      def configure_otlp_exporter(provider)
+        require_relative 'sdk/logs_exporter'
+
+        logs_config = @settings.opentelemetry.logs
+        endpoint = config_or_exporter_fallback(
+          signal: :logs,
+          option_name: :endpoint,
+          computed_default: default_logs_endpoint
+        )
+        timeout = config_or_exporter_fallback(signal: :logs, option_name: :timeout_millis)
+        headers = config_or_exporter_fallback(signal: :logs, option_name: :headers)
+        # opentelemetry-logs-sdk only supports http/protobuf protocol as of 0.5.0.
+        config_or_exporter_fallback(signal: :logs, option_name: :protocol)
+
+        exporter = Datadog::OpenTelemetry::SDK::LogsExporter.new(
+          endpoint: endpoint,
+          timeout: timeout / 1000.0,
+          headers: headers
+        )
+
+        processor = ::OpenTelemetry::SDK::Logs::Export::BatchLogRecordProcessor.new(
+          exporter,
+          max_queue_size: logs_config.max_queue_size,
+          schedule_delay: logs_config.schedule_delay_millis,
+          exporter_timeout: logs_config.export_timeout_millis,
+          max_export_batch_size: logs_config.max_export_batch_size
+        )
+        provider.add_log_record_processor(processor)
+        true
+      rescue LoadError => e
+        @logger.warn("Could not load OTLP logs exporter: #{e.class}: #{e.message}")
+        false
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/metrics.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative '../core/configuration/ext'
+require_relative 'ext'
+require_relative 'signal_configuration'
+
+module Datadog
+  module OpenTelemetry
+    class Metrics
+      include SignalConfiguration
+
+      def self.initialize!(components)
+        new(components).configure_metrics_sdk
+        true
+      rescue => exc
+        components.logger.warn("Failed to initialize OpenTelemetry metrics: #{exc.class}: #{exc.message}: #{exc.backtrace.join("\n")}")
+        false
+      end
+
+      def initialize(components)
+        @logger = components.logger
+        @settings = components.settings
+        @agent_host = components.agent_settings.hostname
+        @agent_ssl = components.agent_settings.ssl
+      end
+
+      def configure_metrics_sdk
+        provider = ::OpenTelemetry.meter_provider
+        provider.shutdown if provider.is_a?(::OpenTelemetry::SDK::Metrics::MeterProvider)
+
+        # The OpenTelemetry SDK defaults to cumulative temporality, but Datadog prefers delta temporality.
+        # Here is an example of how this config is applied: https://github.com/open-telemetry/opentelemetry-ruby/blob/1933d4c18e5f5e45c53fa9e902e58aa91e85cc38/metrics_sdk/lib/opentelemetry/sdk/metrics/aggregation/sum.rb#L14
+        if DATADOG_ENV['OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'].nil?
+          ENV['OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'] = 'delta' # rubocop:disable CustomCops/EnvUsageCop
+        end
+
+        resource = create_resource
+        provider = ::OpenTelemetry::SDK::Metrics::MeterProvider.new(resource: resource)
+        configure_metric_reader(provider)
+        ::OpenTelemetry.meter_provider = provider
+      end
+
+      private
+
+      def configure_metric_reader(provider)
+        exporter_name = @settings.opentelemetry.metrics.exporter
+        return if exporter_name == Ext::EXPORTER_NONE
+
+        configure_otlp_exporter(provider)
+      rescue => e
+        @logger.warn("Failed to configure OTLP metrics exporter:  #{e.class}: #{e.message}")
+      end
+
+      def default_metrics_endpoint
+        "#{@agent_ssl ? "https" : "http"}://#{@agent_host}:4318/v1/metrics"
+      end
+
+      def configure_otlp_exporter(provider)
+        require 'opentelemetry/exporter/otlp_metrics'
+        require_relative 'sdk/metrics_exporter'
+
+        metrics_config = @settings.opentelemetry.metrics
+        endpoint = config_or_exporter_fallback(
+          signal: :metrics,
+          option_name: :endpoint,
+          computed_default: default_metrics_endpoint
+        )
+        timeout = config_or_exporter_fallback(signal: :metrics, option_name: :timeout_millis)
+        headers = config_or_exporter_fallback(signal: :metrics, option_name: :headers)
+        # OpenTelemetry SDK only supports http/protobuf protocol.
+        # TODO: Add support for http/json and grpc.
+        # protocol = config_or_exporter_fallback(signal: :metrics, option_name: :protocol)
+        exporter = Datadog::OpenTelemetry::SDK::MetricsExporter.new(
+          endpoint: endpoint,
+          timeout: timeout / 1000.0,
+          headers: headers
+        )
+
+        reader = ::OpenTelemetry::SDK::Metrics::Export::PeriodicMetricReader.new(
+          exporter: exporter,
+          export_interval_millis: metrics_config.export_interval_millis,
+          export_timeout_millis: metrics_config.export_timeout_millis
+        )
+        provider.add_metric_reader(reader)
+      rescue LoadError => e
+        @logger.warn("Could not load OTLP metrics exporter:  #{e.class}: #{e.message}")
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/sdk/configurator.rb

@@ -19,7 +19,7 @@ module Datadog
         # Ensure Datadog-configure propagation styles have are applied when configured.
         #
         # DEV: Support configuring propagation through the environment variable
-        # DEV: `OTEL_PROPAGATORS`, similar to `DD_TRACE_PROPAGATION*`?
+        # DEV: `OTEL_PROPAGATORS`, alias to `DD_TRACE_PROPAGATION_STYLE`
         def configure_propagation
           @propagators = [Propagator.new(Tracing::Contrib::HTTP)]
           super
@@ -30,7 +30,71 @@ module Datadog
           [SpanProcessor.new]
         end
 
-        ::OpenTelemetry::SDK::Configurator.prepend(self)
+        # SDK 1.6.0+ calls logs_configuration_hook from configure.
+        # https://github.com/open-telemetry/opentelemetry-ruby/blob/opentelemetry-sdk/v1.6.0/sdk/lib/opentelemetry/sdk/configurator.rb#L152
+        # Older supported SDK versions do not, so we call it explicitly as a fallback.
+        # The flag prevents double-calling on newer SDK versions.
+        def configure
+          @datadog_logs_hook_called = false
+          super
+          logs_configuration_hook unless @datadog_logs_hook_called
+        end
+
+        def metrics_configuration_hook
+          components = Datadog.send(:components)
+          return super unless components.settings.opentelemetry.metrics.enabled
+
+          begin
+            require 'opentelemetry-metrics-sdk'
+          rescue LoadError => exc
+            components.logger.warn("Failed to load OpenTelemetry metrics gems: #{exc.class}: #{exc.message}")
+            return super
+          end
+
+          success = Datadog::OpenTelemetry::Metrics.initialize!(components)
+          super unless success
+        end
+
+        def logs_configuration_hook
+          @datadog_logs_hook_called = true
+          components = Datadog.send(:components)
+          unless components.settings.opentelemetry.logs.enabled
+            super if defined?(super)
+            return
+          end
+
+          begin
+            require 'opentelemetry-logs-sdk'
+          rescue LoadError => exc
+            components.logger.warn("Failed to load OpenTelemetry logs gems: #{exc.class}: #{exc.message}")
+            return
+          end
+
+          success = Datadog::OpenTelemetry::Logs.initialize!(components)
+          unless success
+            components.logger.warn('Falling back to OpenTelemetry default logs configuration')
+            super if defined?(super)
+          end
+        end
+
+        # Prepend to ConfiguratorPatch (not Configurator) so our hook runs first.
+        begin
+          require 'opentelemetry-metrics-sdk' if defined?(OpenTelemetry::SDK) && !defined?(OpenTelemetry::SDK::Metrics::ConfiguratorPatch)
+        rescue LoadError
+        end
+
+        begin
+          require 'opentelemetry-logs-sdk' if defined?(OpenTelemetry::SDK) && !defined?(OpenTelemetry::SDK::Logs::ConfiguratorPatch)
+        rescue LoadError
+        end
+
+        if defined?(::OpenTelemetry::SDK::Metrics::ConfiguratorPatch)
+          ::OpenTelemetry::SDK::Metrics::ConfiguratorPatch.prepend(self) unless ::OpenTelemetry::SDK::Metrics::ConfiguratorPatch.ancestors.include?(self)
+        end
+        if defined?(::OpenTelemetry::SDK::Logs::ConfiguratorPatch)
+          ::OpenTelemetry::SDK::Logs::ConfiguratorPatch.prepend(self) unless ::OpenTelemetry::SDK::Logs::ConfiguratorPatch.ancestors.include?(self)
+        end
+        ::OpenTelemetry::SDK::Configurator.prepend(self) unless ::OpenTelemetry::SDK::Configurator.ancestors.include?(self)
       end
     end
   end

data/lib/datadog/opentelemetry/sdk/id_generator.rb

@@ -1,23 +1,29 @@
 # frozen_string_literal: true
 
+require_relative '../../tracing/utils'
+
 module Datadog
   module OpenTelemetry
     module SDK
-      # Generates Datadog-compatible IDs for OpenTelemetry traces.
-      # OpenTelemetry traces already produce Datadog-compatible IDs.
+      # Generates Datadog-compatible trace IDs for OpenTelemetry spans.
+      #
+      # Reuses the same 128-bit ID format as non-OTel Datadog tracing:
+      #   [32-bit seconds since Epoch | 32 zero bits | 64 random bits]
+      #
+      # When DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED is false the high 64
+      # bits are zero, preserving the OTel 16-byte wire format while keeping
+      # backward compatibility with 64-bit Datadog trace IDs.
       class IdGenerator
         class << self
           include ::OpenTelemetry::Trace
 
-          # Generates a valid trace identifier, a 16-byte string with at least one
-          # non-zero byte.
-          #
-          # @return [String] a valid trace ID.
+          # @return [String] a valid 16-byte trace ID.
           def generate_trace_id
-            loop do
-              id = Random.bytes(8) # DEV: Change to 16 (16*8-byte) when 128-bit trace_id is supported.
-              return id unless id == ::OpenTelemetry::Trace::INVALID_SPAN_ID
-            end
+            trace_id = Tracing::Utils::TraceId.next_id
+            [
+              Tracing::Utils::TraceId.to_high_order(trace_id),
+              Tracing::Utils::TraceId.to_low_order(trace_id),
+            ].pack('Q>Q>')
           end
         end
       end

data/lib/datadog/opentelemetry/sdk/logs_exporter.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'opentelemetry/exporter/otlp_logs'
+require_relative '../sdk'
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      class LogsExporter < ::OpenTelemetry::Exporter::OTLP::Logs::LogsExporter
+        METRIC_EXPORT_ATTEMPTS = 'otel.logs_export_attempts'
+        METRIC_EXPORT_SUCCESSES = 'otel.logs_export_successes'
+        METRIC_EXPORT_FAILURES = 'otel.logs_export_failures'
+        METRIC_LOG_RECORDS = 'otel.log_records'
+
+        def export(log_records, timeout: nil)
+          SDK.telemetry_inc(METRIC_EXPORT_ATTEMPTS, 1)
+          SDK.telemetry_inc(METRIC_LOG_RECORDS, log_records.size)
+          result = super
+          metric_name = (result == 0) ? METRIC_EXPORT_SUCCESSES : METRIC_EXPORT_FAILURES
+          SDK.telemetry_inc(metric_name, 1)
+          result
+        rescue => e
+          Datadog.logger.warn("Failed to export OpenTelemetry Logs: #{e.class}: #{e.message}")
+          SDK.telemetry_inc(METRIC_EXPORT_FAILURES, 1)
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/sdk/metrics_exporter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'opentelemetry/exporter/otlp_metrics'
+require_relative '../sdk'
+
+module Datadog
+  module OpenTelemetry
+    module SDK
+      class MetricsExporter < ::OpenTelemetry::Exporter::OTLP::Metrics::MetricsExporter
+        METRIC_EXPORT_ATTEMPTS = 'otel.metrics_export_attempts'
+        METRIC_EXPORT_SUCCESSES = 'otel.metrics_export_successes'
+        METRIC_EXPORT_FAILURES = 'otel.metrics_export_failures'
+
+        def export(metrics, timeout: nil)
+          SDK.telemetry_inc(METRIC_EXPORT_ATTEMPTS, 1)
+          result = super
+          metric_name = (result == 0) ? METRIC_EXPORT_SUCCESSES : METRIC_EXPORT_FAILURES
+          SDK.telemetry_inc(metric_name, 1)
+          result
+        rescue => e
+          Datadog.logger.error("Failed to export OpenTelemetry Metrics:  #{e.class}: #{e.message}")
+          SDK.telemetry_inc(METRIC_EXPORT_FAILURES, 1)
+          raise
+        end
+      end
+    end
+  end
+end