datadog 2.39.0 → 2.40.0

data/lib/datadog/di/el/compiler.rb

@@ -16,8 +16,19 @@ module Datadog
       #
       # @api private
       class Compiler
+        # Compiles +ast+ into eval'able Ruby source.
+        #
+        # Returns the compiled source and companion compiled Regexp
+        # objects.
+        #
+        # @param ast [untyped] expression AST from the probe definition.
+        # @return [Array(String, Array<Regexp>)] the compiled Ruby source and
+        #   the precompiled Regexps, indexed in the order the compiled code
+        #   references them.
         def compile(ast)
-          compile_partial(ast)
+          regexps = []
+          code = compile_partial(ast, regexps)
+          [code, regexps]
         end
 
         private
@@ -37,9 +48,13 @@ module Datadog
           len isEmpty isUndefined
         ].freeze # steep:ignore IncompatibleAssignment
 
+        # `matches` is also a two-argument method but is special-cased in
+        # #compile_partial so that regular expressions can be precompiled
+        # once, so it is not listed here.
+        #
         # Steep: https://github.com/soutaro/steep/issues/363
         TWO_ARG_METHODS = %w[
-          startsWith endsWith contains matches
+          startsWith endsWith contains
           getmember index instanceof
         ].freeze # steep:ignore IncompatibleAssignment
 
@@ -49,13 +64,18 @@ module Datadog
           "or" => "||",
         }.freeze
 
-        def compile_partial(ast)
+        # @param ast [untyped] AST node to compile.
+        # @param regexps [Array<Regexp>] output array that collects the
+        #   companion precompiled Regexp objects.
+        # @return [String] compiled Ruby source for +ast+.
+        def compile_partial(ast, regexps)
           case ast
           when Hash
-            if ast.length != 1
+            entry = ast.first
+            if ast.length != 1 || entry.nil?
               raise DI::Error::InvalidExpression, "Expected hash of length 1: #{ast}"
             end
-            op, target = ast.first
+            op, target = entry
             case op
             when "ref"
               unless String === target
@@ -94,20 +114,33 @@ module Datadog
               end
             when *SINGLE_ARG_METHODS
               method_name = op.gsub(/[A-Z]/) { |m| "_#{m.downcase}" }
-              "#{method_name}(#{compile_partial(target)}, '#{var_name_maybe(target)}')"
+              "#{method_name}(#{compile_partial(target, regexps)}, '#{var_name_maybe(target)}')"
+            when "matches"
+              unless Array === target && target.length == 2
+                raise DI::Error::InvalidExpression, "Improper matches syntax"
+              end
+              first, second = target
+              if String === second
+                # Match against a literal regular expression (string).
+                index = precompile_regexp(second, regexps)
+                "matches_compiled(#{compile_partial(first, regexps)}, #{index})"
+              else
+                # Match against a (complex) expression.
+                "matches(#{compile_partial(first, regexps)}, (#{compile_partial(second, regexps)}))"
+              end
             when *TWO_ARG_METHODS
               method_name = op.gsub(/[A-Z]/) { |m| "_#{m.downcase}" }
               unless Array === target && target.length == 2
                 raise DI::Error::InvalidExpression, "Improper #{op} syntax"
               end
               first, second = target
-              "#{method_name}(#{compile_partial(first)}, (#{compile_partial(second)}))"
+              "#{method_name}(#{compile_partial(first, regexps)}, (#{compile_partial(second, regexps)}))"
             when *MULTI_ARG_METHODS.keys
               unless Array === target && target.length >= 1
                 raise DI::Error::InvalidExpression, "Improper #{op} syntax"
               end
               compiled_targets = target.map do |item|
-                "(#{compile_partial(item)})"
+                "(#{compile_partial(item, regexps)})"
               end
               compiled_op = MULTI_ARG_METHODS[op]
               "(#{compiled_targets.join(" #{compiled_op} ")})"
@@ -115,18 +148,21 @@ module Datadog
               unless Array === target && target.length == 3
                 raise DI::Error::InvalidExpression, "Improper #{op} syntax"
               end
-              "#{op}(#{target.map { |arg| "(#{compile_partial(arg)})" }.join(", ")})"
+              "#{op}(#{target.map { |arg| "(#{compile_partial(arg, regexps)})" }.join(", ")})"
             when "not"
-              "!(#{compile_partial(target)})"
+              "!(#{compile_partial(target, regexps)})"
             when *OPERATORS.keys
               unless Array === target && target.length == 2
                 raise DI::Error::InvalidExpression, "Improper #{op} syntax"
               end
               first, second = target
               operator = OPERATORS.fetch(op)
-              "(#{compile_partial(first)}) #{operator} (#{compile_partial(second)})"
+              "(#{compile_partial(first, regexps)}) #{operator} (#{compile_partial(second, regexps)})"
             when "any", "all", "filter"
-              "#{op}(#{compile_partial(target.first)}) { |current_item, current_key, current_value| #{compile_partial(target.last)} }"
+              unless Array === target && target.length == 2
+                raise DI::Error::InvalidExpression, "Improper #{op} syntax"
+              end
+              "#{op}(#{compile_partial(target.first, regexps)}) { |current_item, current_key, current_value| #{compile_partial(target.last, regexps)} }"
             else
               raise DI::Error::InvalidExpression, "Unknown operation: #{op}"
             end
@@ -162,6 +198,23 @@ module Datadog
         def escape(needle)
           needle.gsub("\\") { "\\\\" }.gsub('"') { "\\\"" }.gsub("#") { "\\#" }
         end
+
+        # Compile a literal regular expression +regexp_str+ at
+        # instrumentation time. Append it to +regexps+, returning its index for
+        # Evaluator#matches_compiled to look up.
+        #
+        # @param regexp_str [String] regular expression source.
+        # @param regexps [Array<Regexp>] output array to append the compiled
+        #   regexp to.
+        # @return [Integer] index into +regexps+.
+        # @raise [DI::Error::InvalidExpression] if +needle+ is not a valid regexp.
+        def precompile_regexp(regexp_str, regexps)
+          index = regexps.length
+          regexps << Evaluator.compile_regexp(regexp_str)
+          index
+        rescue RegexpError => exc
+          raise DI::Error::InvalidExpression, "Invalid regular expression in matches: #{exc.class}: #{exc.message}"
+        end
       end
     end
   end

data/lib/datadog/di/el/evaluator.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require_relative "../../ruby_version"
+
+require "timeout" if Datadog::RubyVersion.is?("< 3.2")
+
 module Datadog
   module DI
     module EL
@@ -7,6 +11,20 @@ module Datadog
       #
       # @api private
       class Evaluator
+        # Maximum wall-clock time allowed for evaluating a single `matches`
+        # operator.
+        MATCHES_TIMEOUT_SECONDS = 0.5
+
+        # @param regexps [Array<Regexp>] Regexps precompiled from literal
+        #   `matches` patterns, looked up by index by #matches_compiled.
+        #    Empty when the expression has no `matches` pattern with
+        #    a direct regular expression argument.
+        def initialize(regexps = [])
+          @regexps = regexps
+        end
+
+        attr_reader :regexps
+
         def ref(var)
           @context.fetch(var)
         end
@@ -48,10 +66,72 @@ module Datadog
           end
         end
 
+        # Build a Regexp from a pattern string. On Ruby 3.2+ the per-match
+        # timeout (MATCHES_TIMEOUT_SECONDS) is baked into the compiled
+        # Regexp via the in-engine `timeout:` keyword, which interrupts the
+        # matcher at every backtrack step and reliably bounds matcher
+        # runtime regardless of pattern shape. On older Rubies the Regexp
+        # carries no timeout; the bound is applied at match time by
+        # #bounded_match? instead.
+        #
+        # @param needle [String] regexp source.
+        # @return [Regexp] compiled regexp, with baked-in timeout on Ruby 3.2+.
+        if Datadog::RubyVersion.is?(">= 3.2")
+          def self.compile_regexp(needle)
+            Regexp.new(needle, timeout: MATCHES_TIMEOUT_SECONDS)
+          end
+        else
+          def self.compile_regexp(needle)
+            Regexp.compile(needle)
+          end
+        end
+
+        # Match +haystack+ against a regexp whose needle is computed at
+        # evaluation time, so the Regexp cannot be precompiled. Literal needles are
+        # precompiled by the Compiler and dispatched to #matches_compiled.
+        #
+        # @param haystack [String] string to match against.
+        # @param needle [String] regexp source.
+        # @return [Boolean] whether the haystack matches the regexp.
+        # @raise [Regexp::TimeoutError] (Ruby 3.2+) regexp engine exceeded MATCHES_TIMEOUT_SECONDS.
+        # @raise [Timeout::Error] (Ruby < 3.2) Timeout.timeout fired.
         def matches(haystack, needle)
-          re = Regexp.compile(needle)
-          !!(haystack =~ re)
+          bounded_match?(Evaluator.compile_regexp(needle), haystack)
+        end
+
+        # Match +haystack+ against a Regexp precompiled at expression-compile
+        # time, looked up by index in +regexps+.
+        #
+        # @param haystack [String] string to match against.
+        # @param index [Integer] position of the precompiled Regexp in +regexps+.
+        # @return [Boolean] whether the haystack matches the regexp.
+        # @raise [Regexp::TimeoutError] (Ruby 3.2+) regexp engine exceeded MATCHES_TIMEOUT_SECONDS.
+        # @raise [Timeout::Error] (Ruby < 3.2) Timeout.timeout fired.
+        def matches_compiled(haystack, index)
+          bounded_match?(regexps.fetch(index), haystack)
+        end
+
+        # Match +haystack+ against +re+, bounded at MATCHES_TIMEOUT_SECONDS
+        # wall-clock.
+        #
+        # @param re [Regexp] regexp to match against.
+        # @param haystack [String] string to match against.
+        # @return [Boolean] whether the haystack matches the regexp.
+        if Datadog::RubyVersion.is?(">= 3.2")
+          def bounded_match?(re, haystack)
+            # Uses Regexp#match? rather than =~ so that the
+            # thread-local match data ($~, $1, ...) is not mutated as a side
+            # effect of DI expression evaluation.
+            re.match?(haystack)
+          end
+        else
+          def bounded_match?(re, haystack)
+            Timeout.timeout(MATCHES_TIMEOUT_SECONDS) do
+              re.match?(haystack)
+            end
+          end
         end
+        private :bounded_match?
 
         def getmember(object, field)
           object.instance_variable_get("@#{field}")

data/lib/datadog/di/el/expression.rb

@@ -7,7 +7,12 @@ module Datadog
       #
       # @api private
       class Expression
-        def initialize(dsl_expr, compiled_expr)
+        # @param dsl_expr [String] human-readable DSL form, kept for debugging.
+        # @param compiled_expr [String] Ruby source produced by Compiler#compile.
+        # @param regexps [Array<Regexp>] precompiled `matches` regexps (see
+        #   Compiler#precompile_regexp), the second element returned by
+        #   Compiler#compile.
+        def initialize(dsl_expr, compiled_expr, regexps = [])
           unless String === compiled_expr
             raise ArgumentError, "compiled_expr must be a string"
           end
@@ -23,7 +28,10 @@ module Datadog
               end
             RUBY
           end
-          @evaluator = cls.new
+          # cls inherits Evaluator#initialize(regexps), but Steep types
+          # Class#new as () -> untyped and cannot see that initializer
+          # through this dynamically created subclass.
+          @evaluator = cls.new(regexps) # steep:ignore UnexpectedPositionalArgument
         end
 
         attr_reader :dsl_expr

data/lib/datadog/di/probe_builder.rb

@@ -45,8 +45,8 @@ module Datadog
           unless cond_spec["dsl"] && cond_spec["json"]
             raise ArgumentError, "Malformed condition specification for probe: #{config}"
           end
-          compiled = EL::Compiler.new.compile(cond_spec["json"])
-          EL::Expression.new(cond_spec["dsl"], compiled)
+          compiled, regexps = EL::Compiler.new.compile(cond_spec["json"])
+          EL::Expression.new(cond_spec["dsl"], compiled, regexps)
         end
         capture_expressions = build_capture_expressions(config["captureExpressions"])
         capture_expressions = dedup_capture_expressions(capture_expressions, config["id"], logger)
@@ -100,8 +100,8 @@ module Datadog
           unless Hash === expr_spec && expr_spec["dsl"] && expr_spec["json"]
             raise ArgumentError, "captureExpressions entry #{name}: missing or malformed expr"
           end
-          compiled = EL::Compiler.new.compile(expr_spec["json"])
-          expr = EL::Expression.new(expr_spec["dsl"], compiled)
+          compiled, regexps = EL::Compiler.new.compile(expr_spec["json"])
+          expr = EL::Expression.new(expr_spec["dsl"], compiled, regexps)
           limits = build_capture_limits(entry["capture"])
           CaptureExpression.new(name: name, expr: expr, limits: limits)
         end
@@ -152,8 +152,8 @@ module Datadog
               unless dsl = segment["dsl"]
                 raise ArgumentError, "Missing dsl for json in segment: #{segment}"
               end
-              compiled = EL::Compiler.new.compile(ast)
-              EL::Expression.new(dsl, compiled)
+              compiled, regexps = EL::Compiler.new.compile(ast)
+              EL::Expression.new(dsl, compiled, regexps)
             else
               # TODO report to telemetry?
             end

data/lib/datadog/profiling/collectors/thread_context.rb

@@ -21,7 +21,8 @@ module Datadog
           endpoint_collection_enabled:,
           waiting_for_gvl_threshold_ns:,
           otel_context_enabled:,
-          native_filenames_enabled:
+          native_filenames_enabled:,
+          show_classes:
         )
           tracer_context_key = safely_extract_context_key_from(tracer)
           self.class._native_initialize(
@@ -32,7 +33,8 @@ module Datadog
             endpoint_collection_enabled: endpoint_collection_enabled,
             waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
             otel_context_enabled: otel_context_enabled,
-            native_filenames_enabled: validate_native_filenames(native_filenames_enabled),
+            native_filenames_enabled: native_filenames_enabled,
+            show_classes: show_classes,
             overhead_filename: __FILE__,
           )
         end
@@ -45,6 +47,7 @@ module Datadog
           waiting_for_gvl_threshold_ns: 10_000_000,
           otel_context_enabled: false,
           native_filenames_enabled: true,
+          show_classes: false,
           trigger_global_reset: true,
           **options
         )
@@ -56,6 +59,7 @@ module Datadog
             waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
             otel_context_enabled: otel_context_enabled,
             native_filenames_enabled: native_filenames_enabled,
+            show_classes: show_classes,
             **options,
           )
 
@@ -90,17 +94,6 @@ module Datadog
           context = provider.instance_variable_get(:@context)
           context&.instance_variable_get(:@key)
         end
-
-        def validate_native_filenames(native_filenames_enabled)
-          if native_filenames_enabled && !Datadog::Profiling::Collectors::Stack._native_filenames_available?
-            Datadog.logger.debug(
-              "Native filenames are enabled, but the required dladdr API was not available. Disabling native filenames."
-            )
-            false
-          else
-            native_filenames_enabled
-          end
-        end
       end
     end
   end

data/lib/datadog/profiling/component.rb

@@ -105,6 +105,7 @@ module Datadog
           waiting_for_gvl_threshold_ns: settings.profiling.advanced.waiting_for_gvl_threshold_ns,
           otel_context_enabled: settings.profiling.advanced.preview_otel_context_enabled,
           native_filenames_enabled: settings.profiling.advanced.native_filenames_enabled,
+          show_classes: settings.profiling.advanced.experimental_show_classes_enabled,
         )
       end
 

data/lib/datadog/profiling.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "rbconfig"
 require_relative "core"
 require_relative "core/environment/variable_helpers"
 require_relative "core/utils/only_once"
@@ -7,6 +8,9 @@ require_relative "core/utils/only_once"
 module Datadog
   # Datadog Continuous Profiler implementation: https://docs.datadoghq.com/profiler/
   module Profiling
+    STATIC_RUBY_PATH = (RbConfig::CONFIG["ENABLE_SHARED"] == "no") ? RbConfig.ruby.freeze : nil
+    private_constant :STATIC_RUBY_PATH
+
     def self.supported?
       unsupported_reason.nil?
     end

data/lib/datadog/tracing/component.rb

@@ -104,9 +104,30 @@ module Datadog
           return writer
         end
 
+        if settings.tracing.native_transport && (transport = build_native_transport(agent_settings))
+          options = options.merge(transport: transport)
+        end
+
         Tracing::Writer.new(agent_settings: agent_settings, **options)
       end
 
+      def build_native_transport(agent_settings)
+        require_relative "transport/native"
+
+        unless Transport::Native.supported?
+          Datadog.logger.warn(
+            "Native transport requested but not available: #{Transport::Native::UNSUPPORTED_REASON}. " \
+            "Falling back to default HTTP transport."
+          )
+          return nil
+        end
+
+        Transport::Native::Transport.new(
+          agent_settings: agent_settings,
+          logger: Datadog.logger
+        )
+      end
+
       def subscribe_to_writer_events!(writer, sampler_delegator, test_mode)
         return unless writer.respond_to?(:events) # Check if it's a custom, external writer
 

data/lib/datadog/tracing/configuration/ext.rb

@@ -16,6 +16,7 @@ module Datadog
         ENV_RESOURCE_RENAMING_ENABLED = "DD_TRACE_RESOURCE_RENAMING_ENABLED"
         ENV_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT = "DD_TRACE_RESOURCE_RENAMING_ALWAYS_SIMPLIFIED_ENDPOINT"
         ENV_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED = "DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED"
+        ENV_EXPERIMENTAL_NATIVE_TRANSPORT_ENABLED = "DD_EXPERIMENTAL_NATIVE_TRANSPORT_ENABLED"
 
         # @public_api
         module SpanAttributeSchema

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

@@ -482,6 +482,22 @@ module Datadog
                 end
               end
 
+              # Use the native trace transport (Rust via C FFI) instead of
+              # the default pure-Ruby HTTP transport.
+              #
+              # The native transport delegates serialization, stats
+              # computation, and HTTP sending to the Rust data pipeline.
+              #
+              # This option is recommended for internal use only.
+              #
+              # @default `false`
+              # @return [Boolean]
+              option :native_transport do |o|
+                o.env Configuration::Ext::ENV_EXPERIMENTAL_NATIVE_TRANSPORT_ENABLED
+                o.default false
+                o.type :bool
+              end
+
               # A custom writer instance.
               # The object must respect the {Datadog::Tracing::Writer} interface.
               #

data/lib/datadog/tracing/contrib/hanami/router_tracing.rb

@@ -10,7 +10,8 @@ module Datadog
         # Hanami Instrumentation for `hanami.routing`
         module RouterTracing
           def call(env)
-            return super if Tracing.active_span && Tracing.active_span.name == Ext::SPAN_ROUTING
+            active_span = Tracing.active_span
+            return super if active_span && active_span.name == Ext::SPAN_ROUTING
 
             Tracing.trace(
               Ext::SPAN_ROUTING,

data/lib/datadog/tracing/contrib/kafka/events/connection/request.rb

@@ -21,6 +21,10 @@ module Datadog
                 super
 
                 span.resource = payload[:api]
+              end
+
+              def on_finish(span, _event, _id, payload)
+                super
 
                 span.set_tag(Ext::TAG_REQUEST_SIZE, payload[:request_size]) if payload.key?(:request_size)
                 span.set_tag(Ext::TAG_RESPONSE_SIZE, payload[:response_size]) if payload.key?(:response_size)

data/lib/datadog/tracing/contrib/kafka/events/produce_operation/send_messages.rb

@@ -17,12 +17,17 @@ module Datadog
 
               module_function
 
-              def on_start(span, _event, _id, payload)
+              def on_start(span, _event, _id, _payload)
+                super
+
+                span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_PRODUCER)
+              end
+
+              def on_finish(span, _event, _id, payload)
                 super
 
                 span.set_tag(Ext::TAG_MESSAGE_COUNT, payload[:message_count]) if payload.key?(:message_count)
                 span.set_tag(Ext::TAG_SENT_MESSAGE_COUNT, payload[:sent_message_count]) if payload.key?(:sent_message_count)
-                span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_PRODUCER)
               end
 
               def span_name

data/lib/datadog/tracing/contrib/kafka/events/producer/deliver_messages.rb

@@ -17,7 +17,13 @@ module Datadog
 
               module_function
 
-              def on_start(span, _event, _id, payload)
+              def on_start(span, _event, _id, _payload)
+                super
+
+                span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_PRODUCER)
+              end
+
+              def on_finish(span, _event, _id, payload)
                 super
 
                 span.set_tag(Ext::TAG_ATTEMPTS, payload[:attempts]) if payload.key?(:attempts)
@@ -25,7 +31,6 @@ module Datadog
                 if payload.key?(:delivered_message_count)
                   span.set_tag(Ext::TAG_DELIVERED_MESSAGE_COUNT, payload[:delivered_message_count])
                 end
-                span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_PRODUCER)
               end
 
               def span_name

data/lib/datadog/tracing/contrib/sequel/database.rb

@@ -46,11 +46,7 @@ module Datadog
             end
 
             def parse_opts(sql, opts)
-              db_opts = if ::Sequel::VERSION < "3.41.0" && self.class.to_s !~ /Dataset$/
-                @opts
-              elsif instance_variable_defined?(:@pool) && @pool
-                @pool.db.opts
-              end
+              db_opts = @pool.db.opts if instance_variable_defined?(:@pool) && @pool
               sql = sql.is_a?(::Sequel::SQL::Expression) ? literal(sql) : sql.to_s
 
               Utils.parse_opts(sql, opts, db_opts)

data/lib/datadog/tracing/distributed/propagation_policy.rb

@@ -28,6 +28,11 @@ module Datadog
               return true
             end
 
+            if ::Datadog.configuration.respond_to?(:ai_guard) && ::Datadog.configuration.ai_guard.enabled &&
+                (trace_source & ::Datadog::AIGuard::Ext::PRODUCT_BIT) != 0
+              return true
+            end
+
             return false
           end
 

data/lib/datadog/tracing/sync_writer.rb

@@ -46,10 +46,15 @@ module Datadog
         logger.debug(e)
       end
 
-      # Does nothing.
-      # The {SyncWriter} does not need to be stopped as it holds no state.
+      # Stops the {SyncWriter}.
+      # The {SyncWriter} holds no worker thread, but it owns its transport, so
+      # on teardown we deterministically release transports that hold native
+      # resources (e.g. the native trace exporter's Rust runtime and
+      # process-global fork hooks) rather than relying on the GC finalizer.
+      # The default HTTP transport has no `#close` and is left untouched, and
+      # `#close` is idempotent so repeated `#stop` calls are safe.
       def stop
-        # No cleanup to do for the SyncWriter
+        @transport.close if @transport.respond_to?(:close)
         true
       end
 

data/lib/datadog/tracing/tracer.rb

@@ -628,6 +628,10 @@ module Datadog
           appsec_bit = upstream_tags[Tracing::Metadata::Ext::Distributed::TAG_TRACE_SOURCE].to_i(16) &
             Datadog::AppSec::Ext::PRODUCT_BIT
           return appsec_enabled if appsec_bit != 0
+
+          ai_guard_bit = upstream_tags[Tracing::Metadata::Ext::Distributed::TAG_TRACE_SOURCE].to_i(16) &
+            Datadog::AIGuard::Ext::PRODUCT_BIT
+          return ai_guard_enabled if ai_guard_bit != 0
         end
 
         false
@@ -642,6 +646,10 @@ module Datadog
         @appsec_enabled ||= Datadog.configuration.appsec.enabled
       end
 
+      def ai_guard_enabled
+        @ai_guard_enabled ||= Datadog.configuration.respond_to?(:ai_guard) && Datadog.configuration.ai_guard.enabled
+      end
+
       # Due to APM Tracing (the product) and Tracing (the transport) being intertwined, we cannot completely disabled APM
       # without also disabling the tracer. When setting `@apm_tracing_enabled` to `false`, it does not disable the tracer,
       # but rather only sends heartbeat traces (1 per minutes), so that the service is considered alive in the backend.

data/lib/datadog/tracing/transport/native/response.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Datadog
+  module Tracing
+    module Transport
+      module Native
+        # Response from the native trace exporter.
+        #
+        # Constructed by the C extension after a send completes (or fails).
+        # Implements the same predicate interface as the HTTP transport's
+        # response so callers can treat both uniformly.
+        class Response
+          SERVICE_RATE_KEY = "rate_by_service"
+
+          attr_reader :trace_count, :payload
+
+          def initialize(ok:, internal_error: false, server_error: false, client_error: false,
+            not_found: false, unsupported: false, trace_count: 0, payload: nil)
+            @ok = ok
+            @internal_error = internal_error
+            @server_error = server_error
+            @client_error = client_error
+            @not_found = not_found
+            @unsupported = unsupported
+            @trace_count = trace_count
+            @payload = payload
+          end
+
+          def ok?
+            @ok
+          end
+
+          def internal_error?
+            @internal_error
+          end
+
+          def server_error?
+            @server_error
+          end
+
+          def client_error?
+            @client_error
+          end
+
+          def not_found?
+            @not_found
+          end
+
+          def unsupported?
+            @unsupported
+          end
+
+          # Parse the agent's JSON response body and extract the
+          # +rate_by_service+ map.  Returns +nil+ when the payload
+          # is absent or does not contain sampling rates.
+          def service_rates
+            payload = @payload
+            return nil if payload.nil? || payload.empty?
+
+            parsed = JSON.parse(payload)
+            parsed[SERVICE_RATE_KEY] if parsed.is_a?(Hash)
+          rescue JSON::ParserError
+            nil
+          end
+        end
+      end
+    end
+  end
+end