ddtrace 0.50.0 → 1.0.0

data/lib/ddtrace/contrib/extensions.rb

@@ -1,143 +0,0 @@
-require 'set'
-require 'ddtrace/contrib/registry'
-
-module Datadog
-  module Contrib
-    # Extensions that can be added to the base library
-    # Adds registry, configuration access for integrations.
-    module Extensions
-      def self.extended(base)
-        Datadog.extend(Helpers)
-        Datadog.extend(Configuration)
-        Datadog::Configuration::Settings.include(Configuration::Settings)
-      end
-
-      # Helper methods for Datadog module.
-      module Helpers
-        def registry
-          configuration.registry
-        end
-      end
-
-      # Configuration methods for Datadog module.
-      module Configuration
-        def configure(target = configuration, opts = {})
-          # Reconfigure core settings
-          super
-
-          # Activate integrations
-          if target.respond_to?(:integrations_pending_activation)
-            reduce_verbosity = target.respond_to?(:reduce_verbosity?) ? target.reduce_verbosity? : false
-            target.integrations_pending_activation.each do |integration|
-              next unless integration.respond_to?(:patch)
-
-              # integration.patch returns either true or a hash of details on why patching failed
-              patch_results = integration.patch
-
-              next if patch_results == true
-
-              # if patching failed, only log output if verbosity is unset
-              # or if patching failure is due to compatibility or integration specific reasons
-              next unless !reduce_verbosity ||
-                          ((patch_results[:available] && patch_results[:loaded]) &&
-                           (!patch_results[:compatible] || !patch_results[:patchable]))
-
-              desc = "Available?: #{patch_results[:available]}"
-              desc += ", Loaded? #{patch_results[:loaded]}"
-              desc += ", Compatible? #{patch_results[:compatible]}"
-              desc += ", Patchable? #{patch_results[:patchable]}"
-
-              Datadog.logger.warn("Unable to patch #{patch_results[:name]} (#{desc})")
-            end
-
-            target.integrations_pending_activation.clear
-          end
-
-          target
-        end
-
-        # Extensions for Datadog::Configuration::Settings
-        module Settings
-          InvalidIntegrationError = Class.new(StandardError)
-
-          def self.included(base)
-            # Add the additional options to the global configuration settings
-            base.instance_eval do
-              option :registry, default: Registry.new
-            end
-          end
-
-          # For the provided `integration_name`, resolves a matching configuration
-          # for the provided integration from an integration-specific `key`.
-          #
-          # How the matching is performed is integration-specific.
-          #
-          # @param [Symbol] integration_name the integration name
-          # @param [Object] key the integration-specific lookup key
-          # @return [Datadog::Contrib::Configuration::Settings]
-          def [](integration_name, key = :default)
-            integration = fetch_integration(integration_name)
-            integration.resolve(key) unless integration.nil?
-          end
-
-          # For the provided `integration_name`, retrieves a configuration previously
-          # stored by `#instrument`. Specifically, `describes` should be
-          # the same value provided in the `describes:` option for `#instrument`.
-          #
-          # If no `describes` value is provided, the default configuration is returned.
-          #
-          # @param [Symbol] integration_name the integration name
-          # @param [Object] describes the previously configured `describes:` object. If `nil`,
-          #   fetches the default configuration
-          # @return [Datadog::Contrib::Configuration::Settings]
-          def configuration(integration_name, describes = nil)
-            integration = fetch_integration(integration_name)
-            integration.configuration(describes) unless integration.nil?
-          end
-
-          def instrument(integration_name, options = {}, &block)
-            integration = fetch_integration(integration_name)
-
-            unless integration.nil? || !integration.default_configuration.enabled
-              configuration_name = options[:describes] || :default
-              filtered_options = options.reject { |k, _v| k == :describes }
-              integration.configure(configuration_name, filtered_options, &block)
-              instrumented_integrations[integration_name] = integration
-
-              # Add to activation list
-              integrations_pending_activation << integration
-            end
-          end
-
-          alias_method :use, :instrument
-
-          def integrations_pending_activation
-            @integrations_pending_activation ||= Set.new
-          end
-
-          def instrumented_integrations
-            @instrumented_integrations ||= {}
-          end
-
-          def reset!
-            instrumented_integrations.clear
-            super
-          end
-
-          def fetch_integration(name)
-            registry[name] ||
-              raise(InvalidIntegrationError, "'#{name}' is not a valid integration.")
-          end
-
-          def reduce_verbosity?
-            defined?(@reduce_verbosity) ? @reduce_verbosity : false
-          end
-
-          def reduce_log_verbosity
-            @reduce_verbosity ||= true
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/faraday/configuration/settings.rb

@@ -1,38 +0,0 @@
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/ext/http'
-require 'ddtrace/contrib/faraday/ext'
-
-module Datadog
-  module Contrib
-    module Faraday
-      module Configuration
-        # Custom settings for the Faraday integration
-        class Settings < Contrib::Configuration::Settings
-          DEFAULT_ERROR_HANDLER = lambda do |env|
-            Datadog::Ext::HTTP::ERROR_RANGE.cover?(env[:status])
-          end
-
-          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, Ext::ENV_ANALYTICS_ENABLED_OLD], false) }
-            o.lazy
-          end
-
-          option :analytics_sample_rate do |o|
-            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
-            o.lazy
-          end
-
-          option :distributed_tracing, default: true
-          option :error_handler, default: DEFAULT_ERROR_HANDLER
-          option :service_name, default: Ext::SERVICE_NAME
-          option :split_by_domain, default: false
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/faraday/connection.rb

@@ -1,18 +0,0 @@
-module Datadog
-  module Contrib
-    module Faraday
-      # Handles installation of our middleware if the user has *not*
-      # already explicitly configured our middleware for this correction.
-      #
-      # Wraps Faraday::Connection#initialize:
-      # https://github.com/lostisland/faraday/blob/ff9dc1d1219a1bbdba95a9a4cf5d135b97247ee2/lib/faraday/connection.rb#L62-L92
-      module Connection
-        def initialize(*args, &block)
-          super.tap do
-            use(:ddtrace) unless builder.handlers.any? { |h| h.klass == Middleware }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/faraday/ext.rb

@@ -1,17 +0,0 @@
-module Datadog
-  module Contrib
-    module Faraday
-      # Faraday integration constants
-      module Ext
-        APP = 'faraday'.freeze
-        ENV_ENABLED = 'DD_TRACE_FARADAY_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_FARADAY_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_FARADAY_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_FARADAY_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_FARADAY_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'faraday'.freeze
-        SPAN_REQUEST = 'faraday.request'.freeze
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/faraday/integration.rb

@@ -1,43 +0,0 @@
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/configuration/resolvers/pattern_resolver'
-require 'ddtrace/contrib/faraday/configuration/settings'
-require 'ddtrace/contrib/faraday/patcher'
-
-module Datadog
-  module Contrib
-    module Faraday
-      # Description of Faraday integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('0.14.0')
-
-        register_as :faraday, auto_patch: true
-
-        def self.version
-          Gem.loaded_specs['faraday'] && Gem.loaded_specs['faraday'].version
-        end
-
-        def self.loaded?
-          !defined?(::Faraday).nil?
-        end
-
-        def self.compatible?
-          super && version >= MINIMUM_VERSION
-        end
-
-        def default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          Patcher
-        end
-
-        def resolver
-          @resolver ||= Contrib::Configuration::Resolvers::PatternResolver.new
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/faraday/middleware.rb

@@ -1,85 +0,0 @@
-require 'faraday'
-require 'ddtrace/ext/http'
-require 'ddtrace/ext/integration'
-require 'ddtrace/ext/net'
-require 'ddtrace/propagation/http_propagator'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/faraday/ext'
-require 'ddtrace/contrib/http_annotation_helper'
-
-module Datadog
-  module Contrib
-    module Faraday
-      # Middleware implements a faraday-middleware for ddtrace instrumentation
-      class Middleware < ::Faraday::Middleware
-        include Datadog::Ext::DistributedTracing
-        include Datadog::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)
-
-          request_options[:tracer].trace(Ext::SPAN_REQUEST) do |span|
-            annotate!(span, env, request_options)
-            propagate!(span, env) if request_options[:distributed_tracing] && request_options[:tracer].enabled
-            app.call(env).on_complete { |resp| handle_response(span, resp, request_options) }
-          end
-        end
-
-        private
-
-        attr_reader :app
-
-        def annotate!(span, env, options)
-          span.resource = resource_name(env)
-          service_name(env[:url].host, options)
-          span.service = options[:split_by_domain] ? env[:url].host : options[:service_name]
-          span.span_type = Datadog::Ext::HTTP::TYPE_OUTBOUND
-
-          # Tag as an external peer service
-          span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
-
-          # 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(Datadog::Ext::HTTP::URL, env[:url].path)
-          span.set_tag(Datadog::Ext::HTTP::METHOD, env[:method].to_s.upcase)
-          span.set_tag(Datadog::Ext::NET::TARGET_HOST, env[:url].host)
-          span.set_tag(Datadog::Ext::NET::TARGET_PORT, env[:url].port)
-        end
-
-        def handle_response(span, env, options)
-          span.set_error(["Error #{env[:status]}", env[:body]]) if options.fetch(:error_handler).call(env)
-
-          span.set_tag(Datadog::Ext::HTTP::STATUS_CODE, env[:status])
-        end
-
-        def propagate!(span, env)
-          Datadog::HTTPPropagator.inject!(span.context, 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[:faraday, host]
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/faraday/patcher.rb

@@ -1,53 +0,0 @@
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/faraday/ext'
-require 'ddtrace/contrib/faraday/connection'
-require 'ddtrace/contrib/faraday/rack_builder'
-
-module Datadog
-  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 'ddtrace/contrib/faraday/middleware'
-
-          register_middleware!
-          add_default_middleware!
-        end
-
-        def register_middleware!
-          ::Faraday::Middleware.register_middleware(ddtrace: 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(:ddtrace)
-
-            # 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

data/lib/ddtrace/contrib/faraday/rack_builder.rb

@@ -1,18 +0,0 @@
-module Datadog
-  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(:ddtrace) unless @handlers.any? { |h| h.klass == Middleware }
-
-          super
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/grape/configuration/settings.rb

@@ -1,38 +0,0 @@
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/ext/http'
-require 'ddtrace/contrib/grape/ext'
-require 'ddtrace/contrib/status_code_matcher'
-
-module Datadog
-  module Contrib
-    module Grape
-      module Configuration
-        # Custom settings for the Grape integration
-        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, Ext::ENV_ANALYTICS_ENABLED_OLD], nil) }
-            o.lazy
-          end
-
-          option :analytics_sample_rate do |o|
-            o.default { env_to_float([Ext::ENV_ANALYTICS_SAMPLE_RATE, Ext::ENV_ANALYTICS_SAMPLE_RATE_OLD], 1.0) }
-            o.lazy
-          end
-
-          option :service_name, default: Ext::SERVICE_NAME
-
-          option :error_statuses, default: nil do |o|
-            o.setter do |new_value, _old_value|
-              Datadog::Contrib::StatusCodeMatcher.new(new_value) unless new_value.nil?
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/grape/endpoint.rb

@@ -1,236 +0,0 @@
-require 'ddtrace/ext/http'
-require 'ddtrace/ext/errors'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/rack/ext'
-
-module Datadog
-  module Contrib
-    module Grape
-      # rubocop:disable Metrics/ModuleLength
-      # Endpoint module includes a list of subscribers to create
-      # traces when a Grape endpoint is hit
-      module Endpoint
-        KEY_RUN = 'datadog_grape_endpoint_run'.freeze
-        KEY_RENDER = 'datadog_grape_endpoint_render'.freeze
-
-        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(*)
-            return if Thread.current[KEY_RUN]
-            return unless enabled?
-
-            # Store the beginning of a trace
-            tracer.trace(
-              Ext::SPAN_ENDPOINT_RUN,
-              service: service_name,
-              span_type: Datadog::Ext::HTTP::TYPE_INBOUND
-            )
-
-            Thread.current[KEY_RUN] = true
-          rescue StandardError => e
-            Datadog.logger.error(e.message)
-          end
-
-          def endpoint_run(name, start, finish, id, payload)
-            return unless Thread.current[KEY_RUN]
-
-            Thread.current[KEY_RUN] = false
-
-            return unless enabled?
-
-            span = tracer.active_span
-            return unless span
-
-            begin
-              # collect endpoint details
-              api = payload[:endpoint].options[:for]
-
-              api_view = api_view(api)
-
-              request_method = payload[:endpoint].options[:method].first
-              path = endpoint_expand_path(payload[:endpoint])
-              resource = "#{api_view} #{request_method} #{path}"
-              span.resource = resource
-
-              # set the request span resource if it's a `rack.request` span
-              request_span = payload[:env][Datadog::Contrib::Rack::Ext::RACK_ENV_REQUEST_SPAN]
-              if !request_span.nil? && request_span.name == Datadog::Contrib::Rack::Ext::SPAN_REQUEST
-                request_span.resource = resource
-              end
-
-              # 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
-
-              span.set_error(payload[:exception_object]) if exception_is_error?(payload[:exception_object])
-
-              # 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(Datadog::Ext::HTTP::METHOD, request_method)
-              span.set_tag(Datadog::Ext::HTTP::URL, path)
-            ensure
-              span.start(start)
-              span.finish(finish)
-            end
-          rescue StandardError => e
-            Datadog.logger.error(e.message)
-          end
-
-          def endpoint_start_render(*)
-            return if Thread.current[KEY_RENDER]
-            return unless enabled?
-
-            # Store the beginning of a trace
-            tracer.trace(
-              Ext::SPAN_ENDPOINT_RENDER,
-              service: service_name,
-              span_type: Datadog::Ext::HTTP::TEMPLATE
-            )
-
-            Thread.current[KEY_RENDER] = true
-          rescue StandardError => e
-            Datadog.logger.error(e.message)
-          end
-
-          def endpoint_render(name, start, finish, id, payload)
-            return unless Thread.current[KEY_RENDER]
-
-            Thread.current[KEY_RENDER] = false
-
-            return unless enabled?
-
-            span = tracer.active_span
-            return unless span
-
-            # catch thrown exceptions
-            begin
-              # Measure service stats
-              Contrib::Analytics.set_measured(span)
-
-              span.set_error(payload[:exception_object]) if exception_is_error?(payload[:exception_object])
-            ensure
-              span.start(start)
-              span.finish(finish)
-            end
-          rescue StandardError => e
-            Datadog.logger.error(e.message)
-          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 = tracer.trace(
-              Ext::SPAN_ENDPOINT_RUN_FILTERS,
-              service: service_name,
-              span_type: Datadog::Ext::HTTP::TYPE_INBOUND,
-              start_time: start
-            )
-
-            begin
-              # 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
-              span.set_error(payload[:exception_object]) if exception_is_error?(payload[:exception_object])
-
-              span.set_tag(Ext::TAG_FILTER_TYPE, type.to_s)
-            ensure
-              span.start(start)
-              span.finish(finish)
-            end
-          rescue StandardError => e
-            Datadog.logger.error(e.message)
-          end
-
-          private
-
-          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 && endpoint.routes.first.namespace || ''
-
-            parts = (namespace.split('/') + route_path).reject { |p| p.blank? || p.eql?('/') }
-            parts.join('/').prepend('/')
-          end
-
-          def tracer
-            datadog_configuration[:tracer]
-          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)
-            matcher = datadog_configuration[:error_statuses]
-            return false unless exception
-            return true unless matcher
-            return true unless exception.respond_to?('status')
-
-            matcher.include?(exception.status)
-          end
-
-          def enabled?
-            datadog_configuration[:enabled] == true
-          end
-
-          def datadog_configuration
-            Datadog.configuration[:grape]
-          end
-        end
-      end
-    end
-  end
-end