ddtrace 0.49.0 → 0.52.0

data/lib/datadog/core/environment/socket.rb

@@ -0,0 +1,17 @@
+# typed: true
+require 'socket'
+
+module Datadog
+  module Core
+    module Environment
+      # For runtime identity
+      module Socket
+        module_function
+
+        def hostname
+          ::Socket.gethostname
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/environment/thread_count.rb

@@ -0,0 +1,19 @@
+# typed: true
+module Datadog
+  module Core
+    module Environment
+      # Retrieves number of threads from runtime
+      module ThreadCount
+        module_function
+
+        def value
+          Thread.list.count
+        end
+
+        def available?
+          Thread.respond_to?(:list)
+        end
+      end
+    end
+  end
+end

data/lib/datadog/core/environment/variable_helpers.rb

@@ -0,0 +1,42 @@
+# typed: false
+module Datadog
+  module Core
+    # Namespace for handling application environment
+    module Environment
+      # Defines helper methods for environment
+      module VariableHelpers
+        extend self
+
+        def env_to_bool(var, default = nil)
+          var = decode_array(var)
+          var && ENV.key?(var) ? ENV[var].to_s.strip.downcase == 'true' : default
+        end
+
+        def env_to_int(var, default = nil)
+          var = decode_array(var)
+          var && ENV.key?(var) ? ENV[var].to_i : default
+        end
+
+        def env_to_float(var, default = nil)
+          var = decode_array(var)
+          var && ENV.key?(var) ? ENV[var].to_f : default
+        end
+
+        def env_to_list(var, default = [])
+          var = decode_array(var)
+          if var && ENV.key?(var)
+            ENV[var].split(',').map(&:strip)
+          else
+            default
+          end
+        end
+
+        private
+
+        def decode_array(var)
+          var.is_a?(Array) ? var.find { |env_var| ENV.key?(env_var) } : var
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace.rb

@@ -1,3 +1,4 @@
+# typed: strict
 # During development, we load `ddtrace` by through `ddtrace.gemspec`,
 # which in turn eager loads 'ddtrace/version'.
 #
@@ -17,68 +18,35 @@ require 'ddtrace/metrics'
 require 'ddtrace/auto_instrument_base'
 require 'ddtrace/profiling'
 
+require 'datadog/contrib'
+require 'ddtrace/contrib/auto_instrument'
+require 'ddtrace/contrib/extensions'
+
+require 'ddtrace/opentelemetry/extensions'
+
 # \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
 module Datadog
   extend Configuration
   extend AutoInstrumentBase
 
-  # Load and extend Contrib by default
-  require 'ddtrace/contrib/extensions'
+  # Load built-in Datadog integrations
   extend Contrib::Extensions
+  # Load Contrib auto instrumentation
+  extend Contrib::AutoInstrument
+  # Load Contrib extension to global Datadog objects
+  Configuration::Settings.include Contrib::Extensions::Configuration::Settings
 
   # Load and extend OpenTelemetry compatibility by default
-  require 'ddtrace/opentelemetry/extensions'
   extend OpenTelemetry::Extensions
 
-  # Load and extend AutoInstrument
-  require 'ddtrace/contrib/auto_instrument'
-  extend Contrib::AutoInstrument
-
   # Add shutdown hook:
   # Ensures the tracer has an opportunity to flush traces
   # and cleanup before terminating the process.
-  at_exit { Datadog.shutdown! }
+  at_exit do
+    if Interrupt === $! # rubocop:disable Style/SpecialGlobalVars is process terminating due to a ctrl+c or similar?
+      Datadog.send(:handle_interrupt_shutdown!)
+    else
+      Datadog.shutdown!
+    end
+  end
 end
-
-require 'ddtrace/contrib/action_cable/integration'
-require 'ddtrace/contrib/action_pack/integration'
-require 'ddtrace/contrib/action_view/integration'
-require 'ddtrace/contrib/active_model_serializers/integration'
-require 'ddtrace/contrib/active_record/integration'
-require 'ddtrace/contrib/active_support/integration'
-require 'ddtrace/contrib/aws/integration'
-require 'ddtrace/contrib/concurrent_ruby/integration'
-require 'ddtrace/contrib/cucumber/integration'
-require 'ddtrace/contrib/dalli/integration'
-require 'ddtrace/contrib/delayed_job/integration'
-require 'ddtrace/contrib/elasticsearch/integration'
-require 'ddtrace/contrib/ethon/integration'
-require 'ddtrace/contrib/excon/integration'
-require 'ddtrace/contrib/faraday/integration'
-require 'ddtrace/contrib/grape/integration'
-require 'ddtrace/contrib/graphql/integration'
-require 'ddtrace/contrib/grpc/integration'
-require 'ddtrace/contrib/http/integration'
-require 'ddtrace/contrib/httpclient/integration'
-require 'ddtrace/contrib/httprb/integration'
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/kafka/integration'
-require 'ddtrace/contrib/presto/integration'
-require 'ddtrace/contrib/que/integration'
-require 'ddtrace/contrib/mysql2/integration'
-require 'ddtrace/contrib/mongodb/integration'
-require 'ddtrace/contrib/qless/integration'
-require 'ddtrace/contrib/racecar/integration'
-require 'ddtrace/contrib/rack/integration'
-require 'ddtrace/contrib/rails/integration'
-require 'ddtrace/contrib/rake/integration'
-require 'ddtrace/contrib/redis/integration'
-require 'ddtrace/contrib/resque/integration'
-require 'ddtrace/contrib/rest_client/integration'
-require 'ddtrace/contrib/rspec/integration'
-require 'ddtrace/contrib/sequel/integration'
-require 'ddtrace/contrib/shoryuken/integration'
-require 'ddtrace/contrib/sidekiq/integration'
-require 'ddtrace/contrib/sinatra/integration'
-require 'ddtrace/contrib/sneakers/integration'
-require 'ddtrace/contrib/sucker_punch/integration'

data/lib/ddtrace/analytics.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'ddtrace/ext/analytics'
 
 module Datadog

data/lib/ddtrace/auto_instrument.rb

@@ -1,3 +1,5 @@
+# typed: strict
 require 'ddtrace'
 
 Datadog.add_auto_instrument
+Datadog.profiler.start if Datadog.profiler

data/lib/ddtrace/auto_instrument_base.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   # base methods stubbed for adding auto instrument extensions
   module AutoInstrumentBase

data/lib/ddtrace/buffer.rb

@@ -1,5 +1,5 @@
+# typed: true
 require 'ddtrace/diagnostics/health'
-require 'ddtrace/runtime/object_space'
 
 # Trace buffer that accumulates traces for a consumer.
 # Consumption can happen from a different thread.
@@ -213,6 +213,8 @@ module Datadog
 
   # Health metrics for trace buffers.
   module MeasuredBuffer
+    include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
+
     def initialize(*_)
       super
 
@@ -259,7 +261,7 @@ module Datadog
 
       @buffer_spans += trace.length
     rescue StandardError => e
-      Datadog.logger.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.debug("Failed to measure queue accept. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
     end
 
     def measure_drop(trace)
@@ -267,7 +269,7 @@ module Datadog
 
       @buffer_spans -= trace.length
     rescue StandardError => e
-      Datadog.logger.debug("Failed to measure queue drop. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.debug("Failed to measure queue drop. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
     end
 
     def measure_pop(traces)
@@ -290,7 +292,7 @@ module Datadog
       @buffer_dropped = 0
       @buffer_spans = 0
     rescue StandardError => e
-      Datadog.logger.debug("Failed to measure queue. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog.logger.debug("Failed to measure queue. Cause: #{e.message} Source: #{Array(e.backtrace).first}")
     end
   end
 
@@ -318,7 +320,7 @@ module Datadog
   #
   # TODO We should restructure this module, so that classes are not declared at top-level ::Datadog.
   # TODO Making such a change is potentially breaking for users manually configuring the tracer.
-  TraceBuffer = if Datadog::Ext::Runtime::RUBY_ENGINE == 'ruby'
+  TraceBuffer = if Datadog::Core::Environment::Ext::RUBY_ENGINE == 'ruby'
                   CRubyTraceBuffer
                 else
                   ThreadSafeTraceBuffer

data/lib/ddtrace/chunker.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'json'
 require 'msgpack'
 

data/lib/ddtrace/configuration.rb

@@ -1,12 +1,13 @@
+# typed: true
 require 'forwardable'
 require 'ddtrace/configuration/pin_setup'
 require 'ddtrace/configuration/settings'
 require 'ddtrace/configuration/components'
-require 'ddtrace/utils/only_once'
 
 module Datadog
   # Configuration provides a unique access point for configurations
   module Configuration # rubocop:disable Metrics/ModuleLength
+    include Kernel # Ensure that kernel methods are always available (https://sorbet.org/docs/error-reference#7003)
     extend Forwardable
 
     # Used to ensure that @components initialization/reconfiguration is performed one-at-a-time, by a single thread.
@@ -43,8 +44,6 @@ module Datadog
     end
 
     def configure(target = configuration, opts = {})
-      ruby_version_deprecation_warning
-
       if target.is_a?(Settings)
         yield(target) if block_given?
 
@@ -140,7 +139,7 @@ module Datadog
           logger_without_components.error(
             'Detected deadlock during ddtrace initialization. ' \
             'Please report this at https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug' \
-            "\n\tSource:\n\t#{e.backtrace.join("\n\t")}"
+            "\n\tSource:\n\t#{Array(e.backtrace).join("\n\t")}"
           )
           nil
         end
@@ -176,23 +175,21 @@ module Datadog
       end
     end
 
-    # Perform version check only once
-    DEPRECATED_RUBY_VERSION = Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.1')
-    private_constant :DEPRECATED_RUBY_VERSION
-
-    RUBY_VERSION_DEPRECATION_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
-    private_constant :RUBY_VERSION_DEPRECATION_ONLY_ONCE
+    # Called from our at_exit hook whenever there was a pending Interrupt exception (e.g. typically due to ctrl+c)
+    # to print a nice message whenever we're taking a bit longer than usual to finish the process.
+    def handle_interrupt_shutdown!
+      logger = Datadog.logger
+      shutdown_thread = Thread.new { shutdown! }
+      print_message_treshold_seconds = 0.2
 
-    def ruby_version_deprecation_warning
-      return unless DEPRECATED_RUBY_VERSION
+      slow_shutdown = shutdown_thread.join(print_message_treshold_seconds).nil?
 
-      RUBY_VERSION_DEPRECATION_ONLY_ONCE.run do
-        Datadog.logger.warn(
-          "Support for Ruby versions < 2.1 in dd-trace-rb is DEPRECATED.\n" \
-          "Last version to support Ruby < 2.1 will be 0.49.x, which will only receive critical bugfixes.\n" \
-          'Support for Ruby versions < 2.1 will be REMOVED in version 0.50.0.'
-        )
+      if slow_shutdown
+        logger.info 'Reporting remaining data... Press ctrl+c to exit immediately.'
+        shutdown_thread.join
       end
+
+      nil
     end
   end
 end

data/lib/ddtrace/configuration/agent_settings_resolver.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'uri'
 
 require 'ddtrace/ext/transport'
@@ -27,15 +28,12 @@ module Datadog
           :deprecated_for_removal_transport_configuration_options
         ) do
           def initialize(
-            # Hacky required kw args, we can get rid of this when we drop Ruby 2.0
-            ssl: raise(ArgumentError, 'missing keyword :ssl'),
-            hostname: raise(ArgumentError, 'missing keyword :hostname'),
-            port: raise(ArgumentError, 'missing keyword :port'),
-            timeout_seconds: raise(ArgumentError, 'missing keyword :timeout_seconds'),
-            deprecated_for_removal_transport_configuration_proc: \
-              raise(ArgumentError, 'missing keyword :deprecated_for_removal_transport_configuration_proc'),
-            deprecated_for_removal_transport_configuration_options: \
-              raise(ArgumentError, 'missing keyword :deprecated_for_removal_transport_configuration_options')
+            ssl:,
+            hostname:,
+            port:,
+            timeout_seconds:,
+            deprecated_for_removal_transport_configuration_proc:,
+            deprecated_for_removal_transport_configuration_options:
           )
             super(ssl, hostname, port, timeout_seconds, deprecated_for_removal_transport_configuration_proc, \
               deprecated_for_removal_transport_configuration_options)
@@ -179,11 +177,7 @@ module Datadog
         @unparsed_url_from_env ||= ENV[Datadog::Ext::Transport::HTTP::ENV_DEFAULT_URL]
       end
 
-      def pick_from(
-        # Hacky required kw args, we can get rid of this when we drop Ruby 2.0
-        configurations_in_priority_order: raise(ArgumentError, 'missing keyword :configurations'),
-        or_use_default: raise(ArgumentError, 'missing keyword :or_use_default')
-      )
+      def pick_from(configurations_in_priority_order:, or_use_default:)
         detected_configurations_in_priority_order = configurations_in_priority_order.select(&:value?)
 
         if detected_configurations_in_priority_order.any?
@@ -213,11 +207,7 @@ module Datadog
       end
 
       DetectedConfiguration = Struct.new(:friendly_name, :value) do
-        def initialize(
-          # Hacky required kw args, we can get rid of this when we drop Ruby 2.0
-          friendly_name: raise(ArgumentError, 'missing keyword :friendly_name'),
-          value: raise(ArgumentError, 'missing keyword :value')
-        )
+        def initialize(friendly_name:, value:)
           super(friendly_name, value)
           freeze
         end

data/lib/ddtrace/configuration/base.rb

@@ -1,4 +1,5 @@
-require 'ddtrace/environment'
+# typed: false
+require 'datadog/core/environment/variable_helpers'
 require 'ddtrace/configuration/options'
 
 module Datadog
@@ -6,12 +7,12 @@ module Datadog
     # Basic configuration behavior
     module Base
       def self.included(base)
-        base.send(:extend, Datadog::Environment::Helpers)
-        base.send(:include, Datadog::Environment::Helpers)
-        base.send(:include, Options)
+        base.extend(Datadog::Core::Environment::VariableHelpers)
+        base.include(Datadog::Core::Environment::VariableHelpers)
+        base.include(Options)
 
-        base.send(:extend, ClassMethods)
-        base.send(:include, InstanceMethods)
+        base.extend(ClassMethods)
+        base.include(InstanceMethods)
       end
 
       # Class methods for configuration
@@ -53,10 +54,7 @@ module Datadog
           ordering = self.class.options.dependency_order
           sorted_opts = opts.sort_by do |name, _value|
             ordering.index(name) || (ordering.length + 1)
-          end
-
-          # Ruby 2.0 doesn't support Array#to_h
-          sorted_opts = Hash[*sorted_opts.flatten]
+          end.to_h
 
           # Apply options in sort order
           sorted_opts.each do |name, value|

data/lib/ddtrace/configuration/components.rb

@@ -1,14 +1,17 @@
+# typed: true
 require 'ddtrace/configuration/agent_settings_resolver'
 require 'ddtrace/diagnostics/health'
 require 'ddtrace/logger'
 require 'ddtrace/profiling'
 require 'ddtrace/runtime/metrics'
 require 'ddtrace/tracer'
+require 'ddtrace/sync_writer'
 require 'ddtrace/workers/runtime_metrics'
 
 module Datadog
   module Configuration
     # Global components for the trace library.
+    # rubocop:disable Metrics/ClassLength
     # rubocop:disable Layout/LineLength
     class Components
       class << self
@@ -17,7 +20,7 @@ module Datadog
           options = { enabled: settings.enabled }
           options[:statsd] = settings.statsd unless settings.statsd.nil?
 
-          Datadog::Diagnostics::Health::Metrics.new(options)
+          Datadog::Diagnostics::Health::Metrics.new(**options)
         end
 
         def build_logger(settings)
@@ -32,7 +35,7 @@ module Datadog
           options[:statsd] = settings.runtime_metrics.statsd unless settings.runtime_metrics.statsd.nil?
           options[:services] = [settings.service] unless settings.service.nil?
 
-          Datadog::Runtime::Metrics.new(options)
+          Datadog::Runtime::Metrics.new(**options)
         end
 
         def build_runtime_metrics_worker(settings)
@@ -55,7 +58,14 @@ module Datadog
             default_service: settings.service,
             enabled: settings.tracer.enabled,
             partial_flush: settings.tracer.partial_flush.enabled,
-            tags: build_tracer_tags(settings)
+            tags: build_tracer_tags(settings),
+            sampler: PrioritySampler.new(
+              base_sampler: AllSampler.new,
+              post_sampler: Sampling::RuleSampler.new(
+                rate_limit: settings.sampling.rate_limit,
+                default_sample_rate: settings.sampling.default_rate
+              )
+            )
           )
 
           # TODO: We reconfigure the tracer here because it has way too many
@@ -63,21 +73,55 @@ module Datadog
           #       tracer initialization for now. Just reconfigure using the
           #       existing mutable #configure function. Remove when these components
           #       are extracted.
-          tracer.configure(agent_settings: agent_settings, **build_tracer_options(settings))
+          tracer.configure(agent_settings: agent_settings, **build_tracer_options(settings, agent_settings))
 
           tracer
         end
 
-        def build_profiler(settings, agent_settings)
+        def build_profiler(settings, agent_settings, tracer)
           return unless Datadog::Profiling.supported? && settings.profiling.enabled
 
+          unless defined?(Datadog::Profiling::Tasks::Setup)
+            # In #1545 a user reported a NameError due to this constant being uninitialized
+            # I've documented my suspicion on why that happened in
+            # https://github.com/DataDog/dd-trace-rb/issues/1545#issuecomment-856049025
+            #
+            # > Thanks for the info! It seems to feed into my theory: there's two moments in the code where we check if
+            # > profiler is "supported": 1) when loading ddtrace (inside preload) and 2) when starting the profile
+            # > after Datadog.configure gets run.
+            # > The problem is that the code assumes that both checks 1) and 2) will always reach the same conclusion:
+            # > either profiler is supported, or profiler is not supported.
+            # > In the problematic case, it looks like in your case check 1 decides that profiler is not
+            # > supported => doesn't load it, and then check 2 decides that it is => assumes it is loaded and tries to
+            # > start it.
+            #
+            # I was never able to validate if this was the issue or why exactly .supported? would change its mind BUT
+            # just in case it happens again, I've left this check which avoids breaking the user's application AND
+            # would instead direct them to report it to us instead, so that we can investigate what's wrong.
+            #
+            # TODO: As of June 2021, most checks in .supported? are related to the google-protobuf gem; so it's
+            # very likely that it was the origin of the issue we saw. Thus, if, as planned we end up moving away from
+            # protobuf OR enough time has passed and no users saw the issue again, we can remove this check altogether.
+            Datadog.logger.error(
+              'Profiling was marked as supported and enabled, but setup task was not loaded properly. ' \
+              'Please report this at https://github.com/DataDog/dd-trace-rb/blob/master/CONTRIBUTING.md#found-a-bug'
+            )
+
+            return
+          end
+
           # Load extensions needed to support some of the Profiling features
           Datadog::Profiling::Tasks::Setup.new.run
 
           # NOTE: Please update the Initialization section of ProfilingDevelopment.md with any changes to this method
 
+          trace_identifiers_helper = Datadog::Profiling::TraceIdentifiers::Helper.new(
+            tracer: tracer,
+            extract_trace_resource: settings.profiling.advanced.extract_trace_resource
+          )
+
           recorder = build_profiler_recorder(settings)
-          collectors = build_profiler_collectors(settings, recorder)
+          collectors = build_profiler_collectors(settings, recorder, trace_identifiers_helper)
           exporters = build_profiler_exporters(settings, agent_settings)
           scheduler = build_profiler_scheduler(settings, recorder, exporters)
 
@@ -88,35 +132,57 @@ module Datadog
 
         def build_tracer_tags(settings)
           settings.tags.dup.tap do |tags|
-            tags['env'] = settings.env unless settings.env.nil?
-            tags['version'] = settings.version unless settings.version.nil?
+            tags[Ext::Environment::TAG_ENV] = settings.env unless settings.env.nil?
+            tags[Ext::Environment::TAG_VERSION] = settings.version unless settings.version.nil?
           end
         end
 
-        def build_tracer_options(settings)
-          settings = settings.tracer
+        def build_tracer_options(settings, agent_settings)
+          tracer_options = {}.tap do |opts|
+            tset = settings.tracer
+            opts[:min_spans_before_partial_flush] = tset.partial_flush.min_spans_threshold unless tset.partial_flush.min_spans_threshold.nil?
+            opts[:partial_flush] = tset.partial_flush.enabled unless tset.partial_flush.enabled.nil?
+            opts[:priority_sampling] = tset.priority_sampling unless tset.priority_sampling.nil?
+            opts[:sampler] = tset.sampler unless tset.sampler.nil?
+            opts[:writer] = tset.writer unless tset.writer.nil?
+            opts[:writer_options] = tset.writer_options if tset.writer.nil?
+          end
+
+          # Apply test mode settings if test mode is activated
+          if settings.test_mode.enabled
+            build_tracer_test_mode_options(tracer_options, settings, agent_settings)
+          else
+            tracer_options
+          end
+        end
+
+        def build_tracer_test_mode_options(tracer_options, settings, agent_settings)
+          tracer_options.tap do |opts|
+            # Do not sample any spans for tests; all must be preserved.
+            opts[:sampler] = Datadog::AllSampler.new
+
+            # If context flush behavior is provided, use it instead.
+            opts[:context_flush] = settings.test_mode.context_flush if settings.test_mode.context_flush
 
-          {}.tap do |opts|
-            opts[:min_spans_before_partial_flush] = settings.partial_flush.min_spans_threshold unless settings.partial_flush.min_spans_threshold.nil?
-            opts[:partial_flush] = settings.partial_flush.enabled unless settings.partial_flush.enabled.nil?
-            opts[:priority_sampling] = settings.priority_sampling unless settings.priority_sampling.nil?
-            opts[:sampler] = settings.sampler unless settings.sampler.nil?
-            opts[:writer] = settings.writer unless settings.writer.nil?
-            opts[:writer_options] = settings.writer_options if settings.writer.nil?
+            # Flush traces synchronously, to guarantee they are written.
+            writer_options = settings.test_mode.writer_options || {}
+            writer_options[:agent_settings] = agent_settings if agent_settings
+            opts[:writer] = Datadog::SyncWriter.new(writer_options)
           end
         end
 
         def build_profiler_recorder(settings)
           event_classes = [Datadog::Profiling::Events::StackSample]
 
-          Datadog::Profiling::Recorder.new(event_classes, settings.profiling.max_events)
+          Datadog::Profiling::Recorder.new(event_classes, settings.profiling.advanced.max_events)
         end
 
-        def build_profiler_collectors(settings, recorder)
+        def build_profiler_collectors(settings, recorder, trace_identifiers_helper)
           [
             Datadog::Profiling::Collectors::Stack.new(
               recorder,
-              max_frames: settings.profiling.max_frames
+              trace_identifiers_helper: trace_identifiers_helper,
+              max_frames: settings.profiling.advanced.max_frames
               # TODO: Provide proc that identifies Datadog worker threads?
               # ignore_thread: settings.profiling.ignore_profiler
             )
@@ -157,7 +223,7 @@ module Datadog
         @tracer = self.class.build_tracer(settings, agent_settings)
 
         # Profiler
-        @profiler = self.class.build_profiler(settings, agent_settings)
+        @profiler = self.class.build_profiler(settings, agent_settings, @tracer)
 
         # Runtime metrics
         @runtime_metrics = self.class.build_runtime_metrics_worker(settings)