ddtrace 0.34.1 → 1.23.1

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.log.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

data/lib/ddtrace/contrib/active_record/configuration/resolver.rb

@@ -1,45 +0,0 @@
-require 'ddtrace/contrib/configuration/resolver'
-require 'ddtrace/vendor/active_record/connection_specification'
-
-module Datadog
-  module Contrib
-    module ActiveRecord
-      module Configuration
-        # Converts Symbols, Strings, and Hashes to a normalized connection settings Hash.
-        class Resolver < Contrib::Configuration::Resolver
-          def initialize(configurations = nil)
-            @configurations = configurations
-          end
-
-          def resolve(key)
-            normalize(connection_resolver.resolve(key).symbolize_keys)
-          end
-
-          def configurations
-            @configurations || ::ActiveRecord::Base.configurations
-          end
-
-          def connection_resolver
-            @resolver ||= begin
-              if defined?(::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver)
-                ::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(configurations)
-              else
-                ::Datadog::Vendor::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(configurations)
-              end
-            end
-          end
-
-          def normalize(hash)
-            {
-              adapter:  hash[:adapter],
-              host:     hash[:host],
-              port:     hash[:port],
-              database: hash[:database],
-              username: hash[:username]
-            }
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/active_record/ext'
-require 'ddtrace/contrib/active_record/utils'
-
-module Datadog
-  module Contrib
-    module ActiveRecord
-      module Configuration
-        # Custom settings for the ActiveRecord 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 :orm_service_name
-          option :service_name do |o|
-            o.default { Utils.adapter_name }
-            o.lazy
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-require 'ddtrace/contrib/active_support/notifications/event'
-
-module Datadog
-  module Contrib
-    module ActiveRecord
-      # Defines basic behaviors for an ActiveRecord event.
-      module Event
-        def self.included(base)
-          base.send(:include, ActiveSupport::Notifications::Event)
-          base.send(:extend, ClassMethods)
-        end
-
-        # Class methods for ActiveRecord events.
-        module ClassMethods
-          def span_options
-            { service: configuration[:service_name] }
-          end
-
-          def tracer
-            -> { configuration[:tracer] }
-          end
-
-          def configuration
-            Datadog.configuration[:active_record]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/active_record/events/instantiation.rb

@@ -1,60 +0,0 @@
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/active_record/ext'
-require 'ddtrace/contrib/active_record/event'
-
-module Datadog
-  module Contrib
-    module ActiveRecord
-      module Events
-        # Defines instrumentation for instantiation.active_record event
-        module Instantiation
-          include ActiveRecord::Event
-
-          EVENT_NAME = 'instantiation.active_record'.freeze
-
-          module_function
-
-          def supported?
-            Gem.loaded_specs['activerecord'] \
-              && Gem.loaded_specs['activerecord'].version >= Gem::Version.new('4.2')
-          end
-
-          def event_name
-            self::EVENT_NAME
-          end
-
-          def span_name
-            Ext::SPAN_INSTANTIATION
-          end
-
-          def process(span, event, _id, payload)
-            # Inherit service name from parent, if available.
-            span.service = if configuration[:orm_service_name]
-                             configuration[:orm_service_name]
-                           elsif span.parent
-                             span.parent.service
-                           else
-                             Ext::SERVICE_NAME
-                           end
-
-            span.resource = payload.fetch(:class_name)
-            span.span_type = Ext::SPAN_TYPE_INSTANTIATION
-
-            # 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)
-
-            span.set_tag(Ext::TAG_INSTANTIATION_CLASS_NAME, payload.fetch(:class_name))
-            span.set_tag(Ext::TAG_INSTANTIATION_RECORD_COUNT, payload.fetch(:record_count))
-          rescue StandardError => e
-            Datadog::Logger.log.debug(e.message)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/active_record/events/sql.rb

@@ -1,64 +0,0 @@
-require 'ddtrace/ext/net'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/active_record/ext'
-require 'ddtrace/contrib/active_record/event'
-
-module Datadog
-  module Contrib
-    module ActiveRecord
-      module Events
-        # Defines instrumentation for sql.active_record event
-        module SQL
-          include ActiveRecord::Event
-
-          EVENT_NAME = 'sql.active_record'.freeze
-          PAYLOAD_CACHE = 'CACHE'.freeze
-
-          module_function
-
-          def event_name
-            self::EVENT_NAME
-          end
-
-          def span_name
-            Ext::SPAN_SQL
-          end
-
-          def process(span, event, _id, payload)
-            config = Utils.connection_config(payload[:connection], payload[:connection_id])
-            settings = Datadog.configuration[:active_record, config]
-            adapter_name = Datadog::Utils::Database.normalize_vendor(config[:adapter])
-            service_name = if settings.service_name != Datadog::Utils::Database::VENDOR_DEFAULT
-                             settings.service_name
-                           else
-                             adapter_name
-                           end
-
-            span.name = "#{adapter_name}.query"
-            span.service = service_name
-            span.resource = payload.fetch(:sql)
-            span.span_type = Datadog::Ext::SQL::TYPE
-
-            # Set analytics sample rate
-            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
-              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
-            end
-
-            # Find out if the SQL query has been cached in this request. This meta is really
-            # helpful to users because some spans may have 0ns of duration because the query
-            # is simply cached from memory, so the notification is fired with start == finish.
-            cached = payload[:cached] || (payload[:name] == PAYLOAD_CACHE)
-
-            span.set_tag(Ext::TAG_DB_VENDOR, adapter_name)
-            span.set_tag(Ext::TAG_DB_NAME, config[:database])
-            span.set_tag(Ext::TAG_DB_CACHED, cached) if cached
-            span.set_tag(Datadog::Ext::NET::TARGET_HOST, config[:host]) if config[:host]
-            span.set_tag(Datadog::Ext::NET::TARGET_PORT, config[:port]) if config[:port]
-          rescue StandardError => e
-            Datadog::Logger.log.debug(e.message)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-require 'ddtrace/contrib/active_record/events/instantiation'
-require 'ddtrace/contrib/active_record/events/sql'
-
-module Datadog
-  module Contrib
-    module ActiveRecord
-      # Defines collection of instrumented ActiveRecord events
-      module Events
-        ALL = [
-          Events::Instantiation,
-          Events::SQL
-        ].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_record/ext.rb

@@ -1,21 +0,0 @@
-module Datadog
-  module Contrib
-    module ActiveRecord
-      # ActiveRecord integration constants
-      module Ext
-        APP = 'active_record'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_ACTIVE_RECORD_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_ACTIVE_RECORD_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'active_record'.freeze
-        SPAN_INSTANTIATION = 'active_record.instantiation'.freeze
-        SPAN_SQL = 'active_record.sql'.freeze
-        SPAN_TYPE_INSTANTIATION = 'custom'.freeze
-        TAG_DB_CACHED = 'active_record.db.cached'.freeze
-        TAG_DB_NAME = 'active_record.db.name'.freeze
-        TAG_DB_VENDOR = 'active_record.db.vendor'.freeze
-        TAG_INSTANTIATION_CLASS_NAME = 'active_record.instantiation.class_name'.freeze
-        TAG_INSTANTIATION_RECORD_COUNT = 'active_record.instantiation.record_count'.freeze
-      end
-    end
-  end
-end