ddtrace 0.12.1 → 0.13.0.beta1

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/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/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'.freeze)
-
-          span.set_tag('active_record.db.vendor'.freeze, connection_config[:adapter_name])
-          span.set_tag('active_record.db.name'.freeze, connection_config[:database_name])
-          span.set_tag('active_record.db.cached'.freeze, cached) if cached
-          span.set_tag('out.host'.freeze, connection_config[:adapter_host])
-          span.set_tag('out.port'.freeze, 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'.freeze
-                         end
-
-          span.resource = payload.fetch(:class_name)
-          span.span_type = 'custom'.freeze
-          span.set_tag('active_record.instantiation.class_name'.freeze, payload.fetch(:class_name))
-          span.set_tag('active_record.instantiation.record_count'.freeze, 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 = RESOURCE
-          span.resource = context.safely(:resource)
+          span.name = context.safely(:resource)
+          span.resource = 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, &block)
+            def initialize(*args)
               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, &block)
+              initialize_without_datadog(*args)
             end
 
             alias_method :perform_request_without_datadog, :perform_request

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

@@ -6,7 +6,11 @@ module Datadog
         PLACEHOLDER = '?'.freeze
         EXCLUDE_KEYS = [].freeze
         SHOW_KEYS = [:_index, :_type, :_id].freeze
-        DEFAULT_OPTIONS = { exclude: EXCLUDE_KEYS, show: SHOW_KEYS }.freeze
+        DEFAULT_OPTIONS = {
+          exclude: EXCLUDE_KEYS,
+          show: SHOW_KEYS,
+          placeholder: PLACEHOLDER
+        }.freeze
 
         ID_REGEXP = %r{\/([0-9]+)([\/\?]|$)}
         ID_PLACEHOLDER = '/?\2'.freeze
@@ -25,7 +29,7 @@ module Datadog
         def format_body(body, options = {})
           format_body!(body, options)
         rescue StandardError
-          PLACEHOLDER
+          options[:placeholder] || PLACEHOLDER
         end
 
         def format_body!(body, options = {})
@@ -36,48 +40,12 @@ module Datadog
 
           # Parse each statement and quantize them.
           statements.collect do |string|
-            reserialize_json(string) do |obj|
-              format_statement(obj, options)
+            reserialize_json(string, options[:placeholder]) do |obj|
+              Datadog::Quantization::Hash.format(obj, options)
             end
           end.join("\n")
         end
 
-        def format_statement(statement, options = {})
-          return statement if options[:show] == :all
-
-          case statement
-          when Hash
-            statement.each_with_object({}) do |(key, value), quantized|
-              if options[:show].include?(key.to_sym)
-                quantized[key] = value
-              elsif !options[:exclude].include?(key.to_sym)
-                quantized[key] = format_value(value, options)
-              end
-            end
-          else
-            format_value(statement, options)
-          end
-        end
-
-        def format_value(value, options = {})
-          return value if options[:show] == :all
-
-          case value
-          when Hash
-            format_statement(value, options)
-          when Array
-            # If any are objects, format them.
-            if value.any? { |v| v.class <= Hash || v.class <= Array }
-              value.collect { |i| format_value(i, options) }
-            # Otherwise short-circuit and return single placeholder
-            else
-              PLACEHOLDER
-            end
-          else
-            PLACEHOLDER
-          end
-        end
-
         def merge_options(original, additional)
           {}.tap do |options|
             # Show

data/lib/ddtrace/contrib/excon/middleware.rb

@@ -0,0 +1,140 @@
+require 'excon'
+require 'ddtrace/ext/http'
+require 'ddtrace/ext/net'
+require 'ddtrace/ext/distributed'
+require 'ddtrace/propagation/http_propagator'
+
+module Datadog
+  module Contrib
+    module Excon
+      # Middleware implements an excon-middleware for ddtrace instrumentation
+      class Middleware < ::Excon::Middleware::Base
+        SPAN_NAME = 'excon.request'.freeze
+        DEFAULT_ERROR_HANDLER = lambda do |response|
+          Ext::HTTP::ERROR_RANGE.cover?(response[:status])
+        end
+
+        def initialize(stack, options = {})
+          super(stack)
+          @options = Datadog.configuration[:excon].merge(options)
+        end
+
+        def request_call(datum)
+          begin
+            unless datum.key?(:datadog_span)
+              tracer.trace(SPAN_NAME).tap do |span|
+                datum[:datadog_span] = span
+                annotate!(span, datum)
+                propagate!(span, datum) if distributed_tracing?
+              end
+            end
+          rescue StandardError => e
+            Datadog::Tracer.log.debug(e.message)
+          end
+
+          @stack.request_call(datum)
+        end
+
+        def response_call(datum)
+          @stack.response_call(datum).tap do |d|
+            handle_response(d)
+          end
+        end
+
+        def error_call(datum)
+          @stack.error_call(datum).tap do |d|
+            handle_response(d)
+          end
+        end
+
+        # Returns a child class of this trace middleware
+        # With options given as defaults.
+        def self.with(options = {})
+          Class.new(self) do
+            @options = options
+
+            # rubocop:disable Style/TrivialAccessors
+            def self.options
+              @options
+            end
+
+            def initialize(stack)
+              super(stack, self.class.options)
+            end
+          end
+        end
+
+        # Returns a copy of the default stack with the trace middleware injected
+        def self.around_default_stack
+          ::Excon.defaults[:middlewares].dup.tap do |default_stack|
+            # If the default stack contains a version of the trace middleware already...
+            existing_trace_middleware = default_stack.find { |m| m <= Middleware }
+            default_stack.delete(existing_trace_middleware) if existing_trace_middleware
+
+            # Inject after the ResponseParser middleware
+            response_middleware_index = default_stack.index(::Excon::Middleware::ResponseParser).to_i
+            default_stack.insert(response_middleware_index + 1, self)
+          end
+        end
+
+        private
+
+        def tracer
+          @options[:tracer]
+        end
+
+        def distributed_tracing?
+          @options[:distributed_tracing] == true && tracer.enabled
+        end
+
+        def error_handler
+          @options[:error_handler] || DEFAULT_ERROR_HANDLER
+        end
+
+        def split_by_domain?
+          @options[:split_by_domain] == true
+        end
+
+        def annotate!(span, datum)
+          span.resource = datum[:method].to_s.upcase
+          span.service = service_name(datum)
+          span.span_type = Ext::HTTP::TYPE
+          span.set_tag(Ext::HTTP::URL, datum[:path])
+          span.set_tag(Ext::HTTP::METHOD, datum[:method].to_s.upcase)
+          span.set_tag(Ext::NET::TARGET_HOST, datum[:host])
+          span.set_tag(Ext::NET::TARGET_PORT, datum[:port].to_s)
+        end
+
+        def handle_response(datum)
+          if datum.key?(:datadog_span)
+            datum[:datadog_span].tap do |span|
+              return span if span.finished?
+
+              if datum.key?(:response)
+                response = datum[:response]
+                if error_handler.call(response)
+                  span.set_error(["Error #{response[:status]}", response[:body]])
+                end
+                span.set_tag(Ext::HTTP::STATUS_CODE, response[:status])
+              end
+              span.set_error(datum[:error]) if datum.key?(:error)
+              span.finish
+              datum.delete(:datadog_span)
+            end
+          end
+        rescue StandardError => e
+          Datadog::Tracer.log.debug(e.message)
+        end
+
+        def propagate!(span, datum)
+          Datadog::HTTPPropagator.inject!(span.context, datum[:headers])
+        end
+
+        def service_name(datum)
+          # TODO: Change this to implement more sensible multiplexing
+          split_by_domain? ? datum[:host] : @options[:service_name]
+        end
+      end
+    end
+  end
+end