datadog 2.1.0 → 2.3.0

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
 
@@ -92,25 +92,38 @@ module Datadog
 
             seen_files << file_path
 
-            _, found_library = libraries_by_path.find { |library_path, _| file_path.start_with?(library_path) }
-            seen_libraries << found_library if found_library
+            # NOTE: Don't use .find, it allocates a lot more memory (see commit that added this note for details)
+            libraries_by_path.any? do |library_path, library|
+              seen_libraries << library if file_path.start_with?(library_path)
+            end
           end
         end
 
         # Represents metadata we have for a ruby gem
+        #
+        # Important note: This class gets encoded to JSON with the built-in JSON gem. But, we've found that in some
+        # buggy cases, some Ruby gems monkey patch the built-in JSON gem and forget to call #to_json, and instead
+        # encode this class instance-field-by-instance-field.
+        #
+        # Thus, this class was setup to match the JSON output. Take this into consideration if you are adding new
+        # fields. (Also, we have a spec for this)
         class Library
-          attr_reader :kind, :name, :version, :path
+          attr_reader :kind, :name, :version
 
           def initialize(kind:, name:, version:, path:)
             @kind = kind.freeze
             @name = name.dup.freeze
             @version = version.to_s.dup.freeze
-            @path = path.dup.freeze
+            @paths = [path.dup.freeze].freeze
             freeze
           end
 
           def to_json(arg = nil)
-            { kind: @kind, name: @name, version: @version, paths: [@path] }.to_json(arg)
+            {kind: @kind, name: @name, version: @version, paths: @paths}.to_json(arg)
+          end
+
+          def path
+            @paths.first
           end
         end
       end

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

@@ -21,6 +21,7 @@ module Datadog
           thread_context_collector:,
           dynamic_sampling_rate_overhead_target_percentage:,
           allocation_profiling_enabled:,
+          allocation_counting_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,7 +30,7 @@ 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
 
@@ -42,6 +43,7 @@ module Datadog
             dynamic_sampling_rate_enabled,
             dynamic_sampling_rate_overhead_target_percentage,
             allocation_profiling_enabled,
+            allocation_counting_enabled,
             skip_idle_samples_for_testing,
           )
           @worker_thread = nil
@@ -54,27 +56,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 +85,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,7 @@
 # frozen_string_literal: true
 
-require 'set'
-require 'time'
+require "set"
+require "time"
 
 module Datadog
   module Profiling
@@ -61,7 +61,7 @@ module Datadog
 
         def collect_profiler_info(settings)
           unless @profiler_info
-            lib_datadog_gem = ::Gem.loaded_specs['libdatadog']
+            lib_datadog_gem = ::Gem.loaded_specs["libdatadog"]
             @profiler_info = {
               # TODO: If profiling is extracted and its version diverges from the datadog gem, this is inaccurate.
               #       Update if this ever occurs.

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

@@ -48,12 +48,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

data/lib/datadog/profiling/component.rb

@@ -8,7 +8,7 @@ module Datadog
       # * Code Hotspots panel 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
-        return [nil, { profiling_enabled: false }] unless settings.profiling.enabled
+        return [nil, {profiling_enabled: false}] unless settings.profiling.enabled
 
         # Workaround for weird dependency direction: the Core::Configuration::Components class currently has a
         # dependency on individual products, in this case the Profiler.
@@ -27,9 +27,9 @@ module Datadog
         # On the other hand, if datadog/core is loaded by a different product and no general `require 'datadog'` is
         # done, then profiling may not be loaded, and thus to avoid this issue we do a require here (which is a
         # no-op if profiling is already loaded).
-        require_relative '../profiling'
+        require_relative "../profiling"
 
-        return [nil, { profiling_enabled: false }] unless Profiling.supported?
+        return [nil, {profiling_enabled: false}] unless Profiling.supported?
 
         # Activate forking extensions
         Profiling::Tasks::Setup.new.run
@@ -47,7 +47,7 @@ module Datadog
         upload_period_seconds = [60, settings.profiling.advanced.upload_period_seconds].max
 
         recorder = Datadog::Profiling::StackRecorder.new(
-          cpu_time_enabled: RUBY_PLATFORM.include?('linux'), # Only supported on Linux currently
+          cpu_time_enabled: RUBY_PLATFORM.include?("linux"), # Only supported on Linux currently
           alloc_samples_enabled: allocation_profiling_enabled,
           heap_samples_enabled: heap_profiling_enabled,
           heap_size_enabled: heap_size_profiling_enabled,
@@ -61,6 +61,7 @@ module Datadog
           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,
         )
 
         internal_metadata = {
@@ -72,10 +73,13 @@ module Datadog
         exporter = build_profiler_exporter(settings, recorder, worker, internal_metadata: internal_metadata)
         transport = build_profiler_transport(settings, agent_settings)
         scheduler = Profiling::Scheduler.new(exporter: exporter, transport: transport, interval: upload_period_seconds)
-        crashtracker = build_crashtracker(settings, transport)
-        profiler = Profiling::Profiler.new(worker: worker, scheduler: scheduler, optional_crashtracker: crashtracker)
+        profiler = Profiling::Profiler.new(worker: worker, scheduler: scheduler)
 
-        [profiler, { profiling_enabled: true }]
+        if dir_interruption_workaround_enabled?(settings, no_signals_workaround_enabled)
+          Datadog::Profiling::Ext::DirMonkeyPatches.apply!
+        end
+
+        [profiler, {profiling_enabled: true}]
       end
 
       private_class_method def self.build_thread_context_collector(settings, recorder, optional_tracer, timeline_enabled)
@@ -112,28 +116,6 @@ module Datadog
           )
       end
 
-      private_class_method def self.build_crashtracker(settings, transport)
-        return unless settings.profiling.advanced.experimental_crash_tracking_enabled
-
-        # By default, the transport is an instance of HttpTransport, which validates the configuration and makes
-        # it available for us to use here.
-        # But we support overriding the transport with a user-specific one, which may e.g. write stuff to a file,
-        # and thus can't really provide a valid configuration to talk to a Datadog agent. Thus, in this situation,
-        # we can't use the crashtracker, even if enabled.
-        unless transport.respond_to?(:exporter_configuration)
-          Datadog.logger.warn(
-            'Cannot enable profiling crash tracking as a custom settings.profiling.exporter.transport is configured'
-          )
-          return
-        end
-
-        Datadog::Profiling::Crashtracker.new(
-          exporter_configuration: transport.exporter_configuration,
-          tags: Datadog::Profiling::TagBuilder.call(settings: settings),
-          upload_timeout_seconds: settings.profiling.upload.timeout_seconds,
-        )
-      end
-
       private_class_method def self.enable_gc_profiling?(settings)
         return false unless settings.profiling.advanced.gc_enabled
 
@@ -142,19 +124,19 @@ module Datadog
         # that causes a segmentation fault during garbage collection of Ractors
         # (https://bugs.ruby-lang.org/issues/18464). We don't allow enabling gc profiling on such Rubies.
         # This bug is fixed on Ruby versions 3.1.4, 3.2.3 and 3.3.0.
-        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')
+        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(
-            "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.'
+            "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.')
+        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 ' \
-            '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.'
+            "In all known versions of Ruby 3.x, 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."
           )
         end
 
@@ -178,11 +160,11 @@ module Datadog
         # Ruby 3.2.0 to 3.2.2 have a bug in the newobj tracepoint (https://bugs.ruby-lang.org/issues/19482,
         # 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'
+        if RUBY_VERSION.start_with?("3.2.") && RUBY_VERSION < "3.2.3"
           Datadog.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.'
+            "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."
           )
           return false
         end
@@ -192,26 +174,26 @@ module Datadog
         # that causes a segmentation fault during garbage collection of Ractors
         # (https://bugs.ruby-lang.org/issues/18464). We don't recommend using this feature on such Rubies.
         # This bug is fixed on Ruby versions 3.1.4, 3.2.3 and 3.3.0.
-        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')
+        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(
-            "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.'
+            "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."
           )
         # ANNOYANCE - Only with Ractors
         # 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.')
+        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.'
+            "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."
           )
         end
 
-        Datadog.logger.debug('Enabled allocation profiling')
+        Datadog.logger.debug("Enabled allocation profiling")
 
         true
       end
@@ -221,33 +203,33 @@ module Datadog
 
         return false unless heap_profiling_enabled
 
-        if RUBY_VERSION.start_with?('2.') && RUBY_VERSION < '2.7'
+        if RUBY_VERSION.start_with?("2.") && RUBY_VERSION < "2.7"
           Datadog.logger.warn(
-            'Heap profiling currently relies on features introduced in Ruby 2.7 and will be forcibly disabled. '\
-            'Please upgrade to Ruby >= 2.7 in order to use this feature.'
+            "Heap profiling currently relies on features introduced in Ruby 2.7 and will be forcibly disabled. " \
+            "Please upgrade to Ruby >= 2.7 in order to use this feature."
           )
           return false
         end
 
-        if RUBY_VERSION < '3.1'
+        if RUBY_VERSION < "3.1"
           Datadog.logger.debug(
             "Current Ruby version (#{RUBY_VERSION}) supports forced object recycling which has a bug that the " \
-            'heap profiler is forced to work around to remain accurate. This workaround requires force-setting '\
+            "heap profiler is forced to work around to remain accurate. This workaround requires force-setting " \
             "the SEEN_OBJ_ID flag on objects that should have it but don't. Full details can be found in " \
-            'https://github.com/DataDog/dd-trace-rb/pull/3360. This workaround should be safe but can be ' \
-            'bypassed by disabling the heap profiler or upgrading to Ruby >= 3.1 where forced object recycling ' \
-            'was completely removed (https://bugs.ruby-lang.org/issues/18290).'
+            "https://github.com/DataDog/dd-trace-rb/pull/3360. This workaround should be safe but can be " \
+            "bypassed by disabling the heap profiler or upgrading to Ruby >= 3.1 where forced object recycling " \
+            "was completely removed (https://bugs.ruby-lang.org/issues/18290)."
           )
         end
 
         unless allocation_profiling_enabled
           raise ArgumentError,
-            'Heap profiling requires allocation profiling to be enabled'
+            "Heap profiling requires allocation profiling to be enabled"
         end
 
         Datadog.logger.warn(
           "Enabled experimental heap profiling: heap_sample_rate=#{heap_sample_rate}. This is experimental, not " \
-          'recommended, and will increase overhead!'
+          "recommended, and will increase overhead!"
         )
 
         true
@@ -259,7 +241,7 @@ module Datadog
         return false unless heap_profiling_enabled && heap_size_profiling_enabled
 
         Datadog.logger.warn(
-          'Enabled experimental heap size profiling. This is experimental, not recommended, and will increase overhead!'
+          "Enabled experimental heap size profiling. This is experimental, not recommended, and will increase overhead!"
         )
 
         true
@@ -267,12 +249,12 @@ module Datadog
 
       private_class_method def self.no_signals_workaround_enabled?(settings) # 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.')
+        legacy_ruby_that_should_use_workaround = RUBY_VERSION.start_with?("2.5.")
 
         unless [true, false, :auto].include?(setting_value)
           Datadog.logger.error(
             "Ignoring invalid value for profiling no_signals_workaround_enabled setting: #{setting_value.inspect}. " \
-            'Valid options are `true`, `false` or (default) `:auto`.'
+            "Valid options are `true`, `false` or (default) `:auto`."
           )
 
           setting_value = :auto
@@ -282,10 +264,10 @@ module Datadog
           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 ' \
-              'via <https://github.com/datadog/dd-trace-rb/issues/new>!'
+              "(< 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 " \
+              "via <https://github.com/datadog/dd-trace-rb/issues/new>!"
             )
           else
             Datadog.logger.warn('Profiling "no signals" workaround disabled via configuration')
@@ -307,30 +289,30 @@ module Datadog
         # 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
 
-        if Gem.loaded_specs['mysql2'] && incompatible_libmysqlclient_version?(settings)
+        if Gem.loaded_specs["mysql2"] && incompatible_libmysqlclient_version?(settings)
           Datadog.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.'
+            "installed. Profiling data will have lower quality. " \
+            "To fix this, upgrade the libmysqlclient in your OS image to version 8.0.0 or above."
           )
           return true
         end
 
-        if Gem.loaded_specs['rugged']
+        if Gem.loaded_specs["rugged"]
           Datadog.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>. ' \
-            'Profiling data will have lower quality.'
+            "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>. " \
+            "Profiling data will have lower quality."
           )
           return true
         end
 
-        if (defined?(::PhusionPassenger) || Gem.loaded_specs['passenger']) && incompatible_passenger_version?
+        if (defined?(::PhusionPassenger) || Gem.loaded_specs["passenger"]) && incompatible_passenger_version?
           Datadog.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.'
+            "installed. Profiling data will have lower quality." \
+            "To fix this, upgrade the passenger gem to version 6.0.19 or above."
           )
           return true
         end
@@ -351,11 +333,11 @@ module Datadog
         return true if settings.profiling.advanced.skip_mysql2_check
 
         Datadog.logger.debug(
-          'Requiring `mysql2` to check if the `libmysqlclient` version it uses is compatible with profiling'
+          "Requiring `mysql2` to check if the `libmysqlclient` version it uses is compatible with profiling"
         )
 
         begin
-          require 'mysql2'
+          require "mysql2"
 
           # The mysql2-aurora gem likes to monkey patch itself in replacement of Mysql2::Client, and uses
           # `method_missing` to delegate to the original BUT unfortunately does not implement `respond_to_missing?` and
@@ -376,18 +358,18 @@ module Datadog
           libmysqlclient_version = Gem::Version.new(info[:version])
 
           compatible =
-            libmysqlclient_version >= Gem::Version.new('8.0.0') ||
+            libmysqlclient_version >= Gem::Version.new("8.0.0") ||
             looks_like_mariadb?(info, libmysqlclient_version)
 
           Datadog.logger.debug(
-            "The `mysql2` gem is using #{compatible ? 'a compatible' : 'an incompatible'} version of " \
+            "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(
-            'Failed to probe `mysql2` gem information. ' \
+            "Failed to probe `mysql2` gem information. " \
             "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
           )
 
@@ -397,8 +379,12 @@ module Datadog
 
       # See https://github.com/datadog/dd-trace-rb/issues/2976 for details.
       private_class_method def self.incompatible_passenger_version?
-        if Gem.loaded_specs['passenger']
-          Gem.loaded_specs['passenger'].version < Gem::Version.new('6.0.19')
+        first_compatible_version = Gem::Version.new("6.0.19")
+
+        if Gem.loaded_specs["passenger"]
+          Gem.loaded_specs["passenger"].version < first_compatible_version
+        elsif defined?(PhusionPassenger::VERSION_STRING)
+          Gem::Version.new(PhusionPassenger::VERSION_STRING) < first_compatible_version
         else
           true
         end
@@ -409,7 +395,7 @@ module Datadog
           overhead_target_percentage
         else
           Datadog.logger.error(
-            'Ignoring invalid value for profiling overhead_target_percentage setting: ' \
+            "Ignoring invalid value for profiling overhead_target_percentage setting: " \
             "#{overhead_target_percentage.inspect}. Falling back to default value."
           )
 
@@ -442,8 +428,17 @@ module Datadog
         header_version = Gem::Version.new(info[:header_version]) if info[:header_version]
 
         !!(header_version &&
-          libmysqlclient_version < Gem::Version.new('5.0.0') &&
-          header_version >= Gem::Version.new('10.0.0'))
+          libmysqlclient_version < Gem::Version.new("5.0.0") &&
+          header_version >= Gem::Version.new("10.0.0"))
+      end
+
+      private_class_method def self.dir_interruption_workaround_enabled?(settings, no_signals_workaround_enabled)
+        return false if no_signals_workaround_enabled
+
+        # NOTE: In the future this method will evolve to check for Ruby versions affected and not apply the workaround
+        # when it's not needed but currently all known Ruby versions are affected.
+
+        settings.profiling.advanced.dir_interruption_workaround_enabled
       end
     end
   end

data/lib/datadog/profiling/exporter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'ext'
-require_relative 'tag_builder'
+require_relative "ext"
+require_relative "tag_builder"
 
 module Datadog
   module Profiling
@@ -61,7 +61,7 @@ module Datadog
         @last_flush_finish_at = finish
 
         if duration_below_threshold?(start, finish)
-          Datadog.logger.debug('Skipped exporting profiling events as profile duration is below minimum')
+          Datadog.logger.debug("Skipped exporting profiling events as profile duration is below minimum")
           return
         end