datadog 2.30.0 → 2.32.0

data/lib/datadog/tracing/contrib/mongodb/subscribers.rb

@@ -73,7 +73,7 @@ module Datadog
             # set the resource with the quantized query
             span.resource = serialized_query
           rescue => e
-            Datadog.logger.debug("error when handling MongoDB 'started' event: #{e}")
+            Datadog.logger.debug("error when handling MongoDB 'started' event: #{e.class}: #{e.message}")
           end
           # rubocop:enable Metrics/AbcSize
 
@@ -85,7 +85,7 @@ module Datadog
             # the framework itself, so we set only the error and the message
             span.set_error(event)
           rescue => e
-            Datadog.logger.debug("error when handling MongoDB 'failed' event: #{e}")
+            Datadog.logger.debug("error when handling MongoDB 'failed' event: #{e.class}: #{e.message}")
           ensure
             # whatever happens, the Span must be removed from the local storage and
             # it must be finished to prevent any leak
@@ -101,7 +101,7 @@ module Datadog
             rows = event.reply.fetch('n', nil)
             span.set_tag(Ext::TAG_ROWS, rows) unless rows.nil?
           rescue => e
-            Datadog.logger.debug("error when handling MongoDB 'succeeded' event: #{e}")
+            Datadog.logger.debug("error when handling MongoDB 'succeeded' event: #{e.class}: #{e.message}")
           ensure
             # whatever happens, the Span must be removed from the local storage and
             # it must be finished to prevent any leak

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

@@ -84,7 +84,7 @@ module Datadog
                 span.resource = "#{method} #{quantized_url}"
                 Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
               rescue => e
-                Datadog.logger.error(e.message)
+                Datadog.logger.error("#{e.class}: #{e.message}")
                 Datadog::Core::Telemetry::Logger.report(e)
                 # TODO: Refactor the code to streamline the execution without ensure
               ensure

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

@@ -28,7 +28,7 @@ module Datadog
                     span.type = Tracing::Metadata::Ext::SQL::TYPE
                     span.set_tag(Ext::TAG_QUERY_ASYNC, false)
                   rescue => e
-                    Datadog.logger.debug("error preparing span for presto: #{e}")
+                    Datadog.logger.debug("error preparing span for presto: #{e.class}: #{e.message}")
                   end
 
                   super(query)
@@ -46,7 +46,7 @@ module Datadog
                     span.type = Tracing::Metadata::Ext::SQL::TYPE
                     span.set_tag(Ext::TAG_QUERY_ASYNC, !blk.nil?)
                   rescue => e
-                    Datadog.logger.debug("error preparing span for presto: #{e}")
+                    Datadog.logger.debug("error preparing span for presto: #{e.class}: #{e.message}")
                   end
 
                   super(query, &blk)
@@ -65,7 +65,7 @@ module Datadog
                     # ^ not an SQL type span, since there's no SQL query
                     span.set_tag(Ext::TAG_QUERY_ID, query_id)
                   rescue => e
-                    Datadog.logger.debug("error preparing span for presto: #{e}")
+                    Datadog.logger.debug("error preparing span for presto: #{e.class}: #{e.message}")
                   end
 
                   super(query_id)

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

@@ -41,7 +41,7 @@ module Datadog
             # context of middleware patching outside a Rails server process (eg. a
             # process that doesn't serve HTTP requests but has Rails environment
             # loaded such as a Resque master process)
-            Datadog.logger.debug("Error patching middleware stack: #{e}")
+            Datadog.logger.debug("Error patching middleware stack: #{e.class}: #{e.message}")
           end
 
           def retain_middleware_name(middleware)

data/lib/datadog/tracing/contrib/rack/request_queue.rb

@@ -39,7 +39,7 @@ module Datadog
           rescue => e
             # in case of an Exception we don't create a
             # `request.queuing` span
-            Datadog.logger.debug("[rack] unable to parse request queue headers: #{e}")
+            Datadog.logger.debug("[rack] unable to parse request queue headers: #{e.class}: #{e.message}")
             nil
           end
         end

data/lib/datadog/tracing/contrib/rails/log_injection.rb

@@ -18,7 +18,7 @@ module Datadog
             app_config.log_tags << proc { Tracing.log_correlation if Datadog.configuration.tracing.log_injection }
           rescue => e
             Datadog.logger.warn(
-              "Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.class.name} #{e.message}"
+              "Unable to add Datadog Trace context to ActiveSupport::TaggedLogging: #{e.class}: #{e.message}"
             )
             false
           end

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

@@ -6,7 +6,6 @@ require_relative 'framework'
 require_relative 'log_injection'
 require_relative 'middlewares'
 require_relative 'runner'
-require_relative '../../../core/contrib/rails/utils'
 require_relative '../semantic_logger/patcher'
 
 module Datadog

data/lib/datadog/tracing/contrib/rails/runner.rb

@@ -86,7 +86,7 @@ module Datadog
                 # Reads one more byte than the limit to allow us to check if the source exceeds the limit.
                 source = File.read(file, MAX_TAG_VALUE_SIZE + 1)
               rescue => e
-                Datadog.logger.debug("Failed to read file '#{file}' for Rails runner: #{e.message}")
+                Datadog.logger.debug { "Failed to read file '#{file}' for Rails runner: #{e.class}: #{e.message}" }
               end
 
               Tracing.trace(

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

@@ -66,7 +66,7 @@ module Datadog
               span.set_tag(Ext::TAG_TASK_ARG_NAMES, arg_names)
               span.set_tag(Ext::TAG_INVOKE_ARGS, quantize_args(args)) unless args.nil?
             rescue => e
-              Datadog.logger.debug("Error while tracing Rake invoke: #{e.class.name} #{e.message}")
+              Datadog.logger.debug { "Error while tracing Rake invoke: #{e.class}: #{e.message}" }
             end
 
             def annotate_execute!(span, args)
@@ -75,7 +75,7 @@ module Datadog
               span.set_tag(Tracing::Metadata::Ext::TAG_OPERATION, Ext::TAG_OPERATION_EXECUTE)
               span.set_tag(Ext::TAG_EXECUTE_ARGS, quantize_args(args.to_hash)) unless args.nil?
             rescue => e
-              Datadog.logger.debug("Error while tracing Rake execute: #{e.class.name} #{e.message}")
+              Datadog.logger.debug { "Error while tracing Rake execute: #{e.class}: #{e.message}" }
             end
 
             def quantize_args(args)

data/lib/datadog/tracing/contrib/redis/quantize.rb

@@ -34,7 +34,7 @@ module Datadog
             str = Core::Utils.utf8_encode(arg, binary: true, placeholder: PLACEHOLDER)
             Core::Utils.truncate(str, VALUE_MAX_LEN, TOO_LONG_MARK)
           rescue => e
-            Datadog.logger.debug("non formattable Redis arg #{str}: #{e}")
+            Datadog.logger.debug("non formattable Redis arg #{str}: #{e.class}: #{e.message}")
             PLACEHOLDER
           end
 

data/lib/datadog/tracing/contrib/redis/tags.rb

@@ -47,7 +47,7 @@ module Datadog
 
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
             rescue => e
-              Datadog.logger.error(e.message)
+              Datadog.logger.error("#{e.class}: #{e.message}")
               Datadog::Core::Telemetry::Logger.report(e)
             end
 

data/lib/datadog/tracing/contrib/sidekiq/utils.rb

@@ -25,7 +25,7 @@ module Datadog
               job['class'].to_s
             end
           rescue => e
-            Datadog.logger.debug { "Error retrieving Sidekiq job class name (jid:#{job["jid"]}): #{e}" }
+            Datadog.logger.debug { "Error retrieving Sidekiq job class name (jid:#{job["jid"]}): #{e.class}: #{e.message}" }
 
             job['class'].to_s
           end

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

@@ -27,6 +27,10 @@ module Datadog
             end
           end
         end
+
+        def to_s
+          @ranges.map { |range| range.is_a?(Range) ? "#{range.begin}-#{range.end}" : range.to_s }.join(',')
+        end
       end
     end
   end

data/lib/datadog/tracing/contrib/stripe/request.rb

@@ -55,7 +55,7 @@ module Datadog
             span.set_tag(Ext::TAG_REQUEST_PATH, event.path)
             span.set_tag(Ext::TAG_REQUEST_NUM_RETRIES, event.num_retries.to_s)
           rescue => e
-            Datadog.logger.debug(e.message)
+            Datadog.logger.debug { "#{e.class}: #{e.message}" }
           end
 
           def configuration

data/lib/datadog/tracing/contrib.rb

@@ -81,3 +81,11 @@ require_relative 'contrib/sneakers/integration'
 require_relative 'contrib/stripe/integration'
 require_relative 'contrib/sucker_punch/integration'
 require_relative 'contrib/trilogy/integration'
+
+# This list is used to determine if an integration is a built-in integration,
+# and prevent sending telemetry for custom integrations.
+# To do this, we get the list of registered integrations at this point and freeze it.
+# Later, when custom integrations are registered, they will not be included in this list.
+# .uniq to handle aliases, as we can register the same integration multiple times with different names.
+Datadog::Tracing::Contrib::BUILT_IN_INTEGRATIONS =
+  Datadog::Tracing::Contrib::REGISTRY.map { |entry| entry.klass }.uniq.freeze

data/lib/datadog/tracing/diagnostics/environment_logger.rb

@@ -24,7 +24,9 @@ module Datadog
             end
           end
         rescue => e
-          logger.warn("Failed to collect tracing environment information: #{e} Location: #{Array(e.backtrace).first}")
+          logger.warn(
+            "Failed to collect tracing environment information: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
+          )
         end
       end
 

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

@@ -77,7 +77,7 @@ module Datadog
             # Record telemetry for successful injection
             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}")
+            ::Datadog.logger.warn("Failed to encode and inject baggage header: #{e.class}: #{e.message}")
           end
         end
 
@@ -133,12 +133,56 @@ module Datadog
         # - Keys and values are URL-encoded
         # - Returns an empty hash if the baggage header is malformed
         #
+        # For entries with duplicate keys, only last one is preserved:
+        # https://www.w3.org/TR/2024/CR-baggage-20240530/#mutating-baggage
+        #
         # @param baggage_header [String] The W3C Baggage header string to parse
         # @return [Hash<String, String>] A hash of decoded baggage items
         def parse_baggage_header(baggage_header)
+          # Reject inputs that would cause String operations below to raise.
+          # `valid_encoding?` is true for ASCII-8BIT regardless of byte values, so
+          # 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'})
+            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'})
+
+            # We MUST NOT propagate partial entries, but we SHOULD try
+            # to parse as much of the baggage as possible:
+            # https://www.w3.org/TR/2024/CR-baggage-20240530/#limits
+
+            # 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) != ','
+
+            # To ensure we don't have a trailing partial UTF-8 codepoint, we keep one extra byte
+            # and safely remove it with `#chop`.
+            # `#chops` walks back the string until it finds a valid character boundary and deletes
+            # from there.
+            baggage_header = baggage_header.byteslice(0, DD_TRACE_BAGGAGE_MAX_BYTES + 1) #: String
+            baggage_header = baggage_header.chop
+          end
+
           baggage = {}
-          baggages = baggage_header.split(',')
-          baggages.each do |key_value|
+          # 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.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'})
+              break
+            end
+
+            # On truncation, remove incomplete trailing partial entry
+            next if remove_last_entry && index == baggages.size - 1
+
+            # Empty items are skipped
+            next if key_value.strip.empty?
+
             key, value = key_value.split('=', 2)
             # If baggage is malformed, return an empty hash
             if key.nil? || value.nil?
@@ -147,8 +191,17 @@ module Datadog
               return {}
             end
 
-            key = URI.decode_www_form_component(key.strip)
-            value = URI.decode_www_form_component(value.strip)
+            begin
+              key = URI.decode_www_form_component(key.strip)
+              value = URI.decode_www_form_component(value.strip)
+            rescue ArgumentError
+              # `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'})
+              return {}
+            end
+
             if key.empty? || value.empty?
               # Record telemetry for malformed header
               record_telemetry_metric('context_header_style.malformed', 1, {'header_style' => 'baggage'})
@@ -157,6 +210,7 @@ module Datadog
 
             baggage[key] = value
           end
+
           baggage
         end
 

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

@@ -131,17 +131,15 @@ module Datadog
 
           encoded_tags = DatadogTagsCodec.encode(tags)
 
-          return set_tags_propagation_error(reason: 'inject_max_size') if tags_too_large?(
-            encoded_tags.size,
-            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')
           ::Datadog.logger.warn(
-            "Failed to inject x-datadog-tags: #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+            "Failed to inject x-datadog-tags: #{e.class}: #{e.message} at #{Array(e.backtrace).first}"
           )
+          nil
         end
 
         # Import `x-datadog-tags` tags as trace distributed tags.
@@ -155,7 +153,7 @@ module Datadog
 
           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.size, scenario: 'extract')
+          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
@@ -166,8 +164,9 @@ module Datadog
         rescue => e
           set_tags_propagation_error(reason: 'decoding_error')
           ::Datadog.logger.warn(
-            "Failed to extract x-datadog-tags: #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+            "Failed to extract x-datadog-tags: #{e.class}: #{e.message} at #{Array(e.backtrace).first}"
           )
+          nil
         end
 
         def set_tags_propagation_error(reason:)
@@ -180,12 +179,15 @@ module Datadog
           ::Datadog.configuration.tracing.x_datadog_tags_max_length <= 0
         end
 
-        def tags_too_large?(size, scenario:)
-          return false if size <= ::Datadog.configuration.tracing.x_datadog_tags_max_length
+        def tags_too_large?(tags, scenario:)
+          size = tags.bytesize
+          max_length = ::Datadog.configuration.tracing.x_datadog_tags_max_length
+
+          return false if size <= max_length
 
           ::Datadog.logger.warn(
-            "Failed to #{scenario} x-datadog-tags: tags are too large for configured limit (size:#{size} >= " \
-              "limit:#{::Datadog.configuration.tracing.x_datadog_tags_max_length}). This limit can be configured " \
+            "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.'
           )
 

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

@@ -41,7 +41,7 @@ module Datadog
             "#{key}=#{value.strip}"
           end.join(',')
         rescue => e
-          raise EncodingError, "Error encoding tags `#{tags}`: `#{e}`"
+          raise EncodingError, "Error encoding tags `#{tags}`: `#{e.class}: #{e.message}`"
         end
 
         # Deserializes a `x-datadog-tags`-formatted String into a {Hash<String,String>}.

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

@@ -76,7 +76,7 @@ module Datadog
           rescue => e
             result = nil
             ::Datadog.logger.error(
-              "Error injecting distributed trace data. Cause: #{e} Location: #{Array(e.backtrace).first}"
+              "Error injecting distributed trace data. Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
             )
             ::Datadog::Core::Telemetry::Logger.report(
               e,
@@ -139,7 +139,7 @@ module Datadog
           rescue => e
             # TODO: Not to report Telemetry logs for now
             ::Datadog.logger.error(
-              "Error extracting distributed trace data. Cause: #{e} Location: #{Array(e.backtrace).first}"
+              "Error extracting distributed trace data. Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
             )
           end
           # Handle baggage after all other styles if present

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

@@ -149,9 +149,9 @@ module Datadog
         # @see https://www.w3.org/TR/trace-context/#tracestate-header
         def build_tracestate(digest)
           tracestate = +'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
+          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.
@@ -159,45 +159,50 @@ module Datadog
             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
 
-            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
@@ -281,19 +286,21 @@ module Datadog
 
         def parse_traceparent_string(traceparent)
           return unless traceparent
+          return if traceparent.bytesize > TRACEPARENT_MAX_SIZE_LIMIT
 
-          version, trace_id, parent_id, trace_flags, extra = traceparent.strip.split('-')
+          traceparent = traceparent.strip
 
-          return if version.size != 2 || version[0] < '0' || version[0] > 'f' || version[1] < '0' || version[1] > 'f'
+          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 == 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
@@ -306,9 +313,10 @@ module Datadog
         # @return [Array<String,Integer,String,String,Hash>] returns 4 values:
         # tracestate, sampling_priority, ts_parent_id, origin, tags.
         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=') }
@@ -396,10 +404,44 @@ 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
+
+          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'

data/lib/datadog/tracing/event.rb

@@ -62,7 +62,7 @@ module Datadog
           block.call(*args)
         rescue => e
           Datadog.logger.debug do
-            "Error while handling '#{name}' event with '#{block}': #{e.class.name} #{e.message} " \
+            "Error while handling '#{name}' event with '#{block}': #{e.class}: #{e.message} " \
             "at #{Array(e.backtrace).first}"
           end
         end

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

@@ -52,7 +52,7 @@ module Datadog
             meta[Core::Utils.utf8_encode(key)] = Core::Utils.utf8_encode(value)
           end
         rescue => e
-          Datadog.logger.debug("Unable to set the tag #{key}, ignoring it. Caused by: #{e}")
+          Datadog.logger.debug("Unable to set the tag #{key}, ignoring it. Caused by: #{e.class}: #{e.message}")
         end
 
         # Sets tags from given hash, for each key in hash it sets the tag with that key
@@ -102,7 +102,7 @@ module Datadog
           # Encode strings in UTF-8 to facilitate downstream serialization
           metrics[Core::Utils.utf8_encode(key)] = value
         rescue => e
-          Datadog.logger.debug("Unable to set the metric #{key}, ignoring it. Caused by: #{e}")
+          Datadog.logger.debug("Unable to set the metric #{key}, ignoring it. Caused by: #{e.class}: #{e.message}")
         end
 
         # This method removes a metric for the given key. It acts like {#clear_tag}.

data/lib/datadog/tracing/pipeline.rb

@@ -51,7 +51,7 @@ module Datadog
         end
       rescue => e
         Datadog.logger.debug(
-          "trace dropped entirely due to `Pipeline.before_flush` error: #{e}"
+          "trace dropped entirely due to `Pipeline.before_flush` error: #{e.class}: #{e.message}"
         )
 
         nil

data/lib/datadog/tracing/remote.rb

@@ -43,7 +43,7 @@ module Datadog
 
           Datadog.send(:components).telemetry.client_configuration_change!(env_vars)
         rescue => e
-          content.errored("#{e.class.name} #{e.message}: #{Array(e.backtrace).join("\n")}")
+          content.errored("#{e.class}: #{e.message}: #{Array(e.backtrace).join("\n")}")
         end
 
         def receivers(_telemetry)

data/lib/datadog/tracing/sampling/ext.rb

@@ -47,6 +47,8 @@ module Datadog
           MANUAL = '-4'
           # Formerly AppSec.
           ASM = '-5'
+          # AI Guard.
+          AI_GUARD = '-13'
           # Dynamically configured rule, explicitly created by the user.
           REMOTE_USER_RULE = '-11'
           # Dynamically configured  rule, automatically generated by Datadog.

data/lib/datadog/tracing/sampling/priority_sampler.rb

@@ -77,6 +77,19 @@ module Datadog
           end
         end
 
+        def reconsider_sample_resource!(trace)
+          return unless @priority_sampler.respond_to?(:reconsider_sample_resource!)
+
+          preserving_sampling(trace) do
+            @priority_sampler.reconsider_sample_resource!(trace)
+          end
+        end
+
+        def resource_sampling?
+          @priority_sampler.respond_to?(:resource_sampling?) &&
+            @priority_sampler.resource_sampling?
+        end
+
         # (see Datadog::Tracing::Sampling::RateByServiceSampler#update)
         def update(rate_by_service, decision: nil)
           @priority_sampler.update(rate_by_service, decision: decision)