datadog 2.29.0 → 2.31.0

data/lib/datadog/tracing/trace_operation.rb

@@ -27,6 +27,8 @@ module Datadog
       include Metadata::Tagging
 
       DEFAULT_MAX_LENGTH = 100_000
+      AUTO_SAMPLING_PRIORITIES = [Sampling::Ext::Priority::AUTO_KEEP, Sampling::Ext::Priority::AUTO_REJECT].freeze
+      RECONSIDERABLE_DECISIONS = [Sampling::Ext::Decision::DEFAULT, Sampling::Ext::Decision::AGENT_RATE].freeze
 
       attr_accessor \
         :agent_sample_rate,
@@ -51,7 +53,6 @@ module Datadog
 
       attr_writer \
         :name,
-        :resource,
         :sampled,
         :service
 
@@ -127,6 +128,8 @@ module Datadog
         @finished = false
         @spans = []
         @auto_finish = !!auto_finish
+        @flushed = false
+        @propagated = false
       end
 
       def full?
@@ -170,6 +173,17 @@ module Datadog
         set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, Tracing::Sampling::Ext::Decision::MANUAL)
       end
 
+      def resource=(value)
+        previous_resource = @resource
+        @resource = value
+
+        return if !!previous_resource || value.nil?
+
+        events.trace_resource_change.publish(self)
+      rescue => e
+        logger.debug { "Error updating trace resource: #{e} Backtrace: #{e.backtrace.first(3)}" }
+      end
+
       def name
         @name || root_span&.name
       end
@@ -208,6 +222,12 @@ module Datadog
         !@resource.nil?
       end
 
+      def reconsider_resource_sample?
+        return false if @resource.nil?
+
+        reconsider_rule_sample?
+      end
+
       def service
         @service || root_span&.service
       end
@@ -274,15 +294,15 @@ module Datadog
         parent_id = parent ? parent.id : @parent_span_id || 0
 
         # Build events
-        events ||= SpanOperation::Events.new(logger: logger)
+        span_events = events || SpanOperation::Events.new(logger: logger)
 
         # Before start: activate the span, publish events.
-        events.before_start.subscribe do |span_op|
+        span_events.before_start.subscribe do |span_op|
           start_span(span_op)
         end
 
         # After finish: deactivate the span, record, publish events.
-        events.after_finish.subscribe do |span, span_op|
+        span_events.after_finish.subscribe do |span, span_op|
           finish_span(span, span_op, parent)
         end
 
@@ -290,7 +310,7 @@ module Datadog
         SpanOperation.new(
           op_name,
           logger: logger,
-          events: events,
+          events: span_events,
           on_error: on_error,
           parent_id: parent_id,
           resource: resource || op_name,
@@ -319,6 +339,7 @@ module Datadog
         # Copy out completed spans
         spans = @spans.dup
         @spans = []
+        @flushed = true
 
         spans = yield(spans) if block_given?
 
@@ -359,6 +380,7 @@ module Datadog
         span_id = @active_span&.id
         span_id ||= @parent_span_id unless finished?
         # sample the trace_operation with the tracer
+        @propagated = true
         events.trace_propagated.publish(self)
 
         TraceDigest.new(
@@ -430,13 +452,15 @@ module Datadog
           :span_before_start,
           :span_finished,
           :trace_finished,
-          :trace_propagated
+          :trace_propagated,
+          :trace_resource_change
 
         def initialize
           @span_before_start = SpanBeforeStart.new
           @span_finished = SpanFinished.new
           @trace_finished = TraceFinished.new
           @trace_propagated = TracePropagated.new
+          @trace_resource_change = TraceResourceChange.new
         end
 
         # Triggered before a span starts.
@@ -476,6 +500,14 @@ module Datadog
             subscribe(&block)
           end
         end
+
+        # Triggered when the resource name is set
+        # This is used to reconsider trace sampling on resource name change
+        class TraceResourceChange < Tracing::Event
+          def initialize
+            super(:trace_resource_change)
+          end
+        end
       end
 
       private
@@ -582,12 +614,24 @@ module Datadog
         meta.select { |name, _| name.start_with?(Metadata::Ext::Distributed::TAGS_PREFIX) }
       end
 
+      def reconsider_rule_sample?
+        decision = get_tag(Metadata::Ext::Distributed::TAG_DECISION_MAKER)
+
+        return false if remote_parent || @propagated || @flushed
+        return false unless AUTO_SAMPLING_PRIORITIES.include?(@sampling_priority)
+        return false if decision && !RECONSIDERABLE_DECISIONS.include?(decision)
+
+        true
+      end
+
       def reset
         @root_span = nil
         @active_span = nil
         @active_span_count = 0
         @finished = false
         @spans = []
+        @flushed = false
+        @propagated = false
       end
     end
   end

data/lib/datadog/tracing/tracer.rb

@@ -307,6 +307,19 @@ module Datadog
         end
       end
 
+      def reconsider_trace_sampling_on_resource(trace_op)
+        return unless trace_op.reconsider_resource_sample?
+        return unless @sampler.respond_to?(:reconsider_sample_resource!)
+
+        @sampler.reconsider_sample_resource!(trace_op)
+      rescue => e
+        RECONSIDER_RESOURCE_SAMPLE_TRACE_LOG_ONLY_ONCE.run do
+          logger.warn do
+            "Failed to reconsider trace sampling: #{e.class.name} #{e} at #{Array(e.backtrace).first}"
+          end
+        end
+      end
+
       # @!visibility private
       # TODO: make this private
       def trace_completed
@@ -415,6 +428,15 @@ module Datadog
           sample_span(event_trace_op, event_span)
           flush_trace(event_trace_op)
         end
+
+        # Conditionally subscribe to the less common sampling rules below, to avoid
+        # measurable unnecessary performance overhead when they are not present.
+
+        if @sampler.respond_to?(:resource_sampling?) && @sampler.resource_sampling?
+          events.trace_resource_change.subscribe do |event_trace_op|
+            reconsider_trace_sampling_on_resource(event_trace_op)
+          end
+        end
       end
 
       # Creates a new TraceOperation, with events bounds to this Tracer instance.
@@ -534,6 +556,9 @@ module Datadog
       SAMPLE_TRACE_LOG_ONLY_ONCE = Core::Utils::OnlyOnce.new
       private_constant :SAMPLE_TRACE_LOG_ONLY_ONCE
 
+      RECONSIDER_RESOURCE_SAMPLE_TRACE_LOG_ONLY_ONCE = Core::Utils::OnlyOnce.new
+      private_constant :RECONSIDER_RESOURCE_SAMPLE_TRACE_LOG_ONLY_ONCE
+
       def sample_span(trace_op, span)
         @span_sampler.sample!(trace_op, span)
       rescue => e

data/lib/datadog/tracing/transport/io/client.rb

@@ -44,7 +44,7 @@ module Datadog
             response
           rescue => e
             message =
-              "Internal error during IO transport request. Cause: #{e.class.name}: #{e.message} " \
+              "Internal error during IO transport request. Cause: #{e.class}: #{e} " \
                 "Location: #{Array(e.backtrace).first}"
 
             # Log error

data/lib/datadog/tracing/transport/trace_formatter.rb

@@ -49,6 +49,7 @@ module Datadog
 
           tag_agent_sample_rate!
           tag_hostname!
+          tag_knuth_sampling_rate!
           tag_lang!
           tag_origin!
           tag_process_id!
@@ -110,6 +111,16 @@ module Datadog
           )
         end
 
+        def tag_knuth_sampling_rate!
+          rate = trace.rule_sample_rate || trace.agent_sample_rate
+          return unless rate
+
+          root_span.set_tag(
+            Tracing::Metadata::Ext::Distributed::TAG_KNUTH_SAMPLING_RATE,
+            format('%.6f', (rate * 1e6).round / 1e6.to_f).sub(/\.?0+\z/, '')
+          )
+        end
+
         def tag_lang!
           return if trace.lang.nil?
 

data/lib/datadog/tracing/writer.rb

@@ -9,7 +9,6 @@ require_relative 'transport/http'
 module Datadog
   module Tracing
     # Processor that sends traces and metadata to the agent
-    # DEV: Our goal is for {Datadog::Tracing::Workers::TraceWriter} to replace this class in the future
     # @public_api
     class Writer
       attr_reader \

data/lib/datadog/version.rb

@@ -3,7 +3,7 @@
 module Datadog
   module VERSION
     MAJOR = 2
-    MINOR = 29
+    MINOR = 31
     PATCH = 0
     PRE = nil
     BUILD = nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datadog
 version: !ruby/object:Gem::Version
-  version: 2.29.0
+  version: 2.31.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-02-20 00:00:00.000000000 Z
+date: 2026-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -64,14 +64,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 25.0.0.1.0
+        version: 30.0.0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 25.0.0.1.0
+        version: 30.0.0.1.0
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -173,6 +173,7 @@ files:
 - ext/libdatadog_api/datadog_ruby_common.c
 - ext/libdatadog_api/datadog_ruby_common.h
 - ext/libdatadog_api/ddsketch.c
+- ext/libdatadog_api/di.c
 - ext/libdatadog_api/extconf.rb
 - ext/libdatadog_api/feature_flags.c
 - ext/libdatadog_api/feature_flags.h
@@ -195,6 +196,8 @@ files:
 - lib/datadog/ai_guard/contrib/ruby_llm/integration.rb
 - lib/datadog/ai_guard/contrib/ruby_llm/patcher.rb
 - lib/datadog/ai_guard/evaluation.rb
+- lib/datadog/ai_guard/evaluation/content_builder.rb
+- lib/datadog/ai_guard/evaluation/content_part.rb
 - lib/datadog/ai_guard/evaluation/message.rb
 - lib/datadog/ai_guard/evaluation/no_op_result.rb
 - lib/datadog/ai_guard/evaluation/request.rb
@@ -261,6 +264,7 @@ files:
 - lib/datadog/appsec/contrib/rack/patcher.rb
 - lib/datadog/appsec/contrib/rack/request_body_middleware.rb
 - lib/datadog/appsec/contrib/rack/request_middleware.rb
+- lib/datadog/appsec/contrib/rack/response_body.rb
 - lib/datadog/appsec/contrib/rails/framework.rb
 - lib/datadog/appsec/contrib/rails/gateway/request.rb
 - lib/datadog/appsec/contrib/rails/gateway/watcher.rb
@@ -338,6 +342,7 @@ files:
 - lib/datadog/core/configuration/settings.rb
 - lib/datadog/core/configuration/stable_config.rb
 - lib/datadog/core/configuration/supported_configurations.rb
+- lib/datadog/core/contrib/rails/railtie.rb
 - lib/datadog/core/contrib/rails/utils.rb
 - lib/datadog/core/crashtracking/component.rb
 - lib/datadog/core/crashtracking/tag_builder.rb
@@ -413,6 +418,7 @@ files:
 - lib/datadog/core/telemetry/event/app_closing.rb
 - lib/datadog/core/telemetry/event/app_dependencies_loaded.rb
 - lib/datadog/core/telemetry/event/app_endpoints_loaded.rb
+- lib/datadog/core/telemetry/event/app_extended_heartbeat.rb
 - lib/datadog/core/telemetry/event/app_heartbeat.rb
 - lib/datadog/core/telemetry/event/app_integrations_change.rb
 - lib/datadog/core/telemetry/event/app_started.rb
@@ -466,6 +472,7 @@ files:
 - lib/datadog/core/utils/only_once_successful.rb
 - lib/datadog/core/utils/safe_dup.rb
 - lib/datadog/core/utils/sequence.rb
+- lib/datadog/core/utils/spawn_monkey_patch.rb
 - lib/datadog/core/utils/time.rb
 - lib/datadog/core/utils/truncation.rb
 - lib/datadog/core/utils/url.rb
@@ -520,6 +527,7 @@ files:
 - lib/datadog/di/probe_manager.rb
 - lib/datadog/di/probe_notification_builder.rb
 - lib/datadog/di/probe_notifier_worker.rb
+- lib/datadog/di/probe_repository.rb
 - lib/datadog/di/proc_responder.rb
 - lib/datadog/di/redactor.rb
 - lib/datadog/di/remote.rb
@@ -1093,7 +1101,6 @@ files:
 - lib/datadog/tracing/transport/traces.rb
 - lib/datadog/tracing/utils.rb
 - lib/datadog/tracing/workers.rb
-- lib/datadog/tracing/workers/trace_writer.rb
 - lib/datadog/tracing/writer.rb
 - lib/datadog/version.rb
 homepage: https://github.com/DataDog/dd-trace-rb
@@ -1102,9 +1109,9 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.29.0/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.29.0
-post_install_message:
+  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.31.0/CHANGELOG.md
+  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.31.0
+post_install_message: 'JRuby support in the datadog gem is deprecated. Details: https://dtdg.co/jruby-deprecation'
 rdoc_options: []
 require_paths:
 - lib

data/lib/datadog/tracing/workers/trace_writer.rb

@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../core/worker'
-require_relative '../../core/workers/async'
-require_relative '../../core/workers/polling'
-require_relative '../../core/workers/queue'
-
-require_relative '../buffer'
-require_relative '../pipeline'
-require_relative '../event'
-
-require_relative '../transport/http'
-
-module Datadog
-  module Tracing
-    module Workers
-      # Writes traces to transport synchronously
-      class TraceWriter < Core::Worker
-        attr_reader \
-          :logger,
-          :transport,
-          :agent_settings
-
-        # DEV-3.0: change to keyword arguments
-        #
-        # rubocop:disable Lint/MissingSuper
-        def initialize(options = {})
-          @logger = options[:logger] || Datadog.logger
-
-          transport_options = options.fetch(:transport_options, {})
-          @agent_settings = options[:agent_settings]
-
-          @transport = options.fetch(:transport) do
-            Datadog::Tracing::Transport::HTTP.default(agent_settings: agent_settings, logger: logger, **transport_options)
-          end
-        end
-        # rubocop:enable Lint/MissingSuper
-
-        def perform(traces)
-          write_traces(traces)
-        end
-
-        def write(trace)
-          write_traces([trace])
-        end
-
-        def write_traces(traces)
-          traces = process_traces(traces)
-          flush_traces(traces)
-        rescue => e
-          logger.warn(
-            "Error while writing traces: dropped #{traces.length} items. Cause: #{e} Location: #{Array(e.backtrace).first}"
-          )
-        end
-
-        def process_traces(traces)
-          # Run traces through the processing pipeline
-          Pipeline.process!(traces)
-        end
-
-        def flush_traces(traces)
-          transport.send_traces(traces).tap do |response|
-            flush_completed.publish(response)
-          end
-        end
-
-        # TODO: Register `Datadog::Tracing::Diagnostics::EnvironmentLogger.collect_and_log!`
-        # TODO: as a flush_completed subscriber when the `TraceWriter`
-        # TODO: instantiation code is implemented.
-        def flush_completed
-          @flush_completed ||= FlushCompleted.new
-        end
-
-        # Flush completed event for worker
-        class FlushCompleted < Event
-          def initialize
-            super(:flush_completed)
-          end
-        end
-      end
-
-      # Writes traces to transport asynchronously,
-      # using a thread & buffer.
-      class AsyncTraceWriter < TraceWriter
-        include Core::Workers::Queue
-        include Core::Workers::Polling
-
-        DEFAULT_BUFFER_MAX_SIZE = 1000
-        FORK_POLICY_ASYNC = :async
-        FORK_POLICY_SYNC = :sync
-
-        attr_writer \
-          :async
-
-        def initialize(options = {})
-          # Workers::TraceWriter settings
-          super
-
-          # Workers::Polling settings
-          self.enabled = options.fetch(:enabled, true)
-
-          # Workers::Async::Thread settings
-          @async = true
-          self.fork_policy = options.fetch(:fork_policy, FORK_POLICY_ASYNC)
-
-          # Workers::IntervalLoop settings
-          self.loop_base_interval = options[:interval] if options.key?(:interval)
-          self.loop_back_off_ratio = options[:back_off_ratio] if options.key?(:back_off_ratio)
-          self.loop_back_off_max = options[:back_off_max] if options.key?(:back_off_max)
-
-          # Workers::Queue settings
-          @buffer_size = options.fetch(:buffer_size, DEFAULT_BUFFER_MAX_SIZE)
-          self.buffer = TraceBuffer.new(@buffer_size)
-
-          @shutdown_timeout = options.fetch(:shutdown_timeout, Core::Workers::Polling::DEFAULT_SHUTDOWN_TIMEOUT)
-        end
-
-        # NOTE: #perform is wrapped by other modules:
-        #       Polling --> Async --> IntervalLoop --> AsyncTraceWriter --> TraceWriter
-        #
-        # WARNING: This method breaks the Liskov Substitution Principle -- TraceWriter#perform is spec'd to return the
-        # result from the writer, whereas this method always returns nil.
-        def perform(traces)
-          super.tap do |responses|
-            loop_back_off! if responses.find(&:server_error?)
-          end
-
-          nil
-        end
-
-        def stop(force_stop = false, timeout = @shutdown_timeout)
-          buffer.close if running?
-          super
-        end
-
-        def enqueue(trace)
-          buffer.push(trace)
-        end
-
-        def dequeue
-          # Wrap results in Array because they are
-          # splatted as args against TraceWriter#perform.
-          [buffer.pop]
-        end
-
-        # Are there more traces to be processed next?
-        def work_pending?
-          # This is the same implementation as in Queue, but it was
-          # overwritten by IntervalLoop on its way to this worker class.
-          # See the comments in those two methods for more info.
-          !buffer.empty?
-        end
-
-        def async?
-          @async == true
-        end
-
-        def fork_policy=(policy)
-          # Translate to Workers::Async::Thread policy
-          thread_fork_policy = case policy
-          when Core::Workers::Async::Thread::FORK_POLICY_STOP
-            policy
-          when FORK_POLICY_SYNC
-            # Stop the async thread because the writer
-            # will bypass and run synchronously.
-            Core::Workers::Async::Thread::FORK_POLICY_STOP
-          else
-            Core::Workers::Async::Thread::FORK_POLICY_RESTART
-          end
-
-          # Update thread fork policy
-          super(thread_fork_policy)
-
-          # Update local policy
-          @writer_fork_policy = policy
-        end
-
-        def after_fork
-          # In multiprocess environments, forks will share the same buffer until its written to.
-          # A.K.A. copy-on-write. We don't want forks to write traces generated from another process.
-          # Instead, we reset it after the fork. (Make sure any enqueue operations happen after this.)
-          self.buffer = TraceBuffer.new(@buffer_size)
-
-          # Switch to synchronous mode if configured to do so.
-          # In some cases synchronous writing is preferred because the fork will be short lived.
-          @async = false if @writer_fork_policy == FORK_POLICY_SYNC
-        end
-
-        # WARNING: This method breaks the Liskov Substitution Principle -- TraceWriter#write is spec'd to return the
-        # result from the writer, whereas this method returns something else when running in async mode.
-        def write(trace)
-          # Start worker thread. If the process has forked, it will trigger #after_fork to
-          # reconfigure the worker accordingly.
-          # NOTE: It's important we do this before queuing or it will drop the current trace,
-          #       because #after_fork resets the buffer.
-          perform
-
-          # Queue the trace if running asynchronously, otherwise short-circuit and write it directly.
-          async? ? enqueue(trace) : write_traces([trace])
-        end
-      end
-    end
-  end
-end