datadog 2.8.0 → 2.39.0

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'set'
+require "set"
 
-require_relative '../../core/configuration/settings'
+require_relative "../../core/configuration/settings"
 
 # Datadog
 module Datadog
@@ -63,17 +63,17 @@ module Datadog
           # TODO: We should promote most of this logic to core parts of datadog.
           def configure(&block)
             # Reconfigure core settings
-            super(&block)
+            super
 
             # Activate integrations
             configuration = self.configuration.tracing
 
             if configuration.respond_to?(:integrations_pending_activation)
               ignore_integration_load_errors = if configuration.respond_to?(:ignore_integration_load_errors?)
-                                                 configuration.ignore_integration_load_errors?
-                                               else
-                                                 false
-                                               end
+                configuration.ignore_integration_load_errors?
+              else
+                false
+              end
 
               configuration.integrations_pending_activation.each do |integration|
                 next unless integration.respond_to?(:patch)
@@ -85,9 +85,9 @@ module Datadog
 
                 # if patching failed, only log output if verbosity is unset
                 # or if patching failure is due to compatibility or integration specific reasons
-                next unless !ignore_integration_load_errors ||
-                  ((patch_results[:available] && patch_results[:loaded]) &&
-                  (!patch_results[:compatible] || !patch_results[:patchable]))
+                next if ignore_integration_load_errors &&
+                  (!patch_results[:available] || !patch_results[:loaded] ||
+                  (patch_results[:compatible] && patch_results[:patchable]))
 
                 desc = "Available?: #{patch_results[:available]}"
                 desc += ", Loaded? #{patch_results[:loaded]}"
@@ -110,6 +110,13 @@ module Datadog
           module Settings
             InvalidIntegrationError = Class.new(StandardError)
 
+            # Used to avoid concurrency issues between registering integrations (e.g. mutation) and reporting the
+            # current integrations for logging/debugging/telemetry purposes (e.g. iteration) in the
+            # `@instrumented_integrations` hash.
+            #
+            # See https://github.com/DataDog/dd-trace-rb/issues/2851 for details on the original issue.
+            INSTRUMENTED_INTEGRATIONS_LOCK = Mutex.new
+
             def self.included(base)
               base.class_eval do
                 settings :contrib do
@@ -123,6 +130,20 @@ module Datadog
                     o.default({})
                   end
 
+                  # Enables population of default in the `peer.service` span tag.
+                  # Explicitly setting the `peer.service` for an integration will
+                  # still be honored with this option disabled.
+                  #
+                  # Also when disabled, other peer service related configurations have no effect.
+                  #
+                  # @default `DD_TRACE_PEER_SERVICE_DEFAULTS_ENABLED` environment variable, otherwise `false`
+                  # @return [Boolean]
+                  option :peer_service_defaults do |o|
+                    o.env Tracing::Configuration::Ext::SpanAttributeSchema::ENV_PEER_SERVICE_DEFAULTS_ENABLED
+                    o.type :bool
+                    o.default false
+                  end
+
                   # Global service name behavior
                   settings :global_default_service_name do
                     # Overrides default service name to global service name
@@ -161,7 +182,10 @@ module Datadog
                 configuration_name = options[:describes] || :default
                 filtered_options = options.reject { |k, _v| k == :describes }
                 integration.configure(configuration_name, filtered_options, &block)
-                instrumented_integrations[integration_name] = integration
+                INSTRUMENTED_INTEGRATIONS_LOCK.synchronize do
+                  @instrumented_integrations ||= {}
+                  @instrumented_integrations[integration_name] = integration
+                end
 
                 # Add to activation list
                 integrations_pending_activation << integration
@@ -184,7 +208,7 @@ module Datadog
             # @return [Datadog::Tracing::Contrib::Configuration::Settings]
             def [](integration_name, key = :default)
               integration = fetch_integration(integration_name)
-              integration.resolve(key) unless integration.nil?
+              integration&.resolve(key)
             end
 
             # @!visibility private
@@ -192,14 +216,33 @@ module Datadog
               @integrations_pending_activation ||= Set.new
             end
 
+            # This method is only for logging/debugging/telemetry purposes (e.g. iteration) in the
+            # `@instrumented_integrations` hash.
             # @!visibility private
             def instrumented_integrations
-              @instrumented_integrations ||= {}
+              INSTRUMENTED_INTEGRATIONS_LOCK.synchronize do
+                (if defined?(@instrumented_integrations)
+                   @instrumented_integrations&.dup
+                 end || {}).freeze
+              end
+            end
+
+            # Returns the subset of built-in integrations that are instrumented,
+            # excluding custom integrations registered through the public contrib API.
+            # This method is only for telemetry reporting.
+            # @!visibility private
+            def instrumented_built_in_integrations
+              instrumented = Set.new(instrumented_integrations.each_value)
+              Contrib::BUILT_IN_INTEGRATIONS.select { |integration| instrumented.include?(integration) }.freeze
             end
 
             # @!visibility private
             def reset!
-              instrumented_integrations.clear
+              INSTRUMENTED_INTEGRATIONS_LOCK.synchronize do
+                if defined?(@instrumented_integrations)
+                  @instrumented_integrations&.clear
+                end
+              end
               super
             end
 

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative '../../configuration/settings'
-require_relative '../../status_range_matcher'
-require_relative '../../status_range_env_parser'
-require_relative '../ext'
+require_relative "../../configuration/settings"
+require_relative "../../status_range_matcher"
+require_relative "../../status_range_env_parser"
+require_relative "../ext"
 
 module Datadog
   module Tracing
@@ -13,10 +13,6 @@ module Datadog
           # Custom settings for the Faraday integration
           # @public_api
           class Settings < Contrib::Configuration::Settings
-            DEFAULT_ERROR_HANDLER = lambda do |env|
-              Tracing::Metadata::Ext::HTTP::ERROR_RANGE.cover?(env[:status])
-            end
-
             option :enabled do |o|
               o.type :bool
               o.env Ext::ENV_ENABLED
@@ -36,17 +32,28 @@ 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 :on_error do |o|
               o.type :proc, nilable: true
             end
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 400...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to client (400..499) + server (500..599)
+                  # DEV-3.0: `faraday` is a client library, this should fall back to `http_error_statuses.client` only.
+                  # We cannot change it without causing a breaking change.
+                  client_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.client
+                  server_global_error_statuses = Datadog.configuration.tracing.http_error_statuses.server
+                  client_global_error_statuses + server_global_error_statuses
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v

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

@@ -7,22 +7,24 @@ module Datadog
         # Faraday integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_FARADAY_ENABLED'
-          ENV_SERVICE_NAME = 'DD_TRACE_FARADAY_SERVICE_NAME'
-          ENV_PEER_SERVICE = 'DD_TRACE_FARADAY_PEER_SERVICE'
-          ENV_ERROR_STATUS_CODES = 'DD_TRACE_FARADAY_ERROR_STATUS_CODES'
+          ENV_ENABLED = "DD_TRACE_FARADAY_ENABLED"
+          ENV_DISTRIBUTED_TRACING = "DD_TRACE_FARADAY_DISTRIBUTED_TRACING"
+          ENV_SERVICE_NAME = "DD_TRACE_FARADAY_SERVICE_NAME"
+          ENV_PEER_SERVICE = "DD_TRACE_FARADAY_PEER_SERVICE"
+          ENV_ERROR_STATUS_CODES = "DD_TRACE_FARADAY_ERROR_STATUS_CODES"
 
           # @!visibility private
-          ENV_ANALYTICS_ENABLED = 'DD_TRACE_FARADAY_ANALYTICS_ENABLED'
-          ENV_ANALYTICS_SAMPLE_RATE = 'DD_TRACE_FARADAY_ANALYTICS_SAMPLE_RATE'
-          DEFAULT_PEER_SERVICE_NAME = 'faraday'
-          SPAN_REQUEST = 'faraday.request'
-          TAG_COMPONENT = 'faraday'
-          TAG_OPERATION_REQUEST = 'request'
-          PEER_SERVICE_SOURCES = Array[
+          ENV_ANALYTICS_ENABLED = "DD_TRACE_FARADAY_ANALYTICS_ENABLED"
+          ENV_ANALYTICS_SAMPLE_RATE = "DD_TRACE_FARADAY_ANALYTICS_SAMPLE_RATE"
+          DEFAULT_PEER_SERVICE_NAME = "faraday"
+          SPAN_REQUEST = "faraday.request"
+          TAG_COMPONENT = "faraday"
+          TAG_OPERATION_REQUEST = "request"
+          PEER_SERVICE_SOURCES = [
             Tracing::Metadata::Ext::TAG_PEER_HOSTNAME,
             Tracing::Metadata::Ext::NET::TAG_DESTINATION_NAME,
-            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,].freeze
+            Tracing::Metadata::Ext::NET::TAG_TARGET_HOST,
+          ].freeze
         end
       end
     end

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative '../integration'
-require_relative '../configuration/resolvers/pattern_resolver'
-require_relative 'configuration/settings'
-require_relative 'patcher'
+require_relative "../integration"
+require_relative "../configuration/resolvers/pattern_resolver"
+require_relative "configuration/settings"
+require_relative "patcher"
 
 module Datadog
   module Tracing
@@ -13,13 +13,13 @@ module Datadog
         class Integration
           include Contrib::Integration
 
-          MINIMUM_VERSION = Gem::Version.new('0.14.0')
+          MINIMUM_VERSION = Gem::Version.new("0.14.0")
 
           # @public_api Changing the integration name or integration options can cause breaking changes
           register_as :faraday, auto_patch: true
 
           def self.version
-            Gem.loaded_specs['faraday'] && Gem.loaded_specs['faraday'].version
+            Gem.loaded_specs["faraday"]&.version
           end
 
           def self.loaded?

data/lib/datadog/tracing/contrib/faraday/middleware.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require 'faraday'
+require "faraday"
 
-require_relative '../../metadata/ext'
-require_relative '../http'
-require_relative '../analytics'
-require_relative 'ext'
-require_relative '../http_annotation_helper'
-require_relative '../../../core/telemetry/logger'
+require_relative "../../metadata/ext"
+require_relative "../http"
+require_relative "../analytics"
+require_relative "ext"
+require_relative "../http_annotation_helper"
+require_relative "../../../core/telemetry/logger"
 
 module Datadog
   module Tracing
@@ -29,10 +29,12 @@ module Datadog
 
             Tracing.trace(Ext::SPAN_REQUEST, on_error: request_options[:on_error]) do |span, trace|
               annotate!(span, env, request_options)
-              if Datadog::AppSec::Utils::TraceOperation.appsec_standalone_reject?(trace)
-                trace.sampling_priority = Tracing::Sampling::Ext::Priority::AUTO_REJECT
+              if Tracing::Distributed::PropagationPolicy.enabled?(
+                global_config: request_options,
+                trace: trace
+              )
+                propagate!(trace, span, env)
               end
-              propagate!(trace, span, env) if request_options[:distributed_tracing] && Tracing.enabled?
               app.call(env).on_complete { |resp| handle_response(span, resp, request_options) }
             end
           end
@@ -45,6 +47,7 @@ module Datadog
           def annotate!(span, env, options)
             span.resource = resource_name(env)
             span.service = service_name(env[:url].host, options)
+            span.set_tag(Tracing::Metadata::Ext::TAG_SVC_SRC, Ext::TAG_COMPONENT)
             span.type = Tracing::Metadata::Ext::HTTP::TYPE_OUTBOUND
 
             if options[:peer_service]
@@ -54,11 +57,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)
@@ -80,12 +78,13 @@ module Datadog
             )
 
             Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
-          rescue StandardError => e
-            Datadog.logger.error(e.message)
+          rescue => e
+            Datadog.logger.error("#{e.class}: #{e.message}")
             Datadog::Core::Telemetry::Logger.report(e)
           end
           # rubocop:enable Metrics/AbcSize
 
+          # rubocop:disable Metrics/AbcSize
           def handle_response(span, env, options)
             span.set_error(["Error #{env[:status]}", env[:body]]) if options[:error_status_codes].include? env[:status]
 
@@ -94,10 +93,11 @@ module Datadog
             span.set_tags(
               Datadog.configuration.tracing.header_tags.response_tags(env[:response_headers])
             )
-          rescue StandardError => e
-            Datadog.logger.error(e.message)
+          rescue => e
+            Datadog.logger.error("#{e.class}: #{e.message}")
             Datadog::Core::Telemetry::Logger.report(e)
           end
+          # rubocop:enable Metrics/AbcSize
 
           def propagate!(trace, span, env)
             Contrib::HTTP.inject(trace, env[:request_headers])

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'connection'
-require_relative 'ext'
-require_relative 'rack_builder'
-require_relative '../patcher'
+require_relative "connection"
+require_relative "ext"
+require_relative "rack_builder"
+require_relative "../patcher"
 
 module Datadog
   module Tracing
@@ -20,7 +20,7 @@ module Datadog
           end
 
           def patch
-            require_relative 'middleware'
+            require_relative "middleware"
 
             register_middleware!
             add_default_middleware!
@@ -31,7 +31,7 @@ module Datadog
           end
 
           def add_default_middleware!
-            if target_version >= Gem::Version.new('1.0.0')
+            if target_version >= Gem::Version.new("1.0.0")
               # Patch the default connection (e.g. +Faraday.get+)
               ::Faraday.default_connection.use(:datadog_tracing)
 

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-require_relative '../../configuration/settings'
-require_relative '../ext'
-require_relative '../../status_range_matcher'
-require_relative '../../status_range_env_parser'
+require_relative "../../configuration/settings"
+require_relative "../ext"
+require_relative "../../status_range_matcher"
+require_relative "../../status_range_env_parser"
 
 module Datadog
   module Tracing
@@ -39,9 +39,13 @@ module Datadog
 
             option :error_status_codes do |o|
               o.env Ext::ENV_ERROR_STATUS_CODES
-              o.default 500...600
-              o.setter do |v|
-                Tracing::Contrib::StatusRangeMatcher.new(v) if v
+              o.setter do |value|
+                if value.nil?
+                  # Fallback to global config, which is defaulted to server (500..599)
+                  Datadog.configuration.tracing.http_error_statuses.server
+                else
+                  Tracing::Contrib::StatusRangeMatcher.new(value)
+                end
               end
               o.env_parser do |v|
                 Tracing::Contrib::StatusRangeEnvParser.call(v) if v

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

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative '../../../core'
-require_relative '../../../core/telemetry/logger'
-require_relative '../../metadata/ext'
-require_relative '../analytics'
-require_relative '../rack/ext'
+require_relative "../../../core"
+require_relative "../../../core/telemetry/logger"
+require_relative "../../metadata/ext"
+require_relative "../analytics"
+require_relative "../rack/ext"
 
 module Datadog
   module Tracing
@@ -13,25 +13,25 @@ module Datadog
         # Endpoint module includes a list of subscribers to create
         # traces when a Grape endpoint is hit
         module Endpoint
-          KEY_RUN = 'datadog_grape_endpoint_run'
-          KEY_RENDER = 'datadog_grape_endpoint_render'
+          KEY_RUN = "datadog_grape_endpoint_run"
+          KEY_RENDER = "datadog_grape_endpoint_render"
 
           class << self
             def subscribe
               # subscribe when a Grape endpoint is hit
-              ::ActiveSupport::Notifications.subscribe('endpoint_run.grape.start_process') do |*args|
+              ::ActiveSupport::Notifications.subscribe("endpoint_run.grape.start_process") do |*args|
                 endpoint_start_process(*args)
               end
-              ::ActiveSupport::Notifications.subscribe('endpoint_run.grape') do |*args|
+              ::ActiveSupport::Notifications.subscribe("endpoint_run.grape") do |*args|
                 endpoint_run(*args)
               end
-              ::ActiveSupport::Notifications.subscribe('endpoint_render.grape.start_render') do |*args|
+              ::ActiveSupport::Notifications.subscribe("endpoint_render.grape.start_render") do |*args|
                 endpoint_start_render(*args)
               end
-              ::ActiveSupport::Notifications.subscribe('endpoint_render.grape') do |*args|
+              ::ActiveSupport::Notifications.subscribe("endpoint_render.grape") do |*args|
                 endpoint_render(*args)
               end
-              ::ActiveSupport::Notifications.subscribe('endpoint_run_filters.grape') do |*args|
+              ::ActiveSupport::Notifications.subscribe("endpoint_run_filters.grape") do |*args|
                 endpoint_run_filters(*args)
               end
             end
@@ -62,22 +62,23 @@ 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]
+              if (grape_route = env["grape.routing_args"]) && grape_route[:route_info]
                 trace.set_tag(
                   Tracing::Metadata::Ext::HTTP::TAG_ROUTE,
                   # here we are removing the format from the path:
                   # e.g. /path/to/resource(.json) => /path/to/resource
                   # e.g. /path/to/resource(.:format) => /path/to/resource
-                  grape_route[:route_info].path&.gsub(/\(\.:?\w+\)\z/, '')
+                  grape_route[:route_info].path&.gsub(/\(\.:?\w+\)\z/, "")
                 )
 
-                trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, env['SCRIPT_NAME'])
+                trace.set_tag(Tracing::Metadata::Ext::HTTP::TAG_ROUTE_PATH, env["SCRIPT_NAME"])
               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,12 +268,12 @@ 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?('/') }
-                .join('/')
-              path.prepend('/') if path[0] != '/'
+              path = (namespace.split("/") + route_path)
+                .reject { |p| p.blank? || p.eql?("/") }
+                .join("/")
+              path.prepend("/") if path[0] != "/"
               path
             end
 
@@ -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/ext.rb

@@ -7,22 +7,22 @@ module Datadog
         # Grape integration constants
         # @public_api Changing resource names, tag names, or environment variables creates breaking changes.
         module Ext
-          ENV_ENABLED = 'DD_TRACE_GRAPE_ENABLED'
+          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'
-          ENV_ERROR_STATUS_CODES = 'DD_TRACE_GRAPE_ERROR_STATUS_CODES'
-          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'
+          ENV_ANALYTICS_ENABLED = "DD_TRACE_GRAPE_ANALYTICS_ENABLED"
+          ENV_ANALYTICS_SAMPLE_RATE = "DD_TRACE_GRAPE_ANALYTICS_SAMPLE_RATE"
+          ENV_ERROR_STATUS_CODES = "DD_TRACE_GRAPE_ERROR_STATUS_CODES"
+          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