datadog 2.2.0 → 2.4.0

data/lib/datadog/di/serializer.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require_relative "redactor"
+
+module Datadog
+  module DI
+    # Serializes captured snapshot to primitive types, which are subsequently
+    # serialized to JSON and sent to the backend.
+    #
+    # This class performs actual removal of sensitive values from the
+    # snapshots. It uses Redactor to determine which values are sensitive
+    # and need to be removed.
+    #
+    # Serializer normally ought not to invoke user (application) code,
+    # to guarantee predictable performance. However, objects like ActiveRecord
+    # models cannot be usefully serialized into primitive types without
+    # custom logic (for example, the attributes are more than 3 levels
+    # down from the top-level object which is the default capture depth,
+    # thus they won't be captured at all). To accommodate complex objects,
+    # there is an extension mechanism implemented permitting registration
+    # of serializer callbacks for arbitrary types. Applications and libraries
+    # definining such serializer callbacks should be very careful to
+    # have predictable performance and avoid exceptions and infinite loops
+    # and other such issues.
+    #
+    # All serialization methods take the names of the variables being
+    # serialized in order to be able to redact values.
+    #
+    # @api private
+    class Serializer
+      def initialize(settings, redactor)
+        @settings = settings
+        @redactor = redactor
+      end
+
+      attr_reader :settings
+      attr_reader :redactor
+
+      # Serializes positional and keyword arguments to a method,
+      # as obtained by a method probe.
+      #
+      # UI supports a single argument list only and does not distinguish
+      # 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)
+        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)
+        serialize_vars(combined)
+      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)
+        vars.each_with_object({}) do |(k, v), agg|
+          agg[k] = serialize_value(v, name: k)
+        end
+      end
+
+      # Serializes a single named value.
+      #
+      # The name is needed to perform sensitive data redaction.
+      #
+      # In some cases, the value being serialized does not have a name
+      # (for example, it is the return value of a method).
+      # In this case +name+ can be nil.
+      #
+      # Returns a data structure comprised of only values of basic types
+      # (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)
+        if redactor.redact_type?(value)
+          return {type: class_name(value.class), notCapturedReason: "redactedType"}
+        end
+
+        if name && redactor.redact_identifier?(name)
+          return {type: class_name(value.class), notCapturedReason: "redactedIdent"}
+        end
+
+        serialized = {type: class_name(value.class)}
+        case value
+        when NilClass
+          serialized.update(isNull: true)
+        when Integer, Float, TrueClass, FalseClass
+          serialized.update(value: value.to_s)
+        when String, Symbol
+          value = value.to_s
+          max = settings.dynamic_instrumentation.max_capture_string_length
+          if value.length > max
+            serialized.update(truncated: true, size: value.length)
+            value = value[0...max]
+          end
+          serialized.update(value: value)
+        when Array
+          if depth < 0
+            serialized.update(notCapturedReason: "depth")
+          else
+            max = settings.dynamic_instrumentation.max_capture_collection_size
+            if max != 0 && value.length > max
+              serialized.update(notCapturedReason: "collectionSize", size: value.length)
+              # same steep failure with array slices.
+              # https://github.com/soutaro/steep/issues/1219
+              value = value[0...max] || []
+            end
+            entries = value.map do |elt|
+              serialize_value(elt, depth: depth - 1)
+            end
+            serialized.update(elements: entries)
+          end
+        when Hash
+          if depth < 0
+            serialized.update(notCapturedReason: "depth")
+          else
+            max = settings.dynamic_instrumentation.max_capture_collection_size
+            cur = 0
+            entries = []
+            value.each do |k, v|
+              if max != 0 && cur >= max
+                serialized.update(notCapturedReason: "collectionSize", size: value.length)
+                break
+              end
+              cur += 1
+              entries << [serialize_value(k, depth: depth - 1), serialize_value(v, name: k, depth: depth - 1)]
+            end
+            serialized.update(entries: entries)
+          end
+        else
+          if depth < 0
+            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
+            # order when calling #instance_variables. Previous JRuby versions
+            # did not preserve order and returned the variables in arbitrary
+            # order.
+            #
+            # The arbitrary order is problematic because 1) when there are
+            # fewer instance variables than capture limit, the order in which
+            # the variables are shown in UI will change from one capture to
+            # the next and generally will be arbitrary to the user, and
+            # 2) when there are more instance variables than capture limit,
+            # *which* variables are captured will also change meaning user
+            # looking at the UI may have "new" instance variables appear and
+            # existing ones disappear as they are looking at multiple captures.
+            #
+            # For consistency, we should have some kind of stable order of
+            # instance variables on all supported Ruby runtimes, so that the UI
+            # stays consistent. Given that initial implementation of Ruby DI
+            # does not support JRuby, we don't handle JRuby's lack of ordering
+            # of #instance_variables here, but if JRuby is supported in the
+            # future this may need to be addressed.
+            ivars = value.instance_variables
+
+            ivars.each do |ivar|
+              if cur >= max
+                serialized.update(notCapturedReason: "fieldCount", fields: fields)
+                break
+              end
+              cur += 1
+              fields[ivar] = serialize_value(value.instance_variable_get(ivar), name: ivar, depth: depth - 1)
+            end
+            serialized.update(fields: fields)
+          end
+        end
+        serialized
+      end
+
+      private
+
+      # Returns the name for the specified class object.
+      #
+      # Ruby can have nameless classes, e.g. Class.new is a class object
+      # with no name. We return a placeholder for such nameless classes.
+      def class_name(cls)
+        # We could call `cls.to_s` to get the "standard" Ruby inspection of
+        # the class, but it is likely that user code can override #to_s
+        # and we don't want to invoke user code.
+        cls.name || "[Unnamed class]"
+      end
+    end
+  end
+end

data/lib/datadog/di.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative 'di/configuration'
+require_relative 'di/extensions'
+
+module Datadog
+  # Namespace for Datadog dynamic instrumentation.
+  #
+  # @api private
+  module DI
+    # Expose DI to global shared objects
+    Extensions.activate!
+  end
+end

data/lib/datadog/kit/appsec/events.rb

@@ -53,13 +53,11 @@ module Datadog
           # @param user_exists [bool] Whether the user id that did a login attempt exists.
           # @param others [Hash<String || Symbol, String>] Additional free-form
           #   event information to attach to the trace.
-          def track_login_failure(trace = nil, span = nil, user_id:, user_exists:, **others)
+          def track_login_failure(trace = nil, span = nil, user_exists:, user_id: nil, **others)
             set_trace_and_span_context('track_login_failure', trace, span) do |active_trace, active_span|
-              raise ArgumentError, 'user_id cannot be nil' if user_id.nil?
-
               track(LOGIN_FAILURE_EVENT, active_trace, active_span, **others)
 
-              active_span.set_tag('appsec.events.users.login.failure.usr.id', user_id)
+              active_span.set_tag('appsec.events.users.login.failure.usr.id', user_id) if user_id
               active_span.set_tag('appsec.events.users.login.failure.usr.exists', user_exists)
             end
           end

data/lib/datadog/opentelemetry/sdk/propagator.rb

@@ -15,6 +15,7 @@ module Datadog
           setter: ::OpenTelemetry::Context::Propagation.text_map_setter
         )
           unless setter == ::OpenTelemetry::Context::Propagation.text_map_setter
+            # PENDING: Not to report telemetry logs for now
             Datadog.logger.error(
               'Custom setter is not supported. Please inform the `datadog` team at ' \
             ' https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default ' \
@@ -31,6 +32,7 @@ module Datadog
         )
           if getter != ::OpenTelemetry::Context::Propagation.text_map_getter &&
               getter != ::OpenTelemetry::Common::Propagation.rack_env_getter
+            # PENDING: Not to report telemetry logs for now
             Datadog.logger.error(
               "Custom getter #{getter} is not supported. Please inform the `datadog` team at " \
             ' https://github.com/DataDog/dd-trace-rb of your use case so we can best support you. Using the default ' \

data/lib/datadog/opentelemetry/sdk/span_processor.rb

@@ -2,6 +2,7 @@
 
 require_relative 'trace/span'
 require_relative '../../tracing/span_link'
+require_relative '../../tracing/span_event'
 require_relative '../../tracing/trace_digest'
 
 module Datadog
@@ -31,6 +32,15 @@ module Datadog
         #
         # @param [Span] span the {Span} that just ended.
         def on_finish(span)
+          unless span.events.nil?
+            span.datadog_span.span_events = span.events.map do |event|
+              Datadog::Tracing::SpanEvent.new(
+                event.name,
+                attributes: event.attributes,
+                time_unix_nano: event.timestamp
+              )
+            end
+          end
           span.datadog_span.finish(ns_to_time(span.end_timestamp))
         end
 

data/lib/datadog/opentelemetry/sdk/trace/span.rb

@@ -15,6 +15,29 @@ module Datadog
           res
         end
 
+        # Record an exception during the execution of this span. Multiple exceptions
+        # can be recorded on a span.
+        #
+        # @param [Exception] exception The exception to recorded
+        # @param [optional Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}]
+        #   attributes One or more key:value pairs, where the keys must be
+        #   strings and the values may be (array of) string, boolean or numeric
+        #   type.
+        #
+        # @return [void]
+        def record_exception(exception, attributes: nil)
+          res = super
+          if (span = datadog_span)
+            # Sets the exception attributes as span error tags. The values in the attribute hash MUST
+            # take precedence over the type, message and stacktrace inferred from the exception object
+            type = attributes&.[]('exception.type') || exception.class.to_s
+            message = attributes&.[]('exception.message') || exception.message
+            stacktrace = attributes&.[]('exception.stacktrace') || exception.full_message(highlight: false, order: :top)
+            span.set_error_tags([type, message, stacktrace])
+          end
+          res
+        end
+
         # `alias` performed to match {OpenTelemetry::SDK::Trace::Span} aliasing upstream
         alias []= set_attribute
 

data/lib/datadog/profiling/collectors/code_provenance.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'set'
-require 'json'
+require "set"
+require "json"
 
 module Datadog
   module Profiling
@@ -14,7 +14,7 @@ module Datadog
       #
       # This class acts both as a collector (collecting data) as well as a recorder (records/serializes it)
       class CodeProvenance
-        def initialize(standard_library_path: RbConfig::CONFIG.fetch('rubylibdir'))
+        def initialize(standard_library_path: RbConfig::CONFIG.fetch("rubylibdir"))
           @libraries_by_name = {}
           @libraries_by_path = {}
           @seen_files = Set.new
@@ -22,8 +22,8 @@ module Datadog
 
           record_library(
             Library.new(
-              kind: 'standard library',
-              name: 'stdlib',
+              kind: "standard library",
+              name: "stdlib",
               version: RUBY_VERSION,
               path: standard_library_path,
             )
@@ -79,7 +79,7 @@ module Datadog
           loaded_specs.each do |spec|
             next if libraries_by_name.key?(spec.name)
 
-            record_library(Library.new(kind: 'library', name: spec.name, version: spec.version, path: spec.gem_dir))
+            record_library(Library.new(kind: "library", name: spec.name, version: spec.version, path: spec.gem_dir))
             recorded_library = true
           end
 
@@ -119,7 +119,7 @@ module Datadog
           end
 
           def to_json(arg = nil)
-            { kind: @kind, name: @name, version: @version, paths: @paths }.to_json(arg)
+            {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg)
           end
 
           def path

data/lib/datadog/profiling/collectors/cpu_and_wall_time_worker.rb

@@ -21,6 +21,8 @@ module Datadog
           thread_context_collector:,
           dynamic_sampling_rate_overhead_target_percentage:,
           allocation_profiling_enabled:,
+          allocation_counting_enabled:,
+          gvl_profiling_enabled:,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
@@ -29,20 +31,22 @@ module Datadog
         )
           unless dynamic_sampling_rate_enabled
             Datadog.logger.warn(
-              'Profiling dynamic sampling rate disabled. This should only be used for testing, and will increase overhead!'
+              "Profiling dynamic sampling rate disabled. This should only be used for testing, and will increase overhead!"
             )
           end
 
           self.class._native_initialize(
-            self,
-            thread_context_collector,
-            gc_profiling_enabled,
-            idle_sampling_helper,
-            no_signals_workaround_enabled,
-            dynamic_sampling_rate_enabled,
-            dynamic_sampling_rate_overhead_target_percentage,
-            allocation_profiling_enabled,
-            skip_idle_samples_for_testing,
+            self_instance: self,
+            thread_context_collector: thread_context_collector,
+            gc_profiling_enabled: gc_profiling_enabled,
+            idle_sampling_helper: idle_sampling_helper,
+            no_signals_workaround_enabled: no_signals_workaround_enabled,
+            dynamic_sampling_rate_enabled: dynamic_sampling_rate_enabled,
+            dynamic_sampling_rate_overhead_target_percentage: dynamic_sampling_rate_overhead_target_percentage,
+            allocation_profiling_enabled: allocation_profiling_enabled,
+            allocation_counting_enabled: allocation_counting_enabled,
+            gvl_profiling_enabled: gvl_profiling_enabled,
+            skip_idle_samples_for_testing: skip_idle_samples_for_testing,
           )
           @worker_thread = nil
           @failure_exception = nil
@@ -54,27 +58,25 @@ module Datadog
 
         def start(on_failure_proc: nil)
           @start_stop_mutex.synchronize do
-            return if @worker_thread && @worker_thread.alive?
+            return if @worker_thread&.alive?
 
             Datadog.logger.debug { "Starting thread for: #{self}" }
 
             @idle_sampling_helper.start
 
             @worker_thread = Thread.new do
-              begin
-                Thread.current.name = self.class.name
-
-                self.class._native_sampling_loop(self)
-
-                Datadog.logger.debug('CpuAndWallTimeWorker thread stopping cleanly')
-              rescue Exception => e # rubocop:disable Lint/RescueException
-                @failure_exception = e
-                Datadog.logger.warn(
-                  'CpuAndWallTimeWorker thread error. ' \
-                  "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
-                )
-                on_failure_proc&.call
-              end
+              Thread.current.name = self.class.name
+
+              self.class._native_sampling_loop(self)
+
+              Datadog.logger.debug("CpuAndWallTimeWorker thread stopping cleanly")
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              @failure_exception = e
+              Datadog.logger.warn(
+                "CpuAndWallTimeWorker thread error. " \
+                "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+              )
+              on_failure_proc&.call
             end
             @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap
             @worker_thread.thread_variable_set(:fork_safe, true)
@@ -85,7 +87,7 @@ module Datadog
 
         def stop
           @start_stop_mutex.synchronize do
-            Datadog.logger.debug('Requesting CpuAndWallTimeWorker thread shut down')
+            Datadog.logger.debug("Requesting CpuAndWallTimeWorker thread shut down")
 
             @idle_sampling_helper.stop
 

data/lib/datadog/profiling/collectors/idle_sampling_helper.rb

@@ -21,7 +21,7 @@ module Datadog
 
         def start
           @start_stop_mutex.synchronize do
-            return if @worker_thread && @worker_thread.alive?
+            return if @worker_thread&.alive?
 
             Datadog.logger.debug { "Starting thread for: #{self}" }
 
@@ -30,19 +30,17 @@ module Datadog
             self.class._native_reset(self)
 
             @worker_thread = Thread.new do
-              begin
-                Thread.current.name = self.class.name
+              Thread.current.name = self.class.name
 
-                self.class._native_idle_sampling_loop(self)
+              self.class._native_idle_sampling_loop(self)
 
-                Datadog.logger.debug('IdleSamplingHelper thread stopping cleanly')
-              rescue Exception => e # rubocop:disable Lint/RescueException
-                @failure_exception = e
-                Datadog.logger.warn(
-                  'IdleSamplingHelper thread error. ' \
-                  "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
-                )
-              end
+              Datadog.logger.debug("IdleSamplingHelper thread stopping cleanly")
+            rescue Exception => e # rubocop:disable Lint/RescueException
+              @failure_exception = e
+              Datadog.logger.warn(
+                "IdleSamplingHelper thread error. " \
+                "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+              )
             end
             @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap
             @worker_thread.thread_variable_set(:fork_safe, true)
@@ -53,7 +51,7 @@ module Datadog
 
         def stop
           @start_stop_mutex.synchronize do
-            Datadog.logger.debug('Requesting IdleSamplingHelper thread shut down')
+            Datadog.logger.debug("Requesting IdleSamplingHelper thread shut down")
 
             return unless @worker_thread
 

data/lib/datadog/profiling/collectors/info.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-require 'set'
-require 'time'
+require "set"
+require "time"
+require "libdatadog"
 
 module Datadog
   module Profiling
@@ -61,12 +62,20 @@ module Datadog
 
         def collect_profiler_info(settings)
           unless @profiler_info
-            lib_datadog_gem = ::Gem.loaded_specs['libdatadog']
+            lib_datadog_gem = ::Gem.loaded_specs["libdatadog"]
+
+            libdatadog_version =
+              if lib_datadog_gem
+                "#{lib_datadog_gem.version}-#{lib_datadog_gem.platform}"
+              else
+                # In some cases, Gem.loaded_specs may not be available, as in
+                # https://github.com/DataDog/dd-trace-rb/pull/1506; let's use the version directly
+                "#{Libdatadog::VERSION}-(unknown)"
+              end
+
             @profiler_info = {
-              # TODO: If profiling is extracted and its version diverges from the datadog gem, this is inaccurate.
-              #       Update if this ever occurs.
               version: Datadog::Core::Environment::Identity.gem_datadog_version,
-              libdatadog: "#{lib_datadog_gem.version}-#{lib_datadog_gem.platform}",
+              libdatadog: libdatadog_version,
               settings: collect_settings_recursively(settings.profiling),
             }.freeze
           end

data/lib/datadog/profiling/collectors/thread_context.rb

@@ -20,6 +20,8 @@ module Datadog
           tracer:,
           endpoint_collection_enabled:,
           timeline_enabled:,
+          waiting_for_gvl_threshold_ns:,
+          otel_context_enabled:,
           allocation_type_enabled: true
         )
           tracer_context_key = safely_extract_context_key_from(tracer)
@@ -30,10 +32,34 @@ module Datadog
             tracer_context_key,
             endpoint_collection_enabled,
             timeline_enabled,
+            waiting_for_gvl_threshold_ns,
+            otel_context_enabled,
             allocation_type_enabled,
           )
         end
 
+        def self.for_testing(
+          recorder:,
+          max_frames: 400,
+          tracer: nil,
+          endpoint_collection_enabled: false,
+          timeline_enabled: false,
+          waiting_for_gvl_threshold_ns: 10_000_000,
+          otel_context_enabled: false,
+          **options
+        )
+          new(
+            recorder: recorder,
+            max_frames: max_frames,
+            tracer: tracer,
+            endpoint_collection_enabled: endpoint_collection_enabled,
+            timeline_enabled: timeline_enabled,
+            waiting_for_gvl_threshold_ns: waiting_for_gvl_threshold_ns,
+            otel_context_enabled: otel_context_enabled,
+            **options,
+          )
+        end
+
         def inspect
           # Compose Ruby's default inspect with our custom inspect for the native parts
           result = super()
@@ -48,12 +74,14 @@ module Datadog
         private
 
         def safely_extract_context_key_from(tracer)
-          provider = tracer && tracer.respond_to?(:provider) && tracer.provider
+          return unless tracer
+
+          provider = tracer.respond_to?(:provider) && tracer.provider
 
           return unless provider
 
           context = provider.instance_variable_get(:@context)
-          context && context.instance_variable_get(:@key)
+          context&.instance_variable_get(:@key)
         end
       end
     end