datadog 2.17.0 → 2.37.0

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'sampler'
-require_relative '../utils'
+require_relative '../../core/knuth_sampler'
 
 module Datadog
   module Tracing
@@ -9,46 +9,35 @@ module Datadog
       # {Datadog::Tracing::Sampling::RateSampler} is based on a sample rate.
       class RateSampler < Sampler
         KNUTH_FACTOR = 1111111111111111111
-        UINT64_MODULO = (1 << 64)
 
         # Initialize a {Datadog::Tracing::Sampling::RateSampler}.
         # This sampler keeps a random subset of the traces. Its main purpose is to
         # reduce the instrumentation footprint.
         #
         # @param sample_rate [Numeric] the sample rate between 0.0 and 1.0, inclusive.
-        #   0.0 means that no trace will be sampled; 1.0 means that all traces will be  sampled.
+        #   0.0 means that no trace will be sampled; 1.0 means that all traces will be sampled.
         def initialize(sample_rate = 1.0, decision: nil)
           super()
-
-          unless sample_rate >= 0.0 && sample_rate <= 1.0
-            Datadog.logger.warn('sample rate is not between 0 and 1, falling back to 1')
-            sample_rate = 1.0
-          end
-
-          self.sample_rate = sample_rate
-
+          @sampler = Core::KnuthSampler.new(sample_rate, knuth_factor: KNUTH_FACTOR)
           @decision = decision
         end
 
         def sample_rate(*_)
-          @sample_rate
+          @sampler.rate
         end
 
         def sample_rate=(sample_rate)
-          @sample_rate = sample_rate
-          @sampling_id_threshold = sample_rate * Tracing::Utils::EXTERNAL_MAX_ID
+          @sampler = Core::KnuthSampler.new(sample_rate, knuth_factor: KNUTH_FACTOR)
         end
 
         def sample?(trace)
-          ((trace.id * KNUTH_FACTOR) % UINT64_MODULO) <= @sampling_id_threshold
+          @sampler.sample?(trace.id)
         end
 
         def sample!(trace)
-          sampled = sample?(trace)
-
-          return false unless sampled
+          return false unless sample?(trace)
 
-          trace.sample_rate = @sample_rate
+          trace.sample_rate = sample_rate
           trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, @decision) if @decision
 
           true

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

@@ -34,7 +34,7 @@ module Datadog
           @matcher.match?(trace)
         rescue => e
           Datadog.logger.error(
-            "Matcher failed. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+            "Matcher failed. Cause: #{e.class}: #{e.message} Source: #{Array(e.backtrace).first}"
           )
           Datadog::Core::Telemetry::Logger.report(e, description: 'Matcher failed')
           nil

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

@@ -30,26 +30,27 @@ module Datadog
           default_sampler: nil
         )
           @rules = if default_sample_rate && !default_sampler
-                     # Add to the end of the rule list a rule always matches any trace
-                     rules << SimpleRule.new(sample_rate: default_sample_rate)
-                   else
-                     rules
-                   end
+            # Add to the end of the rule list a rule always matches any trace
+            rules << SimpleRule.new(sample_rate: default_sample_rate)
+          else
+            rules
+          end
           @rate_limiter = if rate_limiter
-                            rate_limiter
-                          elsif rate_limit
-                            Core::TokenBucket.new(rate_limit)
-                          else
-                            Core::UnlimitedLimiter.new
-                          end
+            rate_limiter
+          elsif rate_limit
+            Core::TokenBucket.new(rate_limit)
+          else
+            Core::UnlimitedLimiter.new
+          end
           @default_sampler = if default_sampler
-                               default_sampler
-                             elsif default_sample_rate
-                               nil
-                             else
-                               # TODO: Simplify .tags access, as `Tracer#tags` can't be arbitrarily changed anymore
-                               RateByServiceSampler.new(1.0, env: -> { Tracing.send(:tracer).tags['env'] })
-                             end
+            default_sampler
+          elsif default_sample_rate
+            nil
+          else
+            # TODO: Simplify .tags access, as `Tracer#tags` can't be arbitrarily changed anymore
+            RateByServiceSampler.new(1.0, env: -> { Tracing.send(:tracer).tags['env'] })
+          end
+          @reconsider_sample_resource_enabled = @rules.any? { |rule| resource_rule?(rule) }
         end
 
         def self.parse(rules, rate_limit, default_sample_rate)
@@ -84,7 +85,7 @@ module Datadog
           new(parsed_rules, rate_limit: rate_limit, default_sample_rate: default_sample_rate)
         rescue => e
           Datadog.logger.warn do
-            "Could not parse trace sampling rules '#{rules}': #{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+            "Could not parse trace sampling rules '#{rules}': #{e.class}: #{e.message} at #{Array(e.backtrace).first}"
           end
 
           nil
@@ -103,6 +104,18 @@ module Datadog
           trace.sampled = sampled
         end
 
+        def reconsider_sample_resource!(trace)
+          rule = @rules.find { |r| resource_rule?(r) && r.match?(trace) }
+          return if rule.nil?
+
+          reconsider_matching_rule!(trace, rule)
+        end
+
+        # Do any rules match on the resource name?
+        def resource_sampling?
+          @reconsider_sample_resource_enabled
+        end
+
         # @!visibility private
         def update(*args, **kwargs)
           return false unless @default_sampler.respond_to?(:update)
@@ -117,32 +130,10 @@ module Datadog
 
           return yield(trace) if rule.nil?
 
-          sampled = rule.sample!(trace)
-          sample_rate = rule.sample_rate(trace)
-
-          set_priority(trace, sampled)
-          set_rule_metrics(trace, sample_rate)
-
-          return false unless sampled
-
-          rate_limiter.allow?.tap do |allowed|
-            set_priority(trace, allowed)
-            set_limiter_metrics(trace, rate_limiter.effective_rate)
-
-            provenance = case rule.provenance
-                         when Rule::PROVENANCE_REMOTE_USER
-                           Ext::Decision::REMOTE_USER_RULE
-                         when Rule::PROVENANCE_REMOTE_DYNAMIC
-                           Ext::Decision::REMOTE_DYNAMIC_RULE
-                         else
-                           Ext::Decision::TRACE_SAMPLING_RULE
-                         end
-
-            trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, provenance)
-          end
-        rescue StandardError => e
+          apply_rule!(trace, rule)
+        rescue => e
           Datadog.logger.error(
-            "Rule sampling failed. Cause: #{e.class.name} #{e.message} Source: #{Array(e.backtrace).first}"
+            "Rule sampling failed. Cause: #{e.class}: #{e.message} Source: #{Array(e.backtrace).first}"
           )
           Datadog::Core::Telemetry::Logger.report(e, description: 'Rule sampling failed')
 
@@ -153,10 +144,10 @@ module Datadog
         # was responsible for the sampling decision.
         def set_priority(trace, sampled)
           trace.sampling_priority = if sampled
-                                      Sampling::Ext::Priority::USER_KEEP
-                                    else
-                                      Sampling::Ext::Priority::USER_REJECT
-                                    end
+            Sampling::Ext::Priority::USER_KEEP
+          else
+            Sampling::Ext::Priority::USER_REJECT
+          end
         end
 
         def set_rule_metrics(trace, sample_rate)
@@ -166,6 +157,44 @@ module Datadog
         def set_limiter_metrics(trace, limiter_rate)
           trace.rate_limiter_rate = limiter_rate
         end
+
+        def apply_rule!(trace, rule)
+          sampled = rule.sample!(trace)
+          sample_rate = rule.sample_rate(trace)
+
+          set_priority(trace, sampled)
+          set_rule_metrics(trace, sample_rate)
+
+          return false unless sampled
+
+          rate_limiter.allow?.tap do |allowed|
+            set_priority(trace, allowed)
+            set_limiter_metrics(trace, rate_limiter.effective_rate)
+            trace.set_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER, provenance_for(rule))
+          end
+        end
+
+        def provenance_for(rule)
+          case rule.provenance
+          when Rule::PROVENANCE_REMOTE_USER
+            Ext::Decision::REMOTE_USER_RULE
+          when Rule::PROVENANCE_REMOTE_DYNAMIC
+            Ext::Decision::REMOTE_DYNAMIC_RULE
+          else
+            Ext::Decision::TRACE_SAMPLING_RULE
+          end
+        end
+
+        def resource_rule?(rule)
+          matcher = rule.matcher
+          matcher.respond_to?(:resource) && matcher.resource != Matcher::MATCH_ALL
+        end
+
+        def reconsider_matching_rule!(trace, rule)
+          trace.agent_sample_rate = nil
+          trace.clear_tag(Tracing::Metadata::Ext::Distributed::TAG_DECISION_MAKER)
+          apply_rule!(trace, rule)
+        end
       end
     end
   end

data/lib/datadog/tracing/sampling/span/rule_parser.rb

@@ -28,8 +28,8 @@ module Datadog
                 list = JSON.parse(rules)
               rescue => e
                 Datadog.logger.warn(
-                  "Error parsing Span Sampling Rules `#{rules.inspect}`: "\
-                  "#{e.class.name} #{e.message} at #{Array(e.backtrace).first}"
+                  "Error parsing Span Sampling Rules `#{rules.inspect}`: " \
+                  "#{e.class}: #{e.message} at #{Array(e.backtrace).first}"
                 )
                 return nil
               end
@@ -61,7 +61,7 @@ module Datadog
                 rescue => e
                   Datadog.logger.warn(
                     "Cannot parse Span Sampling Rule #{hash.inspect}: " \
-                    "#{e.class.name} #{e} at #{Array(e.backtrace).first}"
+                    "#{e.class}: #{e.message} at #{Array(e.backtrace).first}"
                   )
                   return nil
                 end

data/lib/datadog/tracing/sampling/span/sampler.rb

@@ -58,13 +58,6 @@ module Datadog
 
               next if decision == :not_matched # Iterate until we find a matching decision
 
-              if decision == :kept
-                trace_op.set_tag(
-                  Metadata::Ext::Distributed::TAG_DECISION_MAKER,
-                  Sampling::Ext::Decision::SPAN_SAMPLING_RATE
-                )
-              end
-
               break # Found either a `kept` or `rejected` decision
             end
 

data/lib/datadog/tracing/span.rb

@@ -80,7 +80,7 @@ module Datadog
 
         @meta = meta || {}
         @metrics = metrics || {}
-        @metastruct = metastruct || {}
+        @metastruct = metastruct || Metastruct.new
         @status = status || 0
 
         # start_time and end_time track wall clock. In Ruby, wall clock
@@ -113,7 +113,7 @@ module Datadog
       def stopped?
         !@end_time.nil?
       end
-      alias :finished? :stopped?
+      alias_method :finished?, :stopped?
 
       def duration
         return @duration if @duration

data/lib/datadog/tracing/span_event.rb

@@ -41,7 +41,7 @@ module Datadog
       # of being limiting span events to the size limit of a span tag.
       # All Datadog agents support this format.
       def to_hash
-        h = { 'name' => @name, 'time_unix_nano' => @time_unix_nano }
+        h = {'name' => @name, 'time_unix_nano' => @time_unix_nano}
         h['attributes'] = @attributes unless @attributes.empty?
         h
       end
@@ -51,15 +51,15 @@ module Datadog
       # This serialization format removes the serialization limitations of the `span.set_tag('events)` approach,
       # but is only supported by newer version of the Datadog agent.
       def to_native_format
-        h = { 'name' => @name, 'time_unix_nano' => @time_unix_nano }
+        h = {'name' => @name, 'time_unix_nano' => @time_unix_nano}
 
         attr = {}
         @attributes.each do |key, value|
           attr[key] = if value.is_a?(Array)
-                        { type: ARRAY_TYPE, array_value: value.map { |v| serialize_native_attribute(v) } }
-                      else
-                        serialize_native_attribute(value)
-                      end
+            {type: ARRAY_TYPE, array_value: {values: value.map { |v| serialize_native_attribute(v) }}}
+          else
+            serialize_native_attribute(value)
+          end
         end
 
         h['attributes'] = attr unless @attributes.empty?
@@ -69,8 +69,8 @@ module Datadog
 
       private
 
-      MIN_INT64_SIGNED = -2**63
-      MAX_INT64_SIGNED = 2 << 63 - 1
+      MIN_INT64_SIGNED = -2 << 62
+      MAX_INT64_SIGNED = (2 << 62) - 1
 
       # Checks the attributes hash to ensure it only contains serializable values.
       # Invalid values are removed from the hash.
@@ -144,13 +144,13 @@ module Datadog
       def serialize_native_attribute(value)
         case value
         when String
-          { type: STRING_TYPE, string_value: value }
+          {type: STRING_TYPE, string_value: value}
         when TrueClass, FalseClass
-          { type: BOOLEAN_TYPE, bool_value: value }
+          {type: BOOLEAN_TYPE, bool_value: value}
         when Integer
-          { type: INTEGER_TYPE, int_value: value }
+          {type: INTEGER_TYPE, int_value: value}
         when Float
-          { type: DOUBLE_TYPE, double_value: value }
+          {type: DOUBLE_TYPE, double_value: value}
         else
           # This is technically unreachable due to the validation in #initialize.
           raise ArgumentError, "Attribute must be a string, number, or boolean: #{value}."

data/lib/datadog/tracing/span_link.rb

@@ -47,15 +47,15 @@ module Datadog
         @span_id = digest.span_id
         @trace_id = digest.trace_id
         @trace_flags = if digest.trace_sampling_priority.nil?
-                         nil
-                       elsif digest.trace_sampling_priority > 0
-                         1
-                       else
-                         0
-                       end
-        @trace_state = digest.trace_state && digest.trace_state.dup
+          nil
+        elsif digest.trace_sampling_priority > 0
+          1
+        else
+          0
+        end
+        @trace_state = digest.trace_state&.dup
         @dropped_attributes = 0
-        @attributes = (attributes && attributes.dup) || {}
+        @attributes = attributes&.dup || {}
       end
 
       def to_hash
@@ -81,10 +81,10 @@ module Datadog
         # If traceflags set, the high bit (bit 31) should be set to 1 (uint32).
         # This helps us distinguish between when the sample decision is zero or not set
         h[:flags] = if @trace_flags.nil?
-                      0
-                    else
-                      @trace_flags | (1 << 31)
-                    end
+          0
+        else
+          @trace_flags | (1 << 31)
+        end
         h
       end
     end

data/lib/datadog/tracing/span_operation.rb

@@ -157,13 +157,15 @@ module Datadog
           # running, to minimize impact on normal application function.
           begin
             start
-          rescue StandardError => e
-            logger.debug { "Failed to start span: #{e}" }
+          rescue => e
+            logger.debug { "Failed to start span: #{e.class}: #{e.message}" }
           ensure
             # We should yield to the provided block when possible, as this
             # block is application code that we don't want to hinder.
             # * We don't yield during a fatal error, as the application is likely trying to
             #   end its execution (either due to a system error or graceful shutdown).
+            # @type var e: Exception?
+            # Steep: https://github.com/soutaro/steep/issues/919
             return_value = yield(self) unless e && !e.is_a?(StandardError)
           end
         # rubocop:disable Lint/RescueException
@@ -214,9 +216,6 @@ module Datadog
       end
 
       # Mark the span stopped at the current time
-      #
-      # steep:ignore:start
-      # Steep issue fixed in https://github.com/soutaro/steep/pull/1467
       def stop(stop_time = nil, exception: nil)
         # A span should not be stopped twice. Note that this is not thread-safe,
         # stop is called from multiple threads, a given span might be stopped
@@ -239,7 +238,6 @@ module Datadog
 
         self
       end
-      # steep:ignore:end
 
       # Return whether the duration is started or not
       def started?
@@ -272,6 +270,9 @@ module Datadog
         # Stop timing
         stop(end_time)
 
+        # Allow subscribers to enrich the span before it is finalized.
+        events.before_finish.publish(self)
+
         # Build span
         # Memoize for performance reasons
         @span = build_span
@@ -287,8 +288,14 @@ module Datadog
       end
 
       def duration
+        # Steep: https://github.com/soutaro/steep/issues/477
+        # @type ivar @duration_end: Time
+        # @type ivar @duration_start: Time
         return @duration_end - @duration_start if @duration_start && @duration_end
 
+        # Steep: https://github.com/soutaro/steep/issues/477
+        # @type ivar @end_time: Time
+        # @type ivar @start_time: Time
         @end_time - @start_time if @start_time && @end_time
       end
 
@@ -297,6 +304,30 @@ module Datadog
         set_error_tags(e)
       end
 
+      # Record an exception during the execution of this span. Multiple exceptions
+      # can be recorded on a span.
+      #
+      # @param [Exception] exception The exception to record
+      # @param [optional Hash{String => String, Numeric, Boolean, Array<String, Numeric, Boolean>}]
+      #   attributes One or more key:value pairs, where the keys must be
+      #   strings and the values may be (array of) string, boolean or numeric
+      #   type.
+      #
+      # @return [void]
+      def record_exception(exception, attributes: {})
+        exc = Core::Error.build_from(exception)
+
+        event_attributes = {
+          'exception.type' => exc.type,
+          'exception.message' => exc.message,
+          'exception.stacktrace' => exc.backtrace,
+        }
+
+        # Steep: Caused by wrong declaration, should be the same parameters as `merge`
+        # https://github.com/ruby/rbs/blob/3d0fb3a7fdde60af7120e875fe3bd7237b5b6a88/core/hash.rbs#L1468
+        @span_events << SpanEvent.new('exception', attributes: event_attributes.merge!(attributes)) # steep:ignore ArgumentTypeMismatch
+      end
+
       # Return a string representation of the span.
       def to_s
         "SpanOperation(name:#{@name},sid:#{@id},tid:#{@trace_id},pid:#{@parent_id})"
@@ -365,18 +396,21 @@ module Datadog
       class Events
         include Tracing::Events
 
-        DEFAULT_ON_ERROR = proc { |span_op, error| span_op.set_error(error) unless span_op.nil? }
+        # Steep: https://github.com/soutaro/steep/issues/335
+        DEFAULT_ON_ERROR = proc { |span_op, error| span_op&.set_error(error) } # steep:ignore IncompatibleAssignment
 
         attr_reader \
           :logger,
           :after_finish,
           :after_stop,
+          :before_finish,
           :before_start
 
-        def initialize(logger: Datadog.logger, on_error: nil)
+        def initialize(logger: Datadog.logger)
           @logger = logger
           @after_finish = AfterFinish.new
           @after_stop = AfterStop.new
+          @before_finish = BeforeFinish.new
           @before_start = BeforeStart.new
         end
 
@@ -400,6 +434,14 @@ module Datadog
           end
         end
 
+        # Triggered just before the span is finalized into a Span object.
+        # Subscribers can still mutate tags on the SpanOperation at this point.
+        class BeforeFinish < Tracing::Event
+          def initialize
+            super(:before_finish)
+          end
+        end
+
         # Triggered just before the span is started.
         class BeforeStart < Tracing::Event
           def initialize
@@ -426,25 +468,23 @@ module Datadog
             original = @handler
 
             @handler = proc do |op, error|
-              begin
-                yield(op, error)
-              rescue StandardError => e
-                logger.debug do
-                  "Custom on_error handler #{@handler} failed, using fallback behavior. \
-                  Cause: #{e.class}: #{e} Location: #{Array(e.backtrace).first}"
-                end
-
-                original.call(op, error) if original
+              yield(op, error)
+            rescue => e
+              logger.debug do
+                "Custom on_error handler #{@handler} failed, using fallback behavior. \
+                  Cause: #{e.class}: #{e.message} Location: #{Array(e.backtrace).first}"
               end
+
+              original&.call(op, error)
             end
           end
 
           def publish(*args)
             begin
               @handler.call(*args)
-            rescue StandardError => e
+            rescue => e
               logger.debug do
-                "Error in on_error handler '#{@default}': #{e.class}: #{e} at #{Array(e.backtrace).first}"
+                "Error in on_error handler '#{@handler}': #{e.class}: #{e.message} at #{Array(e.backtrace).first}"
               end
             end
 
@@ -528,6 +568,10 @@ module Datadog
       # Used for serialization
       # @return [Integer] in nanoseconds since Epoch
       def start_time_nano
+        return 0 if @start_time.nil?
+
+        # Steep: https://github.com/soutaro/steep/issues/477
+        # @type ivar @start_time: Time
         @start_time.to_i * 1000000000 + @start_time.nsec
       end
 

data/lib/datadog/tracing/sync_writer.rb

@@ -9,7 +9,6 @@ require_relative 'transport/http'
 module Datadog
   module Tracing
     # SyncWriter flushes both services and traces synchronously
-    # DEV: To be replaced by Datadog::Tracing::Workers::TraceWriter.
     #
     # Note: If you're wondering if this class is used at all, since there are no other references to it on the codebase,
     # the separate `datadog-lambda` uses it as of February 2021:
@@ -25,7 +24,7 @@ module Datadog
       # @param [Datadog::Tracing::Transport::Traces::Transport] transport a custom transport instance.
       #   If provided, overrides `transport_options` and `agent_settings`.
       # @param [Hash<Symbol,Object>] transport_options options for the default transport instance.
-      # @param [Datadog::Tracing::Configuration::AgentSettingsResolver::AgentSettings] agent_settings agent options for
+      # @param [Datadog::Tracing::Configuration::AgentSettings] agent_settings agent options for
       #   the default transport instance.
       def initialize(transport: nil, transport_options: {}, agent_settings: nil, logger: Datadog.logger)
         @logger = logger

data/lib/datadog/tracing/trace_digest.rb

@@ -22,6 +22,9 @@ module Datadog
       # @!attribute [r] span_type
       #   The type of the currently active span.
       #   @return [String]
+      # @!attribute [r] span_links
+      #   Span links associated with this trace context.
+      #   @return [Array<Datadog::Tracing::SpanLink>, nil]
       # @!attribute [r] trace_distributed_tags
       #   Datadog-specific tags that support richer distributed tracing association.
       #   @return [Hash<String,String>]
@@ -91,6 +94,7 @@ module Datadog
         :span_resource,
         :span_service,
         :span_type,
+        :span_links,
         :trace_distributed_tags,
         :trace_hostname,
         :trace_id,
@@ -114,6 +118,7 @@ module Datadog
         span_resource: nil,
         span_service: nil,
         span_type: nil,
+        span_links: nil,
         trace_distributed_tags: nil,
         trace_hostname: nil,
         trace_id: nil,
@@ -136,6 +141,7 @@ module Datadog
         @span_resource = span_resource && span_resource.dup.freeze
         @span_service = span_service && span_service.dup.freeze
         @span_type = span_type && span_type.dup.freeze
+        @span_links = span_links && span_links.dup.freeze
         @trace_distributed_tags = trace_distributed_tags && trace_distributed_tags.dup.freeze
         @trace_hostname = trace_hostname && trace_hostname.dup.freeze
         @trace_id = trace_id
@@ -162,29 +168,28 @@ module Datadog
         # DEV: Because we want to sometimes freeze the values provided to `TraceDigest`, it's best
         # DEV: to let `#initialize` decide how to handle each field, instead of duplicating that logic here.
         TraceDigest.new(
-          **{
-            span_id: span_id,
-            span_name: span_name,
-            span_resource: span_resource,
-            span_service: span_service,
-            span_type: span_type,
-            trace_distributed_tags: trace_distributed_tags,
-            trace_hostname: trace_hostname,
-            trace_id: trace_id,
-            trace_name: trace_name,
-            trace_origin: trace_origin,
-            trace_process_id: trace_process_id,
-            trace_resource: trace_resource,
-            trace_runtime_id: trace_runtime_id,
-            trace_sampling_priority: trace_sampling_priority,
-            trace_service: trace_service,
-            trace_distributed_id: trace_distributed_id,
-            trace_flags: trace_flags,
-            trace_state: trace_state,
-            trace_state_unknown_fields: trace_state_unknown_fields,
-            span_remote: span_remote,
-            baggage: baggage
-          }.merge!(field_value_pairs)
+          span_id: span_id,
+          span_name: span_name,
+          span_resource: span_resource,
+          span_service: span_service,
+          span_type: span_type,
+          span_links: span_links,
+          trace_distributed_tags: trace_distributed_tags,
+          trace_hostname: trace_hostname,
+          trace_id: trace_id,
+          trace_name: trace_name,
+          trace_origin: trace_origin,
+          trace_process_id: trace_process_id,
+          trace_resource: trace_resource,
+          trace_runtime_id: trace_runtime_id,
+          trace_sampling_priority: trace_sampling_priority,
+          trace_service: trace_service,
+          trace_distributed_id: trace_distributed_id,
+          trace_flags: trace_flags,
+          trace_state: trace_state,
+          trace_state_unknown_fields: trace_state_unknown_fields,
+          span_remote: span_remote,
+          baggage: baggage, **field_value_pairs
         )
       end
     end