ddtrace 0.13.0 → 0.47.0

data/lib/ddtrace/sync_writer.rb

@@ -1,36 +1,67 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/runtime/socket'
+require 'ddtrace/runtime/metrics'
+require 'ddtrace/utils/only_once'
+
 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 :transport
+    DEPRECATION_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
+    attr_reader \
+      :priority_sampler,
+      :transport
 
     def initialize(options = {})
       @transport = options.fetch(:transport) do
-        HTTPTransport.new(Writer::HOSTNAME, Writer::PORT)
+        transport_options = options.fetch(:transport_options, {})
+        Transport::HTTP.default(transport_options)
       end
-    end
 
-    def write(trace, services)
-      perform_concurrently(
-        proc { flush_services(services) },
-        proc { flush_trace(trace) }
-      )
-    rescue => e
-      Tracer.log.debug(e)
+      @priority_sampler = options.fetch(:priority_sampler, nil)
     end
 
-    private
+    def write(trace, services = nil)
+      unless services.nil?
+        DEPRECATION_WARN_ONLY_ONCE.run do
+          Datadog.logger.warn(%(
+            write: Writing services has been deprecated and no longer need to be provided.
+            write(traces, services) can be updated to write(traces)
+          ))
+        end
+      end
 
-    def perform_concurrently(*tasks)
-      tasks.map { |task| Thread.new(&task) }.each(&:join)
+      flush_trace(trace)
+    rescue => e
+      Datadog.logger.debug(e)
     end
 
-    def flush_services(services)
-      transport.send(:services, services)
+    # Added for interface completeness
+    def stop
+      # No cleanup to do for the SyncWriter
+      true
     end
 
+    private
+
     def flush_trace(trace)
       processed_traces = Pipeline.process!([trace])
-      transport.send(:traces, processed_traces)
+      return if processed_traces.empty?
+
+      inject_hostname!(processed_traces.first) if Datadog.configuration.report_hostname
+      transport.send_traces(processed_traces)
+    end
+
+    def inject_hostname!(trace)
+      unless trace.first.nil?
+        hostname = Datadog::Runtime::Socket.hostname
+        trace.first.set_tag(Ext::NET::TAG_HOSTNAME, hostname) unless hostname.nil? || hostname.empty?
+      end
     end
   end
 end

data/lib/ddtrace/tracer.rb

@@ -1,15 +1,16 @@
-require 'pp'
-require 'thread'
 require 'logger'
 require 'pathname'
 
+require 'ddtrace/environment'
 require 'ddtrace/span'
 require 'ddtrace/context'
-require 'ddtrace/context_flush'
-require 'ddtrace/provider'
 require 'ddtrace/logger'
 require 'ddtrace/writer'
+require 'ddtrace/runtime/identity'
 require 'ddtrace/sampler'
+require 'ddtrace/sampling'
+require 'ddtrace/correlation'
+require 'ddtrace/utils/only_once'
 
 # \Datadog global namespace that includes all tracing functionality for Tracer and Span classes.
 module Datadog
@@ -19,45 +20,22 @@ 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, :services, :tags, :provider
+    SERVICES_DEPRECATION_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+    SET_SERVICE_INFO_DEPRECATION_WARN_ONLY_ONCE = Datadog::Utils::OnlyOnce.new
+
+    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
+    def services
+      SERVICES_DEPRECATION_WARN_ONLY_ONCE.run do
+        Datadog.logger.warn('services: Usage of Tracer.services has been deprecated')
       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
-    def self.debug_logging=(value)
-      log.level = value ? Logger::DEBUG : Logger::WARN
-    end
-
-    # Return if the debug mode is activated or not
-    def self.debug_logging
-      log.level == Logger::DEBUG
+      {}
     end
 
     # Shorthand that calls the `shutdown!` method of a registered worker.
@@ -73,8 +51,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
@@ -83,8 +62,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
@@ -93,18 +72,26 @@ module Datadog
     # * +enabled+: set if the tracer submits or not spans to the local agent. It's enabled
     #   by default.
     def initialize(options = {})
+      # Configurable options
+      @context_flush = if options[:partial_flush]
+                         Datadog::ContextFlush::Partial.new(options)
+                       else
+                         Datadog::ContextFlush::Finished.new
+                       end
+
+      @default_service = options[:default_service]
       @enabled = options.fetch(:enabled, true)
-      @writer = options.fetch(:writer, Datadog::Writer.new)
+      @provider = options.fetch(:context_provider, Datadog::DefaultContextProvider.new)
       @sampler = options.fetch(:sampler, Datadog::AllSampler.new)
+      @tags = options.fetch(:tags, {})
+      @writer = options.fetch(:writer, Datadog::Writer.new)
 
-      @provider = options.fetch(:context_provider, Datadog::DefaultContextProvider.new)
+      # Instance variables
+      @mutex = Mutex.new
       @provider ||= Datadog::DefaultContextProvider.new # @provider should never be nil
 
-      @context_flush = options[:partial_flush] ? Datadog::ContextFlush.new(options) : nil
-
-      @mutex = Mutex.new
-      @services = {}
-      @tags = {}
+      # Enable priority sampling by default
+      activate_priority_sampling!(@sampler)
     end
 
     # Updates the current \Tracer instance, so that the tracer can be configured after the
@@ -113,6 +100,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:
     #
@@ -120,43 +108,36 @@ module Datadog
     #
     def configure(options = {})
       enabled = options.fetch(:enabled, nil)
-      hostname = options.fetch(:hostname, nil)
-      port = options.fetch(:port, nil)
 
       # Those are rare "power-user" options.
       sampler = options.fetch(:sampler, nil)
-      priority_sampling = options[:priority_sampling]
-      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?
 
-      if priority_sampling
-        @sampler = PrioritySampler.new(base_sampler: @sampler)
-        @writer = Writer.new(priority_sampler: @sampler)
-      end
-
-      @writer.transport.hostname = hostname unless hostname.nil?
-      @writer.transport.port = port unless port.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?
+      if options.key?(:partial_flush)
+        @context_flush = if options[:partial_flush]
+                           Datadog::ContextFlush::Partial.new(options)
+                         else
+                           Datadog::ContextFlush::Finished.new
+                         end
+      end
     end
 
     # Set the information about the given service. A valid example is:
     #
     #   tracer.set_service_info('web-application', 'rails', 'web')
+    #
+    # set_service_info is deprecated, no service information needs to be tracked
     def set_service_info(service, app, app_type)
-      @services[service] = {
-        'app' => app,
-        'app_type' => app_type
-      }
-
-      return unless Datadog::Tracer.debug_logging
-      Datadog::Tracer.log.debug("set_service_info: service: #{service} app: #{app} type: #{app_type}")
+      SET_SERVICE_INFO_DEPRECATION_WARN_ONLY_ONCE.run do
+        Datadog.logger.warn(%(
+          set_service_info: Usage of set_service_info has been deprecated,
+          service information no longer needs to be reported to the trace agent.
+        ))
+      end
     end
 
     # A default value for service. One should really override this one
@@ -164,10 +145,11 @@ 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
-        Datadog::Tracer.log.error("unable to guess default service: #{e}")
+        Datadog.logger.error("unable to guess default service: #{e}")
         @default_service = 'ruby'.freeze
       end
       @default_service
@@ -179,7 +161,8 @@ module Datadog
     #
     #   tracer.set_tags('env' => 'prod', 'component' => 'core')
     def set_tags(tags)
-      @tags.update(tags)
+      string_tags = Hash[tags.collect { |k, v| [k.to_s, v] }]
+      @tags = @tags.merge(string_tags)
     end
 
     # Guess context and parent from child_of entry.
@@ -205,35 +188,36 @@ module Datadog
     # * +start_time+: when the span actually starts (defaults to \now)
     # * +tags+: extra tags which should be added to the span.
     def start_span(name, options = {})
-      start_time = options.fetch(:start_time, Time.now.utc)
-
+      start_time = options[:start_time]
       tags = options.fetch(:tags, {})
 
-      opts = options.select do |k, _v|
+      span_options = options.select do |k, _v|
         # Filter options, we want no side effects with unexpected args.
-        # Plus, this documents the code (Ruby 2 named args would be better but we're Ruby 1.9 compatible)
         ALLOWED_SPAN_OPTIONS.include?(k)
       end
 
       ctx, parent = guess_context_and_parent(options[:child_of])
-      opts[:context] = ctx unless ctx.nil?
+      span_options[:context] = ctx unless ctx.nil?
 
-      span = Span.new(self, name, opts)
+      span = Span.new(self, name, span_options)
       if parent.nil?
         # root span
-        @sampler.sample(span)
+        @sampler.sample!(span)
         span.set_tag('system.pid', Process.pid)
-        if ctx && ctx.trace_id && ctx.span_id
+        span.set_tag(Datadog::Ext::Runtime::TAG_ID, Datadog::Runtime::Identity.id)
+
+        if ctx && ctx.trace_id
           span.trace_id = ctx.trace_id
-          span.parent_id = ctx.span_id
+          span.parent_id = ctx.span_id unless ctx.span_id.nil?
         end
       else
         # child span
         span.parent = parent # sets service, trace_id, parent_id, sampled
       end
-      tags.each { |k, v| span.set_tag(k, v) } unless tags.empty?
-      @tags.each { |k, v| span.set_tag(k, v) } unless @tags.empty?
-      span.start_time = start_time
+
+      span.set_tags(@tags) unless @tags.empty?
+      span.set_tags(tags) unless tags.empty?
+      span.start(start_time)
 
       # this could at some point be optional (start_active_span vs start_manual_span)
       ctx.add_span(span) unless ctx.nil?
@@ -274,31 +258,60 @@ module Datadog
     # * +service+: the service name for this span
     # * +resource+: the resource this span refers, or \name if it's missing
     # * +span_type+: the type of the span (such as \http, \db and so on)
+    # * +child_of+: a \Span or a \Context instance representing the parent for this span.
+    #   If not set, defaults to Tracer.call_context
     # * +tags+: extra tags which should be added to the span.
     def trace(name, options = {})
-      options[:child_of] = call_context
-      span = start_span(name, options)
+      options[:child_of] ||= call_context
 
       # call the finish only if a block is given; this ensures
       # that a call to tracer.trace() without a block, returns
       # a span that should be manually finished.
       if block_given?
+        span = nil
+        return_value = nil
+
         begin
-          yield(span)
+          begin
+            span = start_span(name, options)
+          rescue StandardError => e
+            Datadog.logger.debug("Failed to start span: #{e}")
+          ensure
+            # We should yield to the provided block when possible, as this
+            # block is application code that we don't want to hinder. We call:
+            # * `yield(span)` during normal execution.
+            # * `yield(nil)` if `start_span` fails with a runtime error.
+            # * We don't yield during a fatal error, as the application is likely trying to
+            #   end its execution (either due to a system error or graceful shutdown).
+            return_value = yield(span) if span || e.is_a?(StandardError)
+          end
         # rubocop:disable Lint/RescueException
         # Here we really want to catch *any* exception, not only StandardError,
         # as we really have no clue of what is in the block,
         # 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
-          span.set_error(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()
+          span.finish unless span.nil?
         end
+
+        return_value
       else
-        span
+        start_span(name, options)
       end
     end
 
@@ -309,47 +322,132 @@ 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 @enabled && trace && !trace.empty?
     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(key = nil)
+      call_context(key).current_root_span
+    end
+
+    # Return a CorrelationIdentifier for active span
+    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
     # sending queue.
     def write(trace)
-      return if @writer.nil? || !@enabled
+      return if @writer.nil?
 
-      if Datadog::Tracer.debug_logging
-        Datadog::Tracer.log.debug("Writing #{trace.length} spans (enabled: #{@enabled})")
+      if Datadog.configuration.diagnostics.debug
+        Datadog.logger.debug("Writing #{trace.length} spans (enabled: #{@enabled})")
         str = String.new('')
         PP.pp(trace, str)
-        Datadog::Tracer.log.debug(str)
+        Datadog.logger.debug(str)
+      end
+
+      @writer.write(trace)
+    end
+
+    # TODO: Move this kind of configuration building out of the tracer.
+    #       Tracer should not have this kind of knowledge of writer.
+    # rubocop:disable Metrics/PerceivedComplexity
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength
+    def configure_writer(options = {})
+      hostname = options.fetch(:hostname, nil)
+      port = options.fetch(:port, nil)
+      sampler = options.fetch(:sampler, nil)
+      priority_sampling = options.fetch(:priority_sampling, nil)
+      writer = options.fetch(:writer, nil)
+      transport_options = options.fetch(:transport_options, {}).dup
+
+      # Compile writer options
+      writer_options = options.fetch(:writer_options, {}).dup
+      rebuild_writer = !writer_options.empty?
+
+      # Re-build the sampler and writer if priority sampling is enabled,
+      # but neither are configured. Verify the sampler isn't already a
+      # priority sampler too, so we don't wrap one with another.
+      if options.key?(:writer)
+        if writer.priority_sampler.nil?
+          deactivate_priority_sampling!(sampler)
+        else
+          activate_priority_sampling!(writer.priority_sampler)
+        end
+      elsif priority_sampling != false && !@sampler.is_a?(PrioritySampler)
+        writer_options[:priority_sampler] = activate_priority_sampling!(@sampler)
+        rebuild_writer = true
+      elsif priority_sampling == false
+        deactivate_priority_sampling!(sampler)
+        rebuild_writer = true
+      elsif @sampler.is_a?(PrioritySampler)
+        # Make sure to add sampler to options if transport is rebuilt.
+        writer_options[:priority_sampler] = @sampler
+      end
+
+      # Apply options to transport
+      if transport_options.is_a?(Proc)
+        transport_options = { on_build: transport_options }
+        rebuild_writer = true
       end
 
-      @writer.write(trace, @services)
-      @services = {}
+      if hostname || port
+        transport_options[:hostname] = hostname unless hostname.nil?
+        transport_options[:port] = port unless port.nil?
+        rebuild_writer = true
+      end
+
+      writer_options[:transport_options] = transport_options
+
+      if rebuild_writer || writer
+        # Make sure old writer is shut down before throwing away.
+        # Don't want additional threads running...
+        @writer.stop unless writer.nil?
+        @writer = writer || Writer.new(writer_options)
+      end
+    end
+
+    def activate_priority_sampling!(base_sampler = nil)
+      @sampler = if base_sampler.is_a?(PrioritySampler)
+                   base_sampler
+                 else
+                   PrioritySampler.new(
+                     base_sampler: base_sampler,
+                     post_sampler: Sampling::RuleSampler.new
+                   )
+                 end
+    end
+
+    def deactivate_priority_sampling!(base_sampler = nil)
+      @sampler = base_sampler || Datadog::AllSampler.new if @sampler.is_a?(PrioritySampler)
     end
 
-    private :write, :guess_context_and_parent
+    private \
+      :activate_priority_sampling!,
+      :configure_writer,
+      :deactivate_priority_sampling!,
+      :guess_context_and_parent,
+      :record_context,
+      :write
   end
 end