fair-ddtrace 0.8.2.a

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

@@ -0,0 +1,156 @@
+# requirements should be kept minimal as Patcher is a shared requirement.
+
+module Datadog
+  module Contrib
+    # Datadog Net/HTTP integration.
+    module HTTP
+      URL = 'http.url'.freeze
+      METHOD = 'http.method'.freeze
+      BODY = 'http.body'.freeze
+
+      NAME = 'http.request'.freeze
+      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)
+        # we don't want to trace our own call to the API (they use net/http)
+        # when we know the host & port (from the URI) we use it, else (most-likely
+        # called with a block) rely on the URL at the end.
+        if req.respond_to?(:uri) && req.uri
+          if req.uri.host.to_s == transport.hostname.to_s &&
+             req.uri.port.to_i == transport.port.to_i
+            return true
+          end
+        elsif address && port &&
+              address.to_s == transport.hostname.to_s &&
+              port.to_i == transport.port.to_i
+          return true
+        end
+        # we don't want a "shotgun" effect with two nested traces for one
+        # logical get, and request is likely to call itself recursively
+        active = pin.tracer.active_span()
+        return true if active && (active.name == NAME)
+        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
+        @patched = false
+
+        module_function
+
+        # patch applies our patch if needed
+        def patch
+          unless @patched
+            begin
+              require 'uri'
+              require 'ddtrace/pin'
+              require 'ddtrace/monkey'
+              require 'ddtrace/ext/app_types'
+              require 'ddtrace/ext/http'
+              require 'ddtrace/ext/net'
+              require 'ddtrace/ext/distributed'
+
+              patch_http()
+
+              @patched = true
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply net/http integration: #{e}")
+            end
+          end
+          @patched
+        end
+
+        # patched? tells wether patch has been successfully applied
+        def patched?
+          @patched
+        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
+            Datadog::Monkey.without_warnings do
+              remove_method :initialize
+            end
+
+            def initialize(*args)
+              pin = Datadog::Pin.new(SERVICE, app: APP, app_type: Datadog::Ext::AppTypes::WEB)
+              pin.onto(self)
+              initialize_without_datadog(*args)
+            end
+
+            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
+
+              transport = pin.tracer.writer.transport
+              return request_without_datadog(req, body, &block) if
+                Datadog::Contrib::HTTP.should_skip_tracing?(req, @address, @port, transport, pin)
+
+              pin.tracer.trace(NAME) do |span|
+                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)
+                  span.set_tag(Datadog::Ext::NET::TARGET_PORT, req.uri.port.to_s)
+                else
+                  span.set_tag(Datadog::Ext::NET::TARGET_HOST, @address)
+                  span.set_tag(Datadog::Ext::NET::TARGET_PORT, @port.to_s)
+                end
+
+                case response.code.to_i / 100
+                when 4
+                  span.set_error(response)
+                when 5
+                  span.set_error(response)
+                end
+
+                response
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,150 @@
+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
+      # application. If request tags are not set by the app, they will be set using
+      # information available at the Rack level.
+      class TraceMiddleware
+        DEFAULT_CONFIG = {
+          tracer: Datadog.tracer,
+          default_service: 'rack',
+          distributed_tracing_enabled: false
+        }.freeze
+
+        def initialize(app, options = {})
+          # update options with our configuration, unless it's already available
+          [:tracer, :default_service, :distributed_tracing_enabled].each do |k|
+            options[k] ||= DEFAULT_CONFIG[k]
+          end
+
+          @app = app
+          @options = options
+        end
+
+        def configure
+          # ensure that the configuration is executed only once
+          return clean_context if @tracer && @service
+
+          # 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(
+            @service,
+            'rack',
+            Datadog::Ext::AppTypes::WEB
+          )
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def call(env)
+          # configure the Rack middleware once
+          configure()
+
+          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)
+
+        # 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.
+          request_span.set_error(e)
+          raise e
+        ensure
+          # the source of truth in Rack is the PATH_INFO key that holds the
+          # URL for the current request; some framework may override that
+          # value, especially during exception handling and because of that
+          # we prefer using the `REQUEST_URI` if this is available.
+          # NOTE: `REQUEST_URI` is Rails specific and may not apply for other frameworks
+          url = env['REQUEST_URI'] || env['PATH_INFO']
+
+          # Rack is a really low level interface and it doesn't provide any
+          # advanced functionality like routers. Because of that, we assume that
+          # the underlying framework or application has more knowledge about
+          # the result for this request; `resource` and `tags` are expected to
+          # 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
+          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
+          if status.to_s.start_with?('5') && request_span.status.zero?
+            request_span.status = 1
+          end
+
+          request_span.finish()
+
+          [status, headers, response]
+        end
+
+        private
+
+        # TODO: Remove this once we change how context propagation works. This
+        # ensures we clean thread-local variables on each HTTP request avoiding
+        # memory leaks.
+        def clean_context
+          @tracer.provider.context = Datadog::Context.new
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+require 'ddtrace/ext/http'
+require 'ddtrace/ext/errors'
+
+module Datadog
+  module Contrib
+    module Rails
+      # Code used to create and handle 'rails.action_controller' spans.
+      module ActionController
+        KEY = 'datadog_actioncontroller'.freeze
+
+        def self.instrument
+          # subscribe when the request processing starts
+          ::ActiveSupport::Notifications.subscribe('start_processing.action_controller') do |*args|
+            start_processing(*args)
+          end
+
+          # subscribe when the request processing has been completed
+          ::ActiveSupport::Notifications.subscribe('process_action.action_controller') do |*args|
+            process_action(*args)
+          end
+        end
+
+        def self.start_processing(*)
+          return if Thread.current[KEY]
+
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          service = ::Rails.configuration.datadog_trace.fetch(:default_controller_service)
+          type = Datadog::Ext::HTTP::TYPE
+          tracer.trace('rails.action_controller', service: service, span_type: type)
+
+          Thread.current[KEY] = true
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.process_action(_name, start, finish, _id, payload)
+          return unless Thread.current[KEY]
+          Thread.current[KEY] = false
+
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          span = tracer.active_span()
+          return unless span
+
+          begin
+            resource = "#{payload.fetch(:controller)}##{payload.fetch(:action)}"
+            span.resource = resource
+
+            # set the parent resource if it's a `rack.request` span
+            if !span.parent.nil? && span.parent.name == 'rack.request'
+              span.parent.resource = resource
+            end
+
+            span.set_tag('rails.route.action', payload.fetch(:action))
+            span.set_tag('rails.route.controller', payload.fetch(:controller))
+
+            if payload[:exception].nil?
+              # [christian] in some cases :status is not defined,
+              # rather than firing an error, simply acknowledge we don't know it.
+              status = payload.fetch(:status, '?').to_s
+              span.status = 1 if status.starts_with?('5')
+            else
+              error = payload[:exception]
+              if defined?(::ActionDispatch::ExceptionWrapper)
+                status = ::ActionDispatch::ExceptionWrapper.status_code_for_exception(error[0])
+                status = status ? status.to_s : '?'
+              else
+                status = '500'
+              end
+              span.set_error(error) if status.starts_with?('5')
+            end
+          ensure
+            span.start_time = start
+            span.finish(finish)
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+require 'ddtrace/contrib/rails/utils'
+
+module Datadog
+  module Contrib
+    module Rails
+      # Code used to create and handle 'rails.render_template' and 'rails.render_partial' spans.
+      module ActionView
+        def self.instrument
+          # patch Rails core components
+          Datadog::RailsRendererPatcher.patch_renderer()
+
+          # subscribe when the template rendering starts
+          ::ActiveSupport::Notifications.subscribe('start_render_template.action_view') do |*args|
+            start_render_template(*args)
+          end
+
+          # subscribe when the partial rendering starts
+          ::ActiveSupport::Notifications.subscribe('start_render_partial.action_view') do |*args|
+            start_render_partial(*args)
+          end
+
+          # subscribe when the template rendering has been processed
+          ::ActiveSupport::Notifications.subscribe('render_template.action_view') do |*args|
+            render_template(*args)
+          end
+
+          # subscribe when the partial rendering has been processed
+          ::ActiveSupport::Notifications.subscribe('render_partial.action_view') do |*args|
+            render_partial(*args)
+          end
+        end
+
+        def self.get_key(f)
+          'datadog_actionview_' + f
+        end
+
+        def self.start_render_template(*)
+          key = get_key('render_template')
+          return if Thread.current[key]
+
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          type = Datadog::Ext::HTTP::TEMPLATE
+          tracer.trace('rails.render_template', span_type: type)
+
+          Thread.current[key] = true
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.start_render_partial(*)
+          key = get_key('render_partial')
+          return if Thread.current[key]
+
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          type = Datadog::Ext::HTTP::TEMPLATE
+          tracer.trace('rails.render_partial', span_type: type)
+
+          Thread.current[key] = true
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.render_template(_name, start, finish, _id, payload)
+          key = get_key('render_template')
+          return unless Thread.current[key]
+          Thread.current[key] = false
+
+          # finish the tracing and update the execution time
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          span = tracer.active_span()
+          return unless span
+
+          begin
+            template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(payload.fetch(:identifier))
+            span.set_tag('rails.template_name', template_name)
+            span.set_tag('rails.layout', payload.fetch(:layout))
+            span.set_error(payload[:exception]) if payload[:exception]
+          ensure
+            span.start_time = start
+            span.finish(finish)
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+
+        def self.render_partial(_name, start, finish, _id, payload)
+          key = get_key('render_partial')
+          return unless Thread.current[key]
+          Thread.current[key] = false
+
+          # finish the tracing and update the execution time
+          tracer = ::Rails.configuration.datadog_trace.fetch(:tracer)
+          span = tracer.active_span()
+          return unless span
+
+          begin
+            template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(payload.fetch(:identifier))
+            span.set_tag('rails.template_name', template_name)
+            span.set_error(payload[:exception]) if payload[:exception]
+          ensure
+            span.start_time = start
+            span.finish(finish)
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.error(e.message)
+        end
+      end
+    end
+  end
+end