datadog 2.7.0 → 2.8.0

data/lib/datadog/di/component.rb

@@ -24,7 +24,9 @@ module Datadog
 
           return unless environment_supported?(settings)
 
-          new(settings, agent_settings, Datadog.logger, code_tracker: DI.code_tracker, telemetry: telemetry)
+          new(settings, agent_settings, Datadog.logger, code_tracker: DI.code_tracker, telemetry: telemetry).tap do |component|
+            DI.add_current_component(component)
+          end
         end
 
         def build!(settings, agent_settings, telemetry: nil)
@@ -99,6 +101,8 @@ module Datadog
       # was replaced by a new instance, the new instance of it wouldn't have
       # any of the already loaded code tracked.
       def shutdown!(replacement = nil)
+        DI.remove_current_component(self)
+
         probe_manager.clear_hooks
         probe_manager.close
         probe_notifier_worker.stop

data/lib/datadog/di/contrib/active_record.rb

@@ -5,6 +5,7 @@ Datadog::DI::Serializer.register(condition: lambda { |value| ActiveRecord::Base
   # steep:ignore:start
   value_to_serialize = {
     attributes: value.attributes,
+    new_record: value.new_record?,
   }
   serializer.serialize_value(value_to_serialize, depth: depth ? depth - 1 : nil, type: value.class)
   # steep:ignore:end

data/lib/datadog/di/init.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Require 'datadog/di/init' early in the application boot process to
+# enable dynamic instrumentation for third-party libraries used by the
+# application.
+
+require_relative '../tracing'
+require_relative '../tracing/contrib'
+require_relative '../di'
+
+# Code tracking is required for line probes to work; see the comments
+# on the activate_tracking methods in di.rb for further details.
+#
+# Unlike di.rb which conditionally activates tracking only if the
+# DD_DYNAMIC_INSTRUMENTATION_ENABLED environment variable is set, this file
+# always activates tracking. This is because this file is explicitly loaded
+# by customer applications for the purpose of enabling code tracking
+# early in application boot process (i.e., before datadog library itself
+# is loaded).
+Datadog::DI.activate_tracking

data/lib/datadog/di/instrumenter.rb

@@ -92,34 +92,89 @@ module Datadog
         cls = symbolize_class_name(probe.type_name)
         serializer = self.serializer
         method_name = probe.method_name
-        target_method = cls.instance_method(method_name)
-        loc = target_method.source_location
+        loc = begin
+          cls.instance_method(method_name).source_location
+        rescue NameError
+          # The target method is not defined.
+          # This could be because it will be explicitly defined later
+          # (since classes can be reopened in Ruby)
+          # or the method is virtual (provided by a method_missing handler).
+          # In these cases we do not have a source location for the
+          # target method here.
+        end
         rate_limiter = probe.rate_limiter
+        settings = self.settings
 
         mod = Module.new do
-          define_method(method_name) do |*args, **kwargs| # steep:ignore
+          define_method(method_name) do |*args, **kwargs, &target_block| # steep:ignore
             if rate_limiter.nil? || rate_limiter.allow?
               # Arguments may be mutated by the method, therefore
               # they need to be serialized prior to method invocation.
               entry_args = if probe.capture_snapshot?
-                serializer.serialize_args(args, kwargs)
+                serializer.serialize_args(args, kwargs,
+                  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
               rv = nil
+              # Under Ruby 2.6 we cannot just call super(*args, **kwargs)
+              # for methods defined via method_missing.
               duration = Benchmark.realtime do # steep:ignore
-                rv = super(*args, **kwargs)
+                rv = if args.any?
+                  if kwargs.any?
+                    super(*args, **kwargs, &target_block)
+                  else
+                    super(*args, &target_block)
+                  end
+                elsif kwargs.any?
+                  super(**kwargs, &target_block)
+                else
+                  super(&target_block)
+                end
               end
               # The method itself is not part of the stack trace because
               # we are getting the stack trace from outside of the method.
               # Add the method in manually as the top frame.
-              method_frame = Location.new(loc.first, loc.last, method_name)
-              caller_locs = [method_frame] + caller_locations # steep:ignore
+              method_frame = if loc
+                [Location.new(loc.first, loc.last, method_name)]
+              else
+                # For virtual and lazily-defined methods, we do not have
+                # the original source location here, and they won't be
+                # included in the stack trace currently.
+                # TODO when begin/end trace points are added for local
+                # variable capture in method probes, we should be able
+                # to obtain actual method execution location and use
+                # that location here.
+                []
+              end
+              caller_locs = method_frame + caller_locations # steep:ignore
               # TODO capture arguments at exit
               # & is to stop steep complaints, block is always present here.
               block&.call(probe: probe, rv: rv, duration: duration, caller_locations: caller_locs,
                 serialized_entry_args: entry_args)
               rv
             else
-              super(*args, **kwargs)
+              # stop standard from trying to mess up my code
+              _ = 42
+
+              # The necessity to invoke super in each of these specific
+              # ways is very difficult to test.
+              # Existing tests, even though I wrote many, still don't
+              # cause a failure if I replace all of the below with a
+              # simple super(*args, **kwargs, &target_block).
+              # But, let's be safe and go through the motions in case
+              # there is actually a legitimate need for the breakdown.
+              # TODO figure out how to test this properly.
+              if args.any?
+                if kwargs.any?
+                  super(*args, **kwargs, &target_block)
+                else
+                  super(*args, &target_block)
+                end
+              elsif kwargs.any?
+                super(**kwargs, &target_block)
+              else
+                super(&target_block)
+              end
             end
           end
         end
@@ -222,12 +277,25 @@ module Datadog
         # overhead of targeted trace points is minimal, don't worry about
         # this optimization just yet and create a trace point for each probe.
 
-        tp = TracePoint.new(:line) do |tp|
+        types = if iseq
+          # When targeting trace points we can target the 'end' line of a method.
+          # However, by adding the :return trace point we lose diagnostics
+          # for lines that contain no executable code (e.g. comments only)
+          # and thus cannot actually be instrumented.
+          [:line, :return, :b_return]
+        else
+          [:line]
+        end
+        tp = TracePoint.new(*types) do |tp|
           begin
             # If trace point is not targeted, we must verify that the invocation
             # is the file & line that we want, because untargeted trace points
             # are invoked for *each* line of Ruby executed.
-            if iseq || tp.lineno == probe.line_no && probe.file_matches?(tp.path)
+            # TODO find out exactly when the path in trace point is relative.
+            # Looks like this is the case when line trace point is not targeted?
+            if iseq || tp.lineno == probe.line_no && (
+              probe.file == tp.path || probe.file_matches?(tp.path)
+            )
               if rate_limiter.nil? || rate_limiter.allow?
                 # & is to stop steep complaints, block is always present here.
                 block&.call(probe: probe, trace_point: tp, caller_locations: caller_locations)
@@ -240,7 +308,7 @@ module Datadog
             # TODO test this path
           end
         rescue => exc
-          raise if settings.dynamic_instrumentation.propagate_all_exceptions
+          raise if settings.dynamic_instrumentation.internal.propagate_all_exceptions
           logger.warn("Unhandled exception in line trace point: #{exc.class}: #{exc}")
           telemetry&.report(exc, description: "Unhandled exception in line trace point")
           # TODO test this path
@@ -266,7 +334,9 @@ module Datadog
           else
             tp.enable
           end
+          # TracePoint#enable returns false when it succeeds.
         end
+        true
       end
 
       def unhook_line(probe)

data/lib/datadog/di/probe.rb

@@ -36,7 +36,9 @@ module Datadog
 
       def initialize(id:, type:,
         file: nil, line_no: nil, type_name: nil, method_name: nil,
-        template: nil, capture_snapshot: false, max_capture_depth: nil, rate_limit: nil)
+        template: nil, capture_snapshot: false, max_capture_depth: nil,
+        max_capture_attribute_count: nil,
+        rate_limit: nil)
         # Perform some sanity checks here to detect unexpected attribute
         # combinations, in order to not do them in subsequent code.
         unless KNOWN_TYPES.include?(type)
@@ -64,6 +66,7 @@ module Datadog
         @template = template
         @capture_snapshot = !!capture_snapshot
         @max_capture_depth = max_capture_depth
+        @max_capture_attribute_count = max_capture_attribute_count
 
         # These checks use instance methods that have more complex logic
         # than checking a single argument value. To avoid duplicating
@@ -91,6 +94,10 @@ module Datadog
       # the global default will be used.
       attr_reader :max_capture_depth
 
+      # Configured maximum capture attribute count. Can be nil in which case
+      # the global default will be used.
+      attr_reader :max_capture_attribute_count
+
       # Rate limit in effect, in invocations per second. Always present.
       attr_reader :rate_limit
 
@@ -154,6 +161,9 @@ module Datadog
       # If file is not an absolute path, the path matches if the file is its suffix,
       # at a path component boundary.
       def file_matches?(path)
+        if path.nil?
+          raise ArgumentError, "Cannot match against a nil path"
+        end
         unless file
           raise ArgumentError, "Probe does not have a file to match against"
         end

data/lib/datadog/di/probe_builder.rb

@@ -37,6 +37,7 @@ module Datadog
           template: config["template"],
           capture_snapshot: !!config["captureSnapshot"],
           max_capture_depth: config["capture"]&.[]("maxReferenceDepth"),
+          max_capture_attribute_count: config["capture"]&.[]("maxFieldCount"),
           rate_limit: config["sampling"]&.[]("snapshotsPerSecond"),
         )
       rescue KeyError => exc

data/lib/datadog/di/probe_manager.rb

@@ -161,7 +161,7 @@ module Datadog
                 # Silence all exceptions?
                 # TODO should we propagate here and rescue upstream?
                 logger.warn("Error removing probe #{probe.id}: #{exc.class}: #{exc}")
-                telemetry&.report(exc, description: "Error removing probe #{probe.id}")
+                telemetry&.report(exc, description: "Error removing probe")
               end
             end
           end
@@ -206,6 +206,9 @@ module Datadog
       # point, which is invoked for each required or loaded file
       # (and also for eval'd code, but those invocations are filtered out).
       def install_pending_line_probes(path)
+        if path.nil?
+          raise ArgumentError, "path must not be nil"
+        end
         @lock.synchronize do
           @pending_probes.values.each do |probe|
             if probe.line?

data/lib/datadog/di/probe_notification_builder.rb

@@ -65,14 +65,18 @@ module Datadog
                 arguments: if serialized_entry_args
                   serialized_entry_args
                 else
-                  (args || kwargs) && serializer.serialize_args(args, kwargs)
+                  (args || kwargs) && serializer.serialize_args(args, kwargs,
+                    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,
                 throwable: nil,
                 # standard:enable all
               },
               return: {
                 arguments: {
-                  "@return": serializer.serialize_value(rv),
+                  "@return": serializer.serialize_value(rv,
+                    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),
                 },
                 throwable: nil,
               },
@@ -80,7 +84,9 @@ module Datadog
           elsif probe.line?
             {
               lines: snapshot && {
-                probe.line_no => {locals: serializer.serialize_vars(snapshot)},
+                probe.line_no => {locals: serializer.serialize_vars(snapshot,
+                  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
@@ -121,7 +127,7 @@ module Datadog
           },
           # In python tracer duration is under debugger.snapshot,
           # but UI appears to expect it here at top level.
-          duration: duration ? (duration * 10**9).to_i : nil,
+          duration: duration ? (duration * 10**9).to_i : 0,
           host: nil,
           logger: {
             name: probe.file,
@@ -135,11 +141,11 @@ module Datadog
             version: 2,
           },
           # TODO add tests that the trace/span id is correctly propagated
-          "dd.trace_id": Datadog::Tracing.active_trace&.id,
-          "dd.span_id": Datadog::Tracing.active_span&.id,
+          "dd.trace_id": Datadog::Tracing.active_trace&.id&.to_s,
+          "dd.span_id": Datadog::Tracing.active_span&.id&.to_s,
           ddsource: 'dd_debugger',
           message: probe.template && evaluate_template(probe.template,
-            duration: duration ? duration * 1000 : nil),
+            duration: duration ? duration * 1000 : 0),
           timestamp: timestamp,
         }
       end

data/lib/datadog/di/remote.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Datadog
+  module DI
+    # Provides an interface expected by the core Remote subsystem to
+    # receive DI-specific remote configuration.
+    #
+    # In order to apply (i.e., act on) the configuration, we need the
+    # state stored under DI Component. Thus, this module forwards actual
+    # configuration application to the ProbeManager associated with the
+    # global DI Component.
+    #
+    # @api private
+    module Remote
+      class ReadError < StandardError; end
+
+      class << self
+        PRODUCT = 'LIVE_DEBUGGING'
+
+        def products
+          [PRODUCT]
+        end
+
+        def capabilities
+          []
+        end
+
+        def receivers(telemetry)
+          receiver do |repository, _changes|
+            # DEV: Filter our by product. Given it will be very common
+            # DEV: we can filter this out before we receive the data in this method.
+            # DEV: Apply this refactor to AppSec as well if implemented.
+
+            component = DI.component
+            # We should always have a non-nil DI component here, because we
+            # only add DI product to remote config request if DI is enabled.
+            # Ideally, we should be injected with the DI component here
+            # rather than having to retrieve it from global state.
+            # If the component is nil for some reason, we also don't have a
+            # logger instance to report the issue.
+            if component
+
+              probe_manager = component.probe_manager
+
+              current_probe_ids = {}
+              repository.contents.each do |content|
+                case content.path.product
+                when PRODUCT
+                  begin
+                    probe_spec = parse_content(content)
+                    probe = ProbeBuilder.build_from_remote_config(probe_spec)
+                    payload = component.probe_notification_builder.build_received(probe)
+                    component.probe_notifier_worker.add_status(payload)
+                    component.logger.info("Received probe from RC: #{probe.type} #{probe.location}")
+
+                    begin
+                      # TODO test exception capture
+                      probe_manager.add_probe(probe)
+                      content.applied
+                    rescue => exc
+                      raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
+
+                      component.logger.warn("Unhandled exception adding probe in DI remote receiver: #{exc.class}: #{exc}")
+                      component.telemetry&.report(exc, description: "Unhandled exception adding probe in DI remote receiver")
+
+                      # If a probe fails to install, we will mark the content
+                      # as errored. On subsequent remote configuration application
+                      # attemps, probe manager will raise the "previously errored"
+                      # exception and we'll rescue it here, again marking the
+                      # content as errored but with a somewhat different exception
+                      # message.
+                      # TODO stack trace must be redacted or not sent at all
+                      content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}: #{Array(exc.backtrace).join("\n")}")
+                    end
+
+                    # Important: even if processing fails for this probe config,
+                    # we need to note it as being current so that we do not
+                    # try to remove instrumentation that is still supposed to be
+                    # active.
+                    current_probe_ids[probe_spec.fetch('id')] = true
+                  rescue => exc
+                    raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
+
+                    component.logger.warn("Unhandled exception handling probe in DI remote receiver: #{exc.class}: #{exc}")
+                    component.telemetry&.report(exc, description: "Unhandled exception handling probe in DI remote receiver")
+
+                    content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}: #{Array(exc.backtrace).join("\n")}")
+                  end
+                end
+              end
+
+              begin
+                # TODO test exception capture
+                probe_manager.remove_other_probes(current_probe_ids.keys)
+              rescue => exc
+                raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
+
+                component.logger.warn("Unhandled exception removing probes in DI remote receiver: #{exc.class}: #{exc}")
+                component.telemetry&.report(exc, description: "Unhandled exception removing probes in DI remote receiver")
+              end
+            end
+          end
+        end
+
+        def receiver(products = [PRODUCT], &block)
+          matcher = Core::Remote::Dispatcher::Matcher::Product.new(products)
+          [Core::Remote::Dispatcher::Receiver.new(matcher, &block)]
+        end
+
+        private
+
+        def parse_content(content)
+          data = content.data.read
+
+          content.data.rewind
+
+          raise ReadError, 'EOF reached' if data.nil?
+
+          JSON.parse(data)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/di/serializer.rb

@@ -82,7 +82,9 @@ module Datadog
       # between positional and keyword arguments. We convert positional
       # arguments to keyword arguments ("arg1", "arg2", ...) and ensure
       # the positional arguments are listed first.
-      def serialize_args(args, kwargs)
+      def serialize_args(args, kwargs,
+        depth: settings.dynamic_instrumentation.max_capture_depth,
+        attribute_count: settings.dynamic_instrumentation.max_capture_attribute_count)
         counter = 0
         combined = args.each_with_object({}) do |value, c|
           counter += 1
@@ -90,16 +92,18 @@ module Datadog
           # kwargs when they are merged below.
           c[:"arg#{counter}"] = value
         end.update(kwargs)
-        serialize_vars(combined)
+        serialize_vars(combined, depth: depth, attribute_count: attribute_count)
       end
 
       # Serializes variables captured by a line probe.
       #
       # These are normally local variables that exist on a particular line
       # of executed code.
-      def serialize_vars(vars)
+      def serialize_vars(vars,
+        depth: settings.dynamic_instrumentation.max_capture_depth,
+        attribute_count: settings.dynamic_instrumentation.max_capture_attribute_count)
         vars.each_with_object({}) do |(k, v), agg|
-          agg[k] = serialize_value(v, name: k)
+          agg[k] = serialize_value(v, name: k, depth: depth, attribute_count: attribute_count)
         end
       end
 
@@ -115,7 +119,11 @@ module Datadog
       # (integers, strings, arrays, hashes).
       #
       # Respects string length, collection size and traversal depth limits.
-      def serialize_value(value, name: nil, depth: settings.dynamic_instrumentation.max_capture_depth, type: nil)
+      def serialize_value(value, name: nil,
+        depth: settings.dynamic_instrumentation.max_capture_depth,
+        attribute_count: nil,
+        type: nil)
+        attribute_count ||= settings.dynamic_instrumentation.max_capture_attribute_count
         cls = type || value.class
         begin
           if redactor.redact_type?(value)
@@ -203,7 +211,6 @@ module Datadog
               serialized.update(notCapturedReason: "depth")
             else
               fields = {}
-              max = settings.dynamic_instrumentation.max_capture_attribute_count
               cur = 0
 
               # MRI and JRuby 9.4.5+ preserve instance variable definition
@@ -229,7 +236,7 @@ module Datadog
               ivars = value.instance_variables
 
               ivars.each do |ivar|
-                if cur >= max
+                if cur >= attribute_count
                   serialized.update(notCapturedReason: "fieldCount", fields: fields)
                   break
                 end

data/lib/datadog/di/transport.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'ostruct'
 require_relative 'error'
 
 module Datadog
@@ -44,7 +45,7 @@ module Datadog
 
       def send_input(payload)
         send_request('Probe snapshot submission',
-          path: INPUT_PATH, body: payload.to_s,
+          path: INPUT_PATH, body: payload.to_json,
           headers: {'content-type' => 'application/json'},)
       end
 

data/lib/datadog/di/utils.rb

@@ -12,6 +12,13 @@ module Datadog
       # If suffix is not an absolute path, the path matches if its suffix is
       # the provided suffix, at a path component boundary.
       module_function def path_matches_suffix?(path, suffix)
+        if path.nil?
+          raise ArgumentError, "nil path passed"
+        end
+        if suffix.nil?
+          raise ArgumentError, "nil suffix passed"
+        end
+
         if suffix.start_with?('/')
           path == suffix
         else