ddtrace 0.26.1 → 0.27.0

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

@@ -1,100 +0,0 @@
-require 'ddtrace/ext/http'
-require 'ddtrace/ext/errors'
-require 'ddtrace/contrib/rack/ext'
-require 'ddtrace/contrib/rails/ext'
-
-module Datadog
-  module Contrib
-    module Rails
-      # Code used to create and handle 'rails.action_controller' spans.
-      module ActionController
-        include Datadog::Patcher
-
-        def self.instrument
-          # patch Rails core components
-          do_once(:instrument) do
-            Datadog::RailsActionPatcher.patch_action_controller
-          end
-        end
-
-        def self.start_processing(payload)
-          # trace the execution
-          tracer = Datadog.configuration[:rails][:tracer]
-          service = Datadog.configuration[:rails][:controller_service]
-          type = Datadog::Ext::HTTP::TYPE_INBOUND
-          span = tracer.trace(Ext::SPAN_ACTION_CONTROLLER, service: service, span_type: type)
-
-          # attach the current span to the tracing context
-          tracing_context = payload.fetch(:tracing_context)
-          tracing_context[:dd_request_span] = span
-        rescue StandardError => e
-          Datadog::Tracer.log.error(e.message)
-        end
-
-        def self.finish_processing(payload)
-          # retrieve the tracing context and the latest active span
-          tracing_context = payload.fetch(:tracing_context)
-          env = payload.fetch(:env)
-          span = tracing_context[:dd_request_span]
-          return unless span && !span.finished?
-
-          begin
-            # Set the resource name, if it's still the default name
-            if span.resource == span.name
-              span.resource = "#{payload.fetch(:controller)}##{payload.fetch(:action)}"
-            end
-
-            # Set the resource name of the Rack request span unless this is an exception controller.
-            unless exception_controller?(payload)
-              rack_request_span = env[Datadog::Contrib::Rack::TraceMiddleware::RACK_REQUEST_SPAN]
-              rack_request_span.resource = span.resource if rack_request_span
-            end
-
-            # Set analytics sample rate
-            Utils.set_analytics_sample_rate(span)
-
-            # Associate with runtime metrics
-            Datadog.runtime_metrics.associate_with_span(span)
-
-            span.set_tag(Ext::TAG_ROUTE_ACTION, payload.fetch(:action))
-            span.set_tag(Ext::TAG_ROUTE_CONTROLLER, payload.fetch(:controller))
-
-            exception = payload[:exception_object]
-            if 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')
-            elsif Utils.exception_is_error?(exception)
-              span.set_error(exception)
-            end
-          ensure
-            span.finish()
-          end
-        rescue StandardError => e
-          Datadog::Tracer.log.error(e.message)
-        end
-
-        def self.exception_controller?(payload)
-          exception_controller_class = Datadog.configuration[:rails][:exception_controller]
-          controller = payload.fetch(:controller)
-          headers = payload.fetch(:headers)
-
-          # If no exception controller class has been set,
-          # guess whether this is an exception controller from the headers.
-          if exception_controller_class.nil?
-            !headers[:request_exception].nil?
-          # If an exception controller class has been specified,
-          # check if the controller is a kind of the exception controller class.
-          elsif exception_controller_class.is_a?(Class) || exception_controller_class.is_a?(Module)
-            controller <= exception_controller_class
-          # Otherwise if the exception controller class is some other value (like false)
-          # assume that this controller doesn't handle exceptions.
-          else
-            false
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,78 +0,0 @@
-module Datadog
-  module Contrib
-    module Rails
-      # Instrument ActiveController processing
-      module ActionControllerPatch
-        def self.included(base)
-          if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0.0')
-            base.send(:prepend, ProcessActionPatch)
-          else
-            base.class_eval do
-              alias_method :process_action_without_datadog, :process_action
-
-              include ProcessActionPatch
-            end
-          end
-        end
-
-        # Compatibility module for Ruby versions not supporting #prepend
-        module ProcessActionCompatibilityPatch
-          def process_action(*args)
-            process_action_without_datadog(*args)
-          end
-        end
-
-        # ActionController patch
-        module ProcessActionPatch
-          # compatibility module for Ruby versions not supporting #prepend
-          include ProcessActionCompatibilityPatch unless Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.0.0')
-
-          def process_action(*args)
-            # mutable payload with a tracing context that is used in two different
-            # signals; it propagates the request span so that it can be finished
-            # no matter what
-            payload = {
-              controller: self.class,
-              action: action_name,
-              env: request.env,
-              headers: {
-                # The exception this controller was given in the request,
-                # which is typical if the controller is configured to handle exceptions.
-                request_exception: request.headers['action_dispatch.exception']
-              },
-              tracing_context: {}
-            }
-
-            begin
-              # process and catch request exceptions
-              Datadog::Contrib::Rails::ActionController.start_processing(payload)
-              result = super(*args)
-              status = datadog_response_status
-              payload[:status] = status unless status.nil?
-              result
-            # rubocop:disable Lint/RescueException
-            rescue Exception => e
-              payload[:exception] = [e.class.name, e.message]
-              payload[:exception_object] = e
-              raise e
-            end
-          # rubocop:enable Lint/RescueException
-          ensure
-            Datadog::Contrib::Rails::ActionController.finish_processing(payload)
-          end
-
-          def datadog_response_status
-            case response
-            when ActionDispatch::Response
-              response.status
-            when Array
-              # Likely a Rack response array: first element is the status.
-              status = response.first
-              status.class <= Integer ? status : nil
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-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
-        include Datadog::Patcher
-
-        def self.instrument
-          # patch Rails core components
-          do_once(:instrument) do
-            Datadog::RailsRendererPatcher.patch_renderer
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-require 'thread'
-require 'ddtrace/contrib/rails/ext'
-
-module Datadog
-  module Contrib
-    module Rails
-      # Code used to create and handle 'rails.cache' spans.
-      module ActiveSupport
-        include Datadog::Patcher
-
-        def self.instrument
-          do_once(:instrument) do
-            # patch Rails core components
-            Datadog::RailsCachePatcher.patch_cache_store
-          end
-        end
-
-        def self.start_trace_cache(payload)
-          tracer = Datadog.configuration[:rails][:tracer]
-
-          # In most of the cases Rails ``fetch()`` and ``read()`` calls are nested.
-          # This check ensures that two reads are not nested since they don't provide
-          # interesting details.
-          # NOTE: the ``finish_trace_cache()`` is fired but it already has a safe-guard
-          # to avoid any kind of issue.
-          current_span = tracer.active_span
-          return if payload[:action] == Ext::RESOURCE_CACHE_GET &&
-                    current_span.try(:name) == Ext::SPAN_CACHE &&
-                    current_span.try(:resource) == Ext::RESOURCE_CACHE_GET
-
-          tracing_context = payload.fetch(:tracing_context)
-
-          # create a new ``Span`` and add it to the tracing context
-          service = Datadog.configuration[:rails][:cache_service]
-          type = Ext::SPAN_TYPE_CACHE
-          span = tracer.trace(Ext::SPAN_CACHE, service: service, span_type: type)
-          span.resource = payload.fetch(:action)
-          tracing_context[:dd_cache_span] = span
-        rescue StandardError => e
-          Datadog::Tracer.log.debug(e.message)
-        end
-
-        def self.finish_trace_cache(payload)
-          # retrieve the tracing context and continue the trace
-          tracing_context = payload.fetch(:tracing_context)
-          span = tracing_context[:dd_cache_span]
-          return unless span && !span.finished?
-
-          begin
-            # discard parameters from the cache_store configuration
-            store, = *Array.wrap(::Rails.configuration.cache_store).flatten
-            span.set_tag(Ext::TAG_CACHE_BACKEND, store)
-            normalized_key = ::ActiveSupport::Cache.expand_cache_key(payload.fetch(:key))
-            cache_key = Datadog::Utils.truncate(normalized_key, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
-            span.set_tag(Ext::TAG_CACHE_KEY, cache_key)
-
-            span.set_error(payload[:exception]) if payload[:exception]
-          ensure
-            span.finish
-          end
-        rescue StandardError => e
-          Datadog::Tracer.log.debug(e.message)
-        end
-      end
-    end
-  end
-end

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

@@ -1,353 +0,0 @@
-require 'ddtrace/contrib/rails/ext'
-
-module Datadog
-  # RailsRendererPatcher contains function to patch Rails rendering libraries.
-  # rubocop:disable Lint/RescueException
-  # rubocop:disable Metrics/MethodLength
-  # rubocop:disable Metrics/ModuleLength
-  module RailsRendererPatcher
-    include Datadog::Patcher
-
-    module_function
-
-    def patch_renderer
-      do_once(:patch_renderer) do
-        if defined?(::ActionView::TemplateRenderer) && defined?(::ActionView::PartialRenderer)
-          patch_template_renderer(::ActionView::TemplateRenderer)
-          patch_partial_renderer(::ActionView::PartialRenderer)
-        elsif defined?(::ActionView::Rendering) && defined?(::ActionView::Partials::PartialRenderer)
-          # NOTE: Rails < 3.1 compatibility: different classes are used
-          patch_template_renderer(::ActionView::Rendering)
-          patch_partial_renderer(::ActionView::Partials::PartialRenderer)
-        else
-          Datadog::Tracer.log.debug('Expected Template/Partial classes not found; template rendering disabled')
-        end
-      end
-    end
-
-    def patch_template_renderer(klass)
-      # rubocop:disable Metrics/BlockLength
-      do_once(:patch_template_renderer) do
-        klass.class_eval do
-          def render_with_datadog(*args, &block)
-            # NOTE: This check exists purely for Rails 3.0 compatibility.
-            #       The 'if' part can be removed when support for Rails 3.0 is removed.
-            if active_datadog_span
-              render_without_datadog(*args, &block)
-            else
-              datadog_tracer.trace(
-                Datadog::Contrib::Rails::Ext::SPAN_RENDER_TEMPLATE,
-                span_type: Datadog::Ext::HTTP::TEMPLATE
-              ) do |span|
-                with_datadog_span(span) { render_without_datadog(*args, &block) }
-              end
-            end
-          end
-
-          def render_template_with_datadog(*args)
-            begin
-              # arguments based on render_template signature (stable since Rails 3.2)
-              template = args[0]
-              layout_name = args[1]
-
-              # update the tracing context with computed values before the rendering
-              template_name = template.try('identifier')
-              template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(template_name)
-              layout = if layout_name.is_a?(String)
-                         # NOTE: Rails < 3.1 compatibility: the second argument is the layout name
-                         layout_name
-                       else
-                         layout_name.try(:[], 'virtual_path')
-                       end
-              if template_name
-                active_datadog_span.set_tag(
-                  Datadog::Contrib::Rails::Ext::TAG_TEMPLATE_NAME,
-                  template_name
-                )
-              end
-
-              if layout
-                active_datadog_span.set_tag(
-                  Datadog::Contrib::Rails::Ext::TAG_LAYOUT,
-                  layout
-                )
-              end
-            rescue StandardError => e
-              Datadog::Tracer.log.debug(e.message)
-            end
-
-            # execute the original function anyway
-            render_template_without_datadog(*args)
-          end
-
-          private
-
-          attr_accessor :active_datadog_span
-
-          def datadog_tracer
-            Datadog.configuration[:rails][:tracer]
-          end
-
-          def with_datadog_span(span)
-            self.active_datadog_span = span
-            yield
-          ensure
-            self.active_datadog_span = nil
-          end
-
-          # method aliasing to patch the class
-          alias_method :render_without_datadog, :render
-          alias_method :render, :render_with_datadog
-
-          if klass.private_method_defined?(:render_template) || klass.method_defined?(:render_template)
-            alias_method :render_template_without_datadog, :render_template
-            alias_method :render_template, :render_template_with_datadog
-          else
-            # NOTE: Rails < 3.1 compatibility: the method name is different
-            alias_method :render_template_without_datadog, :_render_template
-            alias_method :_render_template, :render_template_with_datadog
-          end
-        end
-      end
-    end
-
-    def patch_partial_renderer(klass)
-      do_once(:patch_partial_renderer) do
-        klass.class_eval do
-          def render_with_datadog(*args, &block)
-            datadog_tracer.trace(
-              Datadog::Contrib::Rails::Ext::SPAN_RENDER_PARTIAL,
-              span_type: Datadog::Ext::HTTP::TEMPLATE
-            ) do |span|
-              with_datadog_span(span) { render_without_datadog(*args) }
-            end
-          end
-
-          def render_partial_with_datadog(*args)
-            begin
-              template_name = Datadog::Contrib::Rails::Utils.normalize_template_name(@template.try('identifier'))
-              if template_name
-                active_datadog_span.set_tag(
-                  Datadog::Contrib::Rails::Ext::TAG_TEMPLATE_NAME,
-                  template_name
-                )
-              end
-            rescue StandardError => e
-              Datadog::Tracer.log.debug(e.message)
-            end
-
-            # execute the original function anyway
-            render_partial_without_datadog(*args)
-          end
-
-          private
-
-          attr_accessor :active_datadog_span
-
-          def datadog_tracer
-            Datadog.configuration[:rails][:tracer]
-          end
-
-          def with_datadog_span(span)
-            self.active_datadog_span = span
-            yield
-          ensure
-            self.active_datadog_span = nil
-          end
-
-          # method aliasing to patch the class
-          alias_method :render_without_datadog, :render
-          alias_method :render, :render_with_datadog
-          alias_method :render_partial_without_datadog, :render_partial
-          alias_method :render_partial, :render_partial_with_datadog
-        end
-      end
-    end
-  end
-
-  # RailsActionPatcher contains functions to patch Rails action controller instrumentation
-  module RailsActionPatcher
-    include Datadog::Patcher
-
-    module_function
-
-    def patch_action_controller
-      do_once(:patch_action_controller) do
-        patch_process_action
-      end
-    end
-
-    def patch_process_action
-      do_once(:patch_process_action) do
-        require 'ddtrace/contrib/rails/action_controller_patch'
-
-        ::ActionController::Metal.send(:include, Datadog::Contrib::Rails::ActionControllerPatch)
-      end
-    end
-  end
-
-  # RailsCachePatcher contains function to patch Rails caching libraries.
-  module RailsCachePatcher
-    include Datadog::Patcher
-
-    module_function
-
-    def patch_cache_store
-      do_once(:patch_cache_store) do
-        patch_cache_store_read
-        patch_cache_store_fetch
-        patch_cache_store_write
-        patch_cache_store_delete
-        reload_cache_store
-      end
-    end
-
-    def cache_store_class(k)
-      # When Redis is used, we can't only patch Cache::Store as it is
-      # Cache::RedisStore, a sub-class of it that is used, in practice.
-      # We need to do a per-method monkey patching as some of them might
-      # be redefined, and some of them not. The latest version of redis-activesupport
-      # redefines write but leaves untouched read and delete:
-      # https://github.com/redis-store/redis-activesupport/blob/master/lib/active_support/cache/redis_store.rb
-      c = if defined?(::ActiveSupport::Cache::RedisStore) &&
-             ::ActiveSupport::Cache::RedisStore.instance_methods(false).include?(k)
-            ::ActiveSupport::Cache::RedisStore
-          else
-            ::ActiveSupport::Cache::Store
-          end
-      c
-    end
-
-    def patch_cache_store_read
-      do_once(:patch_cache_store_read) do
-        cache_store_class(:read).class_eval do
-          alias_method :read_without_datadog, :read
-
-          def read(*args, &block)
-            payload = {
-              action: Datadog::Contrib::Rails::Ext::RESOURCE_CACHE_GET,
-              key: args[0],
-              tracing_context: {}
-            }
-
-            begin
-              # process and catch cache exceptions
-              Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(payload)
-              read_without_datadog(*args, &block)
-            rescue Exception => e
-              payload[:exception] = [e.class.name, e.message]
-              payload[:exception_object] = e
-              raise e
-            end
-          ensure
-            Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(payload)
-          end
-        end
-      end
-    end
-
-    def patch_cache_store_fetch
-      do_once(:patch_cache_store_fetch) do
-        cache_store_class(:fetch).class_eval do
-          alias_method :fetch_without_datadog, :fetch
-
-          def fetch(*args, &block)
-            payload = {
-              action: Datadog::Contrib::Rails::Ext::RESOURCE_CACHE_GET,
-              key: args[0],
-              tracing_context: {}
-            }
-
-            begin
-              # process and catch cache exceptions
-              Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(payload)
-              fetch_without_datadog(*args, &block)
-            rescue Exception => e
-              payload[:exception] = [e.class.name, e.message]
-              payload[:exception_object] = e
-              raise e
-            end
-          ensure
-            Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(payload)
-          end
-        end
-      end
-    end
-
-    def patch_cache_store_write
-      do_once(:patch_cache_store_write) do
-        cache_store_class(:write).class_eval do
-          alias_method :write_without_datadog, :write
-
-          def write(*args, &block)
-            payload = {
-              action: Datadog::Contrib::Rails::Ext::RESOURCE_CACHE_SET,
-              key: args[0],
-              tracing_context: {}
-            }
-
-            begin
-              # process and catch cache exceptions
-              Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(payload)
-              write_without_datadog(*args, &block)
-            rescue Exception => e
-              payload[:exception] = [e.class.name, e.message]
-              payload[:exception_object] = e
-              raise e
-            end
-          ensure
-            Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(payload)
-          end
-        end
-      end
-    end
-
-    def patch_cache_store_delete
-      do_once(:patch_cache_store_delete) do
-        cache_store_class(:delete).class_eval do
-          alias_method :delete_without_datadog, :delete
-
-          def delete(*args, &block)
-            payload = {
-              action: Datadog::Contrib::Rails::Ext::RESOURCE_CACHE_DELETE,
-              key: args[0],
-              tracing_context: {}
-            }
-
-            begin
-              # process and catch cache exceptions
-              Datadog::Contrib::Rails::ActiveSupport.start_trace_cache(payload)
-              delete_without_datadog(*args, &block)
-            rescue Exception => e
-              payload[:exception] = [e.class.name, e.message]
-              payload[:exception_object] = e
-              raise e
-            end
-          ensure
-            Datadog::Contrib::Rails::ActiveSupport.finish_trace_cache(payload)
-          end
-        end
-      end
-    end
-
-    def self.reload_cache_store
-      redis = Datadog.registry[:redis]
-      return unless redis && redis.patcher.patched?
-
-      return unless defined?(::ActiveSupport::Cache::RedisStore) &&
-                    defined?(::Rails.cache) &&
-                    ::Rails.cache.is_a?(::ActiveSupport::Cache::RedisStore)
-
-      Tracer.log.debug('Reloading redis cache store')
-
-      # backward compatibility: Rails 3.x doesn't have `cache=` method
-      cache_store = ::Rails.configuration.cache_store
-      cache_instance = ::ActiveSupport::Cache.lookup_store(cache_store)
-      if ::Rails::VERSION::MAJOR.to_i == 3
-        silence_warnings { Object.const_set 'RAILS_CACHE', cache_instance }
-      elsif ::Rails::VERSION::MAJOR.to_i > 3
-        ::Rails.cache = cache_instance
-      end
-    end
-  end
-end