ddtrace 0.13.0 → 0.47.0

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

@@ -0,0 +1,46 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/action_view/ext'
+require 'ddtrace/contrib/action_view/event'
+
+module Datadog
+  module Contrib
+    module ActionView
+      module Events
+        # Defines instrumentation for render_partial.action_view event
+        module RenderPartial
+          include ActionView::Event
+
+          EVENT_NAME = 'render_partial.action_view'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            Ext::SPAN_RENDER_PARTIAL
+          end
+
+          def process(span, _event, _id, payload)
+            span.service = configuration[:service_name]
+            span.span_type = Datadog::Ext::HTTP::TEMPLATE
+
+            if (template_name = Utils.normalize_template_name(payload[:identifier]))
+              span.resource = template_name
+              span.set_tag(Ext::TAG_TEMPLATE_NAME, template_name)
+            end
+
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
+            record_exception(span, payload)
+          rescue StandardError => e
+            Datadog.logger.debug(e.message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/action_view/ext'
+require 'ddtrace/contrib/action_view/event'
+
+module Datadog
+  module Contrib
+    module ActionView
+      module Events
+        # Defines instrumentation for render_template.action_view event
+        module RenderTemplate
+          include ActionView::Event
+
+          EVENT_NAME = 'render_template.action_view'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            Ext::SPAN_RENDER_TEMPLATE
+          end
+
+          def process(span, _event, _id, payload)
+            span.service = configuration[:service_name]
+            span.span_type = Datadog::Ext::HTTP::TEMPLATE
+
+            if (template_name = Utils.normalize_template_name(payload[:identifier]))
+              span.resource = template_name
+              span.set_tag(Ext::TAG_TEMPLATE_NAME, template_name)
+            end
+
+            layout = payload[:layout]
+            span.set_tag(Ext::TAG_LAYOUT, layout) if layout
+
+            # Measure service stats
+            Contrib::Analytics.set_measured(span)
+
+            record_exception(span, payload)
+          rescue StandardError => e
+            Datadog.logger.debug(e.message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Datadog
+  module Contrib
+    module ActionView
+      # ActionView integration constants
+      module Ext
+        APP = 'action_view'.freeze
+        ENV_ENABLED = 'DD_TRACE_ACTION_VIEW_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTION_VIEW_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_ENABLED_OLD = 'DD_ACTION_VIEW_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTION_VIEW_ANALYTICS_SAMPLE_RATE'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE_OLD = '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,74 @@
+require 'ddtrace/contrib/action_view/ext'
+
+module Datadog
+  module Contrib
+    module ActionView
+      module Instrumentation
+        # Legacy instrumentation for partial rendering for Rails < 4
+        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.logger.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.resource = template_name
+              active_datadog_span.set_tag(
+                Ext::TAG_TEMPLATE_NAME,
+                template_name
+              )
+
+              # Measure service stats
+              Contrib::Analytics.set_measured(active_datadog_span)
+            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 < 4 partial rendering
+          # ActiveSupport events are used instead for Rails >= 4
+          module RailsLessThan4
+            include PartialRenderer
+
+            def datadog_template(*args)
+              @template
+            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
+        # Legacy instrumentation for template rendering for Rails < 4
+        module TemplateRenderer
+          # Legacy 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.resource = 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
+
+                    # Measure service stats
+                    Contrib::Analytics.set_measured(active_datadog_span)
+                  rescue StandardError => e
+                    Datadog.logger.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
+
+          # Legacy 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.logger.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.resource = 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
+
+              # Measure service stats
+              Contrib::Analytics.set_measured(active_datadog_span)
+            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, < 4 template rendering
+          # ActiveSupport events are used instead for Rails >= 4
+          module RailsLessThan4
+            include Rails31Plus
+
+            def datadog_parse_args(template, layout_name, *args)
+              [template, layout_name]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/action_view/configuration/settings'
+require 'ddtrace/contrib/action_view/patcher'
+require 'ddtrace/contrib/rails/utils'
+
+module Datadog
+  module Contrib
+    module ActionView
+      # Describes the ActionView integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('3.0')
+
+        register_as :action_view, auto_patch: false
+
+        def self.version
+          # ActionView is its own gem in Rails 4.1+
+          if Gem.loaded_specs['actionview']
+            Gem.loaded_specs['actionview'].version
+          # ActionView is embedded in ActionPack in versions < 4.1
+          elsif Gem.loaded_specs['actionpack']
+            action_pack_version = Gem.loaded_specs['actionpack'].version
+            action_pack_version unless action_pack_version >= Gem::Version.new('4.1')
+          end
+        end
+
+        def self.loaded?
+          !defined?(::ActionView).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
+          ActionView::Patcher
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+require 'ddtrace/ext/http'
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/action_view/events'
+require 'ddtrace/contrib/action_view/ext'
+require 'ddtrace/contrib/action_view/instrumentation/partial_renderer'
+require 'ddtrace/contrib/action_view/instrumentation/template_renderer'
+require 'ddtrace/contrib/action_view/utils'
+
+module Datadog
+  module Contrib
+    module ActionView
+      # Patcher enables patching of ActionView module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          patch_renderer
+        end
+
+        def patch_renderer
+          if target_version >= Gem::Version.new('4.0.0')
+            Events.subscribe!
+          elsif defined?(::ActionView::TemplateRenderer) && defined?(::ActionView::PartialRenderer)
+            # Rails < 4 compatibility:
+            #  Rendering events are not nested in this version, creating
+            #  render_partial spans outside of the parent render_template span.
+            #  We fall back to manual patching instead.
+            ::ActionView::TemplateRenderer.send(:prepend, Instrumentation::TemplateRenderer::RailsLessThan4)
+            ::ActionView::PartialRenderer.send(:prepend, Instrumentation::PartialRenderer::RailsLessThan4)
+          elsif defined?(::ActionView::Rendering) && defined?(::ActionView::Partials::PartialRenderer)
+            # NOTE: Rails < 3.1 compatibility: different classes are used
+            ::ActionView::Rendering.send(:prepend, Instrumentation::TemplateRenderer::Rails30)
+            ::ActionView::Partials::PartialRenderer.send(:prepend, Instrumentation::PartialRenderer::RailsLessThan4)
+          else
+            Datadog.logger.debug('Expected Template/Partial classes not found; template rendering disabled')
+          end
+        end
+      end
+    end
+  end
+end