ddtrace 0.12.1 → 0.13.0.beta1

data/lib/ddtrace/contrib/racecar/events.rb

@@ -0,0 +1,30 @@
+require 'ddtrace/contrib/racecar/events/batch'
+require 'ddtrace/contrib/racecar/events/message'
+
+module Datadog
+  module Contrib
+    module Racecar
+      # Defines collection of instrumented Racecar events
+      module Events
+        ALL = [
+          Events::Batch,
+          Events::Message
+        ].freeze
+
+        module_function
+
+        def all
+          self::ALL
+        end
+
+        def subscriptions
+          all.collect(&:subscriptions).collect(&:to_a).flatten
+        end
+
+        def subscribe!
+          all.each(&:subscribe!)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/racecar/events/batch.rb

@@ -0,0 +1,27 @@
+require 'ddtrace/contrib/racecar/event'
+
+module Datadog
+  module Contrib
+    module Racecar
+      module Events
+        # Defines instrumentation for process_batch.racecar event
+        module Batch
+          include Racecar::Event
+
+          EVENT_NAME = 'process_batch.racecar'.freeze
+          SPAN_NAME = 'racecar.batch'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            self::SPAN_NAME
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/racecar/events/message.rb

@@ -0,0 +1,27 @@
+require 'ddtrace/contrib/racecar/event'
+
+module Datadog
+  module Contrib
+    module Racecar
+      module Events
+        # Defines instrumentation for process_message.racecar event
+        module Message
+          include Racecar::Event
+
+          EVENT_NAME = 'process_message.racecar'.freeze
+          SPAN_NAME = 'racecar.message'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            self::SPAN_NAME
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,5 +1,5 @@
 require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/active_support/notifications/subscriber'
+require 'ddtrace/contrib/racecar/events'
 
 module Datadog
   module Contrib
@@ -7,50 +7,26 @@ module Datadog
       # Provides instrumentation for `racecar` through ActiveSupport instrumentation signals
       module Patcher
         include Base
-        include ActiveSupport::Notifications::Subscriber
 
-        NAME_MESSAGE = 'racecar.message'.freeze
-        NAME_BATCH = 'racecar.batch'.freeze
         register_as :racecar
         option :service_name, default: 'racecar'
         option :tracer, default: Datadog.tracer do |value|
           (value || Datadog.tracer).tap do |v|
             # Make sure to update tracers of all subscriptions
-            subscriptions.each do |subscription|
+            Events.subscriptions.each do |subscription|
               subscription.tracer = v
             end
           end
         end
 
-        on_subscribe do
-          # Subscribe to single messages
-          subscription(
-            self::NAME_MESSAGE,
-            { service: configuration[:service_name] },
-            configuration[:tracer],
-            &method(:process)
-          ).tap do |subscription|
-            subscription.before_trace { ensure_clean_context! }
-            subscription.subscribe('process_message.racecar')
-          end
-
-          # Subscribe to batch messages
-          subscription(
-            self::NAME_BATCH,
-            { service: configuration[:service_name] },
-            configuration[:tracer],
-            &method(:process)
-          ).tap do |subscription|
-            subscription.before_trace { ensure_clean_context! }
-            subscription.subscribe('process_batch.racecar')
-          end
-        end
-
         class << self
           def patch
             return patched? if patched? || !compatible?
 
-            subscribe!
+            # Subscribe to Racecar events
+            Events.subscribe!
+
+            # Set service info
             configuration[:tracer].set_service_info(
               configuration[:service_name],
               'racecar',
@@ -65,19 +41,6 @@ module Datadog
             @patched = false
           end
 
-          def process(span, event, _, payload)
-            span.service = configuration[:service_name]
-            span.resource = payload[:consumer_class]
-
-            span.set_tag('kafka.topic', payload[:topic])
-            span.set_tag('kafka.consumer', payload[:consumer_class])
-            span.set_tag('kafka.partition', payload[:partition])
-            span.set_tag('kafka.offset', payload[:offset]) if payload.key?(:offset)
-            span.set_tag('kafka.first_offset', payload[:first_offset]) if payload.key?(:first_offset)
-            span.set_tag('kafka.message_count', payload[:message_count]) if payload.key?(:message_count)
-            span.set_error(payload[:exception_object]) if payload[:exception_object]
-          end
-
           private
 
           def configuration
@@ -87,15 +50,6 @@ module Datadog
           def compatible?
             defined?(::Racecar) && defined?(::ActiveSupport::Notifications)
           end
-
-          # Context objects are thread-bound.
-          # If Racecar re-uses threads, context from a previous trace
-          # could leak into the new trace. This "cleans" current context,
-          # preventing such a leak.
-          def ensure_clean_context!
-            return unless configuration[:tracer].call_context.current_span
-            configuration[:tracer].provider.context = Context.new
-          end
         end
       end
     end

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

@@ -1,6 +1,7 @@
 require 'ddtrace/ext/app_types'
 require 'ddtrace/ext/http'
 require 'ddtrace/propagation/http_propagator'
+require 'ddtrace/contrib/rack/request_queue'
 
 module Datadog
   module Contrib
@@ -19,10 +20,28 @@ module Datadog
           @app = app
         end
 
+        def compute_queue_time(env, tracer)
+          return unless Datadog.configuration[:rack][:request_queuing]
+
+          # parse the request queue time
+          request_start = Datadog::Contrib::Rack::QueueTime.get_request_start(env)
+          return if request_start.nil?
+
+          tracer.trace(
+            'http_server.queue',
+            start_time: request_start,
+            service: Datadog.configuration[:rack][:web_service_name]
+          )
+        end
+
         def call(env)
           # retrieve integration settings
           tracer = Datadog.configuration[:rack][:tracer]
 
+          # [experimental] create a root Span to keep track of frontend web servers
+          # (i.e. Apache, nginx) if the header is properly set
+          frontend_span = compute_queue_time(env, tracer)
+
           trace_options = {
             service: Datadog.configuration[:rack][:service_name],
             resource: nil,
@@ -77,6 +96,7 @@ module Datadog
           # ensure the request_span is finished and the context reset;
           # this assumes that the Rack middleware creates a root span
           request_span.finish
+          frontend_span.finish unless frontend_span.nil?
 
           # TODO: Remove this once we change how context propagation works. This
           # ensures we clean thread-local variables on each HTTP request avoiding
@@ -105,7 +125,8 @@ module Datadog
           # So when its not available, we want the original, unmutated PATH_INFO, which
           # is just the relative path without query strings.
           url = env['REQUEST_URI'] || original_env['PATH_INFO']
-          request_id = get_request_id(headers, env)
+          request_headers = parse_request_headers(env)
+          response_headers = parse_response_headers(headers || {})
 
           request_span.resource ||= resource_name_for(env, status)
           if request_span.get_tag(Datadog::Ext::HTTP::METHOD).nil?
@@ -130,8 +151,15 @@ module Datadog
           if request_span.get_tag(Datadog::Ext::HTTP::STATUS_CODE).nil? && status
             request_span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, status)
           end
-          if request_span.get_tag(Datadog::Ext::HTTP::REQUEST_ID).nil? && request_id
-            request_span.set_tag(Datadog::Ext::HTTP::REQUEST_ID, request_id)
+
+          # Request headers
+          request_headers.each do |name, value|
+            request_span.set_tag(name, value) if request_span.get_tag(name).nil?
+          end
+
+          # Response headers
+          response_headers.each do |name, value|
+            request_span.set_tag(name, value) if request_span.get_tag(name).nil?
           end
 
           # detect if the status code is a 5xx and flag the request span as an error
@@ -141,14 +169,6 @@ module Datadog
           end
         end
 
-        # If Rails is present, it will sanitize & use the Request ID header,
-        # or generate a UUID if no request ID header is present, then set that as headers['X-Request-Id'].
-        # Othewise use whatever Rack variables are present (they should all be the same.)
-        def get_request_id(headers, env)
-          headers ||= {}
-          headers['X-Request-Id'] || headers['X-Request-ID'] || env['HTTP_X_REQUEST_ID']
-        end
-
         private
 
         REQUEST_SPAN_DEPRECATION_WARNING = %(
@@ -176,6 +196,40 @@ module Datadog
             end
           end
         end
+
+        def parse_request_headers(env)
+          {}.tap do |result|
+            whitelist = Datadog.configuration[:rack][:headers][:request] || []
+            whitelist.each do |header|
+              rack_header = header_to_rack_header(header)
+              if env.key?(rack_header)
+                result[Datadog::Ext::HTTP::RequestHeaders.to_tag(header)] = env[rack_header]
+              end
+            end
+          end
+        end
+
+        def parse_response_headers(headers)
+          {}.tap do |result|
+            whitelist = Datadog.configuration[:rack][:headers][:response] || []
+            whitelist.each do |header|
+              if headers.key?(header)
+                result[Datadog::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[header]
+              else
+                # Try a case-insensitive lookup
+                uppercased_header = header.to_s.upcase
+                matching_header = headers.keys.find { |h| h.upcase == uppercased_header }
+                if matching_header
+                  result[Datadog::Ext::HTTP::ResponseHeaders.to_tag(header)] = headers[matching_header]
+                end
+              end
+            end
+          end
+        end
+
+        def header_to_rack_header(name)
+          "HTTP_#{name.to_s.upcase.gsub(/[-\s]/, '_')}"
+        end
       end
     end
   end

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

@@ -4,6 +4,14 @@ module Datadog
       # Provides instrumentation for `rack`
       module Patcher
         include Base
+
+        DEFAULT_HEADERS = {
+          response: [
+            'Content-Type',
+            'X-Request-ID'
+          ]
+        }.freeze
+
         register_as :rack
         option :tracer, default: Datadog.tracer
         option :distributed_tracing, default: false
@@ -14,6 +22,14 @@ module Datadog
           get_option(:tracer).set_service_info(value, 'rack', Ext::AppTypes::WEB)
           value
         end
+        option :request_queuing, default: false
+        option :web_service_name, default: 'web-server', depends_on: [:tracer, :request_queuing] do |value|
+          if get_option(:request_queuing)
+            get_option(:tracer).set_service_info(value, 'webserver', Ext::AppTypes::WEB)
+          end
+          value
+        end
+        option :headers, default: DEFAULT_HEADERS
 
         module_function
 

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

@@ -0,0 +1,34 @@
+module Datadog
+  module Contrib
+    module Rack
+      # QueueTime simply...
+      module QueueTime
+        REQUEST_START = 'HTTP_X_REQUEST_START'.freeze
+        QUEUE_START = 'HTTP_X_QUEUE_START'.freeze
+
+        module_function
+
+        def get_request_start(env, now = Time.now.utc)
+          header = env[REQUEST_START] || env[QUEUE_START]
+          return unless header
+
+          # nginx header is in the format "t=1512379167.574"
+          # TODO: this should be generic enough to work with any
+          # frontend web server or load balancer
+          time_string = header.split('t=')[1]
+          return if time_string.nil?
+
+          # return the request_start only if it's lesser than
+          # current time, to avoid significant clock skew
+          request_start = Time.at(time_string.to_f)
+          request_start.utc > now ? nil : request_start
+        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}")
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -13,6 +13,71 @@ module Datadog
             Datadog::RailsRendererPatcher.patch_renderer
           end
         end
+
+        def self.start_render_template(payload)
+          # retrieve the tracing context
+          tracing_context = payload.fetch(:tracing_context)
+
+          # create a new Span and add it to the tracing context
+          tracer = Datadog.configuration[:rails][:tracer]
+          span = tracer.trace('rails.render_template', span_type: Datadog::Ext::HTTP::TEMPLATE)
+          tracing_context[:dd_rails_template_span] = span
+        rescue StandardError => e
+          Datadog::Tracer.log.debug(e.message)
+        end
+
+        def self.finish_render_template(payload)
+          # retrieve the tracing context and the latest active span
+          tracing_context = payload.fetch(:tracing_context)
+          span = tracing_context[:dd_rails_template_span]
+          return if !span || span.finished?
+
+          # finish the tracing and update the execution time
+          begin
+            template_name = tracing_context[:template_name]
+            layout = tracing_context[:layout]
+            exception = tracing_context[:exception]
+
+            span.set_tag('rails.template_name', template_name) if template_name
+            span.set_tag('rails.layout', layout) if layout
+            span.set_error(exception) if exception
+          ensure
+            span.finish()
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.debug(e.message)
+        end
+
+        def self.start_render_partial(payload)
+          # retrieve the tracing context
+          tracing_context = payload.fetch(:tracing_context)
+
+          tracer = Datadog.configuration[:rails][:tracer]
+          span = tracer.trace('rails.render_partial', span_type: Datadog::Ext::HTTP::TEMPLATE)
+          tracing_context[:dd_rails_partial_span] = span
+        rescue StandardError => e
+          Datadog::Tracer.log.debug(e.message)
+        end
+
+        def self.finish_render_partial(payload)
+          # retrieve the tracing context and the latest active span
+          tracing_context = payload.fetch(:tracing_context)
+          span = tracing_context[:dd_rails_partial_span]
+          return if !span || span.finished?
+
+          # finish the tracing and update the execution time
+          begin
+            template_name = tracing_context[:template_name]
+            exception = tracing_context[:exception]
+
+            span.set_tag('rails.template_name', template_name) if template_name
+            span.set_error(exception) if exception
+          ensure
+            span.finish()
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.debug(e.message)
+        end
       end
     end
   end