ddtrace 0.49.0 → 1.12.1

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative '../analytics'
+require_relative '../active_support/notifications/event'
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        # Defines basic behaviors for an ActiveSupport event.
+        module Event
+          def self.included(base)
+            base.include(ActiveSupport::Notifications::Event)
+            base.extend(ClassMethods)
+          end
+
+          # Class methods for Kafka events.
+          module ClassMethods
+            def event_name
+              self::EVENT_NAME
+            end
+
+            def span_options
+              { service: configuration[:service_name] }
+            end
+
+            def configuration
+              Datadog.configuration.tracing[:kafka]
+            end
+
+            def process(span, _event, _id, payload)
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Contrib::Ext::Messaging::TAG_SYSTEM, Ext::TAG_MESSAGING_SYSTEM)
+
+              span.set_tag(Ext::TAG_CLIENT, payload[:client_id])
+
+              # 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)
+
+              report_if_exception(span, payload)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/kafka/events/connection/request.rb

@@ -0,0 +1,40 @@
+require_relative '../../ext'
+require_relative '../../event'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        module Events
+          module Connection
+            # Defines instrumentation for request.connection.kafka event
+            module Request
+              include Kafka::Event
+
+              EVENT_NAME = 'request.connection.kafka'.freeze
+
+              def self.process(span, _event, _id, payload)
+                super
+
+                span.resource = payload[:api]
+
+                span.set_tag(Ext::TAG_REQUEST_SIZE, payload[:request_size]) if payload.key?(:request_size)
+                span.set_tag(Ext::TAG_RESPONSE_SIZE, payload[:response_size]) if payload.key?(:response_size)
+              end
+
+              module_function
+
+              def span_name
+                Ext::SPAN_CONNECTION_REQUEST
+              end
+
+              def span_options
+                super.merge({ tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_CONNECTION_REQUEST } })
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/kafka/events/consumer/process_batch.rb

@@ -0,0 +1,47 @@
+require_relative '../../ext'
+require_relative '../../event'
+require_relative '../../consumer_event'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        module Events
+          module Consumer
+            # Defines instrumentation for process_batch.consumer.kafka event
+            module ProcessBatch
+              include Kafka::Event
+              extend Kafka::ConsumerEvent
+
+              EVENT_NAME = 'process_batch.consumer.kafka'.freeze
+
+              def self.process(span, _event, _id, payload)
+                super
+
+                span.resource = payload[:topic]
+
+                span.set_tag(Ext::TAG_TOPIC, payload[:topic]) if payload.key?(:topic)
+                span.set_tag(Ext::TAG_MESSAGE_COUNT, payload[:message_count]) if payload.key?(:message_count)
+                span.set_tag(Ext::TAG_PARTITION, payload[:partition]) if payload.key?(:partition)
+                if payload.key?(:highwater_mark_offset)
+                  span.set_tag(Ext::TAG_HIGHWATER_MARK_OFFSET, payload[:highwater_mark_offset])
+                end
+                span.set_tag(Ext::TAG_OFFSET_LAG, payload[:offset_lag]) if payload.key?(:offset_lag)
+              end
+
+              module_function
+
+              def span_name
+                Ext::SPAN_PROCESS_BATCH
+              end
+
+              def span_options
+                super.merge({ tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_PROCESS_BATCH } })
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/kafka/events/consumer/process_message.rb

@@ -0,0 +1,45 @@
+require_relative '../../ext'
+require_relative '../../event'
+require_relative '../../consumer_event'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        module Events
+          module Consumer
+            # Defines instrumentation for process_message.consumer.kafka event
+            module ProcessMessage
+              include Kafka::Event
+              extend Kafka::ConsumerEvent
+
+              EVENT_NAME = 'process_message.consumer.kafka'.freeze
+
+              def self.process(span, _event, _id, payload)
+                super
+
+                span.resource = payload[:topic]
+
+                span.set_tag(Ext::TAG_TOPIC, payload[:topic]) if payload.key?(:topic)
+                span.set_tag(Ext::TAG_MESSAGE_KEY, payload[:key]) if payload.key?(:key)
+                span.set_tag(Ext::TAG_PARTITION, payload[:partition]) if payload.key?(:partition)
+                span.set_tag(Ext::TAG_OFFSET, payload[:offset]) if payload.key?(:offset)
+                span.set_tag(Ext::TAG_OFFSET_LAG, payload[:offset_lag]) if payload.key?(:offset_lag)
+              end
+
+              module_function
+
+              def span_name
+                Ext::SPAN_PROCESS_MESSAGE
+              end
+
+              def span_options
+                super.merge({ tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_PROCESS_MESSAGE } })
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/kafka/events/consumer_group/heartbeat.rb

@@ -0,0 +1,45 @@
+require_relative '../../ext'
+require_relative '../../event'
+require_relative '../../consumer_event'
+require_relative '../../consumer_group_event'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        module Events
+          module ConsumerGroup
+            # Defines instrumentation for heartbeat.consumer.kafka event
+            module Heartbeat
+              include Kafka::Event
+              extend Kafka::ConsumerEvent
+              extend Kafka::ConsumerGroupEvent
+
+              EVENT_NAME = 'heartbeat.consumer.kafka'.freeze
+
+              def self.process(span, _event, _id, payload)
+                super
+
+                if payload.key?(:topic_partitions)
+                  payload[:topic_partitions].each do |topic, partitions|
+                    span.set_tag("#{Ext::TAG_TOPIC_PARTITIONS}.#{topic}", partitions)
+                  end
+                end
+              end
+
+              module_function
+
+              def span_name
+                Ext::SPAN_CONSUMER_HEARTBEAT
+              end
+
+              def span_options
+                super.merge({ tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_CONSUMER_HEARTBEAT } })
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/kafka/events/consumer_group/join_group.rb

@@ -0,0 +1,35 @@
+require_relative '../../ext'
+require_relative '../../event'
+require_relative '../../consumer_event'
+require_relative '../../consumer_group_event'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        module Events
+          module ConsumerGroup
+            # Defines instrumentation for join_group.consumer.kafka event
+            module JoinGroup
+              include Kafka::Event
+              extend Kafka::ConsumerEvent
+              extend Kafka::ConsumerGroupEvent
+
+              EVENT_NAME = 'join_group.consumer.kafka'.freeze
+
+              module_function
+
+              def span_name
+                Ext::SPAN_CONSUMER_JOIN_GROUP
+              end
+
+              def span_options
+                super.merge({ tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_CONSUMER_JOIN_GROUP } })
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/kafka/events/consumer_group/leave_group.rb

@@ -0,0 +1,35 @@
+require_relative '../../ext'
+require_relative '../../event'
+require_relative '../../consumer_event'
+require_relative '../../consumer_group_event'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        module Events
+          module ConsumerGroup
+            # Defines instrumentation for leave_group.consumer.kafka event
+            module LeaveGroup
+              include Kafka::Event
+              extend Kafka::ConsumerEvent
+              extend Kafka::ConsumerGroupEvent
+
+              EVENT_NAME = 'leave_group.consumer.kafka'.freeze
+
+              module_function
+
+              def span_name
+                Ext::SPAN_CONSUMER_LEAVE_GROUP
+              end
+
+              def span_options
+                super.merge({ tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_CONSUMER_LEAVE_GROUP } })
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/kafka/events/consumer_group/sync_group.rb

@@ -0,0 +1,35 @@
+require_relative '../../ext'
+require_relative '../../event'
+require_relative '../../consumer_event'
+require_relative '../../consumer_group_event'
+
+module Datadog
+  module Tracing
+    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
+
+              def span_options
+                super.merge({ tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_CONSUMER_SYNC_GROUP } })
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/kafka/events/produce_operation/send_messages.rb

@@ -0,0 +1,39 @@
+require_relative '../../ext'
+require_relative '../../event'
+
+module Datadog
+  module Tracing
+    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)
+                span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_PRODUCER)
+              end
+
+              module_function
+
+              def span_name
+                Ext::SPAN_SEND_MESSAGES
+              end
+
+              def span_options
+                super.merge({ tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_SEND_MESSAGES } })
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/kafka/events/producer/deliver_messages.rb

@@ -0,0 +1,42 @@
+require_relative '../../ext'
+require_relative '../../event'
+
+module Datadog
+  module Tracing
+    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
+                span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_PRODUCER)
+              end
+
+              module_function
+
+              def span_name
+                Ext::SPAN_DELIVER_MESSAGES
+              end
+
+              def span_options
+                super.merge({ tags: { Tracing::Metadata::Ext::TAG_OPERATION => Ext::TAG_OPERATION_DELIVER_MESSAGES } })
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative 'events/connection/request'
+require_relative 'events/consumer/process_batch'
+require_relative 'events/consumer/process_message'
+require_relative 'events/consumer_group/heartbeat'
+require_relative 'events/consumer_group/join_group'
+require_relative 'events/consumer_group/leave_group'
+require_relative 'events/consumer_group/sync_group'
+require_relative 'events/produce_operation/send_messages'
+require_relative 'events/producer/deliver_messages'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        # Defines collection of instrumented Kafka events
+        module Events
+          ALL = [
+            Events::Connection::Request,
+            Events::Consumer::ProcessBatch,
+            Events::Consumer::ProcessMessage,
+            Events::ConsumerGroup::Heartbeat,
+            Events::ConsumerGroup::JoinGroup,
+            Events::ConsumerGroup::LeaveGroup,
+            Events::ConsumerGroup::SyncGroup,
+            Events::ProduceOperation::SendMessages,
+            Events::Producer::DeliverMessages
+          ].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/kafka/ext.rb

@@ -0,0 +1,51 @@
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        # Kafka integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_KAFKA_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_KAFKA_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_KAFKA_ANALYTICS_SAMPLE_RATE'.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
+          TAG_COMPONENT = 'kafka'.freeze
+          TAG_OPERATION_CONNECTION_REQUEST = 'connection.request'.freeze
+          TAG_OPERATION_CONSUMER_HEARTBEAT = 'consumer.heartbeat'.freeze
+          TAG_OPERATION_CONSUMER_JOIN_GROUP = 'consumer.join_group'.freeze
+          TAG_OPERATION_CONSUMER_LEAVE_GROUP = 'consumer.leave_group'.freeze
+          TAG_OPERATION_CONSUMER_SYNC_GROUP = 'consumer.sync_group'.freeze
+          TAG_OPERATION_DELIVER_MESSAGES = 'producer.deliver_messages'.freeze
+          TAG_OPERATION_PROCESS_BATCH = 'consumer.process_batch'.freeze
+          TAG_OPERATION_PROCESS_MESSAGE = 'consumer.process_message'.freeze
+          TAG_OPERATION_SEND_MESSAGES = 'producer.send_messages'.freeze
+          TAG_MESSAGING_SYSTEM = 'kafka'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        # Description of Kafka integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('0.7.10')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          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 new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+require_relative 'ext'
+require_relative 'events'
+
+module Datadog
+  module Tracing
+    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
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Lograge
+        module Configuration
+          # Custom settings for the Lograge integration
+          # @public_api
+          class Settings < Contrib::Configuration::Settings
+            option :enabled do |o|
+              o.default { env_to_bool(Ext::ENV_ENABLED, true) }
+              o.lazy
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Datadog
+  module Tracing
+    module Contrib
+      module Lograge
+        # Lograge integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_LOGRAGE_ENABLED'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative '../../../core/logging/ext'
+
+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[:lograge].enabled
+
+              original_custom_options = super(event)
+
+              # Retrieves trace information for current thread
+              correlation = Tracing.correlation
+              # merge original lambda with datadog context
+
+              datadog_trace_log_hash = {
+                # Adds IDs as tags to log output
+                dd: {
+                  # To preserve precision during JSON serialization, use strings for large numbers
+                  trace_id: correlation.trace_id.to_s,
+                  span_id: correlation.span_id.to_s,
+                  env: correlation.env.to_s,
+                  service: correlation.service.to_s,
+                  version: correlation.version.to_s
+                },
+                ddsource: Core::Logging::Ext::DD_SOURCE
+              }
+
+              datadog_trace_log_hash.merge(original_custom_options)
+            end
+          end
+        end
+      end
+    end
+  end
+end