ddtrace 0.52.0 → 1.8.0

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

@@ -1,246 +0,0 @@
-# typed: false
-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(_name, _start, _finish, _id, payload)
-            return if Thread.current[KEY_RUN]
-            return unless enabled?
-
-            # 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)
-            resource = "#{api_view} #{request_method} #{path}"
-
-            # Store the beginning of a trace
-            span = tracer.trace(
-              Ext::SPAN_ENDPOINT_RUN,
-              service: service_name,
-              span_type: Datadog::Ext::HTTP::TYPE_INBOUND,
-              resource: resource,
-            )
-
-            try_setting_rack_request_resource(payload, span.resource)
-
-            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
-              endpoint = payload.fetch(:endpoint)
-              api_view = api_view(endpoint.options[:for])
-              request_method = endpoint.options.fetch(:method).first
-              path = endpoint_expand_path(endpoint)
-
-              try_setting_rack_request_resource(payload, 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)
-
-              # 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
-
-          def try_setting_rack_request_resource(payload, resource)
-            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
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    module Grape
-      # Grape integration constants
-      module Ext
-        APP = 'grape'.freeze
-        ENV_ENABLED = 'DD_TRACE_GRAPE_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_GRAPE_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_GRAPE_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_GRAPE_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_GRAPE_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'grape'.freeze
-        SPAN_ENDPOINT_RENDER = 'grape.endpoint_render'.freeze
-        SPAN_ENDPOINT_RUN = 'grape.endpoint_run'.freeze
-        SPAN_ENDPOINT_RUN_FILTERS = 'grape.endpoint_run_filters'.freeze
-        TAG_FILTER_TYPE = 'grape.filter.type'.freeze
-        TAG_ROUTE_ENDPOINT = 'grape.route.endpoint'.freeze
-        TAG_ROUTE_PATH = 'grape.route.path'.freeze
-        TAG_ROUTE_METHOD = 'grape.route.method'.freeze
-      end
-    end
-  end
-end

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

@@ -1,34 +0,0 @@
-# typed: false
-module Datadog
-  module Contrib
-    module Grape
-      # Instrumentation for Grape::Endpoint
-      module Instrumentation
-        def self.included(base)
-          base.singleton_class.prepend(ClassMethods)
-          base.prepend(InstanceMethods)
-        end
-
-        # ClassMethods - implementing instrumentation
-        module ClassMethods
-          def generate_api_method(*params, &block)
-            method_api = super
-
-            proc do |*args|
-              ::ActiveSupport::Notifications.instrument('endpoint_render.grape.start_render')
-              method_api.call(*args)
-            end
-          end
-        end
-
-        # InstanceMethods - implementing instrumentation
-        module InstanceMethods
-          def run(*args)
-            ::ActiveSupport::Notifications.instrument('endpoint_run.grape.start_process', endpoint: self, env: env)
-            super
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/grape/configuration/settings'
-require 'ddtrace/contrib/grape/patcher'
-
-module Datadog
-  module Contrib
-    module Grape
-      # Description of Grape integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('1.0')
-
-        register_as :grape, auto_patch: true
-
-        def self.version
-          Gem.loaded_specs['grape'] && Gem.loaded_specs['grape'].version
-        end
-
-        def self.loaded?
-          !defined?(::Grape).nil? \
-            && !defined?(::ActiveSupport::Notifications).nil?
-        end
-
-        def self.compatible?
-          super && version >= MINIMUM_VERSION
-        end
-
-        def default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          Patcher
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# typed: true
-require 'ddtrace/contrib/patcher'
-require 'ddtrace/ext/app_types'
-
-require 'ddtrace/contrib/grape/ext'
-require 'ddtrace/contrib/grape/endpoint'
-require 'ddtrace/contrib/grape/instrumentation'
-
-module Datadog
-  module Contrib
-    module Grape
-      # Patcher enables patching of 'grape' module.
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          # Patch endpoints
-          ::Grape::Endpoint.include(Instrumentation)
-
-          # Subscribe to ActiveSupport events
-          Datadog::Contrib::Grape::Endpoint.subscribe
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/ext/app_types'
-require 'ddtrace/contrib/graphql/ext'
-
-module Datadog
-  module Contrib
-    module GraphQL
-      module Configuration
-        # Custom settings for the GraphQL 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 :schemas
-          option :service_name, default: Ext::SERVICE_NAME
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-# typed: true
-module Datadog
-  module Contrib
-    module GraphQL
-      # GraphQL integration constants
-      module Ext
-        APP = 'ruby-graphql'.freeze
-        ENV_ENABLED = 'DD_TRACE_GRAPHQL_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_TRACE_GRAPHQL_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_ENABLED_OLD = 'DD_GRAPHQL_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_GRAPHQL_ANALYTICS_SAMPLE_RATE'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE_OLD = 'DD_GRAPHQL_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'ruby-graphql'.freeze
-      end
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/integration'
-require 'ddtrace/contrib/graphql/configuration/settings'
-require 'ddtrace/contrib/graphql/patcher'
-
-module Datadog
-  module Contrib
-    module GraphQL
-      # Description of GraphQL integration
-      class Integration
-        include Contrib::Integration
-
-        MINIMUM_VERSION = Gem::Version.new('1.7.9')
-
-        register_as :graphql, auto_patch: true
-
-        def self.version
-          Gem.loaded_specs['graphql'] && Gem.loaded_specs['graphql'].version
-        end
-
-        def self.loaded?
-          !defined?(::GraphQL).nil? \
-            && !defined?(::GraphQL::Tracing::DataDogTracing).nil?
-        end
-
-        def self.compatible?
-          super && version >= MINIMUM_VERSION
-        end
-
-        def default_configuration
-          Configuration::Settings.new
-        end
-
-        def patcher
-          Patcher
-        end
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/patcher'
-
-module Datadog
-  module Contrib
-    module GraphQL
-      # Provides instrumentation for `graphql` through the GraphQL tracing framework
-      module Patcher
-        include Contrib::Patcher
-
-        module_function
-
-        def target_version
-          Integration.version
-        end
-
-        def patch
-          return if get_option(:schemas).nil?
-
-          require 'ddtrace/ext/app_types'
-          require 'ddtrace/ext/http'
-          get_option(:schemas).each { |s| patch_schema!(s) }
-        end
-
-        def patch_schema!(schema)
-          service_name = get_option(:service_name)
-          analytics_enabled = Contrib::Analytics.enabled?(get_option(:analytics_enabled))
-          analytics_sample_rate = get_option(:analytics_sample_rate)
-
-          if schema.respond_to?(:use)
-            schema.use(
-              ::GraphQL::Tracing::DataDogTracing,
-              # By default, Tracing::DataDogTracing indirectly delegates the tracer instance
-              # to +Datadog.tracer+. If we provide a tracer argument here it will be eagerly cached,
-              # and Tracing::DataDogTracing will send traces to a stale tracer instance.
-              service: service_name,
-              analytics_enabled: analytics_enabled,
-              analytics_sample_rate: analytics_sample_rate
-            )
-          else
-            schema.define do
-              use(
-                ::GraphQL::Tracing::DataDogTracing,
-                # By default, Tracing::DataDogTracing indirectly delegates the tracer instance
-                # to +Datadog.tracer+. If we provide a tracer argument here it will be eagerly cached,
-                # and Tracing::DataDogTracing will send traces to a stale tracer instance.
-                service: service_name,
-                analytics_enabled: analytics_enabled,
-                analytics_sample_rate: analytics_sample_rate
-              )
-            end
-          end
-        end
-
-        def get_option(option)
-          Datadog.configuration[:graphql].get_option(option)
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-# typed: false
-require 'ddtrace/contrib/configuration/settings'
-require 'ddtrace/contrib/grpc/ext'
-
-module Datadog
-  module Contrib
-    module GRPC
-      module Configuration
-        # Custom settings for the gRPC 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], 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 :service_name, default: Ext::SERVICE_NAME
-          option :error_handler, default: Datadog::Tracer::DEFAULT_ON_ERROR
-        end
-      end
-    end
-  end
-end

data/lib/ddtrace/contrib/grpc/datadog_interceptor/client.rb

@@ -1,59 +0,0 @@
-# typed: ignore
-require 'ddtrace/ext/http'
-require 'ddtrace/ext/integration'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/grpc/ext'
-
-module Datadog
-  module Contrib
-    module GRPC
-      module DatadogInterceptor
-        # The DatadogInterceptor::Client implements the tracing strategy
-        # for gRPC client-side endpoints. This middleware component will
-        # inject trace context information into gRPC metadata prior to
-        # sending the request to the server.
-        class Client < Base
-          def trace(keywords)
-            keywords[:metadata] ||= {}
-
-            options = {
-              span_type: Datadog::Ext::HTTP::TYPE_OUTBOUND,
-              service: service_name,
-              resource: format_resource(keywords[:method])
-            }
-
-            tracer.trace(Ext::SPAN_CLIENT, options) do |span|
-              annotate!(span, keywords[:metadata])
-
-              yield
-            end
-          end
-
-          private
-
-          def annotate!(span, metadata)
-            span.set_tags(metadata)
-
-            # Tag as an external peer service
-            span.set_tag(Datadog::Ext::Integration::TAG_PEER_SERVICE, span.service)
-
-            # Set analytics sample rate
-            Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
-
-            Datadog::GRPCPropagator
-              .inject!(span.context, metadata)
-          rescue StandardError => e
-            Datadog.logger.debug("GRPC client trace failed: #{e}")
-          end
-
-          def format_resource(proto_method)
-            proto_method.downcase
-                        .split('/')
-                        .reject(&:empty?)
-                        .join('.')
-          end
-        end
-      end
-    end
-  end
-end