ddtrace 0.54.2 → 1.4.0

data/lib/datadog/tracing/contrib/mongodb/parsers.rb

@@ -0,0 +1,49 @@
+require_relative '../utils/quantization/hash'
+
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      # MongoDB module includes classes and functions to instrument MongoDB clients
+      module MongoDB
+        EXCLUDE_KEYS = [:_id].freeze
+        SHOW_KEYS = [].freeze
+        DEFAULT_OPTIONS = { exclude: EXCLUDE_KEYS, show: SHOW_KEYS }.freeze
+
+        module_function
+
+        # skipped keys are related to command names, since they are already
+        # extracted by the query_builder
+        PLACEHOLDER = '?'.freeze
+
+        # returns a formatted and normalized query
+        def query_builder(command_name, database_name, command)
+          # always exclude the command name
+          options = Contrib::Utils::Quantization::Hash.merge_options(quantization_options, exclude: [command_name.to_s])
+
+          # quantized statements keys are strings to avoid leaking Symbols in older Rubies
+          # as Symbols are not GC'ed in Rubies prior to 2.2
+          base_info = Contrib::Utils::Quantization::Hash.format(
+            {
+              'operation' => command_name,
+              'database' => database_name,
+              'collection' => command.values.first
+            },
+            options
+          )
+
+          base_info.merge(Contrib::Utils::Quantization::Hash.format(command, options))
+        end
+
+        def quantization_options
+          Contrib::Utils::Quantization::Hash.merge_options(DEFAULT_OPTIONS, configuration[:quantize])
+        end
+
+        def configuration
+          Datadog.configuration.tracing[:mongo]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# typed: false
+
+require_relative '../patcher'
+require_relative 'ext'
+require_relative 'instrumentation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module MongoDB
+        # Patcher enables patching of 'mongo' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            ::Mongo::Client.include(Instrumentation::Client)
+            add_mongo_monitoring
+          end
+
+          def add_mongo_monitoring
+            # Subscribe to all COMMAND queries with our subscriber class
+            ::Mongo::Monitoring::Global.subscribe(::Mongo::Monitoring::COMMAND, MongoCommandSubscriber.new)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/mongodb/subscribers.rb

@@ -0,0 +1,121 @@
+# typed: true
+
+require_relative '../analytics'
+require_relative 'ext'
+require_relative 'parsers'
+require_relative '../../metadata/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module MongoDB
+        # `MongoCommandSubscriber` listens to all events from the `Monitoring`
+        # system available in the Mongo driver.
+        class MongoCommandSubscriber
+          def started(event)
+            return unless Tracing.enabled?
+
+            service = Datadog.configuration_for(event.address, :service_name) \
+                      || Datadog.configuration.tracing[:mongo, event.address.seed][:service_name]
+
+            # start a trace and store it in the current thread; using the `operation_id`
+            # is safe since it's a unique id used to link events together. Also only one
+            # thread is involved in this execution so thread-local storage should be safe. Reference:
+            # https://github.com/mongodb/mongo-ruby-driver/blob/master/lib/mongo/monitoring.rb#L70
+            # https://github.com/mongodb/mongo-ruby-driver/blob/master/lib/mongo/monitoring/publishable.rb#L38-L56
+            span = Tracing.trace(Ext::SPAN_COMMAND, service: service, span_type: Ext::SPAN_TYPE_COMMAND)
+            set_span(event, span)
+
+            # build a quantized Query using the Parser module
+            query = MongoDB.query_builder(event.command_name, event.database_name, event.command)
+            serialized_query = query.to_s
+
+            span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+            span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_COMMAND)
+
+            # Tag as an external peer service
+            span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, span.service)
+            span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, event.address.host)
+
+            # Set analytics sample rate
+            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+            # add operation tags; the full query is stored and used as a resource,
+            # since it has been quantized and reduced
+            span.set_tag(Ext::TAG_DB, query['database'])
+            span.set_tag(Ext::TAG_COLLECTION, query['collection'])
+            span.set_tag(Ext::TAG_OPERATION, query['operation'])
+            span.set_tag(Ext::TAG_QUERY, serialized_query)
+            span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, event.address.host)
+            span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, event.address.port)
+
+            # set the resource with the quantized query
+            span.resource = serialized_query
+          end
+
+          def failed(event)
+            span = get_span(event)
+            return unless span
+
+            # the failure is not a real exception because it's handled by
+            # the framework itself, so we set only the error and the message
+            span.set_error(event)
+          rescue StandardError => e
+            Datadog.logger.debug("error when handling MongoDB 'failed' event: #{e}")
+          ensure
+            # whatever happens, the Span must be removed from the local storage and
+            # it must be finished to prevent any leak
+            span.finish unless span.nil?
+            clear_span(event)
+          end
+
+          def succeeded(event)
+            span = get_span(event)
+            return unless span
+
+            # add fields that are available only after executing the query
+            rows = event.reply.fetch('n', nil)
+            span.set_tag(Ext::TAG_ROWS, rows) unless rows.nil?
+          rescue StandardError => e
+            Datadog.logger.debug("error when handling MongoDB 'succeeded' event: #{e}")
+          ensure
+            # whatever happens, the Span must be removed from the local storage and
+            # it must be finished to prevent any leak
+            span.finish unless span.nil?
+            clear_span(event)
+          end
+
+          private
+
+          def get_span(event)
+            Thread.current[:datadog_mongo_span] \
+              && Thread.current[:datadog_mongo_span][event.request_id]
+          end
+
+          def set_span(event, span)
+            Thread.current[:datadog_mongo_span] ||= {}
+            Thread.current[:datadog_mongo_span][event.request_id] = span
+          end
+
+          def clear_span(event)
+            return if Thread.current[:datadog_mongo_span].nil?
+
+            Thread.current[:datadog_mongo_span].delete(event.request_id)
+          end
+
+          def analytics_enabled?
+            Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+          end
+
+          def analytics_sample_rate
+            datadog_configuration[:analytics_sample_rate]
+          end
+
+          def datadog_configuration
+            Datadog.configuration.tracing[:mongo]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# typed: false
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Mysql2
+        module Configuration
+          # Custom settings for the Mysql2 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, default: Ext::DEFAULT_PEER_SERVICE_NAME
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Mysql2
+        # Mysql2 integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_MYSQL2_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_MYSQL2_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_MYSQL2_ANALYTICS_SAMPLE_RATE'.freeze
+          DEFAULT_PEER_SERVICE_NAME = 'mysql2'.freeze
+          SPAN_QUERY = 'mysql2.query'.freeze
+          TAG_DB_NAME = 'mysql2.db.name'.freeze
+          TAG_COMPONENT = 'mysql2'.freeze
+          TAG_OPERATION_QUERY = 'query'.freeze
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/mysql2/instrumentation.rb

@@ -0,0 +1,61 @@
+# typed: false
+
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Mysql2
+        # Mysql2::Client patch module
+        module Instrumentation
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          # Mysql2::Client patch instance methods
+          module InstanceMethods
+            def query(sql, options = {})
+              service = Datadog.configuration_for(self, :service_name) || datadog_configuration[:service_name]
+
+              Tracing.trace(Ext::SPAN_QUERY, service: service) do |span|
+                span.resource = 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_QUERY)
+
+                # Tag as an external peer service
+                span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, service)
+                span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, query_options[:host])
+
+                # Set analytics sample rate
+                Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+                span.set_tag(Ext::TAG_DB_NAME, query_options[:database])
+                span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, query_options[:host])
+                span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, query_options[:port])
+                super(sql, options)
+              end
+            end
+
+            private
+
+            def datadog_configuration
+              Datadog.configuration.tracing[:mysql2]
+            end
+
+            def analytics_enabled?
+              datadog_configuration[:analytics_enabled]
+            end
+
+            def analytics_sample_rate
+              datadog_configuration[:analytics_sample_rate]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# typed: false
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Mysql2
+        # Description of Mysql2 integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('0.3.21')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :mysql2
+
+          def self.version
+            Gem.loaded_specs['mysql2'] && Gem.loaded_specs['mysql2'].version
+          end
+
+          def self.loaded?
+            !defined?(::Mysql2).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/mysql2/patcher.rb

@@ -0,0 +1,31 @@
+# typed: true
+
+require_relative '../patcher'
+require_relative 'instrumentation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Mysql2
+        # Patcher enables patching of 'mysql2' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            patch_mysql2_client
+          end
+
+          def patch_mysql2_client
+            ::Mysql2::Client.include(Instrumentation)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/patchable.rb

@@ -0,0 +1,109 @@
+# typed: false
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Base provides features that are shared across all integrations
+      module Patchable
+        def self.included(base)
+          base.extend(ClassMethods)
+          base.include(InstanceMethods)
+        end
+
+        # Class methods for integrations
+        # @public_api
+        module ClassMethods
+          # Version of the integration target code in the environment.
+          #
+          # This is the gem version, when the instrumentation target is a Ruby gem.
+          #
+          # If the target for instrumentation has concept of versioning, override {.version},
+          # otherwise override {.available?} and implement a custom target presence check.
+          # @return [Object] the target version
+          def version
+            nil
+          end
+
+          # Is the target available to be instrumented? (e.g. gem installed?)
+          #
+          # The target doesn't have to be loaded (e.g. `require`) yet, but needs to be able
+          # to be loaded before instrumentation can commence.
+          #
+          # By default, {.available?} checks if {.version} returned a non-nil object.
+          #
+          # If the target for instrumentation has concept of versioning, override {.version},
+          # otherwise override {.available?} and implement a custom target presence check.
+          # @return [Boolean] is the target available for instrumentation in this Ruby environment?
+          def available?
+            !version.nil?
+          end
+
+          # Is the target loaded into the application? (e.g. gem required? Constant defined?)
+          #
+          # The target's objects should be ready to be referenced by the instrumented when {.loaded}
+          # returns `true`.
+          #
+          # @return [Boolean] is the target ready to be referenced during instrumentation?
+          def loaded?
+            true
+          end
+
+          # Is this instrumentation compatible with the available target? (e.g. minimum version met?)
+          # @return [Boolean] is the available target compatible with this instrumentation?
+          def compatible?
+            available?
+          end
+
+          # Can the patch for this integration be applied?
+          #
+          # By default, this is equivalent to {#available?}, {#loaded?}, and {#compatible?}
+          # all being truthy.
+          def patchable?
+            available? && loaded? && compatible?
+          end
+        end
+
+        # Instance methods for integrations
+        # @public_api
+        module InstanceMethods
+          # The patcher module to inject instrumented objects into the instrumentation target.
+          #
+          # {Contrib::Patcher} includes the basic functionality of a patcher. `include`ing
+          # {Contrib::Patcher} into a new module is the recommend way to create a custom patcher.
+          #
+          # @return [Contrib::Patcher] a module that `include`s {Contrib::Patcher}
+          def patcher
+            nil
+          end
+
+          # @!visibility private
+          def patch
+            if !self.class.patchable? || patcher.nil?
+              return {
+                name: self.class.name,
+                available: self.class.available?,
+                loaded: self.class.loaded?,
+                compatible: self.class.compatible?,
+                patchable: self.class.patchable?
+              }
+            end
+
+            patcher.patch
+            true
+          end
+
+          # Can the patch for this integration be applied automatically?
+          # For example: test integrations should only be applied
+          # by the user explicitly setting `c.ci.instrument :rspec`
+          # and rails sub-modules are auto-instrumented by enabling rails
+          # so auto-instrumenting them on their own will cause changes in
+          # service naming behavior
+          # @return [Boolean] can the tracer activate this instrumentation without explicit user input?
+          def auto_instrument?
+            true
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,85 @@
+# typed: false
+
+require_relative '../../core'
+require_relative '../../core/utils/only_once'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Common behavior for patcher modules.
+      #
+      # `include`ing {Contrib::Patcher} into a new module is the recommend way to create a custom patcher.
+      # The patcher can then be provided to a custom {Datadog::Tracing::Contrib::Integration} for instrumentation.
+      module Patcher
+        def self.included(base)
+          base.singleton_class.prepend(CommonMethods)
+          base.prepend(CommonMethods) if base.instance_of?(Class)
+        end
+
+        # Prepended instance methods for all patchers
+        # @public_api
+        module CommonMethods
+          attr_accessor \
+            :patch_error_result,
+            :patch_successful
+
+          def patch_name
+            self.class != Class && self.class != Module ? self.class.name : name
+          end
+
+          def patched?
+            patch_only_once.ran?
+          end
+
+          def patch
+            return unless defined?(super)
+
+            patch_only_once.run do
+              begin
+                super.tap do
+                  # Emit a metric
+                  Datadog.health_metrics.instrumentation_patched(1, tags: default_tags)
+                  @patch_successful = true
+                end
+              rescue StandardError => e
+                on_patch_error(e)
+              end
+            end
+          end
+
+          # Processes patching errors. This default implementation logs the error and reports relevant metrics.
+          # @param e [Exception]
+          def on_patch_error(e)
+            # Log the error
+            Datadog.logger.error("Failed to apply #{patch_name} patch. Cause: #{e} Location: #{Array(e.backtrace).first}")
+
+            @patch_error_result = {
+              type: e.class.name,
+              message: e.message,
+              line: Array(e.backtrace).first
+            }
+
+            # Emit a metric
+            tags = default_tags
+            tags << "error:#{e.class.name}"
+
+            Datadog.health_metrics.error_instrumentation_patch(1, tags: tags)
+          end
+
+          private
+
+          def default_tags
+            ["patcher:#{patch_name}"].tap do |tags|
+              tags << "target_version:#{target_version}" if respond_to?(:target_version) && !target_version.nil?
+            end
+          end
+
+          def patch_only_once
+            # NOTE: This is not thread-safe
+            @patch_only_once ||= Core::Utils::OnlyOnce.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# typed: false
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Pg
+        module Configuration
+          # Custom settings for the Pg 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, default: Ext::DEFAULT_PEER_SERVICE_NAME
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Pg
+        # pg integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_PG_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_PG_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_PG_ANALYTICS_SAMPLE_RATE'.freeze
+          DEFAULT_PEER_SERVICE_NAME = 'pg'.freeze
+          SPAN_SYSTEM = 'postgresql'.freeze
+          SPAN_EXEC = 'pg.exec'.freeze
+          SPAN_EXEC_PARAMS = 'pg.exec.params'.freeze
+          SPAN_EXEC_PREPARED = 'pg.exec.prepared'.freeze
+          SPAN_ASYNC_EXEC = 'pg.async.exec'.freeze
+          SPAN_ASYNC_EXEC_PARAMS = 'pg.async.exec.params'.freeze
+          SPAN_ASYNC_EXEC_PREPARED = 'pg.async.exec.prepared'.freeze
+          SPAN_SYNC_EXEC = 'pg.sync.exec'.freeze
+          SPAN_SYNC_EXEC_PARAMS = 'pg.sync.exec.params'.freeze
+          SPAN_SYNC_EXEC_PREPARED = 'pg.sync.exec.prepared'.freeze
+          TAG_DB_NAME = 'pg.db.name'.freeze
+          TAG_COMPONENT = 'pg'.freeze
+          TAG_OPERATION_QUERY = 'query'.freeze
+        end
+      end
+    end
+  end
+end