datadog 2.5.0 → 2.7.0

data/lib/datadog/di/serializer.rb

@@ -38,13 +38,42 @@ module Datadog
     #
     # @api private
     class Serializer
-      def initialize(settings, redactor)
+      # Third-party library integration / custom serializers.
+      #
+      # Dynamic instrumentation has limited payload sizes, and for efficiency
+      # reasons it is not desirable to transmit data to Datadog that will
+      # never contain useful information. Additionally, due to depth limits,
+      # desired data may not even be included in payloads when serialized
+      # with the default, naive serializer. Therefore, custom objects like
+      # ActiveRecord model instances may need custom serializers.
+      #
+      # CUSTOMER NOTE: The API for defining custom serializers is not yet
+      # finalized. Please create an issue at
+      # https://github.com/datadog/dd-trace-rb/issues describing the
+      # object(s) you wish to serialize so that we can ensure your use case
+      # will be supported as the library evolves.
+      #
+      # Note that the current implementation does not permit defining a
+      # serializer for a particular class, which is the simplest use case.
+      # This is because the library itself does not need this functionality
+      # yet, and it won't help for ActiveRecord models (that derive from
+      # 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).
+      @@flat_registry = []
+      def self.register(condition: nil, &block)
+        @@flat_registry << {condition: condition, proc: block}
+      end
+
+      def initialize(settings, redactor, telemetry: nil)
         @settings = settings
         @redactor = redactor
+        @telemetry = telemetry
       end
 
       attr_reader :settings
       attr_reader :redactor
+      attr_reader :telemetry
 
       # Serializes positional and keyword arguments to a method,
       # as obtained by a method probe.
@@ -86,116 +115,135 @@ 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)
-        if redactor.redact_type?(value)
-          return {type: class_name(value.class), notCapturedReason: "redactedType"}
-        end
+      def serialize_value(value, name: nil, depth: settings.dynamic_instrumentation.max_capture_depth, type: nil)
+        cls = type || value.class
+        begin
+          if redactor.redact_type?(value)
+            return {type: class_name(cls), notCapturedReason: "redactedType"}
+          end
 
-        if name && redactor.redact_identifier?(name)
-          return {type: class_name(value.class), notCapturedReason: "redactedIdent"}
-        end
+          if name && redactor.redact_identifier?(name)
+            return {type: class_name(cls), 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
-          need_dup = false
-          value = if String === value
-            # This is the only place where we duplicate the value, currently.
-            # All other values are immutable primitives (e.g. numbers).
-            # However, do not duplicate if the string is frozen, or if
-            # it is later truncated.
-            need_dup = !value.frozen?
-            value
-          else
-            value.to_s
+          @@flat_registry.each do |entry|
+            if (condition = entry[:condition]) && condition.call(value)
+              serializer_proc = entry.fetch(:proc)
+              return serializer_proc.call(self, value, name: nil, depth: depth)
+            end
           end
-          max = settings.dynamic_instrumentation.max_capture_string_length
-          if value.length > max
-            serialized.update(truncated: true, size: value.length)
-            value = value[0...max]
+
+          serialized = {type: class_name(cls)}
+          case value
+          when NilClass
+            serialized.update(isNull: true)
+          when Integer, Float, TrueClass, FalseClass
+            serialized.update(value: value.to_s)
+          when Time
+            # This path also handles DateTime values although they do not need
+            # to be explicitly added to the case statement.
+            serialized.update(value: value.iso8601)
+          when Date
+            serialized.update(value: value.to_s)
+          when String, Symbol
             need_dup = false
-          end
-          value = value.dup if need_dup
-          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] || []
+            value = if String === value
+              # This is the only place where we duplicate the value, currently.
+              # All other values are immutable primitives (e.g. numbers).
+              # However, do not duplicate if the string is frozen, or if
+              # it is later truncated.
+              need_dup = !value.frozen?
+              value
+            else
+              value.to_s
             end
-            entries = value.map do |elt|
-              serialize_value(elt, depth: depth - 1)
+            max = settings.dynamic_instrumentation.max_capture_string_length
+            if value.length > max
+              serialized.update(truncated: true, size: value.length)
+              value = value[0...max]
+              need_dup = false
             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
+            value = value.dup if need_dup
+            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)
-                break
+                # 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
-              cur += 1
-              entries << [serialize_value(k, depth: depth - 1), serialize_value(v, name: k, depth: depth - 1)]
+              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
-            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
+            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
+              # 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
+              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
-              cur += 1
-              fields[ivar] = serialize_value(value.instance_variable_get(ivar), name: ivar, depth: depth - 1)
+              serialized.update(fields: fields)
             end
-            serialized.update(fields: fields)
           end
+          serialized
+        rescue => exc
+          telemetry&.report(exc, description: "Error serializing")
+          {type: class_name(cls), notSerializedReason: exc.to_s}
         end
-        serialized
       end
 
       private

data/lib/datadog/di/transport.rb

@@ -35,31 +35,44 @@ module Datadog
           StringIO.new(JSON.dump(payload)), 'application/json', 'event.json'
         )
         payload = {'event' => event_payload}
-        send_request('Probe status submission', DIAGNOSTICS_PATH, payload)
+        # Core transport unconditionally specifies headers to underlying
+        # Net::HTTP client, ends up passing 'nil' as headers if none are
+        # specified by us, which then causes Net::HTTP to die with an exception.
+        send_request('Probe status submission',
+          path: DIAGNOSTICS_PATH, form: payload, headers: {})
       end
 
       def send_input(payload)
-        send_request('Probe snapshot submission', INPUT_PATH, payload,
+        send_request('Probe snapshot submission',
+          path: INPUT_PATH, body: payload.to_s,
           headers: {'content-type' => 'application/json'},)
       end
 
+      # TODO status should use either input or diagnostics endpoints
+      # depending on agent version.
+      alias_method :send_status, :send_diagnostics
+
+      alias_method :send_snapshot, :send_input
+
       private
 
       attr_reader :client
 
-      def send_request(desc, path, payload, headers: {})
+      def send_request(desc, **options)
         # steep:ignore:start
-        env = OpenStruct.new(
-          path: path,
-          form: payload,
-          headers: headers,
-        )
+        env = OpenStruct.new(**options)
         # steep:ignore:end
         response = client.post(env)
         unless response.ok?
           raise Error::AgentCommunicationError, "#{desc} failed: #{response.code}: #{response.payload}"
         end
-      rescue IOError, SystemCallError => exc
+      # Datadog::Core::Transport does not perform any exception mapping,
+      # therefore we could have any exception here from failure to parse
+      # agent URI for example.
+      # If we ever implement retries for network errors, we should distinguish
+      # actual network errors from non-network errors that are raised by
+      # transport code.
+      rescue => exc
         raise Error::AgentCommunicationError, "#{desc} failed: #{exc.class}: #{exc}"
       end
     end

data/lib/datadog/di.rb

@@ -1,21 +1,44 @@
 # frozen_string_literal: true
 
 require_relative 'di/error'
-require_relative 'di/configuration'
 require_relative 'di/code_tracker'
+require_relative 'di/component'
+require_relative 'di/configuration'
 require_relative 'di/extensions'
 require_relative 'di/instrumenter'
 require_relative 'di/probe'
+require_relative 'di/probe_builder'
+require_relative 'di/probe_manager'
+require_relative 'di/probe_notification_builder'
+require_relative 'di/probe_notifier_worker'
 require_relative 'di/redactor'
 require_relative 'di/serializer'
 require_relative 'di/transport'
 require_relative 'di/utils'
 
+if defined?(ActiveRecord::Base)
+  # The third-party library integrations need to be loaded after the
+  # third-party libraries are loaded. Tracing and appsec use Railtie
+  # to delay integrations until all of the application's dependencies
+  # are loaded, when running under Rails. We should do the same here in
+  # principle, however DI currently only has an ActiveRecord integration
+  # and AR should be loaded before any application code is loaded, being
+  # part of Rails, therefore for now we should be OK to just require the
+  # AR integration from here.
+  require_relative 'di/contrib/active_record'
+end
+
 module Datadog
   # Namespace for Datadog dynamic instrumentation.
   #
   # @api private
   module DI
+    class << self
+      def enabled?
+        Datadog.configuration.dynamic_instrumentation.enabled
+      end
+    end
+
     # Expose DI to global shared objects
     Extensions.activate!
 
@@ -52,6 +75,31 @@ module Datadog
       def code_tracking_active?
         code_tracker&.active? || false
       end
+
+      def component
+        # TODO uncomment when remote is merged
+        #Datadog.send(:components).dynamic_instrumentation
+      end
+    end
+  end
+end
+
+=begin not yet enabled
+# :script_compiled trace point was added in Ruby 2.6.
+if RUBY_VERSION >= '2.6'
+  begin
+    # Activate code tracking by default because line trace points will not work
+    # without it.
+    Datadog::DI.activate_tracking!
+  rescue => exc
+    if defined?(Datadog.logger)
+      Datadog.logger.warn("Failed to activate code tracking for DI: #{exc.class}: #{exc}")
+    else
+      # We do not have Datadog logger potentially because DI code tracker is
+      # being loaded early in application boot process and the rest of datadog
+      # wasn't loaded yet. Output to standard error.
+      warn("Failed to activate code tracking for DI: #{exc.class}: #{exc}")
     end
   end
 end
+=end

data/lib/datadog/version.rb

@@ -3,7 +3,7 @@
 module Datadog
   module VERSION
     MAJOR = 2
-    MINOR = 5
+    MINOR = 7
     PATCH = 0
     PRE = nil
     BUILD = nil

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datadog
 version: !ruby/object:Gem::Version
-  version: 2.5.0
+  version: 2.7.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-05 00:00:00.000000000 Z
+date: 2024-11-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 13.1.0.1.0
+        version: 14.1.0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 13.1.0.1.0
+        version: 14.1.0.1.0
 description: |
   datadog is Datadog's client library for Ruby. It includes a suite of tools
   which provide visibility into the performance and security of Ruby applications,
@@ -364,13 +364,16 @@ files:
 - lib/datadog/core/workers/runtime_metrics.rb
 - lib/datadog/di.rb
 - lib/datadog/di/code_tracker.rb
+- lib/datadog/di/component.rb
 - lib/datadog/di/configuration.rb
 - lib/datadog/di/configuration/settings.rb
+- lib/datadog/di/contrib/active_record.rb
 - lib/datadog/di/error.rb
 - lib/datadog/di/extensions.rb
 - lib/datadog/di/instrumenter.rb
 - lib/datadog/di/probe.rb
 - lib/datadog/di/probe_builder.rb
+- lib/datadog/di/probe_manager.rb
 - lib/datadog/di/probe_notification_builder.rb
 - lib/datadog/di/probe_notifier_worker.rb
 - lib/datadog/di/redactor.rb
@@ -895,8 +898,8 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.5.0/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.5.0
+  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.7.0/CHANGELOG.md
+  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.7.0
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -915,7 +918,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications