ddtrace 0.54.0 → 1.1.0

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

@@ -0,0 +1,21 @@
+# typed: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Httprb
+        # Httprb integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_HTTPRB_ENABLED'.freeze
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_HTTPRB_ANALYTICS_ENABLED'.freeze
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_EHTTPRB_ANALYTICS_SAMPLE_RATE'.freeze
+          DEFAULT_PEER_SERVICE_NAME = 'httprb'.freeze
+          SPAN_REQUEST = 'httprb.request'.freeze
+          TAG_COMPONENT = 'httprb'.freeze
+          TAG_OPERATION_REQUEST = 'request'.freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,128 @@
+# typed: false
+
+require 'datadog/tracing'
+require 'datadog/tracing/metadata/ext'
+require 'datadog/tracing/propagation/http'
+require 'datadog/tracing/contrib/analytics'
+require 'datadog/tracing/contrib/http_annotation_helper'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Httprb
+        # Instrumentation for Httprb
+        module Instrumentation
+          def self.included(base)
+            base.prepend(InstanceMethods)
+          end
+
+          # Instance methods for configuration
+          module InstanceMethods
+            include Contrib::HttpAnnotationHelper
+
+            def perform(req, options)
+              host = req.uri.host if req.respond_to?(:uri) && req.uri
+              request_options = datadog_configuration(host)
+              client_config = Datadog.configuration_for(self)
+
+              Tracing.trace(Ext::SPAN_REQUEST, on_error: method(:annotate_span_with_error!)) do |span, trace|
+                begin
+                  span.service = service_name(host, request_options, client_config)
+                  span.span_type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
+
+                  if Tracing.enabled? && !should_skip_distributed_tracing?(client_config)
+                    Tracing::Propagation::HTTP.inject!(trace, req)
+                  end
+
+                  # Add additional request specific tags to the span.
+                  annotate_span_with_request!(span, req, request_options)
+                rescue StandardError => e
+                  logger.error("error preparing span for http.rb request: #{e}, Source: #{e.backtrace}")
+                ensure
+                  res = super(req, options)
+                end
+
+                # Add additional response specific tags to the span.
+                annotate_span_with_response!(span, res)
+
+                res
+              end
+            end
+
+            private
+
+            def annotate_span_with_request!(span, req, req_options)
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_REQUEST)
+
+              if req.verb && req.verb.is_a?(String) || req.verb.is_a?(Symbol)
+                http_method = req.verb.to_s.upcase
+                span.resource = http_method
+                span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, http_method)
+              else
+                logger.debug("service #{req_options[:service_name]} span #{Ext::SPAN_REQUEST} missing request verb")
+              end
+
+              if req.uri
+                uri = req.uri
+                span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, uri.path)
+                span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, uri.host)
+                span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, uri.port)
+
+                span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, uri.host)
+              else
+                logger.debug("service #{req_options[:service_name]} span #{Ext::SPAN_REQUEST} missing uri")
+              end
+
+              # Tag as an external peer service
+              span.set_tag(Tracing::Metadata::Ext::TAG_PEER_SERVICE, span.service)
+
+              set_analytics_sample_rate(span, req_options)
+            end
+
+            def annotate_span_with_response!(span, response)
+              return unless response && response.code
+
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response.code)
+
+              case response.code.to_i
+              when 400...599
+                # https://github.com/DataDog/dd-trace-rb/issues/1116
+                # parsing the response body message will alter downstream application behavior
+                span.set_error(["Error #{response.code}", 'Error'])
+              end
+            end
+
+            def annotate_span_with_error!(span, error)
+              span.set_error(error)
+            end
+
+            def datadog_configuration(host = :default)
+              Datadog.configuration.tracing[:httprb, host]
+            end
+
+            def analytics_enabled?(request_options)
+              Contrib::Analytics.enabled?(request_options[:analytics_enabled])
+            end
+
+            def logger
+              Datadog.logger
+            end
+
+            def should_skip_distributed_tracing?(client_config)
+              return !client_config[:distributed_tracing] if client_config && client_config.key?(:distributed_tracing)
+
+              !Datadog.configuration.tracing[:httprb][:distributed_tracing]
+            end
+
+            def set_analytics_sample_rate(span, request_options)
+              return unless analytics_enabled?(request_options)
+
+              Contrib::Analytics.set_sample_rate(span, request_options[:analytics_sample_rate])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# typed: false
+
+require 'datadog/tracing/contrib/integration'
+require 'datadog/tracing/contrib/httprb/configuration/settings'
+require 'datadog/tracing/contrib/configuration/resolvers/pattern_resolver'
+require 'datadog/tracing/contrib/httprb/patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Httprb
+        # Description of Httprb integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('2.0.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :httprb
+
+          def self.version
+            Gem.loaded_specs['http'] && Gem.loaded_specs['http'].version
+          end
+
+          def self.loaded?
+            !defined?(::HTTP).nil? && !defined?(::HTTP::Client).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/httprb/patcher.rb

@@ -0,0 +1,42 @@
+# typed: true
+
+require 'datadog/core/utils/only_once'
+require 'datadog/tracing/contrib/httprb/instrumentation'
+require 'datadog/tracing/contrib/patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Datadog Httprb integration.
+      module Httprb
+        # Patcher enables patching of 'httprb' module.
+        module Patcher
+          include Contrib::Patcher
+
+          PATCH_ONLY_ONCE = Core::Utils::OnlyOnce.new
+
+          module_function
+
+          def patched?
+            PATCH_ONLY_ONCE.ran?
+          end
+
+          def target_version
+            Integration.version
+          end
+
+          # patch applies our patch
+          def patch
+            PATCH_ONLY_ONCE.run do
+              begin
+                ::HTTP::Client.include(Instrumentation)
+              rescue StandardError => e
+                Datadog.logger.error("Unable to apply httprb integration: #{e}")
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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