DI: lift Context out of EL (#4949)

Co-authored-by: Oleg Pudeyev <[email protected]>

Author: 2 people

lib/datadog/di/boot.rb

@@ -5,6 +5,7 @@
 require_relative 'error'
 require_relative 'code_tracker'
 require_relative 'component'
+require_relative 'context'
 require_relative 'instrumenter'
 require_relative 'probe'
 require_relative 'probe_builder'

lib/datadog/di/context.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Datadog
+  module DI
+    # Contains local and instance variables used when evaluating
+    # expressions in DI Expression Language.
+    #
+    # @api private
+    class Context
+      def initialize(probe:, settings:, serializer:, locals: nil,
+        # In Ruby everything is a method, therefore we should always have
+        # a target self. However, if we are not capturing a snapshot,
+        # there is no need to pass in the target self.
+        target_self: nil,
+        path: nil, caller_locations: nil,
+        serialized_entry_args: nil,
+        return_value: nil, duration: nil, exception: nil)
+        @probe = probe
+        @settings = settings
+        @serializer = serializer
+        @locals = locals
+        @target_self = target_self
+        @path = path
+        @caller_locations = caller_locations
+        @serialized_entry_args = serialized_entry_args
+        @return_value = return_value
+        @duration = duration
+        @exception = exception
+      end
+
+      attr_reader :probe
+      attr_reader :settings
+      attr_reader :serializer
+      attr_reader :locals
+      attr_reader :target_self
+      # Actual path of the instrumented file.
+      attr_reader :path
+      # TODO check how many stack frames we should be keeping/sending,
+      # this should be all frames for enriched probes and no frames for
+      # non-enriched probes?
+      attr_reader :caller_locations
+      attr_reader :serialized_entry_args
+      # Return value for the method, for a method probe
+      attr_reader :return_value
+      # How long the method took to execute, for a method probe
+      attr_reader :duration
+      # Exception raised by the method, if any, for a method probe
+      attr_reader :exception
+
+      def serialized_locals
+        # TODO cache?
+        locals && serializer.serialize_vars(locals,
+          depth: probe.max_capture_depth || settings.dynamic_instrumentation.max_capture_depth,
+          attribute_count: probe.max_capture_attribute_count || settings.dynamic_instrumentation.max_capture_attribute_count,)
+      end
+
+      def fetch(var_name)
+        unless locals
+          # TODO return "undefined" instead?
+          return nil
+        end
+        locals[var_name.to_sym]
+      end
+
+      def fetch_ivar(var_name)
+        target_self.instance_variable_get(var_name)
+      end
+    end
+  end
+end

lib/datadog/di/el.rb

@@ -2,5 +2,4 @@
 
 require_relative 'el/expression'
 require_relative 'el/compiler'
-require_relative 'el/context'
 require_relative 'el/evaluator'

lib/datadog/di/el/context.rb

@@ -123,7 +123,7 @@ def hook_method(probe, &block)
             if condition = probe.condition
               begin
                 # This context will be recreated later, unlike for line probes.
-                context = EL::Context.new(
+                context = Context.new(
                   locals: serializer.combine_args(args, kwargs, self),
                   target_self: self,
                   probe: probe, settings: settings, serializer: serializer,
@@ -189,7 +189,7 @@ def hook_method(probe, &block)
               caller_locs = method_frame + caller_locations # steep:ignore
               # TODO capture arguments at exit
 
-              context = EL::Context.new(locals: nil, target_self: self,
+              context = Context.new(locals: nil, target_self: self,
                 probe: probe, settings: settings, serializer: serializer,
                 serialized_entry_args: serialized_entry_args,
                 caller_locations: caller_locs,
@@ -367,7 +367,7 @@ def hook_line(probe, &block)
 
             if continue
               if condition = probe.condition
-                context = EL::Context.new(
+                context = Context.new(
                   locals: Instrumenter.get_local_variables(tp),
                   target_self: tp.self,
                   probe: probe, settings: settings, serializer: serializer,
@@ -385,7 +385,7 @@ def hook_line(probe, &block)
               # want to run it if the callback won't be executed due to the
               # rate limit.
               # Thus the copy-paste of the creation call here.
-              context ||= EL::Context.new(
+              context ||= Context.new(
                 locals: Instrumenter.get_local_variables(tp),
                 target_self: tp.self,
                 probe: probe, settings: settings, serializer: serializer,

lib/datadog/di/instrumenter.rb

@@ -0,0 +1,52 @@
+module Datadog
+  module DI
+    class Context
+      @probe: untyped
+
+      @settings: untyped
+
+      @serializer: untyped
+
+      @locals: untyped
+
+      @target_self: untyped
+
+      @path: untyped
+
+      @caller_locations: untyped
+
+      @serialized_entry_args: untyped
+
+      @return_value: untyped
+
+      @duration: untyped
+
+      @exception: untyped
+
+      def initialize: (probe: untyped, settings: untyped, serializer: untyped, ?locals: untyped?, ?target_self: untyped?, ?path: untyped?, ?caller_locations: untyped?, ?serialized_entry_args: untyped?, ?return_value: untyped?, ?duration: untyped?, ?exception: untyped?) -> void
+
+      attr_reader probe: untyped
+
+      attr_reader settings: untyped
+
+      attr_reader serializer: untyped
+
+      attr_reader locals: untyped
+
+      attr_reader target_self: untyped
+      attr_reader path: untyped
+      attr_reader caller_locations: untyped
+
+      attr_reader serialized_entry_args: untyped
+      attr_reader return_value: untyped
+      attr_reader duration: untyped
+      attr_reader exception: untyped
+
+      def serialized_locals: () -> untyped
+
+      def fetch: (untyped var_name) -> (nil | untyped)
+
+      def fetch_ivar: (untyped var_name) -> untyped
+    end
+  end
+end

sig/datadog/di/context.rbs

@@ -57,7 +57,7 @@ module Datadog
 
       public
       def install_pending_line_probes: (untyped path) -> untyped
-      def probe_executed_callback: (EL::Context context) -> untyped
+      def probe_executed_callback: (Context context) -> untyped
       attr_reader definition_trace_point: untyped
     end
   end

sig/datadog/di/el/context.rbs

@@ -19,15 +19,15 @@ module Datadog
 
       def build_errored: (Probe probe, Exception exception) -> Hash[Symbol,untyped]
 
-      def build_executed: (EL::Context context) -> Hash[Symbol,untyped]
+      def build_executed: (Context context) -> Hash[Symbol,untyped]
 
-      def build_snapshot: (EL::Context context) -> Hash[Symbol,untyped]
+      def build_snapshot: (Context context) -> Hash[Symbol,untyped]
 
       def build_status: (Probe probe, message: untyped, status: untyped) -> Hash[Symbol,untyped]
 
       def format_caller_locations: (Array[untyped] callers) -> Array[Hash[Symbol,untyped]]
 
-      def evaluate_template: (untyped template, EL::Context context) -> [String, Array[String]]
+      def evaluate_template: (untyped template, Context context) -> [String, Array[String]]
 
       def timestamp_now: () -> Integer
 

sig/datadog/di/probe_manager.rbs

@@ -46,7 +46,7 @@ class ELTestIvarClass
           end
 
           let(:context) do
-            Datadog::DI::EL::Context.new(locals: locals, target_self: target,
+            Datadog::DI::Context.new(locals: locals, target_self: target,
               probe: nil, settings: nil, serializer: nil)
           end