ddtrace 0.54.0 → 1.0.0

data/lib/datadog/tracing/contrib/active_record/configuration/makara_resolver.rb

@@ -0,0 +1,36 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveRecord
+        module Configuration
+          # The `makara` gem has the concept of **role**, which can be
+          # inferred from the configuration `name`, in the form of:
+          # `master/0`, `replica/0`, `replica/1`, etc.
+          # The first part of this string is the database role.
+          #
+          # This allows the matching of a connection based on its role,
+          # instead of connection-specific information.
+          module MakaraResolver
+            def normalize_for_config(active_record_config)
+              hash = super
+              hash[:makara_role] = active_record_config[:makara_role]
+              hash
+            end
+
+            def normalize_for_resolve(active_record_config)
+              hash = super
+
+              if active_record_config[:name].is_a?(String)
+                hash[:makara_role] = active_record_config[:name].split('/')[0].to_s
+              end
+
+              hash
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_record/configuration/resolver.rb

@@ -0,0 +1,138 @@
+# typed: false
+
+require 'datadog/tracing/contrib/configuration/resolver'
+require 'datadog/tracing/contrib/active_record/vendor/connection_specification'
+require_relative 'makara_resolver'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveRecord
+        module Configuration
+          # Converts Symbols, Strings, and Hashes to a normalized connection settings Hash.
+          #
+          # When matching using a Hash, these are the valid fields:
+          # ```
+          # {
+          #   adapter: ...,
+          #   host: ...,
+          #   port: ...,
+          #   database: ...,
+          #   username: ...,
+          #   role: ...,
+          # }
+          # ```
+          #
+          # Partial matching is supported: not including certain fields or setting them to `nil`
+          # will cause them to matching all values for that field. For example: `database: nil`
+          # will match any database, given the remaining fields match.
+          #
+          # Any fields not listed above are discarded.
+          #
+          # When more than one configuration could be matched, the last one to match is selected,
+          # based on addition order (`#add`).
+          class Resolver < Contrib::Configuration::Resolver
+            prepend MakaraResolver
+
+            def initialize(active_record_configuration = nil)
+              super()
+
+              @active_record_configuration = active_record_configuration
+            end
+
+            def active_record_configuration
+              @active_record_configuration || ::ActiveRecord::Base.configurations
+            end
+
+            def add(matcher, value)
+              parsed = parse_matcher(matcher)
+
+              # In case of error parsing, don't store `nil` key
+              # as it wouldn't be useful for matching configuration
+              # hashes in `#resolve`.
+              super(parsed, value) if parsed
+            end
+
+            def resolve(db_config)
+              active_record_config = resolve_connection_key(db_config).symbolize_keys
+
+              hash = normalize_for_resolve(active_record_config)
+
+              # Hashes in Ruby maintain insertion order
+              _, config = @configurations.reverse_each.find do |matcher, _|
+                matcher.none? do |key, value|
+                  value != hash[key]
+                end
+              end
+
+              config
+            rescue => e
+              Datadog.logger.error(
+                "Failed to resolve ActiveRecord configuration key #{db_config.inspect}. " \
+                "Cause: #{e.message} Source: #{Array(e.backtrace).first}"
+              )
+
+              nil
+            end
+
+            protected
+
+            def parse_matcher(matcher)
+              resolved_pattern = resolve_connection_key(matcher).symbolize_keys
+              normalized = normalize_for_config(resolved_pattern)
+
+              # Remove empty fields to allow for partial matching
+              normalized.reject! { |_, v| v.nil? }
+
+              normalized
+            rescue => e
+              Datadog.logger.error(
+                "Failed to resolve ActiveRecord configuration key #{matcher.inspect}. " \
+                "Cause: #{e.message} Source: #{Array(e.backtrace).first}"
+              )
+            end
+
+            def connection_resolver
+              @resolver ||= if defined?(::ActiveRecord::Base.configurations.resolve)
+                              ::ActiveRecord::DatabaseConfigurations.new(active_record_configuration)
+                            elsif defined?(::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver)
+                              ::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver.new(
+                                active_record_configuration
+                              )
+                            else
+                              Contrib::ActiveRecord::Vendor::ConnectionAdapters::ConnectionSpecification::Resolver.new(
+                                active_record_configuration
+                              )
+                            end
+            end
+
+            def resolve_connection_key(key)
+              result = connection_resolver.resolve(key)
+
+              if result.respond_to?(:configuration_hash) # Rails >= 6.1
+                result.configuration_hash
+              else # Rails < 6.1
+                result
+              end
+            end
+
+            # Extract only fields we'd like to match
+            # from the ActiveRecord configuration.
+            def normalize_for_config(active_record_config)
+              {
+                adapter: active_record_config[:adapter],
+                host: active_record_config[:host],
+                port: active_record_config[:port],
+                database: active_record_config[:database],
+                username: active_record_config[:username]
+              }
+            end
+
+            # Both resolvers perform the same operations for this implementation, but can be specialized
+            alias_method :normalize_for_resolve, :normalize_for_config
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_record/configuration/settings.rb

@@ -0,0 +1,39 @@
+# typed: false
+
+require 'datadog/tracing/contrib/configuration/settings'
+require 'datadog/tracing/contrib/active_record/ext'
+require 'datadog/tracing/contrib/active_record/utils'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveRecord
+        module Configuration
+          # Custom settings for the ActiveRecord integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+              o.lazy
+            end
+
+            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 do |o|
+              o.default { Utils.adapter_name }
+              o.lazy
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_record/event.rb

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

data/lib/datadog/tracing/contrib/active_record/events/instantiation.rb

@@ -0,0 +1,58 @@
+# typed: false
+
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/active_record/ext'
+require 'datadog/tracing/contrib/active_record/event'
+
+module Datadog
+  module Tracing
+    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)
+              span.resource = payload.fetch(:class_name)
+              span.span_type = Ext::SPAN_TYPE_INSTANTIATION
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_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.debug(e.message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_record/events/sql.rb

@@ -0,0 +1,78 @@
+# typed: false
+
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/contrib/active_record/event'
+require 'datadog/tracing/contrib/active_record/ext'
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/utils/database'
+
+module Datadog
+  module Tracing
+    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.tracing[:active_record, config]
+              adapter_name = Contrib::Utils::Database.normalize_vendor(config[:adapter])
+              service_name = if settings.service_name != Contrib::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 = Tracing::Metadata::Ext::SQL::TYPE
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_SQL)
+
+              # Tag as an external peer service
+              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, span.service)
+              # TODO: Populate hostname for JDBC connections
+              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, config[:host]) if config[:host]
+
+              # 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(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, config[:host]) if config[:host]
+              span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, config[:port]) if config[:port]
+            rescue StandardError => e
+              Datadog.logger.debug(e.message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_record/events.rb

@@ -0,0 +1,34 @@
+# typed: false
+
+require 'datadog/tracing/contrib/active_record/events/instantiation'
+require 'datadog/tracing/contrib/active_record/events/sql'
+
+module Datadog
+  module Tracing
+    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
+end

data/lib/datadog/tracing/contrib/active_record/ext.rb

@@ -0,0 +1,29 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveRecord
+        # ActiveRecord integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_ACTIVE_RECORD_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTIVE_RECORD_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_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_COMPONENT = 'active_record'.freeze
+          TAG_OPERATION_INSTANTIATION = 'instantiation'.freeze
+          TAG_OPERATION_SQL = 'sql'.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
+end

data/lib/datadog/tracing/contrib/active_record/integration.rb

@@ -0,0 +1,56 @@
+# typed: false
+
+require 'datadog/tracing/contrib/active_record/configuration/resolver'
+require 'datadog/tracing/contrib/active_record/configuration/settings'
+require 'datadog/tracing/contrib/active_record/events'
+require 'datadog/tracing/contrib/active_record/patcher'
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/rails/utils'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveRecord
+        # Describes the ActiveRecord integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('3.2')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :active_record, auto_patch: false
+
+          def self.version
+            Gem.loaded_specs['activerecord'] && Gem.loaded_specs['activerecord'].version
+          end
+
+          def self.loaded?
+            !defined?(::ActiveRecord).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          # enabled by rails integration so should only auto instrument
+          # if detected that it is being used without rails
+          def auto_instrument?
+            !Contrib::Rails::Utils.railtie_supported?
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            ActiveRecord::Patcher
+          end
+
+          def resolver
+            @resolver ||= Configuration::Resolver.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_record/patcher.rb

@@ -0,0 +1,27 @@
+# typed: true
+
+require 'datadog/tracing/contrib/patcher'
+require 'datadog/tracing/contrib/active_record/events'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveRecord
+        # Patcher enables patching of 'active_record' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            Events.subscribe!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_record/utils.rb

@@ -0,0 +1,128 @@
+# typed: false
+
+require 'datadog/core/environment/ext'
+require 'datadog/tracing/contrib/utils/database'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveRecord
+        # Common utilities for Rails
+        module Utils
+          EMPTY_CONFIG = {}.freeze
+
+          def self.adapter_name
+            Contrib::Utils::Database.normalize_vendor(connection_config[:adapter])
+          end
+
+          def self.database_name
+            connection_config[:database]
+          end
+
+          def self.adapter_host
+            connection_config[:host]
+          end
+
+          def self.adapter_port
+            connection_config[:port]
+          end
+
+          # Returns the connection configuration hash from the
+          # current connection
+          #
+          # Since Rails 6.0, we have direct access to the object,
+          # while older versions of Rails only provide us the
+          # connection id.
+          #
+          # @see https://github.com/rails/rails/pull/34602
+          def self.connection_config(connection = nil, connection_id = nil)
+            return default_connection_config if connection.nil? && connection_id.nil?
+
+            conn = if !connection.nil?
+                     # Since Rails 6.0, the connection object
+                     # is directly available.
+                     connection
+                   else
+                     # For Rails < 6.0, only the `connection_id`
+                     # is available. We have to find the connection
+                     # object from it.
+                     connection_from_id(connection_id)
+                   end
+
+            if conn && conn.instance_variable_defined?(:@config)
+              conn.instance_variable_get(:@config)
+            else
+              EMPTY_CONFIG
+            end
+          end
+
+          # DEV: JRuby responds to {ObjectSpace._id2ref}, despite raising an error
+          # DEV: when invoked. Thus, we have to explicitly check for Ruby runtime.
+          if Core::Environment::Ext::RUBY_ENGINE != 'jruby'
+            # CRuby has access to {ObjectSpace._id2ref}, which allows for
+            # direct look up of the connection object.
+            def self.connection_from_id(connection_id)
+              # `connection_id` is the `#object_id` of the
+              # connection. We can perform an ObjectSpace
+              # lookup to find it.
+              #
+              # This works not only for ActiveRecord, but for
+              # extensions that might have their own connection
+              # pool (e.g. https://rubygems.org/gems/makara).
+              ObjectSpace._id2ref(connection_id)
+            rescue => e
+              # Because `connection_id` references a live connection
+              # present in the current stack, it is very unlikely that
+              # `_id2ref` will fail, but we add this safeguard just
+              # in case.
+              Datadog.logger.debug(
+                "connection_id #{connection_id} does not represent a valid object. " \
+                        "Cause: #{e.message} Source: #{Array(e.backtrace).first}"
+              )
+            end
+          else
+            # JRuby does not enable {ObjectSpace._id2ref} by default,
+            # as it has large performance impact:
+            # https://github.com/jruby/jruby/wiki/PerformanceTuning/cf155dd9#dont-enable-objectspace
+            #
+            # This fallback code does not support the makara gem,
+            # as its connections don't live in the ActiveRecord
+            # connection pool.
+            def self.connection_from_id(connection_id)
+              ::ActiveRecord::Base
+                .connection_handler
+                .connection_pool_list
+                .flat_map(&:connections)
+                .find { |c| c.object_id == connection_id }
+            end
+          end
+
+          # @return [Hash]
+          def self.default_connection_config
+            return @default_connection_config if instance_variable_defined?(:@default_connection_config)
+
+            current_connection_name = if ::ActiveRecord::Base.respond_to?(:connection_specification_name)
+                                        ::ActiveRecord::Base.connection_specification_name
+                                      else
+                                        ::ActiveRecord::Base
+                                      end
+
+            connection_pool = ::ActiveRecord::Base.connection_handler.retrieve_connection_pool(current_connection_name)
+            connection_pool.nil? ? EMPTY_CONFIG : (@default_connection_config = db_config(connection_pool))
+          rescue StandardError
+            EMPTY_CONFIG
+          end
+
+          # @return [Hash]
+          def self.db_config(connection_pool)
+            if ::Rails::VERSION::MAJOR >= 6 && ::Rails::VERSION::MINOR >= 1
+              connection_pool.db_config.configuration_hash
+            else
+              connection_pool.spec.config
+            end
+          end
+        end
+      end
+    end
+  end
+end