ls-trace 0.1.1

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

@@ -0,0 +1,37 @@
+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 patched?
+            done?(:action_controller)
+          end
+
+          def patch
+            do_once(:action_controller) do
+              begin
+                patch_action_controller_metal
+              rescue StandardError => e
+                Datadog::Tracer.log.error("Unable to apply ActionController integration: #{e}")
+              end
+            end
+          end
+
+          def patch_action_controller_metal
+            do_once(:patch_action_controller_metal) do
+              ::ActionController::Metal.send(:prepend, ActionController::Instrumentation::Metal)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+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 :analytics_enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, nil) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 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,16 @@
+module Datadog
+  module Contrib
+    module ActionPack
+      # ActionPack integration constants
+      module Ext
+        APP = 'action_pack'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_ACTION_PACK_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = '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,36 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/action_pack/configuration/settings'
+require 'ddtrace/contrib/action_pack/patcher'
+
+module Datadog
+  module Contrib
+    module ActionPack
+      # Describes the ActionPack integration
+      class Integration
+        include Contrib::Integration
+
+        register_as :action_pack, auto_patch: false
+
+        def self.version
+          Gem.loaded_specs['actionpack'] && Gem.loaded_specs['actionpack'].version
+        end
+
+        def self.present?
+          super && defined?(::ActionPack)
+        end
+
+        def self.compatible?
+          super && version >= Gem::Version.new('3.0')
+        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,29 @@
+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 patched?
+          done?(:action_pack)
+        end
+
+        def patch
+          do_once(:action_pack) do
+            begin
+              ActionController::Patcher.patch
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply ActionPack integration: #{e}")
+            end
+          end
+        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,26 @@
+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 :analytics_enabled do |o|
+            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, false) }
+            o.lazy
+          end
+
+          option :analytics_sample_rate do |o|
+            o.default { env_to_float(Ext::ENV_ANALYTICS_SAMPLE_RATE, 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/ext.rb

@@ -0,0 +1,17 @@
+module Datadog
+  module Contrib
+    module ActionView
+      # ActionView integration constants
+      module Ext
+        APP = 'action_view'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_ACTION_VIEW_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_ACTION_VIEW_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'action_view'.freeze
+        SPAN_RENDER_PARTIAL = 'rails.render_partial'.freeze
+        SPAN_RENDER_TEMPLATE = 'rails.render_template'.freeze
+        TAG_LAYOUT = 'rails.layout'.freeze
+        TAG_TEMPLATE_NAME = 'rails.template_name'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/action_view/instrumentation/partial_renderer.rb

@@ -0,0 +1,78 @@
+require 'ddtrace/contrib/action_view/ext'
+
+module Datadog
+  module Contrib
+    module ActionView
+      module Instrumentation
+        # Instrumentation for partial rendering
+        module PartialRenderer
+          def render(*args, &block)
+            datadog_tracer.trace(
+              Ext::SPAN_RENDER_PARTIAL,
+              span_type: Datadog::Ext::HTTP::TEMPLATE
+            ) do |span|
+              with_datadog_span(span) { super(*args) }
+            end
+          end
+
+          def render_partial(*args)
+            begin
+              template = datadog_template(*args)
+
+              datadog_render_partial(template)
+            rescue StandardError => e
+              Datadog::Tracer.log.debug(e.message)
+            end
+
+            # execute the original function anyway
+            super(*args)
+          end
+
+          def datadog_render_partial(template)
+            template_name = Utils.normalize_template_name(template.try('identifier'))
+
+            if template_name
+              active_datadog_span.set_tag(
+                Ext::TAG_TEMPLATE_NAME,
+                template_name
+              )
+            end
+          end
+
+          private
+
+          attr_accessor :active_datadog_span
+
+          def datadog_tracer
+            Datadog.configuration[:action_view][:tracer]
+          end
+
+          def with_datadog_span(span)
+            self.active_datadog_span = span
+            yield
+          ensure
+            self.active_datadog_span = nil
+          end
+
+          # Rails < 6 partial rendering
+          module RailsLessThan6
+            include PartialRenderer
+
+            def datadog_template(*args)
+              @template
+            end
+          end
+
+          # Rails >= 6 partial rendering
+          module Rails6Plus
+            include PartialRenderer
+
+            def datadog_template(*args)
+              args[1]
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/action_view/instrumentation/template_renderer.rb

@@ -0,0 +1,167 @@
+require 'ddtrace/contrib/action_view/ext'
+
+module Datadog
+  module Contrib
+    module ActionView
+      module Instrumentation
+        # Instrumentation for template rendering
+        module TemplateRenderer
+          # Rails < 3.1 template rendering
+          module Rails30
+            # rubocop:disable Metrics/MethodLength
+            def self.prepended(base)
+              # rubocop:disable Metrics/BlockLength
+              base.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(
+                      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
+                    template = args[0]
+                    layout_name = args[1]
+
+                    # update the tracing context with computed values before the rendering
+                    template_name = template.try('identifier')
+                    template_name = Utils.normalize_template_name(template_name)
+
+                    if template_name
+                      active_datadog_span.set_tag(
+                        Ext::TAG_TEMPLATE_NAME,
+                        template_name
+                      )
+                    end
+
+                    if layout_name
+                      active_datadog_span.set_tag(
+                        Ext::TAG_LAYOUT,
+                        layout_name
+                      )
+                    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[:action_view][: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_template_without_datadog, :_render_template
+                alias_method :_render_template, :render_template_with_datadog
+              end
+            end
+          end
+
+          # Shared code for Rails >= 3.1 template rendering
+          module Rails31Plus
+            def render(*args, &block)
+              datadog_tracer.trace(
+                Ext::SPAN_RENDER_TEMPLATE,
+                span_type: Datadog::Ext::HTTP::TEMPLATE
+              ) do |span|
+                with_datadog_span(span) { super(*args, &block) }
+              end
+            end
+
+            def render_template(*args)
+              begin
+                template, layout_name = datadog_parse_args(*args)
+
+                datadog_render_template(template, layout_name)
+              rescue StandardError => e
+                Datadog::Tracer.log.debug(e.message)
+              end
+
+              # execute the original function anyway
+              super(*args)
+            end
+
+            def datadog_render_template(template, layout_name)
+              # update the tracing context with computed values before the rendering
+              template_name = template.try('identifier')
+              template_name = Utils.normalize_template_name(template_name)
+              layout = layout_name.try(:[], 'virtual_path') # Proc can be called without parameters since Rails 6
+
+              if template_name
+                active_datadog_span.set_tag(
+                  Ext::TAG_TEMPLATE_NAME,
+                  template_name
+                )
+              end
+
+              if layout
+                active_datadog_span.set_tag(
+                  Ext::TAG_LAYOUT,
+                  layout
+                )
+              end
+            end
+
+            private
+
+            attr_accessor :active_datadog_span
+
+            def datadog_tracer
+              Datadog.configuration[:action_view][:tracer]
+            end
+
+            def with_datadog_span(span)
+              self.active_datadog_span = span
+              yield
+            ensure
+              self.active_datadog_span = nil
+            end
+          end
+
+          # Rails >= 3.1 && < 6 template rendering
+          module Rails31To5
+            include Rails31Plus
+
+            def datadog_parse_args(template, layout_name, *args)
+              [template, layout_name]
+            end
+          end
+
+          # Rails >= 6 template rendering
+          module Rails6Plus
+            include Rails31Plus
+
+            def datadog_parse_args(view, template, layout_name, *args)
+              [template, layout_name]
+            end
+          end
+        end
+      end
+    end
+  end
+end