ddtrace 0.41.0 → 0.46.0

data/lib/ddtrace/transport/io.rb

@@ -17,7 +17,7 @@ module Datadog
       # Pass options to override any settings.
       def default(options = {})
         new(
-          options.fetch(:out, STDOUT),
+          options.fetch(:out, $stdout),
           options.fetch(:encoder, Encoding::JSONEncoder)
         )
       end

data/lib/ddtrace/transport/traces.rb

@@ -142,17 +142,20 @@ module Datadog
 
         def downgrade?(response)
           return false unless apis.fallbacks.key?(@current_api_id)
+
           response.not_found? || response.unsupported?
         end
 
         def downgrade!
           downgrade_api_id = apis.fallbacks[@current_api_id]
           raise NoDowngradeAvailableError, @current_api_id if downgrade_api_id.nil?
+
           change_api!(downgrade_api_id)
         end
 
         def change_api!(api_id)
           raise UnknownApiVersionError, api_id unless apis.key?(api_id)
+
           @current_api_id = api_id
           @client = HTTP::Client.new(current_api)
         end

data/lib/ddtrace/utils.rb

@@ -1,8 +1,11 @@
 require 'ddtrace/utils/database'
+require 'ddtrace/utils/forking'
 
 module Datadog
   # Utils contains low-level utilities, typically to provide pseudo-random trace IDs.
   module Utils
+    extend Utils::Forking
+
     EMPTY_STRING = ''.encode(::Encoding::UTF_8).freeze
     # We use a custom random number generator because we want no interference
     # with the default one. Using the default prng, we could break code that
@@ -10,23 +13,19 @@ module Datadog
 
     # Return a span id
     def self.next_id
-      reset! if was_forked?
-
-      @rnd.rand(Datadog::Span::RUBY_MAX_ID)
+      after_fork! { reset! }
+      id_rng.rand(Datadog::Span::RUBY_MAX_ID)
     end
 
-    def self.reset!
-      @pid = Process.pid
-      @rnd = Random.new
+    def self.id_rng
+      @id_rng ||= Random.new
     end
 
-    def self.was_forked?
-      Process.pid != @pid
+    def self.reset!
+      @id_rng = Random.new
     end
 
-    private_class_method :reset!, :was_forked?
-
-    reset!
+    private_class_method :id_rng, :reset!
 
     def self.truncate(value, size, omission = '...'.freeze)
       string = value.to_s

data/lib/ddtrace/utils/forking.rb

@@ -0,0 +1,52 @@
+module Datadog
+  module Utils
+    # Helper methods for managing forking behavior
+    module Forking
+      def self.included(base)
+        base.send(:prepend, ClassExtensions) if base.is_a?(Class)
+      end
+
+      def self.extended(base)
+        # Explicitly update PID here because there's a case where
+        # the code path that lazily updates the PID may not be exercised
+        # until after a fork occurs, thus causing the event to be missed.
+        # By eagerly setting this, we avoid this scenario.
+        base.update_fork_pid!
+      end
+
+      def after_fork!
+        if forked?
+          yield
+          update_fork_pid!
+          true
+        else
+          false
+        end
+      end
+
+      def forked?
+        Process.pid != fork_pid
+      end
+
+      def update_fork_pid!
+        @fork_pid = Process.pid
+      end
+
+      def fork_pid
+        @fork_pid ||= Process.pid
+      end
+
+      # Adds additional functionality for Classes that implement Forking
+      module ClassExtensions
+        # Addresses an edge case where forking before invoking #update_fork_pid! on the
+        # object will cause forking to not be detected in the fork when it should have.
+        #
+        # This wrapper prevents this by initializing the fork PID when the object is created.
+        def initialize(*args, &block)
+          super
+          update_fork_pid!
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/utils/time.rb

@@ -6,8 +6,32 @@ module Datadog
 
       module_function
 
+      # Current monotonic time.
+      # Falls back to `now` if monotonic clock
+      # is not available.
+      #
+      # @return [Float] in seconds, since some unspecified starting point
       def get_time
-        PROCESS_TIME_SUPPORTED ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : ::Time.now.to_f
+        PROCESS_TIME_SUPPORTED ? Process.clock_gettime(Process::CLOCK_MONOTONIC) : now.to_f
+      end
+
+      # Current wall time.
+      #
+      # @return [Time] current time object
+      def now
+        ::Time.now
+      end
+
+      # Overrides the implementation of `#now
+      # with the provided callable.
+      #
+      # Overriding the method `#now` instead of
+      # indirectly calling `block` removes
+      # one level of method call overhead.
+      #
+      # @param block [Proc] block that returns a `Time` object representing the current wall time
+      def now_provider=(block)
+        define_singleton_method(:now, &block)
       end
     end
   end

data/lib/ddtrace/vendor/active_record/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2005-2018 David Heinemeier Hansson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/ddtrace/version.rb

@@ -1,7 +1,7 @@
 module Datadog
   module VERSION
     MAJOR = 0
-    MINOR = 41
+    MINOR = 46
     PATCH = 0
     PRE = nil
 

data/lib/ddtrace/workers.rb

@@ -67,9 +67,13 @@ module Datadog
       def start
         @mutex.synchronize do
           return if @run
+
           @run = true
           Datadog.logger.debug("Starting thread in the process: #{Process.pid}")
           @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 +112,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

@@ -31,11 +31,13 @@ module Datadog
 
         def join(timeout = nil)
           return true unless running?
+
           !worker.join(timeout).nil?
         end
 
         def terminate
           return false unless running?
+
           @run_async = false
           worker.terminate
           true
@@ -43,6 +45,7 @@ module Datadog
 
         def run_async?
           return false unless instance_variable_defined?(:@run_async)
+
           @run_async == true
         end
 
@@ -56,6 +59,7 @@ module Datadog
 
         def error?
           return false unless instance_variable_defined?(:@error)
+
           !@error.nil?
         end
 
@@ -104,6 +108,7 @@ module Datadog
         def start(&block)
           mutex.synchronize do
             return if running?
+
             if forked?
               case fork_policy
               when FORK_POLICY_STOP
@@ -133,6 +138,9 @@ module Datadog
               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

@@ -21,6 +21,7 @@ module Datadog
       def stop_loop
         mutex.synchronize do
           return false unless run_loop?
+
           @run_loop = false
           shutdown.signal
         end
@@ -34,6 +35,7 @@ module Datadog
 
       def run_loop?
         return false unless instance_variable_defined?(:@run_loop)
+
         @run_loop == true
       end
 
@@ -92,6 +94,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

@@ -35,6 +35,7 @@ module Datadog
 
       def enabled?
         return true unless instance_variable_defined?(:@enabled)
+
         @enabled
       end
 

data/lib/ddtrace/workers/runtime_metrics.rb

@@ -12,6 +12,10 @@ module Datadog
       extend Forwardable
       include Workers::Polling
 
+      # In seconds
+      DEFAULT_FLUSH_INTERVAL = 10
+      DEFAULT_BACK_OFF_MAX = 30
+
       attr_reader \
         :metrics
 
@@ -22,9 +26,9 @@ module Datadog
         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

data/lib/ddtrace/workers/trace_writer.rb

@@ -16,9 +16,7 @@ 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 = { on_build: transport_options } if transport_options.is_a?(Proc)
 
         transport_options[:hostname] = options[:hostname] if options.key?(:hostname)
         transport_options[:port] = options[:port] if options.key?(:port)
@@ -66,9 +64,7 @@ module Datadog
           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
+          trace.first.set_tag(Ext::NET::TAG_HOSTNAME, hostname) unless hostname.nil? || hostname.empty?
         end
       end
 
@@ -84,10 +80,6 @@ module Datadog
         def initialize
           super(:flush_completed)
         end
-
-        def publish(response)
-          super(response)
-        end
       end
     end
 
@@ -127,10 +119,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)
@@ -187,6 +184,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.

data/lib/ddtrace/writer.rb

@@ -42,13 +42,23 @@ module Datadog
 
       # one worker for traces
       @worker = nil
+
+      # Once stopped, this writer instance cannot be restarted.
+      # This allow for graceful shutdown, while preventing
+      # the host application from inadvertently start new
+      # threads during shutdown.
+      @stopped = false
     end
 
     def start
       @mutex_after_fork.synchronize do
+        return false if @stopped
+
         pid = Process.pid
         return if @worker && pid == @pid
+
         @pid = pid
+
         start_worker
         true
       end
@@ -67,14 +77,24 @@ module Datadog
       @worker.start
     end
 
+    # Gracefully shuts down this writer.
+    #
+    # Once stopped methods calls won't fail, but
+    # no internal work will be performed.
+    #
+    # It is not possible to restart a stopped writer instance.
     def stop
       @mutex_after_fork.synchronize { stop_worker }
     end
 
     def stop_worker
+      @stopped = true
+
       return if @worker.nil?
+
       @worker.stop
       @worker = nil
+
       true
     end
 
@@ -136,7 +156,7 @@ module Datadog
 
       if worker_local
         worker_local.enqueue_trace(trace)
-      else
+      elsif !@stopped
         Datadog.logger.debug('Writer either failed to start or was stopped before #write could complete')
       end
     end
@@ -156,9 +176,7 @@ module Datadog
         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
+        trace.first.set_tag(Ext::NET::TAG_HOSTNAME, hostname) unless hostname.nil? || hostname.empty?
       end
     end