ddtrace 0.13.0 → 0.47.0

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

@@ -0,0 +1,27 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/action_cable/ext'
+require 'ddtrace/contrib/action_cable/events'
+require 'ddtrace/contrib/action_cable/instrumentation'
+
+module Datadog
+  module Contrib
+    module ActionCable
+      # Patcher enables patching of 'action_cable' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          Events.subscribe!
+          ::ActionCable::Connection::Base.prepend(Instrumentation::ActionCableConnection)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/action_pack/action_controller/instrumentation.rb

@@ -0,0 +1,146 @@
+require 'ddtrace/ext/http'
+
+require 'ddtrace/contrib/action_pack/ext'
+require 'ddtrace/contrib/action_pack/utils'
+require 'ddtrace/contrib/rack/middlewares'
+require 'ddtrace/contrib/analytics'
+
+module Datadog
+  module Contrib
+    module ActionPack
+      module ActionController
+        # Instrumentation for ActionController components
+        module Instrumentation
+          module_function
+
+          def start_processing(payload)
+            # trace the execution
+            tracer = Datadog.configuration[:action_pack][:tracer]
+            service = Datadog.configuration[:action_pack][: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.logger.error(e.message)
+          end
+
+          def 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
+              span.resource = "#{payload.fetch(:controller)}##{payload.fetch(:action)}" if span.resource == span.name
+
+              # 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)
+
+              # Measure service stats
+              Contrib::Analytics.set_measured(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.logger.error(e.message)
+          end
+
+          def exception_controller?(payload)
+            exception_controller_class = Datadog.configuration[:action_pack][: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
+
+          # Instrumentation for ActionController::Metal
+          module Metal
+            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
+                Instrumentation.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
+              Instrumentation.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
+end

data/lib/ddtrace/contrib/action_pack/action_controller/patcher.rb

@@ -0,0 +1,25 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/action_pack/action_controller/instrumentation'
+
+module Datadog
+  module Contrib
+    module ActionPack
+      module ActionController
+        # Patcher for ActionController components
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            ::ActionController::Metal.send(:prepend, ActionController::Instrumentation::Metal)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/action_pack/configuration/settings.rb

@@ -0,0 +1,32 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/action_pack/ext'
+
+module Datadog
+  module Contrib
+    module ActionPack
+      module Configuration
+        # Custom settings for the ActionPack integration
+        class Settings < Contrib::Configuration::Settings
+          option :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+
+          option :analytics_enabled do |o|
+            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], nil) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
+            o.lazy
+          end
+
+          option :controller_service
+          option :exception_controller
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/action_pack/ext.rb

@@ -0,0 +1,19 @@
+module Datadog
+  module Contrib
+    module ActionPack
+      # ActionPack integration constants
+      module Ext
+        APP = 'action_pack'.freeze
+        ENV_ENABLED = 'DD_TRACE_ACTION_PACK_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTION_PACK_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_ACTION_PACK_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTION_PACK_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_ACTION_PACK_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'action_pack'.freeze
+        SPAN_ACTION_CONTROLLER = 'rails.action_controller'.freeze
+        TAG_ROUTE_ACTION = 'rails.route.action'.freeze
+        TAG_ROUTE_CONTROLLER = 'rails.route.controller'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/action_pack/integration.rb

@@ -0,0 +1,45 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/action_pack/configuration/settings'
+require 'ddtrace/contrib/action_pack/patcher'
+require 'ddtrace/contrib/rails/utils'
+
+module Datadog
+  module Contrib
+    module ActionPack
+      # Describes the ActionPack integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('3.0')
+
+        register_as :action_pack, auto_patch: false
+
+        def self.version
+          Gem.loaded_specs['actionpack'] && Gem.loaded_specs['actionpack'].version
+        end
+
+        def self.loaded?
+          !defined?(::ActionPack).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        # enabled by rails integration so should only auto instrument
+        # if detected that it is being used without rails
+        def auto_instrument?
+          !Datadog::Contrib::Rails::Utils.railtie_supported?
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          ActionPack::Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/action_pack/action_controller/patcher'
+
+module Datadog
+  module Contrib
+    module ActionPack
+      # Patcher enables patching of 'action_pack' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          ActionController::Patcher.patch
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/action_pack/utils.rb

@@ -0,0 +1,36 @@
+require 'ddtrace/contrib/analytics'
+
+module Datadog
+  module Contrib
+    module ActionPack
+      # Common utilities for ActionPack
+      module Utils
+        def self.exception_is_error?(exception)
+          if defined?(::ActionDispatch::ExceptionWrapper)
+            # Gets the equivalent status code for the exception (not all are 5XX)
+            # You can add custom errors via `config.action_dispatch.rescue_responses`
+            status = ::ActionDispatch::ExceptionWrapper.status_code_for_exception(exception.class.name)
+            # Only 5XX exceptions are actually errors (e.g. don't flag 404s)
+            status.to_s.starts_with?('5')
+          else
+            true
+          end
+        end
+
+        def self.set_analytics_sample_rate(span)
+          if Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+            Contrib::Analytics.set_sample_rate(span, datadog_configuration[:analytics_sample_rate])
+          end
+        end
+
+        class << self
+          private
+
+          def datadog_configuration
+            Datadog.configuration[:action_pack]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/action_view/configuration/settings.rb

@@ -0,0 +1,31 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/action_view/ext'
+
+module Datadog
+  module Contrib
+    module ActionView
+      module Configuration
+        # Custom settings for the ActionView integration
+        class Settings < Contrib::Configuration::Settings
+          option :enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+            o.lazy
+          end
+
+          option :analytics_enabled do |o|
+            o.default { env_to_bool([Ext::ENV_ANALYTICS_ENABLED, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
+            o.lazy
+          end
+
+          option :service_name, default: Ext::SERVICE_NAME
+          option :template_base_path, default: 'views/'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'ddtrace/contrib/active_support/notifications/event'
+
+module Datadog
+  module Contrib
+    module ActionView
+      # Defines basic behavior for an ActionView event.
+      module Event
+        def self.included(base)
+          base.send(:include, ActiveSupport::Notifications::Event)
+          base.send(:extend, ClassMethods)
+        end
+
+        # Class methods for ActionView events.
+        module ClassMethods
+          def tracer
+            -> { configuration[:tracer] }
+          end
+
+          def configuration
+            Datadog.configuration[:action_view]
+          end
+
+          def record_exception(span, payload)
+            if payload[:exception_object]
+              span.set_error(payload[:exception_object])
+            elsif payload[:exception]
+              # Fallback for ActiveSupport < 5.0
+              span.set_error(payload[:exception])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'ddtrace/contrib/action_view/events/render_partial'
+require 'ddtrace/contrib/action_view/events/render_template'
+
+module Datadog
+  module Contrib
+    module ActionView
+      # Defines collection of instrumented ActionView events
+      module Events
+        ALL = [
+          Events::RenderPartial,
+          Events::RenderTemplate
+        ].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