ddtrace 1.14.0 → 1.16.0

data/lib/datadog/profiling/native_extension.rb

@@ -15,27 +15,6 @@ module Datadog
           false
         end
       end
-
-      unless singleton_class.method_defined?(:clock_id_for)
-        def self.clock_id_for(_)
-          nil
-        end
-      end
-
-      def self.cpu_time_ns_for(thread)
-        clock_id =
-          begin
-            clock_id_for(thread)
-          rescue Errno::ESRCH
-            nil
-          end
-
-        begin
-          ::Process.clock_gettime(clock_id, :nanosecond) if clock_id
-        rescue Errno::EINVAL
-          nil
-        end
-      end
     end
   end
 end

data/lib/datadog/profiling/profiler.rb

@@ -1,39 +1,62 @@
 module Datadog
   module Profiling
-    # Profiling entry point, which coordinates collectors and a scheduler
+    # Profiling entry point, which coordinates the worker and scheduler threads
     class Profiler
       include Datadog::Core::Utils::Forking
 
-      attr_reader \
-        :collectors,
-        :scheduler
+      private
 
-      def initialize(collectors, scheduler)
-        @collectors = collectors
+      attr_reader :worker, :scheduler
+
+      public
+
+      def initialize(worker:, scheduler:)
+        @worker = worker
         @scheduler = scheduler
       end
 
       def start
         after_fork! do
-          collectors.each(&:reset_after_fork)
+          worker.reset_after_fork
           scheduler.reset_after_fork
         end
 
-        collectors.each(&:start)
-        scheduler.start
+        worker.start(on_failure_proc: proc { component_failed(:worker) })
+        scheduler.start(on_failure_proc: proc { component_failed(:scheduler) })
       end
 
       def shutdown!
         Datadog.logger.debug('Shutting down profiler')
 
-        collectors.each do |collector|
-          collector.enabled = false
-          collector.stop(true)
-        end
+        stop_worker
+        stop_scheduler
+      end
+
+      private
 
+      def stop_worker
+        worker.stop
+      end
+
+      def stop_scheduler
         scheduler.enabled = false
         scheduler.stop(true)
       end
+
+      def component_failed(failed_component)
+        Datadog.logger.warn(
+          "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
+          'See previous log messages for details.'
+        )
+
+        if failed_component == :worker
+          stop_scheduler
+        elsif failed_component == :scheduler
+          stop_worker
+        else
+          raise ArgumentError, "Unexpected failed_component: #{failed_component.inspect}"
+        end
+      end
     end
   end
 end

data/lib/datadog/profiling/scheduler.rb

@@ -45,20 +45,27 @@ module Datadog
         self.enabled = enabled
       end
 
-      def start
-        perform
+      def start(on_failure_proc: nil)
+        perform(on_failure_proc)
       end
 
-      def perform
-        # A profiling flush may be called while the VM is shutting down, to report the last profile. When we do so,
-        # we impose a strict timeout. This means this last profile may or may not be sent, depending on if the flush can
-        # successfully finish in the strict timeout.
-        # This can be somewhat confusing (why did it not get reported?), so let's at least log what happened.
-        interrupted = true
-
+      def perform(on_failure_proc)
         begin
+          # A profiling flush may be called while the VM is shutting down, to report the last profile. When we do so,
+          # we impose a strict timeout. This means this last profile may or may not be sent, depending on if the flush can
+          # successfully finish in the strict timeout.
+          # This can be somewhat confusing (why did it not get reported?), so let's at least log what happened.
+          interrupted = true
+
           flush_and_wait
           interrupted = false
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          Datadog.logger.warn(
+            'Profiling::Scheduler thread error. ' \
+            "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          )
+          on_failure_proc&.call
+          raise
         ensure
           Datadog.logger.debug('#flush was interrupted or failed before it could complete') if interrupted
         end

data/lib/datadog/profiling.rb

@@ -5,22 +5,15 @@ require_relative 'core/utils/only_once'
 module Datadog
   # Datadog Continuous Profiler implementation: https://docs.datadoghq.com/profiler/
   module Profiling
-    GOOGLE_PROTOBUF_MINIMUM_VERSION = Gem::Version.new('3.0')
-    private_constant :GOOGLE_PROTOBUF_MINIMUM_VERSION
-
     def self.supported?
       unsupported_reason.nil?
     end
 
     def self.unsupported_reason
       # NOTE: Only the first matching reason is returned, so try to keep a nice order on reasons -- e.g. tell users
-      # first that they can't use this on JRuby before telling them that they are missing protobuf
+      # first that they can't use this on JRuby before telling them that something else failed
 
-      native_library_compilation_skipped? ||
-        native_library_failed_to_load? ||
-        protobuf_gem_unavailable? ||
-        protobuf_version_unsupported? ||
-        protobuf_failed_to_load?
+      native_library_compilation_skipped? || native_library_failed_to_load?
     end
 
     # Starts the profiler, if the profiler is supported by in
@@ -53,9 +46,7 @@ module Datadog
     #
     # Note 2: All fibers in the same thread will share the same counter values.
     #
-    # Only available when the profiler is running, the new CPU Profiling 2.0 profiler is in use, and allocation-related
-    # features are not disabled via configuration.
-    # For instructions on enabling CPU Profiling 2.0 see the ddtrace release notes.
+    # Only available when the profiler is running, and allocation-related features are not disabled via configuration.
     #
     # @return [Integer] number of allocations observed in the current thread.
     # @return [nil] when not available.
@@ -68,11 +59,12 @@ module Datadog
 
     def self.enabled?
       profiler = Datadog.send(:components).profiler
-      !!(profiler.scheduler.running? if profiler)
+      # Use .send(...) to avoid exposing the attr_reader as an API to the outside
+      !!(profiler.send(:scheduler).running? if profiler)
     end
 
     private_class_method def self.replace_noop_allocation_count
-      def self.allocation_count # rubocop:disable Lint/DuplicateMethods, Lint/NestedMethodDefinition (On purpose!)
+      def self.allocation_count # rubocop:disable Lint/NestedMethodDefinition (On purpose!)
         Datadog::Profiling::Collectors::CpuAndWallTimeWorker._native_allocation_count
       end
     end
@@ -97,66 +89,6 @@ module Datadog
       end
     end
 
-    private_class_method def self.protobuf_gem_unavailable?
-      # NOTE: On environments where protobuf is already loaded, we skip the check. This allows us to support environments
-      # where no Gem.loaded_version is NOT available but customers are able to load protobuf; see for instance
-      # https://github.com/teamcapybara/capybara/commit/caf3bcd7664f4f2691d0ca9ef3be9a2a954fecfb
-      if !protobuf_already_loaded? && Gem.loaded_specs['google-protobuf'].nil?
-        "Missing google-protobuf dependency; please add `gem 'google-protobuf', '~> 3.0'` to your Gemfile or gems.rb file"
-      end
-    end
-
-    private_class_method def self.protobuf_version_unsupported?
-      # See above for why we skip the check when protobuf is already loaded; note that when protobuf was already loaded
-      # we skip the version check to avoid the call to Gem.loaded_specs. Unfortunately, protobuf does not seem to
-      # expose the gem version constant elsewhere, so in that setup we are not able to check the version.
-      if !protobuf_already_loaded? && Gem.loaded_specs['google-protobuf'].version < GOOGLE_PROTOBUF_MINIMUM_VERSION
-        'Your google-protobuf is too old; ensure that you have google-protobuf >= 3.0 by ' \
-        "adding `gem 'google-protobuf', '~> 3.0'` to your Gemfile or gems.rb file"
-      end
-    end
-
-    private_class_method def self.protobuf_already_loaded?
-      defined?(::Google::Protobuf) && !defined?(::Protobuf)
-      !!(defined?(::Google::Protobuf) && !defined?(::Protobuf))
-    end
-
-    private_class_method def self.protobuf_failed_to_load?
-      unless protobuf_loaded_successfully?
-        'There was an error loading the google-protobuf library; see previous warning message for details'
-      end
-    end
-
-    # The `google-protobuf` gem depends on a native component, and its creators helpfully tried to provide precompiled
-    # versions of this extension on rubygems.org.
-    #
-    # Unfortunately, for a long time, the supported Ruby versions metadata on these precompiled versions of the extension
-    # was not correctly set. (This is fixed in newer versions -- but not all Ruby versions we want to support can use
-    # these.)
-    #
-    # Thus, the gem can still be installed, but can be in a broken state. To avoid breaking customer applications, we
-    # use this helper to load it and gracefully handle failures.
-    private_class_method def self.protobuf_loaded_successfully?
-      return @protobuf_loaded if defined?(@protobuf_loaded)
-
-      begin
-        require 'google/protobuf'
-        @protobuf_loaded = true
-      rescue LoadError => e
-        # NOTE: We use Kernel#warn here because this code gets run BEFORE Datadog.logger is actually set up.
-        # In the future it'd be nice to shuffle the logger startup to happen first to avoid this special case.
-        Kernel.warn(
-          '[ddtrace] Error while loading google-protobuf gem. ' \
-          "Cause: '#{e.class.name} #{e.message}' Location: '#{Array(e.backtrace).first}'. " \
-          'This can happen when google-protobuf is missing its native components. ' \
-          'To fix this, try removing and reinstalling the gem, forcing it to recompile the components: ' \
-          '`gem uninstall google-protobuf -a; BUNDLE_FORCE_RUBY_PLATFORM=true bundle install`. ' \
-          'If the error persists, please contact Datadog support at <https://docs.datadoghq.com/help/>.'
-        )
-        @protobuf_loaded = false
-      end
-    end
-
     private_class_method def self.native_library_failed_to_load?
       success, exception = try_loading_native_library
 
@@ -184,7 +116,7 @@ module Datadog
     end
 
     # All requires for the profiler should be directly added here; and everything should be loaded eagerly.
-    # (Currently there's a few exceptions for the old profiler, but we should avoid other exceptions.)
+    # (Currently there's a leftovers that need to be cleaned up, but we should avoid other exceptions.)
     #
     # All of the profiler should be loaded and ready to go when this method returns `true`.
     private_class_method def self.load_profiling
@@ -195,21 +127,16 @@ module Datadog
       require_relative 'profiling/collectors/cpu_and_wall_time_worker'
       require_relative 'profiling/collectors/dynamic_sampling_rate'
       require_relative 'profiling/collectors/idle_sampling_helper'
-      require_relative 'profiling/collectors/old_stack'
       require_relative 'profiling/collectors/stack'
       require_relative 'profiling/collectors/thread_context'
       require_relative 'profiling/diagnostics/environment_logger'
       require_relative 'profiling/stack_recorder'
-      require_relative 'profiling/old_recorder'
       require_relative 'profiling/exporter'
+      require_relative 'profiling/flush'
       require_relative 'profiling/scheduler'
       require_relative 'profiling/tasks/setup'
       require_relative 'profiling/profiler'
       require_relative 'profiling/native_extension'
-      require_relative 'profiling/trace_identifiers/helper'
-      # This file is no longer eagerly loaded as a workaround for an issue. It only gets loaded dynamically if the old
-      # profiler is in use. See Profiling::Component#load_pprof_support for more details.
-      # require_relative 'profiling/pprof/pprof_pb'
       require_relative 'profiling/tag_builder'
       require_relative 'profiling/http_transport'
 

data/lib/datadog/tracing/component.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'tracer'
+require_relative 'configuration/agent_settings_resolver'
 require_relative 'flush'
 require_relative 'sync_writer'
 require_relative 'sampling/span/rule_parser'
@@ -22,12 +23,14 @@ module Datadog
         end
       end
 
-      def build_tracer(settings, agent_settings)
+      def build_tracer(settings, logger:)
         # If a custom tracer has been provided, use it instead.
         # Ignore all other options (they should already be configured.)
         tracer = settings.tracing.instance
         return tracer unless tracer.nil?
 
+        agent_settings = Configuration::AgentSettingsResolver.call(settings, logger: logger)
+
         # Apply test mode settings if test mode is activated
         if settings.tracing.test_mode.enabled
           trace_flush = build_test_mode_trace_flush(settings)
@@ -131,12 +134,12 @@ module Datadog
       # process, but can take a variety of options (including
       # a fully custom instance) that makes the Tracer
       # initialization process complex.
-      def build_writer(settings, agent_settings)
+      def build_writer(settings, agent_settings, options = settings.tracing.writer_options)
         if (writer = settings.tracing.writer)
           return writer
         end
 
-        Tracing::Writer.new(agent_settings: agent_settings, **settings.tracing.writer_options)
+        Tracing::Writer.new(agent_settings: agent_settings, **options)
       end
 
       def subscribe_to_writer_events!(writer, sampler_delegator, test_mode)
@@ -220,8 +223,11 @@ module Datadog
       end
 
       def build_test_mode_writer(settings, agent_settings)
-        # Flush traces synchronously, to guarantee they are written.
         writer_options = settings.tracing.test_mode.writer_options || {}
+
+        return build_writer(settings, agent_settings, writer_options) if settings.tracing.test_mode.async
+
+        # Flush traces synchronously, to guarantee they are written.
         Tracing::SyncWriter.new(agent_settings: agent_settings, **writer_options)
       end
     end

data/lib/datadog/tracing/configuration/agent_settings_resolver.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../../core/configuration/agent_settings_resolver'
+
+module Datadog
+  module Tracing
+    module Configuration
+      # This class encapsulates any tracing specific agent settings
+      class AgentSettingsResolver < Datadog::Core::Configuration::AgentSettingsResolver
+      end
+    end
+  end
+end

data/lib/datadog/tracing/configuration/ext.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative '../../core/configuration/ext'
+
 module Datadog
   module Tracing
     module Configuration
@@ -88,8 +90,8 @@ module Datadog
 
         # @public_api
         module Transport
-          ENV_DEFAULT_PORT = 'DD_TRACE_AGENT_PORT'
-          ENV_DEFAULT_URL = 'DD_TRACE_AGENT_URL'
+          ENV_DEFAULT_PORT = Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_PORT
+          ENV_DEFAULT_URL = Datadog::Core::Configuration::Ext::Agent::ENV_DEFAULT_URL
         end
 
         # @public_api

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

@@ -1,4 +1,5 @@
 require_relative '../../tracing/configuration/ext'
+require_relative '../../core/environment/variable_helpers'
 require_relative 'http'
 
 module Datadog
@@ -64,7 +65,7 @@ module Datadog
                       Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER,
                     ]
                   )
-                  o.on_set do |styles|
+                  o.after_set do |styles|
                     # Modernize B3 options
                     # DEV-2.0: Can be removed with the removal of deprecated B3 constants.
                     styles.map! do |style|
@@ -93,7 +94,7 @@ module Datadog
                   o.env Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_INJECT
                   # DEV-2.0: Change default value to `tracecontext, Datadog`.
                   o.default [Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG]
-                  o.on_set do |styles|
+                  o.after_set do |styles|
                     # Modernize B3 options
                     # DEV-2.0: Can be removed with the removal of deprecated B3 constants.
                     styles.map! do |style|
@@ -121,7 +122,7 @@ module Datadog
                   o.type :array
                   o.env Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE
                   o.default []
-                  o.on_set do |styles|
+                  o.after_set do |styles|
                     next if styles.empty?
 
                     # Modernize B3 options
@@ -371,6 +372,12 @@ module Datadog
                   o.env Tracing::Configuration::Ext::Test::ENV_MODE_ENABLED
                 end
 
+                # Use async writer in test mode
+                option :async do |o|
+                  o.type :bool
+                  o.default false
+                end
+
                 option :trace_flush
 
                 option :writer_options do |o|
@@ -382,8 +389,8 @@ module Datadog
               # @see file:docs/GettingStarted.md#configuring-the-transport-layer Configuring the transport layer
               #
               # A {Proc} that configures a custom tracer transport.
-              # @yield Receives a {Datadog::Transport::HTTP} that can be modified with custom adapters and settings.
-              # @yieldparam [Datadog::Transport::HTTP] t transport to be configured.
+              # @yield Receives a {Datadog::Tracing::Transport::HTTP} that can be modified with custom adapters and settings.
+              # @yieldparam [Datadog::Tracing::Transport::HTTP] t transport to be configured.
               # @default `nil`
               # @return [Proc,nil]
               option :transport_options do |o|
@@ -425,7 +432,7 @@ module Datadog
                 option :enabled do |o|
                   o.type :bool
                   o.default do
-                    disabled = env_to_bool(Tracing::Configuration::Ext::ClientIp::ENV_DISABLED)
+                    disabled = Core::Environment::VariableHelpers.env_to_bool(Tracing::Configuration::Ext::ClientIp::ENV_DISABLED)
 
                     enabled = if disabled.nil?
                                 false
@@ -438,7 +445,7 @@ module Datadog
                               end
 
                     # ENABLED env var takes precedence over deprecated DISABLED
-                    env_to_bool(Tracing::Configuration::Ext::ClientIp::ENV_ENABLED, enabled)
+                    Core::Environment::VariableHelpers.env_to_bool(Tracing::Configuration::Ext::ClientIp::ENV_ENABLED, enabled)
                   end
                 end
 

data/lib/datadog/tracing/contrib/action_pack/configuration/settings.rb

@@ -30,7 +30,7 @@ module Datadog
 
             # DEV-2.0: Breaking changes for removal.
             option :exception_controller do |o|
-              o.on_set do |value|
+              o.after_set do |value|
                 if value
                   Datadog::Core.log_deprecation do
                     'The error controller is now automatically detected. '\

data/lib/datadog/tracing/contrib/active_job/configuration/settings.rb

@@ -33,7 +33,7 @@ module Datadog
             option :service_name
             option :error_handler do |o|
               o.type :proc
-              o.experimental_default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
+              o.default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
             end
           end
         end

data/lib/datadog/tracing/contrib/active_record/events/sql.rb

@@ -45,6 +45,10 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_SQL)
 
+              if service_name != Datadog.configuration.service
+                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
+              end
+
               # Set analytics sample rate
               if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
                 Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])