ddtrace 0.13.0 → 0.14.0

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

@@ -1,6 +1,4 @@
-require 'ddtrace/ext/sql'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/active_record/utils'
+require 'ddtrace/contrib/patcher'
 require 'ddtrace/contrib/active_record/events'
 
 module Datadog
@@ -8,44 +6,22 @@ module Datadog
     module ActiveRecord
       # Patcher enables patching of 'active_record' module.
       module Patcher
-        include Base
-
-        register_as :active_record, auto_patch: false
-        option :service_name, depends_on: [:tracer] do |value|
-          (value || Utils.adapter_name).tap do |v|
-            get_option(:tracer).set_service_info(v, 'active_record', Ext::AppTypes::DB)
-          end
-        end
-        option :orm_service_name
-        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
-
-        @patched = false
+        include Contrib::Patcher
 
         module_function
 
-        # patched? tells whether patch has been successfully applied
         def patched?
-          @patched
+          done?(:active_record)
         end
 
         def patch
-          if !@patched && defined?(::ActiveRecord)
+          do_once(:active_record) do
             begin
               Events.subscribe!
-              @patched = true
             rescue StandardError => e
               Datadog::Tracer.log.error("Unable to apply Active Record integration: #{e}")
             end
           end
-
-          @patched
         end
       end
     end

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

@@ -4,29 +4,23 @@ module Datadog
       # Common utilities for Rails
       module Utils
         def self.adapter_name
-          connection_config[:adapter_name]
+          Datadog::Utils::Database.normalize_vendor(connection_config[:adapter])
         end
 
         def self.database_name
-          connection_config[:database_name]
+          connection_config[:database]
         end
 
         def self.adapter_host
-          connection_config[:adapter_host]
+          connection_config[:host]
         end
 
         def self.adapter_port
-          connection_config[:adapter_port]
+          connection_config[:port]
         end
 
         def self.connection_config(object_id = nil)
-          config = object_id.nil? ? default_connection_config : connection_config_by_id(object_id)
-          {
-            adapter_name: Datadog::Utils::Database.normalize_vendor(config[:adapter]),
-            adapter_host: config[:host],
-            adapter_port: config[:port],
-            database_name: config[:database]
-          }
+          object_id.nil? ? default_connection_config : connection_config_by_id(object_id)
         end
 
         # Attempt to retrieve the connection from an object ID.

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

@@ -75,11 +75,12 @@ module Datadog
             tracer.trace(@span_name, @options).tap do |span|
               # Assign start time if provided
               span.start_time = start unless start.nil?
+              payload[:datadog_span] = span
             end
           end
 
           def finish_span(name, id, payload, finish = nil)
-            tracer.active_span.tap do |span|
+            payload[:datadog_span].tap do |span|
               # If no active span, return.
               return nil if span.nil?
 

data/lib/ddtrace/contrib/base.rb

@@ -1,5 +1,6 @@
-require 'ddtrace/registry'
 require 'ddtrace/configurable'
+require 'ddtrace/patcher'
+require 'ddtrace/registry/registerable'
 
 module Datadog
   module Contrib
@@ -7,8 +8,8 @@ module Datadog
     module Base
       def self.included(base)
         base.send(:include, Registry::Registerable)
-        base.send(:include, Configurable)
-        base.send(:include, Patcher)
+        base.send(:include, Datadog::Configurable)
+        base.send(:include, Datadog::Patcher)
       end
     end
   end

data/lib/ddtrace/contrib/configurable.rb

@@ -0,0 +1,55 @@
+require 'ddtrace/contrib/configuration/resolver'
+require 'ddtrace/contrib/configuration/settings'
+
+module Datadog
+  module Contrib
+    # Defines configurable behavior for integrations
+    module Configurable
+      def self.included(base)
+        base.send(:include, InstanceMethods)
+      end
+
+      # Configurable instance behavior for integrations
+      module InstanceMethods
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def reset_configuration!
+          @configurations = nil
+          @resolver = nil
+        end
+
+        def configuration(name = :default)
+          name = :default if name.nil?
+          name = resolver.resolve(name)
+          return nil unless configurations.key?(name)
+          configurations[name]
+        end
+
+        def configurations
+          @configurations ||= Hash.new { default_configuration }.tap do |configs|
+            configs[:default] = default_configuration
+          end
+        end
+
+        def configure(name, options = {}, &block)
+          name = resolver.resolve(name || :default)
+
+          configurations[name].tap do |settings|
+            settings.configure(options, &block)
+            configurations[name] = settings
+          end
+        end
+
+        protected
+
+        attr_writer :resolver
+
+        def resolver
+          @resolver ||= Configuration::Resolver.new
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/configuration/option.rb

@@ -0,0 +1,33 @@
+module Datadog
+  module Contrib
+    module Configuration
+      # Represents an instance of an integration configuration option
+      class Option
+        attr_reader \
+          :definition
+
+        def initialize(definition, context)
+          @definition = definition
+          @context = context
+          @value = nil
+          @is_set = false
+        end
+
+        def set(value)
+          @value = @context.instance_exec(value, &definition.setter).tap do
+            @is_set = true
+          end
+        end
+
+        def get
+          return definition.default_value unless @is_set
+          @value
+        end
+
+        def reset
+          set(definition.default_value)
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/configuration/option_definition.rb

@@ -0,0 +1,29 @@
+module Datadog
+  module Contrib
+    module Configuration
+      # Represents a definition for an integration configuration option
+      class OptionDefinition
+        IDENTITY = ->(x) { x }
+
+        attr_reader \
+          :default,
+          :depends_on,
+          :lazy,
+          :name,
+          :setter
+
+        def initialize(name, meta = {}, &block)
+          @default = meta[:default]
+          @depends_on = meta[:depends_on] || []
+          @lazy = meta[:lazy] || false
+          @name = name.to_sym
+          @setter = meta[:setter] || block || IDENTITY
+        end
+
+        def default_value
+          lazy ? @default.call : @default
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/configuration/option_definition_set.rb

@@ -0,0 +1,20 @@
+require 'ddtrace/configuration/resolver'
+
+module Datadog
+  module Contrib
+    module Configuration
+      # Represents a set of configuration option definitions for an integration
+      class OptionDefinitionSet < Hash
+        def dependency_order
+          Datadog::Configuration::Resolver.new(dependency_graph).call
+        end
+
+        def dependency_graph
+          each_with_object({}) do |(name, option), graph|
+            graph[name] = option.depends_on
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/configuration/option_set.rb

@@ -0,0 +1,8 @@
+module Datadog
+  module Contrib
+    module Configuration
+      class OptionSet < Hash
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/configuration/options.rb

@@ -0,0 +1,95 @@
+require 'ddtrace/contrib/configuration/option'
+require 'ddtrace/contrib/configuration/option_set'
+require 'ddtrace/contrib/configuration/option_definition'
+require 'ddtrace/contrib/configuration/option_definition_set'
+
+module Datadog
+  module Contrib
+    module Configuration
+      # Behavior for a configuration object that has options
+      module Options
+        def self.included(base)
+          base.send(:extend, ClassMethods)
+          base.send(:include, InstanceMethods)
+        end
+
+        # Class behavior for a configuration object with options
+        module ClassMethods
+          def options
+            @options ||= begin
+              # Allows for class inheritance of option definitions
+              superclass <= Options ? superclass.options.dup : OptionDefinitionSet.new
+            end
+          end
+
+          protected
+
+          def option(name, meta = {}, &block)
+            options[name] = OptionDefinition.new(name, meta, &block).tap do
+              define_option_accessors(name)
+            end
+          end
+
+          private
+
+          def define_option_accessors(name)
+            option_name = name
+
+            define_method(option_name) do
+              get_option(option_name)
+            end
+
+            define_method("#{option_name}=") do |value|
+              set_option(option_name, value)
+            end
+          end
+        end
+
+        # Instance behavior for a configuration object with options
+        module InstanceMethods
+          def options
+            @options ||= OptionSet.new
+          end
+
+          def set_option(name, value)
+            add_option(name) unless options.key?(name)
+            options[name].set(value)
+          end
+
+          def get_option(name)
+            add_option(name) unless options.key?(name)
+            options[name].get
+          end
+
+          def to_h
+            options.each_with_object({}) do |(key, _), hash|
+              hash[key] = get_option(key)
+            end
+          end
+
+          def reset_options!
+            options.values.each(&:reset)
+          end
+
+          private
+
+          def add_option(name)
+            assert_valid_option!(name)
+            definition = self.class.options[name]
+            Option.new(definition, self).tap do |option|
+              options[name] = option
+            end
+          end
+
+          def assert_valid_option!(name)
+            unless self.class.options.key?(name)
+              raise(InvalidOptionError, "#{self.class.name} doesn't define the option: #{name}")
+            end
+          end
+        end
+
+        InvalidOptionError = Class.new(StandardError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+module Datadog
+  module Contrib
+    module Configuration
+      # Resolves a value to a configuration key
+      class Resolver
+        def resolve(name)
+          name
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require 'ddtrace/contrib/configuration/options'
+
+module Datadog
+  module Contrib
+    module Configuration
+      # Common settings for all integrations
+      class Settings
+        include Options
+
+        option :service_name
+        option :tracer, default: Datadog.tracer
+
+        def initialize(options = {})
+          configure(options)
+        end
+
+        def configure(options = {})
+          self.class.options.dependency_order.each do |name|
+            self[name] = options.fetch(name, self[name])
+          end
+
+          yield(self) if block_given?
+        end
+
+        def [](name)
+          respond_to?(name) ? send(name) : get_option(name)
+        end
+
+        def []=(name, value)
+          respond_to?("#{name}=") ? send("#{name}=", value) : set_option(name, value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Datadog
+  module Contrib
+    module DelayedJob
+      # DelayedJob integration
+      module Patcher
+        include Base
+        register_as :delayed_job
+
+        option :service_name, default: 'delayed_job'.freeze
+        option :tracer, default: Datadog.tracer
+
+        @patched = false
+
+        class << self
+          def patch
+            return @patched if patched? || !defined?(::Delayed)
+
+            require 'ddtrace/ext/app_types'
+            require_relative 'plugin'
+
+            add_instrumentation(::Delayed::Worker)
+            @patched = true
+          rescue => e
+            Tracer.log.error("Unable to apply DelayedJob integration: #{e}")
+            @patched
+          end
+
+          def patched?
+            @patched
+          end
+
+          private
+
+          def add_instrumentation(klass)
+            klass.plugins << Plugin
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/delayed_job/plugin.rb

@@ -0,0 +1,43 @@
+require 'delayed/plugin'
+
+module Datadog
+  module Contrib
+    module DelayedJob
+      # DelayedJob plugin that instruments invoke_job hook
+      class Plugin < Delayed::Plugin
+        def self.instrument(job, &block)
+          return block.call(job) unless tracer && tracer.enabled
+
+          tracer.trace('delayed_job'.freeze, service: configuration[:service_name], resource: job.name) do |span|
+            span.set_tag('delayed_job.id'.freeze, job.id)
+            span.set_tag('delayed_job.queue'.freeze, job.queue) if job.queue
+            span.set_tag('delayed_job.priority'.freeze, job.priority)
+            span.set_tag('delayed_job.attempts'.freeze, job.attempts)
+            span.span_type = Ext::AppTypes::WORKER
+
+            yield job
+          end
+        end
+
+        def self.flush(worker, &block)
+          yield worker
+
+          tracer.shutdown! if tracer && tracer.enabled
+        end
+
+        def self.configuration
+          Datadog.configuration[:delayed_job]
+        end
+
+        def self.tracer
+          configuration[:tracer]
+        end
+
+        callbacks do |lifecycle|
+          lifecycle.around(:invoke_job, &method(:instrument))
+          lifecycle.around(:execute, &method(:flush))
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/integration.rb

@@ -0,0 +1,16 @@
+require 'ddtrace/contrib/configurable'
+require 'ddtrace/contrib/patchable'
+require 'ddtrace/contrib/registerable'
+
+module Datadog
+  module Contrib
+    # Base provides features that are shared across all integrations
+    module Integration
+      def self.included(base)
+        base.send(:include, Configurable)
+        base.send(:include, Patchable)
+        base.send(:include, Registerable)
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/patchable.rb

@@ -0,0 +1,38 @@
+module Datadog
+  module Contrib
+    # Base provides features that are shared across all integrations
+    module Patchable
+      def self.included(base)
+        base.send(:extend, ClassMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      # Class methods for integrations
+      module ClassMethods
+        def version
+          nil
+        end
+
+        def present?
+          !version.nil?
+        end
+
+        def compatible?
+          RUBY_VERSION >= '1.9.3' && present?
+        end
+      end
+
+      # Instance methods for integrations
+      module InstanceMethods
+        def patcher
+          nil
+        end
+
+        def patch
+          return if !self.class.compatible? || patcher.nil?
+          patcher.patch
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/patcher.rb

@@ -0,0 +1,28 @@
+require 'ddtrace/patcher'
+
+module Datadog
+  module Contrib
+    # Common behavior for patcher modules
+    module Patcher
+      def self.included(base)
+        base.send(:include, Datadog::Patcher)
+        base.send(:extend, InstanceMethods)
+        base.send(:include, InstanceMethods)
+      end
+
+      # Class methods for patchers
+      module ClassMethods
+        def patch
+          raise NotImplementedError, '#patch not implemented for Patcher!'
+        end
+      end
+
+      # Instance methods for patchers
+      module InstanceMethods
+        def patch
+          raise NotImplementedError, '#patch not implemented for Patcher!'
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/rack/middlewares.rb

@@ -13,6 +13,7 @@ module Datadog
       # in the Rack environment so that it can be retrieved by the underlying
       # application. If request tags are not set by the app, they will be set using
       # information available at the Rack level.
+      # rubocop:disable Metrics/ClassLength
       class TraceMiddleware
         RACK_REQUEST_SPAN = 'datadog.rack_request_span'.freeze
 
@@ -58,11 +59,12 @@ module Datadog
           request_span = tracer.trace('rack.request', trace_options)
           env[RACK_REQUEST_SPAN] = request_span
 
-          # TODO: For backwards compatibility; this attribute is deprecated.
-          env[:datadog_rack_request_span] = env[RACK_REQUEST_SPAN]
-
           # Add deprecation warnings
           add_deprecation_warnings(env)
+          env.without_datadog_warnings do
+            # TODO: For backwards compatibility; this attribute is deprecated.
+            env[:datadog_rack_request_span] = env[RACK_REQUEST_SPAN]
+          end
 
           # Copy the original env, before the rest of the stack executes.
           # Values may change; we want values before that happens.
@@ -175,24 +177,41 @@ module Datadog
           :datadog_rack_request_span is considered an internal symbol in the Rack env,
           and has been been DEPRECATED. Public support for its usage is discontinued.
           If you need the Rack request span, try using `Datadog.tracer.active_span`.
-          This key will be removed in version 0.14.0).freeze
+          This key will be removed in version 1.0).freeze
 
         def add_deprecation_warnings(env)
           env.instance_eval do
-            def [](key)
-              if key == :datadog_rack_request_span && !@request_span_warning_issued
-                Datadog::Tracer.log.warn(REQUEST_SPAN_DEPRECATION_WARNING)
-                @request_span_warning_issued = true
+            unless instance_variable_defined?(:@patched_with_datadog_warnings)
+              @patched_with_datadog_warnings = true
+              @datadog_deprecation_warnings = true
+              @datadog_span_warning = true
+
+              def [](key)
+                if key == :datadog_rack_request_span \
+                  && @datadog_span_warning \
+                  && @datadog_deprecation_warnings
+                  Datadog::Tracer.log.warn(REQUEST_SPAN_DEPRECATION_WARNING)
+                  @datadog_span_warning = true
+                end
+                super
+              end
+
+              def []=(key, value)
+                if key == :datadog_rack_request_span \
+                  && @datadog_span_warning \
+                  && @datadog_deprecation_warnings
+                  Datadog::Tracer.log.warn(REQUEST_SPAN_DEPRECATION_WARNING)
+                  @datadog_span_warning = true
+                end
+                super
               end
-              super
-            end
 
-            def []=(key, value)
-              if key == :datadog_rack_request_span && !@request_span_warning_issued
-                Datadog::Tracer.log.warn(REQUEST_SPAN_DEPRECATION_WARNING)
-                @request_span_warning_issued = true
+              def without_datadog_warnings
+                @datadog_deprecation_warnings = false
+                yield
+              ensure
+                @datadog_deprecation_warnings = true
               end
-              super
             end
           end
         end