ddtrace 1.17.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/configuration.rb

@@ -273,6 +273,10 @@ module Datadog
       def handle_interrupt_shutdown!
         logger = Datadog.logger
         shutdown_thread = Thread.new { shutdown! }
+        unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+          shutdown_thread.name = Datadog::Core::Configuration.name
+        end
+
         print_message_treshold_seconds = 0.2
 
         slow_shutdown = shutdown_thread.join(print_message_treshold_seconds).nil?

data/lib/datadog/core/remote/worker.rb

@@ -30,6 +30,7 @@ module Datadog
 
           thread = Thread.new { poll(@interval) }
           thread.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+          thread.thread_variable_set(:fork_safe, true)
           @thr = thread
 
           @started = true

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/core/workers/async.rb

@@ -147,6 +147,7 @@ module Datadog
               # rubocop:enable Lint/RescueException
             end
             @worker.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+            @worker.thread_variable_set(:fork_safe, true)
 
             nil
           end

data/lib/datadog/kit/enable_core_dumps.rb

@@ -16,11 +16,13 @@ module Datadog
             '(Could not open /proc/sys/kernel/core_pattern)'
           end
 
+        enabled_status = "Maximum size: #{maximum_size} Output pattern: '#{core_pattern}'"
+
         if maximum_size <= 0
           Kernel.warn("[ddtrace] Could not enable core dumps on crash, maximum size is #{maximum_size} (disabled).")
           return
         elsif maximum_size == current_size
-          Kernel.warn('[ddtrace] Core dumps already enabled, nothing to do!')
+          Kernel.warn("[ddtrace] Core dumps already enabled, nothing to do. #{enabled_status}")
           return
         end
 
@@ -35,12 +37,9 @@ module Datadog
         end
 
         if current_size == 0
-          Kernel.warn("[ddtrace] Enabled core dumps. Maximum size: #{maximum_size} Output pattern: '#{core_pattern}'")
+          Kernel.warn("[ddtrace] Enabled core dumps. #{enabled_status}")
         else
-          Kernel.warn(
-            "[ddtrace] Raised core dump limit. Old size: #{current_size} " \
-            "Maximum size: #{maximum_size} Output pattern: '#{core_pattern}'"
-          )
+          Kernel.warn("[ddtrace] Raised core dump limit. Old size: #{current_size} #{enabled_status}")
         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
@@ -78,6 +73,7 @@ module Datadog
               end
             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)
           end
 
           true

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

@@ -43,6 +43,7 @@ module Datadog
               end
             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)
           end
 
           true