datadog 2.12.0 → 2.22.0

data/lib/datadog/di/probe_notification_builder.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable Lint/AssignmentInCondition
+
 module Datadog
   module DI
     # Builds probe status notification and snapshot payloads.
@@ -39,60 +41,47 @@ module Datadog
       end
 
       # Duration is in seconds.
-      def build_executed(probe,
-        trace_point: nil, rv: nil, duration: nil, caller_locations: nil,
-        args: nil, kwargs: nil, serialized_entry_args: nil)
-        snapshot = if probe.line? && probe.capture_snapshot?
-          if trace_point.nil?
-            raise "Cannot create snapshot because there is no trace point"
-          end
-          get_local_variables(trace_point)
-        end
-        # 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?
-        build_snapshot(probe, rv: rv, snapshot: snapshot,
-          # Actual path of the instrumented file.
-          path: trace_point&.path,
-          duration: duration, caller_locations: caller_locations, args: args, kwargs: kwargs,
-          serialized_entry_args: serialized_entry_args)
+      # path is the actual path of the instrumented file.
+      def build_executed(context)
+        build_snapshot(context)
       end
 
-      def build_snapshot(probe, rv: nil, snapshot: nil, path: nil,
-        duration: nil, caller_locations: nil, args: nil, kwargs: nil,
-        serialized_entry_args: nil)
+      NANOSECONDS = 10**9
+      MILLISECONDS = 1000
+
+      def build_snapshot(context)
+        probe = context.probe
+
+        if probe.capture_snapshot? && !context.target_self
+          raise ArgumentError, "Asked to build snapshot with snapshot capture but target_self is nil"
+        end
+
         # TODO also verify that non-capturing probe does not pass
         # snapshot or vars/args into this method
         captures = if probe.capture_snapshot?
           if probe.method?
+            return_arguments = {
+              "@return": serializer.serialize_value(context.return_value,
+                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),
+              self: serializer.serialize_value(context.target_self),
+            }
             {
               entry: {
-                # standard:disable all
-                arguments: if serialized_entry_args
-                  serialized_entry_args
-                else
-                  (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
+                arguments: context.serialized_entry_args,
               },
               return: {
-                arguments: {
-                  "@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),
-                },
+                arguments: return_arguments,
                 throwable: nil,
               },
             }
           elsif probe.line?
             {
-              lines: 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,)},
+              lines: (locals = context.serialized_locals) && {
+                probe.line_no => {
+                  locals: locals,
+                  arguments: {self: serializer.serialize_value(context.target_self)},
+                },
               },
             }
           end
@@ -100,7 +89,7 @@ module Datadog
 
         location = if probe.line?
           {
-            file: path,
+            file: context.path,
             lines: [probe.line_no],
           }
         elsif probe.method?
@@ -110,17 +99,23 @@ module Datadog
           }
         end
 
-        stack = if caller_locations
+        stack = if caller_locations = context.caller_locations
           format_caller_locations(caller_locations)
         end
 
         timestamp = timestamp_now
+        message = nil
+        evaluation_errors = []
+        if segments = probe.template_segments
+          message, evaluation_errors = evaluate_template(segments, context)
+        end
+        duration = context.duration
         {
           service: settings.service,
           "debugger.snapshot": {
             id: SecureRandom.uuid,
             timestamp: timestamp,
-            evaluationErrors: [],
+            evaluationErrors: evaluation_errors,
             probe: {
               id: probe.id,
               version: 0,
@@ -133,7 +128,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 : 0,
+          duration: duration ? (duration * NANOSECONDS).to_i : 0,
           host: nil,
           logger: {
             name: probe.file,
@@ -150,8 +145,7 @@ module Datadog
           "dd.trace_id": active_trace&.id&.to_s,
           "dd.span_id": active_span&.id&.to_s,
           ddsource: 'dd_debugger',
-          message: probe.template && evaluate_template(probe.template,
-            duration: duration ? duration * 1000 : 0),
+          message: message,
           timestamp: timestamp,
         }
       end
@@ -182,31 +176,29 @@ module Datadog
         end
       end
 
-      def evaluate_template(template, **vars)
-        message = template.dup
-        vars.each do |key, value|
-          message.gsub!("{@#{key}}", value.to_s)
-        end
-        message
+      def evaluate_template(template_segments, context)
+        evaluation_errors = []
+        message = template_segments.map do |segment|
+          case segment
+          when String
+            segment
+          when EL::Expression
+            serializer.serialize_value_for_message(segment.evaluate(context))
+          else
+            raise ArgumentError, "Invalid template segment type: #{segment}"
+          end
+        rescue => exc
+          evaluation_errors << {
+            message: "#{exc.class}: #{exc}",
+            expr: segment.dsl_expr,
+          }
+          '[evaluation error]'
+        end.join
+        [message, evaluation_errors]
       end
 
       def timestamp_now
-        (Time.now.to_f * 1000).to_i
-      end
-
-      def get_local_variables(trace_point)
-        # binding appears to be constructed on access, therefore
-        # 1) we should attempt to cache it and
-        # 2) we should not call +binding+ until we actually need variable values.
-        binding = trace_point.binding
-
-        # steep hack - should never happen
-        return {} unless binding
-
-        binding.local_variables.each_with_object({}) do |name, map|
-          value = binding.local_variable_get(name)
-          map[name] = value
-        end
+        (Core::Utils::Time.now.to_f * MILLISECONDS).to_i
       end
 
       def active_trace
@@ -223,3 +215,5 @@ module Datadog
     end
   end
 end
+
+# rubocop:enable Lint/AssignmentInCondition

data/lib/datadog/di/probe_notifier_worker.rb

@@ -171,7 +171,7 @@ module Datadog
       attr_reader :last_sent
 
       def status_transport
-        @status_transport ||= DI::Transport::HTTP.diagnostics(agent_settings: agent_settings)
+        @status_transport ||= DI::Transport::HTTP.diagnostics(agent_settings: agent_settings, logger: logger)
       end
 
       def do_send_status(batch)
@@ -179,11 +179,19 @@ module Datadog
       end
 
       def snapshot_transport
-        @snapshot_transport ||= DI::Transport::HTTP.input(agent_settings: agent_settings)
+        @snapshot_transport ||= DI::Transport::HTTP.input(agent_settings: agent_settings, logger: logger)
       end
 
       def do_send_snapshot(batch)
-        snapshot_transport.send_input(batch)
+        snapshot_transport.send_input(batch, tags)
+      end
+
+      def tags
+        # DEV: The tags could be cached but they need to be recreated
+        # when process forks (since the child receives new runtime IDs).
+        Core::TagBuilder.tags(settings).merge(
+          'debugger_version' => Core::Environment::Identity.gem_datadog_version,
+        )
       end
 
       [
@@ -227,20 +235,6 @@ module Datadog
           start
         end
 
-        # Determine how much longer the worker thread should sleep
-        # so as not to send in less than min send interval since the last send.
-        # Important: this method must be called when @lock is held.
-        #
-        # Returns the time remaining to sleep.
-        def set_sleep_remaining
-          now = Core::Utils::Time.get_time
-          @sleep_remaining = if last_sent
-            [last_sent + min_send_interval - now, 0].max
-          else
-            0
-          end
-        end
-
         public "add_#{event_type}"
 
         # Sends pending probe statuses or snapshots.
@@ -288,6 +282,20 @@ module Datadog
         end
       end
 
+      # Determine how much longer the worker thread should sleep
+      # so as not to send in less than min send interval since the last send.
+      # Important: this method must be called when @lock is held.
+      #
+      # Returns the time remaining to sleep.
+      def set_sleep_remaining
+        now = Core::Utils::Time.get_time
+        @sleep_remaining = if last_sent
+          [last_sent + min_send_interval - now, 0].max
+        else
+          0
+        end
+      end
+
       def maybe_send
         rv = maybe_send_status
         maybe_send_snapshot || rv

data/lib/datadog/di/remote.rb

@@ -18,6 +18,8 @@ module Datadog
         PRODUCT = 'LIVE_DEBUGGING'
 
         def products
+          # TODO: do not send our product on unsupported runtimes
+          # (Ruby 2.5 / JRuby)
           [PRODUCT]
         end
 
@@ -41,6 +43,8 @@ module Datadog
             if component
 
               probe_manager = component.probe_manager
+              probe_notification_builder = component.probe_notification_builder
+              probe_notifier_worker = component.probe_notifier_worker
 
               current_probe_ids = {}
               repository.contents.each do |content|
@@ -48,11 +52,7 @@ module Datadog
                 when PRODUCT
                   begin
                     probe_spec = parse_content(content)
-                    probe = ProbeBuilder.build_from_remote_config(probe_spec)
-                    probe_notification_builder = component.probe_notification_builder
-                    payload = probe_notification_builder.build_received(probe)
-                    probe_notifier_worker = component.probe_notifier_worker
-                    probe_notifier_worker.add_status(payload)
+                    probe = component.parse_probe_spec_and_notify(probe_spec)
                     component.logger.debug { "di: received #{probe.type} probe at #{probe.location} (#{probe.id}) via RC" }
 
                     begin

data/lib/datadog/di/serializer.rb

@@ -36,6 +36,10 @@ module Datadog
     # efficient but there would be additional overhead from passing this
     # parameter all the time and the API would get more complex.
     #
+    # Note: "self" cannot be used as a parameter name in Ruby, therefore
+    # there should never be a conflict between instance variable
+    # serialization and method parameters.
+    #
     # @api private
     class Serializer
       # Third-party library integration / custom serializers.
@@ -60,6 +64,9 @@ module Datadog
       # a common base class but are all of different classes) or for Mongoid
       # models (that do not have a common base class at all but include a
       # standard Mongoid module).
+      #
+      # Important: these serializers are NOT used in log messages.
+      # They are only used for variables that are captured in the snapshots.
       @@flat_registry = []
       def self.register(condition: nil, &block)
         @@flat_registry << {condition: condition, proc: block}
@@ -75,6 +82,18 @@ module Datadog
       attr_reader :redactor
       attr_reader :telemetry
 
+      def combine_args(args, kwargs, target_self)
+        counter = 0
+        combined = args.each_with_object({}) do |value, c|
+          counter += 1
+          # Conversion to symbol is needed here to put args ahead of
+          # kwargs when they are merged below.
+          c[:"arg#{counter}"] = value
+        end.update(kwargs)
+        combined[:self] = target_self
+        combined
+      end
+
       # Serializes positional and keyword arguments to a method,
       # as obtained by a method probe.
       #
@@ -82,16 +101,14 @@ 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,
+      #
+      # Instance variables are technically a hash just like kwargs,
+      # we take them as a separate parameter to avoid a hash merge
+      # 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)
-        counter = 0
-        combined = args.each_with_object({}) do |value, c|
-          counter += 1
-          # Conversion to symbol is needed here to put args ahead of
-          # kwargs when they are merged below.
-          c[:"arg#{counter}"] = value
-        end.update(kwargs)
+        combined = combine_args(args, kwargs, target_self)
         serialize_vars(combined, depth: depth, attribute_count: attribute_count)
       end
 
@@ -142,6 +159,8 @@ module Datadog
           end
 
           serialized = {type: class_name(cls)}
+          # https://github.com/soutaro/steep/issues/1860
+          # @type var serialized: untyped
           case value
           when NilClass
             serialized.update(isNull: true)
@@ -253,8 +272,120 @@ module Datadog
         end
       end
 
+      # This method is used for serializing arbitrary values into log messages.
+      # Because the output is meant to be human-readable, we cannot use
+      # the "normal" serialization format which is meant to be machine-readable.
+      # Serialize objects with depth of 1 and include the class name.
+      #
+      # Note that this method does not (currently) utilize the custom
+      # serializers that the "normal" serialization logic uses.
+      #
+      # This serializer differs from the RFC in two ways:
+      # 1. We omit the middle of long strings rather than the end,
+      #    and also the inner entries in arrays/hashes/objects.
+      # 2. We use Ruby-ish syntax for hashes and objects.
+      #
+      # We also use the Ruby-like syntax for symbols, which don't exist
+      # in other languages.
+      def serialize_value_for_message(value, depth = 1)
+        # This method is more verbose than "normal" Ruby code to avoid
+        # array allocations.
+        case value
+        when NilClass
+          'nil'
+        when Integer, Float, TrueClass, FalseClass, Time, Date
+          value.to_s
+        when String
+          serialize_string_or_symbol_for_message(value)
+        when Symbol
+          ':' + serialize_string_or_symbol_for_message(value)
+        when Array
+          return '...' if depth <= 0
+
+          max = max_capture_collection_size_for_message
+          if value.length > max
+            value_ = value[0...max - 1] || []
+            value_ << '...'
+            value_ << value[-1]
+            value = value_
+          end
+          '[' + value.map do |item|
+            serialize_value_for_message(item, depth - 1)
+          end.join(', ') + ']'
+        when Hash
+          return '...' if depth <= 0
+
+          max = max_capture_collection_size_for_message
+          keys = value.keys
+          truncated = false
+          if value.length > max
+            keys_ = keys[0...max - 1] || []
+            keys_ << keys[-1]
+            keys = keys_
+            truncated = true
+          end
+          serialized = keys.map do |key|
+            "#{serialize_value_for_message(key, depth - 1)} => #{serialize_value_for_message(value[key], depth - 1)}"
+          end
+          if truncated
+            serialized[serialized.length] = serialized[serialized.length - 1]
+            serialized[serialized.length - 2] = '...'
+          end
+          "{#{serialized.join(", ")}}"
+        else
+          return '...' if depth <= 0
+
+          vars = value.instance_variables
+          truncated = false
+          max = max_capture_attribute_count_for_message
+          if vars.length > max
+            vars_ = vars[0...max - 1] || []
+            vars_ << vars[-1]
+            truncated = true
+            vars = vars_
+          end
+          serialized = vars.map do |var|
+            # +var+ here is always the instance variable name which is a
+            # symbol, we do not need to run it through our serializer.
+            "#{var}=#{serialize_value_for_message(value.send(:instance_variable_get, var), depth - 1)}"
+          end
+          if truncated
+            serialized << serialized.last
+            serialized[-2] = '...'
+          end
+          serialized = if serialized.any?
+            ' ' + serialized.join(' ')
+          end
+          "#<#{class_name(value.class)}#{serialized}>"
+        end
+      rescue => exc
+        telemetry&.report(exc, description: "Error serializing for message")
+        # TODO class_name(foo) can also fail, which we don't handle here.
+        # Telemetry reporting could potentially also fail?
+        "#<#{class_name(value.class)}: serialization error>"
+      end
+
       private
 
+      MAX_MESSAGE_COLLECTION_SIZE = 3
+      MAX_MESSAGE_ATTRIBUTE_COUNT = 5
+
+      def max_capture_collection_size_for_message
+        max = settings.dynamic_instrumentation.max_capture_collection_size
+        if max > MAX_MESSAGE_COLLECTION_SIZE
+          max = MAX_MESSAGE_COLLECTION_SIZE
+        end
+        max
+      end
+
+      def max_capture_attribute_count_for_message
+        max = settings.dynamic_instrumentation.max_capture_attribute_count
+        if max > MAX_MESSAGE_ATTRIBUTE_COUNT
+          max = MAX_MESSAGE_ATTRIBUTE_COUNT
+        end
+        max
+      end
+
       # Returns the name for the specified class object.
       #
       # Ruby can have nameless classes, e.g. Class.new is a class object
@@ -265,6 +396,27 @@ module Datadog
         # and we don't want to invoke user code.
         cls.name || "[Unnamed class]"
       end
+
+      def serialize_string_or_symbol_for_message(value)
+        max = settings.dynamic_instrumentation.max_capture_string_length
+        if max > 100
+          max = 100
+        end
+        value = value.to_s
+        if (length = value.length) > max
+          if max < 5
+            value[0...max]
+          else
+            upper = length - max / 2 + 1
+            if max % 2 == 0
+              upper += 1
+            end
+            value[0...max / 2 - 1] + '...' + value[upper...length]
+          end
+        else
+          value
+        end
+      end
     end
   end
 end

data/lib/datadog/di/transport/diagnostics.rb

@@ -15,12 +15,13 @@ module Datadog
         end
 
         class Transport
-          attr_reader :client, :apis, :default_api, :current_api_id
+          attr_reader :client, :apis, :default_api, :current_api_id, :logger
 
-          def initialize(apis, default_api)
+          def initialize(apis, default_api, logger:)
             @apis = apis
+            @logger = logger
 
-            @client = HTTP::Client.new(current_api)
+            @client = HTTP::Client.new(current_api, logger: logger)
           end
 
           def current_api

data/lib/datadog/di/transport/http/api.rb

@@ -21,13 +21,13 @@ module Datadog
 
           def defaults
             Datadog::Core::Transport::HTTP::API::Map[
-              DIAGNOSTICS => Spec.new do |s|
+              DIAGNOSTICS => Diagnostics::API::Spec.new do |s|
                 s.diagnostics = Diagnostics::API::Endpoint.new(
                   '/debugger/v1/diagnostics',
                   Core::Encoding::JSONEncoder,
                 )
               end,
-              INPUT => Spec.new do |s|
+              INPUT => Input::API::Spec.new do |s|
                 s.input = Input::API::Endpoint.new(
                   '/debugger/v1/input',
                   Core::Encoding::JSONEncoder,
@@ -35,16 +35,6 @@ module Datadog
               end,
             ]
           end
-
-          class Instance < Core::Transport::HTTP::API::Instance
-            include Diagnostics::API::Instance
-            include Input::API::Instance
-          end
-
-          class Spec < Core::Transport::HTTP::API::Spec
-            include Diagnostics::API::Spec
-            include Input::API::Spec
-          end
         end
       end
     end

data/lib/datadog/di/transport/http/client.rb

@@ -14,10 +14,11 @@ module Datadog
       module HTTP
         # Routes, encodes, and sends DI data to the trace agent via HTTP.
         class Client
-          attr_reader :api
+          attr_reader :api, :logger
 
-          def initialize(api)
+          def initialize(api, logger:)
             @api = api
+            @logger = logger
           end
 
           def send_request(request, &block)
@@ -31,7 +32,7 @@ module Datadog
               "Internal error during #{self.class.name} request. Cause: #{e.class.name} #{e.message} " \
                 "Location: #{Array(e.backtrace).first}"
 
-            Datadog.logger.debug(message)
+            logger.debug(message)
 
             Datadog::Core::Transport::InternalErrorResponse.new(e)
           end

data/lib/datadog/di/transport/http/diagnostics.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../../../core/transport/http/api/instance'
+require_relative '../../../core/transport/http/api/spec'
 require_relative 'client'
 
 module Datadog
@@ -16,55 +18,26 @@ module Datadog
           end
 
           module API
-            module Instance
+            class Instance < Core::Transport::HTTP::API::Instance
               def send_diagnostics(env)
-                raise DiagnosticsNotSupportedError, spec unless spec.is_a?(Diagnostics::API::Spec)
+                raise Core::Transport::HTTP::API::Instance::EndpointNotSupportedError.new('diagnostics', self) unless spec.is_a?(Diagnostics::API::Spec)
 
                 spec.send_diagnostics(env) do |request_env|
                   call(request_env)
                 end
               end
-
-              class DiagnosticsNotSupportedError < StandardError
-                attr_reader :spec
-
-                def initialize(spec)
-                  super
-
-                  @spec = spec
-                end
-
-                def message
-                  'Diagnostics not supported for this API!'
-                end
-              end
             end
 
-            module Spec
+            class Spec < Core::Transport::HTTP::API::Spec
               attr_accessor :diagnostics
 
               def send_diagnostics(env, &block)
-                raise NoDiagnosticsEndpointDefinedError, self if diagnostics.nil?
+                raise Core::Transport::HTTP::API::Spec::EndpointNotDefinedError.new('diagnostics', self) if diagnostics.nil?
 
                 diagnostics.call(env, &block)
               end
-
-              class NoDiagnosticsEndpointDefinedError < StandardError
-                attr_reader :spec
-
-                def initialize(spec)
-                  super
-
-                  @spec = spec
-                end
-
-                def message
-                  'No diagnostics endpoint is defined for API specification!'
-                end
-              end
             end
 
-            # Endpoint for negotiation
             class Endpoint < Datadog::Core::Transport::HTTP::API::Endpoint
               attr_reader :encoder
 
@@ -79,7 +52,7 @@ module Datadog
                 )
                 env.form = {'event' => event_payload}
 
-                super(env, &block)
+                super
               end
             end
           end