datadog 2.33.0 → 2.34.0

data/lib/datadog/core/utils/spawn_monkey_patch.rb

@@ -3,32 +3,62 @@
 module Datadog
   module Core
     module Utils
+      # Applies the Process.spawn wrapper used to merge additional environment variables
+      # into child processes.
       module SpawnMonkeyPatch
-        # @param lineage_envs_provider [#call] returns a Hash of env vars to merge into the child process
-        def self.apply!(lineage_envs_provider:)
-          @lineage_envs_provider = lineage_envs_provider
+        # @param env_provider [#call] returns a Hash of env vars to merge into the child process
+        def self.apply!(env_provider:)
+          @env_provider = env_provider
+
+          # Idempotent: tests, reloads, or repeated Components init must not stack prepends.
+          return if ::Process.singleton_class.ancestors.include?(ProcessSpawnPatch)
+
           ::Process.singleton_class.prepend(ProcessSpawnPatch)
-          true
         end
 
+        # Prepends `Process.spawn` to merge `env_provider` output into the child's environment hash.
         module ProcessSpawnPatch
-          def spawn(*args, **opts)
-            args.replace(SpawnMonkeyPatch.inject_lineage_envs(args))
-            super
+          # The One and Only Correct Delegation Pattern
+          if RUBY_VERSION >= '3'
+            def spawn(*args, **kwargs) # steep:ignore DifferentMethodParameterKind
+              super(*SpawnMonkeyPatch.inject_envs(args), **kwargs)
+            end
+          else
+            def spawn(*args)
+              super(*SpawnMonkeyPatch.inject_envs(args))
+            end
+            ruby2_keywords :spawn if respond_to?(:ruby2_keywords, true)
           end
         end
 
-        # Process.spawn(env?, cmd, ...): env is optional first arg (Hash). When present, merge
-        # runtime_ids into it; when absent, prepend full ENV + runtime_ids so the child inherits both.
-        def self.inject_lineage_envs(args)
-          runtime_ids = @lineage_envs_provider.call
-          env_provided = Hash === args.first
+        # Merge the env vars from `env_provider` with the optional env `Hash` from {Process.spawn}.
+        #
+        # `env` is the first argument when it is a {Hash}; see MRI `spawn([env, ] *args, options)`:
+        # https://docs.ruby-lang.org/en/master/Process.html#method-c-spawn
+        #
+        # When there is **no** leading env Hash, MRI inherits the parent's `ENV`; we prepend only the
+        # `env_provider` hash so spawned children see parent env plus injections.
+        #
+        # When callers pass `unsetenv_others: true`, MRI only forwards the explicitly passed env Hash;
+        # replacing a missing hash with DATADOG_ENV.to_h would wrongly carry over parent variables.
+        # Prepending only the provider hash preserves `unsetenv_others` semantics.
+        #
+        # See https://docs.ruby-lang.org/en/master/Process.html#module-Process-label-Environment+Variables+-28-3Aunsetenv_others-29
+        #
+        # NOTE: `::Hash` (not bare `Hash`) is required because this module is nested under
+        # `Datadog::Core::Utils`, and `Datadog::Core::Utils::Hash` exists.
+        # Bare `Hash` resolves to that module via Module.nesting, making `Hash === some_hash`
+        # silently return `false`. See https://github.com/DataDog/dd-trace-rb/issues/5621.
+        def self.inject_envs(args)
+          provided_env = @env_provider.call
 
-          base_env = env_provided ? args.first : DATADOG_ENV.to_h
-          env = base_env.merge(runtime_ids)
-          rest = env_provided ? args.drop(1) : args
+          if ::Hash === args.first
+            args[0] = args.first.merge(provided_env)
+          else
+            args.unshift(provided_env)
+          end
 
-          [env, *rest]
+          args
         end
       end
     end

data/lib/datadog/data_streams/pathway_context.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'stringio'
-require_relative '../core/utils/base64'
+require_relative '../core/utils/base64_codec'
 
 module Datadog
   module DataStreams
@@ -34,7 +34,7 @@ module Datadog
       end
 
       def encode_b64
-        Core::Utils::Base64.strict_encode64(encode)
+        Core::Utils::Base64Codec.strict_encode64(encode)
       end
 
       # Decode pathway context from base64 encoded string
@@ -42,7 +42,7 @@ module Datadog
         return nil unless encoded_ctx && !encoded_ctx.empty?
 
         begin
-          binary_data = Core::Utils::Base64.strict_decode64(encoded_ctx)
+          binary_data = Core::Utils::Base64Codec.strict_decode64(encoded_ctx)
           decode(binary_data)
         rescue ArgumentError => e
           # Invalid base64 encoding - may indicate version mismatch or corruption

data/lib/datadog/di/code_tracker.rb

@@ -249,23 +249,34 @@ module Datadog
           exact = registry[suffix]
           return [suffix, exact] if exact
 
-          suffix = suffix.dup
-          loop do
-            inexact = []
-            registry.each do |path, iseq|
-              if Utils.path_matches_suffix?(path, suffix)
-                inexact << [path, iseq]
+          # Normalize Windows-style backslash separators (DEBUG-5111) upfront
+          # so the suffix-shortening loop's "/+" regex can strip leading
+          # components on probes whose sourceFile uses backslashes.
+          suffix = Utils.normalize_windows_separators(suffix)
+
+          # Per the design comment in utils.rb, attempt case-sensitive
+          # matching first (steps 5-6) and only fall back to case-insensitive
+          # matching (steps 7-8) when no case-sensitive match is found.
+          [false, true].each do |case_insensitive|
+            working_suffix = suffix.dup
+            loop do
+              inexact = []
+              registry.each do |path, iseq|
+                if Utils.path_matches_suffix?(path, working_suffix, case_insensitive: case_insensitive)
+                  inexact << [path, iseq]
+                end
               end
+              if inexact.length > 1
+                raise Error::MultiplePathsMatch, "Multiple paths matched requested suffix"
+              end
+              if inexact.any?
+                return inexact.first
+              end
+              break unless working_suffix.include?('/')
+              working_suffix.sub!(%r{.*/+}, '')
             end
-            if inexact.length > 1
-              raise Error::MultiplePathsMatch, "Multiple paths matched requested suffix"
-            end
-            if inexact.any?
-              return inexact.first
-            end
-            return nil unless suffix.include?('/')
-            suffix.sub!(%r{.*/+}, '')
           end
+          nil
         end
       end
 
@@ -365,15 +376,25 @@ module Datadog
         # Exact match.
         return suffix if paths.include?(suffix)
 
-        # Suffix match.
-        suffix = suffix.dup
-        loop do
-          matches = paths.select { |p| Utils.path_matches_suffix?(p, suffix) }
-          raise Error::MultiplePathsMatch, "Multiple paths matched requested suffix" if matches.length > 1
-          return matches.first if matches.any?
-          return nil unless suffix.include?('/')
-          suffix.sub!(%r{.*/+}, '')
+        # Normalize Windows-style backslash separators (DEBUG-5111) upfront
+        # so the suffix-shortening loop's "/+" regex can strip leading
+        # components on probes whose sourceFile uses backslashes.
+        suffix = Utils.normalize_windows_separators(suffix)
+
+        # Suffix match. Per the design comment in utils.rb, attempt
+        # case-sensitive matching first (steps 5-6) and only fall back to
+        # case-insensitive (steps 7-8) when no case-sensitive match is found.
+        [false, true].each do |case_insensitive|
+          working_suffix = suffix.dup
+          loop do
+            matches = paths.select { |p| Utils.path_matches_suffix?(p, working_suffix, case_insensitive: case_insensitive) }
+            raise Error::MultiplePathsMatch, "Multiple paths matched requested suffix" if matches.length > 1
+            return matches.first if matches.any?
+            break unless working_suffix.include?('/')
+            working_suffix.sub!(%r{.*/+}, '')
+          end
         end
+        nil
       end
     end
   end

data/lib/datadog/di/contrib/active_record.rb

@@ -23,7 +23,11 @@ Datadog::DI::Serializer.register(
   #
   # +depth+ is the remaining depth for serializing collections and objects.
   # It should always be an integer.
-  # Reduce it by 1 when invoking +serialize_value+ on the contents of +value+.
+  # Pass it through to +serialize_value+ when the structure you produce
+  # represents +value+ directly (a transparent wrapper); +serialize_value+
+  # decrements depth itself when it recurses into Array/Hash/object entries.
+  # Decrement +depth+ only if your wrapper introduces real additional
+  # nesting levels in the output.
   # This serializer could also potentially do its own depth limiting.
   #
   # Steep: steep thinks all of the arguments are nil here
@@ -33,5 +37,5 @@ Datadog::DI::Serializer.register(
     attributes: value.attributes,
     new_record: value.new_record?,
   }
-  serializer.serialize_value(value_to_serialize, depth: depth - 1, type: value.class)
+  serializer.serialize_value(value_to_serialize, depth: depth, type: value.class)
 end

data/lib/datadog/di/instrumenter.rb

@@ -106,7 +106,7 @@ module Datadog
         serializer = self.serializer
         method_name = probe.method_name
         loc = begin
-          cls.instance_method(method_name).source_location
+          cls.instance_method(method_name).source_location # steep:ignore ArgumentTypeMismatch
         rescue NameError
           # The target method is not defined.
           # This could be because it will be explicitly defined later
@@ -618,12 +618,32 @@ module Datadog
       def raise_if_probe_in_loaded_features(probe, line_no, code_tracker)
         return unless probe.file
 
-        # Find the loaded path matching the probe file.
+        # Find the loaded path matching the probe file. Case-sensitive
+        # matching is attempted first, with case-insensitive matching as a
+        # fallback (see the design comment in utils.rb, steps 5-8). Leading
+        # directory components are stripped so probes whose sourceFile carries
+        # a source-repo prefix that does not exist on disk still resolve to
+        # the loaded file — matching the behavior of
+        # CodeTracker#iseqs_for_path_suffix.
         loaded_path = if $LOADED_FEATURES.include?(probe.file)
           probe.file
         else
           # Expensive suffix check.
-          $LOADED_FEATURES.find { |path| Utils.path_matches_suffix?(path, probe.file) }
+          suffix = Utils.normalize_windows_separators(probe.file)
+          found = nil #: ::String?
+          [false, true].each do |case_insensitive|
+            working_suffix = suffix.dup
+            loop do
+              found = $LOADED_FEATURES.find do |path|
+                Utils.path_matches_suffix?(path, working_suffix, case_insensitive: case_insensitive)
+              end
+              break if found
+              break unless working_suffix.include?('/')
+              working_suffix.sub!(%r{.*/+}, '')
+            end
+            break if found
+          end
+          found
         end
 
         return unless loaded_path
@@ -648,7 +668,7 @@ module Datadog
 
       # TODO test that this resolves qualified names e.g. A::B
       def symbolize_class_name(cls_name)
-        Object.const_get(cls_name)
+        Object.const_get(cls_name) # steep:ignore ArgumentTypeMismatch
       rescue NameError => exc
         raise Error::DITargetNotDefined, "Class not defined: #{cls_name}: #{exc.class}: #{exc.message}"
       end

data/lib/datadog/di/probe_notification_builder.rb

@@ -369,7 +369,7 @@ module Datadog
         rescue => exc
           evaluation_errors << {
             message: "#{exc.class}: #{exc.message}",
-            expr: segment.dsl_expr,
+            expr: segment.dsl_expr, # steep:ignore NoMethod
           }
           '[evaluation error]'
         end.join

data/lib/datadog/di/remote.rb

@@ -42,14 +42,14 @@ module Datadog
               changes.each do |change|
                 case change.type
                 when :insert
-                  add_probe(change.content, component)
+                  add_probe(change.content, component) # steep:ignore NoMethod
                 when :update
                   # We do not implement updates at the moment, remove the
                   # probe and reinstall.
-                  remove_probe(change.content, component)
-                  add_probe(change.content, component)
+                  remove_probe(change.content, component) # steep:ignore NoMethod
+                  add_probe(change.content, component) # steep:ignore NoMethod
                 when :delete
-                  remove_probe(change.previous, component)
+                  remove_probe(change.previous, component) # steep:ignore NoMethod
                 else
                   # This really should never happen since we generate the
                   # change types in the library.

data/lib/datadog/di/serializer.rb

@@ -255,7 +255,7 @@ module Datadog
 
             serialized.update(value: value)
           when Array
-            if depth < 0
+            if depth <= 0
               serialized.update(notCapturedReason: "depth")
             else
               max = settings.dynamic_instrumentation.max_capture_collection_size
@@ -271,7 +271,7 @@ module Datadog
               serialized.update(elements: entries)
             end
           when Hash
-            if depth < 0
+            if depth <= 0
               serialized.update(notCapturedReason: "depth")
             else
               max = settings.dynamic_instrumentation.max_capture_collection_size
@@ -288,7 +288,7 @@ module Datadog
               serialized.update(entries: entries)
             end
           else
-            if depth < 0
+            if depth <= 0
               serialized.update(notCapturedReason: "depth")
             else
               fields = {}
@@ -369,7 +369,7 @@ module Datadog
         when String
           serialize_string_or_symbol_for_message(value)
         when Symbol
-          ':' + serialize_string_or_symbol_for_message(value)
+          ':' + serialize_string_or_symbol_for_message(value) # steep:ignore ArgumentTypeMismatch
         when Array
           return '...' if depth <= 0
 
@@ -482,7 +482,7 @@ module Datadog
             if max % 2 == 0
               upper += 1
             end
-            value[0...max / 2 - 1] + '...' + value[upper...length]
+            value[0...max / 2 - 1] + '...' + value[upper...length] # steep:ignore NoMethod
           end
         else
           value

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