datadog 2.39.0 → 2.47.0

data/lib/datadog/core/telemetry/configuration_value.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Telemetry
+      module ConfigurationValue
+        module_function
+
+        def convert(value)
+          case value
+          when Integer, String, true, false, nil
+            value
+          when Float
+            value.finite? ? value : value.to_s
+          when Hash
+            value.map { |key, entry_value| "#{key}:#{entry_value}" }.join(",")
+          when Array
+            value.join(",")
+          when Module
+            value.name.to_s
+          else
+            implements_to_s = begin
+              value.method(:to_s).owner != Kernel
+            rescue NameError
+              false
+            end
+
+            if implements_to_s
+              value.to_s
+            else
+              value.class.to_s
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/telemetry/event/app_client_configuration_change.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base"
+require_relative "../configuration_value"
 
 module Datadog
   module Core
@@ -27,10 +28,11 @@ module Datadog
           def configuration
             config = Datadog.configuration
 
+            # @type var res: Array[telemetry_configuration]
             res = @changes.map do |name, value|
               {
                 name: name,
-                value: value,
+                value: Telemetry::ConfigurationValue.convert(value),
                 origin: @origin,
                 seq_id: Configuration::Option::Precedence::REMOTE_CONFIGURATION.numeric.next,
               }

data/lib/datadog/core/telemetry/event/app_endpoints_loaded.rb

@@ -20,7 +20,7 @@ module Datadog
           def payload
             {
               is_first: @is_first,
-              endpoints: @endpoints
+              endpoints: @endpoints,
             }
           end
         end

data/lib/datadog/core/telemetry/event/app_started.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "base"
+require_relative "../configuration_value"
 
 module Datadog
   module Core
@@ -65,7 +66,7 @@ module Datadog
                 # actually enabled by env var or by implicit enablement via
                 # remote config.
                 enabled: components.dynamic_instrumentation&.started? || false,
-              }
+              },
             }
 
             if (unsupported_reason = Datadog::Profiling.unsupported_reason)
@@ -214,23 +215,9 @@ module Datadog
           end
 
           def to_telemetry_value(value)
-            # TODO: Add float if telemetry starts accepting it
-            case value
-            when Integer, String, true, false, nil
-              value
-            when Hash
-              value.map { |key, entry_value| "#{key}:#{entry_value}" }.join(",")
-            when Array
-              value.join(",")
-            when Module
-              value.name.to_s
-            else
-              if implements_to_s?(value)
-                value.to_s
-              else
-                value.class.to_s
-              end
-            end
+            return value.to_s if value.is_a?(Float)
+
+            Telemetry::ConfigurationValue.convert(value)
           end
 
           def install_signature(settings)
@@ -280,12 +267,6 @@ module Datadog
             parent_setting = settings.dig(*split_option)
             parent_setting.send(:resolve_option, option_name.to_sym)
           end
-
-          def implements_to_s?(value)
-            value.method(:to_s).owner != Kernel
-          rescue NameError
-            false
-          end
         end
       end
     end

data/lib/datadog/core/telemetry/event/generate_metrics.rb

@@ -23,7 +23,7 @@ module Datadog
           def payload
             {
               namespace: @namespace,
-              series: @metric_series.map(&:to_h)
+              series: @metric_series.map(&:to_h),
             }
           end
 

data/lib/datadog/core/telemetry/event/log.rb

@@ -52,8 +52,8 @@ module Datadog
                   level: @level,
                   stack_trace: @stack_trace,
                   count: @count,
-                }.compact
-              ]
+                }.compact,
+              ],
             }
           end
 

data/lib/datadog/core/telemetry/event/synth_app_client_configuration_change.rb

@@ -57,7 +57,7 @@ module Datadog
           end
 
           def reset?
-            defined?(@reset) && !!@reset
+            !!(defined?(@reset) && @reset)
           end
         end
       end

data/lib/datadog/core/telemetry/metric.rb

@@ -37,7 +37,7 @@ module Datadog
               points: values,
               type: type,
               tags: tags,
-              common: common
+              common: common,
             }
           end
 
@@ -179,7 +179,7 @@ module Datadog
               metric: name,
               points: values,
               tags: tags,
-              common: common
+              common: common,
             }
           end
         end

data/lib/datadog/core/telemetry/request.rb

@@ -50,7 +50,7 @@ module Datadog
               runtime_version: Core::Environment::Ext::ENGINE_VERSION,
               service_name: config.service,
               service_version: config.version,
-              tracer_version: tracer_version
+              tracer_version: tracer_version,
             }
 
             tag_process_tags!(app, config)
@@ -64,7 +64,7 @@ module Datadog
               hostname: Core::Environment::Platform.hostname,
               kernel_name: Core::Environment::Platform.kernel_name,
               kernel_release: Core::Environment::Platform.kernel_release,
-              kernel_version: Core::Environment::Platform.kernel_version
+              kernel_version: Core::Environment::Platform.kernel_version,
             }
           end
 

data/lib/datadog/core/transport/http.rb

@@ -61,7 +61,7 @@ module Datadog
             Core::Transport::Ext::HTTP::HEADER_META_LANG_INTERPRETER_VENDOR =>
               Core::Environment::Ext::LANG_ENGINE,
             Core::Transport::Ext::HTTP::HEADER_META_TRACER_VERSION =>
-              Datadog::Core::Environment::Ext::GEM_DATADOG_VERSION
+              Datadog::Core::Environment::Ext::GEM_DATADOG_VERSION,
           }.tap do |headers|
             # Add application container info
             headers.merge!(Core::Environment::Container.to_headers)

data/lib/datadog/core/transport/transport.rb

@@ -69,7 +69,7 @@ module Datadog
 
           @current_api_id = api_id
           client_class = self.class.http_client_class || Core::Transport::HTTP::Client
-          @client = client_class.new(current_api, logger: logger) # steep:ignore
+          @client = client_class.new(current_api, logger: logger)
         end
 
         def downgrade?(response)

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

@@ -6,8 +6,30 @@ module Datadog
       # Monkey patches `Kernel#fork` and similar functions, adding an `at_fork` callback mechanism which
       # is used to restart observability after the VM forks (e.g. in multiprocess Ruby apps).
       module AtForkMonkeyPatch
-        AT_FORK_CHILD_BLOCKS = [] # rubocop:disable Style/MutableConstant -- Used to store blocks to run, mutable by design.
-        private_constant :AT_FORK_CHILD_BLOCKS
+        class Callback
+          attr_reader :block, :group
+
+          def initialize(block, group = nil)
+            @block = block
+            @group = group
+            freeze
+          end
+        end
+        private_constant :Callback
+
+        EMPTY_AT_FORK_BLOCKS = {
+          before: [].freeze,
+          parent: [].freeze,
+          child: [].freeze,
+        }.freeze
+        private_constant :EMPTY_AT_FORK_BLOCKS
+
+        @at_fork_blocks = EMPTY_AT_FORK_BLOCKS
+
+        # Serializes copy-on-write registry updates. Fork dispatch only reads the
+        # latest immutable registry reference and never acquires this mutex.
+        AT_FORK_REGISTRY_MUTEX = Mutex.new
+        private_constant :AT_FORK_REGISTRY_MUTEX
 
         def self.supported?
           Process.respond_to?(:fork)
@@ -31,43 +53,147 @@ module Datadog
           true
         end
 
-        def self.run_at_fork_blocks(stage)
-          raise(ArgumentError, "Unsupported stage #{stage}") unless stage == :child
+        # Runs the callbacks copied for one fork lifecycle. Before callbacks
+        # stop at the first failure; parent and child callbacks all run before
+        # the first failure is re-raised.
+        def self.run_at_fork_blocks(stage, snapshot:, started: nil)
+          callbacks = blocks_for(snapshot, stage)
+          if stage == :before
+            return callbacks.each do |callback|
+              started[callback.group] = true if started && callback.group
+              callback.block.call
+            end
+          end
+
+          error = nil
+          callbacks.each do |callback|
+            next if started && callback.group && !started.key?(callback.group)
 
-          AT_FORK_CHILD_BLOCKS.each(&:call)
+            callback.block.call
+          rescue Exception => e # rubocop:disable Lint/RescueException -- finish cleanup, then re-raise the first failure
+            error ||= e
+          end
+          raise error if error
         end
 
+        def self.run_parent_cleanup(snapshot, started, fork_error)
+          run_at_fork_blocks(:parent, snapshot: snapshot, started: started)
+        rescue Exception => cleanup_error # rubocop:disable Lint/RescueException -- preserve the original fork failure
+          Datadog.logger.warn do
+            "Parent at-fork cleanup failed while handling #{fork_error.class}: " \
+              "#{cleanup_error.class}: #{cleanup_error.message}"
+          end
+        end
+        private_class_method :run_parent_cleanup
+
+        # Registers a block to run at the given fork +stage+ (+:before+,
+        # +:parent+, or +:child+).
+        #
+        # Returns the registered block so callers can keep a handle to it and
+        # later deregister it via {.remove_at_fork}.
         def self.at_fork(stage, &block)
-          raise(ArgumentError, "Unsupported stage #{stage}") unless stage == :child
           raise(ArgumentError, "Missing block argument") unless block
 
-          AT_FORK_CHILD_BLOCKS << block
+          AT_FORK_REGISTRY_MUTEX.synchronize do
+            current = @at_fork_blocks
+            @at_fork_blocks = current.merge(
+              stage => (blocks_for(current, stage) + [Callback.new(block)]).freeze
+            ).freeze
+          end
 
-          true
+          block
+        end
+
+        # Registers one before/parent/child callback triplet atomically relative
+        # to the snapshots taken by fork dispatch.
+        def self.at_fork_blocks(before:, parent:, child:)
+          blocks = {before: before, parent: parent, child: child}
+          group = Object.new.freeze
+          AT_FORK_REGISTRY_MUTEX.synchronize do
+            current = @at_fork_blocks
+            @at_fork_blocks = {
+              before: (current.fetch(:before) + [Callback.new(before, group)]).freeze,
+              parent: (current.fetch(:parent) + [Callback.new(parent, group)]).freeze,
+              child: (current.fetch(:child) + [Callback.new(child, group)]).freeze,
+            }.freeze
+          end
+          blocks
         end
 
+        # Deregisters a block previously registered with {.at_fork} for the given
+        # +stage+. It is a no-op (does not raise) when +block+ was never
+        # registered (or was already removed). Raises +ArgumentError+ for an
+        # unknown stage, matching the {.at_fork} contract.
+        def self.remove_at_fork(stage, block)
+          AT_FORK_REGISTRY_MUTEX.synchronize do
+            current = @at_fork_blocks
+            callbacks = blocks_for(current, stage)
+            @at_fork_blocks = current.merge(
+              stage => callbacks.reject { |callback| callback.block.equal?(block) }.freeze
+            ).freeze
+          end
+
+          nil
+        end
+
+        # Returns the immutable callback registry for one fork lifecycle.
+        # Copy-on-write updates publish a new reference, so registrations made
+        # afterwards apply only to the next lifecycle without locking this read.
+        def self.snapshot_at_fork_blocks
+          @at_fork_blocks
+        end
+
+        def self.replace_at_fork_blocks(snapshot)
+          AT_FORK_REGISTRY_MUTEX.synchronize { @at_fork_blocks = snapshot }
+        end
+        private_class_method :replace_at_fork_blocks
+
+        def self.blocks_for(snapshot, stage)
+          case stage
+          when :before, :parent, :child then snapshot.fetch(stage)
+          else raise(ArgumentError, "Unsupported stage #{stage}")
+          end
+        end
+        private_class_method :blocks_for
+
         # Adds `at_fork` behavior; see parent module for details.
         module KernelMonkeyPatch
           def fork
+            snapshot = AtForkMonkeyPatch.snapshot_at_fork_blocks
+            started = {}
+
             # If a block is provided, it must be wrapped to trigger callbacks.
             child_block = if block_given?
               proc do
-                AtForkMonkeyPatch.run_at_fork_blocks(:child)
+                AtForkMonkeyPatch.run_at_fork_blocks(:child, snapshot: snapshot)
 
                 # Invoke original block
                 yield
               end
             end
 
-            # Start fork
-            # If a block is provided, use the wrapped version.
-            result = child_block.nil? ? super : super(&child_block)
+            begin
+              # Run pre-fork callbacks in the parent, just before forking.
+              AtForkMonkeyPatch.run_at_fork_blocks(:before, snapshot: snapshot, started: started)
+
+              # Start fork. If a block is provided, use the wrapped version.
+              result = child_block.nil? ? super : super(&child_block)
+            rescue Exception => e # rubocop:disable Lint/RescueException -- re-raised unchanged; we only need to run parent cleanup first
+              # The fork or a before-fork callback failed and we are still in
+              # the parent. Restore any state set up by earlier callbacks.
+              AtForkMonkeyPatch.send(:run_parent_cleanup, snapshot, started, e)
+              raise
+            end
 
             # When fork gets called without a block, it returns twice:
             # If we're in the fork, result = nil: trigger child callbacks.
-            # If we're in the parent, result = pid: we do nothing.
+            # If we're in the parent, result = pid: trigger parent callbacks.
             # (If it gets called with a block, it only returns on the parent)
-            AtForkMonkeyPatch.run_at_fork_blocks(:child) if result.nil?
+            if result.nil?
+              AtForkMonkeyPatch.run_at_fork_blocks(:child, snapshot: snapshot)
+            else
+              AtForkMonkeyPatch.run_at_fork_blocks(:parent, snapshot: snapshot)
+            end
 
             result
           end
@@ -78,9 +204,23 @@ module Datadog
           # Hook provided by Ruby 3.1+ for observability libraries that want to know about fork, see
           # https://github.com/ruby/ruby/pull/5017 and https://bugs.ruby-lang.org/issues/17795
           def _fork
-            pid = super
+            snapshot = AtForkMonkeyPatch.snapshot_at_fork_blocks
+            started = {}
+            begin
+              AtForkMonkeyPatch.run_at_fork_blocks(:before, snapshot: snapshot, started: started)
+              pid = super
+            rescue Exception => e # rubocop:disable Lint/RescueException -- re-raised unchanged; we only need to run parent cleanup first
+              # The fork or a before-fork callback failed, so no child was
+              # created. Restore state set up by any earlier callbacks.
+              AtForkMonkeyPatch.send(:run_parent_cleanup, snapshot, started, e)
+              raise
+            end
 
-            AtForkMonkeyPatch.run_at_fork_blocks(:child) if pid == 0
+            if pid == 0
+              AtForkMonkeyPatch.run_at_fork_blocks(:child, snapshot: snapshot)
+            else
+              AtForkMonkeyPatch.run_at_fork_blocks(:parent, snapshot: snapshot)
+            end
 
             pid
           end
@@ -89,9 +229,21 @@ module Datadog
           # keeps executing code in the child process, killing off the parent, thus effectively replacing it.
           # This is not covered by `_fork` and thus we have some extra code for it.
           def daemon(*args)
-            result = super
+            snapshot = AtForkMonkeyPatch.snapshot_at_fork_blocks
+            started = {}
+            begin
+              AtForkMonkeyPatch.run_at_fork_blocks(:before, snapshot: snapshot, started: started)
+              result = super
+            rescue Exception => e # rubocop:disable Lint/RescueException -- re-raised unchanged; we only need to run parent cleanup first
+              # `daemon` or a before-fork callback failed, so the original
+              # process survives. Restore state set up by earlier callbacks.
+              AtForkMonkeyPatch.send(:run_parent_cleanup, snapshot, started, e)
+              raise
+            end
 
-            AtForkMonkeyPatch.run_at_fork_blocks(:child)
+            # `daemon` kills the parent, so there is no surviving parent to run
+            # `:parent` callbacks in; only the child continues executing.
+            AtForkMonkeyPatch.run_at_fork_blocks(:child, snapshot: snapshot)
 
             result
           end

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

@@ -5,18 +5,15 @@ module Datadog
     module Utils
       # Generates values from a consistent sequence
       class Sequence
-        def initialize(seed = 0, &block)
+        def initialize(seed = 0)
           @seed = seed
           @current = seed
-          @next_item = block
         end
 
         def next
-          # Steep: https://github.com/soutaro/steep/issues/477
-          # @type ivar @next_item: ^(::Integer) -> Integer
-          next_item = @next_item ? @next_item.call(@current) : @current
+          current = @current
           @current += 1
-          next_item
+          current
         end
 
         def reset!

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

@@ -5,7 +5,16 @@ 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,
@@ -13,71 +22,24 @@ module Datadog
         #
         # @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
-        MONOTONIC_CLOCK_ID = RUBY_PLATFORM.include?("darwin") ? Process::CLOCK_MONOTONIC_RAW : Process::CLOCK_MONOTONIC
-
-        def get_time(unit = :float_second)
-          Process.clock_gettime(MONOTONIC_CLOCK_ID, 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/workers/runtime_metrics.rb

@@ -32,7 +32,7 @@ module Datadog
           end
 
           # Workers::Async::Thread settings
-          self.fork_policy = options.fetch(:fork_policy, Workers::Async::Thread::FORK_POLICY_STOP)
+          self.fork_policy = options.fetch(:fork_policy, Workers::Async::Thread::FORK_POLICY_RESTART)
 
           # Workers::IntervalLoop settings
           self.loop_base_interval = options.fetch(:interval, DEFAULT_FLUSH_INTERVAL)

data/lib/datadog/data_streams/pathway_context.rb

@@ -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 << 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