ddtrace 0.35.2 → 1.1.0

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

@@ -0,0 +1,78 @@
+# typed: true
+
+require 'datadog/tracing/contrib/configurable'
+require 'datadog/tracing/contrib/patchable'
+require 'datadog/tracing/contrib/registerable'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # {Integration} provides the basic contract of a tracing integration.
+      #
+      # An example for a simple instrumentation of a fictional `BillingApi::Client`:
+      #
+      # ```
+      # require 'ddtrace'
+      #
+      # module BillingApi
+      #   class Integration
+      #     include ::Datadog::Tracing::Contrib::Integration
+      #
+      #     register_as :billing_api # Register in the global tracing registry
+      #
+      #     def self.available?
+      #       defined?(::BillingApi::Client) # Check if the target for instrumentation is present.
+      #     end
+      #
+      #     def new_configuration
+      #       Settings.new
+      #     end
+      #
+      #     def patcher
+      #       Patcher
+      #     end
+      #   end
+      #
+      #   class Settings < ::Datadog::Tracing::Contrib::Configuration::Settings
+      #     # Custom service name, if a separate service is desirable for BillingApi calls.
+      #     option :service, default: nil
+      #   end
+      #
+      #   module Patcher
+      #     include ::Datadog::Tracing::Contrib::Patcher
+      #
+      #     def self.patch
+      #       ::BillingApi::Client.prepend(Instrumentation)
+      #     end
+      #   end
+      #
+      #   module Instrumentation
+      #     def api_request!(env)
+      #       Tracing.trace('billing.request',
+      #                            type: 'http',
+      #                            service: Datadog.configuration.tracing[:billing_api][:service]) do |span|
+      #         span.resource = env[:route].to_s
+      #         span.set_tag('client_id', env[:client][:id])
+      #
+      #         super
+      #       end
+      #     end
+      #   end
+      # end
+      #
+      # Datadog.configure do |c|
+      #   c.tracing.instrument :billing_api # Settings (e.g. `service:`) can be provided as keyword arguments.
+      # end
+      # ```
+      #
+      # @public_api
+      module Integration
+        def self.included(base)
+          base.include(Configurable)
+          base.include(Patchable)
+          base.include(Registerable)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# typed: false
+
+require 'datadog/tracing/contrib/configuration/settings'
+require 'datadog/tracing/contrib/kafka/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        module Configuration
+          # Custom settings for the Kafka 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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        # Defines basic behaviors for an event for a consumer.
+        module ConsumerEvent
+          def process(span, _event, _id, payload)
+            super
+
+            span.set_tag(Ext::TAG_GROUP, payload[:group_id])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Kafka
+        # Defines basic behaviors for an event for a consumer group.
+        module ConsumerGroupEvent
+          def process(span, _event, _id, payload)
+            super
+
+            span.resource = payload[:group_id]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# typed: false
+
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/active_support/notifications/event'
+require 'datadog/tracing/contrib/kafka/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(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,42 @@
+# typed: true
+
+require 'datadog/tracing/contrib/kafka/ext'
+require 'datadog/tracing/contrib/kafka/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,49 @@
+# typed: true
+
+require 'datadog/tracing/contrib/kafka/ext'
+require 'datadog/tracing/contrib/kafka/event'
+require 'datadog/tracing/contrib/kafka/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,47 @@
+# typed: true
+
+require 'datadog/tracing/contrib/kafka/ext'
+require 'datadog/tracing/contrib/kafka/event'
+require 'datadog/tracing/contrib/kafka/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,47 @@
+# typed: true
+
+require 'datadog/tracing/contrib/kafka/ext'
+require 'datadog/tracing/contrib/kafka/event'
+require 'datadog/tracing/contrib/kafka/consumer_event'
+require 'datadog/tracing/contrib/kafka/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,37 @@
+# typed: true
+
+require 'datadog/tracing/contrib/kafka/ext'
+require 'datadog/tracing/contrib/kafka/event'
+require 'datadog/tracing/contrib/kafka/consumer_event'
+require 'datadog/tracing/contrib/kafka/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,37 @@
+# typed: true
+
+require 'datadog/tracing/contrib/kafka/ext'
+require 'datadog/tracing/contrib/kafka/event'
+require 'datadog/tracing/contrib/kafka/consumer_event'
+require 'datadog/tracing/contrib/kafka/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,37 @@
+# typed: true
+
+require 'datadog/tracing/contrib/kafka/ext'
+require 'datadog/tracing/contrib/kafka/event'
+require 'datadog/tracing/contrib/kafka/consumer_event'
+require 'datadog/tracing/contrib/kafka/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,40 @@
+# typed: true
+
+require 'datadog/tracing/contrib/kafka/ext'
+require 'datadog/tracing/contrib/kafka/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)
+              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,43 @@
+# typed: true
+
+require 'datadog/tracing/contrib/kafka/ext'
+require 'datadog/tracing/contrib/kafka/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
+              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 @@
+# typed: false
+
+require 'datadog/tracing/contrib/kafka/events/connection/request'
+require 'datadog/tracing/contrib/kafka/events/consumer/process_batch'
+require 'datadog/tracing/contrib/kafka/events/consumer/process_message'
+require 'datadog/tracing/contrib/kafka/events/consumer_group/heartbeat'
+require 'datadog/tracing/contrib/kafka/events/consumer_group/join_group'
+require 'datadog/tracing/contrib/kafka/events/consumer_group/leave_group'
+require 'datadog/tracing/contrib/kafka/events/consumer_group/sync_group'
+require 'datadog/tracing/contrib/kafka/events/produce_operation/send_messages'
+require 'datadog/tracing/contrib/kafka/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