datadog 2.17.0 → 2.37.0

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

@@ -62,6 +62,7 @@ module Datadog
 
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ENDPOINT_RUN)
+              span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
 
               if (grape_route = env['grape.routing_args']) && grape_route[:route_info]
                 trace.set_tag(
@@ -76,8 +77,8 @@ module Datadog
               end
 
               Thread.current[KEY_RUN] = true
-            rescue StandardError => e
-              Datadog.logger.error(e.message)
+            rescue => e
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
@@ -120,8 +121,8 @@ module Datadog
                 span.start(start)
                 span.finish(finish)
               end
-            rescue StandardError => e
-              Datadog.logger.error(e.message)
+            rescue => e
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
@@ -162,10 +163,11 @@ module Datadog
 
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ENDPOINT_RENDER)
+              span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
 
               Thread.current[KEY_RENDER] = true
-            rescue StandardError => e
-              Datadog.logger.error(e.message)
+            rescue => e
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
@@ -189,8 +191,8 @@ module Datadog
                 span.start(start)
                 span.finish(finish)
               end
-            rescue StandardError => e
-              Datadog.logger.error(e.message)
+            rescue => e
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
@@ -213,6 +215,7 @@ module Datadog
               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)
+                span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
 
                 # Set analytics sample rate
                 Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
@@ -228,8 +231,8 @@ module Datadog
                 span.start(start)
                 span.finish(finish)
               end
-            rescue StandardError => e
-              Datadog.logger.error(e.message)
+            rescue => e
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 
@@ -253,10 +256,10 @@ module Datadog
             end
 
             def api_view(api)
-              # If the API inherits from Grape::API in version >= 1.2.0
+              # If the API inherits from Grape::API in version >= 1.2.0 and version <= 2.3.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
+              if defined?(::Grape::API::Instance) && api <= ::Grape::API::Instance && api.respond_to?(:base)
                 api.base.to_s
               else
                 api.to_s
@@ -265,7 +268,7 @@ module Datadog
 
             def endpoint_expand_path(endpoint)
               route_path = endpoint.options[:path]
-              namespace = endpoint.routes.first && endpoint.routes.first.namespace || ''
+              namespace = endpoint.routes.first&.namespace || ''
 
               path = (namespace.split('/') + route_path)
                 .reject { |p| p.blank? || p.eql?('/') }
@@ -297,11 +300,11 @@ module Datadog
               matcher = datadog_configuration[:error_statuses]
               return true unless matcher
 
-              matcher.include?(status) if matcher
+              matcher&.include?(status)
             end
 
             def enabled?
-              Datadog.configuration.tracing.enabled && \
+              Datadog.configuration.tracing.enabled &&
                 datadog_configuration[:enabled] == true
             end
 

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

@@ -6,13 +6,8 @@ module Datadog
       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
+          # GenerateApiMethodPatch - class method instrumentation for endpoint render (Grape < 3.0.0)
+          module GenerateApiMethodPatch
             def generate_api_method(*params, &block)
               method_api = super
 
@@ -23,7 +18,17 @@ module Datadog
             end
           end
 
-          # InstanceMethods - implementing instrumentation
+          # ExecutePatch - instance method instrumentation for endpoint render (Grape >= 3.0.0)
+          module ExecutePatch
+            def execute(*args)
+              return unless @source
+
+              ::ActiveSupport::Notifications.instrument('endpoint_render.grape.start_render')
+              super
+            end
+          end
+
+          # InstanceMethods - instance method instrumentation for endpoint run
           module InstanceMethods
             def run(*args)
               ::ActiveSupport::Notifications.instrument('endpoint_run.grape.start_process', endpoint: self, env: env)

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

@@ -18,7 +18,7 @@ module Datadog
           register_as :grape, auto_patch: true
 
           def self.version
-            Gem.loaded_specs['grape'] && Gem.loaded_specs['grape'].version
+            Gem.loaded_specs['grape']&.version
           end
 
           def self.loaded?

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

@@ -21,7 +21,12 @@ module Datadog
 
           def patch
             # Patch endpoints
-            ::Grape::Endpoint.include(Instrumentation)
+            ::Grape::Endpoint.prepend(Instrumentation::InstanceMethods)
+            if target_version < Gem::Version.new('3.0.0')
+              ::Grape::Endpoint.singleton_class.prepend(Instrumentation::GenerateApiMethodPatch)
+            else
+              ::Grape::Endpoint.prepend(Instrumentation::ExecutePatch)
+            end
 
             # Subscribe to ActiveSupport events
             Endpoint.subscribe

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

@@ -58,6 +58,13 @@ module Datadog
               o.default []
               o.env_parser { |v| ErrorExtensionEnvParser.call(v) }
             end
+
+            # Surface GraphQL errors in Error Tracking.
+            option :error_tracking do |o|
+              o.env Ext::ENV_ERROR_TRACKING
+              o.type :bool
+              o.default false
+            end
           end
         end
       end

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

@@ -13,6 +13,7 @@ module Datadog
           ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_GRAPHQL_ANALYTICS_SAMPLE_RATE'
           ENV_WITH_UNIFIED_TRACER = 'DD_TRACE_GRAPHQL_WITH_UNIFIED_TRACER'
           ENV_ERROR_EXTENSIONS = 'DD_TRACE_GRAPHQL_ERROR_EXTENSIONS'
+          ENV_ERROR_TRACKING = 'DD_TRACE_GRAPHQL_ERROR_TRACKING'
           SERVICE_NAME = 'graphql'
           TAG_COMPONENT = 'graphql'
 

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

@@ -16,7 +16,7 @@ module Datadog
           register_as :graphql, auto_patch: true
 
           def self.version
-            Gem.loaded_specs['graphql'] && Gem.loaded_specs['graphql'].version
+            Gem.loaded_specs['graphql']&.version
           end
 
           def self.loaded?

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

@@ -36,8 +36,8 @@ module Datadog
               end
             else
               Datadog.logger.warn(
-                "GraphQL version (#{target_version}) does not support GraphQL::Tracing::DataDogTrace"\
-                'or Datadog::Tracing::Contrib::GraphQL::UnifiedTrace.'\
+                "GraphQL version (#{target_version}) does not support GraphQL::Tracing::DataDogTrace" \
+                'or Datadog::Tracing::Contrib::GraphQL::UnifiedTrace.' \
                 'Falling back to GraphQL::Tracing::DataDogTracing.'
               )
               TracingPatcher.patch!(schemas)

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

@@ -11,11 +11,45 @@ module Datadog
         # which is required to use features such as API Catalog.
         # DEV-3.0: This tracer should be the default one in the next major version.
         module UnifiedTrace
+          include ::GraphQL::Tracing::PlatformTrace
+
           def initialize(*args, **kwargs)
             @has_prepare_span = respond_to?(:prepare_span)
+
+            # Cache configuration values to avoid repeated lookups
+            config = Datadog.configuration.tracing[:graphql]
+            @service_name = config[:service_name]
+            @analytics_enabled = config[:analytics_enabled]
+            @analytics_sample_rate = config[:analytics_sample_rate]
+            @error_extensions_config = config[:error_extensions]
+
+            load_error_event_attributes(config[:error_tracking])
+
             super
           end
 
+          def load_error_event_attributes(error_tracking)
+            if error_tracking
+              @event_name = Tracing::Metadata::Ext::Errors::EVENT_NAME
+              @message_key = Tracing::Metadata::Ext::Errors::ATTRIBUTE_MESSAGE
+              @type_key = Tracing::Metadata::Ext::Errors::ATTRIBUTE_TYPE
+              @stacktrace_key = Tracing::Metadata::Ext::Errors::ATTRIBUTE_STACKTRACE
+              @locations_key = 'graphql.error.locations'
+              @path_key = 'graphql.error.path'
+              @extensions_key = 'graphql.error.extensions.'
+            else
+              @event_name = Ext::EVENT_QUERY_ERROR
+              @message_key = 'message'
+              @type_key = 'type'
+              @stacktrace_key = 'stacktrace'
+              @locations_key = 'locations'
+              @path_key = 'path'
+              @extensions_key = 'extensions.'
+            end
+          end
+
+          private :load_error_event_attributes
+
           def lex(*args, query_string:, **kwargs)
             trace(proc { super }, 'lex', query_string, query_string: query_string)
           end
@@ -42,7 +76,7 @@ module Datadog
 
           def execute_multiplex(*args, multiplex:, **kwargs)
             trace(proc { super }, 'execute_multiplex', multiplex_resource(multiplex), multiplex: multiplex) do |span|
-              span.set_tag('graphql.source', "Multiplex[#{multiplex.queries.map(&:query_string).join(', ')}]")
+              span.set_tag('graphql.source', "Multiplex[#{multiplex.queries.map(&:query_string).join(", ")}]")
             end
           end
 
@@ -50,10 +84,13 @@ module Datadog
             trace(
               proc { super },
               'execute',
-              query.selected_operation_name,
+              operation_resource(query.selected_operation),
               lambda { |span|
+                # Ensure this span can be aggregated by in the Datadog App, and generates RED metrics.
+                span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
+
                 span.set_tag('graphql.source', query.query_string)
-                span.set_tag('graphql.operation.type', query.selected_operation.operation_type)
+                span.set_tag('graphql.operation.type', query.selected_operation&.operation_type)
                 if query.selected_operation_name
                   span.set_tag(
                     'graphql.operation.name',
@@ -71,10 +108,10 @@ module Datadog
 
           def execute_query_lazy(*args, query:, multiplex:, **kwargs)
             resource = if query
-                         query.selected_operation_name || fallback_transaction_name(query.context)
-                       else
-                         multiplex_resource(multiplex)
-                       end
+              query.selected_operation_name || fallback_transaction_name(query.context)
+            else
+              multiplex_resource(multiplex)
+            end
             trace(proc { super }, 'execute_lazy', resource, query: query, multiplex: multiplex)
           end
 
@@ -127,8 +164,6 @@ module Datadog
             resolve_type_span(proc { super }, 'resolve_type_lazy', **kwargs)
           end
 
-          include ::GraphQL::Tracing::PlatformTrace
-
           def platform_field_key(field, *args, **kwargs)
             field.path
           end
@@ -141,6 +176,26 @@ module Datadog
             "#{type.graphql_name}.resolve_type"
           end
 
+          # Serialize error's `locations` array as an array of Strings, given
+          # Span Events do not support hashes nested inside arrays.
+          #
+          # Here's an example in which `locations`:
+          #   [
+          #    {"line" => 3, "column" => 10},
+          #    {"line" => 7, "column" => 8},
+          #   ]
+          # is serialized as:
+          #   ["3:10", "7:8"]
+          def self.serialize_error_locations(locations)
+            # locations are only provided by the `graphql` library when the error can
+            # be associated to a particular point in the query.
+            return [] if locations.nil?
+
+            locations.map do |location|
+              "#{location["line"]}:#{location["column"]}"
+            end
+          end
+
           private
 
           # Traces the given callable with the given trace key, resource, and kwargs.
@@ -153,16 +208,15 @@ module Datadog
           # @param kwargs [Hash] the arguments to pass to `prepare_span`
           # @yield [Span] the block to run before the trace, same as the `before` parameter
           def trace(callable, trace_key, resource, before = nil, after = nil, **kwargs, &before_block)
-            config = Datadog.configuration.tracing[:graphql]
-
             Tracing.trace(
               "graphql.#{trace_key}",
               type: 'graphql',
               resource: resource,
-              service: config[:service_name]
+              service: @service_name
             ) do |span|
-              if Contrib::Analytics.enabled?(config[:analytics_enabled])
-                Contrib::Analytics.set_sample_rate(span, config[:analytics_sample_rate])
+              span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
+              if Contrib::Analytics.enabled?(@analytics_enabled)
+                Contrib::Analytics.set_sample_rate(span, @analytics_sample_rate)
               end
 
               # A sanity check for us.
@@ -176,7 +230,7 @@ module Datadog
 
               ret = callable.call
 
-              after.call(span) if after
+              after&.call(span)
 
               ret
             end
@@ -194,66 +248,54 @@ module Datadog
             end
           end
 
+          def operation_resource(operation)
+            if operation&.name
+              "#{operation.operation_type} #{operation.name}"
+            else
+              'anonymous'
+            end
+          end
+
           # Create a Span Event for each error that occurs at query level.
-          #
-          # These are represented in the Datadog App as special GraphQL errors,
-          # given their event name `dd.graphql.query.error`.
           def add_query_error_events(span, errors)
-            capture_extensions = Datadog.configuration.tracing[:graphql][:error_extensions]
             errors.each do |error|
-              extensions = if !capture_extensions.empty? && (extensions = error.extensions)
-                             # Capture extensions, ensuring all values are primitives
-                             extensions.each_with_object({}) do |(key, value), hash|
-                               next unless capture_extensions.include?(key.to_s)
-
-                               value = case value
-                                       when TrueClass, FalseClass, Integer, Float
-                                         value
-                                       else
-                                         # Stringify anything that is not a boolean or a number
-                                         value.to_s
-                                       end
-
-                               hash["extensions.#{key}"] = value
-                             end
-                           else
-                             {}
-                           end
+              attributes = if !@error_extensions_config.empty? && (extensions = error.extensions)
+                # Capture extensions, ensuring all values are primitives
+                extensions.each_with_object({}) do |(key, value), hash|
+                  next unless @error_extensions_config.include?(key.to_s)
+
+                  value = case value
+                  when TrueClass, FalseClass, Integer, Float
+                    value
+                  else
+                    value.to_s
+                  end
+
+                  hash[@extensions_key + key.to_s] = value
+                end
+              else
+                {}
+              end
 
               # {::GraphQL::Error#to_h} returns the error formatted in compliance with the GraphQL spec.
               # This is an unwritten contract in the `graphql` library.
               # See for an example: https://github.com/rmosolgo/graphql-ruby/blob/0afa241775e5a113863766cce126214dee093464/lib/graphql/execution_error.rb#L32
               graphql_error = error.to_h
-              error = Core::Error.build_from(error)
-
-              span.span_events << Datadog::Tracing::SpanEvent.new(
-                Ext::EVENT_QUERY_ERROR,
-                attributes: extensions.merge!(
-                  message: graphql_error['message'],
-                  type: error.type,
-                  stacktrace: error.backtrace,
-                  locations: serialize_error_locations(graphql_error['locations']),
-                  path: graphql_error['path'],
+              parsed_error = Core::Error.build_from(error)
+
+              span.span_events << SpanEvent.new(
+                @event_name,
+                attributes: attributes.merge!(
+                  @type_key => parsed_error.type,
+                  @stacktrace_key => parsed_error.backtrace,
+                  @message_key => graphql_error['message'],
+                  @locations_key =>
+                    Datadog::Tracing::Contrib::GraphQL::UnifiedTrace.serialize_error_locations(graphql_error['locations']),
+                  @path_key => graphql_error['path'],
                 )
               )
             end
           end
-
-          # Serialize error's `locations` array as an array of Strings, given
-          # Span Events do not support hashes nested inside arrays.
-          #
-          # Here's an example in which `locations`:
-          #   [
-          #    {"line" => 3, "column" => 10},
-          #    {"line" => 7, "column" => 8},
-          #   ]
-          # is serialized as:
-          #   ["3:10", "7:8"]
-          def serialize_error_locations(locations)
-            locations.map do |location|
-              "#{location['line']}:#{location['column']}"
-            end
-          end
         end
       end
     end

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

@@ -30,8 +30,11 @@ module Datadog
               o.default 1.0
             end
 
-            option :distributed_tracing, default: true, type: :bool
-
+            option :distributed_tracing do |o|
+              o.type :bool
+              o.env Ext::ENV_DISTRIBUTED_TRACING
+              o.default true
+            end
             option :service_name do |o|
               o.type :string, nilable: true
               o.default do

data/lib/datadog/tracing/contrib/grpc/datadog_interceptor/client.rb

@@ -29,11 +29,12 @@ module Datadog
               }
 
               Tracing.trace(Ext::SPAN_CLIENT, **options) do |span, trace|
+                span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
                 annotate!(trace, span, keywords, formatter)
 
                 begin
                   result = yield
-                rescue StandardError => e
+                rescue => e
                   code = e.is_a?(::GRPC::BadStatus) ? e.code : ::GRPC::Core::StatusCodes::UNKNOWN
                   span.set_tag(Contrib::Ext::RPC::GRPC::TAG_STATUS_CODE, code)
 
@@ -59,11 +60,6 @@ module Datadog
                 )
               end
 
-              # Tag original global service name if not used
-              if span.service != Datadog.configuration.service
-                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
-              end
-
               span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_CLIENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_CLIENT)
@@ -89,8 +85,8 @@ module Datadog
                 GRPC.inject(trace, metadata)
               end
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
-            rescue StandardError => e
-              Datadog.logger.debug("GRPC client trace failed: #{e}")
+            rescue => e
+              Datadog.logger.debug("GRPC client trace failed: #{e.class}: #{e.message}")
             end
 
             def find_deadline(call)
@@ -103,16 +99,16 @@ module Datadog
               return unless call
 
               peer_address = if call.respond_to?(:peer)
-                               call.peer
-                             else
-                               # call is a "view" class with restricted method visibility.
-                               # We reach into it to find our data source anyway.
-                               call.instance_variable_get(:@wrapped).peer
-                             end
+                call.peer
+              else
+                # call is a "view" class with restricted method visibility.
+                # We reach into it to find our data source anyway.
+                call.instance_variable_get(:@wrapped).peer
+              end
 
               Core::Utils.extract_host_port(peer_address)
             rescue => e
-              Datadog.logger.debug { "Could not parse host:port from #{call}: #{e}" }
+              Datadog.logger.debug { "Could not parse host:port from #{call}: #{e.class}: #{e.message}" }
               nil
             end
           end

data/lib/datadog/tracing/contrib/grpc/datadog_interceptor/server.rb

@@ -33,11 +33,12 @@ module Datadog
               set_distributed_context!(metadata)
 
               Tracing.trace(Ext::SPAN_SERVICE, **options) do |span|
+                span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
                 annotate!(span, metadata, formatter)
 
                 begin
                   yield
-                rescue StandardError => e
+                rescue => e
                   code = e.is_a?(::GRPC::BadStatus) ? e.code : ::GRPC::Core::StatusCodes::UNKNOWN
                   span.set_tag(Contrib::Ext::RPC::GRPC::TAG_STATUS_CODE, code)
 
@@ -52,9 +53,9 @@ module Datadog
 
             def set_distributed_context!(metadata)
               Tracing.continue_trace!(GRPC.extract(metadata))
-            rescue StandardError => e
+            rescue => e
               Datadog.logger.debug(
-                "unable to propagate GRPC metadata to context: #{e}"
+                "unable to propagate GRPC metadata to context: #{e.class}: #{e.message}"
               )
             end
 
@@ -66,11 +67,6 @@ module Datadog
                 span.set_tag(header, value)
               end
 
-              # Tag original global service name if not used
-              if span.service != Datadog.configuration.service
-                span.set_tag(Tracing::Contrib::Ext::Metadata::TAG_BASE_SERVICE, Datadog.configuration.service)
-              end
-
               span.set_tag(Tracing::Metadata::Ext::TAG_KIND, Tracing::Metadata::Ext::SpanKind::TAG_SERVER)
               span.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_SERVICE)
@@ -85,8 +81,8 @@ module Datadog
 
               # Measure service stats
               Contrib::Analytics.set_measured(span)
-            rescue StandardError => e
-              Datadog.logger.debug("GRPC server trace failed: #{e}")
+            rescue => e
+              Datadog.logger.debug("GRPC server trace failed: #{e.class}: #{e.message}")
             end
           end
         end

data/lib/datadog/tracing/contrib/grpc/distributed/fetcher.rb

@@ -15,7 +15,7 @@ module Datadog
             def [](key)
               # Metadata values are normally integrals but can also be
               # arrays when multiple values are associated with the same key.
-              value = super(key)
+              value = super
               value.is_a?(::Array) ? value[0] : value
             end
           end

data/lib/datadog/tracing/contrib/grpc/distributed/propagation.rb

@@ -20,6 +20,7 @@ module Datadog
             def initialize(
               propagation_style_inject:,
               propagation_style_extract:,
+              propagation_behavior_extract:,
               propagation_extract_first:
             )
               super(
@@ -38,6 +39,7 @@ module Datadog
                 },
                 propagation_style_inject: propagation_style_inject,
                 propagation_style_extract: propagation_style_extract,
+                propagation_behavior_extract: propagation_behavior_extract,
                 propagation_extract_first: propagation_extract_first
               )
             end

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

@@ -8,6 +8,7 @@ module Datadog
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
           ENV_ENABLED = 'DD_TRACE_GRPC_ENABLED'
+          ENV_DISTRIBUTED_TRACING = 'DD_TRACE_GRPC_DISTRIBUTED_TRACING'
           ENV_SERVICE_NAME = 'DD_TRACE_GRPC_SERVICE_NAME'
           ENV_PEER_SERVICE = 'DD_TRACE_GRPC_PEER_SERVICE'
           # @!visibility private

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

@@ -18,7 +18,7 @@ module Datadog
           register_as :grpc, auto_patch: true
 
           def self.version
-            Gem.loaded_specs['grpc'] && Gem.loaded_specs['grpc'].version
+            Gem.loaded_specs['grpc']&.version
           end
 
           def self.loaded?

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

@@ -36,6 +36,7 @@ module Datadog
           @propagation = GRPC::Distributed::Propagation.new(
             propagation_style_inject: tracing.propagation_style_inject,
             propagation_style_extract: tracing.propagation_style_extract,
+            propagation_behavior_extract: tracing.propagation_behavior_extract,
             propagation_extract_first: tracing.propagation_extract_first
           )
         end

data/lib/datadog/tracing/contrib/hanami/action_tracer.rb

@@ -22,6 +22,7 @@ module Datadog
               service: configuration[:service_name],
               type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND
             ) do |span_op, trace_op|
+              span_op.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
               span_op.set_tag(Tracing::Metadata::Ext::TAG_COMPONENT, Ext::TAG_COMPONENT)
               span_op.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_ACTION)