datadog 2.6.0 → 2.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 23fdb98e800ed71c28238b4b61e7f1187b27833d8e98c14e0f60d43ce838d4cd
-  data.tar.gz: ed99ae40d1e94aedcf27f8bcdeb70059c02ad116e8648621e37d22d5be1f69ad
+  metadata.gz: '00617590b3381113b74dde6671802aad74e6ffee0a96737fbc04149515c6a79d'
+  data.tar.gz: 5bed675aca238d308051ba0a728209e2a4a5ba17f2dc11a52eacee8aaf55a123
 SHA512:
-  metadata.gz: df3d8bc5efb89bb7a893b006484d3d826acf7beb57d6abbf8b25c2e9a277a95f7f681d6262d5dd08485aaf5526c677edf641711435e67674f1043c1fbf1ba55f
-  data.tar.gz: 02b397ae85a8ced3f6112beb899826c86ba137be36c229a85150cdc708dadd937e9860775bdfd02d7475bb4f7c890b1019901ec146acb5ad21bdd192906aa339
+  metadata.gz: 4097896d2d8126418f0827b9c4ad916a003e71ead0919fae2b3586415540f869d58f140865d4c625d20fd4de6a76bcf667156893e7c01f0fee981b7fcb6cafe9
+  data.tar.gz: ce91b73f91a97db31570bd92dab0ca26bf7a6b849d67b774a4efacea0ec93e19f19c27a3dc3f0f232f2adce6cf5ed13b510c30651c529a6b402137944a6b2e87

data/CHANGELOG.md

@@ -2,6 +2,28 @@
 
 ## [Unreleased]
 
+## [2.7.1] - 2024-11-28
+
+### Fixed
+
+* Tracing: Fix missing version tag ([#4075][])
+* Profiling: Fix profiling not loading in certain situations on Ruby 2.5 and 3.3 ([#4161][])
+
+## [2.7.0] - 2024-11-13
+
+### Added
+
+* Profiling: Enable "heap clean after GC" profiler optimization by default ([#4085][])
+
+### Changed
+
+* Enable crashtracking by default ([#4083][])
+* Upgrade to `libdatadog` 14.1 ([#4082][])
+
+### Fixed
+
+* Fix `Process.waitall` hanging and stack overflow when crashtracking enabled ([#4082][])
+
 ## [2.6.0] - 2024-11-06
 
 ### Changed
@@ -3013,7 +3035,8 @@ Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.3.1
 Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 
 
-[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.6.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v2.7.0...master
+[2.7.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.6.0...v2.7.0
 [2.6.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.5.0...v2.6.0
 [2.5.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.4.0...v2.5.0
 [2.4.0]: https://github.com/DataDog/dd-trace-rb/compare/v2.3.0...v2.4.0
@@ -4457,7 +4480,12 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#4027]: https://github.com/DataDog/dd-trace-rb/issues/4027
 [#4033]: https://github.com/DataDog/dd-trace-rb/issues/4033
 [#4065]: https://github.com/DataDog/dd-trace-rb/issues/4065
+[#4075]: https://github.com/DataDog/dd-trace-rb/issues/4075
 [#4078]: https://github.com/DataDog/dd-trace-rb/issues/4078
+[#4082]: https://github.com/DataDog/dd-trace-rb/issues/4082
+[#4083]: https://github.com/DataDog/dd-trace-rb/issues/4083
+[#4085]: https://github.com/DataDog/dd-trace-rb/issues/4085
+[#4161]: https://github.com/DataDog/dd-trace-rb/issues/4161
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot

data/ext/datadog_profiling_native_extension/extconf.rb

@@ -131,6 +131,9 @@ end
 
 have_func "malloc_stats"
 
+# On Ruby 2.5 and 3.3, this symbol was not visible. It is on 2.6 to 3.2, as well as 3.4+
+$defs << "-DNO_RB_OBJ_INFO" if RUBY_VERSION.start_with?("2.5", "3.3")
+
 # On older Rubies, rb_postponed_job_preregister/rb_postponed_job_trigger did not exist
 $defs << "-DNO_POSTPONED_TRIGGER" if RUBY_VERSION < "3.3"
 

data/ext/datadog_profiling_native_extension/private_vm_api_access.c

@@ -587,16 +587,13 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *st
 // Taken from upstream vm_insnhelper.c at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
 // Copyright (C) 2007 Koichi Sasada
 // to support our custom rb_profile_frames (see above)
-// Modifications: None
+// Modifications:
+// * Removed debug checks (they were ifdef'd out anyway)
 static rb_callable_method_entry_t *
 check_method_entry(VALUE obj, int can_be_svar)
 {
     if (obj == Qfalse) return NULL;
 
-#if VM_CHECK_MODE > 0
-    if (!RB_TYPE_P(obj, T_IMEMO)) rb_bug("check_method_entry: unknown type: %s", rb_obj_info(obj));
-#endif
-
     switch (imemo_type(obj)) {
       case imemo_ment:
         return (rb_callable_method_entry_t *)obj;
@@ -608,9 +605,6 @@ check_method_entry(VALUE obj, int can_be_svar)
         }
         // fallthrough
       default:
-#if VM_CHECK_MODE > 0
-        rb_bug("check_method_entry: svar should not be there:");
-#endif
         return NULL;
     }
 }

data/ext/datadog_profiling_native_extension/profiling.c

@@ -37,6 +37,7 @@ static VALUE _native_trigger_holding_the_gvl_signal_handler_on(DDTRACE_UNUSED VA
 static VALUE _native_enforce_success(DDTRACE_UNUSED VALUE _self, VALUE syserr_errno, VALUE with_gvl);
 static void *trigger_enforce_success(void *trigger_args);
 static VALUE _native_malloc_stats(DDTRACE_UNUSED VALUE _self);
+static VALUE _native_safe_object_info(DDTRACE_UNUSED VALUE _self, VALUE obj);
 
 void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   VALUE datadog_module = rb_define_module("Datadog");
@@ -72,6 +73,7 @@ void DDTRACE_EXPORT Init_datadog_profiling_native_extension(void) {
   rb_define_singleton_method(testing_module, "_native_trigger_holding_the_gvl_signal_handler_on", _native_trigger_holding_the_gvl_signal_handler_on, 1);
   rb_define_singleton_method(testing_module, "_native_enforce_success", _native_enforce_success, 2);
   rb_define_singleton_method(testing_module, "_native_malloc_stats", _native_malloc_stats, 0);
+  rb_define_singleton_method(testing_module, "_native_safe_object_info", _native_safe_object_info, 1);
 }
 
 static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
@@ -265,3 +267,7 @@ static VALUE _native_malloc_stats(DDTRACE_UNUSED VALUE _self) {
     return Qfalse;
   #endif
 }
+
+static VALUE _native_safe_object_info(DDTRACE_UNUSED VALUE _self, VALUE obj) {
+  return rb_str_new_cstr(safe_object_info(obj));
+}

data/ext/datadog_profiling_native_extension/ruby_helpers.c

@@ -3,6 +3,7 @@
 
 #include "ruby_helpers.h"
 #include "private_vm_api_access.h"
+#include "extconf.h"
 
 // The following global variables are initialized at startup to save expensive lookups later.
 // They are not expected to be mutated outside of init.
@@ -219,17 +220,26 @@ static bool ruby_is_obj_with_class(VALUE obj) {
   return false;
 }
 
-// These two functions are not present in the VM headers, but are public symbols that can be invoked.
+// This function is not present in the VM headers, but is a public symbol that can be invoked.
 int rb_objspace_internal_object_p(VALUE obj);
-const char *rb_obj_info(VALUE obj);
+
+#ifdef NO_RB_OBJ_INFO
+  const char* safe_object_info(DDTRACE_UNUSED VALUE obj) { return "(No rb_obj_info for current Ruby)"; }
+#else
+  // This function is a public symbol, but not on all Rubies; `safe_object_info` below abstracts this, and
+  // should be used instead.
+  const char *rb_obj_info(VALUE obj);
+
+  const char* safe_object_info(VALUE obj) { return rb_obj_info(obj); }
+#endif
 
 VALUE ruby_safe_inspect(VALUE obj) {
   if (!ruby_is_obj_with_class(obj))       return rb_str_new_cstr("(Not an object)");
-  if (rb_objspace_internal_object_p(obj)) return rb_sprintf("(VM Internal, %s)", rb_obj_info(obj));
+  if (rb_objspace_internal_object_p(obj)) return rb_sprintf("(VM Internal, %s)", safe_object_info(obj));
   // @ivoanjo: I saw crashes on Ruby 3.1.4 when trying to #inspect matchdata objects. I'm not entirely sure why this
   // is needed, but since we only use this method for debug purposes I put in this alternative and decided not to
   // dig deeper.
-  if (rb_type(obj) == RUBY_T_MATCH)   return rb_sprintf("(MatchData, %s)", rb_obj_info(obj));
+  if (rb_type(obj) == RUBY_T_MATCH)   return rb_sprintf("(MatchData, %s)", safe_object_info(obj));
   if (rb_respond_to(obj, inspect_id)) return rb_sprintf("%+"PRIsVALUE, obj);
   if (rb_respond_to(obj, to_s_id))    return rb_sprintf("%"PRIsVALUE, obj);
 

data/ext/datadog_profiling_native_extension/ruby_helpers.h

@@ -90,3 +90,7 @@ size_t ruby_obj_memsize_of(VALUE obj);
 // return a string with the result of that call. Elsif the object responds to
 // 'to_s', return a string with the result of that call. Otherwise, return Qnil.
 VALUE ruby_safe_inspect(VALUE obj);
+
+// You probably want ruby_safe_inspect instead; this is a lower-level dependency
+// of it, that's being exposed here just to facilitate testing.
+const char* safe_object_info(VALUE obj);

data/ext/libdatadog_api/crashtracker.c

@@ -58,16 +58,18 @@ static VALUE _native_start_or_update_on_fork(int argc, VALUE *argv, DDTRACE_UNUS
 
   ddog_crasht_Config config = {
     .additional_files = {},
-    // The Ruby VM already uses an alt stack to detect stack overflows so the crash handler must not overwrite it.
+    // @ivoanjo: The Ruby VM already uses an alt stack to detect stack overflows.
     //
-    // @ivoanjo: Specifically, with `create_alt_stack = true` I saw a segfault, such as Ruby 2.6's bug with
+    // In libdatadog < 14 with `create_alt_stack = true` I saw a segfault, such as Ruby 2.6's bug with
     // "Process.detach(fork { exit! }).instance_variable_get(:@foo)" being turned into a
     // "-e:1:in `instance_variable_get': stack level too deep (SystemStackError)" by Ruby.
-    //
     // The Ruby crash handler also seems to get confused when this option is enabled and
     // "Process.kill('SEGV', Process.pid)" gets run.
+    //
+    // This actually changed in libdatadog 14, so I could see no issues with `create_alt_stack = true`, but not
+    // overridding what Ruby set up seems a saner default to keep anyway.
     .create_alt_stack = false,
-    .use_alt_stack = true, // NOTE: This is a no-op in libdatadog 14.0; should be fixed in a future version
+    .use_alt_stack = true,
     .endpoint = endpoint,
     .resolve_frames = DDOG_CRASHT_STACKTRACE_COLLECTION_ENABLED_WITH_SYMBOLS_IN_RECEIVER,
     .timeout_ms = FIX2INT(upload_timeout_seconds) * 1000,

data/ext/libdatadog_extconf_helpers.rb

@@ -8,7 +8,7 @@ module Datadog
   module LibdatadogExtconfHelpers
     # Used to make sure the correct gem version gets loaded, as extconf.rb does not get run with "bundle exec" and thus
     # may see multiple libdatadog versions. See https://github.com/DataDog/dd-trace-rb/pull/2531 for the horror story.
-    LIBDATADOG_VERSION = '~> 14.0.0.1.0'
+    LIBDATADOG_VERSION = '~> 14.1.0.1.0'
 
     # Used as an workaround for a limitation with how dynamic linking works in environments where the datadog gem and
     # libdatadog are moved after the extension gets compiled.

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

@@ -518,13 +518,13 @@ module Datadog
             # Controls if the heap profiler should attempt to clean young objects after GC, rather than just at
             # serialization time. This lowers memory usage and high percentile latency.
             #
-            # Only takes effect when used together with `gc_enabled: true` and `experimental_heap_enabled: true`.
+            # Only has effect when used together with `gc_enabled: true` and `experimental_heap_enabled: true`.
             #
-            # @default false
+            # @default true
             option :heap_clean_after_gc_enabled do |o|
               o.type :bool
               o.env 'DD_PROFILING_HEAP_CLEAN_AFTER_GC_ENABLED'
-              o.default false
+              o.default true
             end
           end
 
@@ -927,7 +927,7 @@ module Datadog
           # Enables reporting of information when Ruby VM crashes.
           option :enabled do |o|
             o.type :bool
-            o.default false
+            o.default true
             o.env 'DD_CRASHTRACKING_ENABLED'
           end
         end

data/lib/datadog/di/code_tracker.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# rubocop:disable Lint/AssignmentInCondition
+
 module Datadog
   module DI
     # Tracks loaded Ruby code by source file and maintains a map from
@@ -77,6 +79,26 @@ module Datadog
                 registry[path] = tp.instruction_sequence
               end
             end
+
+            DI.component&.probe_manager&.install_pending_line_probes(path)
+
+          # Since this method normally is called from customer applications,
+          # rescue any exceptions that might not be handled to not break said
+          # customer applications.
+          rescue => exc
+            # TODO we do not have DI.component defined yet, remove steep:ignore
+            # before release.
+            if component = DI.component # steep:ignore
+              raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
+              component.logger.warn("Unhandled exception in script_compiled trace point: #{exc.class}: #{exc}")
+              component.telemetry&.report(exc, description: "Unhandled exception in script_compiled trace point")
+              # TODO test this path
+            else
+              # If we don't have a component, we cannot log anything properly.
+              # Do not just print a warning to avoid spamming customer logs.
+              # Don't reraise the exception either.
+              # TODO test this path
+            end
           end
         end
       end
@@ -112,15 +134,18 @@ module Datadog
       def iseqs_for_path_suffix(suffix)
         registry_lock.synchronize do
           exact = registry[suffix]
-          return [exact] if exact
+          return [suffix, exact] if exact
 
           inexact = []
           registry.each do |path, iseq|
             if Utils.path_matches_suffix?(path, suffix)
-              inexact << iseq
+              inexact << [path, iseq]
             end
           end
-          inexact
+          if inexact.length > 1
+            raise Error::MultiplePathsMatch, "Multiple paths matched requested suffix"
+          end
+          inexact.first
         end
       end
 
@@ -164,3 +189,5 @@ module Datadog
     end
   end
 end
+
+# rubocop:enable Lint/AssignmentInCondition

data/lib/datadog/di/component.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Datadog
+  module DI
+    # Component for dynamic instrumentation.
+    #
+    # Only one instance of the Component should ever be active;
+    # if configuration is changed, the old distance should be shut down
+    # prior to the new instance being created.
+    #
+    # The Component instance stores all state related to DI, for example
+    # which probes have been retrieved via remote config,
+    # intalled tracepoints and so on. Component will clean up all
+    # resources and installed tracepoints upon shutdown.
+    class Component
+      class << self
+        def build(settings, agent_settings, telemetry: nil)
+          return unless settings.respond_to?(:dynamic_instrumentation) && settings.dynamic_instrumentation.enabled
+
+          unless settings.respond_to?(:remote) && settings.remote.enabled
+            Datadog.logger.debug("Dynamic Instrumentation could not be enabled because Remote Configuration Management is not available. To enable Remote Configuration, see https://docs.datadoghq.com/agent/remote_config")
+            return
+          end
+
+          return unless environment_supported?(settings)
+
+          new(settings, agent_settings, Datadog.logger, code_tracker: DI.code_tracker, telemetry: telemetry)
+        end
+
+        def build!(settings, agent_settings, telemetry: nil)
+          unless settings.respond_to?(:dynamic_instrumentation) && settings.dynamic_instrumentation.enabled
+            raise "Requested DI component but DI is not enabled in settings"
+          end
+
+          unless settings.respond_to?(:remote) && settings.remote.enabled
+            raise "Requested DI component but remote config is not enabled in settings"
+          end
+
+          unless environment_supported?(settings)
+            raise "DI does not support the environment (development or Ruby version too low or not MRI)"
+          end
+
+          new(settings, agent_settings, Datadog.logger, code_tracker: DI.code_tracker, telemetry: telemetry)
+        end
+
+        # Checks whether the runtime environment is supported by
+        # dynamic instrumentation. Currently we only require that, if Rails
+        # is used, that Rails environment is not development because
+        # DI does not currently support code unloading and reloading.
+        def environment_supported?(settings)
+          # TODO add tests?
+          unless settings.dynamic_instrumentation.internal.development
+            if Datadog::Core::Environment::Execution.development?
+              Datadog.logger.debug("Not enabling dynamic instrumentation because we are in development environment")
+              return false
+            end
+          end
+          if RUBY_ENGINE != 'ruby' || RUBY_VERSION < '2.6'
+            Datadog.logger.debug("Not enabling dynamic instrumentation because of unsupported Ruby version")
+            return false
+          end
+          true
+        end
+      end
+
+      def initialize(settings, agent_settings, logger, code_tracker: nil, telemetry: nil)
+        @settings = settings
+        @agent_settings = agent_settings
+        @logger = logger
+        @telemetry = telemetry
+        @redactor = Redactor.new(settings)
+        @serializer = Serializer.new(settings, redactor, telemetry: telemetry)
+        @instrumenter = Instrumenter.new(settings, serializer, logger, code_tracker: code_tracker, telemetry: telemetry)
+        @transport = Transport.new(agent_settings)
+        @probe_notifier_worker = ProbeNotifierWorker.new(settings, transport, logger, telemetry: telemetry)
+        @probe_notification_builder = ProbeNotificationBuilder.new(settings, serializer)
+        @probe_manager = ProbeManager.new(settings, instrumenter, probe_notification_builder, probe_notifier_worker, logger, telemetry: telemetry)
+        probe_notifier_worker.start
+      end
+
+      attr_reader :settings
+      attr_reader :agent_settings
+      attr_reader :logger
+      attr_reader :telemetry
+      attr_reader :instrumenter
+      attr_reader :transport
+      attr_reader :probe_notifier_worker
+      attr_reader :probe_notification_builder
+      attr_reader :probe_manager
+      attr_reader :redactor
+      attr_reader :serializer
+
+      # Shuts down dynamic instrumentation.
+      #
+      # Removes all code hooks and stops background threads.
+      #
+      # Does not clear out the code tracker, because it's only populated
+      # by code when code is compiled and therefore, if the code tracker
+      # was replaced by a new instance, the new instance of it wouldn't have
+      # any of the already loaded code tracked.
+      def shutdown!(replacement = nil)
+        probe_manager.clear_hooks
+        probe_manager.close
+        probe_notifier_worker.stop
+      end
+    end
+  end
+end

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

@@ -12,8 +12,6 @@ module Datadog
 
         def self.add_settings!(base)
           base.class_eval do
-            # The setting has "internal" prefix to prevent it from being
-            # prematurely turned on by customers.
             settings :dynamic_instrumentation do
               option :enabled do |o|
                 o.type :bool
@@ -26,48 +24,6 @@ module Datadog
                 o.default false
               end
 
-              # This option instructs dynamic instrumentation to use
-              # untargeted trace points when installing line probes and
-              # code tracking is not active.
-              # WARNING: untargeted trace points carry a massive performance
-              # penalty for the entire file in which a line probe is placed.
-              #
-              # If this option is set to false, which is the default,
-              # dynamic instrumentation will add probes that reference
-              # unknown files to the list of pending probes, and when
-              # the respective files are loaded, the line probes will be
-              # installed using targeted trace points. If the file in
-              # question is already loaded when the probe is received
-              # (for example, it is in a third-party library loaded during
-              # application boot), and code tracking was not active when
-              # the file was loaded, such files will not be instrumentable
-              # via line probes.
-              #
-              # If this option is set to true
-              #
-              # activated, DI will in
-              # activated or because the files being targeted have beenIf true and code tracking is not enabled, dynamic instrumentation
-              # will use untargeted trace points.
-              # If false and code tracking is not enabled, dynamic
-              # instrumentation will not instrument any files loaded
-              # WARNING: these trace points will greatly degrade performance
-              # of all code in the instrumented files.
-              option :untargeted_trace_points do |o|
-                o.type :bool
-                o.default false
-              end
-
-              # If true, all of the catch-all rescue blocks in DI
-              # will propagate the exceptions onward.
-              # WARNING: for internal Datadog use only - this will break
-              # the DI product and potentially the library in general in
-              # a multitude of ways, cause resource leakage, permanent
-              # performance decreases, etc.
-              option :propagate_all_exceptions do |o|
-                o.type :bool
-                o.default false
-              end
-
               # An array of variable and key names to redact in addition to
               # the built-in list of identifiers.
               #
@@ -154,6 +110,75 @@ module Datadog
                 o.type :int
                 o.default 20
               end
+
+              # Settings in the 'internal' group are for internal Datadog
+              # use only, and are needed to test dynamic instrumentation or
+              # experiment with features not released to customers.
+              settings :internal do
+                # This option instructs dynamic instrumentation to use
+                # untargeted trace points when installing line probes and
+                # code tracking is not active.
+                # WARNING: untargeted trace points carry a massive performance
+                # penalty for the entire file in which a line probe is placed.
+                #
+                # If this option is set to false, which is the default,
+                # dynamic instrumentation will add probes that reference
+                # unknown files to the list of pending probes, and when
+                # the respective files are loaded, the line probes will be
+                # installed using targeted trace points. If the file in
+                # question is already loaded when the probe is received
+                # (for example, it is in a third-party library loaded during
+                # application boot), and code tracking was not active when
+                # the file was loaded, such files will not be instrumentable
+                # via line probes.
+                #
+                # If this option is set to true, dynamic instrumentation will
+                # install untargeted trace points for all line probes,
+                # regardless of whether the referenced file is loaded.
+                # This permits instrumenting code which was loaded prior to
+                # code tracking being activated and instrumenting lines when
+                # code tracking is not activated at all. However, untargeted
+                # trace points are extremely slow and will greatly degrade
+                # performance of *all* code executed while they are installed,
+                # not just the instrumentation target.
+                option :untargeted_trace_points do |o|
+                  o.type :bool
+                  o.default false
+                end
+
+                # If true, all of the catch-all rescue blocks in DI
+                # will propagate the exceptions onward.
+                # WARNING: for internal Datadog use only - this will break
+                # the DI product and potentially the library in general in
+                # a multitude of ways, cause resource leakage, permanent
+                # performance decreases, etc.
+                option :propagate_all_exceptions do |o|
+                  o.type :bool
+                  o.default false
+                end
+
+                # Minimum interval, in seconds, between probe status and
+                # snapshot submissions to the agent. Probe notifier worker will
+                # batch together payloads submitted during each interval.
+                # A longer interval reduces the overhead imposed by dynamic
+                # instrumentation on the application, but also increases the
+                # time when application code cannot run (when the batches are
+                # being sent out by the probe notifier worker) and creates a
+                # possibility of dropping payloads if the queue gets too long.
+                option :min_send_interval do |o|
+                  o.type :int
+                  o.default 3
+                end
+
+                # Enable dynamic instrumentation in development environments.
+                # Currently DI does not fully implement support for code
+                # unloading and reloading, and is not supported in
+                # non-production environments.
+                option :development do |o|
+                  o.type :bool
+                  o.default false
+                end
+              end
             end
           end
         end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+Datadog::DI::Serializer.register(condition: lambda { |value| ActiveRecord::Base === value }) do |serializer, value, name:, depth:| # steep:ignore
+  # steep thinks all of the arguments are nil here
+  # steep:ignore:start
+  value_to_serialize = {
+    attributes: value.attributes,
+  }
+  serializer.serialize_value(value_to_serialize, depth: depth ? depth - 1 : nil, type: value.class)
+  # steep:ignore:end
+end

data/lib/datadog/di/error.rb

@@ -26,6 +26,23 @@ module Datadog
       # that does not in fact exist anywhere (e.g. due to a misspelling).
       class DITargetNotDefined < Error
       end
+
+      # Raised when trying to install a probe whose installation failed
+      # earlier in the same process. This exception should contain the
+      # original exception report from initial installation attempt.
+      class ProbePreviouslyFailed < Error
+      end
+
+      # Raised when installing a line probe and multiple files match the
+      # specified path suffix.
+      # A probe must be installed into one file only, since UI only
+      # supports one instrumented location for a probe.
+      # If multiple files match, UI cannot properly render the data from
+      # all of them, and arbitrarily choosing one file may be not what the
+      # user intended. Instrumentation will fail when multiple files match
+      # and the user will need to make their suffix more precise.
+      class MultiplePathsMatch < Error
+      end
     end
   end
 end