datadog 2.37.0 → 2.38.0

data/lib/datadog/di/serializer.rb

@@ -131,9 +131,12 @@ module Datadog
       # in upstream code.
       def serialize_args(args, kwargs, target_self,
         depth: settings.dynamic_instrumentation.max_capture_depth,
-        attribute_count: settings.dynamic_instrumentation.max_capture_attribute_count)
+        attribute_count: settings.dynamic_instrumentation.max_capture_attribute_count,
+        length: nil,
+        collection_size: nil)
         combined = combine_args(args, kwargs, target_self)
-        serialize_vars(combined, depth: depth, attribute_count: attribute_count)
+        serialize_vars(combined, depth: depth, attribute_count: attribute_count,
+          length: length, collection_size: collection_size)
       end
 
       # Serializes variables captured by a line probe.
@@ -142,9 +145,12 @@ module Datadog
       # of executed code.
       def serialize_vars(vars,
         depth: settings.dynamic_instrumentation.max_capture_depth,
-        attribute_count: settings.dynamic_instrumentation.max_capture_attribute_count)
+        attribute_count: settings.dynamic_instrumentation.max_capture_attribute_count,
+        length: nil,
+        collection_size: nil)
         vars.each_with_object({}) do |(k, v), agg|
-          agg[k] = serialize_value(v, name: k, depth: depth, attribute_count: attribute_count)
+          agg[k] = serialize_value(v, name: k, depth: depth, attribute_count: attribute_count,
+            length: length, collection_size: collection_size)
         end
       end
 
@@ -163,6 +169,8 @@ module Datadog
       def serialize_value(value, name: nil,
         depth: settings.dynamic_instrumentation.max_capture_depth,
         attribute_count: nil,
+        length: nil,
+        collection_size: nil,
         type: nil)
         attribute_count ||= settings.dynamic_instrumentation.max_capture_attribute_count
         cls = type || value.class
@@ -235,7 +243,8 @@ module Datadog
             #
             # Truncate binary data BEFORE escaping to avoid cutting mid-escape-sequence.
             # For regular strings, the limit is applied to string length in characters.
-            max = settings.dynamic_instrumentation.max_capture_string_length
+            length ||= settings.dynamic_instrumentation.max_capture_string_length
+            max = length
 
             if value.encoding == Encoding::BINARY || !value.valid_encoding?
               # Truncate binary data BEFORE escaping to avoid cutting mid-escape-sequence
@@ -263,7 +272,8 @@ module Datadog
             if depth <= 0
               serialized.update(notCapturedReason: "depth")
             else
-              max = settings.dynamic_instrumentation.max_capture_collection_size
+              collection_size ||= settings.dynamic_instrumentation.max_capture_collection_size
+              max = collection_size
               if max != 0 && value.length > max
                 serialized.update(notCapturedReason: "collectionSize", size: value.length)
                 # same steep failure with array slices.
@@ -271,7 +281,7 @@ module Datadog
                 value = value[0...max] || []
               end
               entries = value.map do |elt|
-                serialize_value(elt, depth: depth - 1)
+                serialize_value(elt, depth: depth - 1, length: length, collection_size: collection_size, attribute_count: attribute_count)
               end
               serialized.update(elements: entries)
             end
@@ -279,7 +289,8 @@ module Datadog
             if depth <= 0
               serialized.update(notCapturedReason: "depth")
             else
-              max = settings.dynamic_instrumentation.max_capture_collection_size
+              collection_size ||= settings.dynamic_instrumentation.max_capture_collection_size
+              max = collection_size
               cur = 0
               entries = []
               value.each do |k, v|
@@ -288,7 +299,8 @@ module Datadog
                   break
                 end
                 cur += 1
-                entries << [serialize_value(k, depth: depth - 1), serialize_value(v, name: k, depth: depth - 1)]
+                entries << [serialize_value(k, depth: depth - 1, length: length, collection_size: collection_size, attribute_count: attribute_count),
+                  serialize_value(v, name: k, depth: depth - 1, length: length, collection_size: collection_size, attribute_count: attribute_count)]
               end
               serialized.update(entries: entries)
             end
@@ -327,7 +339,7 @@ module Datadog
                   break
                 end
                 cur += 1
-                fields[ivar] = serialize_value(value.instance_variable_get(ivar), name: ivar, depth: depth - 1)
+                fields[ivar] = serialize_value(value.instance_variable_get(ivar), name: ivar, depth: depth - 1, length: length, collection_size: collection_size, attribute_count: attribute_count)
               end
               serialized.update(fields: fields)
             end

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

@@ -170,11 +170,16 @@ module Datadog
 
             @wait_until_running_condition.wait(@wait_until_running_mutex, timeout_seconds)
 
+            # Not using `_native_is_running?(self) || raise(...)` here: `_native_is_running?` is declared
+            # to return `bool`, so steep infers the `||` expression as `bool` too and rejects it against
+            # this method's declared `true` return type. The explicit `if`/`else` type-checks correctly.
+            # rubocop:disable Style/RedundantCondition
             if self.class._native_is_running?(self)
               true
             else
               raise "Timeout waiting for #{self.class.name} to start (waited for #{timeout_seconds} seconds)"
             end
+            # rubocop:enable Style/RedundantCondition
           end
         end
 

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

@@ -45,9 +45,10 @@ module Datadog
           waiting_for_gvl_threshold_ns: 10_000_000,
           otel_context_enabled: false,
           native_filenames_enabled: true,
+          trigger_global_reset: true,
           **options
         )
-          new(
+          collector = new(
             recorder: recorder,
             max_frames: max_frames,
             tracer: tracer,
@@ -57,6 +58,13 @@ module Datadog
             native_filenames_enabled: native_filenames_enabled,
             **options,
           )
+
+          # By default, mirror what the CpuAndWallTimeWorker does when profiling starts: reset the global per-thread
+          # context state, which (among other things) resizes the per-thread sampling buffers to this collector's
+          # max_frames. Tests that need to control this explicitly can pass `trigger_global_reset: false`.
+          Testing._native_global_reset_per_thread_context(collector) if trigger_global_reset
+
+          collector
         end
 
         def inspect

data/lib/datadog/profiling/component.rb

@@ -226,6 +226,15 @@ module Datadog
           return false
         end
 
+        # Heap profiling relies on `ObjectSpace._id2ref`, which was removed on Ruby 4.1
+        # (https://bugs.ruby-lang.org/issues/22135).
+        if RubyVersion.is?(">= 4.1")
+          logger.warn(
+            "Heap profiling is currently incompatible with Ruby 4.1+ and has been disabled."
+          )
+          return false
+        end
+
         unless allocation_profiling_enabled
           logger.warn(
             "Heap profiling was requested but allocation profiling is not enabled. " \
@@ -244,6 +253,14 @@ module Datadog
 
         return false unless heap_profiling_enabled && heap_size_profiling_enabled
 
+        if RubyVersion.is?(">= 4")
+          logger.info(
+            "Heap live size profiling is currently incompatible with Ruby 4 and has been disabled. " \
+            "Heap live objects is not affected and remains enabled."
+          )
+          return false
+        end
+
         true
       end
 

data/lib/datadog/tracing/contrib/active_job/data_streams.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative '../../../data_streams'
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveJob
+        # Propagates Data Streams Monitoring pathway context through the serialized
+        # job payload, allowing produce (enqueue) and consume (perform) checkpoints
+        # to be connected across the process boundary.
+        #
+        # The DSM calls are rescued in isolation so a checkpoint failure can never
+        # break a job, while a genuine error raised by the underlying serialization
+        # still propagates.
+        #
+        # Only prepended on ActiveJob 5.0+, where `serialize`/`deserialize` are instance
+        # methods the framework routes through. ActiveJob 4.2 deserializes via a class
+        # method, so the pathway cannot be propagated there.
+        module DataStreams
+          def serialize
+            job_data = super
+            return job_data unless Datadog::DataStreams.enabled?
+
+            begin
+              Datadog::DataStreams.set_produce_checkpoint(
+                type: Ext::TAG_COMPONENT,
+                destination: queue_name,
+                auto_instrumentation: true
+              ) do |key, value|
+                job_data[key] = value
+              end
+            rescue => e
+              Datadog.logger.debug { "Error setting DSM produce checkpoint: #{e.class}: #{e.message}" }
+            end
+
+            job_data
+          end
+
+          def deserialize(job_data)
+            super
+
+            return unless Datadog::DataStreams.enabled?
+
+            begin
+              Datadog::DataStreams.set_consume_checkpoint(
+                type: Ext::TAG_COMPONENT,
+                source: queue_name,
+                auto_instrumentation: true
+              ) do |key|
+                job_data[key]
+              end
+            rescue => e
+              Datadog.logger.debug { "Error setting DSM consume checkpoint: #{e.class}: #{e.message}" }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_job/patcher.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../patcher'
+require_relative 'data_streams'
 require_relative 'ext'
 require_relative 'events'
 require_relative 'log_injection'
@@ -22,6 +23,7 @@ module Datadog
           def patch
             Events.subscribe!
             inject_log_correlation
+            inject_data_streams
           end
 
           def inject_log_correlation
@@ -33,6 +35,16 @@ module Datadog
               end
             end
           end
+
+          def inject_data_streams
+            # ActiveJob 4.2 deserializes jobs through a class method rather than the
+            # instance method, so the DSM pathway can only be propagated on 5.0+.
+            return if ::ActiveJob.gem_version < Gem::Version.new('5.0.0')
+
+            ::ActiveSupport.on_load(:active_job) do
+              prepend DataStreams
+            end
+          end
         end
       end
     end

data/lib/datadog/tracing/contrib/active_model_serializers/events/serialize.rb

@@ -18,10 +18,9 @@ module Datadog
 
             def supported?
               Gem.loaded_specs['active_model_serializers'] \
-                && (
-                  Gem.loaded_specs['active_model_serializers'].version >= Gem::Version.new('0.9') \
+                &&
+                Gem.loaded_specs['active_model_serializers'].version >= Gem::Version.new('0.9') \
                   && Gem.loaded_specs['active_model_serializers'].version < Gem::Version.new('0.10')
-                )
             end
 
             def event_name

data/lib/datadog/tracing/contrib/pg/instrumentation.rb

@@ -28,19 +28,19 @@ module Datadog
               end
             end
 
-            def exec_params(sql, params, *args, &block)
+            def exec_params(sql, *args, &block)
               return super unless enabled?
 
               trace(Ext::SPAN_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
-                super(sql_statement, params, *args, &wrapped_block)
+                super(sql_statement, *args, &wrapped_block)
               end
             end
 
-            def exec_prepared(statement_name, params, *args, &block)
+            def exec_prepared(statement_name, *args, &block)
               return super unless enabled?
 
               trace(Ext::SPAN_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
-                super(statement_name, params, *args, &wrapped_block)
+                super(statement_name, *args, &wrapped_block)
               end
             end
 
@@ -54,20 +54,20 @@ module Datadog
             end
 
             # async_exec_params is an alias to exec_params
-            def async_exec_params(sql, params, *args, &block)
+            def async_exec_params(sql, *args, &block)
               return super unless enabled?
 
               trace(Ext::SPAN_ASYNC_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
-                super(sql_statement, params, *args, &wrapped_block)
+                super(sql_statement, *args, &wrapped_block)
               end
             end
 
             # async_exec_prepared is an alias to exec_prepared
-            def async_exec_prepared(statement_name, params, *args, &block)
+            def async_exec_prepared(statement_name, *args, &block)
               return super unless enabled?
 
               trace(Ext::SPAN_ASYNC_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
-                super(statement_name, params, *args, &wrapped_block)
+                super(statement_name, *args, &wrapped_block)
               end
             end
 
@@ -79,19 +79,19 @@ module Datadog
               end
             end
 
-            def sync_exec_params(sql, params, *args, &block)
+            def sync_exec_params(sql, *args, &block)
               return super unless enabled?
 
               trace(Ext::SPAN_SYNC_EXEC_PARAMS, sql: sql, block: block) do |sql_statement, wrapped_block|
-                super(sql_statement, params, *args, &wrapped_block)
+                super(sql_statement, *args, &wrapped_block)
               end
             end
 
-            def sync_exec_prepared(statement_name, params, *args, &block)
+            def sync_exec_prepared(statement_name, *args, &block)
               return super unless enabled?
 
               trace(Ext::SPAN_SYNC_EXEC_PREPARED, statement_name: statement_name, block: block) do |_, wrapped_block|
-                super(statement_name, params, *args, &wrapped_block)
+                super(statement_name, *args, &wrapped_block)
               end
             end
 

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

@@ -56,7 +56,7 @@ module Datadog
               end
             end
 
-            following = (middleware.instance_variable_get('@app') if middleware.instance_variable_defined?('@app'))
+            following = (middleware.instance_variable_get(:@app) if middleware.instance_variable_defined?(:@app))
 
             retain_middleware_name(following)
           end

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

@@ -34,8 +34,8 @@ module Datadog
 
             def parse_opts(sql, opts, db_opts, dataset = nil)
               # Prepared statements don't provide their sql query in the +sql+ parameter.
-              if !sql.is_a?(String) && (dataset&.respond_to?(:prepared_sql) &&
-                (resolved_sql = dataset.prepared_sql))
+              if !sql.is_a?(String) && dataset&.respond_to?(:prepared_sql) &&
+                  (resolved_sql = dataset.prepared_sql)
                 # The dataset contains the resolved SQL query and prepared statement name.
                 prepared_name = dataset.prepared_statement_name
                 sql = resolved_sql

data/lib/datadog/tracing/contrib/sidekiq/server_tracer.rb

@@ -69,7 +69,7 @@ module Datadog
 
               args = job['args']
               if args && !args.empty?
-                span.set_tag(Ext::TAG_JOB_ARGS, Contrib::Utils::Quantization::HashFormatter.format(args, (@quantize[:args] || {})))
+                span.set_tag(Ext::TAG_JOB_ARGS, Contrib::Utils::Quantization::HashFormatter.format(args, @quantize[:args] || {}))
               end
 
               yield

data/lib/datadog/tracing/contrib/sinatra/framework.rb

@@ -81,7 +81,7 @@ module Datadog
           # The block gets passed prepared arguments for the caller to decide
           # how to insert.
           def self.insert_middleware(builder, middleware, args, block)
-            use = builder.instance_variable_get('@use')
+            use = builder.instance_variable_get(:@use)
             wrapped = wrap_middleware(middleware, *args, &block)
 
             # Makes the insert idempotent

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

@@ -117,7 +117,7 @@ module Datadog
 
           root_span.set_tag(
             Tracing::Metadata::Ext::Distributed::TAG_KNUTH_SAMPLING_RATE,
-            format('%.6f', (rate * 1e6).round / 1e6.to_f).sub(/\.?0+\z/, '')
+            format('%.6f', (rate * 1e6).round / 1e6).sub(/\.?0+\z/, '')
           )
         end
 

data/lib/datadog/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datadog
 version: !ruby/object:Gem::Version
-  version: 2.37.0
+  version: 2.38.0
 platform: ruby
 authors:
 - Datadog, Inc.
@@ -32,7 +32,7 @@ dependencies:
         version: '3.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.5.2
+        version: 3.5.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,7 @@ dependencies:
         version: '3.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.5.2
+        version: 3.5.3
 - !ruby/object:Gem::Dependency
   name: libddwaf
   requirement: !ruby/object:Gem::Requirement
@@ -520,6 +520,9 @@ files:
 - lib/datadog/di.rb
 - lib/datadog/di/base.rb
 - lib/datadog/di/boot.rb
+- lib/datadog/di/capture_expression.rb
+- lib/datadog/di/capture_expression_evaluator.rb
+- lib/datadog/di/capture_limits.rb
 - lib/datadog/di/code_tracker.rb
 - lib/datadog/di/component.rb
 - lib/datadog/di/configuration.rb
@@ -703,6 +706,7 @@ files:
 - lib/datadog/tracing/contrib/action_view/patcher.rb
 - lib/datadog/tracing/contrib/action_view/utils.rb
 - lib/datadog/tracing/contrib/active_job/configuration/settings.rb
+- lib/datadog/tracing/contrib/active_job/data_streams.rb
 - lib/datadog/tracing/contrib/active_job/event.rb
 - lib/datadog/tracing/contrib/active_job/events.rb
 - lib/datadog/tracing/contrib/active_job/events/discard.rb
@@ -1153,8 +1157,8 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.37.0/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.37.0
+  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.38.0/CHANGELOG.md
+  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.38.0
 post_install_message: 'JRuby support in the datadog gem is deprecated. Details: https://dtdg.co/jruby-deprecation'
 rdoc_options: []
 require_paths: