ddtrace 0.13.2 → 0.14.0.beta1

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

@@ -22,9 +22,13 @@ module Datadog
           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]
+            config = Utils.connection_config(payload[:connection_id])
+            settings = Datadog.configuration[:active_record, config]
+            adapter_name = Datadog::Utils::Database.normalize_vendor(config[:adapter])
+            service_name = !settings.nil? ? settings.service_name : configuration[:service_name]
+
+            span.name = "#{adapter_name}.query"
+            span.service = service_name
             span.resource = payload.fetch(:sql)
             span.span_type = Datadog::Ext::SQL::TYPE
 
@@ -33,11 +37,11 @@ module Datadog
             # 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.vendor', adapter_name)
+            span.set_tag('active_record.db.name', config[:database])
             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])
+            span.set_tag('out.host', config[:host]) if config[:host]
+            span.set_tag('out.port', config[:port]) if config[:port]
           rescue StandardError => e
             Datadog::Tracer.log.debug(e.message)
           end

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

@@ -0,0 +1,44 @@
+require 'ddtrace/ext/sql'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/active_record/events'
+require 'ddtrace/contrib/active_record/configuration/resolver'
+require 'ddtrace/contrib/active_record/configuration/settings'
+require 'ddtrace/contrib/active_record/patcher'
+
+module Datadog
+  module Contrib
+    module ActiveRecord
+      # Describes the ActiveRecord integration
+      class Integration
+        include Contrib::Integration
+
+        register_as :active_record, auto_patch: false
+
+        def self.version
+          Gem.loaded_specs['activerecord'] && Gem.loaded_specs['activerecord'].version
+        end
+
+        def self.present?
+          super && defined?(::ActiveRecord)
+        end
+
+        def self.compatible?
+          super && version >= Gem::Version.new('3.0')
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          ActiveRecord::Patcher
+        end
+
+        def resolver
+          @resolver ||= Configuration::Resolver.new
+        end
+      end
+    end
+  end
+end

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/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