datadog 2.39.0 → 2.41.0

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,12 +7,22 @@ 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.
+        # @param redaction_identifier [String, nil] the identifier this
+        #   expression directly references at its top level (see
+        #   Compiler#redaction_identifier); nil when it is not a direct
+        #   reference.
+        def initialize(dsl_expr, compiled_expr, regexps: [], redaction_identifier: nil)
           unless String === compiled_expr
             raise ArgumentError, "compiled_expr must be a string"
           end
 
           @dsl_expr = dsl_expr
+          @redaction_identifier = redaction_identifier
 
           cls = Class.new(Evaluator)
           cls.class_exec do
@@ -23,11 +33,12 @@ module Datadog
               end
             RUBY
           end
-          @evaluator = cls.new
+          @evaluator = cls.new(regexps)
         end
 
         attr_reader :dsl_expr
         attr_reader :evaluator
+        attr_reader :redaction_identifier
 
         def evaluate(context)
           @evaluator.evaluate(context)

data/lib/datadog/di/instrumenter.rb

@@ -160,6 +160,7 @@ module Datadog
         end
 
         loc = target_method&.source_location
+        # @type var instrumenter: Instrumenter
         instrumenter = self
 
         mod = Module.new do
@@ -193,7 +194,7 @@ module Datadog
           # user probe on Proc#call cannot intercept the trampoline, and no
           # Proc is allocated for the block.
           if RubyVersion.is?(">= 3")
-            define_method(method_name) do |*args, **kwargs, &target_block| # steep:ignore NoMethod
+            define_method(method_name) do |*args, **kwargs, &target_block|
               # steep:ignore FallbackAny below: Steep cannot narrow the
               # **kwargs parameter inside this define_method block, so it
               # falls back to untyped at the super and run_method_probe sites.
@@ -211,7 +212,7 @@ module Datadog
               end
             end
           else
-            define_method(method_name) do |*args, &target_block| # steep:ignore NoMethod
+            define_method(method_name) do |*args, &target_block|
               if DI.in_probe?
                 return super(*args, &target_block)
               end
@@ -230,7 +231,7 @@ module Datadog
                 super(*args, &target_block)
               end
             end
-            ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true) # steep:ignore NoMethod
+            ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)
           end
         end
 
@@ -461,7 +462,7 @@ module Datadog
       # @param args [Array] positional arguments passed to the probed method
       # @param kwargs [Hash{Symbol => Object}] keyword arguments passed to the probed method
       # @param target_block [Proc, nil] block argument passed to the probed method
-      # @param target_self [Object] the receiver of the probed method invocation
+      # @param target_self [any] the receiver of the probed method invocation
       # @param probe [Datadog::DI::Probe] the probe whose callback this invocation runs
       # @param responder [#probe_executed_callback, #probe_condition_evaluation_failed_callback] callback target invoked with the built Context
       # @param loc [Array(String, Integer), nil] source location of the probed method, or nil for virtual/lazily-defined methods

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: 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: regexps)
           limits = build_capture_limits(entry["capture"])
           CaptureExpression.new(name: name, expr: expr, limits: limits)
         end
@@ -152,8 +152,9 @@ 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)
+              compiler = EL::Compiler.new
+              compiled, regexps = compiler.compile(ast)
+              EL::Expression.new(dsl, compiled, regexps: regexps, redaction_identifier: compiler.redaction_identifier(ast))
             else
               # TODO report to telemetry?
             end

data/lib/datadog/di/probe_notification_builder.rb

@@ -179,7 +179,7 @@ module Datadog
         if status == "ERROR"
           diagnostics[:exception] = { # steep:ignore
             type: exception ? exception.class.name : "Error",
-            message: exception ? exception.message : message
+            message: exception ? exception.message : message,
           }
         end
 
@@ -405,7 +405,7 @@ module Datadog
           when String
             segment
           when EL::Expression
-            serializer.serialize_value_for_message(segment.evaluate(context))
+            serializer.serialize_value_for_message(segment.evaluate(context), name: segment.redaction_identifier)
           else
             raise ArgumentError, "Invalid template segment type: #{segment}"
           end

data/lib/datadog/di/serializer.rb

@@ -50,6 +50,13 @@ module Datadog
       # return a safe stub rather than tear the process down.
       SERIALIZABLE_FATAL_EXCEPTION_CLASSES = [SystemExit, SignalException].freeze
 
+      # Placeholder emitted by #serialize_value_for_message in place of a value
+      # whose identifier or type matches the redaction configuration. This
+      # mirrors, for the human-readable log-probe message path, the
+      # notCapturedReason: "redactedIdent"/"redactedType" gating that
+      # #serialize_value applies on the snapshot path.
+      REDACTED_VALUE_FOR_MESSAGE = "[redacted]"
+
       # Third-party library integration / custom serializers.
       #
       # Dynamic instrumentation has limited payload sizes, and for efficiency
@@ -375,9 +382,17 @@ module Datadog
       #
       # We also use the Ruby-like syntax for symbols, which don't exist
       # in other languages.
-      def serialize_value_for_message(value, depth = 1)
+      #
+      # +name+, when given, is the identifier the template expression
+      # references at its top level; a redacted identifier yields the
+      # redaction placeholder, mirroring #serialize_value on the snapshot path.
+      def serialize_value_for_message(value, depth: 1, name: nil)
         # This method is more verbose than "normal" Ruby code to avoid
         # array allocations.
+
+        return REDACTED_VALUE_FOR_MESSAGE if redactor.redact_type?(value)
+        return REDACTED_VALUE_FOR_MESSAGE if name && redactor.redact_identifier?(name)
+
         case value
         when NilClass
           "nil"
@@ -398,7 +413,7 @@ module Datadog
             value = value_
           end
           "[" + value.map do |item|
-            serialize_value_for_message(item, depth - 1)
+            serialize_value_for_message(item, depth: depth - 1)
           end.join(", ") + "]"
         when Hash
           return "..." if depth <= 0
@@ -413,7 +428,12 @@ module Datadog
             truncated = true
           end
           serialized = keys.map do |key|
-            "#{serialize_value_for_message(key, depth - 1)} => #{serialize_value_for_message(value[key], depth - 1)}"
+            serialized_value = if (String === key || Symbol === key) && redactor.redact_identifier?(key)
+              REDACTED_VALUE_FOR_MESSAGE
+            else
+              serialize_value_for_message(value[key], depth: depth - 1)
+            end
+            "#{serialize_value_for_message(key, depth: depth - 1)} => #{serialized_value}"
           end
           if truncated
             serialized[serialized.length] = serialized[serialized.length - 1]
@@ -435,7 +455,12 @@ module Datadog
           serialized = vars.map do |var|
             # +var+ here is always the instance variable name which is a
             # symbol, we do not need to run it through our serializer.
-            "#{var}=#{serialize_value_for_message(value.send(:instance_variable_get, var), depth - 1)}"
+            serialized_value = if redactor.redact_identifier?(var)
+              REDACTED_VALUE_FOR_MESSAGE
+            else
+              serialize_value_for_message(value.send(:instance_variable_get, var), depth: depth - 1)
+            end
+            "#{var}=#{serialized_value}"
           end
           if truncated
             serialized << serialized.last

data/lib/datadog/error_tracking/component.rb

@@ -154,7 +154,7 @@ module Datadog
         attributes = {
           "exception.type" => formatted_exception.type,
           "exception.message" => formatted_exception.message,
-          "exception.stacktrace" => formatted_exception.backtrace
+          "exception.stacktrace" => formatted_exception.backtrace,
         }
         Datadog::Tracing::SpanEvent.new("exception", attributes: attributes)
       end

data/lib/datadog/kit/appsec/events/v2.rb

@@ -19,7 +19,7 @@ module Datadog
           TELEMETRY_METRICS_EVENTS_INTO_TYPES = {
             LOGIN_SUCCESS_EVENT => "login_success",
             LOGIN_FAILURE_EVENT => "login_failure",
-            SIGNUP_EVENT => "signup"
+            SIGNUP_EVENT => "signup",
           }.freeze
 
           class << self
@@ -241,7 +241,7 @@ module Datadog
 
               tags = {
                 event_type: TELEMETRY_METRICS_EVENTS_INTO_TYPES[event],
-                sdk_version: TELEMETRY_METRICS_SDK_VERSION
+                sdk_version: TELEMETRY_METRICS_SDK_VERSION,
               }
               telemetry.inc(TELEMETRY_METRICS_NAMESPACE, TELEMETRY_METRICS_SDK_EVENT, 1, tags: tags)
             end

data/lib/datadog/open_feature/exposures/batch_builder.rb

@@ -12,7 +12,7 @@ module Datadog
         def payload_for(events)
           {
             context: @context,
-            exposures: events
+            exposures: events,
           }
         end
 

data/lib/datadog/open_feature/exposures/event.rb

@@ -23,18 +23,18 @@ module Datadog
             {
               timestamp: current_timestamp_ms,
               allocation: {
-                key: result.allocation_key
+                key: result.allocation_key,
               },
               flag: {
-                key: flag_key
+                key: flag_key,
               },
               variant: {
-                key: result.variant
+                key: result.variant,
               },
               subject: {
                 id: context.targeting_key,
-                attributes: extract_attributes(context)
-              }
+                attributes: extract_attributes(context),
+              },
             }.freeze
           end
 

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

@@ -83,7 +83,7 @@ module Datadog
             hostname: Datadog::Core::Environment::Platform.hostname,
             kernel_name: Datadog::Core::Environment::Platform.kernel_name,
             kernel_release: Datadog::Core::Environment::Platform.kernel_release,
-            kernel_version: Datadog::Core::Environment::Platform.kernel_version
+            kernel_version: Datadog::Core::Environment::Platform.kernel_version,
           }.freeze
         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/tasks/exec.rb

@@ -21,7 +21,7 @@ module Datadog
         #: () -> ::Array["-rdatadog/profiling/preload"]
         def rubyopts
           [
-            "-rdatadog/profiling/preload"
+            "-rdatadog/profiling/preload",
           ]
         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/symbol_database/extractor.rb

@@ -616,7 +616,7 @@ module Datadog
           language_specifics: {
             visibility: method_visibility(klass, method_name),
             method_type: method_type.to_s,
-            arity: method.arity
+            arity: method.arity,
           },
           symbols: extract_method_parameters(method)
         )
@@ -647,7 +647,7 @@ module Datadog
       # @param start_line [Integer] Fallback end_line if iseq unavailable
       # @return [Array(Array<Hash>, Integer), Array(nil, Integer)]
       def extract_targetable_lines(method, start_line)
-        iseq = RubyVM::InstructionSequence.of(method) # steep:ignore
+        iseq = RubyVM::InstructionSequence.of(method)
         unless iseq
           @logger.debug { "symdb: no iseq for #{method.name} (C extension or native), skipping targetable lines" }
           return [nil, start_line]
@@ -801,7 +801,7 @@ module Datadog
       # objects allocated to read `source_location` are not retained between
       # passes, so they can be GC'd as soon as the inner loop ends.
       def collect_method_names_by_file(mod)
-        result = Hash.new { |h, k| h[k] = [] } # steep:ignore
+        result = Hash.new { |h, k| h[k] = [] }
 
         # Module#instance_methods(false) already returns both public and protected
         # methods, so iterating it plus private_instance_methods covers all three
@@ -905,7 +905,7 @@ module Datadog
           current[:children][part] ||= {
             name: fqn, type: resolve_scope_type(fqn),
             children: {}, methods: [], mod: nil,
-            source_file: file_path, fqn: fqn
+            source_file: file_path, fqn: fqn,
           }
           current = current[:children][part]
         end
@@ -924,7 +924,7 @@ module Datadog
             type: (Class === mod) ? "CLASS" : "MODULE",
             children: {}, methods: [],
             mod: mod, source_file: file_path,
-            fqn: mod_name
+            fqn: mod_name,
           }
           current[:children][leaf_name] = leaf
         end
@@ -1043,7 +1043,7 @@ module Datadog
           language_specifics: {
             visibility: klass ? method_visibility(klass, method_name) : "public", # steep:ignore
             method_type: "instance",
-            arity: method.arity
+            arity: method.arity,
           },
           symbols: extract_method_parameters(method)
         )

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/dynamic/option.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "../../../core/telemetry/configuration_value"
+
 module Datadog
   module Tracing
     module Configuration
@@ -56,6 +58,8 @@ module Datadog
                 precedence: Core::Configuration::Option::Precedence::REMOTE_CONFIGURATION
               )
             end
+
+            Core::Telemetry::ConfigurationValue.convert(value)
           end
 
           protected

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

@@ -24,11 +24,11 @@ module Datadog
           def call(tracing_header_tags)
             # Modify the remote configuration value that it matches the
             # environment variable it configures.
-            tracing_header_tags&.map! do |hash|
+            parsed_header_tags = tracing_header_tags&.map do |hash|
               "#{hash["header"]}:#{hash["tag_name"]}"
             end
 
-            super
+            super(parsed_header_tags)
           end
         end
 
@@ -42,6 +42,7 @@ module Datadog
           def call(tracing_sampling_rate)
             super
             Datadog.send(:components).reconfigure_sampler
+            tracing_sampling_rate
           end
 
           protected
@@ -78,8 +79,9 @@ module Datadog
               tracing_sampling_rules = tracing_sampling_rules.to_json
             end
 
-            super
+            telemetry_value = super
             Datadog.send(:components).reconfigure_sampler
+            telemetry_value
           end
 
           protected

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/action_cable/events.rb

@@ -14,7 +14,7 @@ module Datadog
           ALL = [
             Events::Broadcast,
             Events::PerformAction,
-            Events::Transmit
+            Events::Transmit,
           ].freeze
 
           module_function

data/lib/datadog/tracing/contrib/action_mailer/events.rb

@@ -11,7 +11,7 @@ module Datadog
         module Events
           ALL = [
             Events::Process,
-            Events::Deliver
+            Events::Deliver,
           ].freeze
 
           module_function