datadog 2.28.0 → 2.41.0

data/lib/datadog/di/logger.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'forwardable'
+require "forwardable"
 
 module Datadog
   module DI

data/lib/datadog/di/preload.rb

@@ -4,7 +4,7 @@
 # enable dynamic instrumentation for third-party libraries used by the
 # application.
 
-require_relative 'base'
+require_relative "base"
 
 # Code tracking is required for line probes to work; see the comments
 # on the activate_tracking methods in di.rb for further details.

data/lib/datadog/di/probe.rb

@@ -34,11 +34,17 @@ module Datadog
     class Probe
       KNOWN_TYPES = %i[log].freeze
 
+      EVALUATE_AT_VALUES = %i[entry exit].freeze
+
       def initialize(id:, type:,
         file: nil, line_no: nil, type_name: nil, method_name: nil,
         template: nil, template_segments: nil,
         capture_snapshot: false, max_capture_depth: nil,
-        max_capture_attribute_count: nil, condition: nil,
+        max_capture_attribute_count: nil,
+        max_capture_collection_size: nil, max_capture_string_length: nil,
+        capture_expressions: [],
+        evaluate_at: nil,
+        condition: nil,
         rate_limit: nil)
         # Perform some sanity checks here to detect unexpected attribute
         # combinations, in order to not do them in subsequent code.
@@ -81,9 +87,17 @@ module Datadog
         @capture_snapshot = !!capture_snapshot
         @max_capture_depth = max_capture_depth
         @max_capture_attribute_count = max_capture_attribute_count
+        @max_capture_collection_size = max_capture_collection_size
+        @max_capture_string_length = max_capture_string_length
+        @capture_expressions = capture_expressions || []
+        evaluate_at = :exit if evaluate_at.nil?
+        unless EVALUATE_AT_VALUES.include?(evaluate_at)
+          raise ArgumentError, "Unknown evaluate_at value: #{evaluate_at.inspect} (expected one of #{EVALUATE_AT_VALUES.inspect})"
+        end
+        @evaluate_at = evaluate_at
         @condition = condition
 
-        @rate_limit = rate_limit || (@capture_snapshot ? 1 : 5000)
+        @rate_limit = rate_limit || ((@capture_snapshot || !@capture_expressions.empty?) ? 1 : 5000)
         @rate_limiter = Datadog::Core::TokenBucket.new(@rate_limit)
 
         # At most one report per second.
@@ -97,6 +111,7 @@ module Datadog
         end
 
         @emitting_notified = false
+        @enabled = true
       end
 
       attr_reader :id
@@ -119,6 +134,14 @@ module Datadog
       # the global default will be used.
       attr_reader :max_capture_attribute_count
 
+      attr_reader :max_capture_collection_size
+
+      attr_reader :max_capture_string_length
+
+      attr_reader :capture_expressions
+
+      attr_reader :evaluate_at
+
       # Rate limit in effect, in invocations per second. Always present.
       attr_reader :rate_limit
 
@@ -139,6 +162,29 @@ module Datadog
         @capture_snapshot
       end
 
+      def capture_expressions?
+        !@capture_expressions.empty?
+      end
+
+      def evaluate_at_entry?
+        evaluate_at == :entry
+      end
+
+      # Capture-expression mode: the probe captures expressions but not a full
+      # snapshot. Snapshot capture serializes its own values, so expression
+      # capture only runs when a snapshot is not being taken.
+      def capture_expressions_only?
+        capture_expressions? && !capture_snapshot?
+      end
+
+      def capture_entry_expressions?
+        capture_expressions_only? && evaluate_at_entry?
+      end
+
+      def snapshot_serializer_limits(settings)
+        CaptureLimits.resolve(expr_limits: nil, probe: self, settings: settings)
+      end
+
       # Returns whether the probe is a line probe.
       #
       # Method probes may still specify a file name (to aid in locating the
@@ -170,6 +216,20 @@ module Datadog
         line_no
       end
 
+      # Returns the method name associated with the probe, raising
+      # Error::MissingMethodName if the probe does not have a method name
+      # associated with it.
+      #
+      # This method is used by instrumentation driver to ensure a method name
+      # that is passed into the instrumentation logic is actually a method name
+      # and not nil.
+      def method_name!
+        if method_name.nil?
+          raise Error::MissingMethodName, "Probe #{id} does not have a method name associated with it"
+        end
+        method_name
+      end
+
       # Source code location of the probe, for diagnostic reporting.
       def location
         if method?
@@ -219,13 +279,21 @@ module Datadog
       end
 
       def executed_on_line?
-        !!@executed_on_line
+        !!(defined?(@executed_on_line) && @executed_on_line)
       end
 
       def executed_on_line!
         # TODO lock?
         @executed_on_line = true
       end
+
+      def enabled?
+        @enabled
+      end
+
+      def disable!
+        @enabled = false
+      end
     end
   end
 end

data/lib/datadog/di/probe_builder.rb

@@ -3,7 +3,9 @@
 # rubocop:disable Lint/AssignmentInCondition
 
 require_relative "probe"
-require_relative 'el'
+require_relative "capture_expression"
+require_relative "capture_limits"
+require_relative "el"
 
 module Datadog
   module DI
@@ -22,21 +24,36 @@ module Datadog
     module ProbeBuilder
       # Steep: https://github.com/soutaro/steep/issues/363
       PROBE_TYPES = { # steep:ignore IncompatibleAssignment
-        'LOG_PROBE' => :log,
+        "LOG_PROBE" => :log,
       }.freeze
 
       module_function
 
-      def build_from_remote_config(config)
+      CAPTURE_EXPRESSION_NAME_PATTERN = /\A[a-zA-Z0-9_?]+\z/
+
+      EVALUATE_AT_STRINGS = {
+        "ENTRY" => :entry,
+        "EXIT" => :exit,
+        "DEFAULT" => :exit,
+      }.freeze
+
+      def build_from_remote_config(config, logger:)
         # The validations here are not yet comprehensive.
-        type = config.fetch('type')
+        type = config.fetch("type")
         type_symbol = PROBE_TYPES[type] or raise ArgumentError, "Unrecognized probe type: #{type}"
-        cond = if cond_spec = config['when']
-          unless cond_spec['dsl'] && cond_spec['json']
+        cond = if cond_spec = config["when"]
+          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)
+        if !!config["captureSnapshot"] && !capture_expressions.empty?
+          logger.debug do
+            "di: probe #{config["id"]}: captureSnapshot=true wins over captureExpressions (n=#{capture_expressions.size})"
+          end
         end
         Probe.new(
           id: config.fetch("id"),
@@ -50,28 +67,94 @@ module Datadog
           # We should not be using the template for anything - we instead
           # use +segments+ - but keep the template for debugging.
           template: config["template"],
-          template_segments: build_template_segments(config['segments']),
+          template_segments: build_template_segments(config["segments"]),
           capture_snapshot: !!config["captureSnapshot"],
           max_capture_depth: config["capture"]&.[]("maxReferenceDepth"),
           max_capture_attribute_count: config["capture"]&.[]("maxFieldCount"),
+          max_capture_collection_size: config["capture"]&.[]("maxCollectionSize"),
+          max_capture_string_length: config["capture"]&.[]("maxLength"),
+          capture_expressions: capture_expressions,
+          evaluate_at: parse_evaluate_at(config["evaluateAt"], config["id"], logger),
           rate_limit: config["sampling"]&.[]("snapshotsPerSecond"),
           condition: cond,
         )
       rescue KeyError => exc
-        raise ArgumentError, "Malformed remote configuration entry for probe: #{exc.class}: #{exc}: #{config}"
+        raise ArgumentError, "Malformed remote configuration entry for probe: #{exc.class}: #{exc.message}: #{config}"
+      end
+
+      def build_capture_expressions(raw)
+        return [] if raw.nil?
+        unless Array === raw
+          raise ArgumentError, "captureExpressions must be an array, got: #{raw.class}"
+        end
+        return [] if raw.empty?
+        raw.map do |entry|
+          unless Hash === entry
+            raise ArgumentError, "captureExpressions entry must be a hash, got: #{entry.class}"
+          end
+          name = entry["name"]
+          unless String === name && CAPTURE_EXPRESSION_NAME_PATTERN.match?(name)
+            raise ArgumentError, "captureExpressions entry name missing or invalid (must match #{CAPTURE_EXPRESSION_NAME_PATTERN.inspect}): #{name.inspect}"
+          end
+          expr_spec = entry["expr"]
+          unless Hash === expr_spec && expr_spec["dsl"] && expr_spec["json"]
+            raise ArgumentError, "captureExpressions entry #{name}: missing or malformed expr"
+          end
+          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
+      end
+
+      def dedup_capture_expressions(capture_expressions, probe_id, logger)
+        return capture_expressions if capture_expressions.size < 2
+        by_name = {}
+        capture_expressions.each do |capture_expression|
+          by_name[capture_expression.name] = capture_expression
+        end
+        return capture_expressions if by_name.size == capture_expressions.size
+        logger.debug do
+          "di: probe #{probe_id}: collapsed duplicate captureExpressions names, kept last per name (#{capture_expressions.size} -> #{by_name.size})"
+        end
+        by_name.values
+      end
+
+      def build_capture_limits(raw)
+        return nil if raw.nil?
+        unless Hash === raw
+          raise ArgumentError, "capture-expression entry capture must be a hash, got: #{raw.class}"
+        end
+        CaptureLimits.new(
+          max_reference_depth: raw["maxReferenceDepth"],
+          max_collection_size: raw["maxCollectionSize"],
+          max_length: raw["maxLength"],
+          max_field_count: raw["maxFieldCount"],
+        )
+      end
+
+      def parse_evaluate_at(raw, probe_id, logger)
+        return :exit if raw.nil?
+        EVALUATE_AT_STRINGS[raw] || begin
+          logger.debug do
+            "di: probe #{probe_id}: unrecognized evaluateAt value #{raw.inspect}, defaulting to :exit"
+          end
+          :exit
+        end
       end
 
       def build_template_segments(segments)
         segments&.map do |segment|
           if Hash === segment
-            if str = segment['str']
+            if str = segment["str"]
               str
-            elsif ast = segment['json']
-              unless dsl = segment['dsl']
+            elsif ast = segment["json"]
+              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_file_loader/railtie.rb

@@ -6,7 +6,7 @@ module Datadog
       # Railtie class initializes dynamic instrumentation contrib code
       # in Rails environments.
       class Railtie < Rails::Railtie
-        initializer 'datadog.dynamic_instrumentation.load_probe_file' do |app|
+        initializer "datadog.dynamic_instrumentation.load_probe_file" do |app|
           ProbeFileLoader.load_now
         end
       end

data/lib/datadog/di/probe_file_loader.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
-require 'json'
+require "json"
+
+require_relative "fatal_exceptions"
 
 module Datadog
   module DI
     module ProbeFileLoader
       module_function def load_now_or_later
         if Datadog::Core::Contrib::Rails::Utils.railtie_supported?
-          Datadog.logger.debug('di: loading probe_file_loader/railtie')
-          require_relative 'probe_file_loader/railtie'
+          Datadog.logger.debug("di: loading probe_file_loader/railtie")
+          require_relative "probe_file_loader/railtie"
         else
           load_now
         end
@@ -20,7 +22,7 @@ module Datadog
       module_function def load_now
         should_propagate = false
 
-        probe_file_path = DATADOG_ENV['DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE']
+        probe_file_path = DATADOG_ENV["DD_DYNAMIC_INSTRUMENTATION_PROBE_FILE"]
         if probe_file_path.nil? || probe_file_path.empty?
           return
         end
@@ -46,28 +48,31 @@ module Datadog
               component.telemetry&.report(exc, description: "Line probe is targeting a loaded file that is not in code tracker")
 
               payload = component.probe_notification_builder.build_errored(probe, exc)
-              component.probe_notifier_worker.add_status(payload)
-            rescue => exc
+              component.probe_notifier_worker.add_status(payload, probe: probe)
+            rescue Exception => exc # standard:disable Lint/RescueException
+              Datadog::DI.reraise_if_fatal(exc)
               raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
 
-              component.logger.debug { "di: unhandled exception adding #{probe.type} probe at #{probe.location} (#{probe.id}) in DI probe file loader: #{exc.class}: #{exc}" }
+              component.logger.debug { "di: unhandled exception adding #{probe.type} probe at #{probe.location} (#{probe.id}) in DI probe file loader: #{exc.class}: #{exc.message}" }
               component.telemetry&.report(exc, description: "Unhandled exception adding probe in DI probe file loader")
 
               # TODO test this path
               payload = component.probe_notification_builder.build_errored(probe, exc)
-              component.probe_notifier_worker.add_status(payload)
+              component.probe_notifier_worker.add_status(payload, probe: probe)
             end
           end
-        rescue => exc
+        rescue Exception => exc # standard:disable Lint/RescueException
+          Datadog::DI.reraise_if_fatal(exc)
           if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
             should_propagate = true
             raise
           end
 
-          component.logger.debug { "di: unhandled exception handling a probe in DI probe file loader: #{exc.class}: #{exc}" }
+          component.logger.debug { "di: unhandled exception handling a probe in DI probe file loader: #{exc.class}: #{exc.message}" }
           component.telemetry&.report(exc, description: "Unhandled exception handling probe in DI probe file loader")
         end
-      rescue
+      rescue Exception => exc # standard:disable Lint/RescueException
+        Datadog::DI.reraise_if_fatal(exc)
         # We should generally never get here, but if component tree
         # initialization fails for some unexpected reason, don't nuke
         # the customer application.