datadog 2.0.0.beta1

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative 'configuration/settings'
+require_relative 'patcher'
+require_relative '../integration'
+require_relative '../rails/utils'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveJob
+        # Describes the ActiveJob integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('4.2')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :active_job, auto_patch: false
+
+          def self.version
+            Gem.loaded_specs['activejob'] && Gem.loaded_specs['activejob'].version
+          end
+
+          def self.loaded?
+            !defined?(::ActiveJob).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
+            ActiveJob::Patcher
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_job/log_injection.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveJob
+        # Active Job log injection wrapped around job execution
+        module LogInjection
+          def self.included(base)
+            base.class_eval do
+              around_perform do |_, block|
+                if Datadog.configuration.tracing.log_injection && logger.respond_to?(:tagged)
+                  logger.tagged(Tracing.log_correlation, &block)
+                else
+                  block.call
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'ext'
+require_relative 'events'
+require_relative 'log_injection'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveJob
+        # Patcher enables patching of 'active_job' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            Events.subscribe!
+            inject_log_correlation
+          end
+
+          def inject_log_correlation
+            ::ActiveSupport.on_load(:active_job) do
+              include LogInjection
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveModelSerializers
+        module Configuration
+          # Custom settings for the ActiveModelSerializers integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            # @!visibility private
+            option :analytics_enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative '../active_support/notifications/event'
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveModelSerializers
+        # Defines basic behaviors for an ActiveModelSerializers event.
+        module Event
+          def self.included(base)
+            base.include(ActiveSupport::Notifications::Event)
+            base.extend(ClassMethods)
+          end
+
+          # Class methods for ActiveModelSerializers events.
+          # Note, they share the same process method and before_trace method.
+          module ClassMethods
+            def span_options
+              {}
+            end
+
+            def configuration
+              Datadog.configuration.tracing[:active_model_serializers]
+            end
+
+            def set_common_tags(span, payload)
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+
+              # 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)
+
+              # Set the resource name and serializer name
+              res = resource(payload[:serializer])
+              span.resource = res
+              span.set_tag(Ext::TAG_SERIALIZER, res)
+
+              span.type = Tracing::Metadata::Ext::HTTP::TYPE_TEMPLATE
+
+              # Will be nil in 0.9
+              span.set_tag(Ext::TAG_ADAPTER, payload[:adapter].class) unless payload[:adapter].nil?
+            end
+
+            private
+
+            def resource(serializer)
+              # Depending on the version of ActiveModelSerializers
+              # serializer will be a string or an object.
+              if serializer.respond_to?(:name)
+                serializer.name
+              else
+                serializer
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_model_serializers/events/render.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../../../metadata/ext'
+require_relative '../ext'
+require_relative '../event'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveModelSerializers
+        module Events
+          # Defines instrumentation for render.active_model_serializers event
+          module Render
+            include ActiveModelSerializers::Event
+
+            EVENT_NAME = 'render.active_model_serializers'
+
+            module_function
+
+            def supported?
+              Gem.loaded_specs['active_model_serializers'] \
+                && Gem.loaded_specs['active_model_serializers'].version >= Gem::Version.new('0.10')
+            end
+
+            def event_name
+              self::EVENT_NAME
+            end
+
+            def span_name
+              Ext::SPAN_RENDER
+            end
+
+            def process(span, _event, _id, payload)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_RENDER)
+
+              set_common_tags(span, payload)
+            rescue StandardError => e
+              Datadog.logger.debug(e.message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/active_model_serializers/events/serialize.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative '../ext'
+require_relative '../event'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveModelSerializers
+        module Events
+          # Defines instrumentation for !serialize.active_model_serializers event
+          module Serialize
+            include ActiveModelSerializers::Event
+
+            EVENT_NAME = '!serialize.active_model_serializers'
+
+            module_function
+
+            def supported?
+              Gem.loaded_specs['active_model_serializers'] \
+                && ( \
+                  Gem.loaded_specs['active_model_serializers'].version >= Gem::Version.new('0.9') \
+                  && Gem.loaded_specs['active_model_serializers'].version < Gem::Version.new('0.10') \
+                )
+            end
+
+            def event_name
+              self::EVENT_NAME
+            end
+
+            def span_name
+              Ext::SPAN_SERIALIZE
+            end
+
+            def process(span, _event, _id, payload)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_SERIALIZE)
+
+              set_common_tags(span, payload)
+            rescue StandardError => e
+              Datadog.logger.debug(e.message)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'events/render'
+require_relative 'events/serialize'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveModelSerializers
+        # Defines collection of instrumented ActiveModelSerializers events
+        module Events
+          ALL = [
+            Events::Render,
+            Events::Serialize
+          ].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_model_serializers/ext.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveModelSerializers
+        # ActiveModelSerializers integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_ACTIVE_MODEL_SERIALIZERS_ENABLED'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_ACTIVE_MODEL_SERIALIZERS_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_ACTIVE_MODEL_SERIALIZERS_ANALYTICS_SAMPLE_RATE'
+          SPAN_RENDER = 'active_model_serializers.render'
+          SPAN_SERIALIZE = 'active_model_serializers.serialize'
+          TAG_ADAPTER = 'active_model_serializers.adapter'
+          TAG_COMPONENT = 'active_model_serializers'
+          TAG_OPERATION_RENDER = 'render'
+          TAG_OPERATION_SERIALIZE = 'serialize'
+          TAG_SERIALIZER = 'active_model_serializers.serializer'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveModelSerializers
+        # Description of ActiveModelSerializers integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('0.9.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :active_model_serializers
+
+          def self.version
+            Gem.loaded_specs['active_model_serializers'] \
+              && Gem.loaded_specs['active_model_serializers'].version
+          end
+
+          def self.loaded?
+            !defined?(::ActiveModel::Serializer).nil? \
+              && !defined?(::ActiveSupport::Notifications).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'ext'
+require_relative 'events'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module ActiveModelSerializers
+        # Patcher enables patching of 'active_model_serializers' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            Events.subscribe!
+          end
+
+          def get_option(option)
+            Datadog.configuration.tracing[:active_model_serializers].get_option(option)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: 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,147 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/resolver'
+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
+              # Resolving a valid database configuration should not raise an exception,
+              # but if it does, it can be due to adding a broken pattern match prior to this call.
+              #
+              # `db_config` input may contain sensitive information such as passwords,
+              # hence provide a succinct summary for the error logging.
+              Datadog.logger.error(
+                'Failed to resolve ActiveRecord database configuration. '\
+                "Cause: #{e.class.name} 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 key #{matcher.inspect}. " \
+                "Cause: #{e.class.name} Source: #{Array(e.backtrace).first}"
+              )
+
+              nil
+            end
+
+            #
+            # `::ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver` exists from 4+ til from 6.0.x
+            #
+            # `::ActiveRecord::DatabaseConfigurations` was introduced from 6+,
+            # but from 6.1.x, it was refactored to encapsulates the resolving logic, hence removing the resolver
+            #
+            def connection_resolver
+              @resolver ||=
+                # From 6.1+
+                if defined?(::ActiveRecord::Base.configurations.resolve)
+                  ::ActiveRecord::DatabaseConfigurations.new(active_record_configuration)
+                # From 4+ to 6.0.x
+                else
+                  ::ActiveRecord::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,48 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+require_relative '../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.type :bool
+              o.env Ext::ENV_ENABLED
+              o.default true
+            end
+
+            # @!visibility private
+            option :analytics_enabled do |o|
+              o.type :bool
+              o.env Ext::ENV_ANALYTICS_ENABLED
+              o.default false
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
+            end
+
+            option :service_name do |o|
+              o.type :string, nilable: true
+              o.default do
+                Contrib::SpanAttributeSchema.fetch_service_name(
+                  '',
+                  Utils.adapter_name
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end