datadog 2.4.0 → 2.44.0

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'graphql'
+require "graphql"
 
 module Datadog
   module Tracing
@@ -11,59 +11,108 @@ 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)
+            trace(proc { super }, "lex", query_string, query_string: query_string)
           end
 
           def parse(*args, query_string:, **kwargs)
-            trace(proc { super }, 'parse', query_string, query_string: query_string) do |span|
-              span.set_tag('graphql.source', query_string)
+            trace(proc { super }, "parse", query_string, query_string: query_string) do |span|
+              span.set_tag("graphql.source", query_string)
             end
           end
 
           def validate(*args, query:, validate:, **kwargs)
-            trace(proc { super }, 'validate', query.selected_operation_name, query: query, validate: validate) do |span|
-              span.set_tag('graphql.source', query.query_string)
+            trace(proc { super }, "validate", query.selected_operation_name, query: query, validate: validate) do |span|
+              span.set_tag("graphql.source", query.query_string)
             end
           end
 
           def analyze_multiplex(*args, multiplex:, **kwargs)
-            trace(proc { super }, 'analyze_multiplex', multiplex_resource(multiplex), multiplex: multiplex)
+            trace(proc { super }, "analyze_multiplex", multiplex_resource(multiplex), multiplex: multiplex)
           end
 
           def analyze_query(*args, query:, **kwargs)
-            trace(proc { super }, 'analyze', query.query_string, query: query)
+            trace(proc { super }, "analyze", query.query_string, query: query)
           end
 
           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(', ')}]")
+            trace(proc { super }, "execute_multiplex", multiplex_resource(multiplex), multiplex: multiplex) do |span|
+              span.set_tag("graphql.source", "Multiplex[#{multiplex.queries.map(&:query_string).join(", ")}]")
             end
           end
 
           def execute_query(*args, query:, **kwargs)
-            trace(proc { super }, 'execute', query.selected_operation_name, query: query) do |span|
-              span.set_tag('graphql.source', query.query_string)
-              span.set_tag('graphql.operation.type', query.selected_operation.operation_type)
-              span.set_tag('graphql.operation.name', query.selected_operation_name) if query.selected_operation_name
-              query.variables.instance_variable_get(:@storage).each do |key, value|
-                span.set_tag("graphql.variables.#{key}", value)
-              end
-            end
+            trace(
+              proc { super },
+              "execute",
+              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)
+                if query.selected_operation_name
+                  span.set_tag(
+                    "graphql.operation.name",
+                    query.selected_operation_name
+                  )
+                end
+                query.variables.instance_variable_get(:@storage).each do |key, value|
+                  span.set_tag("graphql.variables.#{key}", value)
+                end
+              },
+              ->(span) { add_query_error_events(span, query.context.errors) },
+              query: query,
+            )
           end
 
           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
-            trace(proc { super }, 'execute_lazy', resource, query: query, multiplex: multiplex)
+              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
 
           def execute_field_span(callable, span_key, **kwargs)
@@ -82,11 +131,11 @@ module Datadog
           end
 
           def execute_field(*args, **kwargs)
-            execute_field_span(proc { super }, 'resolve', **kwargs)
+            execute_field_span(proc { super }, "resolve", **kwargs)
           end
 
           def execute_field_lazy(*args, **kwargs)
-            execute_field_span(proc { super }, 'resolve_lazy', **kwargs)
+            execute_field_span(proc { super }, "resolve_lazy", **kwargs)
           end
 
           def authorized_span(callable, span_key, **kwargs)
@@ -95,11 +144,11 @@ module Datadog
           end
 
           def authorized(*args, **kwargs)
-            authorized_span(proc { super }, 'authorized', **kwargs)
+            authorized_span(proc { super }, "authorized", **kwargs)
           end
 
           def authorized_lazy(*args, **kwargs)
-            authorized_span(proc { super }, 'authorized_lazy', **kwargs)
+            authorized_span(proc { super }, "authorized_lazy", **kwargs)
           end
 
           def resolve_type_span(callable, span_key, **kwargs)
@@ -108,15 +157,13 @@ module Datadog
           end
 
           def resolve_type(*args, **kwargs)
-            resolve_type_span(proc { super }, 'resolve_type', **kwargs)
+            resolve_type_span(proc { super }, "resolve_type", **kwargs)
           end
 
           def resolve_type_lazy(*args, **kwargs)
-            resolve_type_span(proc { super }, 'resolve_type_lazy', **kwargs)
+            resolve_type_span(proc { super }, "resolve_type_lazy", **kwargs)
           end
 
-          include ::GraphQL::Tracing::PlatformTrace
-
           def platform_field_key(field, *args, **kwargs)
             field.path
           end
@@ -129,33 +176,70 @@ module Datadog
             "#{type.graphql_name}.resolve_type"
           end
 
-          private
+          # 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
 
-          def trace(callable, trace_key, resource, **kwargs)
-            config = Datadog.configuration.tracing[:graphql]
+          private
 
+          # Traces the given callable with the given trace key, resource, and kwargs.
+          #
+          # @param callable [Proc] the original method call
+          # @param trace_key [String] the sub-operation name (`"graphql.#{trace_key}"`)
+          # @param resource [String] the resource name for the trace
+          # @param before [Proc, nil] a callable to run before the trace, same as the block parameter
+          # @param after [Proc, nil] a callable to run after the trace, which has access to query values after execution
+          # @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)
             Tracing.trace(
               "graphql.#{trace_key}",
-              type: 'graphql',
+              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
 
-              yield(span) if block_given?
+              # A sanity check for us.
+              raise "Please provide either `before` or a block, but not both" if before && before_block
+
+              if (before_callable = before || before_block)
+                before_callable.call(span)
+              end
 
               prepare_span(trace_key, kwargs, span) if @has_prepare_span
 
-              callable.call
+              ret = callable.call
+
+              after&.call(span)
+
+              ret
             end
           end
 
           def multiplex_resource(multiplex)
             return nil unless multiplex
 
-            operations = multiplex.queries.map(&:selected_operation_name).compact.join(', ')
+            operations = multiplex.queries.map(&:selected_operation_name).compact.join(", ")
             if operations.empty?
               first_query = multiplex.queries.first
               fallback_transaction_name(first_query && first_query.context)
@@ -163,6 +247,55 @@ module Datadog
               operations
             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.
+          def add_query_error_events(span, errors)
+            errors.each do |error|
+              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
+              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
         end
       end
     end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-if Gem.loaded_specs['graphql'] && Gem.loaded_specs['graphql'].version >= Gem::Version.new('2.0.19')
-  require_relative 'unified_trace'
+if Gem.loaded_specs["graphql"] && Gem.loaded_specs["graphql"].version >= Gem::Version.new("2.0.19")
+  require_relative "unified_trace"
 end
 
 module Datadog

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../../configuration/settings'
-require_relative '../ext'
+require_relative "../../configuration/settings"
+require_relative "../ext"
 
 module Datadog
   module Tracing
@@ -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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative '../../../../tracing'
-require_relative '../../../metadata/ext'
-require_relative '../distributed/propagation'
-require_relative '../../analytics'
-require_relative '../ext'
-require_relative '../../ext'
-require_relative '../formatting'
+require_relative "../../../../tracing"
+require_relative "../../../metadata/ext"
+require_relative "../distributed/propagation"
+require_relative "../../analytics"
+require_relative "../ext"
+require_relative "../../ext"
+require_relative "../formatting"
 
 module Datadog
   module Tracing
@@ -25,15 +25,16 @@ module Datadog
                 type: Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND,
                 service: service_name, # Maintain client-side service name configuration
                 resource: formatter.resource_name,
-                on_error: on_error
+                on_error: on_error,
               }
 
               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)
@@ -81,10 +77,16 @@ module Datadog
               # Set analytics sample rate
               Contrib::Analytics.set_sample_rate(span, analytics_sample_rate) if analytics_enabled?
 
-              GRPC.inject(trace, metadata) if distributed_tracing?
+              if Tracing::Distributed::PropagationPolicy.enabled?(
+                pin_config: Datadog.configuration_for(self),
+                global_config: datadog_configuration,
+                trace: trace
+              )
+                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)
@@ -97,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

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
-require_relative '../../../../tracing'
-require_relative '../../../metadata/ext'
-require_relative '../distributed/propagation'
-require_relative '../../analytics'
-require_relative '../ext'
-require_relative '../../ext'
-require_relative '../formatting'
+require_relative "../../../../tracing"
+require_relative "../../../metadata/ext"
+require_relative "../distributed/propagation"
+require_relative "../../analytics"
+require_relative "../ext"
+require_relative "../../ext"
+require_relative "../formatting"
 
 module Datadog
   module Tracing
@@ -26,18 +26,19 @@ module Datadog
                 type: Tracing::Metadata::Ext::HTTP::TYPE_INBOUND,
                 service: service_name, # TODO: Remove server-side service name configuration
                 resource: formatter.resource_name,
-                on_error: on_error
+                on_error: on_error,
               }
               metadata = keywords[:call].metadata
 
               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/datadog_interceptor.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../analytics'
-require_relative 'ext'
-require_relative 'configuration/settings'
+require_relative "../analytics"
+require_relative "ext"
+require_relative "configuration/settings"
 
 module Datadog
   module Tracing
@@ -89,7 +89,7 @@ module Datadog
               end
 
               OPTIONS.each do |option|
-                if option.to_s[-1] == '='
+                if option.to_s[-1] == "="
                   add_setter!(option)
                 else
                   add_getter!(option)
@@ -98,8 +98,8 @@ module Datadog
             end
           end
 
-          require_relative 'datadog_interceptor/client'
-          require_relative 'datadog_interceptor/server'
+          require_relative "datadog_interceptor/client"
+          require_relative "datadog_interceptor/server"
         end
       end
     end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../../distributed/fetcher'
+require_relative "../../../distributed/fetcher"
 
 module Datadog
   module Tracing
@@ -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

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
-require_relative 'fetcher'
-require_relative '../../../distributed/b3_multi'
-require_relative '../../../distributed/b3_single'
-require_relative '../../../distributed/datadog'
-require_relative '../../../distributed/none'
-require_relative '../../../distributed/propagation'
-require_relative '../../../distributed/trace_context'
+require_relative "fetcher"
+require_relative "../../../distributed/b3_multi"
+require_relative "../../../distributed/b3_single"
+require_relative "../../../distributed/propagation_policy"
+require_relative "../../../distributed/datadog"
+require_relative "../../../distributed/none"
+require_relative "../../../distributed/propagation"
+require_relative "../../../distributed/trace_context"
 
 module Datadog
   module Tracing
@@ -19,6 +20,7 @@ module Datadog
             def initialize(
               propagation_style_inject:,
               propagation_style_extract:,
+              propagation_behavior_extract:,
               propagation_extract_first:
             )
               super(
@@ -31,10 +33,13 @@ module Datadog
                     Tracing::Distributed::Datadog.new(fetcher: Fetcher),
                   Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT =>
                     Tracing::Distributed::TraceContext.new(fetcher: Fetcher),
-                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_BAGGAGE =>
+                    Tracing::Distributed::Baggage.new(fetcher: Fetcher),
+                  Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_NONE => Tracing::Distributed::None.new,
                 },
                 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

@@ -7,20 +7,21 @@ module Datadog
         # gRPC integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_GRPC_ENABLED'
-          ENV_SERVICE_NAME = 'DD_TRACE_GRPC_SERVICE_NAME'
-          ENV_PEER_SERVICE = 'DD_TRACE_GRPC_PEER_SERVICE'
+          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
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_GRPC_ANALYTICS_ENABLED'
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_GRPC_ANALYTICS_SAMPLE_RATE'
-          DEFAULT_PEER_SERVICE_NAME = 'grpc'
-          SPAN_CLIENT = 'grpc.client'
-          SPAN_SERVICE = 'grpc.service'
-          TAG_CLIENT_DEADLINE = 'grpc.client.deadline'
-          TAG_COMPONENT = 'grpc'
-          TAG_OPERATION_CLIENT = 'client'
-          TAG_OPERATION_SERVICE = 'service'
-          TAG_SYSTEM = 'grpc'
+          ENV_ANALYTICS_ENABLED = "DD_TRACE_GRPC_ANALYTICS_ENABLED"
+          ENV_ANALYTICS_SAMPLE_RATE = "DD_TRACE_GRPC_ANALYTICS_SAMPLE_RATE"
+          DEFAULT_PEER_SERVICE_NAME = "grpc"
+          SPAN_CLIENT = "grpc.client"
+          SPAN_SERVICE = "grpc.service"
+          TAG_CLIENT_DEADLINE = "grpc.client.deadline"
+          TAG_COMPONENT = "grpc"
+          TAG_OPERATION_CLIENT = "client"
+          TAG_OPERATION_SERVICE = "service"
+          TAG_SYSTEM = "grpc"
           PEER_SERVICE_SOURCES = Contrib::Ext::RPC::PEER_SERVICE_SOURCES.freeze
         end
       end