ls-trace 0.1.1

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

@@ -0,0 +1,30 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/active_record/ext'
+require 'ddtrace/contrib/active_record/utils'
+
+module Datadog
+  module Contrib
+    module ActiveRecord
+      module Configuration
+        # Custom settings for the ActiveRecord integration
+        class Settings < Contrib::Configuration::Settings
+          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 :orm_service_name
+          option :service_name do |o|
+            o.default { Utils.adapter_name }
+            o.lazy
+          end
+        end
+      end
+    end
+  end
+end

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

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

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,57 @@
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/active_record/ext'
+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
+
+          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)
+            # 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
+                             Ext::SERVICE_NAME
+                           end
+
+            span.resource = payload.fetch(:class_name)
+            span.span_type = Ext::SPAN_TYPE_INSTANTIATION
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(configuration[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, configuration[:analytics_sample_rate])
+            end
+
+            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::Tracer.log.debug(e.message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'ddtrace/ext/net'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/active_record/ext'
+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
+          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[:active_record, config]
+            adapter_name = Datadog::Utils::Database.normalize_vendor(config[:adapter])
+            service_name = if settings.service_name != Datadog::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 = Datadog::Ext::SQL::TYPE
+
+            # 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(Datadog::Ext::NET::TARGET_HOST, config[:host]) if config[:host]
+            span.set_tag(Datadog::Ext::NET::TARGET_PORT, config[:port]) if config[:port]
+          rescue StandardError => e
+            Datadog::Tracer.log.debug(e.message)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Datadog
+  module Contrib
+    module ActiveRecord
+      # ActiveRecord integration constants
+      module Ext
+        APP = 'active_record'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_ACTIVE_RECORD_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_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_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

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

@@ -0,0 +1,29 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/active_record/events'
+
+module Datadog
+  module Contrib
+    module ActiveRecord
+      # Patcher enables patching of 'active_record' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def patched?
+          done?(:active_record)
+        end
+
+        def patch
+          do_once(:active_record) do
+            begin
+              Events.subscribe!
+            rescue StandardError => e
+              Datadog::Tracer.log.error("Unable to apply Active Record integration: #{e}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Datadog
+  module Contrib
+    module ActiveRecord
+      # Common utilities for Rails
+      module Utils
+        EMPTY_CONFIG = {}.freeze
+
+        def self.adapter_name
+          Datadog::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
+
+        # In newer Rails versions, the `payload` contains both the `connection` and its `object_id` named `connection_id`.
+        #
+        # So, if rails is recent we'll have a direct access to the connection.
+        # Else, we'll find it thanks to the passed `connection_id`.
+        #
+        # See this PR for more details: 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?
+                   connection
+                 # Rails 3.0 - 3.2
+                 elsif Gem.loaded_specs['activerecord'].version < Gem::Version.new('4.0')
+                   ::ActiveRecord::Base
+                     .connection_handler
+                     .connection_pools
+                     .values
+                     .flat_map(&:connections)
+                     .find { |c| c.object_id == connection_id }
+                 # Rails 4.2+
+                 else
+                   ::ActiveRecord::Base
+                     .connection_handler
+                     .connection_pool_list
+                     .flat_map(&:connections)
+                     .find { |c| c.object_id == connection_id }
+                 end
+
+          if conn.instance_variable_defined?(:@config)
+            conn.instance_variable_get(:@config)
+          else
+            EMPTY_CONFIG
+          end
+        end
+
+        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 = connection_pool.spec.config)
+        rescue StandardError
+          EMPTY_CONFIG
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/active_support/cache/instrumentation.rb

@@ -0,0 +1,157 @@
+require 'ddtrace/contrib/active_support/ext'
+
+module Datadog
+  module Contrib
+    module ActiveSupport
+      module Cache
+        # Defines instrumentation for ActiveSupport caching
+        # rubocop:disable Lint/RescueException
+        module Instrumentation
+          module_function
+
+          def start_trace_cache(payload)
+            tracer = Datadog.configuration[:active_support][:tracer]
+
+            # In most of the cases Rails ``fetch()`` and ``read()`` calls are nested.
+            # This check ensures that two reads are not nested since they don't provide
+            # interesting details.
+            # NOTE: the ``finish_trace_cache()`` is fired but it already has a safe-guard
+            # to avoid any kind of issue.
+            current_span = tracer.active_span
+            return if payload[:action] == Ext::RESOURCE_CACHE_GET &&
+                      current_span.try(:name) == Ext::SPAN_CACHE &&
+                      current_span.try(:resource) == Ext::RESOURCE_CACHE_GET
+
+            tracing_context = payload.fetch(:tracing_context)
+
+            # create a new ``Span`` and add it to the tracing context
+            service = Datadog.configuration[:active_support][:cache_service]
+            type = Ext::SPAN_TYPE_CACHE
+            span = tracer.trace(Ext::SPAN_CACHE, service: service, span_type: type)
+            span.resource = payload.fetch(:action)
+            tracing_context[:dd_cache_span] = span
+          rescue StandardError => e
+            Datadog::Tracer.log.debug(e.message)
+          end
+
+          def finish_trace_cache(payload)
+            # retrieve the tracing context and continue the trace
+            tracing_context = payload.fetch(:tracing_context)
+            span = tracing_context[:dd_cache_span]
+            return unless span && !span.finished?
+
+            begin
+              # discard parameters from the cache_store configuration
+              if defined?(::Rails)
+                store, = *Array.wrap(::Rails.configuration.cache_store).flatten
+                span.set_tag(Ext::TAG_CACHE_BACKEND, store)
+              end
+
+              normalized_key = ::ActiveSupport::Cache.expand_cache_key(payload.fetch(:key))
+              cache_key = Datadog::Utils.truncate(normalized_key, Ext::QUANTIZE_CACHE_MAX_KEY_SIZE)
+              span.set_tag(Ext::TAG_CACHE_KEY, cache_key)
+
+              span.set_error(payload[:exception]) if payload[:exception]
+            ensure
+              span.finish
+            end
+          rescue StandardError => e
+            Datadog::Tracer.log.debug(e.message)
+          end
+
+          # Defines instrumentation for ActiveSupport cache reading
+          module Read
+            def read(*args, &block)
+              payload = {
+                action: Ext::RESOURCE_CACHE_GET,
+                key: args[0],
+                tracing_context: {}
+              }
+
+              begin
+                # process and catch cache exceptions
+                Instrumentation.start_trace_cache(payload)
+                super
+              rescue Exception => e
+                payload[:exception] = [e.class.name, e.message]
+                payload[:exception_object] = e
+                raise e
+              end
+            ensure
+              Instrumentation.finish_trace_cache(payload)
+            end
+          end
+
+          # Defines instrumentation for ActiveSupport cache fetching
+          module Fetch
+            def fetch(*args, &block)
+              payload = {
+                action: Ext::RESOURCE_CACHE_GET,
+                key: args[0],
+                tracing_context: {}
+              }
+
+              begin
+                # process and catch cache exceptions
+                Instrumentation.start_trace_cache(payload)
+                super
+              rescue Exception => e
+                payload[:exception] = [e.class.name, e.message]
+                payload[:exception_object] = e
+                raise e
+              end
+            ensure
+              Instrumentation.finish_trace_cache(payload)
+            end
+          end
+
+          # Defines instrumentation for ActiveSupport cache writing
+          module Write
+            def write(*args, &block)
+              payload = {
+                action: Ext::RESOURCE_CACHE_SET,
+                key: args[0],
+                tracing_context: {}
+              }
+
+              begin
+                # process and catch cache exceptions
+                Instrumentation.start_trace_cache(payload)
+                super
+              rescue Exception => e
+                payload[:exception] = [e.class.name, e.message]
+                payload[:exception_object] = e
+                raise e
+              end
+            ensure
+              Instrumentation.finish_trace_cache(payload)
+            end
+          end
+
+          # Defines instrumentation for ActiveSupport cache deleting
+          module Delete
+            def delete(*args, &block)
+              payload = {
+                action: Ext::RESOURCE_CACHE_DELETE,
+                key: args[0],
+                tracing_context: {}
+              }
+
+              begin
+                # process and catch cache exceptions
+                Instrumentation.start_trace_cache(payload)
+                super
+              rescue Exception => e
+                payload[:exception] = [e.class.name, e.message]
+                payload[:exception_object] = e
+                raise e
+              end
+            ensure
+              Instrumentation.finish_trace_cache(payload)
+            end
+          end
+        end
+      end
+    end
+  end
+end