cw-datadog 2.23.0.2

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

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+require_relative '../../metadata/ext'
+require_relative '../http'
+require_relative '../analytics'
+require_relative 'ext'
+require_relative '../http_annotation_helper'
+require_relative '../../../core/telemetry/logger'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Faraday
+        # Middleware implements a faraday-middleware for datadog instrumentation
+        class Middleware < ::Faraday::Middleware
+          include Contrib::HttpAnnotationHelper
+
+          def initialize(app, options = {})
+            super(app)
+            @options = options
+          end
+
+          def call(env)
+            # Resolve configuration settings to use for this request.
+            # Do this once to reduce expensive regex calls.
+            request_options = build_request_options!(env)
+
+            Tracing.trace(Ext::SPAN_REQUEST, on_error: request_options[:on_error]) do |span, trace|
+              annotate!(span, env, request_options)
+              if Tracing::Distributed::PropagationPolicy.enabled?(
+                global_config: request_options,
+                trace: trace
+              )
+                propagate!(trace, span, env)
+              end
+              app.call(env).on_complete { |resp| handle_response(span, resp, request_options) }
+            end
+          end
+
+          private
+
+          attr_reader :app
+
+          # rubocop:disable Metrics/AbcSize
+          def annotate!(span, env, options)
+            span.resource = resource_name(env)
+            span.service = service_name(env[:url].host, options)
+            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, env[:url].host)
+
+            # Set analytics sample rate
+            if Contrib::Analytics.enabled?(options[:analytics_enabled])
+              Contrib::Analytics.set_sample_rate(span, options[:analytics_sample_rate])
+            end
+
+            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, env[:url].path)
+            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, env[:method].to_s.upcase)
+            span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_HOST, env[:url].host)
+            span.set_tag(Tracing::Metadata::Ext::NET::TAG_TARGET_PORT, env[:url].port)
+            span.set_tags(
+              Datadog.configuration.tracing.header_tags.request_tags(env[:request_headers])
+            )
+
+            Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
+          rescue => e
+            Datadog.logger.error(e.message)
+            Datadog::Core::Telemetry::Logger.report(e)
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          # rubocop:disable Metrics/AbcSize
+          def handle_response(span, env, options)
+            span.set_error(["Error #{env[:status]}", env[:body]]) if options[:error_status_codes].include? env[:status]
+
+            span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, env[:status])
+
+            span.set_tags(
+              Datadog.configuration.tracing.header_tags.response_tags(env[:response_headers])
+            )
+          rescue => e
+            Datadog.logger.error(e.message)
+            Datadog::Core::Telemetry::Logger.report(e)
+          end
+          # rubocop:enable Metrics/AbcSize
+
+          def propagate!(trace, span, env)
+            Contrib::HTTP.inject(trace, env[:request_headers])
+          end
+
+          def resource_name(env)
+            env[:method].to_s.upcase
+          end
+
+          def build_request_options!(env)
+            datadog_configuration
+              .options_hash # integration level settings
+              .merge(datadog_configuration(env[:url].host).options_hash) # per-host override
+              .merge(@options) # middleware instance override
+          end
+
+          def datadog_configuration(host = :default)
+            Datadog.configuration.tracing[:faraday, host]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative 'connection'
+require_relative 'ext'
+require_relative 'rack_builder'
+require_relative '../patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Faraday
+        # Patcher enables patching of 'faraday' module.
+        module Patcher
+          include Contrib::Patcher
+
+          module_function
+
+          def target_version
+            Integration.version
+          end
+
+          def patch
+            require_relative 'middleware'
+
+            register_middleware!
+            add_default_middleware!
+          end
+
+          def register_middleware!
+            ::Faraday::Middleware.register_middleware(datadog_tracing: Middleware)
+          end
+
+          def add_default_middleware!
+            if target_version >= Gem::Version.new('1.0.0')
+              # Patch the default connection (e.g. +Faraday.get+)
+              ::Faraday.default_connection.use(:datadog_tracing)
+
+              # Patch new connection instances (e.g. +Faraday.new+)
+              ::Faraday::Connection.prepend(Connection)
+            else
+              # Patch the default connection (e.g. +Faraday.get+)
+              #
+              # We insert our middleware before the 'adapter', which is
+              # always the last handler.
+              idx = ::Faraday.default_connection.builder.handlers.size - 1
+              ::Faraday.default_connection.builder.insert(idx, Middleware)
+
+              # Patch new connection instances (e.g. +Faraday.new+)
+              ::Faraday::RackBuilder.prepend(RackBuilder)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/faraday/rack_builder.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Faraday
+        # Handles installation of our middleware if the user has *not*
+        # already explicitly configured it for this correction.
+        #
+        # RackBuilder class was introduced in faraday 0.9.0:
+        # https://github.com/lostisland/faraday/commit/77d7546d6d626b91086f427c56bc2cdd951353b3
+        module RackBuilder
+          def adapter(*args)
+            use(:datadog_tracing) unless @handlers.any? { |h| h.klass == Middleware }
+
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+require_relative '../../status_range_matcher'
+require_relative '../../status_range_env_parser'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Grape
+        module Configuration
+          # Custom settings for the Grape 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, nilable: true
+              o.env Ext::ENV_ANALYTICS_ENABLED
+            end
+
+            option :analytics_sample_rate do |o|
+              o.type :float
+              o.env Ext::ENV_ANALYTICS_SAMPLE_RATE
+              o.default 1.0
+            end
+
+            option :service_name
+
+            option :on_error do |o|
+              o.type :proc, nilable: true
+            end
+
+            option :error_status_codes do |o|
+              o.env Ext::ENV_ERROR_STATUS_CODES
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to server (500..599)
+                  Datadog.configuration.tracing.http_error_statuses.server
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
+              end
+              o.env_parser do |v|
+                Tracing::Contrib::StatusRangeEnvParser.call(v) if v
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/grape/endpoint.rb

@@ -0,0 +1,316 @@
+# frozen_string_literal: true
+
+require_relative '../../../core'
+require_relative '../../../core/telemetry/logger'
+require_relative '../../metadata/ext'
+require_relative '../analytics'
+require_relative '../rack/ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Grape
+        # Endpoint module includes a list of subscribers to create
+        # traces when a Grape endpoint is hit
+        module Endpoint
+          KEY_RUN = 'datadog_grape_endpoint_run'
+          KEY_RENDER = 'datadog_grape_endpoint_render'
+
+          class << self
+            def subscribe
+              # subscribe when a Grape endpoint is hit
+              ::ActiveSupport::Notifications.subscribe('endpoint_run.grape.start_process') do |*args|
+                endpoint_start_process(*args)
+              end
+              ::ActiveSupport::Notifications.subscribe('endpoint_run.grape') do |*args|
+                endpoint_run(*args)
+              end
+              ::ActiveSupport::Notifications.subscribe('endpoint_render.grape.start_render') do |*args|
+                endpoint_start_render(*args)
+              end
+              ::ActiveSupport::Notifications.subscribe('endpoint_render.grape') do |*args|
+                endpoint_render(*args)
+              end
+              ::ActiveSupport::Notifications.subscribe('endpoint_run_filters.grape') do |*args|
+                endpoint_run_filters(*args)
+              end
+            end
+
+            def endpoint_start_process(_name, _start, _finish, _id, payload)
+              return if Thread.current[KEY_RUN]
+              return unless enabled?
+
+              # collect endpoint details
+              endpoint = payload.fetch(:endpoint)
+              env = payload.fetch(:env)
+              api_view = api_view(endpoint.options[:for])
+              request_method = endpoint.options.fetch(:method).first
+              path = endpoint_expand_path(endpoint)
+              resource = "#{api_view} #{request_method} #{path}"
+
+              # Store the beginning of a trace
+              span = Tracing.trace(
+                Ext::SPAN_ENDPOINT_RUN,
+                service: service_name,
+                type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND,
+                resource: resource
+              )
+              trace = Tracing.active_trace
+
+              # Set the trace resource
+              trace.resource = span.resource
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ENDPOINT_RUN)
+
+              if (grape_route = env['grape.routing_args']) && grape_route[:route_info]
+                trace.set_tag(
+                  Tracing::Metadata::Ext::HTTP::TAG_ROUTE,
+                  # here we are removing the format from the path:
+                  # e.g. /path/to/resource(.json) => /path/to/resource
+                  # e.g. /path/to/resource(.:format) => /path/to/resource
+                  grape_route[:route_info].path&.gsub(/\(\.:?\w+\)\z/, '')
+                )
+
+                trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, env['SCRIPT_NAME'])
+              end
+
+              Thread.current[KEY_RUN] = true
+            rescue => e
+              Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
+            end
+
+            def endpoint_run(name, start, finish, id, payload)
+              return unless Thread.current[KEY_RUN]
+
+              Thread.current[KEY_RUN] = false
+
+              return unless enabled?
+
+              trace = Tracing.active_trace
+              span = Tracing.active_span
+              return unless trace && span
+
+              begin
+                # collect endpoint details
+                endpoint = payload.fetch(:endpoint)
+                api_view = api_view(endpoint.options[:for])
+                request_method = endpoint.options.fetch(:method).first
+                path = endpoint_expand_path(endpoint)
+
+                trace.resource = span.resource
+
+                # Set analytics sample rate
+                Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+                # Measure service stats
+                Contrib::Analytics.set_measured(span)
+
+                handle_error_and_status_code(span, endpoint, payload)
+
+                # override the current span with this notification values
+                span.set_tag(Ext::TAG_ROUTE_ENDPOINT, api_view) unless api_view.nil?
+                span.set_tag(Ext::TAG_ROUTE_PATH, path)
+                span.set_tag(Ext::TAG_ROUTE_METHOD, request_method)
+
+                span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_METHOD, request_method)
+                span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_URL, path)
+              ensure
+                span.start(start)
+                span.finish(finish)
+              end
+            rescue => e
+              Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
+            end
+
+            # Status code resolution is tied to the exception handling
+            def handle_error_and_status_code(span, endpoint, payload)
+              status = nil
+
+              # Handle exceptions and status code
+              if (exception_object = payload[:exception_object])
+                # If the exception is not an internal Grape error, we won't have a status code at this point.
+                status = exception_object.status if exception_object.respond_to?(:status)
+
+                handle_error(span, exception_object, status)
+              else
+                # Status code is unreliable in `endpoint_run.grape` if there was an exception.
+                # Only after `Grape::Middleware::Error#run_rescue_handler` that the error status code of a request with a
+                # Ruby exception error is resolved. But that handler is called further down the Grape middleware stack.
+                # Rack span will then be the most reliable source for status codes.
+                # DEV: As a corollary, instrumenting Grape without Rack will provide incomplete
+                # DEV: status quote information.
+                status = endpoint.status
+                span.set_error(endpoint) if error_status_codes.include?(status)
+              end
+
+              span.set_tag(Tracing::Metadata::Ext::HTTP::TAG_STATUS_CODE, status) if status
+            end
+
+            def endpoint_start_render(*)
+              return if Thread.current[KEY_RENDER]
+              return unless enabled?
+
+              # Store the beginning of a trace
+              span = Tracing.trace(
+                Ext::SPAN_ENDPOINT_RENDER,
+                service: service_name,
+                type: Tracing::Metadata::Ext::HTTP::TYPE_TEMPLATE
+              )
+
+              span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+              span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ENDPOINT_RENDER)
+
+              Thread.current[KEY_RENDER] = true
+            rescue => e
+              Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
+            end
+
+            def endpoint_render(name, start, finish, id, payload)
+              return unless Thread.current[KEY_RENDER]
+
+              Thread.current[KEY_RENDER] = false
+
+              return unless enabled?
+
+              span = Tracing.active_span
+              return unless span
+
+              # catch thrown exceptions
+              begin
+                # Measure service stats
+                Contrib::Analytics.set_measured(span)
+
+                handle_error(span, payload[:exception_object]) if payload[:exception_object]
+              ensure
+                span.start(start)
+                span.finish(finish)
+              end
+            rescue => e
+              Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
+            end
+
+            def endpoint_run_filters(name, start, finish, id, payload)
+              return unless enabled?
+
+              # safe-guard to prevent submitting empty filters
+              zero_length = (finish - start).zero?
+              filters = payload[:filters]
+              type = payload[:type]
+              return if (!filters || filters.empty?) || !type || zero_length
+
+              span = Tracing.trace(
+                Ext::SPAN_ENDPOINT_RUN_FILTERS,
+                service: service_name,
+                type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND,
+                start_time: start
+              )
+
+              begin
+                span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
+                span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ENDPOINT_RUN_FILTERS)
+
+                # Set analytics sample rate
+                Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
+
+                # Measure service stats
+                Contrib::Analytics.set_measured(span)
+
+                # catch thrown exceptions
+                handle_error(span, payload[:exception_object]) if payload[:exception_object]
+
+                span.set_tag(Ext::TAG_FILTER_TYPE, type.to_s)
+              ensure
+                span.start(start)
+                span.finish(finish)
+              end
+            rescue => e
+              Datadog.logger.error(e.message)
+              Datadog::Core::Telemetry::Logger.report(e)
+            end
+
+            private
+
+            def handle_error(span, exception, status = nil)
+              status ||= (exception.status if exception.respond_to?(:status))
+              if status
+                span.set_error(exception) if error_status_codes.include?(status)
+              else
+                on_error.call(span, exception)
+              end
+            end
+
+            def error_status_codes
+              datadog_configuration[:error_status_codes]
+            end
+
+            def on_error
+              datadog_configuration[:on_error] || Tracing::SpanOperation::Events::DEFAULT_ON_ERROR
+            end
+
+            def api_view(api)
+              # If the API inherits from Grape::API in version >= 1.2.0
+              # then the API will be an instance and the name must be derived from the base.
+              # See https://github.com/ruby-grape/grape/issues/1825
+              if defined?(::Grape::API::Instance) && api <= ::Grape::API::Instance
+                api.base.to_s
+              else
+                api.to_s
+              end
+            end
+
+            def endpoint_expand_path(endpoint)
+              route_path = endpoint.options[:path]
+              namespace = endpoint.routes.first&.namespace || ''
+
+              path = (namespace.split('/') + route_path)
+                .reject { |p| p.blank? || p.eql?('/') }
+                .join('/')
+              path.prepend('/') if path[0] != '/'
+              path
+            end
+
+            def service_name
+              datadog_configuration[:service_name]
+            end
+
+            def analytics_enabled?
+              Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+            end
+
+            def analytics_sample_rate
+              datadog_configuration[:analytics_sample_rate]
+            end
+
+            def exception_is_error?(exception)
+              return false unless exception
+              return true unless exception.respond_to?(:status)
+
+              error_status?(status.exception)
+            end
+
+            def error_status?(status)
+              matcher = datadog_configuration[:error_statuses]
+              return true unless matcher
+
+              matcher&.include?(status)
+            end
+
+            def enabled?
+              Datadog.configuration.tracing.enabled &&
+                datadog_configuration[:enabled] == true
+            end
+
+            def datadog_configuration
+              Datadog.configuration.tracing[:grape]
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Grape
+        # Grape integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_GRAPE_ENABLED'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_GRAPE_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_GRAPE_ANALYTICS_SAMPLE_RATE'
+          ENV_ERROR_STATUS_CODES = 'DD_TRACE_GRAPE_ERROR_STATUS_CODES'
+          SPAN_ENDPOINT_RENDER = 'grape.endpoint_render'
+          SPAN_ENDPOINT_RUN = 'grape.endpoint_run'
+          SPAN_ENDPOINT_RUN_FILTERS = 'grape.endpoint_run_filters'
+          TAG_COMPONENT = 'grape'
+          TAG_FILTER_TYPE = 'grape.filter.type'
+          TAG_OPERATION_ENDPOINT_RENDER = 'endpoint_render'
+          TAG_OPERATION_ENDPOINT_RUN = 'endpoint_run'
+          TAG_OPERATION_ENDPOINT_RUN_FILTERS = 'endpoint_run_filters'
+          TAG_ROUTE_ENDPOINT = 'grape.route.endpoint'
+          TAG_ROUTE_PATH = 'grape.route.path'
+          TAG_ROUTE_METHOD = 'grape.route.method'
+        end
+      end
+    end
+  end
+end