datadog 2.8.0 → 2.39.0

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require_relative "../../core/utils"
+require_relative "helpers"
+
 module Datadog
   module Tracing
     module Distributed
@@ -7,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:,
@@ -52,7 +55,7 @@ module Datadog
               tags ||= {}
               tags[Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER] = decision
             when :drop
-              tags.delete(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER) if tags
+              tags&.delete(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
             end
           end
 
@@ -75,34 +78,6 @@ module Datadog
 
         private
 
-        # Refinements to ensure newer rubies do not suffer performance impact
-        # by needing to use older APIs.
-        module Refine
-          # Backport `Regexp::match?` because it is measurably the most performant
-          # way to check if a string matches a regular expression.
-          unless Regexp.method_defined?(:match?)
-            refine ::Regexp do
-              def match?(*args)
-                !match(*args).nil?
-              end
-            end
-          end
-
-          unless String.method_defined?(:delete_prefix)
-            refine ::String do
-              def delete_prefix(prefix)
-                prefix = prefix.to_s
-                if rindex(prefix, 0)
-                  self[prefix.length..-1]
-                else
-                  dup
-                end
-              end
-            end
-          end
-        end
-        using Refine
-
         # @see https://www.w3.org/TR/trace-context/#traceparent-header
         def build_traceparent(digest)
           build_traceparent_string(
@@ -128,7 +103,7 @@ module Datadog
         # @param parent_id [Integer] 64-bit
         # @param trace_flags [Integer] 8-bit
         def build_traceparent_string(trace_id, parent_id, trace_flags)
-          "00-#{format('%032x', trace_id)}-#{format('%016x', parent_id)}-#{format('%02x', trace_flags)}"
+          "00-#{format("%032x", trace_id)}-#{format("%016x", parent_id)}-#{format("%02x", trace_flags)}"
         end
 
         # Sets the trace flag to an existing `trace_flags`.
@@ -148,62 +123,69 @@ module Datadog
 
         # @see https://www.w3.org/TR/trace-context/#tracestate-header
         def build_tracestate(digest)
-          tracestate = String.new('dd=')
-          tracestate << last_dd_parent_id(digest)
-          tracestate << "s:#{digest.trace_sampling_priority};" if digest.trace_sampling_priority
-          tracestate << "o:#{serialize_origin(digest.trace_origin)};" if digest.trace_origin
-
-          if digest.trace_distributed_tags
+          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
+
+          # Replacing this by safe navigation seems to have a different behaviour on Rubies <= 3.0.
+          # It cause a LocalJumpError in the CI.
+          if digest.trace_distributed_tags # rubocop:disable Style/SafeNavigation
             digest.trace_distributed_tags.each do |name, value|
               tag = "t.#{serialize_tag_key(name)}:#{serialize_tag_value(value)};"
 
-              # If tracestate size limit is exceed, drop the remaining data.
-              # String#bytesize is used because only ASCII characters are allowed.
-              #
-              # We add 1 to the limit because of the trailing comma, which will be removed before returning.
-              break if tracestate.bytesize + tag.bytesize > (TRACESTATE_VALUE_SIZE_LIMIT + 1)
-
-              tracestate << tag
+              # If tracestate size limit is exceeded, drop the remaining data.
+              break unless append_dd(tracestate, tag)
             end
           end
 
-          tracestate << digest.trace_state_unknown_fields if digest.trace_state_unknown_fields
+          append_dd(tracestate, digest.trace_state_unknown_fields) if digest.trace_state_unknown_fields
+          vendors = split_tracestate(digest.trace_state)
 
           # Is there any Datadog-specific information to propagate.
           # Check for > 3 size because the empty prefix `dd=` has 3 characters.
-          if tracestate.size > 3
+          if tracestate.bytesize > 3
             # Propagate upstream tracestate with `dd=...` appended to the list
             tracestate.chop! # Removes trailing `;` from Datadog trace state string.
 
-            if digest.trace_state
-              trace_state = digest.trace_state.strip
-
+            if vendors && !vendors.empty?
               # Delete existing `dd=` tracestate fields, if present.
-              vendors = split_tracestate(trace_state)
-              vendors.reject! { |v| v.start_with?('dd=') }
-            end
+              vendors.reject! { |v| v.start_with?("dd=") }
 
-            if vendors && !vendors.empty?
               # Ensure the list has at most 31 elements, as we need to prepend Datadog's
               # entry and the limit is 32 elements total.
-              vendors = vendors[0..30]
-              "#{tracestate},#{vendors.join(',')}"
-            else
-              tracestate.to_s
+              vendors.first(TRACESTATE_MAX_LIST_MEMBERS - 1).each do |vendor|
+                break if tracestate.bytesize + vendor.bytesize + 1 > TRACESTATE_MAX_SIZE_LIMIT
+
+                tracestate << "," << vendor
+              end
             end
-          else
-            digest.trace_state # Propagate upstream tracestate with no Datadog changes
+
+            tracestate.to_s
+          elsif vendors && !vendors.empty?
+            vendors.join(",")
           end
         end
 
+        # Appends a Datadog tracestate field when it fits.
+        def append_dd(tracestate, field)
+          return true if field.empty?
+
+          # We add 1 to the limit because of the trailing semicolon, which will be removed before returning.
+          return false if tracestate.bytesize + field.bytesize > (TRACESTATE_VALUE_SIZE_LIMIT + 1)
+
+          tracestate << field
+          true
+        end
+
         def last_dd_parent_id(digest)
           if !digest.span_remote
             span_id = digest.span_id || 0 # Fall back to zero (invalid) if not present
-            "p:#{format('%016x', span_id)};"
+            "p:#{format("%016x", span_id)};"
           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
 
@@ -216,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, '_')
-                  else
-                    value
-                  end
+            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
@@ -239,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
@@ -253,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, '_')
-                else
-                  value
-                end
+            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
@@ -279,19 +261,21 @@ module Datadog
 
         def parse_traceparent_string(traceparent)
           return unless traceparent
+          return if traceparent.bytesize > TRACEPARENT_MAX_SIZE_LIMIT
+
+          traceparent = traceparent.strip
 
-          version, trace_id, parent_id, trace_flags, extra = traceparent.strip.split('-')
+          version, trace_id, parent_id, trace_flags, extra = traceparent.split("-", 5)
 
-          return if version.size != 2 || version[0] < '0' || version[0] > 'f' || version[1] < '0' || version[1] > 'f'
+          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 == INVALID_VERSION
 
           # Extra fields are not allowed in version 00, but we have to be lenient for future versions.
           return if version == SPEC_VERSION && extra
 
-          # Invalid field sizes
-          return if trace_id.size != 32 || parent_id.size != 16 || trace_flags.size != 2
-
           [Integer(trace_id, 16), Integer(parent_id, 16), Integer(trace_flags, 16)]
         rescue ArgumentError # Conversion to integer failed
           nil
@@ -301,15 +285,19 @@ module Datadog
           trace_flags & TRACE_FLAGS_SAMPLED
         end
 
-        # @return [Array<String,Integer,String,String,Hash>] returns 4 values:
-        # tracestate, sampling_priority, ts_parent_id, origin, tags.
+        # @return [nil] when the tracestate is absent or has no vendor entries.
+        # @return [String] when no `dd=` entry is present, the joined vendor list.
+        # @return [Array(String, Integer, String, String, Hash, String)] when a `dd=`
+        #   entry is present: [tracestate without `dd=`, sampling_priority, origin,
+        #   ts_parent_id, tags, unknown_fields]. All elements past the first may be nil.
         def extract_tracestate(tracestate)
-          return unless tracestate
-
           vendors = split_tracestate(tracestate)
+          return unless vendors && !vendors.empty?
+
+          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
@@ -318,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)
@@ -329,14 +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'
-              sampling_priority = Integer(value) rescue nil
-            when 'o'
+            when "s"
+              sampling_priority = begin
+                Integer(value)
+              rescue
+                nil
+              end
+            when "o"
               origin = value
-            when 'p'
+            when "p"
               ts_parent_id = value
             when /^t\./
               key.slice!(0..1) # Delete `t.` prefix
@@ -350,9 +342,9 @@ module Datadog
               tags ||= {}
               tags["#{Tracing::Metadata::Ext::Distributed::TAGS_PREFIX}#{key}"] = value
             else
-              unknown_fields ||= String.new
+              unknown_fields ||= +""
               unknown_fields << pair
-              unknown_fields << ';'
+              unknown_fields << ";"
             end
           end
 
@@ -361,7 +353,7 @@ module Datadog
 
         # Restore `~` back to `=`.
         def deserialize_tag_value(value)
-          value.tr!('~', '=')
+          value.tr!("~", "=")
           value
         end
 
@@ -390,13 +382,50 @@ module Datadog
           end
         end
 
+        # We MUST NOT propagate partial members, but we SHOULD try
+        # to parse as much of the tracestate as possible.
         def split_tracestate(tracestate)
-          tracestate.split(/[ \t]*+,[ \t]*+/)[0..31]
+          return unless tracestate
+
+          remove_last_member = false
+          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) != ","
+
+            # To ensure we don't have a trailing partial UTF-8 codepoint, we keep one extra byte
+            # and safely remove it with `#chop`.
+            # `#chop` walks back the string until it finds a valid character boundary and deletes
+            # from there.
+            tracestate = tracestate.byteslice(0, TRACESTATE_MAX_SIZE_LIMIT + 1) #: String
+            tracestate = tracestate.chop
+          end
+
+          tracestate = ::Datadog::Core::Utils.utf8_encode(tracestate, placeholder: nil)
+          return unless tracestate
+
+          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
         end
 
+        TRACEPARENT_MAX_SIZE_LIMIT = 512
+        private_constant :TRACEPARENT_MAX_SIZE_LIMIT
+
+        TRACESTATE_MAX_SIZE_LIMIT = 512
+        private_constant :TRACESTATE_MAX_SIZE_LIMIT
+
+        TRACESTATE_MAX_LIST_MEMBERS = 32
+        private_constant :TRACESTATE_MAX_LIST_MEMBERS
+
         # 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
@@ -59,13 +59,11 @@ module Datadog
 
       def publish(*args)
         subscriptions.each do |block|
-          begin
-            block.call(*args)
-          rescue StandardError => e
-            Datadog.logger.debug do
-              "Error while handling '#{name}' event with '#{block}': #{e.class.name} #{e.message} " \
-              "at #{Array(e.backtrace).first}"
-            end
+          block.call(*args)
+        rescue => e
+          Datadog.logger.debug do
+            "Error while handling '#{name}' event with '#{block}': #{e.class}: #{e.message} " \
+            "at #{Array(e.backtrace).first}"
           end
         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/flush.rb

@@ -59,7 +59,7 @@ module Datadog
       class Finished < Base
         # Are all spans finished?
         def flush?(trace_op)
-          trace_op && trace_op.finished?
+          trace_op&.finished?
         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
@@ -12,7 +12,7 @@ module Datadog
           case key
           when Ext::Analytics::TAG_ENABLED
             # If true, set rate to 1.0, otherwise set 0.0.
-            value = value == true ? Ext::Analytics::DEFAULT_SAMPLE_RATE : 0.0
+            value = (value == true) ? Ext::Analytics::DEFAULT_SAMPLE_RATE : 0.0
             Tracing::Analytics.set_sample_rate(self, value)
           when Ext::Analytics::TAG_SAMPLE_RATE
             Tracing::Analytics.set_sample_rate(self, value)

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../../core/error'
+require_relative "../../core/error"
 
-require_relative 'ext'
+require_relative "ext"
 
 module Datadog
   module Tracing
@@ -10,17 +10,17 @@ module Datadog
       # Adds error tagging behavior
       # @public_api
       module Errors
-        def set_error(e)
+        def set_error(error)
           Datadog::Core.log_deprecation do
-            'Errors.set_error(..) is deprecated. ' \
-            'Use Errors.set_error_tags(..) instead.'
+            "Errors.set_error(..) is deprecated. " \
+            "Use Errors.set_error_tags(..) instead."
           end
-          set_error_tags(e)
+          set_error_tags(error)
         end
 
         # Mark the span with the given error.
-        def set_error_tags(e)
-          e = Core::Error.build_from(e)
+        def set_error_tags(error)
+          e = Core::Error.build_from(error)
 
           set_tag(Ext::Errors::TAG_TYPE, e.type) unless e.type.empty?
           set_tag(Ext::Errors::TAG_MSG, e.message) unless e.message.empty?