ddtrace 1.18.0 → 1.19.0

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

@@ -314,32 +314,85 @@ module Datadog
 
             # Can be used to enable/disable the Datadog::Profiling.allocation_count feature.
             #
-            # This feature is safe and enabled by default on Ruby 2.x, but has a few caveats on Ruby 3.x.
+            # This feature is now controlled via {:experimental_allocation_enabled}
+            option :allocation_counting_enabled do |o|
+              o.after_set do
+                Datadog.logger.warn(
+                  'The profiling.advanced.allocation_counting_enabled setting has been deprecated for removal and no ' \
+                  'longer does anything. Please remove it from your Datadog.configure block. ' \
+                  'Allocation counting is now controlled by the `experimental_allocation_enabled` setting instead.'
+                )
+              end
+            end
+
+            # Can be used to enable/disable collection of allocation profiles.
+            #
+            # This feature is alpha and disabled by default
             #
-            # Caveat 1 (severe):
-            # On Ruby versions 3.0 (all), 3.1.0 to 3.1.3, and 3.2.0 to 3.2.2 this is disabled by default because it
-            # can trigger a VM bug 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.
+            # @warn This feature is not supported/safe in all Rubies. Details in {Datadog::Profiling::Component} but
+            #       in summary, this should be supported on Ruby 2.x, 3.1.4+, 3.2.3+ and 3.3.0+. Enabling it on
+            #       unsupported Rubies may result in unexpected behaviour, including crashes.
             #
-            # Caveat 2 (annoyance):
-            # 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.
-            # Thus this feature is only usable if you're not using Ractors.
+            # @default `DD_PROFILING_EXPERIMENTAL_ALLOCATION_ENABLED` environment variable as a boolean, otherwise `false`
+            option :experimental_allocation_enabled do |o|
+              o.type :bool
+              o.env 'DD_PROFILING_EXPERIMENTAL_ALLOCATION_ENABLED'
+              o.default false
+            end
+
+            # Can be used to enable/disable the collection of heap profiles.
             #
-            # Caveat 3 (severe):
-            # 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) so that's an extra reason why it's not safe on those Rubies.
-            # This bug is fixed on Ruby versions 3.2.3 and 3.3.0.
+            # This feature is alpha and disabled by default
             #
-            # @default `true` on Ruby 2.x and 3.1.4+, 3.2.3+ and 3.3.0+; `false` for Ruby 3.0 and unpatched Rubies.
-            option :allocation_counting_enabled do |o|
-              o.default do
-                RUBY_VERSION.start_with?('2.') ||
-                  (RUBY_VERSION.start_with?('3.1.') && RUBY_VERSION >= '3.1.4') ||
-                  (RUBY_VERSION.start_with?('3.2.') && RUBY_VERSION >= '3.2.3') ||
-                  RUBY_VERSION >= '3.3.'
-              end
+            # @warn To enable heap profiling you are required to also enable allocation profiling.
+            #
+            # @default `DD_PROFILING_EXPERIMENTAL_HEAP_ENABLED` environment variable as a boolean, otherwise `false`
+            option :experimental_heap_enabled do |o|
+              o.type :bool
+              o.env 'DD_PROFILING_EXPERIMENTAL_HEAP_ENABLED'
+              o.default false
+            end
+
+            # Can be used to enable/disable the collection of heap size profiles.
+            #
+            # This feature is alpha and enabled by default when heap profiling is enabled.
+            #
+            # @warn To enable heap size profiling you are required to also enable allocation and heap profiling.
+            #
+            # @default `DD_PROFILING_EXPERIMENTAL_HEAP_SIZE_ENABLED` environment variable as a boolean, otherwise
+            # whatever the value of DD_PROFILING_EXPERIMENTAL_HEAP_ENABLED is.
+            option :experimental_heap_size_enabled do |o|
+              o.type :bool
+              o.env 'DD_PROFILING_EXPERIMENTAL_HEAP_SIZE_ENABLED'
+              o.default true # This gets ANDed with experimental_heap_enabled in the profiler component.
+            end
+
+            # Can be used to configure the allocation sampling rate: a sample will be collected every x allocations.
+            #
+            # The lower the value, the more accuracy in allocation and heap tracking but the bigger the overhead. In
+            # particular, a value of 1 will sample ALL allocations.
+            #
+            # @default `DD_PROFILING_EXPERIMENTAL_ALLOCATION_SAMPLE_RATE` environment variable, otherwise `50`.
+            option :experimental_allocation_sample_rate do |o|
+              o.type :int
+              o.env 'DD_PROFILING_EXPERIMENTAL_ALLOCATION_SAMPLE_RATE'
+              o.default 50
+            end
+
+            # Can be used to configure the heap sampling rate: a heap sample will be collected for every x allocation
+            # samples.
+            #
+            # The lower the value, the more accuracy in heap tracking but the bigger the overhead. In particular, a
+            # value of 1 will track ALL allocations samples for heap profiles.
+            #
+            # The effective heap sampling rate in terms of allocations (not allocation samples) can be calculated via
+            # effective_heap_sample_rate = allocation_sample_rate * heap_sample_rate.
+            #
+            # @default `DD_PROFILING_EXPERIMENTAL_HEAP_SAMPLE_RATE` environment variable, otherwise `10`.
+            option :experimental_heap_sample_rate do |o|
+              o.type :int
+              o.env 'DD_PROFILING_EXPERIMENTAL_HEAP_SAMPLE_RATE'
+              o.default 10
             end
 
             # Can be used to disable checking which version of `libmysqlclient` is being used by the `mysql2` gem.
@@ -391,6 +444,34 @@ module Datadog
                 end
               end
             end
+
+            # Configures how much wall-time overhead the profiler targets. The profiler will dynamically adjust the
+            # interval between samples it takes so as to try and maintain the property that it spends no longer than
+            # this amount of wall-clock time profiling. For example, with the default value of 2%, the profiler will
+            # try and cause no more than 1.2 seconds per minute of overhead. Decreasing this value will reduce the
+            # accuracy of the data collected. Increasing will impact the application.
+            #
+            # We do not recommend tweaking this value.
+            #
+            # This value should be a percentage i.e. a number between 0 and 100, not 0 and 1.
+            #
+            # @default `DD_PROFILING_OVERHEAD_TARGET_PERCENTAGE` as a float, otherwise 2.0
+            option :overhead_target_percentage do |o|
+              o.type :float
+              o.env 'DD_PROFILING_OVERHEAD_TARGET_PERCENTAGE'
+              o.default 2.0
+            end
+
+            # Controls how often the profiler reports data, in seconds. Cannot be lower than 60 seconds.
+            #
+            # We do not recommend tweaking this value.
+            #
+            # @default `DD_PROFILING_UPLOAD_PERIOD` environment variable, otherwise 60
+            option :upload_period_seconds do |o|
+              o.type :int
+              o.env 'DD_PROFILING_UPLOAD_PERIOD'
+              o.default 60
+            end
           end
 
           # @public_api
@@ -592,6 +673,42 @@ module Datadog
             o.env Core::Telemetry::Ext::ENV_HEARTBEAT_INTERVAL
             o.default 60.0
           end
+
+          # The install id of the application.
+          #
+          # This method is used internally, by library injection.
+          #
+          # @default `DD_INSTRUMENTATION_INSTALL_ID` environment variable, otherwise `nil`.
+          # @return [String,nil]
+          # @!visibility private
+          option :install_id do |o|
+            o.type :string, nilable: true
+            o.env Core::Telemetry::Ext::ENV_INSTALL_ID
+          end
+
+          # The install type of the application.
+          #
+          # This method is used internally, by library injection.
+          #
+          # @default `DD_INSTRUMENTATION_INSTALL_TYPE` environment variable, otherwise `nil`.
+          # @return [String,nil]
+          # @!visibility private
+          option :install_type do |o|
+            o.type :string, nilable: true
+            o.env Core::Telemetry::Ext::ENV_INSTALL_TYPE
+          end
+
+          # The install time of the application.
+          #
+          # This method is used internally, by library injection.
+          #
+          # @default `DD_INSTRUMENTATION_INSTALL_TIME` environment variable, otherwise `nil`.
+          # @return [String,nil]
+          # @!visibility private
+          option :install_time do |o|
+            o.type :string, nilable: true
+            o.env Core::Telemetry::Ext::ENV_INSTALL_TIME
+          end
         end
 
         # Remote configuration

data/lib/datadog/core/telemetry/collector.rb

@@ -9,6 +9,7 @@ require_relative '../utils/hash'
 require_relative 'v1/application'
 require_relative 'v1/dependency'
 require_relative 'v1/host'
+require_relative 'v1/install_signature'
 require_relative 'v1/integration'
 require_relative 'v1/product'
 require_relative '../transport/ext'
@@ -81,6 +82,15 @@ module Datadog
           )
         end
 
+        # Forms a telemetry app-started install_signature object
+        def install_signature
+          Telemetry::V1::InstallSignature.new(
+            install_id: Datadog.configuration.dig('telemetry', 'install_id'),
+            install_type: Datadog.configuration.dig('telemetry', 'install_type'),
+            install_time: Datadog.configuration.dig('telemetry', 'install_time'),
+          )
+        end
+
         # Forms a telemetry app-started integrations object
         def integrations
           Datadog.registry.map do |integration|

data/lib/datadog/core/telemetry/event.rb

@@ -60,7 +60,8 @@ module Datadog
             dependencies: dependencies,
             integrations: integrations,
             configuration: configurations,
-            additional_payload: additional_payload
+            additional_payload: additional_payload,
+            install_signature: install_signature
           )
         end
 

data/lib/datadog/core/telemetry/ext.rb

@@ -6,6 +6,9 @@ module Datadog
       module Ext
         ENV_ENABLED = 'DD_INSTRUMENTATION_TELEMETRY_ENABLED'
         ENV_HEARTBEAT_INTERVAL = 'DD_TELEMETRY_HEARTBEAT_INTERVAL'
+        ENV_INSTALL_ID = 'DD_INSTRUMENTATION_INSTALL_ID'
+        ENV_INSTALL_TYPE = 'DD_INSTRUMENTATION_INSTALL_TYPE'
+        ENV_INSTALL_TIME = 'DD_INSTRUMENTATION_INSTALL_TIME'
       end
     end
   end

data/lib/datadog/core/telemetry/v1/app_event.rb

@@ -10,18 +10,24 @@ module Datadog
             :additional_payload,
             :configuration,
             :dependencies,
+            :install_signature,
             :integrations
 
           # @param additional_payload [Array<Telemetry::V1::Configuration>] List of Additional payload to track (any key
           #   value not mentioned and doesn't fit under a metric)
           # @param configuration [Array<Telemetry::V1::Configuration>] List of Tracer related configuration data
           # @param dependencies [Array<Telemetry::V1::Dependency>] List of all loaded modules requested by the app
+          # @param install_signature [Telemetry::V1::InstallSignature] Install signature data
           # @param integrations [Array<Telemetry::V1::Integration>] List of integrations that are available within the app
           #   and applicable to be traced
-          def initialize(additional_payload: nil, configuration: nil, dependencies: nil, integrations: nil)
+          def initialize(
+            additional_payload: nil, configuration: nil, dependencies: nil, install_signature: nil,
+            integrations: nil
+          )
             @additional_payload = additional_payload
             @configuration = configuration
             @dependencies = dependencies
+            @install_signature = install_signature
             @integrations = integrations
           end
 
@@ -30,6 +36,7 @@ module Datadog
               hash[:additional_payload] = map_hash(@additional_payload) if @additional_payload
               hash[:configuration] = map_hash(@configuration) if @configuration
               hash[:dependencies] = map_array(@dependencies) if @dependencies
+              hash[:install_signature] = @install_signature.to_h if @install_signature
               hash[:integrations] = map_array(@integrations) if @integrations
             end
           end

data/lib/datadog/core/telemetry/v1/install_signature.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Core
+    module Telemetry
+      module V1
+        # Describes attributes for install signature
+        class InstallSignature
+          using Core::Utils::Hash::Refinement
+
+          attr_reader \
+            :install_id,
+            :install_type,
+            :install_time
+
+          # @param id [String,nil] Install ID
+          # @param type [String,nil] Install type
+          # @param type [String,nil] Install time
+          def initialize(install_id:, install_type:, install_time:)
+            @install_id = install_id
+            @install_type = install_type
+            @install_time = install_time
+          end
+
+          def to_h
+            hash = {
+              install_id: @install_id,
+              install_type: @install_type,
+              install_time: @install_time
+            }
+            hash.compact!
+            hash
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -15,14 +15,15 @@ module Datadog
 
         def initialize(
           gc_profiling_enabled:,
-          allocation_counting_enabled:,
           no_signals_workaround_enabled:,
           thread_context_collector:,
-          idle_sampling_helper: IdleSamplingHelper.new,
+          dynamic_sampling_rate_overhead_target_percentage:,
+          allocation_sample_every:,
+          allocation_profiling_enabled:,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
           dynamic_sampling_rate_enabled: true,
-          allocation_sample_every: 0 # Currently only for testing; Setting this to > 0 can add a lot of overhead!
+          idle_sampling_helper: IdleSamplingHelper.new
         )
           unless dynamic_sampling_rate_enabled
             Datadog.logger.warn(
@@ -30,22 +31,16 @@ module Datadog
             )
           end
 
-          if allocation_counting_enabled && allocation_sample_every > 0
-            Datadog.logger.warn(
-              "Enabled experimental allocation profiling: allocation_sample_every=#{allocation_sample_every}. This is " \
-              'experimental, not recommended, and will increase overhead!'
-            )
-          end
-
           self.class._native_initialize(
             self,
             thread_context_collector,
             gc_profiling_enabled,
             idle_sampling_helper,
-            allocation_counting_enabled,
             no_signals_workaround_enabled,
             dynamic_sampling_rate_enabled,
+            dynamic_sampling_rate_overhead_target_percentage,
             allocation_sample_every,
+            allocation_profiling_enabled,
           )
           @worker_thread = nil
           @failure_exception = nil

data/lib/datadog/profiling/component.rb

@@ -7,7 +7,7 @@ module Datadog
       # 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
       # * Endpoint aggregation in the profiler UX, including normalization (resource per endpoint call)
-      def self.build_profiler_component(settings:, agent_settings:, optional_tracer:)
+      def self.build_profiler_component(settings:, agent_settings:, optional_tracer:) # rubocop:disable Metrics/MethodLength
         require_relative '../profiling/diagnostics/environment_logger'
 
         Profiling::Diagnostics::EnvironmentLogger.collect_and_log!
@@ -41,38 +41,57 @@ module Datadog
 
         no_signals_workaround_enabled = no_signals_workaround_enabled?(settings)
         timeline_enabled = settings.profiling.advanced.experimental_timeline_enabled
+        allocation_sample_every = get_allocation_sample_every(settings)
+        allocation_profiling_enabled = enable_allocation_profiling?(settings, allocation_sample_every)
+        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)
+
+        overhead_target_percentage = valid_overhead_target(settings.profiling.advanced.overhead_target_percentage)
+        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
-          alloc_samples_enabled: false, # Always disabled for now -- work in progress
-        )
-        thread_context_collector = Datadog::Profiling::Collectors::ThreadContext.new(
-          recorder: recorder,
-          max_frames: settings.profiling.advanced.max_frames,
-          tracer: optional_tracer,
-          endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled,
+          alloc_samples_enabled: allocation_profiling_enabled,
+          heap_samples_enabled: heap_profiling_enabled,
+          heap_size_enabled: heap_size_profiling_enabled,
+          heap_sample_every: heap_sample_every,
           timeline_enabled: timeline_enabled,
         )
+        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),
-          allocation_counting_enabled: settings.profiling.advanced.allocation_counting_enabled,
           no_signals_workaround_enabled: no_signals_workaround_enabled,
           thread_context_collector: thread_context_collector,
-          allocation_sample_every: 0,
+          dynamic_sampling_rate_overhead_target_percentage: overhead_target_percentage,
+          allocation_sample_every: allocation_sample_every,
+          allocation_profiling_enabled: allocation_profiling_enabled,
         )
 
         internal_metadata = {
           no_signals_workaround_enabled: no_signals_workaround_enabled,
           timeline_enabled: timeline_enabled,
+          allocation_sample_every: allocation_sample_every,
+          heap_sample_every: heap_sample_every,
         }.freeze
 
         exporter = build_profiler_exporter(settings, recorder, internal_metadata: internal_metadata)
         transport = build_profiler_transport(settings, agent_settings)
-        scheduler = Profiling::Scheduler.new(exporter: exporter, transport: transport)
+        scheduler = Profiling::Scheduler.new(exporter: exporter, transport: transport, interval: upload_period_seconds)
 
         Profiling::Profiler.new(worker: worker, scheduler: scheduler)
       end
 
+      private_class_method def self.build_thread_context_collector(settings, recorder, optional_tracer, timeline_enabled)
+        Datadog::Profiling::Collectors::ThreadContext.new(
+          recorder: recorder,
+          max_frames: settings.profiling.advanced.max_frames,
+          tracer: optional_tracer,
+          endpoint_collection_enabled: settings.profiling.advanced.endpoint.collection.enabled,
+          timeline_enabled: timeline_enabled,
+        )
+      end
+
       private_class_method def self.build_profiler_exporter(settings, recorder, internal_metadata:)
         code_provenance_collector =
           (Profiling::Collectors::CodeProvenance.new if settings.profiling.advanced.code_provenance_enabled)
@@ -110,6 +129,126 @@ module Datadog
         end
       end
 
+      private_class_method def self.get_allocation_sample_every(settings)
+        allocation_sample_rate = settings.profiling.advanced.experimental_allocation_sample_rate
+
+        if allocation_sample_rate <= 0
+          raise ArgumentError, "Allocation sample rate must be a positive integer. Was #{allocation_sample_rate}"
+        end
+
+        allocation_sample_rate
+      end
+
+      private_class_method def self.get_heap_sample_every(settings)
+        heap_sample_rate = settings.profiling.advanced.experimental_heap_sample_rate
+
+        raise ArgumentError, "Heap sample rate must be a positive integer. Was #{heap_sample_rate}" if heap_sample_rate <= 0
+
+        heap_sample_rate
+      end
+
+      private_class_method def self.enable_allocation_profiling?(settings, allocation_sample_every)
+        unless settings.profiling.advanced.experimental_allocation_enabled
+          # Allocation profiling disabled, short-circuit out
+          return false
+        end
+
+        # Allocation sampling is safe and supported on Ruby 2.x, but has a few caveats on Ruby 3.x.
+
+        # SEVERE - All configurations
+        # 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'
+          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.'
+          )
+          return false
+        end
+
+        # SEVERE - Only with Ractors
+        # On Ruby versions 3.0 (all), 3.1.0 to 3.1.3, and 3.2.0 to 3.2.2 allocation profiling can trigger a VM bug
+        # 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')
+          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.'
+          )
+        # 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.')
+          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.'
+          )
+        end
+
+        Datadog.logger.warn(
+          "Enabled experimental allocation profiling: allocation_sample_rate=#{allocation_sample_every}. This is " \
+          'experimental, not recommended, and will increase overhead!'
+        )
+
+        true
+      end
+
+      private_class_method def self.enable_heap_profiling?(settings, allocation_profiling_enabled, heap_sample_rate)
+        heap_profiling_enabled = settings.profiling.advanced.experimental_heap_enabled
+
+        return false unless heap_profiling_enabled
+
+        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.'
+          )
+          return false
+        end
+
+        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 '\
+            "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).'
+          )
+        end
+
+        unless allocation_profiling_enabled
+          raise ArgumentError,
+            '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!'
+        )
+
+        true
+      end
+
+      private_class_method def self.enable_heap_size_profiling?(settings, heap_profiling_enabled)
+        heap_size_profiling_enabled = settings.profiling.advanced.experimental_heap_size_enabled
+
+        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!'
+        )
+
+        true
+      end
+
       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.3.', '2.4.', '2.5.')
@@ -217,9 +356,12 @@ module Datadog
 
           return true unless mysql2_client_class && mysql2_client_class.respond_to?(:info)
 
-          libmysqlclient_version = Gem::Version.new(mysql2_client_class.info[:version])
+          info = mysql2_client_class.info
+          libmysqlclient_version = Gem::Version.new(info[:version])
 
-          compatible = libmysqlclient_version >= Gem::Version.new('8.0.0')
+          compatible =
+            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 " \
@@ -245,6 +387,48 @@ module Datadog
           true
         end
       end
+
+      private_class_method def self.valid_overhead_target(overhead_target_percentage)
+        if overhead_target_percentage > 0 && overhead_target_percentage <= 20
+          overhead_target_percentage
+        else
+          Datadog.logger.error(
+            'Ignoring invalid value for profiling overhead_target_percentage setting: ' \
+            "#{overhead_target_percentage.inspect}. Falling back to default value."
+          )
+
+          2.0
+        end
+      end
+
+      # To add just a bit more complexity to our detection code, in https://github.com/DataDog/dd-trace-rb/issues/3334
+      # a user reported that our code was incorrectly flagging the mariadb variant of libmysqlclient as being
+      # incompatible. In fact we have no reports of the mariadb variant needing the "no signals" workaround,
+      # so we flag it as compatible when it's in use.
+      #
+      # A problem is that there doesn't seem to be an obvious way to query the mysql2 gem on which kind of
+      # libmysqlclient it's using, so we detect it by looking at the version.
+      #
+      # The info method for mysql2 with mariadb looks something like this:
+      # `{:id=>30308, :version=>"3.3.8", :header_version=>"11.2.2"}`
+      #
+      # * The version seems to come from https://github.com/mariadb-corporation/mariadb-connector-c and the latest
+      # one is 3.x.
+      # * The header_version is what people usually see as the "mariadb version"
+      #
+      # As a comparison, for libmysql the info looks like:
+      # * `{:id=>80035, :version=>"8.0.35", :header_version=>"8.0.35"}`
+      #
+      # Thus our detection is version 4 or older, because libmysqlclient 4 is almost 20 years old so it's most probably
+      # not that one + header_version being 10 or newer, since according to https://endoflife.date/mariadb that's a
+      # sane range for modern mariadb releases.
+      private_class_method def self.looks_like_mariadb?(info, libmysqlclient_version)
+        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'))
+      end
     end
   end
 end

data/lib/datadog/profiling/scheduler.rb

@@ -5,12 +5,11 @@ require_relative '../core/workers/polling'
 
 module Datadog
   module Profiling
-    # Periodically (every DEFAULT_INTERVAL_SECONDS) takes a profile from the `Exporter` and reports it using the
+    # Periodically (every interval, 60 seconds by default) takes a profile from the `Exporter` and reports it using the
     # configured transport. Runs on its own background thread.
     class Scheduler < Core::Worker
       include Core::Workers::Polling
 
-      DEFAULT_INTERVAL_SECONDS = 60
       MINIMUM_INTERVAL_SECONDS = 0
 
       # We sleep for at most this duration seconds before reporting data to avoid multi-process applications all
@@ -28,8 +27,7 @@ module Datadog
       def initialize(
         exporter:,
         transport:,
-        fork_policy: Core::Workers::Async::Thread::FORK_POLICY_RESTART, # Restart in forks by default
-        interval: DEFAULT_INTERVAL_SECONDS,
+        interval:, fork_policy: Core::Workers::Async::Thread::FORK_POLICY_RESTART, # Restart in forks by default, # seconds
         enabled: true
       )
         @exporter = exporter
@@ -115,8 +113,8 @@ module Datadog
         #
         # During PR review (https://github.com/DataDog/dd-trace-rb/pull/1807) we discussed the possible alternative of
         # just sleeping before starting the scheduler loop. We ended up not going with that option to avoid the first
-        # profile containing up to DEFAULT_INTERVAL_SECONDS + DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS instead of the
-        # usual DEFAULT_INTERVAL_SECONDS size.
+        # profile containing up to interval + DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS instead of the
+        # usual interval seconds.
         if run_loop?
           jitter_seconds = rand * DEFAULT_FLUSH_JITTER_MAXIMUM_SECONDS # floating point number between (0.0...maximum)
           sleep(jitter_seconds)