ddtrace 0.38.0

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

@@ -0,0 +1,208 @@
+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]
+              # 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.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]) unless payload[:exception_object].nil?
+            ensure
+              span.start_time = 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
+            )
+
+            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.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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,73 @@
+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.warn("#{method_name}:#{DEPRECATION_WARNING}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,39 @@
+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