ddtrace 0.12.0 → 0.13.0

data/lib/ddtrace/configuration.rb

@@ -9,11 +9,11 @@ module Datadog
 
     def initialize(options = {})
       @registry = options.fetch(:registry, Datadog.registry)
+      @wrapped_registry = {}
     end
 
     def [](integration_name)
-      integration = fetch_integration(integration_name)
-      Proxy.new(integration)
+      @wrapped_registry[integration_name] ||= Proxy.new(fetch_integration(integration_name))
     end
 
     def use(integration_name, options = {})

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

@@ -0,0 +1,57 @@
+require 'ddtrace/contrib/active_support/notifications/event'
+
+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 the resource name and serializer name
+            res = resource(payload[:serializer])
+            span.resource = res
+            span.set_tag('active_model_serializers.serializer', res)
+
+            span.span_type = Datadog::Ext::HTTP::TEMPLATE
+
+            # Will be nil in 0.9
+            span.set_tag('active_model_serializers.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

@@ -0,0 +1,32 @@
+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
+          SPAN_NAME = 'active_model_serializers.render'.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
+            self::SPAN_NAME
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+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
+          SPAN_NAME = 'active_model_serializers.serialize'.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
+            self::SPAN_NAME
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+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/patcher.rb

@@ -0,0 +1,62 @@
+require 'ddtrace/ext/app_types'
+require 'ddtrace/ext/http'
+require 'ddtrace/contrib/active_model_serializers/events'
+
+module Datadog
+  module Contrib
+    module ActiveModelSerializers
+      # Provides instrumentation for ActiveModelSerializers through ActiveSupport instrumentation signals
+      module Patcher
+        include Base
+
+        VERSION_REQUIRED = Gem::Version.new('0.9.0')
+
+        register_as :active_model_serializers
+
+        option :service_name, default: 'active_model_serializers'
+        option :tracer, default: Datadog.tracer do |value|
+          (value || Datadog.tracer).tap do |v|
+            # Make sure to update tracers of all subscriptions
+            Events.subscriptions.each do |subscription|
+              subscription.tracer = v
+            end
+          end
+        end
+
+        class << self
+          def patch
+            return patched? if patched? || !compatible?
+
+            # Subscribe to ActiveModelSerializers events
+            Events.subscribe!
+
+            # Set service info
+            configuration[:tracer].set_service_info(
+              configuration[:service_name],
+              'active_model_serializers',
+              Ext::AppTypes::WEB
+            )
+
+            @patched = true
+          end
+
+          def patched?
+            return @patched if defined?(@patched)
+            @patched = false
+          end
+
+          private
+
+          def configuration
+            Datadog.configuration[:active_model_serializers]
+          end
+
+          def compatible?
+            Gem.loaded_specs['active_model_serializers'] && Gem.loaded_specs['activesupport'] \
+              && Gem.loaded_specs['active_model_serializers'].version >= VERSION_REQUIRED
+          end
+        end
+      end
+    end
+  end
+end

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

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

@@ -0,0 +1,51 @@
+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
+          SPAN_NAME = 'active_record.instantiation'.freeze
+          DEFAULT_SERVICE_NAME = '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
+            self::SPAN_NAME
+          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
+                             self::DEFAULT_SERVICE_NAME
+                           end
+
+            span.resource = payload.fetch(:class_name)
+            span.span_type = 'custom'
+            span.set_tag('active_record.instantiation.class_name', payload.fetch(:class_name))
+            span.set_tag('active_record.instantiation.record_count', payload.fetch(:record_count))
+          rescue StandardError => e
+            Datadog::Tracer.log.debug(e.message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+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
+          SPAN_NAME = 'active_record.sql'.freeze
+
+          module_function
+
+          def event_name
+            self::EVENT_NAME
+          end
+
+          def span_name
+            self::SPAN_NAME
+          end
+
+          def process(span, event, _id, payload)
+            connection_config = Utils.connection_config(payload[:connection_id])
+            span.name = "#{connection_config[:adapter_name]}.query"
+            span.service = configuration[:service_name]
+            span.resource = payload.fetch(:sql)
+            span.span_type = Datadog::Ext::SQL::TYPE
+
+            # 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] == 'CACHE')
+
+            span.set_tag('active_record.db.vendor', connection_config[:adapter_name])
+            span.set_tag('active_record.db.name', connection_config[:database_name])
+            span.set_tag('active_record.db.cached', cached) if cached
+            span.set_tag('out.host', connection_config[:adapter_host])
+            span.set_tag('out.port', connection_config[:adapter_port])
+          rescue StandardError => e
+            Datadog::Tracer.log.debug(e.message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+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/patcher.rb

@@ -1,7 +1,7 @@
 require 'ddtrace/ext/sql'
 require 'ddtrace/ext/app_types'
 require 'ddtrace/contrib/active_record/utils'
-require 'ddtrace/contrib/active_support/notifications/subscriber'
+require 'ddtrace/contrib/active_record/events'
 
 module Datadog
   module Contrib
@@ -9,10 +9,6 @@ module Datadog
       # Patcher enables patching of 'active_record' module.
       module Patcher
         include Base
-        include ActiveSupport::Notifications::Subscriber
-
-        NAME_SQL = 'sql.active_record'.freeze
-        NAME_INSTANTIATION = 'instantiation.active_record'.freeze
 
         register_as :active_record, auto_patch: false
         option :service_name, depends_on: [:tracer] do |value|
@@ -24,7 +20,7 @@ module Datadog
         option :tracer, default: Datadog.tracer do |value|
           (value || Datadog.tracer).tap do |v|
             # Make sure to update tracers of all subscriptions
-            subscriptions.each do |subscription|
+            Events.subscriptions.each do |subscription|
               subscription.tracer = v
             end
           end
@@ -32,28 +28,6 @@ module Datadog
 
         @patched = false
 
-        on_subscribe do
-          # sql.active_record
-          subscribe(
-            self::NAME_SQL,                         # Event name
-            'active_record.sql',                    # Span name
-            { service: get_option(:service_name) }, # Span options
-            get_option(:tracer),                    # Tracer
-            &method(:sql)                           # Handler
-          )
-
-          # instantiation.active_record
-          if instantiation_tracing_supported?
-            subscribe(
-              self::NAME_INSTANTIATION,               # Event name
-              'active_record.instantiation',          # Span name
-              { service: get_option(:service_name) }, # Span options
-              get_option(:tracer),                    # Tracer
-              &method(:instantiation)                 # Handler
-            )
-          end
-        end
-
         module_function
 
         # patched? tells whether patch has been successfully applied
@@ -64,7 +38,7 @@ module Datadog
         def patch
           if !@patched && defined?(::ActiveRecord)
             begin
-              subscribe!
+              Events.subscribe!
               @patched = true
             rescue StandardError => e
               Datadog::Tracer.log.error("Unable to apply Active Record integration: #{e}")
@@ -73,50 +47,6 @@ module Datadog
 
           @patched
         end
-
-        def instantiation_tracing_supported?
-          Gem.loaded_specs['activerecord'] \
-            && Gem.loaded_specs['activerecord'].version >= Gem::Version.new('4.2')
-        end
-
-        def sql(span, event, _id, payload)
-          connection_config = Utils.connection_config(payload[:connection_id])
-          span.name = "#{connection_config[:adapter_name]}.query"
-          span.service = get_option(:service_name)
-          span.resource = payload.fetch(:sql)
-          span.span_type = Datadog::Ext::SQL::TYPE
-
-          # 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] == 'CACHE')
-
-          span.set_tag('active_record.db.vendor', connection_config[:adapter_name])
-          span.set_tag('active_record.db.name', connection_config[:database_name])
-          span.set_tag('active_record.db.cached', cached) if cached
-          span.set_tag('out.host', connection_config[:adapter_host])
-          span.set_tag('out.port', connection_config[:adapter_port])
-        rescue StandardError => e
-          Datadog::Tracer.log.debug(e.message)
-        end
-
-        def instantiation(span, event, _id, payload)
-          # Inherit service name from parent, if available.
-          span.service = if get_option(:orm_service_name)
-                           get_option(:orm_service_name)
-                         elsif span.parent
-                           span.parent.service
-                         else
-                           'active_record'
-                         end
-
-          span.resource = payload.fetch(:class_name)
-          span.span_type = 'custom'
-          span.set_tag('active_record.instantiation.class_name', payload.fetch(:class_name))
-          span.set_tag('active_record.instantiation.record_count', payload.fetch(:record_count))
-        rescue StandardError => e
-          Datadog::Tracer.log.debug(e.message)
-        end
       end
     end
   end

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

@@ -3,20 +3,6 @@ module Datadog
     module ActiveRecord
       # Common utilities for Rails
       module Utils
-        # Return a canonical name for a type of database
-        def self.normalize_vendor(vendor)
-          case vendor
-          when nil
-            'defaultdb'
-          when 'postgresql'
-            'postgres'
-          when 'sqlite3'
-            'sqlite'
-          else
-            vendor
-          end
-        end
-
         def self.adapter_name
           connection_config[:adapter_name]
         end
@@ -36,7 +22,7 @@ module Datadog
         def self.connection_config(object_id = nil)
           config = object_id.nil? ? default_connection_config : connection_config_by_id(object_id)
           {
-            adapter_name: normalize_vendor(config[:adapter]),
+            adapter_name: Datadog::Utils::Database.normalize_vendor(config[:adapter]),
             adapter_host: config[:host],
             adapter_port: config[:port],
             database_name: config[:database]

data/lib/ddtrace/contrib/active_support/notifications/event.rb

@@ -0,0 +1,62 @@
+require 'ddtrace/contrib/active_support/notifications/subscriber'
+
+module Datadog
+  module Contrib
+    module ActiveSupport
+      module Notifications
+        # Defines behaviors for an ActiveSupport::Notifications event.
+        # Compose this into a module or class, then define
+        # #event_name, #span_name, and #process. You can then
+        # invoke Event.subscribe! to more easily subscribe to an event.
+        module Event
+          def self.included(base)
+            base.send(:include, Subscriber)
+            base.send(:extend, ClassMethods)
+            base.send(:on_subscribe) { base.subscribe }
+          end
+
+          # Redefines some class behaviors for a Subscriber to make
+          # it a bit simpler for an Event.
+          module ClassMethods
+            def subscribe!
+              super
+            end
+
+            def subscription(span_name = nil, options = nil, tracer = nil)
+              super(
+                span_name || self.span_name,
+                options || span_options,
+                tracer || self.tracer,
+                &method(:process)
+              )
+            end
+
+            def subscribe(pattern = nil, span_name = nil, options = nil, tracer = nil)
+              if supported?
+                super(
+                  pattern || event_name,
+                  span_name || self.span_name,
+                  options || span_options,
+                  tracer || self.tracer,
+                  &method(:process)
+                )
+              end
+            end
+
+            def supported?
+              true
+            end
+
+            def span_options
+              {}
+            end
+
+            def tracer
+              Datadog.tracer
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/aws/instrumentation.rb

@@ -27,8 +27,8 @@ module Datadog
         def annotate!(span, pin, context)
           span.service = pin.service
           span.span_type = pin.app_type
-          span.name = context.safely(:resource)
-          span.resource = RESOURCE
+          span.name = RESOURCE
+          span.resource = context.safely(:resource)
           span.set_tag('aws.agent', AGENT)
           span.set_tag('aws.operation', context.safely(:operation))
           span.set_tag('aws.region', context.safely(:region))

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

@@ -52,11 +52,11 @@ module Datadog
               remove_method :initialize
             end
 
-            def initialize(*args)
+            def initialize(*args, &block)
               service = Datadog.configuration[:elasticsearch][:service_name]
               pin = Datadog::Pin.new(service, app: 'elasticsearch', app_type: Datadog::Ext::AppTypes::DB)
               pin.onto(self)
-              initialize_without_datadog(*args)
+              initialize_without_datadog(*args, &block)
             end
 
             alias_method :perform_request_without_datadog, :perform_request