ddtrace 0.35.2 → 1.1.0

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

@@ -1,74 +0,0 @@
-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

@@ -1,167 +0,0 @@
-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

@@ -1,45 +0,0 @@
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/action_view/configuration/settings'
-require 'ddtrace/contrib/action_view/patcher'
-
-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
-
-        def default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          ActionView::Patcher
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-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

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

@@ -1,32 +0,0 @@
-require 'ddtrace/contrib/analytics'
-
-module Datadog
-  module Contrib
-    module ActionView
-      # common utilities for Rails
-      module Utils
-        module_function
-
-        # in Rails the template name includes the template full path
-        # and it's better to avoid storing such information. This method
-        # returns the relative path from `views/` or the template name
-        # if a `views/` folder is not in the template full path. A wrong
-        # usage ensures that this method will not crash the tracing system.
-        def normalize_template_name(name)
-          return if name.nil?
-
-          base_path = Datadog.configuration[:action_view][:template_base_path]
-          sections_view = name.split(base_path)
-
-          if sections_view.length == 1
-            name.split('/')[-1]
-          else
-            sections_view[-1]
-          end
-        rescue
-          return name.to_s
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/active_model_serializers/ext'
-
-module Datadog
-  module Contrib
-    module ActiveModelSerializers
-      module Configuration
-        # Custom settings for the ActiveModelSerializers 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
-        end
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-require 'ddtrace/ext/http'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/active_support/notifications/event'
-require 'ddtrace/contrib/active_model_serializers/ext'
-
-module Datadog
-  module Contrib
-    module ActiveModelSerializers
-      # Defines basic behaviors for an ActiveModelSerializers event.
-      module Event
-        def self.included(base)
-          base.send(:include, ActiveSupport::Notifications::Event)
-          base.send(:extend, ClassMethods)
-        end
-
-        # Class methods for ActiveModelSerializers events.
-        # Note, they share the same process method and before_trace method.
-        module ClassMethods
-          def span_options
-            { service: configuration[:service_name] }
-          end
-
-          def tracer
-            -> { configuration[:tracer] }
-          end
-
-          def configuration
-            Datadog.configuration[:active_model_serializers]
-          end
-
-          def process(span, event, _id, payload)
-            span.service = configuration[:service_name]
-
-            # Set analytics sample rate
-            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
-              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
-            end
-
-            # Measure service stats
-            Contrib::Analytics.set_measured(span)
-
-            # Set the resource name and serializer name
-            res = resource(payload[:serializer])
-            span.resource = res
-            span.set_tag(Ext::TAG_SERIALIZER, res)
-
-            span.span_type = Datadog::Ext::HTTP::TEMPLATE
-
-            # Will be nil in 0.9
-            span.set_tag(Ext::TAG_ADAPTER, payload[:adapter].class) unless payload[:adapter].nil?
-          end
-
-          private
-
-          def resource(serializer)
-            # Depending on the version of ActiveModelSerializers
-            # serializer will be a string or an object.
-            if serializer.respond_to?(:name)
-              serializer.name
-            else
-              serializer
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/active_model_serializers/events/render.rb

@@ -1,32 +0,0 @@
-require 'ddtrace/contrib/active_model_serializers/ext'
-require 'ddtrace/contrib/active_model_serializers/event'
-
-module Datadog
-  module Contrib
-    module ActiveModelSerializers
-      module Events
-        # Defines instrumentation for render.active_model_serializers event
-        module Render
-          include ActiveModelSerializers::Event
-
-          EVENT_NAME = 'render.active_model_serializers'.freeze
-
-          module_function
-
-          def supported?
-            Gem.loaded_specs['active_model_serializers'] \
-              && Gem.loaded_specs['active_model_serializers'].version >= Gem::Version.new('0.10')
-          end
-
-          def event_name
-            self::EVENT_NAME
-          end
-
-          def span_name
-            Ext::SPAN_RENDER
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/active_model_serializers/events/serialize.rb

@@ -1,35 +0,0 @@
-require 'ddtrace/contrib/active_model_serializers/ext'
-require 'ddtrace/contrib/active_model_serializers/event'
-
-module Datadog
-  module Contrib
-    module ActiveModelSerializers
-      module Events
-        # Defines instrumentation for !serialize.active_model_serializers event
-        module Serialize
-          include ActiveModelSerializers::Event
-
-          EVENT_NAME = '!serialize.active_model_serializers'.freeze
-
-          module_function
-
-          def supported?
-            Gem.loaded_specs['active_model_serializers'] \
-              && ( \
-                Gem.loaded_specs['active_model_serializers'].version >= Gem::Version.new('0.9') \
-                && Gem.loaded_specs['active_model_serializers'].version < Gem::Version.new('0.10') \
-              )
-          end
-
-          def event_name
-            self::EVENT_NAME
-          end
-
-          def span_name
-            Ext::SPAN_SERIALIZE
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-require 'ddtrace/contrib/active_model_serializers/events/render'
-require 'ddtrace/contrib/active_model_serializers/events/serialize'
-
-module Datadog
-  module Contrib
-    module ActiveModelSerializers
-      # Defines collection of instrumented ActiveModelSerializers events
-      module Events
-        ALL = [
-          Events::Render,
-          Events::Serialize
-        ].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

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

@@ -1,17 +0,0 @@
-module Datadog
-  module Contrib
-    module ActiveModelSerializers
-      # ActiveModelSerializers integration constants
-      module Ext
-        APP = 'active_model_serializers'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_ACTIVE_MODEL_SERIALIZERS_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_ACTIVE_MODEL_SERIALIZERS_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'active_model_serializers'.freeze
-        SPAN_RENDER = 'active_model_serializers.render'.freeze
-        SPAN_SERIALIZE = 'active_model_serializers.serialize'.freeze
-        TAG_ADAPTER = 'active_model_serializers.adapter'.freeze
-        TAG_SERIALIZER = 'active_model_serializers.serializer'.freeze
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/active_model_serializers/configuration/settings'
-require 'ddtrace/contrib/active_model_serializers/patcher'
-
-module Datadog
-  module Contrib
-    module ActiveModelSerializers
-      # Description of ActiveModelSerializers integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('0.9.0')
-
-        register_as :active_model_serializers
-
-        def self.version
-          Gem.loaded_specs['active_model_serializers'] \
-            && Gem.loaded_specs['active_model_serializers'].version
-        end
-
-        def self.loaded?
-          !defined?(::ActiveModel::Serializer).nil? \
-            && !defined?(::ActiveSupport::Notifications).nil?
-        end
-
-        def self.compatible?
-          super && version >= MINIMUM_VERSION
-        end
-
-        def default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          Patcher
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/active_model_serializers/ext'
-require 'ddtrace/contrib/active_model_serializers/events'
-
-module Datadog
-  module Contrib
-    module ActiveModelSerializers
-      # Patcher enables patching of 'active_model_serializers' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          Events.subscribe!
-        end
-
-        def get_option(option)
-          Datadog.configuration[:active_model_serializers].get_option(option)
-        end
-      end
-    end
-  end
-end