datadog 2.28.0 → 2.41.0

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

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
-require_relative '../core/configuration/ext'
+require_relative "../core/configuration/ext"
+require_relative "ext"
+require_relative "signal_configuration"
 
 module Datadog
   module OpenTelemetry
     class Metrics
-      EXPORTER_NONE = 'none'
+      include SignalConfiguration
 
       def self.initialize!(components)
         new(components).configure_metrics_sdk
         true
       rescue => exc
-        components.logger.error("Failed to initialize OpenTelemetry metrics: #{exc.class}: #{exc}: #{exc.backtrace.join("\n")}")
+        components.logger.warn("Failed to initialize OpenTelemetry metrics: #{exc.class}: #{exc.message}: #{exc.backtrace.join("\n")}")
         false
       end
 
@@ -28,8 +30,8 @@ module Datadog
 
         # 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
+        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
@@ -40,34 +42,13 @@ module Datadog
 
       private
 
-      def create_resource
-        resource_attributes = {}
-        resource_attributes['host.name'] = Datadog::Core::Environment::Socket.hostname if @settings.tracing.report_hostname
-
-        @settings.tags&.each do |key, value|
-          otel_key = case key
-          when 'service' then 'service.name'
-          when 'env' then 'deployment.environment'
-          when 'version' then 'service.version'
-          else key
-          end
-          resource_attributes[otel_key] = value
-        end
-
-        resource_attributes['service.name'] = @settings.service_without_fallback || resource_attributes['service.name'] || Datadog::Core::Environment::Ext::FALLBACK_SERVICE_NAME
-        resource_attributes['deployment.environment'] = @settings.env if @settings.env
-        resource_attributes['service.version'] = @settings.version if @settings.version
-
-        ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
-      end
-
       def configure_metric_reader(provider)
         exporter_name = @settings.opentelemetry.metrics.exporter
-        return if exporter_name == EXPORTER_NONE
+        return if exporter_name == Ext::EXPORTER_NONE
 
         configure_otlp_exporter(provider)
       rescue => e
-        @logger.warn("Failed to configure OTLP metrics exporter:  #{e.class}: #{e}")
+        @logger.warn("Failed to configure OTLP metrics exporter:  #{e.class}: #{e.message}")
       end
 
       def default_metrics_endpoint
@@ -75,19 +56,20 @@ module Datadog
       end
 
       def configure_otlp_exporter(provider)
-        require 'opentelemetry/exporter/otlp_metrics'
-        require_relative 'sdk/metrics_exporter'
+        require "opentelemetry/exporter/otlp_metrics"
+        require_relative "sdk/metrics_exporter"
 
         metrics_config = @settings.opentelemetry.metrics
-        endpoint = get_metrics_config_with_fallback(
+        endpoint = config_or_exporter_fallback(
+          signal: :metrics,
           option_name: :endpoint,
           computed_default: default_metrics_endpoint
         )
-        timeout = get_metrics_config_with_fallback(option_name: :timeout_millis)
-        headers = get_metrics_config_with_fallback(option_name: :headers)
+        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 = get_metrics_config_with_fallback(option_name: :protocol)
+        # protocol = config_or_exporter_fallback(signal: :metrics, option_name: :protocol)
         exporter = Datadog::OpenTelemetry::SDK::MetricsExporter.new(
           endpoint: endpoint,
           timeout: timeout / 1000.0,
@@ -101,16 +83,7 @@ module Datadog
         )
         provider.add_metric_reader(reader)
       rescue LoadError => e
-        @logger.warn("Could not load OTLP metrics exporter:  #{e.class}: #{e}")
-      end
-
-      # Returns metrics config value if explicitly set, otherwise falls back to exporter config or computed default value.
-      def get_metrics_config_with_fallback(option_name:, computed_default: nil)
-        if @settings.opentelemetry.metrics.using_default?(option_name)
-          @settings.opentelemetry.exporter.public_send(option_name) || computed_default
-        else
-          @settings.opentelemetry.metrics.public_send(option_name)
-        end
+        @logger.warn("Could not load OTLP metrics exporter:  #{e.class}: #{e.message}")
       end
     end
   end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative 'span_processor'
-require_relative 'id_generator'
-require_relative 'propagator'
+require_relative "span_processor"
+require_relative "id_generator"
+require_relative "propagator"
 
 module Datadog
   module OpenTelemetry
@@ -30,14 +30,24 @@ module Datadog
           [SpanProcessor.new]
         end
 
+        # 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'
+            require "opentelemetry-metrics-sdk"
           rescue LoadError => exc
-            components.logger.warn("Failed to load OpenTelemetry metrics gems: #{exc.class}: #{exc}")
+            components.logger.warn("Failed to load OpenTelemetry metrics gems: #{exc.class}: #{exc.message}")
             return super
           end
 
@@ -45,15 +55,45 @@ module Datadog
           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)
+          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

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

@@ -1,34 +1,27 @@
 # frozen_string_literal: true
 
-require 'opentelemetry/exporter/otlp_metrics'
+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'
-        TELEMETRY_NAMESPACE = 'tracers'
-        TELEMETRY_TAGS = {'protocol' => "http", 'encoding' => 'protobuf'}
+        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)
-          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_ATTEMPTS, 1, tags: TELEMETRY_TAGS)
+          SDK.telemetry_inc(METRIC_EXPORT_ATTEMPTS, 1)
           result = super
           metric_name = (result == 0) ? METRIC_EXPORT_SUCCESSES : METRIC_EXPORT_FAILURES
-          telemetry&.inc(TELEMETRY_NAMESPACE, metric_name, 1, tags: TELEMETRY_TAGS)
+          SDK.telemetry_inc(metric_name, 1)
           result
         rescue => e
-          Datadog.logger.error("Failed to export OpenTelemetry Metrics:  #{e.class}: #{e}")
-          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_FAILURES, 1, tags: TELEMETRY_TAGS)
+          Datadog.logger.error("Failed to export OpenTelemetry Metrics:  #{e.class}: #{e.message}")
+          SDK.telemetry_inc(METRIC_EXPORT_FAILURES, 1)
           raise
         end
-
-        private
-
-        def telemetry
-          Datadog.send(:components).telemetry
-        end
       end
     end
   end

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

@@ -17,9 +17,9 @@ module Datadog
           unless setter == ::OpenTelemetry::Context::Propagation.text_map_setter
             # PENDING: Not to report telemetry logs for now
             Datadog.logger.error(
-              'Custom setter is not supported. Please inform the `datadog` team at ' \
-            ' https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default ' \
-            'OpenTelemetry::Context::Propagation.text_map_setter as a fallback setter.'
+              "Custom setter is not supported. Please inform the `datadog` team at " \
+            " https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default " \
+            "OpenTelemetry::Context::Propagation.text_map_setter as a fallback setter."
             )
           end
 
@@ -35,19 +35,28 @@ module Datadog
             # PENDING: Not to report telemetry logs for now
             Datadog.logger.error(
               "Custom getter #{getter} is not supported. Please inform the `datadog` team at " \
-            ' https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default ' \
-            'OpenTelemetry::Context::Propagation.text_map_getter as a fallback getter.'
+            " https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default " \
+            "OpenTelemetry::Context::Propagation.text_map_getter as a fallback getter."
             )
           end
 
           digest = @datadog_propagator.extract(carrier)
           return context unless digest
 
+          # Always call continue_trace! so span links are created in restart mode
+          # (when digest.trace_id is nil) before we attempt to build the OTel SpanContext.
+          trace = Tracing.continue_trace!(digest)
+
+          # In restart mode DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT=restart, the extracted
+          # digest carries no trace_id (fresh start). continue_trace! has already recorded
+          # the span link; return the current context so the caller's span starts a new root.
+          return context unless digest.trace_id
+
           # Converts the {Numeric} Datadog id object to OpenTelemetry's byte array format.
           # 128-bit unsigned, big-endian integer
-          trace_id = [digest.trace_id >> 64, digest.trace_id & 0xFFFFFFFFFFFFFFFF].pack('Q>Q>')
+          trace_id = [digest.trace_id >> 64, digest.trace_id & 0xFFFFFFFFFFFFFFFF].pack("Q>Q>")
           # 64-bit unsigned, big-endian integer
-          span_id = [digest.span_id].pack('Q>')
+          span_id = [digest.span_id].pack("Q>")
 
           if digest.trace_state || digest.trace_flags
             trace_flags = ::OpenTelemetry::Trace::TraceFlags.from_byte(digest.trace_flags)
@@ -70,9 +79,6 @@ module Datadog
           )
 
           span = ::OpenTelemetry::Trace.non_recording_span(span_context)
-
-          trace = Tracing.continue_trace!(digest)
-
           span.datadog_trace = trace
 
           ::OpenTelemetry::Trace.context_with_span(span, parent_context: context)

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

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-require_relative 'trace/span'
-require_relative '../../tracing/span_link'
-require_relative '../../tracing/span_event'
-require_relative '../../tracing/trace_digest'
+require_relative "trace/span"
+require_relative "../../core/utils"
+require_relative "../../tracing/span_link"
+require_relative "../../tracing/span_event"
+require_relative "../../tracing/trace_digest"
 
 module Datadog
   module OpenTelemetry
@@ -101,12 +102,14 @@ module Datadog
 
           unless span.links.nil?
             datadog_span.links = span.links.map do |link|
+              tracestate = link.span_context.tracestate&.to_s
+
               Datadog::Tracing::SpanLink.new(
                 Datadog::Tracing::TraceDigest.new(
                   trace_id: link.span_context.hex_trace_id.to_i(16),
                   span_id: link.span_context.hex_span_id.to_i(16),
                   trace_sampling_priority: (link.span_context.trace_flags&.sampled? ? 1 : 0),
-                  trace_state: link.span_context.tracestate&.to_s,
+                  trace_state: tracestate && ::Datadog::Core::Utils.utf8_encode(tracestate, placeholder: nil),
                   span_remote: link.span_context.remote?,
                 ),
                 attributes: link.attributes
@@ -119,29 +122,29 @@ module Datadog
 
         # Some special attributes can override Datadog Span fields
         def span_arguments(span, attributes)
-          if attributes.key?('analytics.event') && (analytics_event = attributes['analytics.event']).respond_to?(:casecmp)
-            attributes[Tracing::Metadata::Ext::Analytics::TAG_SAMPLE_RATE] = (analytics_event.casecmp('true') == 0) ? 1 : 0
+          if attributes.key?("analytics.event") && (analytics_event = attributes["analytics.event"]).respond_to?(:casecmp)
+            attributes[Tracing::Metadata::Ext::Analytics::TAG_SAMPLE_RATE] = (analytics_event.casecmp("true") == 0) ? 1 : 0
           end
 
-          if attributes.key?('http.response.status_code')
-            attributes[Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE] = attributes.delete('http.response.status_code')
+          if attributes.key?("http.response.status_code")
+            attributes[Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE] = attributes.delete("http.response.status_code")
           end
 
-          attributes[Tracing::Metadata::Ext::TAG_KIND] = span.kind || 'internal'
+          attributes[Tracing::Metadata::Ext::TAG_KIND] = span.kind || "internal"
 
           kwargs = {start_time: ns_to_time(span.start_timestamp)}
 
-          name = if attributes.key?('operation.name')
-            attributes['operation.name']
+          name = if attributes.key?("operation.name")
+            attributes["operation.name"]
           elsif (rich_name = Datadog::OpenTelemetry::Trace::Span.enrich_name(span.kind, attributes))
             rich_name.downcase
           else
             span.kind
           end
 
-          kwargs[:resource] = attributes.key?('resource.name') ? attributes['resource.name'] : span.name
-          kwargs[:service] = attributes['service.name'] if attributes.key?('service.name')
-          kwargs[:type] = attributes['span.type'] if attributes.key?('span.type')
+          kwargs[:resource] = attributes.key?("resource.name") ? attributes["resource.name"] : span.name
+          kwargs[:service] = attributes["service.name"] if attributes.key?("service.name")
+          kwargs[:type] = attributes["span.type"] if attributes.key?("span.type")
 
           attributes.reject! { |key, _| OpenTelemetry::Trace::Span::DATADOG_SPAN_ATTRIBUTE_OVERRIDES.include?(key) }