ddtrace 0.7.2 → 0.8.0

data/lib/ddtrace/context.rb

@@ -0,0 +1,145 @@
+require 'thread'
+
+module Datadog
+  # \Context is used to keep track of a hierarchy of spans for the current
+  # execution flow. During each logical execution, the same \Context is
+  # used to represent a single logical trace, even if the trace is built
+  # asynchronously.
+  #
+  # A single code execution may use multiple \Context if part of the execution
+  # must not be related to the current tracing. As example, a delayed job may
+  # compose a standalone trace instead of being related to the same trace that
+  # generates the job itself. On the other hand, if it's part of the same
+  # \Context, it will be related to the original trace.
+  #
+  # This data structure is thread-safe.
+  class Context
+    # Initialize a new thread-safe \Context.
+    def initialize
+      @mutex = Mutex.new
+      reset
+    end
+
+    def reset
+      @trace = []
+      @sampled = false
+      @finished_spans = 0
+      @current_span = nil
+    end
+
+    # Return the last active span that corresponds to the last inserted
+    # item in the trace list. This cannot be considered as the current active
+    # span in asynchronous environments, because some spans can be closed
+    # earlier while child spans still need to finish their traced execution.
+    def current_span
+      @mutex.synchronize do
+        return @current_span
+      end
+    end
+
+    # Add a span to the context trace list, keeping it as the last active span.
+    def add_span(span)
+      @mutex.synchronize do
+        @current_span = span
+        @sampled = span.sampled
+        @trace << span
+        span.context = self
+      end
+    end
+
+    # Mark a span as a finished, increasing the internal counter to prevent
+    # cycles inside _trace list.
+    def close_span(span)
+      @mutex.synchronize do
+        @finished_spans += 1
+        # Current span is only meaningful for linear tree-like traces,
+        # in other cases, this is just broken and one should rely
+        # on per-instrumentation code to retrieve handle parent/child relations.
+        @current_span = span.parent
+        return if span.tracer.nil?
+        return unless Datadog::Tracer.debug_logging
+        if span.parent.nil? && !check_finished_spans
+          opened_spans = @trace.length - @finished_spans
+          Datadog::Tracer.log.debug("root span #{span.name} closed but has #{opened_spans} unfinished spans:")
+          @trace.each do |s|
+            Datadog::Tracer.log.debug("unfinished span: #{s}") unless s.finished?
+          end
+        end
+      end
+    end
+
+    # Returns if the trace for the current Context is finished or not.
+    # Low-level internal function, not thread-safe.
+    def check_finished_spans
+      @finished_spans > 0 && @trace.length == @finished_spans
+    end
+
+    # Returns if the trace for the current Context is finished or not. A \Context
+    # is considered finished if all spans in this context are finished.
+    def finished?
+      @mutex.synchronize do
+        return check_finished_spans
+      end
+    end
+
+    # Returns true if the context is sampled, that is, if it should be kept
+    # and sent to the trace agent.
+    def sampled?
+      @mutex.synchronize do
+        return @sampled
+      end
+    end
+
+    # Returns both the trace list generated in the current context and
+    # if the context is sampled or not. It returns nil, nil if the ``Context`` is
+    # not finished. If a trace is returned, the \Context will be reset so that it
+    # can be re-used immediately.
+    #
+    # This operation is thread-safe.
+    def get
+      @mutex.synchronize do
+        return nil, nil unless check_finished_spans
+
+        trace = @trace
+        sampled = @sampled
+        reset
+        return trace, sampled
+      end
+    end
+
+    # Return a string representation of the context.
+    def to_s
+      @mutex.synchronize do
+        # rubocop:disable Metrics/LineLength
+        "Context(trace.length:#{@trace.length},sampled:#{@sampled},finished_spans:#{@finished_spans},current_span:#{@current_span})"
+      end
+    end
+
+    private :reset
+    private :check_finished_spans
+  end
+
+  # ThreadLocalContext can be used as a tracer global reference to create
+  # a different \Context for each thread. In synchronous tracer, this
+  # is required to prevent multiple threads sharing the same \Context
+  # in different executions.
+  class ThreadLocalContext
+    # ThreadLocalContext can be used as a tracer global reference to create
+    # a different \Context for each thread. In synchronous tracer, this
+    # is required to prevent multiple threads sharing the same \Context
+    # in different executions.
+    def initialize
+      self.local = Datadog::Context.new
+    end
+
+    # Override the thread-local context with a new context.
+    def local=(ctx)
+      Thread.current[:datadog_context] = ctx
+    end
+
+    # Return the thread-local context.
+    def local
+      Thread.current[:datadog_context] ||= Datadog::Context.new
+    end
+  end
+end

data/lib/ddtrace/contrib/active_record/patcher.rb

@@ -23,7 +23,7 @@ module Datadog
               patch_active_record()
 
               @patched = true
-            rescue => e
+            rescue StandardError => e
               Datadog::Tracer.log.error("Unable to apply Active Record integration: #{e}")
             end
           end
@@ -84,7 +84,7 @@ module Datadog
           span.span_type = Datadog::Ext::SQL::TYPE
           span.set_tag('active_record.db.vendor', adapter_name)
           span.start_time = start
-          span.finish_at(finish)
+          span.finish(finish)
         rescue StandardError => e
           Datadog::Tracer.log.error(e.message)
         end

data/lib/ddtrace/contrib/elasticsearch/patcher.rb

@@ -90,6 +90,7 @@ module Datadog
                 ensure
                   # the call is still executed
                   response = perform_request_without_datadog(*args)
+                  span.set_tag('http.status_code', response.status)
                 end
               end
               response

data/lib/ddtrace/contrib/grape/endpoint.rb

@@ -79,12 +79,12 @@ module Datadog
             # catch thrown exceptions
             span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
 
-            # ovverride the current span with this notification values
+            # override the current span with this notification values
             span.set_tag('grape.route.endpoint', api_view)
             span.set_tag('grape.route.path', path)
           ensure
             span.start_time = start
-            span.finish_at(finish)
+            span.finish(finish)
           end
         rescue StandardError => e
           Datadog::Tracer.log.error(e.message)
@@ -125,7 +125,7 @@ module Datadog
             span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
           ensure
             span.start_time = start
-            span.finish_at(finish)
+            span.finish(finish)
           end
         rescue StandardError => e
           Datadog::Tracer.log.error(e.message)
@@ -153,7 +153,7 @@ module Datadog
             span.set_tag('grape.filter.type', type.to_s)
           ensure
             span.start_time = start
-            span.finish_at(finish)
+            span.finish(finish)
           end
         rescue StandardError => e
           Datadog::Tracer.log.error(e.message)

data/lib/ddtrace/contrib/http/patcher.rb

@@ -12,6 +12,12 @@ module Datadog
       APP = 'net/http'.freeze
       SERVICE = 'net/http'.freeze
 
+      @distributed_tracing_enabled = false
+
+      class << self
+        attr_accessor :distributed_tracing_enabled
+      end
+
       module_function
 
       def should_skip_tracing?(req, address, port, transport, pin)
@@ -35,6 +41,13 @@ module Datadog
         false
       end
 
+      def should_skip_distributed_tracing?(pin)
+        unless pin.config.nil?
+          return !pin.config.fetch(:distributed_tracing_enabled, @distributed_tracing_enabled)
+        end
+        !@distributed_tracing_enabled
+      end
+
       # Patcher enables patching of 'net/http' module.
       # This is used in monkey.rb to automatically apply patches
       module Patcher
@@ -52,6 +65,7 @@ module Datadog
               require 'ddtrace/ext/app_types'
               require 'ddtrace/ext/http'
               require 'ddtrace/ext/net'
+              require 'ddtrace/ext/distributed'
 
               patch_http()
 
@@ -69,6 +83,8 @@ module Datadog
         end
 
         # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/BlockLength
+        # rubocop:disable Metrics/AbcSize
         def patch_http
           ::Net::HTTP.class_eval do
             alias_method :initialize_without_datadog, :initialize
@@ -84,6 +100,7 @@ module Datadog
 
             alias_method :request_without_datadog, :request
             remove_method :request
+
             def request(req, body = nil, &block) # :yield: +response+
               pin = Datadog::Pin.get_from(self)
               return request_without_datadog(req, body, &block) unless pin && pin.tracer
@@ -93,15 +110,25 @@ module Datadog
                 Datadog::Contrib::HTTP.should_skip_tracing?(req, @address, @port, transport, pin)
 
               pin.tracer.trace(NAME) do |span|
-                span.service = pin.service
-                span.span_type = Datadog::Ext::HTTP::TYPE
-
-                span.resource = req.method
-                # Using the method as a resource, as URL/path can trigger
-                # a possibly infinite number of resources.
-                span.set_tag(Datadog::Ext::HTTP::URL, req.path)
-                span.set_tag(Datadog::Ext::HTTP::METHOD, req.method)
-                response = request_without_datadog(req, body, &block)
+                begin
+                  span.service = pin.service
+                  span.span_type = Datadog::Ext::HTTP::TYPE
+
+                  span.resource = req.method
+                  # Using the method as a resource, as URL/path can trigger
+                  # a possibly infinite number of resources.
+                  span.set_tag(Datadog::Ext::HTTP::URL, req.path)
+                  span.set_tag(Datadog::Ext::HTTP::METHOD, req.method)
+
+                  unless Datadog::Contrib::HTTP.should_skip_distributed_tracing?(pin)
+                    req.add_field(Datadog::Ext::DistributedTracing::HTTP_HEADER_TRACE_ID, span.trace_id)
+                    req.add_field(Datadog::Ext::DistributedTracing::HTTP_HEADER_PARENT_ID, span.span_id)
+                  end
+                rescue StandardError => e
+                  Datadog::Tracer.log.error("error preparing span for http request: #{e}")
+                ensure
+                  response = request_without_datadog(req, body, &block)
+                end
                 span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, response.code)
                 if req.respond_to?(:uri) && req.uri
                   span.set_tag(Datadog::Ext::NET::TARGET_HOST, req.uri.host)

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

@@ -1,11 +1,21 @@
 require 'ddtrace/ext/app_types'
 require 'ddtrace/ext/http'
+require 'ddtrace/distributed'
 
 module Datadog
   module Contrib
     # Rack module includes middlewares that are required to trace any framework
     # and application built on top of Rack.
     module Rack
+      # RACK headers to test when doing distributed tracing.
+      # They are slightly different from real headers as Rack uppercases everything
+
+      # Header used to transmit the trace ID.
+      HTTP_HEADER_TRACE_ID = 'HTTP_X_DATADOG_TRACE_ID'.freeze
+
+      # Header used to transmit the parent ID.
+      HTTP_HEADER_PARENT_ID = 'HTTP_X_DATADOG_PARENT_ID'.freeze
+
       # TraceMiddleware ensures that the Rack Request is properly traced
       # from the beginning to the end. The middleware adds the request span
       # in the Rack environment so that it can be retrieved by the underlying
@@ -14,13 +24,15 @@ module Datadog
       class TraceMiddleware
         DEFAULT_CONFIG = {
           tracer: Datadog.tracer,
-          default_service: 'rack'
+          default_service: 'rack',
+          distributed_tracing_enabled: false
         }.freeze
 
         def initialize(app, options = {})
           # update options with our configuration, unless it's already available
-          options[:tracer] ||= DEFAULT_CONFIG[:tracer]
-          options[:default_service] ||= DEFAULT_CONFIG[:default_service]
+          [:tracer, :default_service, :distributed_tracing_enabled].each do |k|
+            options[k] ||= DEFAULT_CONFIG[k]
+          end
 
           @app = app
           @options = options
@@ -33,6 +45,7 @@ module Datadog
           # retrieve the current tracer and service
           @tracer = @options.fetch(:tracer)
           @service = @options.fetch(:default_service)
+          @distributed_tracing_enabled = @options.fetch(:distributed_tracing_enabled)
 
           # configure the Rack service
           @tracer.set_service_info(
@@ -42,23 +55,45 @@ module Datadog
           )
         end
 
+        # rubocop:disable Metrics/MethodLength
         def call(env)
           # configure the Rack middleware once
           configure()
 
-          # start a new request span and attach it to the current Rack environment;
-          # we must ensure that the span `resource` is set later
-          request_span = @tracer.trace(
-            'rack.request',
+          trace_options = {
             service: @service,
             resource: nil,
             span_type: Datadog::Ext::HTTP::TYPE
-          )
+          }
+
+          # start a new request span and attach it to the current Rack environment;
+          # we must ensure that the span `resource` is set later
+          request_span = @tracer.trace('rack.request', trace_options)
+
+          if @distributed_tracing_enabled
+            # Merge distributed trace ids if present
+            #
+            # Use integer values for tests, as it will catch both
+            # a non-existing header or a badly formed one.
+            trace_id, parent_id = Datadog::Distributed.parse_trace_headers(
+              env[Datadog::Contrib::Rack::HTTP_HEADER_TRACE_ID],
+              env[Datadog::Contrib::Rack::HTTP_HEADER_PARENT_ID]
+            )
+            request_span.trace_id = trace_id unless trace_id.nil?
+            request_span.parent_id = parent_id unless parent_id.nil?
+          end
+
           env[:datadog_rack_request_span] = request_span
 
           # call the rest of the stack
           status, headers, response = @app.call(env)
-        rescue StandardError => e
+        # 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.
+        rescue Exception => e
           # catch exceptions that may be raised in the middleware chain
           # Note: if a middleware catches an Exception without re raising,
           # the Exception cannot be recorded here
@@ -79,9 +114,15 @@ module Datadog
           # be set in another level but if they're missing, reasonable defaults
           # are used.
           request_span.resource = "#{env['REQUEST_METHOD']} #{status}".strip unless request_span.resource
-          request_span.set_tag('http.method', env['REQUEST_METHOD']) if request_span.get_tag('http.method').nil?
-          request_span.set_tag('http.url', url) if request_span.get_tag('http.url').nil?
-          request_span.set_tag('http.status_code', status) if request_span.get_tag('http.status_code').nil? && status
+          if request_span.get_tag(Datadog::Ext::HTTP::METHOD).nil?
+            request_span.set_tag(Datadog::Ext::HTTP::METHOD, env['REQUEST_METHOD'])
+          end
+          if request_span.get_tag(Datadog::Ext::HTTP::URL).nil?
+            request_span.set_tag(Datadog::Ext::HTTP::URL, url)
+          end
+          if request_span.get_tag(Datadog::Ext::HTTP::STATUS_CODE).nil? && status
+            request_span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, status)
+          end
 
           # detect if the status code is a 5xx and flag the request span as an error
           # unless it has been already set by the underlying framework

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

@@ -33,6 +33,7 @@ module Datadog
           Datadog::Tracer.log.error(e.message)
         end
 
+        # rubocop:disable Metrics/MethodLength
         def self.process_action(_name, start, finish, _id, payload)
           return unless Thread.current[KEY]
           Thread.current[KEY] = false
@@ -63,14 +64,22 @@ module Datadog
               end
             else
               error = payload[:exception]
-              span.status = 1
-              span.set_tag(Datadog::Ext::Errors::TYPE, error[0])
-              span.set_tag(Datadog::Ext::Errors::MSG, error[1])
-              span.set_tag(Datadog::Ext::Errors::STACK, caller().join("\n"))
+              if defined?(::ActionDispatch::ExceptionWrapper)
+                status = ::ActionDispatch::ExceptionWrapper.status_code_for_exception(error[0])
+                status = status ? status.to_s : '?'
+              else
+                status = '500'
+              end
+              if status.starts_with?('5')
+                span.status = 1
+                span.set_tag(Datadog::Ext::Errors::TYPE, error[0])
+                span.set_tag(Datadog::Ext::Errors::MSG, error[1])
+                span.set_tag(Datadog::Ext::Errors::STACK, caller().join("\n"))
+              end
             end
           ensure
             span.start_time = start
-            span.finish_at(finish)
+            span.finish(finish)
           end
         rescue StandardError => e
           Datadog::Tracer.log.error(e.message)

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

@@ -7,7 +7,7 @@ module Datadog
       module ActionView
         def self.instrument
           # patch Rails core components
-          Datadog::RailsPatcher.patch_renderer()
+          Datadog::RailsRendererPatcher.patch_renderer()
 
           # subscribe when the template rendering starts
           ::ActiveSupport::Notifications.subscribe('start_render_template.action_view') do |*args|
@@ -83,7 +83,7 @@ module Datadog
             end
           ensure
             span.start_time = start
-            span.finish_at(finish)
+            span.finish(finish)
           end
         rescue StandardError => e
           Datadog::Tracer.log.error(e.message)
@@ -111,7 +111,7 @@ module Datadog
             end
           ensure
             span.start_time = start
-            span.finish_at(finish)
+            span.finish(finish)
           end
         rescue StandardError => e
           Datadog::Tracer.log.error(e.message)