datadog 2.21.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.
@@ -40,32 +42,17 @@ module Datadog
 
       # Duration is in seconds.
       # path is the actual path of the instrumented file.
-      def build_executed(probe,
-        path: nil, rv: nil, duration: nil, caller_locations: nil,
-        serialized_locals: nil, args: nil, kwargs: nil, target_self: nil,
-        serialized_entry_args: nil)
-        build_snapshot(probe, rv: rv, serialized_locals: serialized_locals,
-          # Actual path of the instrumented file.
-          path: path,
-          duration: duration,
-          # 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?
-          caller_locations: caller_locations,
-          args: args, kwargs: kwargs,
-          target_self: target_self,
-          serialized_entry_args: serialized_entry_args)
+      def build_executed(context)
+        build_snapshot(context)
       end
 
-      def build_snapshot(probe, rv: nil, serialized_locals: nil, path: 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,
-        duration: nil, caller_locations: nil,
-        args: nil, kwargs: nil,
-        serialized_entry_args: nil)
-        if probe.capture_snapshot? && !target_self
+      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
 
@@ -74,22 +61,14 @@ module Datadog
         captures = if probe.capture_snapshot?
           if probe.method?
             return_arguments = {
-              "@return": serializer.serialize_value(rv,
+              "@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(target_self),
+              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, target_self,
-                    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,
-                # standard:enable all
+                arguments: context.serialized_entry_args,
               },
               return: {
                 arguments: return_arguments,
@@ -98,10 +77,10 @@ module Datadog
             }
           elsif probe.line?
             {
-              lines: serialized_locals && {
+              lines: (locals = context.serialized_locals) && {
                 probe.line_no => {
-                  locals: serialized_locals,
-                  arguments: {self: serializer.serialize_value(target_self)},
+                  locals: locals,
+                  arguments: {self: serializer.serialize_value(context.target_self)},
                 },
               },
             }
@@ -110,7 +89,7 @@ module Datadog
 
         location = if probe.line?
           {
-            file: path,
+            file: context.path,
             lines: [probe.line_no],
           }
         elsif probe.method?
@@ -120,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,
@@ -143,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,
@@ -160,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
@@ -192,16 +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
-        (Core::Utils::Time.now.to_f * 1000).to_i
+        (Core::Utils::Time.now.to_f * MILLISECONDS).to_i
       end
 
       def active_trace
@@ -218,3 +215,5 @@ module Datadog
     end
   end
 end
+
+# rubocop:enable Lint/AssignmentInCondition

data/lib/datadog/di/serializer.rb

@@ -64,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}
@@ -79,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.
       #
@@ -93,13 +108,7 @@ module Datadog
       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).update(self: target_self)
+        combined = combine_args(args, kwargs, target_self)
         serialize_vars(combined, depth: depth, attribute_count: attribute_count)
       end
 
@@ -150,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)
@@ -261,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
@@ -273,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/tracing/component.rb

@@ -12,16 +12,7 @@ module Datadog
   module Tracing
     # Tracing component
     module Component
-      # Methods that interact with component instance fields.
-      module InstanceMethods
-        # Hot-swaps with a new sampler.
-        # This operation acquires the Components lock to ensure
-        # there is no concurrent modification of the sampler.
-        def reconfigure_live_sampler
-          sampler = self.class.build_sampler(Datadog.configuration)
-          Datadog.send(:safely_synchronize) { tracer.sampler.sampler = sampler }
-        end
-      end
+      module_function
 
       def build_tracer(settings, agent_settings, logger:)
         # If a custom tracer has been provided, use it instead.
@@ -156,11 +147,6 @@ module Datadog
         Tracing::Sampling::Span::Sampler.new(rules || [])
       end
 
-      # Configure non-privileged components.
-      def configure_tracing(settings)
-        Datadog::Tracing::Contrib::Component.configure(settings)
-      end
-
       # Sampler wrapper component, to allow for hot-swapping
       # the sampler instance used by the tracer.
       # Swapping samplers happens during Dynamic Configuration.
@@ -182,8 +168,7 @@ module Datadog
         end
       end
 
-      private
-
+      # @api private
       def build_tracer_tags(settings)
         settings.tags.dup.tap do |tags|
           tags[Core::Environment::Ext::TAG_ENV] = settings.env unless settings.env.nil?
@@ -193,6 +178,7 @@ module Datadog
 
       # Build a post-sampler that limits the rate of traces to one per `seconds`.
       # E.g.: `build_rate_limit_post_sampler(seconds: 60)` will limit the rate to one trace per minute.
+      # @api private
       def build_rate_limit_post_sampler(seconds:)
         Tracing::Sampling::RuleSampler.new(
           rate_limiter: Datadog::Core::TokenBucket.new(1.0 / seconds, 1.0),
@@ -200,11 +186,13 @@ module Datadog
         )
       end
 
+      # @api private
       def build_test_mode_trace_flush(settings)
         # If context flush behavior is provided, use it instead.
         settings.tracing.test_mode.trace_flush || build_trace_flush(settings)
       end
 
+      # @api private
       def build_test_mode_sampler
         # Do not sample any spans for tests; all must be preserved.
         # Set priority sampler to ensure the agent doesn't drop any traces.
@@ -214,6 +202,7 @@ module Datadog
         )
       end
 
+      # @api private
       def build_test_mode_writer(settings, agent_settings)
         writer_options = settings.tracing.test_mode.writer_options || {}
 

data/lib/datadog/tracing/configuration/dynamic.rb

@@ -41,7 +41,7 @@ module Datadog
           # Ensures sampler is rebuilt and new configuration is applied
           def call(tracing_sampling_rate)
             super
-            Datadog.send(:components).reconfigure_live_sampler
+            Datadog.send(:components).reconfigure_sampler
           end
 
           protected
@@ -79,7 +79,7 @@ module Datadog
             end
 
             super
-            Datadog.send(:components).reconfigure_live_sampler
+            Datadog.send(:components).reconfigure_sampler
           end
 
           protected

data/lib/datadog/tracing/configuration/settings.rb

@@ -96,7 +96,7 @@ module Datadog
                 # Note: Alias (DD_TRACE_PROPAGATION_STYLE) defined in supported-configurations.json
                 o.env Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE
                 o.default []
-                o.after_set do |styles|
+                o.after_set do |styles, _, precedence|
                   next if styles.empty?
 
                   # Make values case-insensitive
@@ -110,8 +110,8 @@ module Datadog
                       false
                     end
                   end
-                  set_option(:propagation_style_extract, styles)
-                  set_option(:propagation_style_inject, styles)
+                  set_option(:propagation_style_extract, styles, precedence: precedence)
+                  set_option(:propagation_style_inject, styles, precedence: precedence)
                 end
               end
 

data/lib/datadog/tracing/contrib/component.rb

@@ -9,13 +9,13 @@ module Datadog
           # Register a callback to be invoked when components are reconfigured.
           # @param name [String] the name of the integration
           # @param callback [Proc] the callback to invoke
-          # @yieldparam config [Datadog::Configuration] the configuration to pass to callbacks
+          # @yieldparam config [Datadog::Core::Configuration::Settings] the configuration to pass to callbacks
           def register(name, &callback)
             @registry[name] = callback
           end
 
           # Invoke all registered callbacks with the given configuration.
-          # @param config [Datadog::Configuration] the configuration to pass to callbacks
+          # @param config [Datadog::Core::Configuration::Settings] the configuration to pass to callbacks
           def configure(config)
             @registry.each do |name, callback|
               callback.call(config)

data/lib/datadog/tracing/contrib/graphql/configuration/settings.rb

@@ -58,6 +58,13 @@ module Datadog
               o.default []
               o.env_parser { |v| ErrorExtensionEnvParser.call(v) }
             end
+
+            # Surface GraphQL errors in Error Tracking.
+            option :error_tracking do |o|
+              o.env Ext::ENV_ERROR_TRACKING
+              o.type :bool
+              o.default false
+            end
           end
         end
       end

data/lib/datadog/tracing/contrib/graphql/ext.rb

@@ -13,6 +13,7 @@ module Datadog
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_GRAPHQL_ANALYTICS_SAMPLE_RATE'
           ENV_WITH_UNIFIED_TRACER = 'DD_TRACE_GRAPHQL_WITH_UNIFIED_TRACER'
           ENV_ERROR_EXTENSIONS = 'DD_TRACE_GRAPHQL_ERROR_EXTENSIONS'
+          ENV_ERROR_TRACKING = 'DD_TRACE_GRAPHQL_ERROR_TRACKING'
           SERVICE_NAME = 'graphql'
           TAG_COMPONENT = 'graphql'
 

data/lib/datadog/tracing/contrib/graphql/unified_trace.rb

@@ -11,11 +11,45 @@ module Datadog
         # which is required to use features such as API Catalog.
         # DEV-3.0: This tracer should be the default one in the next major version.
         module UnifiedTrace
+          include ::GraphQL::Tracing::PlatformTrace
+
           def initialize(*args, **kwargs)
             @has_prepare_span = respond_to?(:prepare_span)
+
+            # Cache configuration values to avoid repeated lookups
+            config = Datadog.configuration.tracing[:graphql]
+            @service_name = config[:service_name]
+            @analytics_enabled = config[:analytics_enabled]
+            @analytics_sample_rate = config[:analytics_sample_rate]
+            @error_extensions_config = config[:error_extensions]
+
+            load_error_event_attributes(config[:error_tracking])
+
             super
           end
 
+          def load_error_event_attributes(error_tracking)
+            if error_tracking
+              @event_name = Tracing::Metadata::Ext::Errors::EVENT_NAME
+              @message_key = Tracing::Metadata::Ext::Errors::ATTRIBUTE_MESSAGE
+              @type_key = Tracing::Metadata::Ext::Errors::ATTRIBUTE_TYPE
+              @stacktrace_key = Tracing::Metadata::Ext::Errors::ATTRIBUTE_STACKTRACE
+              @locations_key = 'graphql.error.locations'
+              @path_key = 'graphql.error.path'
+              @extensions_key = 'graphql.error.extensions.'
+            else
+              @event_name = Ext::EVENT_QUERY_ERROR
+              @message_key = 'message'
+              @type_key = 'type'
+              @stacktrace_key = 'stacktrace'
+              @locations_key = 'locations'
+              @path_key = 'path'
+              @extensions_key = 'extensions.'
+            end
+          end
+
+          private :load_error_event_attributes
+
           def lex(*args, query_string:, **kwargs)
             trace(proc { super }, 'lex', query_string, query_string: query_string)
           end
@@ -56,7 +90,7 @@ module Datadog
                 span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
 
                 span.set_tag('graphql.source', query.query_string)
-                span.set_tag('graphql.operation.type', query.selected_operation.operation_type)
+                span.set_tag('graphql.operation.type', query.selected_operation&.operation_type)
                 if query.selected_operation_name
                   span.set_tag(
                     'graphql.operation.name',
@@ -130,8 +164,6 @@ module Datadog
             resolve_type_span(proc { super }, 'resolve_type_lazy', **kwargs)
           end
 
-          include ::GraphQL::Tracing::PlatformTrace
-
           def platform_field_key(field, *args, **kwargs)
             field.path
           end
@@ -156,16 +188,14 @@ module Datadog
           # @param kwargs [Hash] the arguments to pass to `prepare_span`
           # @yield [Span] the block to run before the trace, same as the `before` parameter
           def trace(callable, trace_key, resource, before = nil, after = nil, **kwargs, &before_block)
-            config = Datadog.configuration.tracing[:graphql]
-
             Tracing.trace(
               "graphql.#{trace_key}",
               type: 'graphql',
               resource: resource,
-              service: config[:service_name]
+              service: @service_name
             ) do |span|
-              if Contrib::Analytics.enabled?(config[:analytics_enabled])
-                Contrib::Analytics.set_sample_rate(span, config[:analytics_sample_rate])
+              if Contrib::Analytics.enabled?(@analytics_enabled)
+                Contrib::Analytics.set_sample_rate(span, @analytics_sample_rate)
               end
 
               # A sanity check for us.
@@ -198,34 +228,29 @@ module Datadog
           end
 
           def operation_resource(operation)
-            if operation.name
+            if operation&.name
               "#{operation.operation_type} #{operation.name}"
             else
-              "anonymous"
+              'anonymous'
             end
           end
 
           # Create a Span Event for each error that occurs at query level.
-          #
-          # These are represented in the Datadog App as special GraphQL errors,
-          # given their event name `dd.graphql.query.error`.
           def add_query_error_events(span, errors)
-            capture_extensions = Datadog.configuration.tracing[:graphql][:error_extensions]
             errors.each do |error|
-              extensions = if !capture_extensions.empty? && (extensions = error.extensions)
+              attributes = if !@error_extensions_config.empty? && (extensions = error.extensions)
                 # Capture extensions, ensuring all values are primitives
                 extensions.each_with_object({}) do |(key, value), hash|
-                  next unless capture_extensions.include?(key.to_s)
+                  next unless @error_extensions_config.include?(key.to_s)
 
                   value = case value
                   when TrueClass, FalseClass, Integer, Float
                     value
                   else
-                    # Stringify anything that is not a boolean or a number
                     value.to_s
                   end
 
-                  hash["extensions.#{key}"] = value
+                  hash[@extensions_key + key.to_s] = value
                 end
               else
                 {}
@@ -235,16 +260,16 @@ module Datadog
               # This is an unwritten contract in the `graphql` library.
               # See for an example: https://github.com/rmosolgo/graphql-ruby/blob/0afa241775e5a113863766cce126214dee093464/lib/graphql/execution_error.rb#L32
               graphql_error = error.to_h
-              error = Core::Error.build_from(error)
-
-              span.span_events << Datadog::Tracing::SpanEvent.new(
-                Ext::EVENT_QUERY_ERROR,
-                attributes: extensions.merge!(
-                  message: graphql_error['message'],
-                  type: error.type,
-                  stacktrace: error.backtrace,
-                  locations: serialize_error_locations(graphql_error['locations']),
-                  path: graphql_error['path'],
+              parsed_error = Core::Error.build_from(error)
+
+              span.span_events << SpanEvent.new(
+                @event_name,
+                attributes: attributes.merge!(
+                  @type_key => parsed_error.type,
+                  @stacktrace_key => parsed_error.backtrace,
+                  @message_key => graphql_error['message'],
+                  @locations_key => serialize_error_locations(graphql_error['locations']),
+                  @path_key => graphql_error['path'],
                 )
               )
             end