ddtrace 0.38.0

data/lib/ddtrace/contrib/kafka/events/consumer_group/sync_group.rb

@@ -0,0 +1,29 @@
+require 'ddtrace/contrib/kafka/ext'
+require 'ddtrace/contrib/kafka/event'
+require 'ddtrace/contrib/kafka/consumer_event'
+require 'ddtrace/contrib/kafka/consumer_group_event'
+
+module Datadog
+  module Contrib
+    module Kafka
+      module Events
+        module ConsumerGroup
+          # Defines instrumentation for sync_group.consumer.kafka event
+          module SyncGroup
+            include Kafka::Event
+            extend Kafka::ConsumerEvent
+            extend Kafka::ConsumerGroupEvent
+
+            EVENT_NAME = 'sync_group.consumer.kafka'.freeze
+
+            module_function
+
+            def span_name
+              Ext::SPAN_CONSUMER_SYNC_GROUP
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/kafka/events/produce_operation/send_messages.rb

@@ -0,0 +1,32 @@
+require 'ddtrace/contrib/kafka/ext'
+require 'ddtrace/contrib/kafka/event'
+
+module Datadog
+  module Contrib
+    module Kafka
+      module Events
+        module ProduceOperation
+          # Defines instrumentation for send_messages.producer.kafka event
+          module SendMessages
+            include Kafka::Event
+
+            EVENT_NAME = 'send_messages.producer.kafka'.freeze
+
+            def self.process(span, _event, _id, payload)
+              super
+
+              span.set_tag(Ext::TAG_MESSAGE_COUNT, payload[:message_count]) if payload.key?(:message_count)
+              span.set_tag(Ext::TAG_SENT_MESSAGE_COUNT, payload[:sent_message_count]) if payload.key?(:sent_message_count)
+            end
+
+            module_function
+
+            def span_name
+              Ext::SPAN_SEND_MESSAGES
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/kafka/events/producer/deliver_messages.rb

@@ -0,0 +1,35 @@
+require 'ddtrace/contrib/kafka/ext'
+require 'ddtrace/contrib/kafka/event'
+
+module Datadog
+  module Contrib
+    module Kafka
+      module Events
+        module Producer
+          # Defines instrumentation for deliver_messages.producer.kafka event
+          module DeliverMessages
+            include Kafka::Event
+
+            EVENT_NAME = 'deliver_messages.producer.kafka'.freeze
+
+            def self.process(span, _event, _id, payload)
+              super
+
+              span.set_tag(Ext::TAG_ATTEMPTS, payload[:attempts]) if payload.key?(:attempts)
+              span.set_tag(Ext::TAG_MESSAGE_COUNT, payload[:message_count]) if payload.key?(:message_count)
+              if payload.key?(:delivered_message_count)
+                span.set_tag(Ext::TAG_DELIVERED_MESSAGE_COUNT, payload[:delivered_message_count])
+              end
+            end
+
+            module_function
+
+            def span_name
+              Ext::SPAN_DELIVER_MESSAGES
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Datadog
+  module Contrib
+    module Kafka
+      # Kafka integration constants
+      module Ext
+        APP = 'kafka'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_KAFKA_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_KAFKA_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'kafka'.freeze
+        SPAN_CONNECTION_REQUEST = 'kafka.connection.request'.freeze
+        SPAN_CONSUMER_HEARTBEAT = 'kafka.consumer.heartbeat'.freeze
+        SPAN_CONSUMER_JOIN_GROUP = 'kafka.consumer.join_group'.freeze
+        SPAN_CONSUMER_LEAVE_GROUP = 'kafka.consumer.leave_group'.freeze
+        SPAN_CONSUMER_SYNC_GROUP = 'kafka.consumer.sync_group'.freeze
+        SPAN_DELIVER_MESSAGES = 'kafka.producer.deliver_messages'.freeze
+        SPAN_PROCESS_BATCH = 'kafka.consumer.process_batch'.freeze
+        SPAN_PROCESS_MESSAGE = 'kafka.consumer.process_message'.freeze
+        SPAN_SEND_MESSAGES = 'kafka.producer.send_messages'.freeze
+        TAG_ATTEMPTS = 'kafka.attempts'.freeze
+        TAG_API = 'kafka.api'.freeze
+        TAG_CLIENT = 'kafka.client'.freeze
+        TAG_GROUP = 'kafka.group'.freeze
+        TAG_HIGHWATER_MARK_OFFSET = 'kafka.highwater_mark_offset'.freeze
+        TAG_MESSAGE_COUNT = 'kafka.message_count'.freeze
+        TAG_MESSAGE_KEY = 'kafka.message_key'.freeze
+        TAG_DELIVERED_MESSAGE_COUNT = 'kafka.delivered_message_count'.freeze
+        TAG_OFFSET = 'kafka.offset'.freeze
+        TAG_OFFSET_LAG = 'kafka.offset_lag'.freeze
+        TAG_PARTITION = 'kafka.partition'.freeze
+        TAG_REQUEST_SIZE = 'kafka.request_size'.freeze
+        TAG_RESPONSE_SIZE = 'kafka.response_size'.freeze
+        TAG_SENT_MESSAGE_COUNT = 'kafka.sent_message_count'.freeze
+        TAG_TOPIC = 'kafka.topic'.freeze
+        TAG_TOPIC_PARTITIONS = 'kafka.topic_partitions'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/kafka/integration.rb

@@ -0,0 +1,39 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/kafka/configuration/settings'
+require 'ddtrace/contrib/kafka/patcher'
+
+module Datadog
+  module Contrib
+    module Kafka
+      # Description of Kafka integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('0.7.10')
+
+        register_as :kafka, auto_patch: false
+
+        def self.version
+          Gem.loaded_specs['ruby-kafka'] && Gem.loaded_specs['ruby-kafka'].version
+        end
+
+        def self.loaded?
+          !defined?(::Kafka).nil? \
+            && !defined?(::ActiveSupport::Notifications).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/kafka/patcher.rb

@@ -0,0 +1,26 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/kafka/ext'
+require 'ddtrace/contrib/kafka/events'
+
+module Datadog
+  module Contrib
+    module Kafka
+      # Patcher enables patching of 'kafka' module.
+      module Patcher
+        include Contrib::Patcher
+
+        module_function
+
+        def target_version
+          Integration.version
+        end
+
+        def patch
+          # Subscribe to Kafka events
+          Events.subscribe!
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'ddtrace/contrib/configuration/settings'
+require 'ddtrace/contrib/mongodb/ext'
+
+module Datadog
+  module Contrib
+    module MongoDB
+      module Configuration
+        # Custom settings for the MongoDB integration
+        class Settings < Contrib::Configuration::Settings
+          DEFAULT_QUANTIZE = { show: [:collection, :database, :operation] }.freeze
+
+          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 :quantize, default: DEFAULT_QUANTIZE
+          option :service_name, default: Ext::SERVICE_NAME
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Datadog
+  module Contrib
+    module MongoDB
+      # MongoDB integration constants
+      module Ext
+        APP = 'mongodb'.freeze
+        ENV_ANALYTICS_ENABLED = 'DD_MONGO_ANALYTICS_ENABLED'.freeze
+        ENV_ANALYTICS_SAMPLE_RATE = 'DD_MONGO_ANALYTICS_SAMPLE_RATE'.freeze
+        SERVICE_NAME = 'mongodb'.freeze
+        SPAN_COMMAND = 'mongo.cmd'.freeze
+        SPAN_TYPE_COMMAND = 'mongodb'.freeze
+        TAG_COLLECTION = 'mongodb.collection'.freeze
+        TAG_DB = 'mongodb.db'.freeze
+        TAG_OPERATION = 'mongodb.operation'.freeze
+        TAG_QUERY = 'mongodb.query'.freeze
+        TAG_ROWS = 'mongodb.rows'.freeze
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/mongodb/instrumentation.rb

@@ -0,0 +1,67 @@
+require 'ddtrace/pin'
+require 'ddtrace/ext/net'
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/mongodb/ext'
+require 'ddtrace/contrib/mongodb/parsers'
+require 'ddtrace/contrib/mongodb/subscribers'
+
+module Datadog
+  module Contrib
+    module MongoDB
+      # Instrumentation for Mongo integration
+      module Instrumentation
+        # Instrumentation for Mongo::Client
+        module Client
+          def self.included(base)
+            base.send(: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::Pin.get_from(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
+
+        # Instrumentation for Mongo::Address
+        module Address
+          def self.included(base)
+            base.send(:include, InstanceMethods)
+          end
+
+          # Instance methods for Mongo::Address
+          module InstanceMethods
+            def datadog_pin
+              @datadog_pin ||= begin
+                service = Datadog.configuration[:mongo][:service_name]
+
+                Datadog::Pin.new(
+                  service,
+                  app: Datadog::Contrib::MongoDB::Ext::APP,
+                  app_type: Datadog::Ext::AppTypes::DB,
+                  tracer: -> { Datadog.configuration[:mongo][:tracer] }
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/mongodb/integration.rb

@@ -0,0 +1,38 @@
+require 'ddtrace/contrib/integration'
+require 'ddtrace/contrib/mongodb/configuration/settings'
+require 'ddtrace/contrib/mongodb/patcher'
+
+module Datadog
+  module Contrib
+    module MongoDB
+      # Description of MongoDB integration
+      class Integration
+        include Contrib::Integration
+
+        MINIMUM_VERSION = Gem::Version.new('2.1.0')
+
+        register_as :mongo, auto_patch: true
+
+        def self.version
+          Gem.loaded_specs['mongo'] && Gem.loaded_specs['mongo'].version
+        end
+
+        def self.loaded?
+          !defined?(::Mongo::Monitoring::Global).nil?
+        end
+
+        def self.compatible?
+          super && version >= MINIMUM_VERSION
+        end
+
+        def default_configuration
+          Configuration::Settings.new
+        end
+
+        def patcher
+          Patcher
+        end
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/mongodb/parsers.rb

@@ -0,0 +1,68 @@
+module Datadog
+  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 = 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 = Quantization::Hash.format({
+                                                'operation' => command_name,
+                                                'database' => database_name,
+                                                'collection' => command.values.first
+                                              }, options)
+
+        base_info.merge(Quantization::Hash.format(command, options))
+      end
+
+      # removes the values from the given query; this quantization recursively
+      # replace elements available in a given query, so that Arrays, Hashes and so
+      # on are compacted. It ensures a low cardinality so that it can be used
+      # as a Span resource.
+      # @deprecated
+      def quantize_statement(statement, skip = [])
+        case statement
+        when Hash
+          statement.each_with_object({}) do |(key, value), quantized|
+            quantized[key] = quantize_value(value, skip) unless skip.include?(key)
+          end
+        else
+          quantize_value(statement, skip)
+        end
+      end
+
+      # @deprecated
+      def quantize_value(value, skip = [])
+        case value
+        when Hash
+          quantize_statement(value, skip)
+        when Array
+          quantize_value(value.first, skip)
+        else
+          PLACEHOLDER
+        end
+      end
+
+      def quantization_options
+        Datadog::Quantization::Hash.merge_options(DEFAULT_OPTIONS, configuration[:quantize])
+      end
+
+      def configuration
+        Datadog.configuration[:mongo]
+      end
+    end
+  end
+end

data/lib/ddtrace/contrib/mongodb/patcher.rb

@@ -0,0 +1,31 @@
+require 'ddtrace/contrib/patcher'
+require 'ddtrace/contrib/mongodb/ext'
+require 'ddtrace/contrib/mongodb/instrumentation'
+
+module Datadog
+  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::Address.send(:include, Instrumentation::Address)
+          ::Mongo::Client.send(: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