datadog 2.32.0 → 2.34.0

data/lib/datadog/di/utils.rb

@@ -82,15 +82,31 @@ module Datadog
       # we just strip leading directory components from the "probe path"
       # until we get a match via a "suffix of the suffix".
 
+      # Returns +path+ with Windows-style backslash separators translated to
+      # forward slashes (DEBUG-5111). Used to normalize probe source paths
+      # that originate from IDE tooling running on Windows.
+      module_function def normalize_windows_separators(path)
+        path.tr('\\', '/')
+      end
+
       # Returns whether the provided +path+ matches the user-designated
       # file suffix (of a line probe).
       #
-      # If suffix is an absolute path (i.e., it starts with a slash), the path
-      # must be identical for it to match.
+      # Backslash separators in +suffix+ are translated to forward slashes
+      # (DEBUG-5111) so paths typed by IDE tooling on Windows can match.
+      # Case-insensitive matching (DEBUG-5107) is opt-in via
+      # +case_insensitive: true+; callers that orchestrate matching against a
+      # set of known paths perform case-sensitive comparisons first and only
+      # fall back to case-insensitive when no case-sensitive match is found
+      # (see the design comment above, steps 5-8).
+      #
+      # If suffix is an absolute path (i.e., it starts with a slash, possibly
+      # after backslash normalization), the path must be identical for it to
+      # match.
       #
       # If suffix is not an absolute path, the path matches if its suffix is
       # the provided suffix, at a path component boundary.
-      module_function def path_matches_suffix?(path, suffix)
+      module_function def path_matches_suffix?(path, suffix, case_insensitive: false)
         if path.nil?
           raise ArgumentError, "nil path passed"
         end
@@ -98,6 +114,12 @@ module Datadog
           raise ArgumentError, "nil suffix passed"
         end
 
+        suffix = normalize_windows_separators(suffix)
+        if case_insensitive
+          path = path.downcase
+          suffix = suffix.downcase
+        end
+
         if suffix.start_with?('/')
           path == suffix
         else
@@ -105,11 +127,6 @@ module Datadog
           # has to be longer than the suffix. Require full component matches,
           # meaning either the first character of the suffix is a slash
           # or the previous character in the path is a slash.
-          # For now only check for forward slashes for Unix-like OSes;
-          # backslash is a legitimate character of a file name in Unix
-          # therefore simply permitting forward or back slash is not
-          # sufficient, we need to perform an OS check to know which
-          # path separator to use.
           !!
           if path.length > suffix.length && path.end_with?(suffix)
             previous_char = path[path.length - suffix.length - 1]
@@ -125,15 +142,26 @@ module Datadog
       # +spec+. Attempts all of the fuzzy matches by stripping directories
       # from the front of +spec+. Does not consider othr known paths to
       # identify the case of (potentially) multiple matching paths for +spec+.
+      #
+      # Matching is attempted case-sensitively first (steps 5-6 in the design
+      # comment above) and only falls back to case-insensitive (steps 7-8)
+      # when no case-sensitive match is found.
       module_function def path_can_match_spec?(path, spec)
-        return true if path_matches_suffix?(path, spec)
+        # Normalize Windows-style backslash separators (DEBUG-5111) so the
+        # suffix-shortening loop's "/+" regex can strip leading components.
+        spec = normalize_windows_separators(spec)
 
-        spec = spec.dup
-        loop do
-          return false unless spec.include?('/')
-          spec.sub!(%r{.*/+}, '')
-          return true if path_matches_suffix?(path, spec)
+        [false, true].each do |case_insensitive|
+          working_spec = spec.dup
+          return true if path_matches_suffix?(path, working_spec, case_insensitive: case_insensitive)
+
+          loop do
+            break unless working_spec.include?('/')
+            working_spec.sub!(%r{.*/+}, '')
+            return true if path_matches_suffix?(path, working_spec, case_insensitive: case_insensitive)
+          end
         end
+        false
       end
     end
   end

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

@@ -152,6 +152,71 @@ module Datadog
                   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

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

@@ -1,17 +1,19 @@
 # frozen_string_literal: true
 
 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.message}: #{exc.backtrace.join("\n")}")
+        components.logger.warn("Failed to initialize OpenTelemetry metrics: #{exc.class}: #{exc.message}: #{exc.backtrace.join("\n")}")
         false
       end
 
@@ -40,30 +42,9 @@ 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
@@ -79,15 +60,16 @@ module Datadog
         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,
@@ -103,15 +85,6 @@ module Datadog
       rescue LoadError => e
         @logger.warn("Could not load OTLP metrics exporter:  #{e.class}: #{e.message}")
       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
-      end
     end
   end
 end

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

@@ -30,6 +30,16 @@ 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
@@ -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)
         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,37 @@
+# frozen_string_literal: true
+
+require 'opentelemetry/exporter/otlp_logs'
+
+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'
+        TELEMETRY_NAMESPACE = 'tracers'
+        TELEMETRY_TAGS = {'protocol' => 'http', 'encoding' => 'protobuf'}.freeze
+
+        def export(log_records, timeout: nil)
+          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_ATTEMPTS, 1, tags: TELEMETRY_TAGS)
+          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_LOG_RECORDS, log_records.size, tags: TELEMETRY_TAGS)
+          result = super
+          metric_name = (result == 0) ? METRIC_EXPORT_SUCCESSES : METRIC_EXPORT_FAILURES
+          telemetry&.inc(TELEMETRY_NAMESPACE, metric_name, 1, tags: TELEMETRY_TAGS)
+          result
+        rescue => e
+          Datadog.logger.warn("Failed to export OpenTelemetry Logs: #{e.class}: #{e.message}")
+          telemetry&.inc(TELEMETRY_NAMESPACE, METRIC_EXPORT_FAILURES, 1, tags: TELEMETRY_TAGS)
+          raise
+        end
+
+        private
+
+        def telemetry
+          Datadog.send(:components).telemetry
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/signal_configuration.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative '../core/configuration/ext'
+require_relative '../core/environment/socket'
+
+module Datadog
+  module OpenTelemetry
+    # Shared resource building and signal-specific config fallback logic for Logs and Metrics.
+    module SignalConfiguration
+      private
+
+      def create_resource
+        resource_attributes = {}
+
+        @settings.tags&.each do |key, value| # steep:ignore
+          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 # steep:ignore
+        resource_attributes['deployment.environment'] = @settings.env if @settings.env # steep:ignore
+        resource_attributes['service.version'] = @settings.version if @settings.version # steep:ignore
+
+        hostname = Datadog::Core::Environment::Socket.resolved_hostname(@settings) # steep:ignore
+        if hostname
+          if hostname == @settings.hostname # steep:ignore
+            resource_attributes['host.name'] = hostname
+          elsif !resource_attributes.key?('host.name')
+            resource_attributes['host.name'] = hostname
+          end
+        end
+
+        ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+      end
+
+      # Returns the signal-specific option value when explicitly set,
+      # otherwise falls back to the general OTLP exporter config or computed_default.
+      def config_or_exporter_fallback(signal:, option_name:, computed_default: nil)
+        signal_settings = @settings.opentelemetry.public_send(signal) # steep:ignore
+        if signal_settings.using_default?(option_name)
+          @settings.opentelemetry.exporter.public_send(option_name) || computed_default # steep:ignore
+        else
+          signal_settings.public_send(option_name)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry.rb

@@ -23,6 +23,7 @@ require_relative 'opentelemetry/sdk/configurator' if defined?(OpenTelemetry::SDK
 require_relative 'opentelemetry/sdk/trace/span' if defined?(OpenTelemetry::SDK)
 
 require_relative 'opentelemetry/metrics' if defined?(OpenTelemetry::SDK::Metrics)
+require_relative 'opentelemetry/logs' if defined?(OpenTelemetry::SDK::Logs)
 
 module Datadog
   # Datadog OpenTelemetry integration.

data/lib/datadog/profiling/component.rb

@@ -49,7 +49,6 @@ module Datadog
           valid_cpu_sampling_interval(settings.profiling.advanced.experimental_cpu_sampling_interval_ms, logger)
 
         recorder = Datadog::Profiling::StackRecorder.new(
-          cpu_time_enabled: RUBY_PLATFORM.include?("linux"), # Only supported on Linux currently
           alloc_samples_enabled: allocation_profiling_enabled,
           heap_samples_enabled: heap_profiling_enabled,
           heap_size_enabled: heap_size_profiling_enabled,

data/lib/datadog/profiling/stack_recorder.rb

@@ -9,7 +9,6 @@ module Datadog
     # Methods prefixed with _native_ are implemented in `stack_recorder.c`
     class StackRecorder
       def initialize(
-        cpu_time_enabled:,
         alloc_samples_enabled:,
         heap_samples_enabled:,
         heap_size_enabled:,
@@ -27,7 +26,6 @@ module Datadog
 
         self.class._native_initialize(
           self_instance: self,
-          cpu_time_enabled: cpu_time_enabled,
           alloc_samples_enabled: alloc_samples_enabled,
           heap_samples_enabled: heap_samples_enabled,
           heap_size_enabled: heap_size_enabled,
@@ -38,7 +36,6 @@ module Datadog
       end
 
       def self.for_testing(
-        cpu_time_enabled: true,
         alloc_samples_enabled: false,
         heap_samples_enabled: false,
         heap_size_enabled: false,
@@ -48,7 +45,6 @@ module Datadog
         **options
       )
         new(
-          cpu_time_enabled: cpu_time_enabled,
           alloc_samples_enabled: alloc_samples_enabled,
           heap_samples_enabled: heap_samples_enabled,
           heap_size_enabled: heap_size_enabled,