datadog 2.8.0 → 2.10.0

data/lib/datadog/di/redactor.rb

@@ -119,7 +119,6 @@ module Datadog
         "dburl",
         "encryptionkey",
         "encryptionkeyid",
-        "env",
         "geolocation",
         "gpgkey",
         "ipaddress",

data/lib/datadog/di/remote.rb

@@ -49,28 +49,48 @@ module Datadog
                   begin
                     probe_spec = parse_content(content)
                     probe = ProbeBuilder.build_from_remote_config(probe_spec)
-                    payload = component.probe_notification_builder.build_received(probe)
-                    component.probe_notifier_worker.add_status(payload)
-                    component.logger.info("Received probe from RC: #{probe.type} #{probe.location}")
+                    probe_notification_builder = component.probe_notification_builder
+                    payload = probe_notification_builder.build_received(probe)
+                    probe_notifier_worker = component.probe_notifier_worker
+                    probe_notifier_worker.add_status(payload)
+                    component.logger.debug { "di: received probe from RC: #{probe.type} #{probe.location}" }
 
                     begin
                       # TODO test exception capture
                       probe_manager.add_probe(probe)
                       content.applied
+                    rescue DI::Error::DITargetNotInRegistry => exc
+                      component.telemetry&.report(exc, description: "Line probe is targeting a loaded file that is not in code tracker")
+
+                      payload = probe_notification_builder.build_errored(probe, exc)
+                      probe_notifier_worker.add_status(payload)
+
+                      # If a probe fails to install, we will mark the content
+                      # as errored. On subsequent remote configuration application
+                      # attemps, probe manager will raise the "previously errored"
+                      # exception and we'll rescue it here, again marking the
+                      # content as errored but with a somewhat different exception
+                      # message.
+                      # TODO assert content state (errored for this example)
+                      content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
                     rescue => exc
                       raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
 
-                      component.logger.warn("Unhandled exception adding probe in DI remote receiver: #{exc.class}: #{exc}")
+                      component.logger.debug { "di: unhandled exception adding probe in DI remote receiver: #{exc.class}: #{exc}" }
                       component.telemetry&.report(exc, description: "Unhandled exception adding probe in DI remote receiver")
 
+                      # TODO test this path
+                      payload = probe_notification_builder.build_errored(probe, exc)
+                      probe_notifier_worker.add_status(payload)
+
                       # If a probe fails to install, we will mark the content
                       # as errored. On subsequent remote configuration application
                       # attemps, probe manager will raise the "previously errored"
                       # exception and we'll rescue it here, again marking the
                       # content as errored but with a somewhat different exception
                       # message.
-                      # TODO stack trace must be redacted or not sent at all
-                      content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}: #{Array(exc.backtrace).join("\n")}")
+                      # TODO assert content state (errored for this example)
+                      content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
                     end
 
                     # Important: even if processing fails for this probe config,
@@ -81,10 +101,11 @@ module Datadog
                   rescue => exc
                     raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
 
-                    component.logger.warn("Unhandled exception handling probe in DI remote receiver: #{exc.class}: #{exc}")
+                    component.logger.debug { "di: unhandled exception handling probe in DI remote receiver: #{exc.class}: #{exc}" }
                     component.telemetry&.report(exc, description: "Unhandled exception handling probe in DI remote receiver")
 
-                    content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}: #{Array(exc.backtrace).join("\n")}")
+                    # TODO assert content state (errored for this example)
+                    content.errored("Error applying dynamic instrumentation configuration: #{exc.class.name} #{exc.message}")
                   end
                 end
               end
@@ -95,7 +116,7 @@ module Datadog
               rescue => exc
                 raise if component.settings.dynamic_instrumentation.internal.propagate_all_exceptions
 
-                component.logger.warn("Unhandled exception removing probes in DI remote receiver: #{exc.class}: #{exc}")
+                component.logger.debug { "di: unhandled exception removing probes in DI remote receiver: #{exc.class}: #{exc}" }
                 component.telemetry&.report(exc, description: "Unhandled exception removing probes in DI remote receiver")
               end
             end

data/lib/datadog/di/transport.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'ostruct'
 require_relative 'error'
+require_relative '../core/transport/http/adapters/net'
 
 module Datadog
   module DI
@@ -60,9 +60,7 @@ module Datadog
       attr_reader :client
 
       def send_request(desc, **options)
-        # steep:ignore:start
-        env = OpenStruct.new(**options)
-        # steep:ignore:end
+        env = Core::Transport::HTTP::Env.new(nil, options)
         response = client.post(env)
         unless response.ok?
           raise Error::AgentCommunicationError, "#{desc} failed: #{response.code}: #{response.payload}"

data/lib/datadog/di.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'di/base'
 require_relative 'di/error'
 require_relative 'di/code_tracker'
 require_relative 'di/component'
@@ -17,21 +18,6 @@ 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.
-  #
-  # TODO this require might need to be delayed via Rails post-initialization
-  # logic?
-  require_relative 'di/contrib/active_record'
-end
-
 module Datadog
   # Namespace for Datadog dynamic instrumentation.
   #
@@ -46,67 +32,7 @@ module Datadog
     # Expose DI to global shared objects
     Extensions.activate!
 
-    LOCK = Mutex.new
-
     class << self
-      attr_reader :code_tracker
-
-      # Activates code tracking. Normally this method should be called
-      # when the application starts. If instrumenting third-party code,
-      # code tracking needs to be enabled before the third-party libraries
-      # are loaded. If you definitely will not be instrumenting
-      # third-party libraries, activating tracking after third-party libraries
-      # have been loaded may improve lookup performance.
-      #
-      # TODO test that activating tracker multiple times preserves
-      # existing mappings in the registry
-      def activate_tracking!
-        (@code_tracker ||= CodeTracker.new).start
-      end
-
-      # Activates code tracking if possible.
-      #
-      # This method does nothing if invoked in an environment that does not
-      # implement required trace points for code tracking (MRI Ruby < 2.6,
-      # JRuby) and rescues any exceptions that may be raised by downstream
-      # DI code.
-      def activate_tracking
-        # :script_compiled trace point was added in Ruby 2.6.
-        return unless 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
-
-      # Deactivates code tracking. In normal usage of DI this method should
-      # never be called, however it is used by DI's test suite to reset
-      # state for individual tests.
-      #
-      # Note that deactivating tracking clears out the registry, losing
-      # the ability to look up files that have been loaded into the process
-      # already.
-      def deactivate_tracking!
-        code_tracker&.stop
-      end
-
-      # Returns whether code tracking is available.
-      # This method should be used instead of querying #code_tracker
-      # because the latter one may be nil.
-      def code_tracking_active?
-        code_tracker&.active? || false
-      end
 
       # This method is called from DI Remote handler to issue DI operations
       # to the probe manager (add or remove probes).
@@ -120,39 +46,6 @@ module Datadog
       def component
         Datadog.send(:components).dynamic_instrumentation
       end
-
-      # DI code tracker is instantiated globally before the regular set of
-      # components is created, but the code tracker needs to call out to the
-      # "current" DI component to perform instrumentation when application
-      # code is loaded. Because this call may happen prior to Datadog
-      # components having been initialized, we maintain the "current component"
-      # which contains a reference to the most recently instantiated
-      # DI::Component. This way, if a DI component hasn't been instantiated,
-      # we do not try to reference Datadog.components.
-      def current_component
-        LOCK.synchronize do
-          @current_components&.last
-        end
-      end
-
-      # To avoid potential races with DI::Component being added and removed,
-      # we maintain a list of the components. Normally the list should contain
-      # either zero or one component depending on whether DI is enabled in
-      # Datadog configuration. However, if a new instance of DI::Component
-      # is created while the previous instance is still running, we are
-      # guaranteed to not end up with no component when one is running.
-      def add_current_component(component)
-        LOCK.synchronize do
-          @current_components ||= []
-          @current_components << component
-        end
-      end
-
-      def remove_current_component(component)
-        LOCK.synchronize do
-          @current_components&.delete(component)
-        end
-      end
     end
   end
 end
@@ -167,3 +60,7 @@ if %w(1 true).include?(ENV['DD_DYNAMIC_INSTRUMENTATION_ENABLED']) # steep:ignore
   # for line probes to work) activate tracking in an initializer.
   Datadog::DI.activate_tracking
 end
+
+require_relative 'di/contrib'
+
+Datadog::DI::Contrib.load_now_or_later

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

@@ -136,9 +136,9 @@ module Datadog
           private
 
           def set_trace_and_span_context(method, trace = nil, span = nil)
-            if (appsec_scope = Datadog::AppSec.active_scope)
-              trace = appsec_scope.trace
-              span = appsec_scope.service_entry_span
+            if (appsec_context = Datadog::AppSec.active_context)
+              trace = appsec_context.trace
+              span = appsec_context.span
             end
 
             trace ||= Datadog::Tracing.active_trace

data/lib/datadog/kit/identity.rb

@@ -66,7 +66,7 @@ module Datadog
               active_span.set_tag("usr.#{k}", v) unless v.nil?
             end
 
-            if Datadog::AppSec.active_scope
+            if Datadog::AppSec.active_context
               user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(id)
               ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
             end
@@ -78,9 +78,9 @@ module Datadog
         private
 
         def set_trace_and_span_context(method, trace = nil, span = nil)
-          if (appsec_scope = Datadog::AppSec.active_scope)
-            trace = appsec_scope.trace
-            span = appsec_scope.service_entry_span
+          if (appsec_context = Datadog::AppSec.active_context)
+            trace = appsec_context.trace
+            span = appsec_context.span
           end
 
           trace ||= Datadog::Tracing.active_trace

data/lib/datadog/profiling/component.rb

@@ -4,10 +4,13 @@ module Datadog
   module Profiling
     # Responsible for wiring up the Profiler for execution
     module Component
+      ALLOCATION_WITH_RACTORS_ONLY_ONCE = Datadog::Core::Utils::OnlyOnce.new
+      private_constant :ALLOCATION_WITH_RACTORS_ONLY_ONCE
+
       # Passing in a `nil` tracer is supported and will disable the following profiling features:
-      # * Code Hotspots panel in the trace viewer, as well as scoping a profile down to a span
+      # * Profiling in the trace viewer, as well as scoping a profile down to a span
       # * Endpoint aggregation in the profiler UX, including normalization (resource per endpoint call)
-      def self.build_profiler_component(settings:, agent_settings:, optional_tracer:) # rubocop:disable Metrics/MethodLength
+      def self.build_profiler_component(settings:, agent_settings:, optional_tracer:, logger:) # rubocop:disable Metrics/MethodLength
         return [nil, {profiling_enabled: false}] unless settings.profiling.enabled
 
         # Workaround for weird dependency direction: the Core::Configuration::Components class currently has a
@@ -36,14 +39,14 @@ module Datadog
 
         # NOTE: Please update the Initialization section of ProfilingDevelopment.md with any changes to this method
 
-        no_signals_workaround_enabled = no_signals_workaround_enabled?(settings)
+        no_signals_workaround_enabled = no_signals_workaround_enabled?(settings, logger)
         timeline_enabled = settings.profiling.advanced.timeline_enabled
-        allocation_profiling_enabled = enable_allocation_profiling?(settings)
+        allocation_profiling_enabled = enable_allocation_profiling?(settings, logger)
         heap_sample_every = get_heap_sample_every(settings)
-        heap_profiling_enabled = enable_heap_profiling?(settings, allocation_profiling_enabled, heap_sample_every)
-        heap_size_profiling_enabled = enable_heap_size_profiling?(settings, heap_profiling_enabled)
+        heap_profiling_enabled = enable_heap_profiling?(settings, allocation_profiling_enabled, heap_sample_every, logger)
+        heap_size_profiling_enabled = enable_heap_size_profiling?(settings, heap_profiling_enabled, logger)
 
-        overhead_target_percentage = valid_overhead_target(settings.profiling.advanced.overhead_target_percentage)
+        overhead_target_percentage = valid_overhead_target(settings.profiling.advanced.overhead_target_percentage, logger)
         upload_period_seconds = [60, settings.profiling.advanced.upload_period_seconds].max
 
         recorder = Datadog::Profiling::StackRecorder.new(
@@ -57,13 +60,13 @@ module Datadog
         )
         thread_context_collector = build_thread_context_collector(settings, recorder, optional_tracer, timeline_enabled)
         worker = Datadog::Profiling::Collectors::CpuAndWallTimeWorker.new(
-          gc_profiling_enabled: enable_gc_profiling?(settings),
+          gc_profiling_enabled: enable_gc_profiling?(settings, logger),
           no_signals_workaround_enabled: no_signals_workaround_enabled,
           thread_context_collector: thread_context_collector,
           dynamic_sampling_rate_overhead_target_percentage: overhead_target_percentage,
           allocation_profiling_enabled: allocation_profiling_enabled,
           allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
-          gvl_profiling_enabled: enable_gvl_profiling?(settings),
+          gvl_profiling_enabled: enable_gvl_profiling?(settings, logger),
         )
 
         internal_metadata = {
@@ -120,7 +123,7 @@ module Datadog
           )
       end
 
-      private_class_method def self.enable_gc_profiling?(settings)
+      private_class_method def self.enable_gc_profiling?(settings, logger)
         return false unless settings.profiling.advanced.gc_enabled
 
         # SEVERE - Only with Ractors
@@ -131,14 +134,14 @@ module Datadog
         if RUBY_VERSION.start_with?("3.0.") ||
             (RUBY_VERSION.start_with?("3.1.") && RUBY_VERSION < "3.1.4") ||
             (RUBY_VERSION.start_with?("3.2.") && RUBY_VERSION < "3.2.3")
-          Datadog.logger.warn(
+          logger.warn(
             "Current Ruby version (#{RUBY_VERSION}) has a VM bug where enabling GC profiling would cause " \
             "crashes (https://bugs.ruby-lang.org/issues/18464). GC profiling has been disabled."
           )
           return false
         elsif RUBY_VERSION.start_with?("3.")
-          Datadog.logger.debug(
-            "In all known versions of Ruby 3.x, using Ractors may result in GC profiling unexpectedly " \
+          logger.debug(
+            "Using Ractors may result in GC profiling unexpectedly " \
             "stopping (https://bugs.ruby-lang.org/issues/19112). Note that this stop has no impact in your " \
             "application stability or performance. This does not happen if Ractors are not used."
           )
@@ -155,7 +158,7 @@ module Datadog
         heap_sample_rate
       end
 
-      private_class_method def self.enable_allocation_profiling?(settings)
+      private_class_method def self.enable_allocation_profiling?(settings, logger)
         return false unless settings.profiling.allocation_enabled
 
         # Allocation sampling is safe and supported on Ruby 2.x, but has a few caveats on Ruby 3.x.
@@ -165,7 +168,7 @@ module Datadog
         # https://github.com/ruby/ruby/pull/7464) that makes this crash in any configuration. This bug is
         # fixed on Ruby versions 3.2.3 and 3.3.0.
         if RUBY_VERSION.start_with?("3.2.") && RUBY_VERSION < "3.2.3"
-          Datadog.logger.warn(
+          logger.warn(
             "Allocation profiling is not supported in Ruby versions 3.2.0, 3.2.1 and 3.2.2 and will be forcibly " \
             "disabled. This is due to a VM bug that can lead to crashes (https://bugs.ruby-lang.org/issues/19482). " \
             "Other Ruby versions do not suffer from this issue."
@@ -181,7 +184,7 @@ module Datadog
         if RUBY_VERSION.start_with?("3.0.") ||
             (RUBY_VERSION.start_with?("3.1.") && RUBY_VERSION < "3.1.4") ||
             (RUBY_VERSION.start_with?("3.2.") && RUBY_VERSION < "3.2.3")
-          Datadog.logger.warn(
+          logger.warn(
             "Current Ruby version (#{RUBY_VERSION}) has a VM bug where enabling allocation profiling while using " \
             "Ractors may cause unexpected issues, including crashes (https://bugs.ruby-lang.org/issues/18464). " \
             "This does not happen if Ractors are not used."
@@ -190,25 +193,27 @@ module Datadog
         # On all known versions of Ruby 3.x, due to https://bugs.ruby-lang.org/issues/19112, when a ractor gets
         # garbage collected, Ruby will disable all active tracepoints, which this feature internally relies on.
         elsif RUBY_VERSION.start_with?("3.")
-          Datadog.logger.warn(
-            "In all known versions of Ruby 3.x, using Ractors may result in allocation profiling unexpectedly " \
-            "stopping (https://bugs.ruby-lang.org/issues/19112). Note that this stop has no impact in your " \
-            "application stability or performance. This does not happen if Ractors are not used."
-          )
+          ALLOCATION_WITH_RACTORS_ONLY_ONCE.run do
+            logger.info(
+              "Using Ractors may result in allocation profiling " \
+              "stopping (https://bugs.ruby-lang.org/issues/19112). Note that this stop has no impact in your " \
+              "application stability or performance. This does not happen if Ractors are not used."
+            )
+          end
         end
 
-        Datadog.logger.debug("Enabled allocation profiling")
+        logger.debug("Enabled allocation profiling")
 
         true
       end
 
-      private_class_method def self.enable_heap_profiling?(settings, allocation_profiling_enabled, heap_sample_rate)
+      private_class_method def self.enable_heap_profiling?(settings, allocation_profiling_enabled, heap_sample_rate, logger)
         heap_profiling_enabled = settings.profiling.advanced.experimental_heap_enabled
 
         return false unless heap_profiling_enabled
 
         if RUBY_VERSION < "3.1"
-          Datadog.logger.warn(
+          logger.warn(
             "Current Ruby version (#{RUBY_VERSION}) cannot support heap profiling due to VM limitations. " \
             "Please upgrade to Ruby >= 3.1 in order to use this feature. Heap profiling has been disabled."
           )
@@ -219,7 +224,7 @@ module Datadog
           raise ArgumentError, "Heap profiling requires allocation profiling to be enabled"
         end
 
-        Datadog.logger.warn(
+        logger.warn(
           "Enabled experimental heap profiling: heap_sample_rate=#{heap_sample_rate}. This is experimental, not " \
           "recommended, and will increase overhead!"
         )
@@ -227,25 +232,23 @@ module Datadog
         true
       end
 
-      private_class_method def self.enable_heap_size_profiling?(settings, heap_profiling_enabled)
+      private_class_method def self.enable_heap_size_profiling?(settings, heap_profiling_enabled, logger)
         heap_size_profiling_enabled = settings.profiling.advanced.experimental_heap_size_enabled
 
         return false unless heap_profiling_enabled && heap_size_profiling_enabled
 
-        Datadog.logger.warn(
+        logger.warn(
           "Enabled experimental heap size profiling. This is experimental, not recommended, and will increase overhead!"
         )
 
         true
       end
 
-      private_class_method def self.no_signals_workaround_enabled?(settings) # rubocop:disable Metrics/MethodLength
+      private_class_method def self.no_signals_workaround_enabled?(settings, logger) # rubocop:disable Metrics/MethodLength
         setting_value = settings.profiling.advanced.no_signals_workaround_enabled
-        legacy_ruby_that_should_use_workaround = RUBY_VERSION.start_with?("2.5.")
 
         unless [true, false, :auto].include?(setting_value)
-          # TODO: Replace with a warning instead.
-          Datadog.logger.error(
+          logger.warn(
             "Ignoring invalid value for profiling no_signals_workaround_enabled setting: #{setting_value.inspect}. " \
             "Valid options are `true`, `false` or (default) `:auto`."
           )
@@ -254,23 +257,23 @@ module Datadog
         end
 
         if setting_value == false
-          if legacy_ruby_that_should_use_workaround
-            Datadog.logger.warn(
-              'The profiling "no signals" workaround has been disabled via configuration on a legacy Ruby version ' \
-              "(< 2.6). This is not recommended " \
-              "in production environments, as due to limitations in Ruby APIs, we suspect it may lead to crashes " \
-              "in very rare situations. Please report any issues you run into to Datadog support or " \
+          if RUBY_VERSION.start_with?("2.5.")
+            logger.warn(
+              'The profiling "no signals" workaround has been disabled via configuration on Ruby 2.5. ' \
+              "This is not recommended " \
+              "in production environments, as due to limitations in Ruby APIs, we suspect it may lead to rare crashes " \
+              "Please report any issues you run into to Datadog support or " \
               "via <https://github.com/datadog/dd-trace-rb/issues/new>!"
             )
           else
-            Datadog.logger.warn('Profiling "no signals" workaround disabled via configuration')
+            logger.warn('Profiling "no signals" workaround disabled via configuration')
           end
 
           return false
         end
 
         if setting_value == true
-          Datadog.logger.warn(
+          logger.warn(
             'Profiling "no signals" workaround enabled via configuration. Profiling data will have lower quality.'
           )
 
@@ -280,10 +283,10 @@ module Datadog
         # Setting is in auto mode. Let's probe to see if we should enable it:
 
         # We don't warn users in this situation because "upgrade your Ruby" is not a great warning
-        return true if legacy_ruby_that_should_use_workaround
+        return true if RUBY_VERSION.start_with?("2.5.")
 
-        if Gem.loaded_specs["mysql2"] && incompatible_libmysqlclient_version?(settings)
-          Datadog.logger.warn(
+        if Gem.loaded_specs["mysql2"] && incompatible_libmysqlclient_version?(settings, logger)
+          logger.warn(
             'Enabling the profiling "no signals" workaround because an incompatible version of the mysql2 gem is ' \
             "installed. Profiling data will have lower quality. " \
             "To fix this, upgrade the libmysqlclient in your OS image to version 8.0.0 or above."
@@ -292,7 +295,7 @@ module Datadog
         end
 
         if Gem.loaded_specs["rugged"]
-          Datadog.logger.warn(
+          logger.warn(
             'Enabling the profiling "no signals" workaround because the rugged gem is installed. ' \
             "This is needed because some operations on this gem are currently incompatible with the normal working mode " \
             "of the profiler, as detailed in <https://github.com/datadog/dd-trace-rb/issues/2721>. " \
@@ -302,7 +305,7 @@ module Datadog
         end
 
         if (defined?(::PhusionPassenger) || Gem.loaded_specs["passenger"]) && incompatible_passenger_version?
-          Datadog.logger.warn(
+          logger.warn(
             'Enabling the profiling "no signals" workaround because an incompatible version of the passenger gem is ' \
             "installed. Profiling data will have lower quality." \
             "To fix this, upgrade the passenger gem to version 6.0.19 or above."
@@ -322,10 +325,10 @@ module Datadog
       #
       # The `mysql2` gem's `info` method can be used to determine which `libmysqlclient` version is in use, and thus to
       # detect if it's safe for the profiler to use signals or if we need to employ a fallback.
-      private_class_method def self.incompatible_libmysqlclient_version?(settings)
+      private_class_method def self.incompatible_libmysqlclient_version?(settings, logger)
         return true if settings.profiling.advanced.skip_mysql2_check
 
-        Datadog.logger.debug(
+        logger.debug(
           "Requiring `mysql2` to check if the `libmysqlclient` version it uses is compatible with profiling"
         )
 
@@ -354,14 +357,14 @@ module Datadog
             libmysqlclient_version >= Gem::Version.new("8.0.0") ||
             looks_like_mariadb?(info, libmysqlclient_version)
 
-          Datadog.logger.debug(
+          logger.debug(
             "The `mysql2` gem is using #{compatible ? "a compatible" : "an incompatible"} version of " \
             "the `libmysqlclient` library (#{libmysqlclient_version})"
           )
 
           !compatible
         rescue StandardError, LoadError => e
-          Datadog.logger.warn(
+          logger.warn(
             "Failed to probe `mysql2` gem information. " \
             "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
           )
@@ -383,12 +386,11 @@ module Datadog
         end
       end
 
-      private_class_method def self.valid_overhead_target(overhead_target_percentage)
+      private_class_method def self.valid_overhead_target(overhead_target_percentage, logger)
         if overhead_target_percentage > 0 && overhead_target_percentage <= 20
           overhead_target_percentage
         else
-          # TODO: Replace with a warning instead.
-          Datadog.logger.error(
+          logger.warn(
             "Ignoring invalid value for profiling overhead_target_percentage setting: " \
             "#{overhead_target_percentage.inspect}. Falling back to default value."
           )
@@ -432,10 +434,10 @@ module Datadog
         settings.profiling.advanced.dir_interruption_workaround_enabled
       end
 
-      private_class_method def self.enable_gvl_profiling?(settings)
+      private_class_method def self.enable_gvl_profiling?(settings, logger)
         if RUBY_VERSION < "3.2"
           if settings.profiling.advanced.preview_gvl_enabled
-            Datadog.logger.warn("GVL profiling is currently not supported in Ruby < 3.2 and will not be enabled.")
+            logger.warn("GVL profiling is currently not supported in Ruby < 3.2 and will not be enabled.")
           end
 
           return false

data/lib/datadog/profiling/http_transport.rb

@@ -13,13 +13,11 @@ module Datadog
       def initialize(agent_settings:, site:, api_key:, upload_timeout_seconds:)
         @upload_timeout_milliseconds = (upload_timeout_seconds * 1_000).to_i
 
-        validate_agent_settings(agent_settings)
-
         @exporter_configuration =
           if agentless?(site, api_key)
             [:agentless, site, api_key].freeze
           else
-            [:agent, base_url_from(agent_settings)].freeze
+            [:agent, agent_settings.url].freeze
           end
 
         status, result = validate_exporter(exporter_configuration)
@@ -75,29 +73,6 @@ module Datadog
 
       private
 
-      def base_url_from(agent_settings)
-        case agent_settings.adapter
-        when Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
-          "#{agent_settings.ssl ? "https" : "http"}://#{agent_settings.hostname}:#{agent_settings.port}/"
-        when Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER
-          "unix://#{agent_settings.uds_path}"
-        else
-          raise ArgumentError, "Unexpected adapter: #{agent_settings.adapter}"
-        end
-      end
-
-      def validate_agent_settings(agent_settings)
-        supported_adapters = [
-          Datadog::Core::Configuration::Ext::Agent::UnixSocket::ADAPTER,
-          Datadog::Core::Configuration::Ext::Agent::HTTP::ADAPTER
-        ]
-        unless supported_adapters.include?(agent_settings.adapter)
-          raise ArgumentError,
-            "Unsupported transport configuration for profiling: Adapter #{agent_settings.adapter} " \
-                        " is not supported"
-        end
-      end
-
       def agentless?(site, api_key)
         site && api_key && Core::Environment::VariableHelpers.env_to_bool(Profiling::Ext::ENV_AGENTLESS, false)
       end

data/lib/datadog/tracing/contrib/action_cable/integration.rb

@@ -3,7 +3,7 @@
 require_relative '../integration'
 require_relative 'configuration/settings'
 require_relative 'patcher'
-require_relative '../rails/utils'
+require_relative '../../../core/contrib/rails/utils'
 
 module Datadog
   module Tracing
@@ -17,6 +17,9 @@ module Datadog
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :action_cable, auto_patch: false
+          def self.gem_name
+            'actioncable'
+          end
 
           def self.version
             Gem.loaded_specs['actioncable'] && Gem.loaded_specs['actioncable'].version
@@ -33,7 +36,7 @@ module Datadog
           # enabled by rails integration so should only auto instrument
           # if detected that it is being used without rails
           def auto_instrument?
-            !Contrib::Rails::Utils.railtie_supported?
+            !Core::Contrib::Rails::Utils.railtie_supported?
           end
 
           def new_configuration