ddtrace 1.4.2 → 1.23.3

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# Entrypoint file for OpenTelemetry integration.
+#
+# This file's path is part of the @public_api.
+#
+# OpenTelemetry includes metrics, tracing, logs, and profiling.
+# This file activates the integrations of all OpenTelemetry
+# components supported by Datadog.
+
+# Load Tracing
+require_relative 'tracing'
+require_relative 'tracing/contrib'
+
+require_relative 'opentelemetry/api/context'
+
+# DEV: Should this be a Contrib integration, that depends on the `opentelemetry-sdk`
+# DEV: and checks for compatibility?
+# 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.
+  module OpenTelemetry
+    # Used by Telemetry to decide if OpenTelemetry instrumentation is enabled
+    LOADED = true
+
+    # Use `Datadog.logger` as the default logger
+    def logger
+      @logger ||= ::Datadog.logger
+    end
+
+    ::OpenTelemetry.singleton_class.prepend(self)
+  end
+end
+
+# OpenTelemetry does not wait until the "root" span is finished to flush:
+# the "root" span does not have special influence on flushing order.
+#
+# The "root" OpenTelemetry span might be a span that is never finished, but
+# instead a placeholder for distributed tracing information, and ultimately gets discarded.
+# Consumers of the OpenTelemetry SpanProcessor pipeline are free to flush spans whenever
+# an individual span is finished.
+# Currently, this closely translates to Datadog's partial flushing.
+#
+# @see OpenTelemetry::SDK::Trace::SpanProcessor#on_finish
+Datadog.configure do |c|
+  c.tracing.partial_flush.enabled = true
+end

data/lib/datadog/opentracer/binary_propagator.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer

data/lib/datadog/opentracer/carrier.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer

data/lib/datadog/opentracer/distributed_headers.rb

@@ -1,15 +1,11 @@
-# typed: true
-
-require_relative '../tracing/span'
-require_relative '../tracing/distributed/headers/ext'
+require_relative '../tracing/distributed/datadog'
+require_relative '../tracing/utils'
 
 module Datadog
   module OpenTracer
     # DistributedHeaders provides easy access and validation to headers
     # @public_api
     class DistributedHeaders
-      include Tracing::Distributed::Headers::Ext
-
       def initialize(carrier)
         @carrier = carrier
       end
@@ -20,15 +16,15 @@ module Datadog
       end
 
       def trace_id
-        id HTTP_HEADER_TRACE_ID
+        id Tracing::Distributed::Datadog::TRACE_ID_KEY
       end
 
       def parent_id
-        id HTTP_HEADER_PARENT_ID
+        id Tracing::Distributed::Datadog::PARENT_ID_KEY
       end
 
       def sampling_priority
-        hdr = @carrier[HTTP_HEADER_SAMPLING_PRIORITY]
+        hdr = @carrier[Tracing::Distributed::Datadog::SAMPLING_PRIORITY_KEY]
         # It's important to make a difference between no header,
         # and a header defined to zero.
         return unless hdr
@@ -40,7 +36,7 @@ module Datadog
       end
 
       def origin
-        hdr = @carrier[HTTP_HEADER_ORIGIN]
+        hdr = @carrier[Tracing::Distributed::Datadog::ORIGIN_KEY]
         # Only return the value if it is not an empty string
         hdr if hdr != ''
       end
@@ -49,7 +45,7 @@ module Datadog
 
       def id(header)
         value = @carrier[header].to_i
-        return if value.zero? || value >= Datadog::Tracing::Span::EXTERNAL_MAX_ID
+        return if value.zero? || value >= Datadog::Tracing::Utils::EXTERNAL_MAX_ID
 
         value < 0 ? value + 0x1_0000_0000_0000_0000 : value
       end

data/lib/datadog/opentracer/global_tracer.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer

data/lib/datadog/opentracer/propagator.rb

@@ -1,4 +1,4 @@
-# typed: false
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer

data/lib/datadog/opentracer/rack_propagator.rb

@@ -1,7 +1,4 @@
-# typed: true
-
 require_relative '../tracing/context'
-require_relative '../tracing/distributed/headers/ext'
 require_relative '../tracing/propagation/http'
 require_relative '../tracing/trace_operation'
 require_relative 'propagator'
@@ -11,8 +8,6 @@ module Datadog
     # OpenTracing propagator for Datadog::OpenTracer::Tracer
     module RackPropagator
       extend Propagator
-      extend Tracing::Distributed::Headers::Ext
-      include Tracing::Distributed::Headers::Ext
 
       BAGGAGE_PREFIX = 'ot-baggage-'.freeze
       BAGGAGE_PREFIX_FORMATTED = 'HTTP_OT_BAGGAGE_'.freeze

data/lib/datadog/opentracer/scope.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer

data/lib/datadog/opentracer/scope_manager.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer

data/lib/datadog/opentracer/span.rb

@@ -1,5 +1,3 @@
-# typed: true
-
 require 'time'
 
 require_relative '../tracing/metadata/ext'

data/lib/datadog/opentracer/span_context.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer

data/lib/datadog/opentracer/span_context_factory.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer

data/lib/datadog/opentracer/text_map_propagator.rb

@@ -1,7 +1,5 @@
-# typed: true
-
 require_relative '../tracing/context'
-require_relative '../tracing/distributed/headers/ext'
+require_relative '../tracing/distributed/datadog'
 require_relative '../tracing/trace_operation'
 require_relative 'propagator'
 
@@ -10,8 +8,6 @@ module Datadog
     # OpenTracing propagator for Datadog::OpenTracer::Tracer
     module TextMapPropagator
       extend Propagator
-      extend Tracing::Distributed::Headers::Ext
-      include Tracing::Distributed::Headers::Ext
 
       BAGGAGE_PREFIX = 'ot-baggage-'.freeze
 
@@ -34,10 +30,11 @@ module Datadog
                    end
           return unless digest
 
-          carrier[HTTP_HEADER_ORIGIN] = digest.trace_origin
-          carrier[HTTP_HEADER_PARENT_ID] = digest.span_id
-          carrier[HTTP_HEADER_SAMPLING_PRIORITY] = digest.trace_sampling_priority
-          carrier[HTTP_HEADER_TRACE_ID] = digest.trace_id
+          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] =
+            Datadog::Tracing::Utils::TraceId.to_low_order(digest.trace_id)
 
           nil
         end

data/lib/datadog/opentracer/thread_local_scope.rb

@@ -1,4 +1,4 @@
-# typed: true
+# frozen_string_literal: true
 
 module Datadog
   module OpenTracer

data/lib/datadog/opentracer/thread_local_scope_manager.rb

@@ -1,5 +1,3 @@
-# typed: false
-
 require_relative '../core/utils/sequence'
 
 module Datadog

data/lib/datadog/opentracer/tracer.rb

@@ -1,5 +1,3 @@
-# typed: false
-
 require 'time'
 
 require_relative '../tracing/context'

data/lib/datadog/opentracer.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# frozen_string_literal: true
 
 require 'opentracing'
 require 'opentracing/carrier'
@@ -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/code_provenance.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# typed: false
-
 require 'set'
 require 'json'
 
@@ -99,14 +97,20 @@ module Datadog
           end
         end
 
-        Library = Struct.new(:kind, :name, :version, :path) do
+        # Represents metadata we have for a ruby gem
+        class Library
+          attr_reader :kind, :name, :version, :path
+
           def initialize(kind:, name:, version:, path:)
-            super(kind.freeze, name.dup.freeze, version.to_s.dup.freeze, path.dup.freeze)
+            @kind = kind.freeze
+            @name = name.dup.freeze
+            @version = version.to_s.dup.freeze
+            @path = path.dup.freeze
             freeze
           end
 
-          def to_json(*args)
-            { kind: kind, name: name, version: version, paths: [path] }.to_json(*args)
+          def to_json(arg = nil)
+            { kind: @kind, name: @name, version: @version, paths: [@path] }.to_json(arg)
           end
         end
       end

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

@@ -1,10 +1,8 @@
-# typed: false
-
 module Datadog
   module Profiling
     module Collectors
-      # Used to trigger the periodic execution of Collectors::CpuAndWallTime, which implements all of the sampling logic
-      # itself; this class only implements the "doing it periodically" part.
+      # Used to trigger the periodic execution of Collectors::ThreadState, which implements all of the sampling logic
+      # itself; this class only implements the "when to do it" part.
       # Almost all of this class is implemented as native code.
       #
       # Methods prefixed with _native_ are implemented in `collectors_cpu_and_wall_time_worker.c`
@@ -16,24 +14,53 @@ module Datadog
         public
 
         def initialize(
-          recorder:,
-          max_frames:,
-          cpu_and_wall_time_collector: CpuAndWallTime.new(recorder: recorder, max_frames: max_frames)
+          gc_profiling_enabled:,
+          no_signals_workaround_enabled:,
+          thread_context_collector:,
+          dynamic_sampling_rate_overhead_target_percentage:,
+          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,
+          skip_idle_samples_for_testing: false,
+          idle_sampling_helper: IdleSamplingHelper.new
         )
-          self.class._native_initialize(self, cpu_and_wall_time_collector)
+          unless dynamic_sampling_rate_enabled
+            Datadog.logger.warn(
+              'Profiling dynamic sampling rate disabled. This should only be used for testing, and will increase overhead!'
+            )
+          end
+
+          self.class._native_initialize(
+            self,
+            thread_context_collector,
+            gc_profiling_enabled,
+            idle_sampling_helper,
+            no_signals_workaround_enabled,
+            dynamic_sampling_rate_enabled,
+            dynamic_sampling_rate_overhead_target_percentage,
+            allocation_profiling_enabled,
+            skip_idle_samples_for_testing,
+          )
           @worker_thread = nil
           @failure_exception = nil
           @start_stop_mutex = Mutex.new
+          @idle_sampling_helper = idle_sampling_helper
+          @wait_until_running_mutex = Mutex.new
+          @wait_until_running_condition = ConditionVariable.new
         end
 
-        def start
+        def start(on_failure_proc: nil)
           @start_stop_mutex.synchronize do
-            return if @worker_thread
+            return if @worker_thread && @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 unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+                Thread.current.name = self.class.name
 
                 self.class._native_sampling_loop(self)
 
@@ -41,33 +68,69 @@ module Datadog
               rescue Exception => e # rubocop:disable Lint/RescueException
                 @failure_exception = e
                 Datadog.logger.warn(
-                  "Worker thread error. Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+                  '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')
 
+            @idle_sampling_helper.stop
+
             return unless @worker_thread
 
-            @worker_thread.kill
-            self.class._native_stop(self)
+            self.class._native_stop(self, @worker_thread)
 
             @worker_thread.join
             @worker_thread = nil
             @failure_exception = nil
           end
         end
+
+        def reset_after_fork
+          self.class._native_reset_after_fork(self)
+        end
+
+        def stats
+          self.class._native_stats(self)
+        end
+
+        def stats_and_reset_not_thread_safe
+          stats = self.stats
+          self.class._native_stats_reset_not_thread_safe(self)
+          stats
+        end
+
+        # Useful for testing, to e.g. make sure the profiler is running before we start running some code we want to observe
+        def wait_until_running(timeout_seconds: 5)
+          @wait_until_running_mutex.synchronize do
+            return true if self.class._native_is_running?(self)
+
+            @wait_until_running_condition.wait(@wait_until_running_mutex, timeout_seconds)
+
+            if self.class._native_is_running?(self)
+              true
+            else
+              raise "Timeout waiting for #{self.class.name} to start (waited for #{timeout_seconds} seconds)"
+            end
+          end
+        end
+
+        private
+
+        def signal_running
+          @wait_until_running_mutex.synchronize { @wait_until_running_condition.broadcast }
+        end
       end
     end
   end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Profiling
+    module Collectors
+      # Used to pace the rate of profiling samples based on the last observed time for a sample.
+      # All of this module is implemented as native code.
+      #
+      # Methods prefixed with _native_ are implemented in `collectors_dynamic_sampling_rate.c`
+      module DynamicSamplingRate
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Datadog
+  module Profiling
+    module Collectors
+      # Used by the Collectors::CpuAndWallTimeWorker to gather samples when the Ruby process is idle.
+      # Almost all of this class is implemented as native code.
+      #
+      # Methods prefixed with _native_ are implemented in `collectors_idle_sampling_helper.c`
+      class IdleSamplingHelper
+        private
+
+        attr_accessor :failure_exception
+
+        public
+
+        def initialize
+          @worker_thread = nil
+          @start_stop_mutex = Mutex.new
+        end
+
+        def start
+          @start_stop_mutex.synchronize do
+            return if @worker_thread && @worker_thread.alive?
+
+            Datadog.logger.debug { "Starting thread for: #{self}" }
+
+            # The same instance of the IdleSamplingHelper can be reused multiple times, and this resets it back to
+            # a pristine state before recreating the worker thread
+            self.class._native_reset(self)
+
+            @worker_thread = Thread.new do
+              begin
+                Thread.current.name = self.class.name
+
+                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
+            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
+          @start_stop_mutex.synchronize do
+            Datadog.logger.debug('Requesting IdleSamplingHelper thread shut down')
+
+            return unless @worker_thread
+
+            self.class._native_stop(self)
+
+            @worker_thread.join
+            @worker_thread = nil
+            @failure_exception = nil
+          end
+        end
+      end
+    end
+  end
+end