ddtrace 0.34.1 → 1.23.1

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

@@ -1,208 +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.log.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]
-              # 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
-              api_view = if defined?(::Grape::API::Instance) && api <= ::Grape::API::Instance
-                           api.base.to_s
-                         else
-                           api.to_s
-                         end
-
-              path = payload[:endpoint].options[:path].join('/')
-              resource = "#{api_view}##{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
-              if analytics_enabled?
-                Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
-              end
-
-              # Measure service stats
-              Contrib::Analytics.set_measured(span)
-
-              # catch thrown exceptions
-              span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
-
-              # 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)
-            ensure
-              span.start_time = start
-              span.finish(finish)
-            end
-          rescue StandardError => e
-            Datadog::Logger.log.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.log.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]) unless payload[:exception_object].nil?
-            ensure
-              span.start_time = start
-              span.finish(finish)
-            end
-          rescue StandardError => e
-            Datadog::Logger.log.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
-            )
-
-            begin
-              # Set analytics sample rate
-              if analytics_enabled?
-                Contrib::Analytics.set_sample_rate(span, analytics_sample_rate)
-              end
-
-              # Measure service stats
-              Contrib::Analytics.set_measured(span)
-
-              # catch thrown exceptions
-              span.set_error(payload[:exception_object]) unless payload[:exception_object].nil?
-              span.set_tag(Ext::TAG_FILTER_TYPE, type.to_s)
-            ensure
-              span.start_time = start
-              span.finish(finish)
-            end
-          rescue StandardError => e
-            Datadog::Logger.log.error(e.message)
-          end
-
-          private
-
-          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 enabled?
-            datadog_configuration[:enabled] == true
-          end
-
-          def datadog_configuration
-            Datadog.configuration[:grape]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-module Datadog
-  module Contrib
-    module Grape
-      # Grape integration constants
-      module Ext
-        APP = 'grape'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_GRAPE_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = '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
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-module Datadog
-  module Contrib
-    module Grape
-      # Instrumentation for Grape::Endpoint
-      module Instrumentation
-        def self.included(base)
-          base.singleton_class.send(:prepend, ClassMethods)
-          base.send(: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')
-            super
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-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,73 +0,0 @@
-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.send(:include, Instrumentation)
-
-          add_pin!
-
-          # Subscribe to ActiveSupport events
-          Datadog::Contrib::Grape::Endpoint.subscribe
-        end
-
-        def add_pin!
-          # Attach a Pin object globally and set the service once
-          pin = DeprecatedPin.new(
-            get_option(:service_name),
-            app: Ext::APP,
-            app_type: Datadog::Ext::AppTypes::WEB,
-            tracer: get_option(:tracer)
-          )
-          pin.onto(::Grape)
-        end
-
-        def get_option(option)
-          Datadog.configuration[:grape].get_option(option)
-        end
-
-        # Implementation of deprecated Pin, which raises warnings when accessed.
-        # To be removed when support for Datadog::Pin with Grape is removed.
-        class DeprecatedPin < Datadog::Pin
-          include Datadog::DeprecatedPin
-
-          DEPRECATION_WARNING = %(
-            Use of Datadog::Pin with Grape is DEPRECATED.
-            Upgrade to the configuration API using the migration guide here:
-            https://github.com/DataDog/dd-trace-rb/releases/tag/v0.11.0).freeze
-
-          def tracer=(tracer)
-            Datadog.configuration[:grape][:tracer] = tracer
-          end
-
-          def service_name=(service_name)
-            Datadog.configuration[:grape][:service_name] = service_name
-          end
-
-          def log_deprecation_warning(method_name)
-            do_once(method_name) do
-              Datadog::Logger.log.warn("#{method_name}:#{DEPRECATION_WARNING}")
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-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 :analytics_enabled do |o|
-            o.default { env_to_bool(Ext::ENV_ANALYTICS_ENABLED, nil) }
-            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 :schemas
-          option :service_name, default: Ext::SERVICE_NAME
-        end
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-module Datadog
-  module Contrib
-    module GraphQL
-      # GraphQL integration constants
-      module Ext
-        APP = 'ruby-graphql'.freeze
-        ENV_ANALYTICS_ENABLED = 'DD_GRAPHQL_ANALYTICS_ENABLED'.freeze
-        ENV_ANALYTICS_SAMPLE_RATE = 'DD_GRAPHQL_ANALYTICS_SAMPLE_RATE'.freeze
-        SERVICE_NAME = 'ruby-graphql'.freeze
-      end
-    end
-  end
-end

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

@@ -1,39 +0,0 @@
-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,57 +0,0 @@
-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)
-          tracer = get_option(:tracer)
-          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,
-              tracer: tracer,
-              service: service_name,
-              analytics_enabled: analytics_enabled,
-              analytics_sample_rate: analytics_sample_rate
-            )
-          else
-            schema.define do
-              use(
-                ::GraphQL::Tracing::DataDogTracing,
-                tracer: tracer,
-                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,25 +0,0 @@
-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 :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, default: Ext::SERVICE_NAME
-        end
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-require 'ddtrace/ext/http'
-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 endpoitns. This middleware compoent 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)
-            metadata.each do |header, value|
-              span.set_tag(header, value)
-            end
-
-            # 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.log.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

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

@@ -1,76 +0,0 @@
-require 'ddtrace/ext/http'
-require 'ddtrace/contrib/analytics'
-require 'ddtrace/contrib/grpc/ext'
-
-module Datadog
-  module Contrib
-    module GRPC
-      module DatadogInterceptor
-        # The DatadogInterceptor::Server implements the tracing strategy
-        # for gRPC server-side endpoints. When the datadog fields have been
-        # added to the gRPC call metadata, this middleware component will
-        # extract any client-side tracing information, attempting to associate
-        # its tracing context with a parent client-side context
-        class Server < Base
-          def trace(keywords)
-            options = {
-              span_type: Datadog::Ext::HTTP::TYPE_INBOUND,
-              service: service_name,
-              resource: format_resource(keywords[:method])
-            }
-            metadata = keywords[:call].metadata
-
-            set_distributed_context!(tracer, metadata)
-
-            tracer.trace(Ext::SPAN_SERVICE, options) do |span|
-              annotate!(span, metadata)
-
-              yield
-            end
-          end
-
-          private
-
-          def set_distributed_context!(tracer, metadata)
-            tracer.provider.context = Datadog::GRPCPropagator
-                                      .extract(metadata)
-          rescue StandardError => e
-            Datadog::Logger.log.debug(
-              "unable to propagate GRPC metadata to context: #{e}"
-            )
-          end
-
-          def annotate!(span, metadata)
-            metadata.each do |header, value|
-              next if reserved_headers.include?(header)
-              span.set_tag(header, value)
-            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)
-          rescue StandardError => e
-            Datadog::Logger.log.debug("GRPC client trace failed: #{e}")
-          end
-
-          def reserved_headers
-            [Datadog::Ext::DistributedTracing::GRPC_METADATA_TRACE_ID,
-             Datadog::Ext::DistributedTracing::GRPC_METADATA_PARENT_ID,
-             Datadog::Ext::DistributedTracing::GRPC_METADATA_SAMPLING_PRIORITY]
-          end
-
-          def format_resource(proto_method)
-            proto_method.owner
-                        .to_s
-                        .downcase
-                        .split('::')
-                        .<<(proto_method.name)
-                        .join('.')
-          end
-        end
-      end
-    end
-  end
-end