datadog 2.30.0 → 2.45.0

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative "../../ruby_version"
+
+module Datadog
+  module Core
+    module Utils
+      # Applies the Process.spawn wrapper used to merge additional environment variables
+      # into child processes.
+      module SpawnMonkeyPatch
+        # @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)
+        end
+
+        # Prepends `Process.spawn` to merge `env_provider` output into the child's environment hash.
+        module ProcessSpawnPatch
+          # The One and Only Correct Delegation Pattern
+          if RubyVersion.is?(">= 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
+
+        # 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
+
+          if ::Hash === args.first
+            args[0] = args.first.merge(provided_env)
+          else
+            args.unshift(provided_env)
+          end
+
+          args
+        end
+      end
+    end
+  end
+end

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

@@ -5,75 +5,41 @@ module Datadog
     module Utils
       # Common database-related utility functions.
       module Time
-        module_function
+        # timecop monkey-patches Time.now, Process.clock_gettime, etc:
+        # https://github.com/travisjeffery/timecop/blob/v0.9.11/lib/timecop/time_extensions.rb
+        # It keeps the original methods as aliases.
+        # We want the real not-mocked time here, so we use those aliases to the original method if present.
+        # If not present we assume these methods have not been monkey-patched and are the original.
+
+        original_clock_gettime_name = Process.respond_to?(:clock_gettime_without_mock) ? :clock_gettime_without_mock : :clock_gettime
+        define_singleton_method(:original_clock_gettime, &Process.method(original_clock_gettime_name))
+
+        MONOTONIC_CLOCK_ID = RUBY_PLATFORM.include?("darwin") ? Process::CLOCK_MONOTONIC_RAW : Process::CLOCK_MONOTONIC
 
         # Current monotonic time
+        # On macOS, CLOCK_MONOTONIC only has microsecond precision,
+        # so we use CLOCK_MONOTONIC_RAW which has nanosecond precision instead.
         #
         # @param unit [Symbol] unit for the resulting value, same as ::Process#clock_gettime, defaults to :float_second
         # @return [Float|Integer] timestamp in the requested unit, since some unspecified starting point
-        def get_time(unit = :float_second)
-          Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
+        def self.get_time(unit = :float_second)
+          original_clock_gettime(MONOTONIC_CLOCK_ID, unit)
         end
 
         # Current wall time.
         #
         # @return [Time] current time object
-        def now
-          ::Time.now
-        end
-
-        # Overrides the implementation of `#now
-        # with the provided callable.
-        #
-        # Overriding the method `#now` instead of
-        # indirectly calling `block` removes
-        # one level of method call overhead.
-        #
-        # @param block [Proc] block that returns a `Time` object representing the current wall time
-        def now_provider=(block)
-          class << self
-            # Avoid method redefinition warning.
-            # `rescue nil` is added in case customers remove the method
-            # themselves to squelch the warning.
-            begin
-              remove_method(:now)
-            rescue
-              nil
-            end
-          end
-          define_singleton_method(:now, &block)
-        end
-
-        # Overrides the implementation of `#get_time
-        # with the provided callable.
-        #
-        # Overriding the method `#get_time` instead of
-        # indirectly calling `block` removes
-        # one level of method call overhead.
-        #
-        # @param block [Proc] block that accepts unit and returns timestamp in the requested unit
-        def get_time_provider=(block)
-          class << self
-            # Avoid method redefinition warning
-            # `rescue nil` is added in case customers remove the method
-            # themselves to squelch the warning.
-            begin
-              remove_method(:get_time)
-            rescue
-              nil
-            end
-          end
-          define_singleton_method(:get_time, &block)
-        end
+        original_time_now_name = ::Time.respond_to?(:now_without_mock_time) ? :now_without_mock_time : :now
+        define_singleton_method(:now, &::Time.method(original_time_now_name))
 
-        def measure(unit = :float_second)
+        def self.measure(unit = :float_second)
           before = get_time(unit)
           yield
           after = get_time(unit)
           after - before
         end
 
-        def as_utc_epoch_ns(time)
+        def self.as_utc_epoch_ns(time)
           # we use #to_r instead of #to_f because Float doesn't have enough precision to represent exact nanoseconds, see
           # https://rubyapi.org/3.0/o/time#method-i-to_f
           (time.to_r * 1_000_000_000).to_i

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'uri'
+require "uri"
 
 module Datadog
   module Core

data/lib/datadog/core/utils.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'utils/forking'
+require_relative "utils/forking"
 
 module Datadog
   module Core
@@ -9,7 +9,7 @@ module Datadog
     module Utils
       extend Forking
 
-      EMPTY_STRING = ''.encode(::Encoding::UTF_8).freeze
+      EMPTY_STRING = "".encode(::Encoding::UTF_8).freeze
 
       # Stringifies `value` and ensures the outcome is
       # string is no longer than `size`.
@@ -20,7 +20,7 @@ module Datadog
       # If `omission.size` is larger than `size`, the output
       # will still be `omission.size` in length.
       # @!visibility private
-      def self.truncate(value, size, omission = '...')
+      def self.truncate(value, size, omission = "...")
         string = value.to_s
 
         return string if string.size <= size
@@ -52,7 +52,7 @@ module Datadog
         if binary
           # This option is useful for "gracefully" displaying binary data that
           # often contains text such as marshalled objects
-          str.encode('UTF-8', 'binary', invalid: :replace, undef: :replace, replace: '')
+          str.encode("UTF-8", "binary", invalid: :replace, undef: :replace, replace: "")
         elsif str.encoding == ::Encoding::UTF_8
           str
         elsif str.empty?
@@ -63,7 +63,7 @@ module Datadog
           str.encode(::Encoding::UTF_8)
         end
       rescue => e
-        Datadog.logger.debug("Error encoding string in UTF-8: #{e}")
+        Datadog.logger.debug("Error encoding string in UTF-8: #{e.class}: #{e.message}")
 
         placeholder
       end

data/lib/datadog/core/workers/async.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../logger'
+require_relative "../logger"
 
 module Datadog
   module Core
@@ -168,7 +168,7 @@ module Datadog
             rescue Exception => e
               @error = e
               Datadog.logger.debug(
-                "Worker thread error. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+                "Worker thread error. Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
               )
               raise
 

data/lib/datadog/core/workers/polling.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'async'
-require_relative 'interval_loop'
+require_relative "async"
+require_relative "interval_loop"
 
 module Datadog
   module Core

data/lib/datadog/core/workers/runtime_metrics.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative '../runtime/metrics'
+require_relative "../runtime/metrics"
 
-require_relative '../worker'
-require_relative 'async'
-require_relative 'polling'
+require_relative "../worker"
+require_relative "async"
+require_relative "polling"
 
 module Datadog
   module Core

data/lib/datadog/core.rb

@@ -1,8 +1,11 @@
 # frozen_string_literal: true
 
-require_relative 'core/deprecations'
-require_relative 'core/configuration/config_helper'
-require_relative 'core/extensions'
+# Keep this at the top, this is needed at require-time by some files
+require_relative "ruby_version"
+
+require_relative "core/deprecations"
+require_relative "core/configuration/config_helper"
+require_relative "core/extensions"
 
 # We must load core extensions to make certain global APIs
 # accessible: both for Datadog features and the core itself.
@@ -18,11 +21,10 @@ module Datadog
         require "libdatadog_api.#{RUBY_VERSION[/\d+.\d+/]}_#{RUBY_PLATFORM}"
         nil
       rescue LoadError => e
-        e.message
+        "#{e.class}: #{e.message}"
       end
   end
 
-  DATADOG_ENV = Core::Configuration::ConfigHelper.new
   extend Core::Extensions
 
   # Add shutdown hook:

data/lib/datadog/data_streams/configuration.rb

@@ -1,11 +1,50 @@
 # frozen_string_literal: true
 
-require_relative 'configuration/settings'
+require_relative "../core/environment/variable_helpers"
+require_relative "ext"
 
 module Datadog
   module DataStreams
     # Configuration for Data Streams Monitoring
     module Configuration
+      # Configuration settings for Data Streams Monitoring.
+      module Settings
+        def self.extended(base)
+          base = base.singleton_class unless base.is_a?(Class)
+          add_settings!(base)
+        end
+
+        def self.add_settings!(base)
+          base.class_eval do
+            # Data Streams Monitoring configuration
+            # @public_api
+            settings :data_streams do
+              # Whether Data Streams Monitoring is enabled. When enabled, the library will
+              # collect and report data lineage information for messaging systems.
+              #
+              # @default `DD_DATA_STREAMS_ENABLED` environment variable, otherwise `false`.
+              # @return [Boolean]
+              option :enabled do |o|
+                o.type :bool
+                o.env Ext::ENV_ENABLED
+                o.default false
+              end
+
+              # The interval (in seconds) at which Data Streams Monitoring stats are flushed.
+              #
+              # @default 10.0
+              # @env '_DD_TRACE_STATS_WRITER_INTERVAL'
+              # @return [Float]
+              # @!visibility private
+              option :interval do |o|
+                o.type :float
+                o.env "_DD_TRACE_STATS_WRITER_INTERVAL"
+                o.default 10.0
+              end
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/datadog/data_streams/ext.rb

@@ -5,7 +5,7 @@ module Datadog
     # Constants for Data Streams Monitoring configuration
     # @public_api
     module Ext
-      ENV_ENABLED = 'DD_DATA_STREAMS_ENABLED'
+      ENV_ENABLED = "DD_DATA_STREAMS_ENABLED"
     end
   end
 end

data/lib/datadog/data_streams/extensions.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'configuration'
-require_relative '../core/configuration'
+require_relative "configuration"
+require_relative "../core/configuration"
 
 module Datadog
   module DataStreams

data/lib/datadog/data_streams/pathway_context.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'stringio'
-require_relative '../core/utils/base64'
+require "stringio"
+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,11 +42,11 @@ 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
-          Datadog.logger.debug("Failed to decode DSM pathway context: #{e.message}")
+          Datadog.logger.debug { "Failed to decode DSM pathway context: #{e.class}: #{e.message}" }
           nil
         end
       end
@@ -58,7 +58,7 @@ module Datadog
         # - 8 bytes: hash value (little-endian)
         # - VarInt: pathway start time (milliseconds)
         # - VarInt: current edge start time (milliseconds)
-        [@hash].pack('Q') <<
+        [@hash].pack("Q") <<
           encode_var_int_64(time_to_ms(@pathway_start)) <<
           encode_var_int_64(time_to_ms(@current_edge_start))
       end
@@ -73,7 +73,7 @@ module Datadog
         hash_bytes = reader.read(8)
         return nil unless hash_bytes
 
-        hash_value = hash_bytes.unpack1('Q') # : Integer
+        hash_value = hash_bytes.unpack1("Q") # : Integer
 
         # Extract pathway start time (VarInt milliseconds)
         pathway_start_ms = decode_varint(reader)
@@ -98,40 +98,38 @@ module Datadog
       end
       private_class_method :decode
 
-      # Encode an unsigned 64-bit integer using LEB128 variable-length encoding.
+      # Encode a signed 64-bit integer using ZigZag + LEB128 variable-length encoding.
       #
-      # This implements unsigned LEB128 (Little Endian Base 128) encoding as specified
-      # in DWARF5 standard section 7.6:
-      # https://dwarfstd.org/doc/DWARF5.pdf#page=301
+      # dd-trace-go's DSM pathway encoder (internal/datastreams/propagator.go, via
+      # sketches-go's ddsketch/encoding package) ZigZag-maps the signed value before
+      # applying plain unsigned LEB128 (DWARF5 section 7.6:
+      # https://dwarfstd.org/doc/DWARF5.pdf#page=301). This implementation previously
+      # skipped the ZigZag step, which silently decoded to the wrong timestamp on any
+      # dd-trace-go consumer -- see https://github.com/DataDog/dd-trace-go/issues/5163.
       #
-      # Each byte uses 7 bits for data and 1 bit to indicate continuation.
-      # The high bit is set if more bytes follow, clear for the final byte.
+      # ZigZag maps signed values to unsigned ones so small-magnitude negative numbers
+      # still encode to few bytes: 0, -1, 1, -2, 2, ... -> 0, 1, 2, 3, 4, ...
       #
-      # @param value [Integer] Unsigned integer value to encode
+      # @param value [Integer] Signed integer value to encode
       # @return [String] Binary string of encoded bytes
       def encode_var_int_64(value)
+        zigzag = (value << 1) ^ (value >> 63)
         bytes = []
-        while value >= 0x80
-          bytes << ((value & 0x7F) | 0x80)
-          value >>= 7
+        while zigzag >= 0x80
+          bytes << ((zigzag & 0x7F) | 0x80)
+          zigzag >>= 7
         end
-        bytes << value
-        bytes.pack('C*')
+        bytes << zigzag
+        bytes.pack("C*")
       end
 
-      # Decode an unsigned LEB128 variable-length integer from IO stream.
+      # Decode a signed 64-bit integer encoded with ZigZag + LEB128 from an IO stream.
       #
-      # This implements unsigned LEB128 (Little Endian Base 128) decoding as specified
-      # in DWARF5 standard section 7.6:
-      # https://dwarfstd.org/doc/DWARF5.pdf#page=301
-      #
-      # VarInt format: Each byte uses 7 bits for data, 1 bit for continuation
-      # - High bit set = more bytes follow
-      # - High bit clear = final byte
-      # - Data bits accumulated in little-endian order
+      # See #encode_var_int_64 for why the ZigZag un-map is required to match
+      # dd-trace-go's wire format.
       #
       # @param io [StringIO] IO stream to read from
-      # @return [Integer, nil] Decoded unsigned integer, or nil if malformed
+      # @return [Integer, nil] Decoded signed integer, or nil if malformed
       def self.decode_varint(io)
         value = 0
         shift = 0
@@ -143,7 +141,7 @@ module Datadog
           value |= (byte & 0x7F) << shift
 
           # If high bit is clear, we're done
-          return value unless (byte & 0x80).nonzero?
+          return (value >> 1) ^ -(value & 1) unless (byte & 0x80).nonzero?
 
           shift += 7