ddtrace 1.12.1 → 1.18.0

data/lib/datadog/kit/identity.rb

@@ -6,84 +6,99 @@ module Datadog
   module Kit
     # Tracking identity via traces
     module Identity
-      # Attach user information to the trace
-      #
-      # @param trace [TraceOperation] Trace to attach data to. Defaults to
-      #   active trace.
-      # @param span [SpanOperation] Span to attach data to. Defaults to
-      #   active span on trace. Note that this should be a service entry span.
-      #   When AppSec is enabled, the expected span and trace are automatically
-      #   used as defaults.
-      # @param id [String] Mandatory. Username or client id extracted
-      #   from the access token or Authorization header in the inbound request
-      #   from outside the system.
-      # @param email [String] Email of the authenticated user associated
-      #   to the trace.
-      # @param name [String] User-friendly name. To be displayed in the
-      #   UI if set.
-      # @param session_id [String] Session ID of the authenticated user.
-      # @param role [String] Actual/assumed role the client is making
-      #   the request under extracted from token or application security
-      #   context.
-      # @param scope [String] Scopes or granted authorities the client
-      #   currently possesses extracted from token or application security
-      #   context. The value would come from the scope associated with an OAuth
-      #   2.0 Access Token or an attribute value in a SAML 2.0 Assertion.
-      # @param others [Hash<Symbol, String>] Additional free-form
-      #   user information to attach to the trace.
-      #
-      # rubocop:disable Metrics/CyclomaticComplexity
-      # rubocop:disable Metrics/PerceivedComplexity
-      # rubocop:disable Metrics/AbcSize
-      def self.set_user(
-        trace = nil, span = nil, id:, email: nil, name: nil, session_id: nil, role: nil, scope: nil, **others
-      )
-        raise ArgumentError, 'missing required key: :id' if id.nil?
+      class << self
+        # Attach user information to the trace
+        #
+        # @param trace [TraceOperation] Trace to attach data to. Defaults to
+        #   active trace.
+        # @param span [SpanOperation] Span to attach data to. Defaults to
+        #   active span on trace. Note that this should be a service entry span.
+        #   When AppSec is enabled, the expected span and trace are automatically
+        #   used as defaults.
+        # @param id [String] Mandatory. Username or client id extracted
+        #   from the access token or Authorization header in the inbound request
+        #   from outside the system.
+        # @param email [String] Email of the authenticated user associated
+        #   to the trace.
+        # @param name [String] User-friendly name. To be displayed in the
+        #   UI if set.
+        # @param session_id [String] Session ID of the authenticated user.
+        # @param role [String] Actual/assumed role the client is making
+        #   the request under extracted from token or application security
+        #   context.
+        # @param scope [String] Scopes or granted authorities the client
+        #   currently possesses extracted from token or application security
+        #   context. The value would come from the scope associated with an OAuth
+        #   2.0 Access Token or an attribute value in a SAML 2.0 Assertion.
+        # @param others [Hash<Symbol, String>] Additional free-form
+        #   user information to attach to the trace.
+        #
+        # rubocop:disable Metrics/CyclomaticComplexity
+        # rubocop:disable Metrics/PerceivedComplexity
+        def set_user(
+          trace = nil, span = nil, id:, email: nil, name: nil, session_id: nil, role: nil, scope: nil, **others
+        )
+          raise ArgumentError, 'missing required key: :id' if id.nil?
 
-        # enforce types
+          # enforce types
 
-        raise TypeError, ':id must be a String'         unless id.is_a?(String)
-        raise TypeError, ':email must be a String'      unless email.nil? || email.is_a?(String)
-        raise TypeError, ':name must be a String'       unless name.nil? || name.is_a?(String)
-        raise TypeError, ':session_id must be a String' unless session_id.nil? || session_id.is_a?(String)
-        raise TypeError, ':role must be a String'       unless role.nil? || role.is_a?(String)
-        raise TypeError, ':scope must be a String'      unless scope.nil? || scope.is_a?(String)
+          raise TypeError, ':id must be a String'         unless id.is_a?(String)
+          raise TypeError, ':email must be a String'      unless email.nil? || email.is_a?(String)
+          raise TypeError, ':name must be a String'       unless name.nil? || name.is_a?(String)
+          raise TypeError, ':session_id must be a String' unless session_id.nil? || session_id.is_a?(String)
+          raise TypeError, ':role must be a String'       unless role.nil? || role.is_a?(String)
+          raise TypeError, ':scope must be a String'      unless scope.nil? || scope.is_a?(String)
 
-        others.each do |k, v|
-          raise TypeError, "#{k.inspect} must be a String" unless v.nil? || v.is_a?(String)
-        end
+          others.each do |k, v|
+            raise TypeError, "#{k.inspect} must be a String" unless v.nil? || v.is_a?(String)
+          end
+
+          set_trace_and_span_context('set_user', trace, span) do |_active_trace, active_span|
+            # set tags once data is known consistent
+            active_span.set_tag('usr.id', id)
+            active_span.set_tag('usr.email', email)           unless email.nil?
+            active_span.set_tag('usr.name', name)             unless name.nil?
+            active_span.set_tag('usr.session_id', session_id) unless session_id.nil?
+            active_span.set_tag('usr.role', role)             unless role.nil?
+            active_span.set_tag('usr.scope', scope)           unless scope.nil?
 
-        if (appsec_scope = Datadog::AppSec.active_scope)
-          trace = appsec_scope.trace
-          span = appsec_scope.service_entry_span
+            others.each do |k, v|
+              active_span.set_tag("usr.#{k}", v) unless v.nil?
+            end
+
+            if Datadog::AppSec.active_scope
+              user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(id)
+              ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+            end
+          end
         end
+        # rubocop:enable Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/CyclomaticComplexity
 
-        trace ||= Datadog::Tracing.active_trace
-        span ||= trace.active_span || Datadog::Tracing.active_span
+        private
 
-        raise ArgumentError, "span #{span.span_id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
+        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
+          end
 
-        # set tags once data is known consistent
+          trace ||= Datadog::Tracing.active_trace
+          span ||= trace && trace.active_span || Datadog::Tracing.active_span
 
-        span.set_tag('usr.id', id)
-        span.set_tag('usr.email', email)           unless email.nil?
-        span.set_tag('usr.name', name)             unless name.nil?
-        span.set_tag('usr.session_id', session_id) unless session_id.nil?
-        span.set_tag('usr.role', role)             unless role.nil?
-        span.set_tag('usr.scope', scope)           unless scope.nil?
+          unless trace && span
+            Datadog.logger.debug(
+              "Tracing not enabled. Method ##{method} is a no-op. Please enable tracing if you want ##{method}"\
+              ' to track this events'
+            )
+            return
+          end
 
-        others.each do |k, v|
-          span.set_tag("usr.#{k}", v) unless v.nil?
-        end
+          raise ArgumentError, "span #{span.span_id} does not belong to trace #{trace.id}" if trace.id != span.trace_id
 
-        if appsec_scope
-          user = ::Datadog::AppSec::Instrumentation::Gateway::User.new(id)
-          ::Datadog::AppSec::Instrumentation.gateway.push('identity.set_user', user)
+          yield(trace, span)
         end
       end
-      # rubocop:enable Metrics/AbcSize
-      # rubocop:enable Metrics/PerceivedComplexity
-      # rubocop:enable Metrics/CyclomaticComplexity
     end
   end
 end

data/lib/datadog/opentelemetry/api/context.rb

@@ -2,6 +2,7 @@
 
 require_relative 'trace/span'
 require_relative '../../tracing/trace_operation'
+require_relative '../trace'
 
 module Datadog
   module OpenTelemetry
@@ -66,9 +67,15 @@ module Datadog
         # @param [Object] value Object to be stored under key
         # @return [Context]
         def set_values(values)
-          trace = nil
-          if (current_span = values[CURRENT_SPAN_KEY])
-            trace = current_span.datadog_trace
+          if (current_span = values[CURRENT_SPAN_KEY]) && current_span.datadog_trace
+            # Because `#set_value` returns new context, we have to create
+            # a new copy of the active trace to ensure there's no conflict with
+            # other users of the active trace.
+            # It effectively becomes an internal trace propagation.
+            trace = Datadog::OpenTelemetry::Trace.start_trace_copy(
+              current_span.datadog_trace,
+              parent_span: current_span.datadog_span
+            )
           end
 
           existing_values = @trace && @trace.otel_values || {}

data/lib/datadog/opentelemetry/sdk/propagator.rb

@@ -81,8 +81,9 @@ module Datadog
         private
 
         # Converts the {Numeric} Datadog id object to OpenTelemetry's byte array format.
+        # This method currently converts an unsigned 64-bit Integer to a binary String.
         def to_otel_id(dd_id)
-          Array(dd_id).pack('S')
+          Array(dd_id).pack('Q')
         end
       end
     end

data/lib/datadog/opentelemetry/sdk/span_processor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'trace/span'
+
 module Datadog
   module OpenTelemetry
     module SDK
@@ -27,7 +29,7 @@ module Datadog
         #
         # @param [Span] span the {Span} that just ended.
         def on_finish(span)
-          span.datadog_span.finish
+          span.datadog_span.finish(ns_to_time(span.end_timestamp))
         end
 
         # Export all ended spans to the configured `Exporter` that have not yet
@@ -76,15 +78,56 @@ module Datadog
         end
 
         def start_datadog_span(span)
-          tags = span.resource.attribute_enumerator.to_h
+          attributes = span.attributes.dup # Dup to allow modification of frozen Hash
+
+          name, kwargs = span_arguments(span, attributes)
 
-          kind = span.kind || 'internal'
-          tags[Tracing::Metadata::Ext::TAG_KIND] = kind
+          datadog_span = Tracing.trace(name, **kwargs)
 
-          datadog_span = Tracing.trace(span.name, tags: tags)
           datadog_span.set_error([nil, span.status.description]) unless span.status.ok?
+          datadog_span.set_tags(span.attributes)
+
           datadog_span
         end
+
+        # Some special attributes can override Datadog Span fields
+        def span_arguments(span, attributes)
+          if attributes.key?('analytics.event') && (analytics_event = attributes['analytics.event']).respond_to?(:casecmp)
+            attributes[Tracing::Metadata::Ext::Analytics::TAG_SAMPLE_RATE] = analytics_event.casecmp('true') == 0 ? 1 : 0
+          end
+          attributes[Tracing::Metadata::Ext::TAG_KIND] = span.kind || 'internal'
+
+          kwargs = { start_time: ns_to_time(span.start_timestamp) }
+
+          name = if attributes.key?('operation.name')
+                   attributes['operation.name']
+                 elsif (rich_name = Datadog::OpenTelemetry::Trace::Span.enrich_name(span.kind, attributes))
+                   rich_name.downcase
+                 else
+                   span.kind
+                 end
+
+          kwargs[:resource] = attributes.key?('resource.name') ? attributes['resource.name'] : span.name
+          kwargs[:service] = attributes['service.name'] if attributes.key?('service.name')
+          kwargs[:type] = attributes['span.type'] if attributes.key?('span.type')
+
+          attributes.reject! { |key, _| OpenTelemetry::Trace::Span::DATADOG_SPAN_ATTRIBUTE_OVERRIDES.include?(key) }
+
+          # DEV: There's no `flat_map!`; we have to split it into two operations
+          attributes = attributes.map do |key, value|
+            Datadog::OpenTelemetry::Trace::Span.serialize_attribute(key, value)
+          end
+          attributes.flatten!(1)
+
+          kwargs[:tags] = attributes
+
+          [name, kwargs]
+        end
+
+        # From nanoseconds, used by OpenTelemetry, to a {Time} object, used by the Datadog Tracer.
+        def ns_to_time(timestamp_ns)
+          Time.at(timestamp_ns / 1000000000.0)
+        end
       end
     end
   end

data/lib/datadog/opentelemetry/sdk/trace/span.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Datadog
+  module OpenTelemetry
+    module Trace
+      # Stores associated Datadog entities to the OpenTelemetry Span.
+      module Span
+        # Attributes are equivalent to span tags and metrics.
+        def set_attribute(key, value)
+          res = super
+          # Attributes can get dropped or their values truncated by `super`
+          datadog_set_attribute(key)
+          res
+        end
+
+        # `alias` performed to match {OpenTelemetry::SDK::Trace::Span} aliasing upstream
+        alias []= set_attribute
+
+        # Attributes are equivalent to span tags and metrics.
+        def add_attributes(attributes)
+          res = super
+          # Attributes can get dropped or their values truncated by `super`
+          attributes.each { |key, _| datadog_set_attribute(key) }
+          res
+        end
+
+        # Captures changes to span error state.
+        def status=(s)
+          super
+
+          return unless status # Return if status are currently disabled by OpenTelemetry.
+          return unless (span = datadog_span)
+
+          # Status code can only change into an error state.
+          # Other change operations should be ignored.
+          span.set_error(status.description) if status && status.code == ::OpenTelemetry::Trace::Status::ERROR
+        end
+
+        # Serialize values into Datadog span tags and metrics.
+        # Notably, arrays are exploded into many keys, each with
+        # a numeric suffix representing the array index, for example:
+        # `'foo' => ['a','b']` becomes `'foo.0' => 'a', 'foo.1' => 'b'`
+        def self.serialize_attribute(key, value)
+          if value.is_a?(Array)
+            value.flat_map.with_index do |v, idx|
+              serialize_attribute("#{key}.#{idx}", v)
+            end
+          elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
+            [[key, value.to_s]]
+          else
+            [[key, value]]
+          end
+        end
+
+        # Create a meaningful Datadog operation name from the OpenTelemetry
+        # semantic convention for span kind and span attributes.
+        # @see https://opentelemetry.io/docs/specs/semconv/general/trace/
+
+        # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        def self.enrich_name(kind, attrs)
+          if attrs.key?('http.request.method')
+            return 'http.server.request' if kind == :server
+            return 'http.client.request' if kind == :client
+          end
+
+          return "#{attrs['db.system']}.query" if attrs.key?('db.system') && kind == :client
+
+          if (attrs.key?('messaging.system') || attrs.key?('messaging.operation')) &&
+              [:consumer, :producer, :server, :client].include?(kind)
+
+            return "#{attrs['messaging.system']}.#{attrs['messaging.operation']}"
+          end
+
+          if attrs.key?('rpc.system')
+            if attrs['rpc.system'] == 'aws-api' && kind == :client
+              service = attrs['rpc.service']
+              return "aws.#{service || 'client'}.request"
+            end
+
+            if kind == :client
+              return "#{attrs['rpc.system']}.client.request"
+            elsif kind == :server
+              return "#{attrs['rpc.system']}.server.request"
+            end
+          end
+
+          if attrs.key?('faas.invoked_provider') && attrs.key?('faas.invoked_name') && kind == :client
+            provider = attrs['faas.invoked_provider']
+            name = attrs['faas.invoked_name']
+            return "#{provider}.#{name}.invoke"
+          end
+
+          return "#{attrs['faas.trigger']}.invoke" if attrs.key?('faas.trigger') && kind == :server
+
+          return 'graphql.server.request' if attrs.key?('graphql.operation.type')
+
+          if kind == :server
+            protocol = attrs['network.protocol.name']
+            return protocol ? "#{protocol}.server.request" : 'server.request'
+          end
+
+          if kind == :client
+            protocol = attrs['network.protocol.name']
+            return protocol ? "#{protocol}.client.request" : 'client.request'
+          end
+
+          kind.to_s
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+
+        private
+
+        def datadog_set_attribute(key)
+          # Return if attributes are currently disabled by OpenTelemetry.
+          return unless defined?(@attributes) && @attributes
+          return unless (span = datadog_span)
+
+          # DEV: Accesses `@attributes` directly, since using `#attributes`
+          # DEV: clones the hash, causing unnecessary overhead.
+          if @attributes.key?(key)
+            # Try to find a richer operation name, unless an explicit override was provided.
+            if !@attributes.key?('operation.name') && (rich_name = Span.enrich_name(kind, @attributes))
+              span.name = rich_name.downcase
+            end
+
+            Span.serialize_attribute(key, @attributes[key]).each do |new_key, value|
+              override_datadog_values(span, new_key, value)
+
+              # When an attribute is used to override a Datadog Span property,
+              # it should NOT be set as a Datadog Span tag.
+              span.set_tag(new_key, value) unless DATADOG_SPAN_ATTRIBUTE_OVERRIDES.include?(new_key)
+            end
+          else
+            span.clear_tag(key)
+
+            if key == 'service.name'
+              # By removing the service name, we set it to the fallback default,
+              # effectively removing the `service` attribute from OpenTelemetry's perspective.
+              span.service = Datadog.send(:components).tracer.default_service
+            end
+          end
+        end
+
+        # Some special attributes can override Datadog Span fields beyond tags and metrics.
+        # @return [Boolean] true if the key is a Datadog Span override attribute, false otherwise
+        def override_datadog_values(span, key, value)
+          span.name = value if key == 'operation.name'
+          span.resource = value if key == 'resource.name'
+          span.service = value if key == 'service.name'
+          span.type = value if key == 'span.type'
+
+          if key == 'analytics.event' && value.respond_to?(:casecmp)
+            Datadog::Tracing::Analytics.set_sample_rate(
+              span,
+              value.casecmp('true') == 0 ? 1 : 0
+            )
+          end
+        end
+
+        DATADOG_SPAN_ATTRIBUTE_OVERRIDES = ['analytics.event', 'operation.name', 'resource.name', 'service.name',
+                                            'span.type'].freeze
+
+        ::OpenTelemetry::SDK::Trace::Span.prepend(self)
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry/trace.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../tracing/trace_digest'
+
+module Datadog
+  module OpenTelemetry
+    # OpenTelemetry utilities related to the respective Datadog trace.
+    module Trace
+      class << self
+        # Creates a new TraceOperation object that can be attached to a new
+        # OpenTelemetry span.
+        # If `parent_span` is provided, then that span is set as the currently
+        # active parent span.
+        #
+        # @return [TraceOperation]
+        def start_trace_copy(trace, parent_span: nil)
+          digest = if parent_span
+                     digest_with_parent_span(trace, parent_span)
+                   else
+                     trace.to_digest
+                   end
+
+          # Create a new TraceOperation, attached to the current Datadog Tracer.
+          Datadog::Tracing.continue_trace!(digest)
+        end
+
+        private
+
+        # Creates a TraceDigest with the active span modified.
+        # This supports the implementation of `OpenTelemetry::Trace.context_with_span`,
+        # which allows you to specific any span as the arbitrary parent of a new span.
+        def digest_with_parent_span(trace, parent_span)
+          digest = trace.to_digest
+
+          Tracing::TraceDigest.new(
+            span_id: parent_span.id,
+            span_name: parent_span.name,
+            span_resource: parent_span.resource,
+            span_service: parent_span.service,
+            span_type: parent_span.type,
+            trace_distributed_tags: digest.trace_distributed_tags,
+            trace_hostname: digest.trace_hostname,
+            trace_id: digest.trace_id,
+            trace_name: digest.trace_name,
+            trace_origin: digest.trace_origin,
+            trace_process_id: digest.trace_process_id,
+            trace_resource: digest.trace_resource,
+            trace_runtime_id: digest.trace_runtime_id,
+            trace_sampling_priority: digest.trace_sampling_priority,
+            trace_service: digest.trace_service,
+            trace_state: digest.trace_state,
+            trace_state_unknown_fields: digest.trace_state_unknown_fields,
+          ).freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/opentelemetry.rb

@@ -16,6 +16,7 @@ require_relative 'opentelemetry/api/context'
 # DEV: This is different from our existing OpenTracer API, but there are many safety
 # DEV: features built into Contrib instrumentation today.
 require_relative 'opentelemetry/sdk/configurator' if defined?(OpenTelemetry::SDK)
+require_relative 'opentelemetry/sdk/trace/span' if defined?(OpenTelemetry::SDK)
 
 module Datadog
   # Datadog OpenTelemetry integration.

data/lib/datadog/opentracer/text_map_propagator.rb

@@ -33,7 +33,8 @@ module Datadog
           carrier[Tracing::Distributed::Datadog::ORIGIN_KEY] = digest.trace_origin
           carrier[Tracing::Distributed::Datadog::PARENT_ID_KEY] = digest.span_id
           carrier[Tracing::Distributed::Datadog::SAMPLING_PRIORITY_KEY] = digest.trace_sampling_priority
-          carrier[Tracing::Distributed::Datadog::TRACE_ID_KEY] = digest.trace_id
+          carrier[Tracing::Distributed::Datadog::TRACE_ID_KEY] =
+            Datadog::Tracing::Utils::TraceId.to_low_order(digest.trace_id)
 
           nil
         end

data/lib/datadog/opentracer.rb

@@ -22,3 +22,12 @@ require_relative 'opentracer/global_tracer'
 
 # Modify the OpenTracing module functions
 ::OpenTracing.singleton_class.prepend(Datadog::OpenTracer::GlobalTracer)
+
+module Datadog
+  # Datadog OpenTracing integration.
+  # DEV: This module should be named `Datadog::OpenTracing` to match the gem (`opentracing`).
+  module OpenTracer
+    # Used by Telemetry to decide if OpenTracing instrumentation is enabled
+    LOADED = true
+  end
+end

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

@@ -14,23 +14,15 @@ module Datadog
         public
 
         def initialize(
-          recorder:,
-          max_frames:,
-          tracer:,
-          endpoint_collection_enabled:,
           gc_profiling_enabled:,
           allocation_counting_enabled:,
           no_signals_workaround_enabled:,
-          thread_context_collector: ThreadContext.new(
-            recorder: recorder,
-            max_frames: max_frames,
-            tracer: tracer,
-            endpoint_collection_enabled: endpoint_collection_enabled,
-          ),
+          thread_context_collector:,
           idle_sampling_helper: IdleSamplingHelper.new,
           # **NOTE**: This should only be used for testing; disabling the dynamic sampling rate will increase the
           # profiler overhead!
-          dynamic_sampling_rate_enabled: true
+          dynamic_sampling_rate_enabled: true,
+          allocation_sample_every: 0 # Currently only for testing; Setting this to > 0 can add a lot of overhead!
         )
           unless dynamic_sampling_rate_enabled
             Datadog.logger.warn(
@@ -38,6 +30,13 @@ 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,
@@ -46,6 +45,7 @@ module Datadog
             allocation_counting_enabled,
             no_signals_workaround_enabled,
             dynamic_sampling_rate_enabled,
+            allocation_sample_every,
           )
           @worker_thread = nil
           @failure_exception = nil
@@ -53,7 +53,7 @@ module Datadog
           @idle_sampling_helper = idle_sampling_helper
         end
 
-        def start
+        def start(on_failure_proc: nil)
           @start_stop_mutex.synchronize do
             return if @worker_thread && @worker_thread.alive?
 
@@ -74,18 +74,17 @@ module Datadog
                   'CpuAndWallTimeWorker thread error. ' \
                   "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
                 )
+                on_failure_proc&.call
               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
         end
 
-        # TODO: Provided only for compatibility with the API for Collectors::OldStack used in the Profiler class.
-        # Can be removed once we remove OldStack.
-        def enabled=(_); end
-
-        def stop(*_)
+        def stop
           @start_stop_mutex.synchronize do
             Datadog.logger.debug('Requesting CpuAndWallTimeWorker thread shut down')
 

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

@@ -42,12 +42,14 @@ 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
         end
 
-        def stop(*_unused)
+        def stop
           @start_stop_mutex.synchronize do
             Datadog.logger.debug('Requesting IdleSamplingHelper thread shut down')