ddtrace 0.13.0 → 0.47.0

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

@@ -1,73 +1,29 @@
+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
-      SERVICE = 'grape'.freeze
-
-      # Patcher that introduces more instrumentation for Grape endpoints, so that
-      # new signals are executed at the beginning of each step (filters, render and run)
+      # Patcher enables patching of 'grape' module.
       module Patcher
-        include Base
-        register_as :grape, auto_patch: true
-        option :service_name, default: SERVICE
-
-        @patched = false
+        include Contrib::Patcher
 
         module_function
 
-        def patched?
-          @patched
+        def target_version
+          Integration.version
         end
 
         def patch
-          if !@patched && defined?(::Grape)
-            begin
-              # do not require these by default, but only when actually patching
-              require 'ddtrace'
-              require 'ddtrace/ext/app_types'
-              require 'ddtrace/contrib/grape/endpoint'
-
-              @patched = true
-              # patch all endpoints
-              patch_endpoint_run()
-              patch_endpoint_render()
-
-              # attach a PIN object globally and set the service once
-              service = get_option(:service_name)
-              pin = Datadog::Pin.new(service, app: 'grape', app_type: Datadog::Ext::AppTypes::WEB)
-              pin.onto(::Grape)
-
-              # subscribe to ActiveSupport events
-              Datadog::Contrib::Grape::Endpoint.subscribe()
-            rescue StandardError => e
-              Datadog::Tracer.log.error("Unable to apply Grape integration: #{e}")
-            end
-          end
-          @patched
-        end
-
-        def patch_endpoint_run
-          ::Grape::Endpoint.class_eval do
-            alias_method :run_without_datadog, :run
-            def run(*args)
-              ::ActiveSupport::Notifications.instrument('endpoint_run.grape.start_process')
-              run_without_datadog(*args)
-            end
-          end
-        end
+          # Patch endpoints
+          ::Grape::Endpoint.send(:include, Instrumentation)
 
-        def patch_endpoint_render
-          ::Grape::Endpoint.class_eval do
-            class << self
-              alias_method :generate_api_method_without_datadog, :generate_api_method
-              def generate_api_method(*params, &block)
-                method_api = generate_api_method_without_datadog(*params, &block)
-                proc do |*args|
-                  ::ActiveSupport::Notifications.instrument('endpoint_render.grape.start_render')
-                  method_api.call(*args)
-                end
-              end
-            end
-          end
+          # Subscribe to ActiveSupport events
+          Datadog::Contrib::Grape::Endpoint.subscribe
         end
       end
     end

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

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

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

@@ -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

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

@@ -1,55 +1,58 @@
-require 'ddtrace/ext/app_types'
-require 'ddtrace/ext/http'
+require 'ddtrace/contrib/patcher'
 
 module Datadog
   module Contrib
     module GraphQL
       # Provides instrumentation for `graphql` through the GraphQL tracing framework
       module Patcher
-        include Base
-        register_as :graphql
+        include Contrib::Patcher
 
-        option :tracer, default: Datadog.tracer
-        option :service_name, default: 'ruby-graphql', depends_on: [:tracer] do |value|
-          get_option(:tracer).set_service_info(value, 'ruby-graphql', Ext::AppTypes::WEB)
-          value
-        end
-        option :schemas
+        module_function
 
-        class << self
-          def patch
-            return patched? if patched? || !compatible? || get_option(:schemas).nil?
+        def target_version
+          Integration.version
+        end
 
-            get_option(:schemas).each { |s| patch_schema!(s) }
+        def patch
+          return if get_option(:schemas).nil?
 
-            @patched = true
-          end
-
-          def patch_schema!(schema)
-            tracer = get_option(:tracer)
-            service_name = get_option(:service_name)
+          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,
-                tracer: tracer,
-                service: service_name
+                # 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 patched?
-            return @patched if defined?(@patched)
-            @patched = false
-          end
-
-          private
-
-          def compatible?
-            defined?(::GraphQL) \
-              && defined?(::GraphQL::Tracing::DataDogTracing) \
-              && Gem.loaded_specs['graphql'].version >= Gem::Version.new('1.7.9')
-          end
+        def get_option(option)
+          Datadog.configuration[:graphql].get_option(option)
         end
       end
     end

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

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

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

@@ -1,3 +1,7 @@
+require 'ddtrace/ext/app_types'
+require 'ddtrace/contrib/analytics'
+require 'ddtrace/contrib/grpc/ext'
+
 module Datadog
   module Contrib
     module GRPC
@@ -8,52 +12,57 @@ module Datadog
           attr_accessor :datadog_pin
 
           def initialize(options = {})
-            datadog_pin_configuration { |c| yield(c) if block_given? }
+            add_datadog_pin! { |c| yield(c) if block_given? }
           end
 
-          def request_response(**keywords)
-            trace(keywords) { yield }
+          def request_response(**keywords, &block)
+            trace(keywords, &block)
           end
 
-          def client_streamer(**keywords)
-            trace(keywords) { yield }
+          def client_streamer(**keywords, &block)
+            trace(keywords, &block)
           end
 
-          def server_streamer(**keywords)
-            trace(keywords) { yield }
+          def server_streamer(**keywords, &block)
+            trace(keywords, &block)
           end
 
-          def bidi_streamer(**keywords)
-            trace(keywords) { yield }
+          def bidi_streamer(**keywords, &block)
+            trace(keywords, &block)
           end
 
           private
 
-          def datadog_pin_configuration
-            pin = default_datadog_pin
-
-            if block_given?
-              pin = Pin.new(
-                pin.service_name,
-                app: pin.app,
-                app_type: pin.app_type,
-                tracer: pin.tracer
-              )
-
-              yield(pin)
+          def add_datadog_pin!
+            Pin.new(
+              service_name,
+              app: Ext::APP,
+              app_type: Datadog::Ext::AppTypes::WEB,
+              tracer: -> { datadog_configuration[:tracer] }
+            ).tap do |pin|
+              yield(pin) if block_given?
+              pin.onto(self)
             end
+          end
 
-            pin.onto(self)
+          def datadog_configuration
+            Datadog.configuration[:grpc]
+          end
 
-            pin
+          def tracer
+            (datadog_pin && datadog_pin.tracer) || datadog_configuration[:tracer]
           end
 
-          def default_datadog_pin
-            Pin.get_from(::GRPC)
+          def service_name
+            (datadog_pin && datadog_pin.service_name) || datadog_configuration[:service_name]
           end
 
-          def tracer
-            datadog_pin.tracer
+          def analytics_enabled?
+            Contrib::Analytics.enabled?(datadog_configuration[:analytics_enabled])
+          end
+
+          def analytics_sample_rate
+            datadog_configuration[:analytics_sample_rate]
           end
         end
 

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

@@ -1,9 +1,14 @@
+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 endpoitns. This middleware compoent will
+        # 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
@@ -11,12 +16,12 @@ module Datadog
             keywords[:metadata] ||= {}
 
             options = {
-              span_type: Datadog::Ext::GRPC::TYPE,
-              service: datadog_pin.service_name,
+              span_type: Datadog::Ext::HTTP::TYPE_OUTBOUND,
+              service: service_name,
               resource: format_resource(keywords[:method])
             }
 
-            tracer.trace('grpc.client', options) do |span|
+            tracer.trace(Ext::SPAN_CLIENT, options) do |span|
               annotate!(span, keywords[:metadata])
 
               yield
@@ -26,14 +31,18 @@ module Datadog
           private
 
           def annotate!(span, metadata)
-            metadata.each do |header, value|
-              span.set_tag(header, value)
-            end
+            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::Tracer.log.debug("GRPC client trace failed: #{e}")
+            Datadog.logger.debug("GRPC client trace failed: #{e}")
           end
 
           def format_resource(proto_method)