datadog 2.12.0 → 2.22.0

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

@@ -0,0 +1,196 @@
+# 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'
+
+module Datadog
+  module Tracing
+    module Distributed
+      # W3C Baggage propagator implementation.
+      # The baggage header is propagated through `baggage`.
+      # @see https://www.w3.org/TR/baggage/
+      class Baggage
+        BAGGAGE_KEY = 'baggage'
+        DD_TRACE_BAGGAGE_MAX_ITEMS = 64
+        DD_TRACE_BAGGAGE_MAX_BYTES = 8192
+        BAGGAGE_TAG_KEYS_MATCH_ALL = ['*'].freeze
+        SAFE_CHARACTERS_KEY = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789$!#&'*+-.^_`|~"
+        SAFE_CHARACTERS_VALUE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789$!#&'()*+-./:<>?@[]^_`{|}~"
+
+        def initialize(
+          fetcher:,
+          baggage_key: BAGGAGE_KEY,
+          baggage_tag_keys: ::Datadog.configuration.tracing.baggage_tag_keys
+        )
+          @baggage_key = baggage_key
+          @fetcher = fetcher
+          @baggage_tag_keys = baggage_tag_keys
+        end
+
+        def inject!(digest, data)
+          return if digest.nil? || digest.baggage.nil?
+
+          baggage_items = digest.baggage.reject { |k, v| k.nil? || v.nil? }
+          return if baggage_items.empty?
+
+          begin
+            if baggage_items.size > DD_TRACE_BAGGAGE_MAX_ITEMS
+              ::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',
+                1,
+                {'header_style' => 'baggage', 'truncation_reason' => 'baggage_item_count_exceeded'}
+              )
+              baggage_items = baggage_items.first(DD_TRACE_BAGGAGE_MAX_ITEMS)
+            end
+
+            encoded_items = []
+            total_size = 0
+
+            baggage_items.each do |key, value|
+              item = "#{encode_item(key, SAFE_CHARACTERS_KEY)}=#{encode_item(value, SAFE_CHARACTERS_VALUE)}"
+              item_size = item.bytesize + (encoded_items.empty? ? 0 : 1) # +1 for comma if not first item
+              if total_size + item_size > DD_TRACE_BAGGAGE_MAX_BYTES
+                ::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',
+                  1,
+                  {'header_style' => 'baggage', 'truncation_reason' => 'baggage_byte_count_exceeded'}
+                )
+                break # stop adding items when size limit is reached
+              end
+              encoded_items << item
+              total_size += item_size
+            end
+
+            # edge case where a single item is too large
+            return if encoded_items.empty?
+
+            data[@baggage_key] = encoded_items.join(',')
+
+            # 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}")
+          end
+        end
+
+        def extract(data)
+          fetcher = @fetcher.new(data)
+          data = fetcher[@baggage_key]
+          return unless data
+
+          baggage = parse_baggage_header(fetcher[@baggage_key])
+          return unless baggage
+
+          # Convert selected baggage items to span tags based on configuration
+          baggage_tags = build_baggage_tags(baggage)
+
+          # 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'})
+          end
+
+          TraceDigest.new(
+            baggage: baggage,
+            trace_distributed_tags: baggage_tags
+          )
+        end
+
+        private
+
+        def encode_item(item, safe_characters)
+          # 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')
+          # 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/
+              hex_str = encoded[1..2]
+              next encoded unless hex_str && !hex_str.empty?
+
+              # Convert hex representation back to character
+              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
+              encoded
+            end
+          end
+        end
+
+        # Parses a W3C Baggage header string into a hash of key-value pairs
+        # The header format follows the W3C Baggage specification:
+        # - Multiple baggage items are separated by commas
+        # - Each baggage item is a key-value pair separated by '='
+        # - Keys and values are URL-encoded
+        # - Returns an empty hash if the baggage header is malformed
+        #
+        # @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)
+          baggage = {}
+          baggages = baggage_header.split(',')
+          baggages.each do |key_value|
+            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'})
+              return {}
+            end
+
+            key = URI.decode_www_form_component(key.strip)
+            value = URI.decode_www_form_component(value.strip)
+            if key.empty? || value.empty?
+              # Record telemetry for malformed header
+              record_telemetry_metric('context_header_style.malformed', 1, {'header_style' => 'baggage'})
+              return {}
+            end
+
+            baggage[key] = value
+          end
+          baggage
+        end
+
+        # Convert selected baggage items to span tags
+        # Baggage carries important contextual information (like user.id, session.id) across distributed services,
+        # but isn't searchable by default.
+        def build_baggage_tags(baggage)
+          return {} if baggage.empty?
+
+          # Get the configuration for which baggage keys should become span tags
+          baggage_tag_keys = @baggage_tag_keys
+          return {} if baggage_tag_keys.empty?
+
+          # If wildcard is specified, use all baggage keys
+          baggage_tag_keys = baggage if baggage_tag_keys == BAGGAGE_TAG_KEYS_MATCH_ALL
+
+          tags = {}
+
+          baggage_tag_keys.each do |key, _| # rubocop:disable Style/HashEachMethods
+            value = baggage[key]
+            next if value.nil? || value.empty?
+
+            tags["baggage.#{key}"] = value
+          end
+
+          tags
+        end
+
+        # 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)
+        end
+      end
+    end
+  end
+end

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

@@ -55,17 +55,16 @@ module Datadog
         def extract(data)
           fetcher = @fetcher.new(data)
 
-          trace_id  = parse_trace_id(fetcher)
+          trace_id = parse_trace_id(fetcher)
           parent_id = parse_parent_id(fetcher)
 
           sampling_priority = Helpers.parse_decimal_id(fetcher[@sampling_priority_key])
           origin = fetcher[@origin_key]
 
           # Return early if this propagation is not valid
-          # DEV: To be valid we need to have a trace id and a parent id
-          #      or when it is a synthetics trace, just the trace id.
+          # DEV: To be valid we need to have a trace id and a parent id or an origin id.
           # DEV: `Fetcher#id` will not return 0
-          return unless (trace_id && parent_id) || (origin && trace_id)
+          return if trace_id.nil? || parent_id.nil? && origin.nil?
 
           trace_distributed_tags = extract_tags(fetcher)
 
@@ -89,7 +88,7 @@ module Datadog
           trace_id = Helpers.parse_decimal_id(fetcher_object[@trace_id_key])
 
           return unless trace_id
-          return if trace_id <= 0 || trace_id >= Tracing::Utils::EXTERNAL_MAX_ID
+          return if trace_id <= 0 || trace_id > Tracing::Utils::EXTERNAL_MAX_ID
 
           trace_id
         end
@@ -98,7 +97,7 @@ module Datadog
           parent_id = Helpers.parse_decimal_id(fetcher_object[@parent_id_key])
 
           return unless parent_id
-          return if parent_id <= 0 || parent_id >= Tracing::Utils::EXTERNAL_MAX_ID
+          return if parent_id <= 0 || parent_id > Tracing::Utils::EXTERNAL_MAX_ID
 
           parent_id
         end
@@ -116,6 +115,8 @@ module Datadog
         def extract_trace_id!(trace_id, tags)
           return trace_id unless tags
           return trace_id unless (high_order = tags.delete(Tracing::Metadata::Ext::Distributed::TAG_TID))
+          return trace_id unless high_order.size == 16
+          return trace_id unless /\A[0-9a-f]+\z/i.match?(high_order)
 
           Tracing::Utils::TraceId.concatenate(high_order.to_i(16), trace_id)
         end
@@ -171,7 +172,7 @@ module Datadog
 
         def set_tags_propagation_error(reason:)
           active_trace = Tracing.active_trace
-          active_trace.set_tag('_dd.propagation_error', reason) if active_trace
+          active_trace&.set_tag('_dd.propagation_error', reason)
           nil
         end
 

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

@@ -31,19 +31,17 @@ module Datadog
         # @return [String] serialized tags hash
         # @raise [EncodingError] if tags cannot be serialized to the `x-datadog-tags` format
         def self.encode(tags)
-          begin
-            tags.map do |raw_key, raw_value|
-              key = raw_key.to_s
-              value = raw_value.to_s
+          tags.map do |raw_key, raw_value|
+            key = raw_key.to_s
+            value = raw_value.to_s
 
-              raise EncodingError, "Invalid key `#{key}` for value `#{value}`" unless VALID_KEY_CHARS.match?(key)
-              raise EncodingError, "Invalid value `#{value}` for key `#{key}`" unless VALID_VALUE_CHARS.match?(value)
+            raise EncodingError, "Invalid key `#{key}` for value `#{value}`" unless VALID_KEY_CHARS.match?(key)
+            raise EncodingError, "Invalid value `#{value}` for key `#{key}`" unless VALID_VALUE_CHARS.match?(value)
 
-              "#{key}=#{value.strip}"
-            end.join(',')
-          rescue => e
-            raise EncodingError, "Error encoding tags `#{tags}`: `#{e}`"
-          end
+            "#{key}=#{value.strip}"
+          end.join(',')
+        rescue => e
+          raise EncodingError, "Error encoding tags `#{tags}`: `#{e}`"
         end
 
         # Deserializes a `x-datadog-tags`-formatted String into a {Hash<String,String>}.
@@ -52,7 +50,7 @@ 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 = Hash[string.split(',').map do |raw_tag|
+          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
@@ -62,7 +60,7 @@ module Datadog
 
               value.strip!
             end
-          end]
+          end).to_h
 
           raise DecodingError, "Invalid empty tags: #{string}" if result.empty? && !string.empty?
 

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

@@ -25,7 +25,7 @@ module Datadog
 
           value = value.to_s
 
-          num   = value.to_i
+          num = value.to_i
 
           # Ensure the parsed number is the same as the original string value
           # e.g. We want to make sure to throw away `'nan'.to_i == 0`

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

@@ -8,10 +8,12 @@ module Datadog
       # @see https://github.com/open-telemetry/opentelemetry-specification/blob/255a6c52b8914a2ed7e26bb5585abecab276aafc/specification/sdk-environment-variables.md?plain=1#L88
       class None
         # No-op
-        def inject!(_digest, _data); end
+        def inject!(_digest, _data)
+        end
 
         # No-op
-        def extract(_data); end
+        def extract(_data)
+        end
       end
     end
   end

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

@@ -4,6 +4,7 @@ require_relative '../configuration/ext'
 require_relative '../trace_digest'
 require_relative '../trace_operation'
 require_relative '../../core/telemetry/logger'
+require_relative 'baggage'
 
 module Datadog
   module Tracing
@@ -26,9 +27,13 @@ module Datadog
         )
           @propagation_styles = propagation_styles
           @propagation_extract_first = propagation_extract_first
-
           @propagation_style_inject = propagation_style_inject.map { |style| propagation_styles[style] }
           @propagation_style_extract = propagation_style_extract.map { |style| propagation_styles[style] }
+
+          # The baggage propagator is unique in that baggage should always be extracted, if present.
+          # Therefore we remove it from the `propagation_style_extract` list.
+          @baggage_propagator = @propagation_style_extract.find { |propagator| propagator.is_a?(Baggage) }
+          @propagation_style_extract.delete(@baggage_propagator) if @baggage_propagator
         end
 
         # inject! populates the env with span ID, trace ID and sampling priority
@@ -57,9 +62,8 @@ module Datadog
           end
 
           digest = digest.to_digest if digest.respond_to?(:to_digest)
-
-          if digest.trace_id.nil?
-            ::Datadog.logger.debug('Cannot inject distributed trace data: digest.trace_id is nil.')
+          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.')
             return nil
           end
 
@@ -138,12 +142,32 @@ module Datadog
               "Error extracting distributed trace data. Cause: #{e} Location: #{Array(e.backtrace).first}"
             )
           end
+          # Handle baggage after all other styles if present
+          extracted_trace_digest = propagate_baggage(data, extracted_trace_digest) if @baggage_propagator
 
           extracted_trace_digest
         end
 
         private
 
+        def propagate_baggage(data, extracted_trace_digest)
+          if extracted_trace_digest
+            # Merge with baggage if present
+            digest = @baggage_propagator.extract(data)
+            if digest
+              extracted_trace_digest.merge(
+                baggage: digest.baggage,
+                trace_distributed_tags: digest.trace_distributed_tags
+              )
+            else
+              extracted_trace_digest
+            end
+          else
+            # Baggage is the only style
+            @baggage_propagator.extract(data)
+          end
+        end
+
         def last_datadog_parent_id(headers, tracecontext_tags)
           dd_propagator = @propagation_style_extract.find { |propagator| propagator.is_a?(Datadog) }
           if tracecontext_tags&.fetch(

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Distributed
+      # Helper method to decide when to skip distributed tracing
+      module PropagationPolicy
+        module_function
+
+        # Skips distributed tracing if disabled for this instrumentation
+        # or if APM is disabled unless there is an AppSec event (from upstream distributed trace or local)
+        #
+        # Both pin_config and global_config are configuration for integrations.
+        # pin_config is a Datadog::Core::Pin object, which gives the configuration of a single instance of an integration.
+        # global_config is the config for all instances of an integration.
+        def enabled?(pin_config: nil, global_config: nil, trace: nil)
+          return false unless Tracing.enabled?
+
+          unless ::Datadog.configuration.apm.tracing.enabled
+            return false if trace.nil?
+
+            trace_source = trace.get_tag(::Datadog::Tracing::Metadata::Ext::Distributed::TAG_TRACE_SOURCE)&.to_i(16)
+            return false if trace_source.nil?
+
+            # If AppSec is enabled and AppSec bit is set in the trace, we should not skip distributed tracing
+            # Other products that will use dd.p.ts should implement similar behavior here
+            if ::Datadog.configuration.appsec.enabled && (trace_source & ::Datadog::AppSec::Ext::PRODUCT_BIT) != 0
+              return true
+            end
+
+            return false
+          end
+
+          return pin_config[:distributed_tracing] if pin_config&.key?(:distributed_tracing)
+          return global_config[:distributed_tracing] if global_config
+
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -52,7 +52,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
 
@@ -128,7 +128,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,12 +148,14 @@ module Datadog
 
         # @see https://www.w3.org/TR/trace-context/#tracestate-header
         def build_tracestate(digest)
-          tracestate = String.new('dd=')
+          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
 
-          if digest.trace_distributed_tags
+          # 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)};"
 
@@ -187,7 +189,7 @@ module Datadog
               # 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(',')}"
+              "#{tracestate},#{vendors.join(",")}"
             else
               tracestate.to_s
             end
@@ -199,7 +201,7 @@ module Datadog
         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
@@ -216,10 +218,10 @@ 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, '~')
@@ -253,10 +255,10 @@ 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?('=')
@@ -333,7 +335,11 @@ module Datadog
             key, value = pair.split(':', 2)
             case key
             when 's'
-              sampling_priority = Integer(value) rescue nil
+              sampling_priority = begin
+                Integer(value)
+              rescue
+                nil
+              end
             when 'o'
               origin = value
             when 'p'
@@ -350,7 +356,7 @@ module Datadog
               tags ||= {}
               tags["#{Tracing::Metadata::Ext::Distributed::TAGS_PREFIX}#{key}"] = value
             else
-              unknown_fields ||= String.new
+              unknown_fields ||= +''
               unknown_fields << pair
               unknown_fields << ';'
             end

data/lib/datadog/tracing/event.rb

@@ -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.name} #{e.message} " \
+            "at #{Array(e.backtrace).first}"
           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

@@ -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

@@ -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.'
           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?

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

@@ -31,6 +31,8 @@ module Datadog
         # See Datadog-internal "RFC: Identifying which spans have profiling enabled " for details
         TAG_PROFILING_ENABLED = '_dd.profiling.enabled'
 
+        TAG_APM_ENABLED = '_dd.apm.enabled'
+
         # Defines constants for trace analytics
         # @public_api
         module Analytics
@@ -55,6 +57,9 @@ module Datadog
           # @see Datadog::Tracing::Sampling::Ext::Mechanism
           TAG_DECISION_MAKER = '_dd.p.dm'
 
+          # Bitmask for which product generated an event. E.g.: 2 for an AppSec event.
+          TAG_TRACE_SOURCE = '_dd.p.ts'
+
           TAG_ORIGIN = '_dd.origin'
           TAG_SAMPLING_PRIORITY = '_sampling_priority_v1'
 
@@ -77,6 +82,14 @@ module Datadog
           TAG_MSG = 'error.message'
           TAG_STACK = 'error.stack'
           TAG_TYPE = 'error.type'
+
+          # From https://opentelemetry.io/docs/specs/semconv/registry/attributes/exception/#exception-stacktrace
+          ATTRIBUTE_MESSAGE = 'exception.message'
+          ATTRIBUTE_STACKTRACE = 'exception.stacktrace'
+          ATTRIBUTE_TYPE = 'exception.type'
+
+          # From https://opentelemetry.io/docs/specs/semconv/exceptions/exceptions-spans/#exception-event
+          EVENT_NAME = 'exception'
         end
 
         # @public_api

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Datadog
+  module Tracing
+    module Metadata
+      # This class is a data structure that is used to store
+      # complex metadata, such as an array of objects.
+      #
+      # It is serialized to MessagePack format when sent to the agent.
+      class Metastruct
+        extend Forwardable
+
+        def_delegators :@metastruct, :[], :[]=, :to_h
+
+        def initialize
+          @metastruct = {}
+        end
+
+        def to_msgpack(packer = nil)
+          # JRuby doesn't pass the packer
+          packer ||= MessagePack::Packer.new
+
+          packer.write(@metastruct.transform_values(&:to_msgpack))
+        end
+
+        def pretty_print(q)
+          q.seplist @metastruct.each do |key, value|
+            q.text "#{key} => #{value}"
+          end
+        end
+      end
+    end
+  end
+end