ddtrace 0.34.1 → 1.23.1

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

@@ -0,0 +1,248 @@
+require_relative '../../../core'
+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'.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 = Tracing.trace(
+                Ext::SPAN_ENDPOINT_RUN,
+                service: service_name,
+                span_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)
+
+              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?
+
+              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)
+
+                # 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(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 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
+              span = Tracing.trace(
+                Ext::SPAN_ENDPOINT_RENDER,
+                service: service_name,
+                span_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 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 = Tracing.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 = Tracing.trace(
+                Ext::SPAN_ENDPOINT_RUN_FILTERS,
+                service: service_name,
+                span_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
+                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 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.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,29 @@
+# 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'
+          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

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

@@ -0,0 +1,35 @@
+module Datadog
+  module Tracing
+    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
+end

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

@@ -0,0 +1,42 @@
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module Grape
+        # Description of Grape integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('1.0')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          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 new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative 'endpoint'
+require_relative 'ext'
+require_relative 'instrumentation'
+require_relative '../patcher'
+
+module Datadog
+  module Tracing
+    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
+            Endpoint.subscribe
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module GraphQL
+        module Configuration
+          # Custom settings for the GraphQL 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 :schemas
+            option :service_name
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Contrib
+      module GraphQL
+        # GraphQL integration constants
+        # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
+        module Ext
+          ENV_ENABLED = 'DD_TRACE_GRAPHQL_ENABLED'
+          # @!visibility private
+          ENV_ANALYTICS_ENABLED = 'DD_TRACE_GRAPHQL_ANALYTICS_ENABLED'
+          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_GRAPHQL_ANALYTICS_SAMPLE_RATE'
+          SERVICE_NAME = 'graphql'
+          TAG_COMPONENT = 'graphql'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+require_relative '../integration'
+require_relative 'configuration/settings'
+require_relative 'patcher'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module GraphQL
+        # Description of GraphQL integration
+        class Integration
+          include Contrib::Integration
+
+          MINIMUM_VERSION = Gem::Version.new('1.7.9')
+
+          # @public_api Changing the integration name or integration options can cause breaking changes
+          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 new_configuration
+            Configuration::Settings.new
+          end
+
+          def patcher
+            Patcher
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require_relative '../analytics'
+require_relative '../patcher'
+
+module Datadog
+  module Tracing
+    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
+            if (schemas = get_option(:schemas))
+              schemas.each { |s| patch_schema!(s) }
+            end
+
+            patch_legacy_gem!
+          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 holds a reference to a 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 holds a reference to a 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
+
+          # Before https://github.com/rmosolgo/graphql-ruby/pull/4038 was introduced,
+          # we were left with incompatibilities between ddtrace 1.0 and older graphql gem versions.
+          def patch_legacy_gem!
+            return unless Gem::Version.new(::GraphQL::VERSION) <= Gem::Version.new('2.0.6')
+
+            ::GraphQL::Tracing::DataDogTracing.prepend(PatchLegacyGem)
+          end
+
+          def get_option(option)
+            Datadog.configuration.tracing[:graphql].get_option(option)
+          end
+
+          # Patches the graphql gem to support ddtrace 1.0.
+          # This is not necessary in versions containing https://github.com/rmosolgo/graphql-ruby/pull/4038.
+          module PatchLegacyGem
+            # Ensure invocation to #trace method targets the new namespaced public API object,
+            # instead of the old global Datadog.trace.
+            # This is fixed in graphql > 2.0.3.
+            def tracer
+              options.fetch(:tracer, Datadog::Tracing) # GraphQL will invoke #trace on the returned object
+            end
+
+            # Ensure resource name is not left as `nil`.
+            # This is fixed in graphql > 2.0.6.
+            def fallback_transaction_name(context)
+              context[:tracing_fallback_transaction_name] || 'execute.graphql'
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative '../../../span_operation'
+require_relative '../../configuration/settings'
+require_relative '../ext'
+
+module Datadog
+  module Tracing
+    module Contrib
+      module GRPC
+        module Configuration
+          # Custom settings for the gRPC 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 :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
+
+            option :error_handler do |o|
+              o.type :proc
+              o.default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
+              o.after_set do |value|
+                if value != Tracing::SpanOperation::Events::DEFAULT_ON_ERROR
+                  Datadog.logger.warn(
+                    'The gRPC `error_handler` setting has been deprecated for removal. Please replace ' \
+                    'it with `server_error_handler` which is explicit about only handling errors from ' \
+                    'server interceptors. Alternatively, to handle errors from client interceptors use ' \
+                    'the `client_error_handler` setting instead.'
+                  )
+                end
+              end
+            end
+
+            option :server_error_handler do |o|
+              o.type :proc
+              o.default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
+            end
+
+            option :client_error_handler do |o|
+              o.type :proc
+              o.default_proc(&Tracing::SpanOperation::Events::DEFAULT_ON_ERROR)
+            end
+          end
+        end
+      end
+    end
+  end
+end