cw-datadog 2.23.0.2

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Lograge
+        # Instrumentation for Lograge
+        module Instrumentation
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          # Instance methods for configuration
+          module InstanceMethods
+            def custom_options(event)
+              return super unless Datadog.configuration.tracing.log_injection
+              return super unless Datadog.configuration.tracing[:lograge].enabled
+
+              original_custom_options = super
+
+              # Retrieves trace information for current thread
+              correlation = Tracing.correlation
+              # merge original lambda with datadog context
+              correlation.to_h.merge(original_custom_options)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Lograge
+        # Description of Lograge integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('0.11.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :lograge
+
+          def self.version
+            Gem.loaded_specs['lograge']&.version
+          end
+
+          def self.loaded?
+            !defined?(::Lograge::LogSubscribers::Base).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          # enabled by rails integration and has a hard dependancy on rails
+          # so can safely say this shouldn't ever be part of auto instrumentation
+          # https://github.com/roidrage/lograge/blob/1729eab7956bb95c5992e4adab251e4f93ff9280/lograge.gemspec#L18-L20
+          def auto_instrument?
+            false
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'instrumentation'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Datadog Lograge integration.
+      module Lograge
+        # Patcher enables patching of 'lograge' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          # patch applies our patch
+          def patch
+            # First check Lograge logger directly for when keep_original_rails_log option is used
+            used_logger = ::Lograge.logger || ::Lograge::LogSubscribers::ActionController.logger
+
+            # ActiveSupport::TaggedLogging is the default Rails logger since Rails 5
+            if defined?(::ActiveSupport::TaggedLogging::Formatter) &&
+                used_logger&.formatter.is_a?(::ActiveSupport::TaggedLogging::Formatter)
+              Datadog.logger.warn(
+                'Lograge and ActiveSupport::TaggedLogging (the default Rails log formatter) are not compatible: ' \
+                  'Lograge does not account for Rails log tags, creating polluted logs and breaking log formatting. ' \
+                  'Traces and Logs correlation may not work. ' \
+                  'Either: 1. Disable tagged logging in your Rails configuration ' \
+                  '`config.logger = ActiveSupport::Logger.new(STDOUT); ' \
+                  'config.active_job.logger = ActiveSupport::Logger.new(STDOUT)` ' \
+                  'or 2. Use the `semantic_logger` gem instead of `lograge`.'
+              )
+            end
+
+            ::Lograge::LogSubscribers::Base.include(Instrumentation)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module MongoDB
+        module Configuration
+          # Custom settings for the MongoDB integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            DEFAULT_QUANTIZE = {show: [:collection, :database, :operation]}.freeze
+
+            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 :quantize, type: :hash, default: DEFAULT_QUANTIZE
+
+            option :service_name do |o|
+              o.type :string, nilable: true
+              o.default do
+                Contrib::SpanAttributeSchema.fetch_service_name(
+                  Ext::ENV_SERVICE_NAME,
+                  Ext::DEFAULT_PEER_SERVICE_NAME
+                )
+              end
+            end
+
+            option :peer_service do |o|
+              o.type :string, nilable: true
+              o.env Ext::ENV_PEER_SERVICE
+            end
+
+            # Serializes the command to JSON format, which is the desired format for the agent and Datadog UI.
+            # Setting this to false is deprecated and does not have any advantages.
+            option :json_command do |o|
+              o.type :bool
+              o.env Ext::ENV_JSON_COMMAND
+              o.default false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module MongoDB
+        # MongoDB integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_MONGO_ENABLED'
+          ENV_SERVICE_NAME = 'DD_TRACE_MONGO_SERVICE_NAME'
+          ENV_PEER_SERVICE = 'DD_TRACE_MONGO_PEER_SERVICE'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_MONGO_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_MONGO_ANALYTICS_SAMPLE_RATE'
+          ENV_JSON_COMMAND = 'DD_TRACE_MONGO_JSON_COMMAND'
+          DEFAULT_PEER_SERVICE_NAME = 'mongodb'
+          SPAN_COMMAND = 'mongo.cmd'
+          SPAN_TYPE_COMMAND = 'mongodb'
+          TAG_COLLECTION = 'mongodb.collection'
+          TAG_DB = 'mongodb.db'
+          TAG_OPERATION = 'mongodb.operation'
+          TAG_QUERY = 'mongodb.query'
+          TAG_ROWS = 'mongodb.rows'
+          TAG_COMPONENT = 'mongodb'
+          TAG_OPERATION_COMMAND = 'command'
+          TAG_SYSTEM = 'mongodb'
+          PEER_SERVICE_SOURCES = ([Ext::TAG_DB] + Contrib::Ext::DB::PEER_SERVICE_SOURCES).freeze
+
+          # Temporary namespace to accommodate unified tags which has naming collision, before
+          # making breaking changes
+          module DB
+            TAG_COLLECTION = 'db.mongodb.collection'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'ext'
+require_relative 'parsers'
+require_relative 'subscribers'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module MongoDB
+        # Instrumentation for Mongo integration
+        module Instrumentation
+          # Instrumentation for Mongo::Client
+          module Client
+            def self.included(base)
+              base.include(InstanceMethods)
+            end
+
+            # Instance methods for Mongo::Client
+            module InstanceMethods
+              def datadog_pin
+                # safe-navigation to avoid crashes during each query
+                return unless respond_to? :cluster
+                return unless cluster.respond_to? :addresses
+                return unless cluster.addresses.respond_to? :first
+
+                Datadog.configuration_for(cluster.addresses.first)
+              end
+
+              def datadog_pin=(pin)
+                # safe-navigation to avoid crashes during each query
+                return unless respond_to? :cluster
+                return unless cluster.respond_to? :addresses
+                return unless cluster.addresses.respond_to? :each
+
+                # attach the PIN to all cluster addresses. One of them is used
+                # when executing a Command and it is attached to the Monitoring
+                # Event instance.
+                cluster.addresses.each { |x| pin.onto(x) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../integration'
+require_relative '../configuration/resolvers/pattern_resolver'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module MongoDB
+        # Description of MongoDB integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('2.1.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :mongo, auto_patch: true
+          def self.gem_name
+            'mongo'
+          end
+
+          def self.version
+            Gem.loaded_specs['mongo']&.version
+          end
+
+          def self.loaded?
+            !defined?(::Mongo::Monitoring::Global).nil?
+          end
+
+          def self.compatible?
+            super && version >= MINIMUM_VERSION
+          end
+
+          def new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+
+          def resolver
+            @resolver ||= Contrib::Configuration::Resolvers::PatternResolver.new
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../utils/quantization/hash'
+
+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 = '?'
+
+        # 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 @@
+# frozen_string_literal: true
+
+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,160 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative '../analytics'
+require_relative 'ext'
+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
+          # rubocop:disable Metrics/AbcSize
+          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, 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 = serialize_query(query)
+
+            if datadog_configuration[:peer_service]
+              span.set_tag(
+                Tracing::Metadata::Ext::TAG_PEER_SERVICE,
+                datadog_configuration[:peer_service]
+              )
+            end
+
+            # Tag original global service name if not used
+            if span.service != Datadog.configuration.service
+              span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
+            end
+
+            span.set_tag(Contrib::Ext::DB::TAG_SYSTEM, Ext::TAG_SYSTEM)
+
+            span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
+
+            span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+            span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_COMMAND)
+
+            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::DB::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)
+
+            Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+
+            # set the resource with the quantized query
+            span.resource = serialized_query
+          rescue => e
+            Datadog.logger.debug("error when handling MongoDB 'started' event: #{e}")
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          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 => 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
+            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 => 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
+            clear_span(event)
+          end
+
+          private
+
+          def serialize_query(query)
+            if datadog_configuration[:json_command]
+              query.to_json
+            else
+              # Incorrect Hash#to_s serialization. The Mongo command should only be encoded as JSON.
+              # This code path should be removed, and is only kept to avoid a breaking change.
+              Datadog::Core.log_deprecation(key: :mongo_json_command) do
+                'MongoDB integration: `json_command: false` causes invalid command serialization. ' \
+                'Use `json_command: true` or `DD_TRACE_MONGO_JSON_COMMAND=1` instead.'
+              end
+
+              query.to_s
+            end
+          end
+
+          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,69 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+require_relative '../../propagation/sql_comment'
+
+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.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(
+                  Ext::ENV_SERVICE_NAME,
+                  Ext::DEFAULT_PEER_SERVICE_NAME
+                )
+              end
+            end
+
+            option :comment_propagation do |o|
+              o.type :string
+              o.env Contrib::Propagation::SqlComment::Ext::ENV_DBM_PROPAGATION_MODE
+              o.default Contrib::Propagation::SqlComment::Ext::DISABLED
+            end
+
+            option :append_comment do |o|
+              o.type :bool
+              o.default false
+            end
+
+            option :peer_service do |o|
+              o.type :string, nilable: true
+              o.env Ext::ENV_PEER_SERVICE
+            end
+
+            option :on_error do |o|
+              o.type :proc, nilable: true
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: 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'
+          ENV_SERVICE_NAME = 'DD_TRACE_MYSQL2_SERVICE_NAME'
+          ENV_PEER_SERVICE = 'DD_TRACE_MYSQL2_PEER_SERVICE'
+
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_MYSQL2_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_MYSQL2_ANALYTICS_SAMPLE_RATE'
+          DEFAULT_PEER_SERVICE_NAME = 'mysql2'
+          SPAN_QUERY = 'mysql2.query'
+          TAG_DB_NAME = 'mysql2.db.name'
+          TAG_COMPONENT = 'mysql2'
+          TAG_OPERATION_QUERY = 'query'
+          TAG_SYSTEM = 'mysql'
+          PEER_SERVICE_SOURCES = ([Ext::TAG_DB_NAME] + Contrib::Ext::DB::PEER_SERVICE_SOURCES).freeze
+        end
+      end
+    end
+  end
+end