datadog 2.39.0 → 2.40.0

data/ext/libdatadog_api/trace_exporter.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include "datadog_ruby_common.h"
+
+void trace_exporter_init(VALUE tracing_module);

data/lib/datadog/ai_guard/evaluation.rb

@@ -15,6 +15,7 @@ module Datadog
               Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER,
               Tracing::Sampling::Ext::Decision::AI_GUARD
             )
+            trace.set_distributed_source(Ext::PRODUCT_BIT)
             trace.set_tag(Ext::EVENT_TAG, true)
             trace.set_tag(Ext::TRACE_EXECUTED_TAG, "1")
 

data/lib/datadog/ai_guard/ext.rb

@@ -4,6 +4,8 @@ module Datadog
   module AIGuard
     # AI Guard specific constants
     module Ext
+      PRODUCT_BIT = 0x20
+
       SPAN_NAME = "ai_guard"
       TARGET_TAG = "ai_guard.target"
       TOOL_NAME_TAG = "ai_guard.tool_name"

data/lib/datadog/appsec/configuration.rb

@@ -52,6 +52,15 @@ module Datadog
                 o.default false
               end
 
+              # NOTE: Marker set by the agentic onboarding tooling.
+              #       Has no effect here — we just report its value in telemetry,
+              #       so onboarding can be detected at runtime
+              option :agentic_onboarding do |o|
+                o.type :string
+                o.env "DD_APPSEC_AGENTIC_ONBOARDING"
+                o.default ""
+              end
+
               define_method(:instrument) do |integration_name|
                 if enabled
                   registered_integration = Datadog::AppSec::Contrib::Integration.registry[integration_name]

data/lib/datadog/appsec/contrib/devise/patcher.rb

@@ -20,7 +20,7 @@ module Datadog
           module_function
 
           def patched?
-            Patcher.instance_variable_get(:@patched)
+            !!Patcher.instance_variable_get(:@patched)
           end
 
           def target_version

data/lib/datadog/appsec/contrib/rack/patcher.rb

@@ -12,7 +12,7 @@ module Datadog
           module_function
 
           def patched?
-            Patcher.instance_variable_get(:@patched) # TODO: Patcher.flag_patched
+            !!Patcher.instance_variable_get(:@patched) # TODO: Patcher.flag_patched
           end
 
           def target_version

data/lib/datadog/appsec/contrib/rack/request_body_middleware.rb

@@ -12,7 +12,8 @@ module Datadog
         # This should be inserted just below Rack::JSONBodyParser or
         # legacy Rack::PostBodyContentTypeParser from rack-contrib
         class RequestBodyMiddleware
-          def initialize(app, opt = {})
+          # TODO: opt is never used, it can probably be safely removed
+          def initialize(app, opt = {}) # steep:ignore DifferentMethodParameterKind
             @app = app
           end
 
@@ -23,7 +24,7 @@ module Datadog
 
             # TODO: handle exceptions, except for @app.call
 
-            http_response = nil
+            http_response = nil #: Rack::response?
             interrupt_params = catch(::Datadog::AppSec::Ext::INTERRUPT) do
               http_response, _request = Instrumentation.gateway.push("rack.request.body", Gateway::Request.new(env)) do
                 @app.call(env)
@@ -34,7 +35,9 @@ module Datadog
 
             return AppSec::Response.from_interrupt_params(interrupt_params, env["HTTP_ACCEPT"]).to_rack if interrupt_params
 
-            http_response
+            # Steep can't see that the catch block always populates http_response
+            # when no interrupt is thrown.
+            http_response #: Rack::response
           end
         end
       end

data/lib/datadog/appsec/contrib/rails/request_middleware.rb

@@ -6,7 +6,8 @@ module Datadog
       module Rails
         # Rack middleware for AppSec on Rails
         class RequestMiddleware
-          def initialize(app, opt = {})
+          # TODO: opt is never used, it can probably be safely removed
+          def initialize(app, opt = {}) # steep:ignore DifferentMethodParameterKind
             @app = app
           end
 

data/lib/datadog/appsec/contrib/sinatra/request_middleware.rb

@@ -6,7 +6,8 @@ module Datadog
       module Sinatra
         # Rack middleware for AppSec on Sinatra
         class RequestMiddleware
-          def initialize(app, opt = {})
+          # TODO: opt is never used, it can probably be safely removed
+          def initialize(app, opt = {}) # steep:ignore DifferentMethodParameterKind
             @app = app
           end
 

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

@@ -644,6 +644,13 @@ module Datadog
               o.env "DD_PROFILING_EXPERIMENTAL_USE_SYSTEM_DNS"
               o.default true
             end
+
+            # Whether the profiler samples include the class/module name in stack frames, like `Foo::Bar#baz`, or not (`baz`)
+            option :experimental_show_classes_enabled do |o|
+              o.type :bool
+              o.env "DD_PROFILING_EXPERIMENTAL_SHOW_CLASSES_ENABLED"
+              o.default false
+            end
           end
 
           # @public_api
@@ -792,55 +799,40 @@ module Datadog
           end
         end
 
-        # The time provider used by Datadog. It must respect the interface of [Time](https://ruby-doc.org/core-3.0.1/Time.html).
-        #
-        # When testing, it can be helpful to use a different time provider.
-        #
-        # For [Timecop](https://rubygems.org/gems/timecop), for example, `->{ Time.now_without_mock_time }`
-        # allows Datadog features to use the real wall time when time is frozen.
-        #
-        # @default `->{ Time.now }`
-        # @return [Proc<Time>]
+        # Deprecated and no longer does anything.
+        # This gem already takes care to not be affected by timecop.
+        # DEV-3.0: Remove `time_now_provider` option
         option :time_now_provider do |o|
-          o.default_proc { ::Time.now }
+          o.default_proc { Datadog::Core::Utils::Time.now }
           o.type :proc
-
-          o.after_set do |time_provider|
-            Core::Utils::Time.now_provider = time_provider
-          end
-
-          o.resetter do |_value|
-            # TODO: Resetter needs access to the default value
-            # TODO: to help reduce duplication.
-            -> { ::Time.now }.tap do |default|
-              Core::Utils::Time.now_provider = default
+          o.after_set do |_, _, precedence|
+            unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+              unless defined?(Datadog::CI) # the datadog-ci gem needs to work with any datadog gem version and not warn
+                Core.log_deprecation(key: :time_now_provider) do
+                  "The time_now_provider setting has been deprecated for removal " \
+                    "and no longer does anything. Please remove it from your Datadog.configure block. " \
+                    "The datadog gem always uses the real non-mocked time, even when the timecop gem monkey-patches Time."
+                end
+              end
             end
           end
         end
 
-        # The monotonic clock time provider used by Datadog. This option is internal and is used by `datadog-ci`
-        # gem to avoid traces' durations being skewed by timecop.
-        #
-        # It must respect the interface of [Datadog::Core::Utils::Time#get_time] method.
-        #
-        # For [Timecop](https://rubygems.org/gems/timecop), for example,
-        # `->(unit = :float_second) { ::Process.clock_gettime_without_mock(Datadog::Core::Utils::Time::MONOTONIC_CLOCK_ID, unit) }`
-        # allows Datadog features to use the real monotonic time when time is frozen with
-        # `Timecop.mock_process_clock = true`.
-        #
-        # @default `->(unit = :float_second) { ::Process.clock_gettime(Core::Utils::Time::MONOTONIC_CLOCK_ID, unit) }`
-        # @return [Proc<Numeric>]
+        # Deprecated and no longer does anything.
+        # This gem already takes care to not be affected by timecop.
+        # DEV-3.0: Remove `get_time_provider` option
         option :get_time_provider do |o|
-          o.default_proc { |unit = :float_second| ::Process.clock_gettime(Core::Utils::Time::MONOTONIC_CLOCK_ID, unit) }
+          o.default_proc { |unit = :float_second| Datadog::Core::Utils::Time.get_time(unit) }
           o.type :proc
-
-          o.after_set do |get_time_provider|
-            Core::Utils::Time.get_time_provider = get_time_provider
-          end
-
-          o.resetter do |_value|
-            ->(unit = :float_second) { ::Process.clock_gettime(Core::Utils::Time::MONOTONIC_CLOCK_ID, unit) }.tap do |default|
-              Core::Utils::Time.get_time_provider = default
+          o.after_set do |_, _, precedence|
+            unless precedence == Datadog::Core::Configuration::Option::Precedence::DEFAULT
+              unless defined?(Datadog::CI) # the datadog-ci gem needs to work with any datadog gem version and not warn
+                Core.log_deprecation(key: :get_time_provider) do
+                  "The get_time_provider setting has been deprecated for removal " \
+                    "and no longer does anything. Please remove it from your Datadog.configure block. " \
+                    "The datadog gem always uses the real non-mocked time, even when the timecop gem monkey-patches Process.clock_gettime."
+                end
+              end
             end
           end
         end

data/lib/datadog/core/configuration/supported_configurations.rb

@@ -24,6 +24,7 @@ module Datadog
           "DD_API_SECURITY_REQUEST_SAMPLE_RATE",
           "DD_API_SECURITY_SAMPLE_DELAY",
           "DD_APM_TRACING_ENABLED",
+          "DD_APPSEC_AGENTIC_ONBOARDING",
           "DD_APPSEC_AUTOMATED_USER_EVENTS_TRACKING",
           "DD_APPSEC_AUTO_USER_INSTRUMENTATION_MODE",
           "DD_APPSEC_BODY_PARSING_SIZE_LIMIT",
@@ -60,6 +61,7 @@ module Datadog
           "DD_ERROR_TRACKING_HANDLED_ERRORS_INCLUDE",
           "DD_EXPERIMENTAL_FLAGGING_PROVIDER_ENABLED",
           "DD_EXPERIMENTAL_FLAGGING_PROVIDER_SPAN_ENRICHMENT_ENABLED",
+          "DD_EXPERIMENTAL_NATIVE_TRANSPORT_ENABLED",
           "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED",
           "DD_EXTERNAL_ENV",
           "DD_FLAGGING_EVALUATION_COUNTS_ENABLED",
@@ -85,6 +87,7 @@ module Datadog
           "DD_PROFILING_EXPERIMENTAL_HEAP_ENABLED",
           "DD_PROFILING_EXPERIMENTAL_HEAP_SAMPLE_RATE",
           "DD_PROFILING_EXPERIMENTAL_HEAP_SIZE_ENABLED",
+          "DD_PROFILING_EXPERIMENTAL_SHOW_CLASSES_ENABLED",
           "DD_PROFILING_EXPERIMENTAL_USE_SYSTEM_DNS",
           "DD_PROFILING_GC_ENABLED",
           "DD_PROFILING_GVL_ENABLED",

data/lib/datadog/core/environment/gc.rb

@@ -12,7 +12,7 @@ module Datadog
         end
 
         def available?
-          defined?(::GC) && ::GC.respond_to?(:stat)
+          !!(defined?(::GC) && ::GC.respond_to?(:stat))
         end
       end
     end

data/lib/datadog/core/environment/vm_cache.rb

@@ -56,7 +56,7 @@ module Datadog
         end
 
         def available?
-          defined?(::RubyVM) && ::RubyVM.respond_to?(:stat)
+          !!(defined?(::RubyVM) && ::RubyVM.respond_to?(:stat))
         end
       end
     end

data/lib/datadog/core/environment/yjit.rb

@@ -59,9 +59,9 @@ module Datadog
         end
 
         def available?
-          defined?(::RubyVM::YJIT) \
+          !!(defined?(::RubyVM::YJIT) \
             && ::RubyVM::YJIT.enabled? \
-            && ::RubyVM::YJIT.respond_to?(:runtime_stats)
+            && ::RubyVM::YJIT.respond_to?(:runtime_stats))
         end
       end
     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/utils/at_fork_monkey_patch.rb

@@ -6,6 +6,12 @@ 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_BEFORE_BLOCKS = [] # rubocop:disable Style/MutableConstant -- Used to store blocks to run, mutable by design.
+        private_constant :AT_FORK_BEFORE_BLOCKS
+
+        AT_FORK_PARENT_BLOCKS = [] # rubocop:disable Style/MutableConstant -- Used to store blocks to run, mutable by design.
+        private_constant :AT_FORK_PARENT_BLOCKS
+
         AT_FORK_CHILD_BLOCKS = [] # rubocop:disable Style/MutableConstant -- Used to store blocks to run, mutable by design.
         private_constant :AT_FORK_CHILD_BLOCKS
 
@@ -32,19 +38,41 @@ module Datadog
         end
 
         def self.run_at_fork_blocks(stage)
-          raise(ArgumentError, "Unsupported stage #{stage}") unless stage == :child
-
-          AT_FORK_CHILD_BLOCKS.each(&:call)
+          blocks_for(stage).each(&:call)
         end
 
+        # 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
+          blocks_for(stage) << block
 
-          true
+          block
+        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)
+          blocks_for(stage).delete(block)
+
+          nil
+        end
+
+        def self.blocks_for(stage)
+          case stage
+          when :before then AT_FORK_BEFORE_BLOCKS
+          when :parent then AT_FORK_PARENT_BLOCKS
+          when :child then AT_FORK_CHILD_BLOCKS
+          else raise(ArgumentError, "Unsupported stage #{stage}")
+          end
         end
+        private_class_method :blocks_for
 
         # Adds `at_fork` behavior; see parent module for details.
         module KernelMonkeyPatch
@@ -59,15 +87,29 @@ module Datadog
               end
             end
 
+            # Run pre-fork callbacks in the parent, just before forking.
+            AtForkMonkeyPatch.run_at_fork_blocks(:before)
+
             # Start fork
             # If a block is provided, use the wrapped version.
-            result = child_block.nil? ? super : super(&child_block)
+            begin
+              result = child_block.nil? ? super : super(&child_block)
+            rescue Exception # rubocop:disable Lint/RescueException -- re-raised unchanged; we only need to run parent cleanup first
+              # The fork failed and we are still in the parent; run `:parent` to
+              # restore any state the `:before` blocks set up, then re-raise.
+              AtForkMonkeyPatch.run_at_fork_blocks(:parent)
+              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)
+            else
+              AtForkMonkeyPatch.run_at_fork_blocks(:parent)
+            end
 
             result
           end
@@ -78,9 +120,24 @@ 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
+            AtForkMonkeyPatch.run_at_fork_blocks(:before)
+
+            begin
+              pid = super
+            rescue Exception # rubocop:disable Lint/RescueException -- re-raised unchanged; we only need to run parent cleanup first
+              # The fork failed, so no child was created and we are still in the
+              # parent. The `:before` blocks already ran (and may hold resources,
+              # e.g. a locked mutex); run the `:parent` blocks so that state is
+              # restored, then re-raise.
+              AtForkMonkeyPatch.run_at_fork_blocks(:parent)
+              raise
+            end
 
-            AtForkMonkeyPatch.run_at_fork_blocks(:child) if pid == 0
+            if pid == 0
+              AtForkMonkeyPatch.run_at_fork_blocks(:child)
+            else
+              AtForkMonkeyPatch.run_at_fork_blocks(:parent)
+            end
 
             pid
           end
@@ -89,8 +146,19 @@ 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
+            AtForkMonkeyPatch.run_at_fork_blocks(:before)
+
+            begin
+              result = super
+            rescue Exception # rubocop:disable Lint/RescueException -- re-raised unchanged; we only need to run parent cleanup first
+              # `daemon` failed, so the original process survives; run `:parent`
+              # to restore state the `:before` blocks set up, then re-raise.
+              AtForkMonkeyPatch.run_at_fork_blocks(:parent)
+              raise
+            end
 
+            # `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)
 
             result

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