ddtrace 0.42.0 → 0.52.0

data/lib/ddtrace/vendor/multipart-post/multipart/post/version.rb

@@ -0,0 +1,10 @@
+# typed: strict
+module Datadog
+  module Vendor
+    module Multipart
+      module Post
+        VERSION = "2.1.1"
+      end
+    end
+  end
+end

data/lib/ddtrace/vendor/multipart-post/net/http/post/multipart.rb

@@ -0,0 +1,33 @@
+# typed: strict
+#--
+# Copyright (c) 2007-2012 Nick Sieger.
+# See the file README.txt included with the distribution for
+# software license details.
+#++
+
+require 'net/http'
+require 'stringio'
+require 'cgi'
+require 'ddtrace/vendor/multipart-post/multipart/post/parts'
+require 'ddtrace/vendor/multipart-post/multipart/post/composite_read_io'
+require 'ddtrace/vendor/multipart-post/multipart/post/multipartable'
+
+module Datadog
+  module Vendor
+    module Net
+      class HTTP
+        class Put
+          class Multipart < ::Net::HTTP::Put
+            include ::Datadog::Vendor::Multipart::Post::Multipartable
+          end
+        end
+
+        class Post
+          class Multipart < ::Net::HTTP::Post
+            include ::Datadog::Vendor::Multipart::Post::Multipartable
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/version.rb

@@ -1,12 +1,25 @@
+# typed: true
 module Datadog
   module VERSION
     MAJOR = 0
-    MINOR = 42
+    MINOR = 52
     PATCH = 0
     PRE = nil
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
 
-    MINIMUM_RUBY_VERSION = '2.0.0'.freeze
+    MINIMUM_RUBY_VERSION = '2.1.0'.freeze
+
+    # Ruby 3.2 is not supported: Ruby 3.x support as implemented using *args
+    # needs ruby2_keywords to continue working, yet the scheduled removal of
+    # ruby2_keywords when Ruby 2.6 is EOL'd (i.e on Ruby 3.2 release) would
+    # leave the code with no option, other than to move to *args, **kwargs.
+    #
+    # See https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0/
+    #
+    # This constraint can only be removed when the dependency on ruby2_keywords is
+    # dropped. An allowance is nonetheless made to test prerelease versions.
+    # The version constraint may be bumped if the removal is postponed.
+    MAXIMUM_RUBY_VERSION = '3.2'.freeze
   end
 end

data/lib/ddtrace/worker.rb

@@ -1,3 +1,4 @@
+# typed: true
 module Datadog
   # Base class for work tasks
   class Worker

data/lib/ddtrace/workers.rb

@@ -1,3 +1,4 @@
+# typed: true
 require 'time'
 
 require 'ddtrace/workers/trace_writer'
@@ -58,7 +59,7 @@ module Datadog
           # TODO[manu]: findout the reason and reschedule the send if it's not
           # a fatal exception
           Datadog.logger.error(
-            "Error during traces flush: dropped #{traces.length} items. Cause: #{e} Location: #{e.backtrace.first}"
+            "Error during traces flush: dropped #{traces.length} items. Cause: #{e} Location: #{Array(e.backtrace).first}"
           )
         end
       end
@@ -67,9 +68,13 @@ module Datadog
       def start
         @mutex.synchronize do
           return if @run
+
           @run = true
-          Datadog.logger.debug("Starting thread in the process: #{Process.pid}")
+          Datadog.logger.debug { "Starting thread for: #{self}" }
           @worker = Thread.new { perform }
+          @worker.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+
+          nil
         end
       end
 
@@ -108,6 +113,7 @@ module Datadog
 
           @mutex.synchronize do
             return if !@run && @trace_buffer.empty?
+
             @shutdown.wait(@mutex, @back_off) if @run # do not wait when shutting down
           end
         end

data/lib/ddtrace/workers/async.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'ddtrace/logger'
 
 module Datadog
@@ -12,13 +13,13 @@ module Datadog
         SHUTDOWN_TIMEOUT = 1
 
         def self.included(base)
-          base.send(:prepend, PrependedMethods)
+          base.prepend(PrependedMethods)
         end
 
         # Methods that must be prepended
         module PrependedMethods
           def perform(*args)
-            start { self.result = super(*args) } unless started?
+            start_async { self.result = super(*args) } unless started?
           end
         end
 
@@ -31,18 +32,22 @@ module Datadog
 
         def join(timeout = nil)
           return true unless running?
+
           !worker.join(timeout).nil?
         end
 
         def terminate
           return false unless running?
+
           @run_async = false
+          Datadog.logger.debug { "Forcibly terminating worker thread for: #{self}" }
           worker.terminate
           true
         end
 
         def run_async?
           return false unless instance_variable_defined?(:@run_async)
+
           @run_async == true
         end
 
@@ -56,6 +61,7 @@ module Datadog
 
         def error?
           return false unless instance_variable_defined?(:@error)
+
           !@error.nil?
         end
 
@@ -101,9 +107,10 @@ module Datadog
           @worker ||= nil
         end
 
-        def start(&block)
+        def start_async(&block)
           mutex.synchronize do
             return if running?
+
             if forked?
               case fork_policy
               when FORK_POLICY_STOP
@@ -121,7 +128,7 @@ module Datadog
           @run_async = true
           @pid = Process.pid
           @error = nil
-          Datadog.logger.debug("Starting thread in the process: #{Process.pid}")
+          Datadog.logger.debug { "Starting thread for: #{self}" }
 
           @worker = ::Thread.new do
             begin
@@ -129,10 +136,13 @@ module Datadog
             # rubocop:disable Lint/RescueException
             rescue Exception => e
               @error = e
-              Datadog.logger.debug("Worker thread error. Cause #{e.message} Location: #{e.backtrace.first}")
+              Datadog.logger.debug("Worker thread error. Cause #{e.message} Location: #{Array(e.backtrace).first}")
               raise
             end
           end
+          @worker.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+
+          nil
         end
 
         def stop_fork

data/lib/ddtrace/workers/loop.rb

@@ -1,3 +1,4 @@
+# typed: false
 module Datadog
   module Workers
     # Adds looping behavior to workers, with a sleep
@@ -8,7 +9,7 @@ module Datadog
       BASE_INTERVAL = 1
 
       def self.included(base)
-        base.send(:prepend, PrependedMethods)
+        base.prepend(PrependedMethods)
       end
 
       # Methods that must be prepended
@@ -21,6 +22,7 @@ module Datadog
       def stop_loop
         mutex.synchronize do
           return false unless run_loop?
+
           @run_loop = false
           shutdown.signal
         end
@@ -34,6 +36,7 @@ module Datadog
 
       def run_loop?
         return false unless instance_variable_defined?(:@run_loop)
+
         @run_loop == true
       end
 
@@ -53,12 +56,29 @@ module Datadog
         @loop_wait_time ||= loop_base_interval
       end
 
+      def loop_wait_time=(value)
+        @loop_wait_time = value
+      end
+
+      def reset_loop_wait_time
+        self.loop_wait_time = loop_base_interval
+      end
+
+      # Should the loop "back off" when there's no work?
       def loop_back_off?
         false
       end
 
-      def loop_back_off!(amount = nil)
-        @loop_wait_time = amount || [loop_wait_time * BACK_OFF_RATIO, BACK_OFF_MAX].min
+      def loop_back_off!
+        self.loop_wait_time = [loop_wait_time * BACK_OFF_RATIO, BACK_OFF_MAX].min
+      end
+
+      # Should perform_loop just straight into work, or start by waiting?
+      #
+      # The use case is if we want to report some information (like profiles) from time to time, we may not want to
+      # report empty/zero/some residual value immediately when the worker starts.
+      def loop_wait_before_first_iteration?
+        false
       end
 
       protected
@@ -75,16 +95,22 @@ module Datadog
       private
 
       def perform_loop
-        @run_loop = true
+        mutex.synchronize do
+          @run_loop = true
+
+          shutdown.wait(mutex, loop_wait_time) if loop_wait_before_first_iteration?
+        end
 
         loop do
           if work_pending?
+            # There's work to do...
             # Run the task
             yield
 
             # Reset the wait interval
-            loop_back_off!(loop_base_interval)
+            reset_loop_wait_time if loop_back_off?
           elsif loop_back_off?
+            # There's no work to do...
             # Back off the wait interval a bit
             loop_back_off!
           end
@@ -92,6 +118,7 @@ module Datadog
           # Wait for an interval, unless shutdown has been signaled.
           mutex.synchronize do
             return unless run_loop? || work_pending?
+
             shutdown.wait(mutex, loop_wait_time) if run_loop?
           end
         end

data/lib/ddtrace/workers/polling.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'ddtrace/workers/async'
 require 'ddtrace/workers/loop'
 
@@ -8,9 +9,9 @@ module Datadog
       SHUTDOWN_TIMEOUT = 1
 
       def self.included(base)
-        base.send(:include, Workers::IntervalLoop)
-        base.send(:include, Workers::Async::Thread)
-        base.send(:prepend, PrependedMethods)
+        base.include(Workers::IntervalLoop)
+        base.include(Workers::Async::Thread)
+        base.prepend(PrependedMethods)
       end
 
       # Methods that must be prepended
@@ -26,8 +27,14 @@ module Datadog
           stop_loop
           graceful = join(timeout)
 
-          # If timeout and force stop...
-          !graceful && force_stop ? terminate : graceful
+          if !graceful && force_stop
+            Datadog.logger.debug do
+              "Timeout while waiting for worker to finish gracefully, forcing termination for: #{self}"
+            end
+            terminate
+          else
+            graceful
+          end
         else
           false
         end
@@ -35,6 +42,7 @@ module Datadog
 
       def enabled?
         return true unless instance_variable_defined?(:@enabled)
+
         @enabled
       end
 

data/lib/ddtrace/workers/queue.rb

@@ -1,10 +1,11 @@
+# typed: false
 module Datadog
   module Workers
     # Adds queue behavior to workers, with a buffer
     # to which items can be queued then dequeued.
     module Queue
       def self.included(base)
-        base.send(:prepend, PrependedMethods)
+        base.prepend(PrependedMethods)
       end
 
       # Methods that must be prepended
@@ -26,6 +27,7 @@ module Datadog
         buffer.shift
       end
 
+      # Are there more items to be processed next?
       def work_pending?
         !buffer.empty?
       end

data/lib/ddtrace/workers/runtime_metrics.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'forwardable'
 
 require 'ddtrace/runtime/metrics'
@@ -12,19 +13,23 @@ module Datadog
       extend Forwardable
       include Workers::Polling
 
+      # In seconds
+      DEFAULT_FLUSH_INTERVAL = 10
+      DEFAULT_BACK_OFF_MAX = 30
+
       attr_reader \
         :metrics
 
       def initialize(options = {})
-        @metrics = options.fetch(:metrics, Runtime::Metrics.new)
+        @metrics = options.fetch(:metrics) { Runtime::Metrics.new }
 
         # Workers::Async::Thread settings
         self.fork_policy = options.fetch(:fork_policy, Workers::Async::Thread::FORK_POLICY_STOP)
 
         # Workers::IntervalLoop settings
-        self.interval = options[:interval] if options.key?(:interval)
-        self.back_off_ratio = options[:back_off_ratio] if options.key?(:back_off_ratio)
-        self.back_off_max = options[:back_off_max] if options.key?(:back_off_max)
+        self.loop_base_interval = options.fetch(:interval, DEFAULT_FLUSH_INTERVAL)
+        self.loop_back_off_ratio = options[:back_off_ratio] if options.key?(:back_off_ratio)
+        self.loop_back_off_max = options.fetch(:back_off_max, DEFAULT_BACK_OFF_MAX)
 
         self.enabled = options.fetch(:enabled, false)
       end
@@ -39,6 +44,19 @@ module Datadog
         metrics.associate_with_span(*args).tap { perform }
       end
 
+      # TODO: `close_metrics` is only needed because
+      # Datadog::Components directly manipulates the lifecycle of
+      # Runtime::Metrics.statsd instances.
+      # This should be avoided, as it prevents this class from
+      # ensuring correct resource decommission of its internal
+      # dependencies.
+      def stop(*args, close_metrics: true)
+        self.enabled = false
+        result = super(*args)
+        @metrics.close if close_metrics
+        result
+      end
+
       def_delegators \
         :metrics,
         :register_service

data/lib/ddtrace/workers/trace_writer.rb

@@ -1,3 +1,4 @@
+# typed: false
 require 'ddtrace/logger'
 require 'ddtrace/transport/http'
 
@@ -16,15 +17,10 @@ module Datadog
       def initialize(options = {})
         transport_options = options.fetch(:transport_options, {})
 
-        if transport_options.is_a?(Proc)
-          transport_options = { on_build: transport_options }
-        end
-
-        transport_options[:hostname] = options[:hostname] if options.key?(:hostname)
-        transport_options[:port] = options[:port] if options.key?(:port)
+        transport_options[:agent_settings] = options[:agent_settings] if options.key?(:agent_settings)
 
         @transport = options.fetch(:transport) do
-          Transport::HTTP.default(transport_options)
+          Transport::HTTP.default(**transport_options)
         end
       end
 
@@ -41,7 +37,7 @@ module Datadog
         flush_traces(traces)
       rescue StandardError => e
         Datadog.logger.error(
-          "Error while writing traces: dropped #{traces.length} items. Cause: #{e} Location: #{e.backtrace.first}"
+          "Error while writing traces: dropped #{traces.length} items. Cause: #{e} Location: #{Array(e.backtrace).first}"
         )
       end
 
@@ -65,10 +61,8 @@ module Datadog
         traces.each do |trace|
           next if trace.first.nil?
 
-          hostname = Datadog::Runtime::Socket.hostname
-          unless hostname.nil? || hostname.empty?
-            trace.first.set_tag(Ext::NET::TAG_HOSTNAME, hostname)
-          end
+          hostname = Datadog::Core::Environment::Socket.hostname
+          trace.first.set_tag(Ext::NET::TAG_HOSTNAME, hostname) unless hostname.nil? || hostname.empty?
         end
       end
 
@@ -84,10 +78,6 @@ module Datadog
         def initialize
           super(:flush_completed)
         end
-
-        def publish(response)
-          super(response)
-        end
       end
     end
 
@@ -127,10 +117,15 @@ module Datadog
 
       # NOTE: #perform is wrapped by other modules:
       #       Polling --> Async --> IntervalLoop --> AsyncTraceWriter --> TraceWriter
+      #
+      # WARNING: This method breaks the Liskov Substitution Principle -- TraceWriter#perform is spec'd to return the
+      # result from the writer, whereas this method always returns nil.
       def perform(traces)
         super(traces).tap do |responses|
           loop_back_off! if responses.find(&:server_error?)
         end
+
+        nil
       end
 
       def stop(*args)
@@ -148,6 +143,7 @@ module Datadog
         [buffer.pop]
       end
 
+      # Are there more traces to be processed next?
       def work_pending?
         !buffer.empty?
       end
@@ -187,6 +183,8 @@ module Datadog
         @async = false if @writer_fork_policy == FORK_POLICY_SYNC
       end
 
+      # WARNING: This method breaks the Liskov Substitution Principle -- TraceWriter#write is spec'd to return the
+      # result from the writer, whereas this method returns something else when running in async mode.
       def write(trace)
         # Start worker thread. If the process has forked, it will trigger #after_fork to
         # reconfigure the worker accordingly.