ddtrace 0.30.1 → 0.31.0

data/lib/ddtrace/contrib/rack/request_queue.rb

@@ -30,7 +30,7 @@ module Datadog
         rescue StandardError => e
           # in case of an Exception we don't create a
           # `request.queuing` span
-          Datadog::Tracer.log.debug("[rack] unable to parse request queue headers: #{e}")
+          Datadog::Logger.log.debug("[rack] unable to parse request queue headers: #{e}")
           nil
         end
       end

data/lib/ddtrace/contrib/rails/configuration/settings.rb

@@ -67,6 +67,7 @@ module Datadog
           option :tracer do |o|
             o.delegate_to { Datadog.tracer }
             o.on_set do |value|
+              Datadog.configuration[:action_cable][:tracer] = value
               Datadog.configuration[:active_record][:tracer] = value
               Datadog.configuration[:active_support][:tracer] = value
               Datadog.configuration[:action_pack][:tracer] = value

data/lib/ddtrace/contrib/rails/framework.rb

@@ -3,6 +3,7 @@ require 'ddtrace/ext/app_types'
 
 require 'ddtrace/contrib/active_record/integration'
 require 'ddtrace/contrib/active_support/integration'
+require 'ddtrace/contrib/action_cable/integration'
 require 'ddtrace/contrib/action_pack/integration'
 require 'ddtrace/contrib/action_view/integration'
 require 'ddtrace/contrib/grape/endpoint'
@@ -23,6 +24,7 @@ module Datadog
           config = config_with_defaults
 
           activate_rack!(config)
+          activate_action_cable!(config)
           activate_active_support!(config)
           activate_action_pack!(config)
           activate_action_view!(config)
@@ -65,6 +67,16 @@ module Datadog
           )
         end
 
+        def self.activate_action_cable!(config)
+          return unless defined?(::ActionCable)
+
+          Datadog.configuration.use(
+            :action_cable,
+            service_name: "#{config[:service_name]}-#{Contrib::ActionCable::Ext::SERVICE_NAME}",
+            tracer: config[:tracer]
+          )
+        end
+
         def self.activate_action_pack!(config)
           return unless defined?(::ActionPack)
 

data/lib/ddtrace/contrib/rake/instrumentation.rb

@@ -47,14 +47,14 @@ module Datadog
             span.set_tag(Ext::TAG_TASK_ARG_NAMES, arg_names)
             span.set_tag(Ext::TAG_INVOKE_ARGS, quantize_args(args)) unless args.nil?
           rescue StandardError => e
-            Datadog::Tracer.log.debug("Error while tracing Rake invoke: #{e.message}")
+            Datadog::Logger.log.debug("Error while tracing Rake invoke: #{e.message}")
           end
 
           def annotate_execute!(span, args)
             span.resource = name
             span.set_tag(Ext::TAG_EXECUTE_ARGS, quantize_args(args.to_hash)) unless args.nil?
           rescue StandardError => e
-            Datadog::Tracer.log.debug("Error while tracing Rake execute: #{e.message}")
+            Datadog::Logger.log.debug("Error while tracing Rake execute: #{e.message}")
           end
 
           def quantize_args(args)

data/lib/ddtrace/contrib/redis/quantize.rb

@@ -15,7 +15,7 @@ module Datadog
           str = Utils.utf8_encode(str, binary: true, placeholder: PLACEHOLDER)
           Utils.truncate(str, VALUE_MAX_LEN, TOO_LONG_MARK)
         rescue => e
-          Datadog::Tracer.log.debug("non formattable Redis arg #{str}: #{e}")
+          Datadog::Logger.log.debug("non formattable Redis arg #{str}: #{e}")
           PLACEHOLDER
         end
 

data/lib/ddtrace/contrib/sinatra/tracer.rb

@@ -68,7 +68,7 @@ module Datadog
             span = Sinatra::Env.datadog_span(env)
 
             unless span
-              Datadog::Tracer.log.error('missing request span in :after hook')
+              Datadog::Logger.log.error('missing request span in :after hook')
               return
             end
 

data/lib/ddtrace/ext/forced_tracing.rb

@@ -12,7 +12,7 @@ module Datadog
 
         # Only log each deprecation warning once (safeguard against log spam)
         unless @deprecation_warning_shown
-          Datadog::Tracer.log.warn(
+          Datadog::Logger.log.warn(
             'forced tracing: Datadog::Ext::ForcedTracing has been renamed to Datadog::Ext::ManualTracing'
           )
           @deprecation_warning_shown = true

data/lib/ddtrace/ext/sampling.rb

@@ -1,6 +1,9 @@
 module Datadog
   module Ext
     module Sampling
+      ENV_SAMPLE_RATE = 'DD_TRACE_SAMPLE_RATE'.freeze
+      ENV_RATE_LIMIT = 'DD_TRACE_RATE_LIMIT'.freeze
+
       # If rule sampling is applied to a span, set this metric the sample rate configured for that rule.
       # This should be done regardless of sampling outcome.
       RULE_SAMPLE_RATE = '_dd.rule_psr'.freeze

data/lib/ddtrace/logger.rb

@@ -7,6 +7,48 @@ module Datadog
   # - progname defaults to ddtrace to clearly identify Datadog dd-trace-rb related messages
   # - adds last caller stack-trace info to know where the message comes from
   class Logger < ::Logger
+    # Global, memoized, lazy initialized instance of a logger that is used within the the Datadog
+    # namespace. This logger outputs to +STDOUT+ by default, and is considered thread-safe.
+    class << self
+      def log
+        unless defined? @logger
+          @logger = Datadog::Logger.new(STDOUT)
+          @logger.level = Logger::WARN
+        end
+        @logger
+      end
+
+      # Override the default logger with a custom one.
+      def log=(logger)
+        return unless logger
+        return unless logger.respond_to? :methods
+        return unless logger.respond_to? :error
+        if logger.respond_to? :methods
+          unimplemented = new(STDOUT).methods - logger.methods
+          unless unimplemented.empty?
+            logger.error("logger #{logger} does not implement #{unimplemented}")
+            return
+          end
+        end
+        @logger = logger
+      end
+
+      # Activate the debug mode providing more information related to tracer usage
+      # Default to Warn level unless using custom logger
+      def debug_logging=(value)
+        if value
+          log.level = Logger::DEBUG
+        elsif log.is_a?(Datadog::Logger)
+          log.level = Logger::WARN
+        end
+      end
+
+      # Return if the debug mode is activated or not
+      def debug_logging
+        log.level == Logger::DEBUG
+      end
+    end
+
     def initialize(*args, &block)
       super
       self.progname = LOG_PREFIX

data/lib/ddtrace/metrics.rb

@@ -62,7 +62,7 @@ module Datadog
 
       statsd.count(stat, value, metric_options(options))
     rescue StandardError => e
-      Datadog::Tracer.log.error("Failed to send count stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog::Logger.log.error("Failed to send count stat. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def distribution(stat, value = nil, options = nil, &block)
@@ -72,7 +72,7 @@ module Datadog
 
       statsd.distribution(stat, value, metric_options(options))
     rescue StandardError => e
-      Datadog::Tracer.log.error("Failed to send distribution stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog::Logger.log.error("Failed to send distribution stat. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def increment(stat, options = nil)
@@ -81,7 +81,7 @@ module Datadog
 
       statsd.increment(stat, metric_options(options))
     rescue StandardError => e
-      Datadog::Tracer.log.error("Failed to send increment stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog::Logger.log.error("Failed to send increment stat. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def gauge(stat, value = nil, options = nil, &block)
@@ -91,7 +91,7 @@ module Datadog
 
       statsd.gauge(stat, value, metric_options(options))
     rescue StandardError => e
-      Datadog::Tracer.log.error("Failed to send gauge stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+      Datadog::Logger.log.error("Failed to send gauge stat. Cause: #{e.message} Source: #{e.backtrace.first}")
     end
 
     def time(stat, options = nil)
@@ -107,7 +107,7 @@ module Datadog
           distribution(stat, ((finished - start) * 1000), options)
         end
       rescue StandardError => e
-        Datadog::Tracer.log.error("Failed to send time stat. Cause: #{e.message} Source: #{e.backtrace.first}")
+        Datadog::Logger.log.error("Failed to send time stat. Cause: #{e.message} Source: #{e.backtrace.first}")
       end
     end
 

data/lib/ddtrace/monkey.rb

@@ -48,7 +48,7 @@ module Datadog
     end
 
     def log_deprecation_warning(method)
-      Datadog::Tracer.log.warn("#{method}:#{DEPRECATION_WARNING}")
+      Datadog::Logger.log.warn("#{method}:#{DEPRECATION_WARNING}")
     end
 
     class << self

data/lib/ddtrace/pin.rb

@@ -107,7 +107,7 @@ module Datadog
     def log_deprecation_warning(method_name)
       # Only log each deprecation warning once (safeguard against log spam)
       do_once(method_name) do
-        Datadog::Tracer.log.warn("#{method_name}:#{DEPRECATION_WARNING}")
+        Datadog::Logger.log.warn("#{method_name}:#{DEPRECATION_WARNING}")
       end
     end
   end

data/lib/ddtrace/pipeline.rb

@@ -34,7 +34,7 @@ module Datadog
 
       result || []
     rescue => e
-      Datadog::Tracer.log.debug(
+      Datadog::Logger.log.debug(
         "trace dropped entirely due to `Pipeline.before_flush` error: #{e}"
       )
 

data/lib/ddtrace/propagation/http_propagator.rb

@@ -19,7 +19,7 @@ module Datadog
     def self.inject!(context, env)
       # Prevent propagation from being attempted if context provided is nil.
       if context.nil?
-        ::Datadog::Tracer.log.debug('Cannot inject context into env to propagate over HTTP: context is nil.'.freeze)
+        ::Datadog::Logger.log.debug('Cannot inject context into env to propagate over HTTP: context is nil.'.freeze)
         return
       end
 
@@ -58,7 +58,7 @@ module Datadog
             # Return an empty/new context if we have a mismatch in values extracted
             msg = "#{context.trace_id} != #{extracted_context.trace_id} && " \
                   "#{context.span_id} != #{extracted_context.span_id}"
-            ::Datadog::Tracer.log.debug("Cannot extract context from HTTP: extracted contexts differ, #{msg}".freeze)
+            ::Datadog::Logger.log.debug("Cannot extract context from HTTP: extracted contexts differ, #{msg}".freeze)
             # DEV: This will return from `self.extract` not this `each` block
             return ::Datadog::Context.new
           end

data/lib/ddtrace/runtime/cgroup.rb

@@ -27,7 +27,7 @@ module Datadog
               end
             end
           rescue StandardError => e
-            Datadog::Tracer.log.error("Error while parsing cgroup. Cause: #{e.message} Location: #{e.backtrace.first}")
+            Datadog::Logger.log.error("Error while parsing cgroup. Cause: #{e.message} Location: #{e.backtrace.first}")
           end
         end
       end

data/lib/ddtrace/runtime/container.rb

@@ -61,7 +61,7 @@ module Datadog
                 break
               end
             rescue StandardError => e
-              Datadog::Tracer.log.error(
+              Datadog::Logger.log.error(
                 "Error while parsing container info. Cause: #{e.message} Location: #{e.backtrace.first}"
               )
             end

data/lib/ddtrace/runtime/metrics.rb

@@ -63,7 +63,7 @@ module Datadog
       def try_flush
         yield
       rescue StandardError => e
-        Datadog::Tracer.log.error("Error while sending runtime metric. Cause: #{e.message}")
+        Datadog::Logger.log.error("Error while sending runtime metric. Cause: #{e.message}")
       end
 
       def default_metric_options

data/lib/ddtrace/sampler.rb

@@ -48,7 +48,7 @@ module Datadog
     #   sampled.
     def initialize(sample_rate = 1.0)
       unless sample_rate > 0.0 && sample_rate <= 1.0
-        Datadog::Tracer.log.error('sample rate is not between 0 and 1, disabling the sampler')
+        Datadog::Logger.log.error('sample rate is not between 0 and 1, disabling the sampler')
         sample_rate = 1.0
       end
 

data/lib/ddtrace/sampling/rule.rb

@@ -28,7 +28,7 @@ module Datadog
       def match?(span)
         @matcher.match?(span)
       rescue => e
-        Datadog::Tracer.log.error("Matcher failed. Cause: #{e.message} Source: #{e.backtrace.first}")
+        Datadog::Logger.log.error("Matcher failed. Cause: #{e.message} Source: #{e.backtrace.first}")
         nil
       end
 

data/lib/ddtrace/sampling/rule_sampler.rb

@@ -19,15 +19,15 @@ module Datadog
       attr_reader :rules, :rate_limiter, :default_sampler
 
       # @param rules [Array<Rule>] ordered list of rules to be applied to a span
-      # @param rate_limit [Float] number of traces per second, defaults to 100
+      # @param rate_limit [Float] number of traces per second, defaults to +100+
       # @param rate_limiter [RateLimiter] limiter applied after rule matching
       # @param default_sample_rate [Float] fallback sample rate when no rules apply to a span,
       #   between +[0,1]+, defaults to +1+
       # @param default_sampler [Sample] fallback strategy when no rules apply to a span
       def initialize(rules = [],
-                     rate_limit: nil,
+                     rate_limit: Datadog.configuration.sampling.rate_limit,
                      rate_limiter: nil,
-                     default_sample_rate: nil,
+                     default_sample_rate: Datadog.configuration.sampling.default_rate,
                      default_sampler: nil)
 
         @rules = rules
@@ -95,7 +95,7 @@ module Datadog
           set_limiter_metrics(span, rate_limiter.effective_rate)
         end
       rescue StandardError => e
-        Datadog::Tracer.log.error("Rule sampling failed. Cause: #{e.message} Source: #{e.backtrace.first}")
+        Datadog::Logger.log.error("Rule sampling failed. Cause: #{e.message} Source: #{e.backtrace.first}")
         yield(span)
       end
 

data/lib/ddtrace/span.rb

@@ -31,6 +31,9 @@ module Datadog
     # parsing 64-bit integers for distributed tracing since an upstream system may generate one
     EXTERNAL_MAX_ID = 2**64
 
+    # This limit is for numeric tags because uint64 could end up rounded.
+    NUMERIC_TAG_SIZE_RANGE = (-2**53..2**53)
+
     attr_accessor :name, :service, :resource, :span_type,
                   :start_time, :end_time,
                   :span_id, :trace_id, :parent_id,
@@ -80,9 +83,21 @@ module Datadog
     #
     #   span.set_tag('http.method', request.method)
     def set_tag(key, value = nil)
-      @meta[key] = value.to_s
+      # Keys must be unique between tags and metrics
+      @metrics.delete(key)
+
+      # NOTE: Adding numeric tags as metrics is stop-gap support
+      #       for numeric typed tags. Eventually they will become
+      #       tags again.
+      # Any numeric that is not an integer greater than max size is logged as a metric.
+      # Everything else gets logged as a tag.
+      if value.is_a?(Numeric) && !(value.is_a?(Integer) && !NUMERIC_TAG_SIZE_RANGE.cover?(value))
+        set_metric(key, value)
+      else
+        @meta[key] = value.to_s
+      end
     rescue StandardError => e
-      Datadog::Tracer.log.debug("Unable to set the tag #{key}, ignoring it. Caused by: #{e}")
+      Datadog::Logger.log.debug("Unable to set the tag #{key}, ignoring it. Caused by: #{e}")
     end
 
     # This method removes a tag for the given key.
@@ -92,17 +107,20 @@ module Datadog
 
     # Return the tag with the given key, nil if it doesn't exist.
     def get_tag(key)
-      @meta[key]
+      @meta[key] || @metrics[key]
     end
 
     # This method sets a tag with a floating point value for the given key. It acts
     # like `set_tag()` and it simply add a tag without further processing.
     def set_metric(key, value)
+      # Keys must be unique between tags and metrics
+      @meta.delete(key)
+
       # enforce that the value is a floating point number
       value = Float(value)
       @metrics[key] = value
     rescue StandardError => e
-      Datadog::Tracer.log.debug("Unable to set the metric #{key}, ignoring it. Caused by: #{e}")
+      Datadog::Logger.log.debug("Unable to set the metric #{key}, ignoring it. Caused by: #{e}")
     end
 
     # This method removes a metric for the given key. It acts like {#remove_tag}.
@@ -112,7 +130,7 @@ module Datadog
 
     # Return the metric with the given key, nil if it doesn't exist.
     def get_metric(key)
-      @metrics[key]
+      @metrics[key] || @meta[key]
     end
 
     # Mark the span with the given error.
@@ -154,7 +172,7 @@ module Datadog
         @context.close_span(self)
         @tracer.record(self)
       rescue StandardError => e
-        Datadog::Tracer.log.debug("error recording finished trace: #{e}")
+        Datadog::Logger.log.debug("error recording finished trace: #{e}")
         Diagnostics::Health.metrics.error_span_finish(1, tags: ["error:#{e.class.name}"])
       end
       self

data/lib/ddtrace/sync_writer.rb

@@ -27,7 +27,7 @@ module Datadog
     def write(trace, services = nil)
       unless services.nil?
         Datadog::Patcher.do_once('SyncWriter#write') do
-          Datadog::Tracer.log.warn(%(
+          Datadog::Logger.log.warn(%(
             write: Writing services has been deprecated and no longer need to be provided.
             write(traces, services) can be updted to write(traces)
           ))
@@ -38,7 +38,7 @@ module Datadog
         proc { flush_trace(trace) }
       )
     rescue => e
-      Tracer.log.debug(e)
+      Logger.log.debug(e)
     end
 
     private
@@ -49,8 +49,9 @@ module Datadog
 
     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)
+      transport.send_traces(processed_traces)
     end
 
     def inject_hostname!(trace)

data/lib/ddtrace/tracer.rb

@@ -5,8 +5,6 @@ require 'pathname'
 
 require 'ddtrace/span'
 require 'ddtrace/context'
-require 'ddtrace/context_flush'
-require 'ddtrace/provider'
 require 'ddtrace/logger'
 require 'ddtrace/writer'
 require 'ddtrace/sampler'
@@ -21,57 +19,17 @@ module Datadog
   # of these function calls and sub-requests would be encapsulated within a single trace.
   # rubocop:disable Metrics/ClassLength
   class Tracer
-    attr_reader :sampler, :tags, :provider
+    attr_reader :sampler, :tags, :provider, :context_flush
     attr_accessor :enabled, :writer
     attr_writer :default_service
 
     ALLOWED_SPAN_OPTIONS = [:service, :resource, :span_type].freeze
     DEFAULT_ON_ERROR = proc { |span, error| span.set_error(error) unless span.nil? }
 
-    # Global, memoized, lazy initialized instance of a logger that is used within the the Datadog
-    # namespace. This logger outputs to +STDOUT+ by default, and is considered thread-safe.
-    def self.log
-      unless defined? @logger
-        @logger = Datadog::Logger.new(STDOUT)
-        @logger.level = Logger::WARN
-      end
-      @logger
-    end
-
-    # Override the default logger with a custom one.
-    def self.log=(logger)
-      return unless logger
-      return unless logger.respond_to? :methods
-      return unless logger.respond_to? :error
-      if logger.respond_to? :methods
-        unimplemented = Logger.new(STDOUT).methods - logger.methods
-        unless unimplemented.empty?
-          logger.error("logger #{logger} does not implement #{unimplemented}")
-          return
-        end
-      end
-      @logger = logger
-    end
-
-    # Activate the debug mode providing more information related to tracer usage
-    # Default to Warn level unless using custom logger
-    def self.debug_logging=(value)
-      if value
-        log.level = Logger::DEBUG
-      elsif log.is_a?(Datadog::Logger)
-        log.level = Logger::WARN
-      end
-    end
-
-    # Return if the debug mode is activated or not
-    def self.debug_logging
-      log.level == Logger::DEBUG
-    end
-
     def services
       # Only log each deprecation warning once (safeguard against log spam)
       Datadog::Patcher.do_once('Tracer#set_service_info') do
-        Datadog::Tracer.log.warn('services: Usage of Tracer.services has been deprecated')
+        Datadog::Logger.log.warn('services: Usage of Tracer.services has been deprecated')
       end
 
       {}
@@ -90,8 +48,9 @@ module Datadog
     #   tracer.shutdown!
     #
     def shutdown!
-      return if !@enabled || @writer.worker.nil?
-      @writer.worker.stop
+      return unless @enabled
+
+      @writer.stop unless @writer.nil?
     end
 
     # Return the current active \Context for this traced execution. This method is
@@ -117,7 +76,11 @@ module Datadog
       @provider = options.fetch(:context_provider, Datadog::DefaultContextProvider.new)
       @provider ||= Datadog::DefaultContextProvider.new # @provider should never be nil
 
-      @context_flush = options[:partial_flush] ? Datadog::ContextFlush.new(options) : nil
+      @context_flush = if options[:partial_flush]
+                         Datadog::ContextFlush::Partial.new(options)
+                       else
+                         Datadog::ContextFlush::Finished.new
+                       end
 
       @mutex = Mutex.new
       @tags = {}
@@ -132,6 +95,7 @@ module Datadog
     # * +enabled+: set if the tracer submits or not spans to the trace agent
     # * +hostname+: change the location of the trace agent
     # * +port+: change the port of the trace agent
+    # * +partial_flush+: enable partial trace flushing
     #
     # For instance, if the trace agent runs in a different location, just:
     #
@@ -142,18 +106,17 @@ module Datadog
 
       # Those are rare "power-user" options.
       sampler = options.fetch(:sampler, nil)
-      max_spans_before_partial_flush = options.fetch(:max_spans_before_partial_flush, nil)
-      min_spans_before_partial_flush = options.fetch(:min_spans_before_partial_flush, nil)
-      partial_flush_timeout = options.fetch(:partial_flush_timeout, nil)
 
       @enabled = enabled unless enabled.nil?
       @sampler = sampler unless sampler.nil?
 
       configure_writer(options)
 
-      @context_flush = Datadog::ContextFlush.new(options) unless min_spans_before_partial_flush.nil? &&
-                                                                 max_spans_before_partial_flush.nil? &&
-                                                                 partial_flush_timeout.nil?
+      @context_flush = if options[:partial_flush]
+                         Datadog::ContextFlush::Partial.new(options)
+                       else
+                         Datadog::ContextFlush::Finished.new
+                       end
     end
 
     # Set the information about the given service. A valid example is:
@@ -164,7 +127,7 @@ module Datadog
     def set_service_info(service, app, app_type)
       # Only log each deprecation warning once (safeguard against log spam)
       Datadog::Patcher.do_once('Tracer#set_service_info') do
-        Datadog::Tracer.log.warn(%(
+        Datadog::Logger.log.warn(%(
           set_service_info: Usage of set_service_info has been deprecated,
           service information no longer needs to be reported to the trace agent.
         ))
@@ -179,7 +142,7 @@ module Datadog
       begin
         @default_service = File.basename($PROGRAM_NAME, '.*')
       rescue StandardError => e
-        Datadog::Tracer.log.error("unable to guess default service: #{e}")
+        Datadog::Logger.log.error("unable to guess default service: #{e}")
         @default_service = 'ruby'.freeze
       end
       @default_service
@@ -302,7 +265,7 @@ module Datadog
             span = start_span(name, options)
           # rubocop:disable Lint/UselessAssignment
           rescue StandardError => e
-            Datadog::Tracer.log.debug('Failed to start span: #{e}')
+            Datadog::Logger.log.debug('Failed to start span: #{e}')
           ensure
             return_value = yield(span)
           end
@@ -332,24 +295,20 @@ module Datadog
     def record(context)
       context = context.context if context.is_a?(Datadog::Span)
       return if context.nil?
-      trace, sampled = context.get
-
-      # If context flushing is configured...
-      if @context_flush
-        if sampled
-          if trace.nil? || trace.empty?
-            @context_flush.each_partial_trace(context) do |t|
-              write(t)
-            end
-          else
-            write(trace)
-          end
-        end
-      # Default behavior
-      else
-        ready = !trace.nil? && !trace.empty? && sampled
-        write(trace) if ready
-      end
+
+      record_context(context)
+    end
+
+    # Consume trace from +context+, according to +@context_flush+
+    # criteria.
+    #
+    # \ContextFlush#consume! can return nil or an empty list if the
+    # trace is not available to flush or if the trace has not been
+    # chosen to be sampled.
+    def record_context(context)
+      trace = @context_flush.consume!(context)
+
+      write(trace) if trace && !trace.empty?
     end
 
     # Return the current active span or +nil+.
@@ -372,11 +331,11 @@ module Datadog
     def write(trace)
       return if @writer.nil? || !@enabled
 
-      if Datadog::Tracer.debug_logging
-        Datadog::Tracer.log.debug("Writing #{trace.length} spans (enabled: #{@enabled})")
+      if Datadog::Logger.debug_logging
+        Datadog::Logger.log.debug("Writing #{trace.length} spans (enabled: #{@enabled})")
         str = String.new('')
         PP.pp(trace, str)
-        Datadog::Tracer.log.debug(str)
+        Datadog::Logger.log.debug(str)
       end
 
       @writer.write(trace)
@@ -461,6 +420,7 @@ module Datadog
       :configure_writer,
       :deactivate_priority_sampling!,
       :guess_context_and_parent,
+      :record_context,
       :write
   end
 end