datadog 2.36.0 → 2.40.0

data/lib/datadog/tracing/distributed/baggage.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
-require_relative '../metadata/ext'
-require_relative '../trace_digest'
-require_relative 'datadog_tags_codec'
-require_relative '../utils'
-require_relative 'helpers'
-require 'uri'
+require_relative "../ext"
+require_relative "../metadata/ext"
+require_relative "../trace_digest"
+require_relative "datadog_tags_codec"
+require_relative "../utils"
+require_relative "helpers"
+require "uri"
 
 module Datadog
   module Tracing
@@ -14,10 +15,10 @@ module Datadog
       # The baggage header is propagated through `baggage`.
       # @see https://www.w3.org/TR/baggage/
       class Baggage
-        BAGGAGE_KEY = 'baggage'
+        BAGGAGE_KEY = "baggage"
         DD_TRACE_BAGGAGE_MAX_ITEMS = 64
         DD_TRACE_BAGGAGE_MAX_BYTES = 8192
-        BAGGAGE_TAG_KEYS_MATCH_ALL = ['*'].freeze
+        BAGGAGE_TAG_KEYS_MATCH_ALL = ["*"].freeze
         SAFE_CHARACTERS_KEY = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789$!#&'*+-.^_`|~"
         SAFE_CHARACTERS_VALUE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789$!#&'()*+-./:<>?@[]^_`{|}~"
 
@@ -42,9 +43,9 @@ module Datadog
               ::Datadog.logger.warn("Baggage item limit (#{DD_TRACE_BAGGAGE_MAX_ITEMS}) exceeded, dropping excess items")
               # Record telemetry for item count truncation
               record_telemetry_metric(
-                'context_header.truncated',
+                "context_header.truncated",
                 1,
-                {'header_style' => 'baggage', 'truncation_reason' => 'baggage_item_count_exceeded'}
+                {"header_style" => "baggage", "truncation_reason" => "baggage_item_count_exceeded"}
               )
               baggage_items = baggage_items.first(DD_TRACE_BAGGAGE_MAX_ITEMS)
             end
@@ -59,9 +60,9 @@ module Datadog
                 ::Datadog.logger.warn("Baggage header size (#{DD_TRACE_BAGGAGE_MAX_BYTES}) exceeded, dropping excess items")
                 # Record telemetry for byte count truncation
                 record_telemetry_metric(
-                  'context_header.truncated',
+                  "context_header.truncated",
                   1,
-                  {'header_style' => 'baggage', 'truncation_reason' => 'baggage_byte_count_exceeded'}
+                  {"header_style" => "baggage", "truncation_reason" => "baggage_byte_count_exceeded"}
                 )
                 break # stop adding items when size limit is reached
               end
@@ -72,10 +73,10 @@ module Datadog
             # edge case where a single item is too large
             return if encoded_items.empty?
 
-            data[@baggage_key] = encoded_items.join(',')
+            data[@baggage_key] = encoded_items.join(",")
 
             # Record telemetry for successful injection
-            record_telemetry_metric('context_header_style.injected', 1, {'header_style' => 'baggage'})
+            record_telemetry_metric("context_header_style.injected", 1, {"header_style" => "baggage"})
           rescue => e
             ::Datadog.logger.warn("Failed to encode and inject baggage header: #{e.class}: #{e.message}")
           end
@@ -94,7 +95,7 @@ module Datadog
 
           # Record telemetry for successful extraction only if baggage is not empty
           unless baggage.empty?
-            record_telemetry_metric('context_header_style.extracted', 1, {'header_style' => 'baggage'})
+            record_telemetry_metric("context_header_style.extracted", 1, {"header_style" => "baggage"})
           end
 
           TraceDigest.new(
@@ -109,7 +110,7 @@ module Datadog
           # Strip whitespace and URL-encode the item
           result = URI.encode_www_form_component(item.strip)
           # Replace '+' with '%20' for space encoding consistency with W3C spec
-          result = result.gsub('+', '%20')
+          result = result.gsub("+", "%20")
           # Selectively decode percent-encoded characters that are considered "safe" in W3C Baggage spec
           result.gsub(/%[0-9A-F]{2}/) do |encoded|
             if encoded.size >= 3 && encoded[1..2] =~ /\A[0-9A-F]{2}\z/
@@ -117,7 +118,7 @@ module Datadog
               next encoded unless hex_str && !hex_str.empty?
 
               # Convert hex representation back to character
-              char = [hex_str.hex].pack('C')
+              char = [hex_str.hex].pack("C")
               # Keep the character as-is if it's in the safe character set, otherwise keep it encoded
               safe_characters.include?(char) ? char : encoded
             else
@@ -144,12 +145,12 @@ module Datadog
           # the typical Rack path is unaffected; only UTF-8-tagged-but-actually-invalid
           # input (e.g. headers re-encoded upstream) is short-circuited here.
           unless baggage_header.valid_encoding?
-            record_telemetry_metric('context_header_style.malformed', 1, {'header_style' => 'baggage'})
+            record_telemetry_metric("context_header_style.malformed", 1, {"header_style" => "baggage"})
             return {}
           end
 
           if baggage_header.bytesize > DD_TRACE_BAGGAGE_MAX_BYTES
-            record_telemetry_metric('context_header.truncated', 1, {'header_style' => 'baggage', 'truncation_reason' => 'baggage_byte_count_exceeded'})
+            record_telemetry_metric("context_header.truncated", 1, {"header_style" => "baggage", "truncation_reason" => "baggage_byte_count_exceeded"})
 
             # We MUST NOT propagate partial entries, but we SHOULD try
             # to parse as much of the baggage as possible:
@@ -157,7 +158,7 @@ module Datadog
 
             # We parse 1 byte over the limit to detect if the last entry
             # is a partial entry (toss) or ends exactly at the limit (keep).
-            remove_last_entry = baggage_header.byteslice(DD_TRACE_BAGGAGE_MAX_BYTES, 1) != ','
+            remove_last_entry = baggage_header.byteslice(DD_TRACE_BAGGAGE_MAX_BYTES, 1) != ","
 
             # To ensure we don't have a trailing partial UTF-8 codepoint, we keep one extra byte
             # and safely remove it with `#chop`.
@@ -170,10 +171,10 @@ module Datadog
           baggage = {}
           # DEV: To avoid unnecessary eager string allocation, replace with
           # DEV: `split(',') { |s| ... }` when Ruby 2.5 is no longer supported.
-          baggages = baggage_header.split(',', DD_TRACE_BAGGAGE_MAX_ITEMS + 1) # Stop splitting if we've reached max size
+          baggages = baggage_header.split(",", DD_TRACE_BAGGAGE_MAX_ITEMS + 1) # Stop splitting if we've reached max size
           baggages.each_with_index do |key_value, index|
             if index >= DD_TRACE_BAGGAGE_MAX_ITEMS
-              record_telemetry_metric('context_header.truncated', 1, {'header_style' => 'baggage', 'truncation_reason' => 'baggage_item_count_exceeded'})
+              record_telemetry_metric("context_header.truncated", 1, {"header_style" => "baggage", "truncation_reason" => "baggage_item_count_exceeded"})
               break
             end
 
@@ -183,11 +184,11 @@ module Datadog
             # Empty items are skipped
             next if key_value.strip.empty?
 
-            key, value = key_value.split('=', 2)
+            key, value = key_value.split("=", 2)
             # If baggage is malformed, return an empty hash
             if key.nil? || value.nil?
               # Record telemetry for malformed header
-              record_telemetry_metric('context_header_style.malformed', 1, {'header_style' => 'baggage'})
+              record_telemetry_metric("context_header_style.malformed", 1, {"header_style" => "baggage"})
               return {}
             end
 
@@ -198,13 +199,13 @@ module Datadog
               # `URI.decode_www_form_component` raises on malformed percent encoding
               # (e.g. `%XX`, lone `%`). Treat as malformed rather than letting it
               # propagate to `Propagation#extract`'s caller.
-              record_telemetry_metric('context_header_style.malformed', 1, {'header_style' => 'baggage'})
+              record_telemetry_metric("context_header_style.malformed", 1, {"header_style" => "baggage"})
               return {}
             end
 
             if key.empty? || value.empty?
               # Record telemetry for malformed header
-              record_telemetry_metric('context_header_style.malformed', 1, {'header_style' => 'baggage'})
+              record_telemetry_metric("context_header_style.malformed", 1, {"header_style" => "baggage"})
               return {}
             end
 
@@ -243,7 +244,7 @@ module Datadog
         # Record telemetry metrics for baggage operations
         def record_telemetry_metric(metric_name, value, tags)
           telemetry = ::Datadog.send(:components).telemetry
-          telemetry.inc('instrumentation_telemetry_data.tracers', metric_name, value, tags: tags)
+          telemetry.inc(Tracing::Ext::TELEMETRY_METRICS_NAMESPACE, metric_name, value, tags: tags)
         end
       end
     end

data/lib/datadog/tracing/distributed/datadog.rb

@@ -1,25 +1,25 @@
 # frozen_string_literal: true
 
-require_relative '../metadata/ext'
-require_relative '../trace_digest'
-require_relative 'datadog_tags_codec'
-require_relative '../utils'
-require_relative 'helpers'
+require_relative "../metadata/ext"
+require_relative "../trace_digest"
+require_relative "datadog_tags_codec"
+require_relative "../utils"
+require_relative "helpers"
 
 module Datadog
   module Tracing
     module Distributed
       # Datadog-style trace propagation.
       class Datadog
-        TRACE_ID_KEY = 'x-datadog-trace-id'
-        PARENT_ID_KEY = 'x-datadog-parent-id'
-        SAMPLING_PRIORITY_KEY = 'x-datadog-sampling-priority'
-        ORIGIN_KEY = 'x-datadog-origin'
+        TRACE_ID_KEY = "x-datadog-trace-id"
+        PARENT_ID_KEY = "x-datadog-parent-id"
+        SAMPLING_PRIORITY_KEY = "x-datadog-sampling-priority"
+        ORIGIN_KEY = "x-datadog-origin"
         # Distributed trace-level tags
-        TAGS_KEY = 'x-datadog-tags'
+        TAGS_KEY = "x-datadog-tags"
 
         # Prefix used by all Datadog-specific distributed tags
-        TAGS_PREFIX = 'x-datadog-'
+        TAGS_PREFIX = "x-datadog-"
 
         def initialize(
           fetcher:,
@@ -108,7 +108,7 @@ module Datadog
 
           return tags if high_order == 0
 
-          tags.merge(Tracing::Metadata::Ext::Distributed::TAG_TID => format('%016x', high_order))
+          tags.merge(Tracing::Metadata::Ext::Distributed::TAG_TID => format("%016x", high_order))
         end
 
         # Side effect: Remove high order 64 bit hex-encoded `tid` tag from distributed tags
@@ -127,15 +127,15 @@ module Datadog
         # DEV: This means errors cannot be reported if there's not active span.
         # DEV: Ideally, we'd have a dedicated error reporting stream for all of datadog.
         def inject_tags!(tags, data)
-          return set_tags_propagation_error(reason: 'disabled') if tags_disabled?
+          return set_tags_propagation_error(reason: "disabled") if tags_disabled?
 
           encoded_tags = DatadogTagsCodec.encode(tags)
 
-          return set_tags_propagation_error(reason: 'inject_max_size') if tags_too_large?(encoded_tags, scenario: 'inject')
+          return set_tags_propagation_error(reason: "inject_max_size") if tags_too_large?(encoded_tags, scenario: "inject")
 
           data[@tags_key] = encoded_tags
         rescue => e
-          set_tags_propagation_error(reason: 'encoding_error')
+          set_tags_propagation_error(reason: "encoding_error")
           ::Datadog.logger.warn(
             "Failed to inject x-datadog-tags: #{e.class}: #{e.message} at #{Array(e.backtrace).first}"
           )
@@ -152,8 +152,8 @@ module Datadog
           tags = fetcher[@tags_key]
 
           return if !tags || tags.empty?
-          return set_tags_propagation_error(reason: 'disabled') if tags_disabled?
-          return set_tags_propagation_error(reason: 'extract_max_size') if tags_too_large?(tags, scenario: 'extract')
+          return set_tags_propagation_error(reason: "disabled") if tags_disabled?
+          return set_tags_propagation_error(reason: "extract_max_size") if tags_too_large?(tags, scenario: "extract")
 
           tags_hash = DatadogTagsCodec.decode(tags)
           # Only extract keys with the expected Datadog prefix
@@ -162,7 +162,7 @@ module Datadog
           end
           tags_hash
         rescue => e
-          set_tags_propagation_error(reason: 'decoding_error')
+          set_tags_propagation_error(reason: "decoding_error")
           ::Datadog.logger.warn(
             "Failed to extract x-datadog-tags: #{e.class}: #{e.message} at #{Array(e.backtrace).first}"
           )
@@ -171,7 +171,7 @@ module Datadog
 
         def set_tags_propagation_error(reason:)
           active_trace = Tracing.active_trace
-          active_trace&.set_tag('_dd.propagation_error', reason)
+          active_trace&.set_tag("_dd.propagation_error", reason)
           nil
         end
 
@@ -188,14 +188,14 @@ module Datadog
           ::Datadog.logger.warn(
             "Failed to #{scenario} x-datadog-tags: tags are too large for configured limit (bytesize:#{size} >= " \
               "limit:#{max_length}). This limit can be configured " \
-              'through the DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH environment variable.'
+              "through the DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH environment variable."
           )
 
           true
         end
 
         # We want to exclude tags that we don't want to propagate downstream.
-        EXCLUDED_TAG = '_dd.p.upstream_services'
+        EXCLUDED_TAG = "_dd.p.upstream_services"
         private_constant :EXCLUDED_TAG
       end
     end

data/lib/datadog/tracing/distributed/datadog_tags_codec.rb

@@ -26,7 +26,7 @@ module Datadog
             raise EncodingError, "Invalid value `#{value}` for key `#{key}`" unless VALID_VALUE_CHARS.match?(value)
 
             "#{key}=#{value.strip}"
-          end.join(',')
+          end.join(",")
         rescue => e
           raise EncodingError, "Error encoding tags `#{tags}`: `#{e.class}: #{e.message}`"
         end
@@ -37,8 +37,8 @@ module Datadog
         # @return [Hash<String,String>] decoded input as a hash of strings
         # @raise [DecodingError] if string does not conform to the `x-datadog-tags` format
         def self.decode(string)
-          result = (string.split(',').map do |raw_tag|
-            raw_tag.split('=', 2).tap do |raw_key, raw_value|
+          result = (string.split(",").map do |raw_tag|
+            raw_tag.split("=", 2).tap do |raw_key, raw_value|
               key = raw_key.to_s
               value = raw_value.to_s
 

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'helpers'
+require_relative "helpers"
 
 module Datadog
   module Tracing

data/lib/datadog/tracing/distributed/helpers.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../sampling/ext'
-require_relative '../utils'
+require_relative "../sampling/ext"
+require_relative "../utils"
 
 module Datadog
   module Tracing
@@ -47,7 +47,7 @@ module Datadog
           #      for us so we want to make sure the comparision will work as expected
           # DEV: regex, remove all leading zeros up until we find the last 0 in the string
           #      or we find the first non-zero, this allows `'0000' -> '0'` and `'00001' -> '1'`
-          value = value.sub(/^0*(?=(0$)|[^0])/, '')
+          value = value.sub(/^0*(?=(0$)|[^0])/, "")
 
           # Convert value to an integer
           # DEV: Ruby `.to_i` will return `0` if a number could not be parsed

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

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative '../configuration/ext'
-require_relative '../trace_digest'
-require_relative '../trace_operation'
-require_relative '../span_link'
-require_relative '../../core/telemetry/logger'
-require_relative 'baggage'
+require_relative "../configuration/ext"
+require_relative "../trace_digest"
+require_relative "../trace_operation"
+require_relative "../span_link"
+require_relative "../../core/telemetry/logger"
+require_relative "baggage"
 
 module Datadog
   module Tracing
@@ -62,13 +62,13 @@ module Datadog
         # @return [nil] in case of unrecoverable errors, see `Datadog.logger` output for details.
         def inject!(digest, data)
           if digest.nil?
-            ::Datadog.logger.debug('Cannot inject distributed trace data: digest is nil.')
+            ::Datadog.logger.debug("Cannot inject distributed trace data: digest is nil.")
             return nil
           end
 
           digest = digest.to_digest if digest.respond_to?(:to_digest)
           if digest.trace_id.nil? && digest.baggage.nil?
-            ::Datadog.logger.debug('Cannot inject distributed trace data: digest.trace_id and digest.baggage are both nil.')
+            ::Datadog.logger.debug("Cannot inject distributed trace data: digest.trace_id and digest.baggage are both nil.")
             return nil
           end
 
@@ -166,11 +166,11 @@ module Datadog
           link = SpanLink.new(
             extracted_trace_digest,
             attributes: {
-              'reason' => 'propagation_behavior_extract',
-              'context_headers' => extracted_style_name,
+              "reason" => "propagation_behavior_extract",
+              "context_headers" => extracted_style_name,
             }
           )
-          baggage_tags = extracted_trace_digest.trace_distributed_tags&.select { |k, _| k.start_with?('baggage.') }
+          baggage_tags = extracted_trace_digest.trace_distributed_tags&.select { |k, _| k.start_with?("baggage.") }
           baggage_tags = nil if baggage_tags&.empty?
           TraceDigest.new(
             span_links: [link],
@@ -210,7 +210,7 @@ module Datadog
             tracecontext_tags[Tracing::Metadata::Ext::Distributed::TAG_DD_PARENT_ID]
           elsif dd_propagator && (dd_digest = dd_propagator.extract(headers))
             # if p value is not present in tracestate, use the parent id from the datadog headers
-            format('%016x', dd_digest.span_id)
+            format("%016x", dd_digest.span_id)
           end
         end
       end

data/lib/datadog/tracing/distributed/propagation_policy.rb

@@ -28,6 +28,11 @@ module Datadog
               return true
             end
 
+            if ::Datadog.configuration.respond_to?(:ai_guard) && ::Datadog.configuration.ai_guard.enabled &&
+                (trace_source & ::Datadog::AIGuard::Ext::PRODUCT_BIT) != 0
+              return true
+            end
+
             return false
           end
 

data/lib/datadog/tracing/distributed/trace_context.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../../core/utils'
-require_relative 'helpers'
+require_relative "../../core/utils"
+require_relative "helpers"
 
 module Datadog
   module Tracing
@@ -10,9 +10,9 @@ module Datadog
       # The trace is propagated through two fields: `traceparent` and `tracestate`.
       # @see https://www.w3.org/TR/trace-context/
       class TraceContext
-        TRACEPARENT_KEY = 'traceparent'
-        TRACESTATE_KEY = 'tracestate'
-        SPEC_VERSION = '00'
+        TRACEPARENT_KEY = "traceparent"
+        TRACESTATE_KEY = "tracestate"
+        SPEC_VERSION = "00"
 
         def initialize(
           fetcher:,
@@ -123,7 +123,7 @@ module Datadog
 
         # @see https://www.w3.org/TR/trace-context/#tracestate-header
         def build_tracestate(digest)
-          tracestate = +'dd='
+          tracestate = +"dd="
           append_dd(tracestate, last_dd_parent_id(digest))
           append_dd(tracestate, "s:#{digest.trace_sampling_priority};") if digest.trace_sampling_priority
           append_dd(tracestate, "o:#{serialize_origin(digest.trace_origin)};") if digest.trace_origin
@@ -150,20 +150,20 @@ module Datadog
 
             if vendors && !vendors.empty?
               # Delete existing `dd=` tracestate fields, if present.
-              vendors.reject! { |v| v.start_with?('dd=') }
+              vendors.reject! { |v| v.start_with?("dd=") }
 
               # Ensure the list has at most 31 elements, as we need to prepend Datadog's
               # entry and the limit is 32 elements total.
               vendors.first(TRACESTATE_MAX_LIST_MEMBERS - 1).each do |vendor|
                 break if tracestate.bytesize + vendor.bytesize + 1 > TRACESTATE_MAX_SIZE_LIMIT
 
-                tracestate << ',' << vendor
+                tracestate << "," << vendor
               end
             end
 
             tracestate.to_s
           elsif vendors && !vendors.empty?
-            vendors.join(',')
+            vendors.join(",")
           end
         end
 
@@ -185,7 +185,7 @@ module Datadog
           elsif digest.trace_distributed_tags&.key?(Tracing::Metadata::Ext::Distributed::TAG_DD_PARENT_ID)
             "p:#{digest.trace_distributed_tags[Tracing::Metadata::Ext::Distributed::TAG_DD_PARENT_ID]};"
           else
-            ''
+            ""
           end
         end
 
@@ -198,13 +198,13 @@ module Datadog
           # DEV: come from Datadog-controlled sources.
           # DEV: Trying to `match?` is measurably faster than a `gsub` that does not match.
           value = if INVALID_ORIGIN_CHARS.match?(value)
-            value.gsub(INVALID_ORIGIN_CHARS, '_')
+            value.gsub(INVALID_ORIGIN_CHARS, "_")
           else
             value
           end
 
           if REMAP_ORIGIN_CHARS.match?(value)
-            value.gsub(REMAP_ORIGIN_CHARS, '~')
+            value.gsub(REMAP_ORIGIN_CHARS, "~")
           else
             value
           end
@@ -221,7 +221,7 @@ module Datadog
           # DEV: It's unlikely that characters will be out of range, as they mostly
           # DEV: come from Datadog-controlled sources.
           # DEV: Trying to `match?` is measurably faster than a `gsub!` that does not match.
-          key.gsub!(INVALID_TAG_KEY_CHARS, '_') if INVALID_TAG_KEY_CHARS.match?(key)
+          key.gsub!(INVALID_TAG_KEY_CHARS, "_") if INVALID_TAG_KEY_CHARS.match?(key)
 
           key
         end
@@ -235,14 +235,14 @@ module Datadog
           # DEV: come from Datadog-controlled sources.
           # DEV: Trying to `match?` is measurably faster than a `gsub` that does not match.
           ret = if INVALID_TAG_VALUE_CHARS.match?(value)
-            value.gsub(INVALID_TAG_VALUE_CHARS, '_')
+            value.gsub(INVALID_TAG_VALUE_CHARS, "_")
           else
             value
           end
 
           # DEV: Checking for an unlikely '=' is faster than a no-op `tr`.
-          if ret.include?('=')
-            ret.tr('=', '~')
+          if ret.include?("=")
+            ret.tr("=", "~")
           else
             ret
           end
@@ -265,11 +265,11 @@ module Datadog
 
           traceparent = traceparent.strip
 
-          version, trace_id, parent_id, trace_flags, extra = traceparent.split('-', 5)
+          version, trace_id, parent_id, trace_flags, extra = traceparent.split("-", 5)
 
           return unless version && trace_id && parent_id && trace_flags
           return if version.size != 2 || trace_id.size != 32 || parent_id.size != 16 || trace_flags.size != 2
-          return if version[0] < '0' || version[0] > 'f' || version[1] < '0' || version[1] > 'f'
+          return if version[0] < "0" || version[0] > "f" || version[1] < "0" || version[1] > "f"
 
           return if version == INVALID_VERSION
 
@@ -294,10 +294,10 @@ module Datadog
           vendors = split_tracestate(tracestate)
           return unless vendors && !vendors.empty?
 
-          tracestate = vendors.join(',')
+          tracestate = vendors.join(",")
 
           # Find Datadog's `dd=` tracestate field.
-          idx = vendors.index { |v| v.start_with?('dd=') }
+          idx = vendors.index { |v| v.start_with?("dd=") }
           return tracestate unless idx
 
           # Delete `dd=` prefix
@@ -306,7 +306,7 @@ module Datadog
 
           origin, sampling_priority, ts_parent_id, tags, unknown_fields = extract_datadog_fields(dd_tracestate)
 
-          [vendors.join(','), sampling_priority, origin, ts_parent_id, tags, unknown_fields]
+          [vendors.join(","), sampling_priority, origin, ts_parent_id, tags, unknown_fields]
         end
 
         def extract_datadog_fields(dd_tracestate)
@@ -317,18 +317,18 @@ module Datadog
           unknown_fields = nil
 
           # DEV: Since Ruby 2.6 `split` can receive a block, so `each` can be removed then.
-          dd_tracestate.split(';').each do |pair|
-            key, value = pair.split(':', 2)
+          dd_tracestate.split(";").each do |pair|
+            key, value = pair.split(":", 2)
             case key
-            when 's'
+            when "s"
               sampling_priority = begin
                 Integer(value)
               rescue
                 nil
               end
-            when 'o'
+            when "o"
               origin = value
-            when 'p'
+            when "p"
               ts_parent_id = value
             when /^t\./
               key.slice!(0..1) # Delete `t.` prefix
@@ -342,9 +342,9 @@ module Datadog
               tags ||= {}
               tags["#{Tracing::Metadata::Ext::Distributed::TAGS_PREFIX}#{key}"] = value
             else
-              unknown_fields ||= +''
+              unknown_fields ||= +""
               unknown_fields << pair
-              unknown_fields << ';'
+              unknown_fields << ";"
             end
           end
 
@@ -353,7 +353,7 @@ module Datadog
 
         # Restore `~` back to `=`.
         def deserialize_tag_value(value)
-          value.tr!('~', '=')
+          value.tr!("~", "=")
           value
         end
 
@@ -391,7 +391,7 @@ module Datadog
           if tracestate.bytesize > TRACESTATE_MAX_SIZE_LIMIT
             # We parse 1 byte over the limit to detect if the last member
             # is a partial member (toss) or ends exactly at the limit (keep).
-            remove_last_member = tracestate.byteslice(TRACESTATE_MAX_SIZE_LIMIT, 1) != ','
+            remove_last_member = tracestate.byteslice(TRACESTATE_MAX_SIZE_LIMIT, 1) != ","
 
             # To ensure we don't have a trailing partial UTF-8 codepoint, we keep one extra byte
             # and safely remove it with `#chop`.
@@ -404,13 +404,13 @@ module Datadog
           tracestate = ::Datadog::Core::Utils.utf8_encode(tracestate, placeholder: nil)
           return unless tracestate
 
-          vendors = tracestate.split(',', TRACESTATE_MAX_LIST_MEMBERS + 1)
+          vendors = tracestate.split(",", TRACESTATE_MAX_LIST_MEMBERS + 1)
           if vendors.length > TRACESTATE_MAX_LIST_MEMBERS || remove_last_member
             vendors.pop
           end
 
           vendors.each(&:strip!)
-          vendors.pop while vendors.last == ''
+          vendors.pop while vendors.last == ""
           vendors
         end
 
@@ -425,7 +425,7 @@ module Datadog
 
         # Version 0xFF is invalid as per spec
         # @see https://www.w3.org/TR/trace-context/#version
-        INVALID_VERSION = 'ff'
+        INVALID_VERSION = "ff"
         private_constant :INVALID_VERSION
 
         # Empty 8-bit `trace-flags`.

data/lib/datadog/tracing/event.rb

@@ -46,7 +46,7 @@ module Datadog
       end
 
       def subscribe(&block)
-        raise ArgumentError, 'Must give a block to subscribe!' unless block
+        raise ArgumentError, "Must give a block to subscribe!" unless block
 
         subscriptions << block
       end

data/lib/datadog/tracing/ext.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Ext
+      TELEMETRY_METRICS_NAMESPACE = "tracers"
+    end
+  end
+end

data/lib/datadog/tracing/metadata/analytics.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../analytics'
-require_relative 'ext'
+require_relative "../analytics"
+require_relative "ext"
 
 module Datadog
   module Tracing