ddtrace 0.41.0 → 0.46.0

data/lib/ddtrace/sampler.rb

@@ -81,7 +81,7 @@ module Datadog
       :default_key
 
     def initialize(default_key, default_rate = 1.0, &block)
-      raise ArgumentError, 'No resolver given!' unless block_given?
+      raise ArgumentError, 'No resolver given!' unless block
 
       @default_key = default_key
       @resolver = block

data/lib/ddtrace/sampling/rate_limiter.rb

@@ -38,6 +38,10 @@ module Datadog
         @tokens = max_tokens
         @total_messages = 0
         @conforming_messages = 0
+        @prev_conforming_messages = nil
+        @prev_total_messages = nil
+        @current_window = nil
+
         @last_refill = Utils::Time.get_time
       end
 
@@ -47,28 +51,17 @@ module Datadog
       # If it does, return +true+ and remove +size+
       # tokens from the bucket.
       # If it does not, return +false+ without affecting
-      # the tokens form the bucket.
+      # the tokens from the bucket.
       #
       # @return [Boolean] +true+ if message conforms with current bucket limit
       def allow?(size)
-        return false if @rate.zero?
-        return true if @rate < 0
-
-        refill_since_last_message
-
-        increment_total_count
-
-        return false if @tokens < size
-
-        increment_conforming_count
-
-        @tokens -= size
-
-        true
+        allowed = should_allow?(size)
+        update_rate_counts(allowed)
+        allowed
       end
 
       # Ratio of 'conformance' per 'total messages' checked
-      # on this bucket.
+      # averaged for the past 2 buckets
       #
       # Returns +1.0+ when no messages have been checked yet.
       #
@@ -77,6 +70,20 @@ module Datadog
         return 0.0 if @rate.zero?
         return 1.0 if @rate < 0 || @total_messages.zero?
 
+        return current_window_rate if @prev_conforming_messages.nil? || @prev_total_messages.nil?
+
+        (@conforming_messages.to_f + @prev_conforming_messages.to_f) / (@total_messages + @prev_total_messages)
+      end
+
+      # Ratio of 'conformance' per 'total messages' checked
+      # on this bucket
+      #
+      # Returns +1.0+ when no messages have been checked yet.
+      #
+      # @return [Float] Conformance ratio, between +[0,1]+
+      def current_window_rate
+        return 1.0 if @total_messages.zero?
+
         @conforming_messages.to_f / @total_messages
       end
 
@@ -91,6 +98,8 @@ module Datadog
         now = Utils::Time.get_time
         elapsed = now - @last_refill
 
+        # Update the number of available tokens, but ensure we do not exceed the max
+        # we return the min of tokens + rate*elapsed, or max tokens
         refill_tokens(@rate * elapsed)
 
         @last_refill = now
@@ -108,6 +117,46 @@ module Datadog
       def increment_conforming_count
         @conforming_messages += 1
       end
+
+      def should_allow?(size)
+        # rate limit of 0 blocks everything
+        return false if @rate.zero?
+
+        # negative rate limit disables rate limiting
+        return true if @rate < 0
+
+        refill_since_last_message
+
+        # if tokens < 1 we don't allow?
+        return false if @tokens < size
+
+        @tokens -= size
+
+        true
+      end
+
+      # Sets and Updates the past two 1 second windows for which
+      # the rate limiter must compute it's rate over and updates
+      # the total count, and conforming message count if +allowed+
+      def update_rate_counts(allowed)
+        now = Utils::Time.get_time
+
+        # No tokens have been seen yet, start a new window
+        if @current_window.nil?
+          @current_window = now
+        # If more than 1 second has past since last window, reset
+        elsif now - @current_window >= 1
+          @prev_conforming_messages = @conforming_messages
+          @prev_total_messages = @total_messages
+          @conforming_messages = 0
+          @total_messages = 0
+          @current_window = now
+        end
+
+        increment_conforming_count if allowed
+
+        increment_total_count
+      end
     end
 
     # \RateLimiter that accepts all resources,

data/lib/ddtrace/sampling/rule_sampler.rb

@@ -88,6 +88,7 @@ module Datadog
 
       def update(*args)
         return false unless @default_sampler.respond_to?(:update)
+
         @default_sampler.update(*args)
       end
 

data/lib/ddtrace/span.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require 'time'
-require 'thread'
-
 require 'ddtrace/utils'
 require 'ddtrace/ext/errors'
 require 'ddtrace/ext/priority'
@@ -38,14 +36,16 @@ module Datadog
     EXTERNAL_MAX_ID = 1 << 64
 
     # This limit is for numeric tags because uint64 could end up rounded.
-    NUMERIC_TAG_SIZE_RANGE = (-1 << 53..1 << 53)
+    NUMERIC_TAG_SIZE_RANGE = (-1 << 53..1 << 53).freeze
 
     attr_accessor :name, :service, :resource, :span_type,
                   :span_id, :trace_id, :parent_id,
                   :status, :sampled,
-                  :tracer, :context, :duration, :start_time, :end_time
+                  :tracer, :context
+
+    attr_reader :parent, :start_time, :end_time
 
-    attr_reader :parent
+    attr_writer :duration
 
     # Create a new span linked to the given tracer. Call the \Tracer method <tt>start_span()</tt>
     # and then <tt>finish()</tt> once the tracer operation is over.
@@ -180,7 +180,7 @@ module Datadog
       # behavior and so we maintain it for backward compatibility for those
       # who are using async manual instrumentation that may rely on this
 
-      @start_time = start_time || Time.now.utc
+      @start_time = start_time || Utils::Time.now.utc
       @duration_start = start_time.nil? ? duration_marker : nil
 
       self
@@ -206,7 +206,7 @@ module Datadog
 
       @allocation_count_finish = now_allocations
 
-      now = Time.now.utc
+      now = Utils::Time.now.utc
 
       # Provide a default start_time if unset.
       # Using `now` here causes duration to be 0; this is expected

data/lib/ddtrace/sync_writer.rb

@@ -5,6 +5,10 @@ require 'ddtrace/runtime/metrics'
 module Datadog
   # SyncWriter flushes both services and traces synchronously
   # DEV: To be replaced by Datadog::Workers::TraceWriter.
+  #
+  # Note: If you're wondering if this class is used at all, since there are no other references to it on the codebase,
+  # the separate `datadog-lambda` uses it as of February 2021:
+  # <https://github.com/DataDog/datadog-lambda-rb/blob/c15f0f0916c90123416dc44e7d6800ef4a7cfdbf/lib/datadog/lambda.rb#L38>
   class SyncWriter
     attr_reader \
       :priority_sampler,
@@ -29,9 +33,7 @@ module Datadog
         end
       end
 
-      perform_concurrently(
-        proc { flush_trace(trace) }
-      )
+      flush_trace(trace)
     rescue => e
       Datadog.logger.debug(e)
     end
@@ -44,13 +46,10 @@ module Datadog
 
     private
 
-    def perform_concurrently(*tasks)
-      tasks.map { |task| Thread.new(&task) }.each(&:join)
-    end
-
     def flush_trace(trace)
       processed_traces = Pipeline.process!([trace])
       return if processed_traces.empty?
+
       inject_hostname!(processed_traces.first) if Datadog.configuration.report_hostname
       transport.send_traces(processed_traces)
     end
@@ -58,9 +57,7 @@ module Datadog
     def inject_hostname!(trace)
       unless 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
   end

data/lib/ddtrace/tracer.rb

@@ -1,4 +1,3 @@
-require 'thread'
 require 'logger'
 require 'pathname'
 
@@ -7,6 +6,7 @@ require 'ddtrace/span'
 require 'ddtrace/context'
 require 'ddtrace/logger'
 require 'ddtrace/writer'
+require 'ddtrace/runtime/identity'
 require 'ddtrace/sampler'
 require 'ddtrace/sampling'
 require 'ddtrace/correlation'
@@ -59,8 +59,8 @@ module Datadog
     #
     # This method makes use of a \ContextProvider that is automatically set during the tracer
     # initialization, or while using a library instrumentation.
-    def call_context
-      @provider.context
+    def call_context(key = nil)
+      @provider.context(key)
     end
 
     # Initialize a new \Tracer used to create, sample and submit spans that measure the
@@ -143,6 +143,7 @@ module Datadog
     # a service would be invalid and rejected.
     def default_service
       return @default_service if instance_variable_defined?(:@default_service) && @default_service
+
       begin
         @default_service = File.basename($PROGRAM_NAME, '.*')
       rescue StandardError => e
@@ -201,6 +202,7 @@ module Datadog
         # root span
         @sampler.sample!(span)
         span.set_tag('system.pid', Process.pid)
+        span.set_tag(Datadog::Ext::Runtime::TAG_ID, Datadog::Runtime::Identity.id)
 
         if ctx && ctx.trace_id
           span.trace_id = ctx.trace_id
@@ -287,8 +289,19 @@ module Datadog
         # and it is user code which should be executed no matter what.
         # It's not a problem since we re-raise it afterwards so for example a
         # SignalException::Interrupt would still bubble up.
+        # rubocop:disable Metrics/BlockNesting
         rescue Exception => e
-          (options[:on_error] || DEFAULT_ON_ERROR).call(span, e)
+          if (on_error_handler = options[:on_error]) && on_error_handler.respond_to?(:call)
+            begin
+              on_error_handler.call(span, e)
+            rescue
+              Datadog.logger.debug('Custom on_error handler failed, falling back to default')
+              DEFAULT_ON_ERROR.call(span, e)
+            end
+          else
+            Datadog.logger.debug('Custom on_error handler must be a callable, falling back to default') if on_error_handler
+            DEFAULT_ON_ERROR.call(span, e)
+          end
           raise e
         ensure
           span.finish unless span.nil?
@@ -324,18 +337,18 @@ module Datadog
     end
 
     # Return the current active span or +nil+.
-    def active_span
-      call_context.current_span
+    def active_span(key = nil)
+      call_context(key).current_span
     end
 
     # Return the current active root span or +nil+.
-    def active_root_span
-      call_context.current_root_span
+    def active_root_span(key = nil)
+      call_context(key).current_root_span
     end
 
     # Return a CorrelationIdentifier for active span
-    def active_correlation
-      Datadog::Correlation.identifier_from_context(call_context)
+    def active_correlation(key = nil)
+      Datadog::Correlation.identifier_from_context(call_context(key))
     end
 
     # Send the trace to the writer to enqueue the spans list in the agent

data/lib/ddtrace/transport/http.rb

@@ -69,9 +69,7 @@ module Datadog
         }.tap do |headers|
           # Add container ID, if present.
           container_id = Datadog::Runtime::Container.container_id
-          unless container_id.nil?
-            headers[Datadog::Ext::Transport::HTTP::HEADER_CONTAINER_ID] = container_id
-          end
+          headers[Datadog::Ext::Transport::HTTP::HEADER_CONTAINER_ID] = container_id unless container_id.nil?
         end
       end
 

data/lib/ddtrace/transport/http/adapters/net.rb

@@ -19,7 +19,7 @@ module Datadog
             @timeout = options[:timeout] || DEFAULT_TIMEOUT
           end
 
-          def open
+          def open(&block)
             # DEV Initializing +Net::HTTP+ directly help us avoid expensive
             # options processing done in +Net::HTTP.start+:
             # https://github.com/ruby/ruby/blob/b2d96abb42abbe2e01f010ffc9ac51f0f9a50002/lib/net/http.rb#L614-L618
@@ -27,9 +27,7 @@ module Datadog
 
             req.open_timeout = req.read_timeout = timeout
 
-            req.start do |http|
-              yield(http)
-            end
+            req.start(&block)
           end
 
           def call(env)
@@ -82,36 +80,43 @@ module Datadog
 
             def payload
               return super if http_response.nil?
+
               http_response.body
             end
 
             def code
               return super if http_response.nil?
+
               http_response.code.to_i
             end
 
             def ok?
               return super if http_response.nil?
+
               code.between?(200, 299)
             end
 
             def unsupported?
               return super if http_response.nil?
+
               code == 415
             end
 
             def not_found?
               return super if http_response.nil?
+
               code == 404
             end
 
             def client_error?
               return super if http_response.nil?
+
               code.between?(400, 499)
             end
 
             def server_error?
               return super if http_response.nil?
+
               code.between?(500, 599)
             end
 

data/lib/ddtrace/transport/http/adapters/registry.rb

@@ -15,6 +15,7 @@ module Datadog
           def set(klass, name = nil)
             name ||= klass.to_s
             return if name.nil?
+
             @adapters[name] = klass
           end
         end

data/lib/ddtrace/transport/http/adapters/unix_socket.rb

@@ -18,7 +18,7 @@ module Datadog
             @timeout = options.fetch(:timeout, DEFAULT_TIMEOUT)
           end
 
-          def open
+          def open(&block)
             # Open connection
             connection = HTTP.new(
               filepath,
@@ -26,9 +26,7 @@ module Datadog
               continue_timeout: timeout
             )
 
-            connection.start do |http|
-              yield(http)
-            end
+            connection.start(&block)
           end
 
           def url

data/lib/ddtrace/transport/http/builder.rb

@@ -36,6 +36,7 @@ module Datadog
           @default_adapter = if type.is_a?(Symbol)
                                registry_klass = REGISTRY.get(type)
                                raise UnknownAdapterError, type if registry_klass.nil?
+
                                registry_klass.new(*args)
                              else
                                type
@@ -67,6 +68,7 @@ module Datadog
 
         def default_api=(key)
           raise UnknownApiError, key unless @apis.key?(key)
+
           @default_api = key
         end
 

data/lib/ddtrace/transport/http/traces.rb

@@ -41,6 +41,7 @@ module Datadog
 
             def send_traces(env, &block)
               raise NoTraceEndpointDefinedError, self if traces.nil?
+
               traces.call(env, &block)
             end
 
@@ -121,9 +122,7 @@ module Datadog
                 # Parse service rates, if configured to do so.
                 if service_rates? && !http_response.payload.to_s.empty?
                   body = JSON.parse(http_response.payload)
-                  if body.is_a?(Hash) && body.key?(SERVICE_RATE_KEY)
-                    options[:service_rates] = body[SERVICE_RATE_KEY]
-                  end
+                  options[:service_rates] = body[SERVICE_RATE_KEY] if body.is_a?(Hash) && body.key?(SERVICE_RATE_KEY)
                 end
               end