datadog 2.47.0 → 2.48.0

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

@@ -12,8 +12,29 @@ module Datadog
       # @api private
       class Evaluator
         # Maximum wall-clock time allowed for evaluating a single `matches`
-        # operator.
-        MATCHES_TIMEOUT_SECONDS = 0.5
+        # operator. Wall clock, while the evaluation budget is thread CPU
+        # time: the regexp engine's `timeout:` keyword and Timeout.timeout
+        # offer no CPU-time mode.
+        MATCHES_TIMEOUT_SECONDS = 0.05
+
+        MATCHES_TIMEOUT_MESSAGE = "matches operator timeout"
+
+        # Number of collection items processed between cooperative
+        # evaluation-deadline checks; evaluation aborts within one
+        # interval's worth of items past the deadline. A `matches`
+        # invocation can spend MATCHES_TIMEOUT_SECONDS of wall time, so
+        # #matches and #matches_compiled check the deadline before each
+        # match; a predicate that runs `matches` per item therefore
+        # adds at most the one match in flight when the deadline
+        # passes to the overshoot.
+        EVALUATION_DEADLINE_CHECK_INTERVAL = 64
+
+        # Built-in Array#each and Hash#each, resolved once at load and
+        # bound per invocation: the collection operators' iteration then
+        # dispatches no customer each override during probe evaluation.
+        ARRAY_EACH = Array.instance_method(:each)
+        HASH_EACH = Hash.instance_method(:each)
+        private_constant :ARRAY_EACH, :HASH_EACH
 
         # @param regexps [Array<Regexp>] Regexps precompiled from literal
         #   `matches` patterns, looked up by index by #matches_compiled.
@@ -25,12 +46,110 @@ module Datadog
 
         attr_reader :regexps
 
-        def ref(var)
-          @context.fetch(var)
+        # Raises DI::Error::EvaluationTimeout when the evaluation deadline
+        # has been exceeded, aborting evaluation cooperatively.
+        #
+        # @param evaluation_deadline [Float] invocation-local evaluation
+        #   deadline, passed from the compiled #evaluate into the operator
+        #   calls.
+        # @return [void]
+        # @raise [DI::Error::EvaluationTimeout] the deadline has been exceeded.
+        def raise_if_evaluation_deadline_exceeded(evaluation_deadline)
+          if self.class.evaluation_deadline_exceeded?(evaluation_deadline)
+            raise DI::Error::EvaluationTimeout
+          end
+        end
+        private :raise_if_evaluation_deadline_exceeded
+
+        # Raises DI::Error::EvaluationTimeout when +item_index+ falls on
+        # a cooperative check boundary and the evaluation deadline has
+        # been exceeded. The thread CPU clock is read only at every
+        # EVALUATION_DEADLINE_CHECK_INTERVAL-th item, so an already-exceeded
+        # deadline raises at the first boundary at or after it passes.
+        #
+        # @param item_index [Integer] zero-based index of the collection
+        #   element being processed.
+        # @param evaluation_deadline [Float] invocation-local evaluation
+        #   deadline, passed from the compiled #evaluate into the operator
+        #   calls.
+        # @return [void]
+        # @raise [DI::Error::EvaluationTimeout] a check boundary was reached
+        #   with the deadline exceeded.
+        def raise_if_deadline_check_due_and_exceeded(item_index, evaluation_deadline)
+          if (item_index % EVALUATION_DEADLINE_CHECK_INTERVAL).zero?
+            raise_if_evaluation_deadline_exceeded(evaluation_deadline)
+          end
+        end
+        private :raise_if_deadline_check_due_and_exceeded
+
+        # Yields the evaluation values for one collection element — the
+        # item alone for an Array element, or the [key, value] pair as
+        # @it together with the @key and the @value for a Hash element —
+        # iterating through the built-in iteration methods bound per
+        # invocation and performing the interval-gated evaluation-deadline
+        # check and its counter advance between elements.
+        #
+        # @param collection [Array, Hash] collection whose elements the
+        #   block receives.
+        # @param evaluation_deadline [Float] invocation-local evaluation deadline.
+        # @param operator_name [String] name of the invoking collection
+        #   operator, reported in the bad-collection-type error.
+        # @yield [current_item, current_key, current_value] evaluation
+        #   values for one element.
+        # @return [void]
+        # @raise [DI::Error::EvaluationTimeout] the evaluation deadline was
+        #   exceeded mid-iteration.
+        # @raise [DI::Error::ExpressionEvaluationError] +collection+ is
+        #   not an Array or a Hash.
+        def each_collection_item(collection, evaluation_deadline, operator_name)
+          case collection
+          when Array
+            i = 0
+            ARRAY_EACH.bind(collection).call do |item|
+              raise_if_deadline_check_due_and_exceeded(i, evaluation_deadline)
+              i += 1
+              yield item, nil, nil
+            end
+          when Hash
+            i = 0
+            HASH_EACH.bind(collection).call do |key, value|
+              raise_if_deadline_check_due_and_exceeded(i, evaluation_deadline)
+              i += 1
+              yield [key, value], key, value
+            end
+          else
+            raise DI::Error::ExpressionEvaluationError, "Bad collection type for #{operator_name}: #{collection.class}"
+          end
+          nil
+        end
+        private :each_collection_item
+
+        # Returns whether the thread CPU clock has passed +evaluation_deadline+.
+        #
+        # @param evaluation_deadline [Float] the deadline to check.
+        # @return [Boolean] whether the deadline has been exceeded.
+        def self.evaluation_deadline_exceeded?(evaluation_deadline)
+          Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID, :float_second) >= evaluation_deadline
+        end
+
+        # Resolves the value of the local variable or argument +var+ from
+        # the evaluation +context+.
+        #
+        # @param context [Context] context holding the evaluation locals.
+        # @param var [Symbol, String] name of the local variable or argument.
+        # @return [Object] value of the local variable or argument.
+        def ref(context, var)
+          context.fetch(var)
         end
 
-        def iref(var)
-          @context.fetch_ivar(var)
+        # Resolves the value of the instance variable +var+ from the
+        # receiver of the evaluation +context+.
+        #
+        # @param context [Context] context holding the evaluation receiver.
+        # @param var [Symbol, String] name of the instance variable.
+        # @return [Object] value of the instance variable.
+        def iref(context, var)
+          context.fetch_ivar(var)
         end
 
         def len(var, var_name)
@@ -92,10 +211,14 @@ module Datadog
         #
         # @param haystack [String] string to match against.
         # @param needle [String] regexp source.
+        # @param evaluation_deadline [Float] invocation-local evaluation
+        #   deadline.
         # @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)
+        # @raise [DI::Error::EvaluationTimeout] the evaluation deadline was
+        #   exceeded before the match started, or the match exceeded
+        #   MATCHES_TIMEOUT_SECONDS.
+        def matches(haystack, needle, evaluation_deadline)
+          raise_if_evaluation_deadline_exceeded(evaluation_deadline)
           bounded_match?(Evaluator.compile_regexp(needle), haystack)
         end
 
@@ -104,10 +227,14 @@ module Datadog
         #
         # @param haystack [String] string to match against.
         # @param index [Integer] position of the precompiled Regexp in +regexps+.
+        # @param evaluation_deadline [Float] invocation-local evaluation
+        #   deadline.
         # @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)
+        # @raise [DI::Error::EvaluationTimeout] the evaluation deadline was
+        #   exceeded before the match started, or the match exceeded
+        #   MATCHES_TIMEOUT_SECONDS.
+        def matches_compiled(haystack, index, evaluation_deadline)
+          raise_if_evaluation_deadline_exceeded(evaluation_deadline)
           bounded_match?(regexps.fetch(index), haystack)
         end
 
@@ -117,18 +244,32 @@ module Datadog
         # @param re [Regexp] regexp to match against.
         # @param haystack [String] string to match against.
         # @return [Boolean] whether the haystack matches the regexp.
+        # @raise [DI::Error::EvaluationTimeout] the match exceeded
+        #   MATCHES_TIMEOUT_SECONDS.
         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)
+          rescue Regexp::TimeoutError
+            raise DI::Error::EvaluationTimeout.new(message: MATCHES_TIMEOUT_MESSAGE)
           end
         else
+          # Raised by Timeout.timeout in the matching thread. A dedicated
+          # class because Timeout.timeout passes a positional message,
+          # which EvaluationTimeout does not accept, and because rescuing
+          # Timeout::Error would also catch an enclosing customer timeout.
+          class MatchTimeoutSignal < StandardError
+          end
+          private_constant :MatchTimeoutSignal
+
           def bounded_match?(re, haystack)
-            Timeout.timeout(MATCHES_TIMEOUT_SECONDS) do
+            Timeout.timeout(MATCHES_TIMEOUT_SECONDS, MatchTimeoutSignal) do
               re.match?(haystack)
             end
+          rescue MatchTimeoutSignal
+            raise DI::Error::EvaluationTimeout.new(message: MATCHES_TIMEOUT_MESSAGE)
           end
         end
         private :bounded_match?
@@ -171,50 +312,113 @@ module Datadog
           String === haystack && haystack.end_with?(needle)
         end
 
-        def all(collection, &block)
-          case collection
-          when Array
-            collection.all? do |item|
-              block.call(item)
-            end
-          when Hash
-            # For hashes, the expression language has both @it and
-            # @key/@value. Manufacture @it from the key and value.
-            collection.all? do |key, value|
-              block.call([key, value], key, value)
+        # Returns true when +block+ returns a truthy value for every element
+        # of +collection+.
+        #
+        # @param collection [Array, Hash] collection to test.
+        # @param evaluation_deadline [Float] invocation-local evaluation deadline.
+        # @return [Boolean] whether the block is satisfied by every element.
+        # @raise [DI::Error::EvaluationTimeout] the evaluation deadline was
+        #   exceeded mid-iteration.
+        # @raise [DI::Error::ExpressionEvaluationError] +collection+ is not
+        #   an Array or a Hash.
+        def all(collection, evaluation_deadline, &block)
+          result = true
+          each_collection_item(collection, evaluation_deadline, "all") do |current_item, current_key, current_value|
+            unless block.call(current_item, current_key, current_value)
+              result = false
+              break
             end
-          else
-            raise DI::Error::ExpressionEvaluationError, "Bad collection type for all: #{collection.class}"
           end
+          result
         end
 
-        def any(collection, &block)
-          case collection
-          when Array
-            collection.any? do |item|
-              block.call(item)
+        # Returns true when +block+ returns a truthy value for any element
+        # of +collection+.
+        #
+        # @param collection [Array, Hash] collection to test.
+        # @param evaluation_deadline [Float] invocation-local evaluation deadline.
+        # @return [Boolean] whether the block is satisfied by any element.
+        # @raise [DI::Error::EvaluationTimeout] the evaluation deadline was
+        #   exceeded mid-iteration.
+        # @raise [DI::Error::ExpressionEvaluationError] +collection+ is not
+        #   an Array or a Hash.
+        def any(collection, evaluation_deadline, &block)
+          result = false
+          each_collection_item(collection, evaluation_deadline, "any") do |current_item, current_key, current_value|
+            if block.call(current_item, current_key, current_value)
+              result = true
+              break
             end
-          when Hash
-            collection.any? do |key, value|
-              # For hashes, the expression language has both @it and
-              # @key/@value. Manufacture @it from the key and value.
+          end
+          result
+        end
+
+        # Returns the key-value pairs of the Hash +collection+ for which
+        # +block+ returns a truthy value.
+        #
+        # Ruby 3.1 changed Hash#select to reuse the stored key hashes
+        # instead of invoking the keys' hash methods and to keep a
+        # compare_by_identity hash's distinct-but-eql? keys and identity
+        # flag, so this Ruby filters through the built-in Hash#select
+        # bound per invocation. Earlier Rubies invoke the keys' hash
+        # methods and collapse identity hashes, so they keep the manual
+        # iteration through #each_collection_item, preserving the source
+        # hash's identity mode in the result.
+        if Datadog::RubyVersion.is?(">= 3.1")
+          # Built-in Hash#select, resolved once at load and bound per
+          # invocation: #filter's Hash iteration then dispatches no
+          # customer select override during probe evaluation.
+          HASH_SELECT = Hash.instance_method(:select)
+          private_constant :HASH_SELECT
+
+          def filter_hash(collection, evaluation_deadline, &block)
+            i = 0
+            HASH_SELECT.bind(collection).call do |key, value|
+              raise_if_deadline_check_due_and_exceeded(i, evaluation_deadline)
+              i += 1
               block.call([key, value], key, value)
+            end.to_h
+          end
+        else
+          # Core identity-mode check, resolved once at load and bound per
+          # invocation so that #filter dispatches no customer
+          # compare_by_identity? override during probe evaluation.
+          IDENTITY_MODE_CHECK = Hash.instance_method(:compare_by_identity?)
+          private_constant :IDENTITY_MODE_CHECK
+
+          def filter_hash(collection, evaluation_deadline, &block)
+            result = {}
+            result.compare_by_identity if IDENTITY_MODE_CHECK.bind(collection).call
+            each_collection_item(collection, evaluation_deadline, "filter") do |_current_item, current_key, current_value|
+              result[current_key] = current_value if block.call([current_key, current_value], current_key, current_value)
             end
-          else
-            raise DI::Error::ExpressionEvaluationError, "Bad collection type for any: #{collection.class}"
+            result
           end
         end
+        private :filter_hash
 
-        def filter(collection, &block)
+        # Returns the elements of +collection+ for which +block+ returns a
+        # truthy value: the selected items of an Array collection, and a
+        # Hash of the selected key-value pairs of a Hash collection.
+        #
+        # @param collection [Array, Hash] collection to filter.
+        # @param evaluation_deadline [Float] invocation-local evaluation deadline.
+        # @return [Array, Hash] the selected elements.
+        # @raise [DI::Error::EvaluationTimeout] the evaluation deadline was
+        #   exceeded mid-iteration.
+        # @raise [DI::Error::ExpressionEvaluationError] +collection+ is not
+        #   an Array or a Hash.
+        def filter(collection, evaluation_deadline, &block)
           case collection
           when Array
-            collection.select do |item|
-              block.call(item)
+            result = []
+            each_collection_item(collection, evaluation_deadline, "filter") do |current_item, current_key, current_value|
+              result << current_item if block.call(current_item, current_key, current_value)
             end
+            result
           when Hash
-            collection.select do |key, value|
-              block.call([key, value], key, value)
-            end.to_h
+            filter_hash(collection, evaluation_deadline, &block)
           else
             raise DI::Error::ExpressionEvaluationError, "Bad collection type for filter: #{collection.class}"
           end

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

@@ -27,8 +27,18 @@ module Datadog
           cls = Class.new(Evaluator)
           cls.class_exec do
             eval(<<-RUBY, Object.new.send(:binding), __FILE__, __LINE__ + 1) # standard:disable Security/Eval
-              def evaluate(context)
-                @context = context
+              # Evaluates the compiled expression against +context+ within
+              # the cooperative evaluation +evaluation_deadline+.
+              #
+              # @param context [Context] evaluation context (locals, instance
+              #   variables, and per-invocation special variables).
+              # @param evaluation_deadline [Float] invocation-local evaluation
+              #   deadline, as CLOCK_THREAD_CPUTIME_ID float seconds.
+              # @return [Object] the value the expression evaluates to.
+              # @raise [DI::Error::ExpressionEvaluationError] the expression
+              #   failed to evaluate, including the EvaluationTimeout
+              #   subclass raised when the deadline is exceeded.
+              def evaluate(context, evaluation_deadline)
                 #{compiled_expr}
               end
             RUBY
@@ -40,12 +50,32 @@ module Datadog
         attr_reader :evaluator
         attr_reader :redaction_identifier
 
-        def evaluate(context)
-          @evaluator.evaluate(context)
+        # Evaluates the expression against +context+.
+        #
+        # @param context [Context] evaluation context (locals, instance
+        #   variables, and per-invocation special variables).
+        # @param evaluation_deadline [Float] cooperative evaluation deadline, as
+        #   CLOCK_THREAD_CPUTIME_ID float seconds.
+        # @return [Object] the value the expression evaluates to.
+        # @raise [DI::Error::ExpressionEvaluationError] the expression failed
+        #   to evaluate; DI::Error::EvaluationTimeout, raised when the
+        #   evaluation deadline is exceeded, is a subclass.
+        def evaluate(context, evaluation_deadline:)
+          evaluator.evaluate(context, evaluation_deadline)
         end
 
-        def satisfied?(context)
-          !!evaluate(context)
+        # Returns whether the expression evaluates to a truthy value
+        # against +context+.
+        #
+        # @param context [Context] evaluation context.
+        # @param evaluation_deadline [Float] cooperative evaluation deadline, as
+        #   CLOCK_THREAD_CPUTIME_ID float seconds.
+        # @return [Boolean] whether the expression is satisfied.
+        # @raise [DI::Error::ExpressionEvaluationError] the expression failed
+        #   to evaluate; DI::Error::EvaluationTimeout, raised when the
+        #   evaluation deadline is exceeded, is a subclass.
+        def satisfied?(context, evaluation_deadline:)
+          !!evaluate(context, evaluation_deadline: evaluation_deadline)
         end
       end
     end

data/lib/datadog/di/error.rb

@@ -92,6 +92,22 @@ module Datadog
       # expressions.
       class ExpressionEvaluationError < Error
       end
+
+      # Raised when expression evaluation exceeds the configured
+      # evaluation CPU-time budget, or a `matches` operator exceeds its
+      # per-match wall-clock bound.
+      class EvaluationTimeout < ExpressionEvaluationError
+        # Default message for EvaluationTimeout exceptions.
+        DEFAULT_MESSAGE = "expression evaluation timeout"
+
+        # Builds the exception, defaulting +message+ to DEFAULT_MESSAGE.
+        #
+        # @param message [String] exception message.
+        # @return [void]
+        def initialize(message: DEFAULT_MESSAGE)
+          super(message)
+        end
+      end
     end
   end
 end

data/lib/datadog/di/guardrails_telemetry/reason.rb

@@ -16,8 +16,9 @@ module Datadog
         # process-wide rate limiter.
         RATE_LIMIT_GLOBAL = "rateLimitGlobal"
 
-        # Skip reason emitted when a capture expression evaluation exceeds
-        # the capture time budget.
+        # Skip reason emitted when an evaluation exceeds its time budget:
+        # a probe condition, a capture expression (including one skipped at
+        # the expired capture time budget), or a message template.
         EVALUATION_TIMEOUT = "evaluationTimeout"
 
         # Skip reason named in the +di: debug log when a condition-evaluation

data/lib/datadog/di/instrumenter.rb

@@ -83,7 +83,7 @@ module Datadog
       # @param settings [Datadog::Core::Configuration::Settings] tracer settings
       # @param serializer [Serializer] serializer for captured values
       # @param logger [DI::Logger] logger for instrumenter diagnostics
-      # @param guardrails_telemetry [GuardrailsTelemetry] emitter for the canonical rate-limit skip metric
+      # @param guardrails_telemetry [GuardrailsTelemetry] emitter for the canonical guardrail skip metrics
       # @param capture_expression_evaluator [CaptureExpressionEvaluator] evaluator for the probe's capture expressions
       # @param code_tracker [CodeTracker, nil] code tracker for line probe installation
       # @param telemetry [Datadog::Core::Telemetry::Component, nil] component instrumenter errors are reported through
@@ -554,7 +554,8 @@ module Datadog
                 target_self: target_self,
                 probe: probe, settings: settings, serializer: serializer,
               )
-              continue = condition.satisfied?(context)
+              continue = condition.satisfied?(context,
+                evaluation_deadline: serializer.evaluation_deadline)
             rescue Exception => exc # standard:disable Lint/RescueException
               Datadog::DI.reraise_if_fatal(exc)
               # Evaluation error exception can be raised for "expected"
@@ -563,6 +564,10 @@ module Datadog
               raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions &&
                 !exc.is_a?(DI::Error::ExpressionEvaluationError)
 
+              # An evaluation timeout is an internal budget abort, so it
+              # stays contained even under propagate_all_exceptions.
+              record_condition_evaluation_timeout(probe, exc)
+
               if context
                 # We want to report evaluation errors for conditions
                 # as probe snapshots. However, if we failed to create
@@ -605,7 +610,7 @@ module Datadog
             serialized_entry_args = if probe.capture_snapshot?
               serializer.serialize_args(args, kwargs, target_self,
                 deadline: serializer.serialization_deadline,
-                **probe.snapshot_serializer_limits(settings),)
+                **probe.snapshot_serializer_limits(settings))
             end
 
             entry_capture_expressions = nil
@@ -698,7 +703,7 @@ module Datadog
               entry_capture_expressions: entry_capture_expressions,
               entry_capture_evaluation_errors: entry_capture_evaluation_errors,
               caller_locations: caller_locs,
-              return_value: rv, duration: duration, exception: exc,)
+              return_value: rv, duration: duration, exception: exc)
 
             begin
               responder.probe_executed_callback(context)
@@ -788,12 +793,16 @@ module Datadog
         public :kwargs_from_splat
       end
 
-      # Trace point callback for a line probe.
+      # Trace point callback for a line probe hit. Evaluates the probe's
+      # condition, applies the per-probe rate limiter and the global rate
+      # limiter, then invokes the responder with the built context.
       #
-      # @param probe [Probe] the probe installed on this line
-      # @param iseq [RubyVM::InstructionSequence, nil] instruction sequence the trace point is targeted at, or nil when untargeted
-      # @param responder [#probe_executed_callback, #probe_condition_evaluation_failed_callback] callback target invoked with the built Context
-      # @param tp [TracePoint] the firing trace point
+      # @param probe [Probe] the probe the trace point was installed for.
+      # @param iseq [RubyVM::InstructionSequence, nil] instruction sequence of
+      #   the probe's target file, when the trace point is targeted.
+      # @param responder [#probe_executed_callback, #probe_condition_evaluation_failed_callback, #probe_disabled_callback]
+      #   callback target for the probe hit.
+      # @param tp [TracePoint] the trace point event that fired.
       # @return [void]
       def line_trace_point_callback(probe, iseq, responder, tp)
         di_start_time = Process.clock_gettime(Process::CLOCK_THREAD_CPUTIME_ID)
@@ -832,7 +841,8 @@ module Datadog
         if condition = probe.condition
           begin
             context = build_trace_point_context(probe, tp)
-            return unless condition.satisfied?(context)
+            return unless condition.satisfied?(context,
+              evaluation_deadline: serializer.evaluation_deadline)
           rescue Exception => exc # standard:disable Lint/RescueException
             Datadog::DI.reraise_if_fatal(exc)
             # Evaluation error exception can be raised for "expected"
@@ -841,6 +851,10 @@ module Datadog
             raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions &&
               !exc.is_a?(DI::Error::ExpressionEvaluationError)
 
+            # An evaluation timeout is an internal budget abort, so it
+            # stays contained even under propagate_all_exceptions.
+            record_condition_evaluation_timeout(probe, exc)
+
             if context
               # We want to report evaluation errors for conditions
               # as probe snapshots. However, if we failed to create
@@ -900,6 +914,21 @@ module Datadog
         nil
       end
 
+      # Records a condition evaluation timeout for +probe+ through the
+      # shared evaluation-timeout reporter. Does nothing when +exc+ is not
+      # an evaluation timeout.
+      #
+      # @param probe [Probe] the probe whose condition evaluation timed out.
+      # @param exc [Exception] the exception raised by the evaluation.
+      # @return [void]
+      def record_condition_evaluation_timeout(probe, exc)
+        DI.report_evaluation_timeout(
+          telemetry: telemetry, guardrails_telemetry: guardrails_telemetry, logger: logger,
+          probe: probe, kind: "condition", exc: exc,
+        )
+        nil
+      end
+
       def build_trace_point_context(probe, tp)
         stack = caller_locations
         # We have two helper methods being invoked from the trace point