ddtrace 0.34.1 → 1.23.1

data/lib/datadog/tracing/contrib/ethon/multi_patch.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require_relative '../../metadata/ext'
+require_relative '../../propagation/http'
+require_relative 'ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Ethon
+        # Ethon MultiPatch
+        module MultiPatch
+          def self.included(base)
+            # No need to prepend here since add method is included into Multi class
+            base.include(InstanceMethods)
+          end
+
+          # InstanceMethods - implementing instrumentation
+          module InstanceMethods
+            def add(easy)
+              handles = super
+              return handles unless handles && Tracing.enabled?
+
+              if datadog_multi_performing?
+                # Start Easy span in case Multi is already performing
+                easy.datadog_before_request(continue_from: datadog_multi_trace_digest)
+              end
+              handles
+            end
+
+            def perform
+              if Tracing.enabled?
+                easy_handles.each do |easy|
+                  easy.datadog_before_request(continue_from: datadog_multi_trace_digest) unless easy.datadog_span_started?
+                end
+              end
+              super
+            ensure
+              if Tracing.enabled? && datadog_multi_performing?
+                @datadog_multi_span.finish
+                @datadog_multi_span = nil
+                @datadog_multi_trace_digest = nil
+              end
+            end
+
+            private
+
+            def datadog_multi_performing?
+              instance_variable_defined?(:@datadog_multi_span) && !@datadog_multi_span.nil?
+            end
+
+            def datadog_multi_trace_digest
+              return unless datadog_multi_span
+
+              @datadog_multi_trace_digest
+            end
+
+            def datadog_multi_span
+              return @datadog_multi_span if datadog_multi_performing?
+
+              @datadog_multi_span = Tracing.trace(
+                Ext::SPAN_MULTI_REQUEST,
+                service: datadog_configuration[:service_name]
+              )
+              @datadog_multi_trace_digest = Tracing.active_trace.to_digest
+
+              @datadog_multi_span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              @datadog_multi_span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_MULTI_REQUEST)
+
+              @datadog_multi_span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
+
+              # Tag original global service name if not used
+              if @datadog_multi_span.service != Datadog.configuration.service
+                @datadog_multi_span.set_tag(
+                  Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE,
+                  Datadog.configuration.service
+                )
+              end
+
+              # Set analytics sample rate
+              Contrib::Analytics.set_sample_rate(@datadog_multi_span, analytics_sample_rate) if analytics_enabled?
+
+              @datadog_multi_span
+            end
+
+            def datadog_configuration
+              Datadog.configuration.tracing[:ethon]
+            end
+
+            def analytics_enabled?
+              Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+            end
+
+            def analytics_sample_rate
+              datadog_configuration[:analytics_sample_rate]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Ethon
+        # Patcher enables patching of 'ethon' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative 'easy_patch'
+            require_relative 'multi_patch'
+
+            ::Ethon::Easy.include(EasyPatch)
+            ::Ethon::Multi.include(MultiPatch)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Excon
+        module Configuration
+          # Custom settings for the Excon 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 :distributed_tracing, default: true, type: :bool
+            option :error_handler do |o|
+              o.type :proc, nilable: true
+            end
+            option :split_by_domain, default: false, type: :bool
+
+            option :service_name do |o|
+              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
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Excon
+        # Excon integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_EXCON_ENABLED'
+          ENV_SERVICE_NAME = 'DD_TRACE_EXCON_SERVICE_NAME'
+          ENV_PEER_SERVICE = 'DD_TRACE_EXCON_PEER_SERVICE'
+
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_EXCON_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_EXCON_ANALYTICS_SAMPLE_RATE'
+          DEFAULT_PEER_SERVICE_NAME = 'excon'
+          SPAN_REQUEST = 'excon.request'
+          TAG_COMPONENT = 'excon'
+          TAG_OPERATION_REQUEST = 'request'
+          PEER_SERVICE_SOURCES = Array[
+            Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
+            Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative '../configuration/resolvers/pattern_resolver'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Excon
+        # Description of Excon integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('0.50.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          register_as :excon
+
+          def self.version
+            Gem.loaded_specs['excon'] && Gem.loaded_specs['excon'].version
+          end
+
+          def self.loaded?
+            !defined?(::Excon).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/excon/middleware.rb

@@ -0,0 +1,192 @@
+require 'excon'
+
+require_relative '../../../core'
+require_relative '../../metadata/ext'
+require_relative '../../propagation/http'
+require_relative '../analytics'
+require_relative 'ext'
+require_relative '../http_annotation_helper'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Excon
+        # Middleware implements an excon-middleware for ddtrace instrumentation
+        class Middleware < ::Excon::Middleware::Base
+          include Contrib::HttpAnnotationHelper
+
+          DEFAULT_ERROR_HANDLER = lambda do |response|
+            Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(response[:status])
+          end
+
+          def initialize(stack, options = {})
+            super(stack)
+            @default_options = datadog_configuration.options_hash.merge(options)
+          end
+
+          def request_call(datum)
+            begin
+              unless datum.key?(:datadog_span)
+                @options = build_request_options!(datum)
+                span = Tracing.trace(Ext::SPAN_REQUEST)
+                trace = Tracing.active_trace
+                datum[:datadog_span] = span
+                annotate!(span, datum)
+                propagate!(trace, span, datum) if distributed_tracing?
+
+                span
+              end
+            rescue StandardError => e
+              Datadog.logger.debug(e.message)
+            end
+
+            @stack.request_call(datum)
+          end
+
+          def response_call(datum)
+            @stack.response_call(datum).tap do |d|
+              handle_response(d)
+            end
+          end
+
+          def error_call(datum)
+            handle_response(datum)
+            @stack.error_call(datum)
+          end
+
+          # Returns a child class of this trace middleware
+          # With options given as defaults.
+          def self.with(options = {})
+            Class.new(self) do
+              @options = options
+
+              # rubocop:disable Style/TrivialAccessors
+              def self.options
+                @options
+              end
+              # rubocop:enable Style/TrivialAccessors
+
+              # default_options in this case contains our specific middleware options
+              # so we want it to take precedence in build_request_options
+              def build_request_options!(datum)
+                datadog_configuration(datum[:host]).options_hash.merge(@default_options)
+              end
+
+              def initialize(stack)
+                super(stack, self.class.options)
+              end
+            end
+          end
+
+          # Returns a copy of the default stack with the trace middleware injected
+          def self.around_default_stack
+            ::Excon.defaults[:middlewares].dup.tap do |default_stack|
+              # If the default stack contains a version of the trace middleware already...
+              existing_trace_middleware = default_stack.find { |m| m <= Middleware }
+              default_stack.delete(existing_trace_middleware) if existing_trace_middleware
+
+              # Inject after the ResponseParser middleware
+              response_middleware_index = default_stack.index(::Excon::Middleware::ResponseParser).to_i
+              default_stack.insert(response_middleware_index + 1, self)
+            end
+          end
+
+          private
+
+          def analytics_enabled?
+            Contrib::Analytics.enabled?(@options[:analytics_enabled])
+          end
+
+          def analytics_sample_rate
+            @options[:analytics_sample_rate]
+          end
+
+          def distributed_tracing?
+            @options[:distributed_tracing] == true && Tracing.enabled?
+          end
+
+          def error_handler
+            @options[:error_handler] || DEFAULT_ERROR_HANDLER
+          end
+
+          def annotate!(span, datum)
+            span.resource = datum[:method].to_s.upcase
+            span.service = service_name(datum[:host], @options)
+            span.span_type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
+
+            if @options[:peer_service]
+              span.set_tag(
+                Tracing::Metadata::Ext::TAG_PEER_SERVICE,
+                @options[: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(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_REQUEST)
+
+            span.set_tag(Tracing::Metadata::Ext::TAG_PEER_HOSTNAME, datum[:host])
+
+            # Set analytics sample rate
+            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, datum[:path])
+            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, datum[:method].to_s.upcase)
+            span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, datum[:host])
+            span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, datum[:port])
+            span.set_tags(
+              Datadog.configuration.tracing.header_tags.request_tags(
+                Core::Utils::Hash::CaseInsensitiveWrapper.new(datum[:headers])
+              )
+            )
+
+            Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+          end
+
+          def handle_response(datum)
+            if datum.key?(:datadog_span)
+              datum[:datadog_span].tap do |span|
+                return span if span.finished?
+
+                if datum.key?(:response)
+                  response = datum[:response]
+                  span.set_error(["Error #{response[:status]}", response[:body]]) if error_handler.call(response)
+                  span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, response[:status])
+
+                  span.set_tags(
+                    Datadog.configuration.tracing.header_tags.response_tags(
+                      Core::Utils::Hash::CaseInsensitiveWrapper.new(response[:headers])
+                    )
+                  )
+                end
+                span.set_error(datum[:error]) if datum.key?(:error)
+                span.finish
+                datum.delete(:datadog_span)
+              end
+            end
+          rescue StandardError => e
+            Datadog.logger.debug(e.message)
+          end
+
+          def propagate!(trace, span, datum)
+            Tracing::Propagation::HTTP.inject!(trace, datum[:headers])
+          end
+
+          def build_request_options!(datum)
+            @default_options.merge(datadog_configuration(datum[:host]).options_hash)
+          end
+
+          def datadog_configuration(host = :default)
+            Datadog.configuration.tracing[:excon, host]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Excon
+        # Patcher enables patching of 'excon' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative 'middleware'
+            add_middleware
+          end
+
+          def add_middleware
+            ::Excon.defaults[:middlewares] = Middleware.around_default_stack
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      # Contrib specific constants
+      module Ext
+        # @public_api
+        module DB
+          TAG_INSTANCE = 'db.instance'
+          TAG_USER = 'db.user'
+          TAG_SYSTEM = 'db.system'
+          TAG_STATEMENT = 'db.statement'
+          TAG_ROW_COUNT = 'db.row_count'
+          PEER_SERVICE_SOURCES = Array[TAG_INSTANCE,
+            Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
+            Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
+        end
+
+        module RPC
+          TAG_SYSTEM = 'rpc.system'
+          TAG_SERVICE = 'rpc.service'
+          TAG_METHOD = 'rpc.method'
+          PEER_SERVICE_SOURCES = Array[TAG_SERVICE,
+            Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
+            Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
+          module GRPC
+            TAG_STATUS_CODE = 'rpc.grpc.status_code'
+            TAG_FULL_METHOD = 'rpc.grpc.full_method'
+          end
+        end
+
+        module Messaging
+          TAG_SYSTEM = 'messaging.system'
+          PEER_SERVICE_SOURCES = Array[Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
+            Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
+        end
+
+        module Metadata
+          # Name of tag from which where peer.service information was extracted from
+          TAG_PEER_SERVICE_SOURCE = '_dd.peer.service.source'
+
+          # Value of tag from which peer.service value was remapped from
+          TAG_PEER_SERVICE_REMAP = '_dd.peer.service.remapped_from'
+
+          # Set equal to the global service when contrib span.service is overriden
+          TAG_BASE_SERVICE = '_dd.base_service'
+        end
+      end
+    end
+  end
+end