datadog 2.0.0.beta1

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../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 @@
+# frozen_string_literal: true
+
+require_relative '../../../metadata/ext'
+require_relative '../../analytics'
+require_relative '../ext'
+require_relative '../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'
+
+            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.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,77 @@
+# frozen_string_literal: true
+
+require_relative '../../../../tracing'
+require_relative '../../../metadata/ext'
+require_relative '../event'
+require_relative '../ext'
+require_relative '../../analytics'
+require_relative '../../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'
+            PAYLOAD_CACHE = 'CACHE'
+
+            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.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)
+
+              if service_name != Datadog.configuration.service
+                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
+              end
+
+              # 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 @@
+# frozen_string_literal: true
+
+require_relative 'events/instantiation'
+require_relative '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,30 @@
+# frozen_string_literal: 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'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTIVE_RECORD_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTIVE_RECORD_ANALYTICS_SAMPLE_RATE'
+          SERVICE_NAME = 'active_record'
+          SPAN_INSTANTIATION = 'active_record.instantiation'
+          SPAN_SQL = 'active_record.sql'
+          SPAN_TYPE_INSTANTIATION = 'custom'
+          TAG_COMPONENT = 'active_record'
+          TAG_OPERATION_INSTANTIATION = 'instantiation'
+          TAG_OPERATION_SQL = 'sql'
+          TAG_DB_CACHED = 'active_record.db.cached'
+          TAG_DB_NAME = 'active_record.db.name'
+          TAG_DB_VENDOR = 'active_record.db.vendor'
+          TAG_INSTANTIATION_CLASS_NAME = 'active_record.instantiation.class_name'
+          TAG_INSTANTIATION_RECORD_COUNT = 'active_record.instantiation.record_count'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'configuration/resolver'
+require_relative 'configuration/settings'
+require_relative 'events'
+require_relative 'patcher'
+require_relative '../integration'
+require_relative '../rails/integration'
+require_relative '../rails/utils'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveRecord
+        # Describes the ActiveRecord integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Contrib::Rails::Ext::MINIMUM_VERSION
+
+          # @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 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative '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 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/environment/ext'
+require_relative '../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.class.name} #{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 connection_pool.respond_to? :db_config
+              connection_pool.db_config.configuration_hash
+            else
+              connection_pool.spec.config
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_support/cache/instrumentation.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require_relative '../../../../core/utils'
+require_relative '../../../metadata/ext'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveSupport
+        module Cache
+          # Defines instrumentation for ActiveSupport caching
+          module Instrumentation
+            module_function
+
+            # @param action [String] type of cache operation. Will be set as the span resource.
+            # @param key [Object] redis cache key. Used for actions with a single key locator.
+            # @param multi_key [Array<Object>] list of redis cache keys. Used for actions with a multiple key locators.
+            def trace(action, store, key: nil, multi_key: nil)
+              return yield unless enabled?
+
+              # create a new ``Span`` and add it to the tracing context
+              Tracing.trace(
+                Ext::SPAN_CACHE,
+                type: Ext::SPAN_TYPE_CACHE,
+                service: Datadog.configuration.tracing[:active_support][:cache_service],
+                resource: action
+              ) do |span|
+                span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_CACHE)
+
+                if span.service != Datadog.configuration.service
+                  span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
+                end
+
+                span.set_tag(Ext::TAG_CACHE_BACKEND, store) if store
+                set_cache_key(span, key, multi_key)
+
+                yield
+              end
+            end
+
+            # In most of the cases, `#fetch()` and `#read()` calls are nested.
+            # Instrument both does not add any value.
+            # This method checks if these two operations are nested.
+            def nested_read?
+              current_span = Tracing.active_span
+              current_span && current_span.name == Ext::SPAN_CACHE && current_span.resource == Ext::RESOURCE_CACHE_GET
+            end
+
+            # (see #nested_read?)
+            def nested_multiread?
+              current_span = Tracing.active_span
+              current_span && current_span.name == Ext::SPAN_CACHE && current_span.resource == Ext::RESOURCE_CACHE_MGET
+            end
+
+            def set_cache_key(span, single_key, multi_key)
+              if multi_key
+                resolved_key = multi_key.map { |key| ::ActiveSupport::Cache.expand_cache_key(key) }
+                cache_key = Core::Utils.truncate(resolved_key, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
+                span.set_tag(Ext::TAG_CACHE_KEY_MULTI, cache_key)
+              else
+                resolved_key = ::ActiveSupport::Cache.expand_cache_key(single_key)
+                cache_key = Core::Utils.truncate(resolved_key, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
+                span.set_tag(Ext::TAG_CACHE_KEY, cache_key)
+              end
+            end
+
+            def enabled?
+              Tracing.enabled? && Datadog.configuration.tracing[:active_support][:enabled]
+            end
+
+            # Instance methods injected into the cache client
+            module InstanceMethods
+              private
+
+              # The name of the store is never saved.
+              # ActiveSupport looks up stores by converting a symbol into a 'require' path,
+              # then "camelizing" it for a `const_get` call:
+              # ```
+              # require "active_support/cache/#{store}"
+              # ActiveSupport::Cache.const_get(store.to_s.camelize)
+              # ```
+              # @see https://github.com/rails/rails/blob/261975dbef77731d2c76f907f1076c5132ebc0e4/activesupport/lib/active_support/cache.rb#L139-L149
+              #
+              # As `self` is the store object, we can reverse engineer
+              # the original symbol by converting the class name to snake case:
+              # e.g. ActiveSupport::Cache::RedisStore -> active_support/cache/redis_store
+              # In this case, `redis_store` is the store name.
+              #
+              # Because there's no API retrieve only the class name
+              # (only `RedisStore`, and not `ActiveSupport::Cache::RedisStore`)
+              # the easiest way to retrieve the store symbol is to convert the fully qualified
+              # name using the Rails-provided method `#underscore`, which is the reverse of `#camelize`,
+              # then extracting the last part of it.
+              #
+              # Also, this method caches the store name, given this value will be retrieve
+              # multiple times and involves string manipulation.
+              def dd_store_name
+                return @store_name if defined?(@store_name)
+
+                # DEV: String#underscore is available through ActiveSupport, and is
+                # DEV: the exact reverse operation to `#camelize`.
+                # DEV: String#demodulize is available through ActiveSupport, and is
+                # DEV: used to remove the module ('*::') part of a constant name.
+                @store_name = self.class.name.demodulize.underscore
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache reading
+            module Read
+              include InstanceMethods
+
+              def read(*args, &block)
+                return super if Instrumentation.nested_read?
+
+                Instrumentation.trace(Ext::RESOURCE_CACHE_GET, dd_store_name, key: args[0]) { super }
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache reading of multiple keys
+            module ReadMulti
+              include InstanceMethods
+
+              def read_multi(*keys, &block)
+                return super if Instrumentation.nested_multiread?
+
+                Instrumentation.trace(Ext::RESOURCE_CACHE_MGET, dd_store_name, multi_key: keys) { super }
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache fetching
+            module Fetch
+              include InstanceMethods
+
+              def fetch(*args, &block)
+                return super if Instrumentation.nested_read?
+
+                Instrumentation.trace(Ext::RESOURCE_CACHE_GET, dd_store_name, key: args[0]) { super }
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache fetching of multiple keys
+            module FetchMulti
+              include InstanceMethods
+
+              def fetch_multi(*args, &block)
+                return super if Instrumentation.nested_multiread?
+
+                keys = args[-1].instance_of?(Hash) ? args[0..-2] : args
+                Instrumentation.trace(Ext::RESOURCE_CACHE_MGET, dd_store_name, multi_key: keys) { super }
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache writing
+            module Write
+              include InstanceMethods
+
+              def write(*args, &block)
+                Instrumentation.trace(Ext::RESOURCE_CACHE_SET, dd_store_name, key: args[0]) { super }
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache writing of multiple keys
+            module WriteMulti
+              include InstanceMethods
+
+              def write_multi(hash, options = nil)
+                Instrumentation.trace(Ext::RESOURCE_CACHE_MSET, dd_store_name, multi_key: hash.keys) { super }
+              end
+            end
+
+            # Defines instrumentation for ActiveSupport cache deleting
+            module Delete
+              include InstanceMethods
+
+              def delete(*args, &block)
+                Instrumentation.trace(Ext::RESOURCE_CACHE_DELETE, dd_store_name, key: args[0]) { super }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end