ddtrace 1.16.1 → 1.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4e85c12caf77e324eee9de8f9ddf143b0e49c3487230ff841ab7a5be05e4c7d
-  data.tar.gz: 44d799e085ae66280177800c136c656085d6f1fc5d32085c2852158c4290ef59
+  metadata.gz: 2da890705f074bf11ffaa1b5099472a4695d318fc1a1a98238d61a061d6582ec
+  data.tar.gz: 8c6db62249ee456939c3eacdeddb0f985148e9daa78adb844144d8da1191e8bb
 SHA512:
-  metadata.gz: 8c651f6acbdff86fac984f61df4f2322eb449e3355220810a955496c51d33565ddbd6d15f3ca5049f9f0738c93508db9def7c24f046a51d3ef616b6182a1ca4d
-  data.tar.gz: 75fc3aa27da60ec0998087a814f77fe33a4f4c0bcbbda52b647cc00552945e412fa8d7e276d69d470b258da8c204db5186f24118cf4e0dc24bec9c1681ed1c33
+  metadata.gz: a70b6856159a46f30a4ff67bc672011bb016b2aa7b1562834957a325eee90be681f9d0e153ef94c97a4ce675f7b63ac9f5a68f5573b4b9144ee40cf89a70395f
+  data.tar.gz: 0d8d1a5d2ee255e53daab1cea7e82ec6f61c8e4a67b89ab1293853786d634c6cde2407a1ea0ceb4ff8bbb3391940dec5bdcfc56dd4b55b7b3826e35bdcff84eb

data/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 ## [Unreleased]
 
+## [1.17.0] - 2023-11-22
+
+For W3C Trace Context, this release adds [`tracecontext`](https://www.w3.org/TR/trace-context/) to the default trace propagation extraction and injection styles. The new defaults are:
+* Extraction: `Datadog,b3multi,b3,tracecontext`
+* Injection: `Datadog,tracecontext`
+
+And to increase interoperability with `tracecontext`, 128-bit Trace ID generation is now the default.
+
+For OpenTelemetry, this release adds support for converting [OpenTelemetry Trace Semantic Conventions](https://opentelemetry.io/docs/specs/semconv/general/trace/) into equivalent Datadog trace semantics. Also, it's now possible to configure top-level Datadog span fields using OpenTelemetry span attributes (https://github.com/DataDog/dd-trace-rb/pull/3262).
+
+For CI Visibility, you can now manually create CI traces and spans with the [newly released API](https://github.com/DataDog/datadog-ci-rb/releases/tag/v0.4.0).
+
+### Added
+
+* OpenTelemetry: Parse OpenTelemetry semantic conventions to Datadog's ([#3273][])
+* OpenTelemetry: Support span reserved attribute overrides ([#3262][])
+* Tracing: Ensure W3C `tracestate` is always propagated ([#3255][])
+
+### Changed
+
+* Tracing: Set 128-bit trace_id to true by default ([#3266][])
+* Tracing: Default trace propagation styles to `Datadog,b3multi,b3,tracecontext` ([#3248][],#3267)
+* Ci-App: Upgraded `datadog-ci` dependency to 0.4 ([#3270][])
+
+## [1.16.2] - 2023-11-10
+
+This release reverts a change to appsec response body parsing that was introduced in [1.16.0 ](https://github.com/DataDog/dd-trace-rb/releases/tag/v1.16.0) that may cause memory leaks.
+
+### Fixed
+*  Appsec: [Revert parse response body fix introduced in 1.16.0](https://github.com/DataDog/dd-trace-rb/pull/3153) ([#3252][])
+
 ## [1.16.1] - 2023-11-08
 
 ### Fixed
@@ -2627,7 +2658,9 @@ Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.3.1
 Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 
 
-[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.16.1...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.17.0...master
+[1.17.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.16.2...v1.17.0
+[1.16.2]: https://github.com/DataDog/dd-trace-rb/compare/v1.16.1...v1.16.2
 [1.16.1]: https://github.com/DataDog/dd-trace-rb/compare/v1.16.0...v1.16.1
 [1.16.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.15.0...v1.16.0
 [1.15.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.14.0...v1.15.0
@@ -3841,6 +3874,14 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#3235]: https://github.com/DataDog/dd-trace-rb/issues/3235
 [#3240]: https://github.com/DataDog/dd-trace-rb/issues/3240
 [#3242]: https://github.com/DataDog/dd-trace-rb/issues/3242
+[#3248]: https://github.com/DataDog/dd-trace-rb/issues/3248
+[#3252]: https://github.com/DataDog/dd-trace-rb/issues/3252
+[#3255]: https://github.com/DataDog/dd-trace-rb/issues/3255
+[#3262]: https://github.com/DataDog/dd-trace-rb/issues/3262
+[#3266]: https://github.com/DataDog/dd-trace-rb/issues/3266
+[#3267]: https://github.com/DataDog/dd-trace-rb/issues/3267
+[#3270]: https://github.com/DataDog/dd-trace-rb/issues/3270
+[#3273]: https://github.com/DataDog/dd-trace-rb/issues/3273
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot

data/lib/datadog/appsec/configuration/settings.rb

@@ -188,12 +188,6 @@ module Datadog
                   end
                 end
               end
-
-              option :parse_response_body do |o|
-                o.type :bool
-                o.env 'DD_API_SECURITY_PARSE_RESPONSE_BODY'
-                o.default true
-              end
             end
           end
         end

data/lib/datadog/appsec/contrib/rack/gateway/response.rb

@@ -19,55 +19,9 @@ module Datadog
               @scope = scope
             end
 
-            def parsed_body
-              return unless Datadog.configuration.appsec.parse_response_body
-
-              unless body.instance_of?(Array)
-                Datadog.logger.debug do
-                  "Response body type unsupported: #{body.class}"
-                end
-                return
-              end
-
-              return unless json_content_type?
-
-              result = ''.dup
-              all_body_parts_are_string = true
-
-              body.each do |body_part|
-                if body_part.is_a?(String)
-                  result.concat(body_part)
-                else
-                  all_body_parts_are_string = false
-                  break
-                end
-              end
-
-              return unless all_body_parts_are_string
-
-              begin
-                JSON.parse(result)
-              rescue JSON::ParserError => e
-                Datadog.logger.debug { "Failed to parse response body. Error #{e.class}. Message #{e.message}" }
-                nil
-              end
-            end
-
             def response
               @response ||= ::Rack::Response.new(body, status, headers)
             end
-
-            private
-
-            VALID_JSON_TYPES = [
-              'application/json',
-              'text/json'
-            ].freeze
-
-            def json_content_type?
-              content_type = headers['content-type']
-              VALID_JSON_TYPES.include?(content_type)
-            end
           end
         end
       end

data/lib/datadog/appsec/contrib/rack/reactive/response.rb

@@ -10,7 +10,6 @@ module Datadog
             ADDRESSES = [
               'response.status',
               'response.headers',
-              'response.body',
             ].freeze
             private_constant :ADDRESSES
 
@@ -18,7 +17,6 @@ module Datadog
               catch(:block) do
                 op.publish('response.status', gateway_response.status)
                 op.publish('response.headers', gateway_response.headers)
-                op.publish('response.body', gateway_response.parsed_body)
 
                 nil
               end
@@ -31,7 +29,6 @@ module Datadog
                 response_status = values[0]
                 response_headers = values[1]
                 response_headers_no_cookies = response_headers.dup.tap { |h| h.delete('set-cookie') }
-                response_body = values[2]
 
                 waf_args = {
                   'server.response.status' => response_status.to_s,
@@ -39,8 +36,6 @@ module Datadog
                   'server.response.headers.no_cookies' => response_headers_no_cookies,
                 }
 
-                waf_args['server.response.body'] = response_body if response_body
-
                 waf_timeout = Datadog.configuration.appsec.waf_timeout
                 result = waf_context.run(waf_args, waf_timeout)
 

data/lib/datadog/appsec/contrib/rack/request_middleware.rb

@@ -66,16 +66,6 @@ module Datadog
               request_return = AppSec::Response.negotiate(env, blocked_event.last[:actions]).to_rack if blocked_event
             end
 
-            if request_return[2].respond_to?(:to_ary)
-              # Following the Rack specification. The response body should only call :each once.
-              # Calling :to_ary returns an array with identical content as the produced when calling :each
-              # replacing request_return[2] with that new value allow us to safely operate on the response body.
-              # On Gateway::Response#parsed_body we might iterate over the reposne body using :each
-              # https://github.com/rack/rack/blob/main/SPEC.rdoc#enumerable-body-
-              consumed_body = request_return[2].to_ary
-              request_return[2] = consumed_body if consumed_body
-            end
-
             gateway_response = Gateway::Response.new(
               request_return[2],
               request_return[0],

data/lib/datadog/core/configuration/settings.rb

@@ -330,7 +330,7 @@ module Datadog
             # Caveat 3 (severe):
             # Ruby 3.2.0 to 3.2.2 have a bug in the newobj tracepoint (https://bugs.ruby-lang.org/issues/19482,
             # https://github.com/ruby/ruby/pull/7464) so that's an extra reason why it's not safe on those Rubies.
-            # This bug is fixed on Ruby versions 3.2.2 and 3.3.0.
+            # This bug is fixed on Ruby versions 3.2.3 and 3.3.0.
             #
             # @default `true` on Ruby 2.x and 3.1.4+, 3.2.3+ and 3.3.0+; `false` for Ruby 3.0 and unpatched Rubies.
             option :allocation_counting_enabled do |o|

data/lib/datadog/opentelemetry/sdk/span_processor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'trace/span'
+
 module Datadog
   module OpenTelemetry
     module SDK
@@ -76,16 +78,11 @@ module Datadog
         end
 
         def start_datadog_span(span)
-          tags = span.resource.attribute_enumerator.to_h
+          attributes = span.attributes.dup # Dup to allow modification of frozen Hash
 
-          kind = span.kind || 'internal'
-          tags[Tracing::Metadata::Ext::TAG_KIND] = kind
+          name, kwargs = span_arguments(span, attributes)
 
-          datadog_span = Tracing.trace(
-            span.name,
-            tags: tags,
-            start_time: ns_to_time(span.start_timestamp)
-          )
+          datadog_span = Tracing.trace(name, **kwargs)
 
           datadog_span.set_error([nil, span.status.description]) unless span.status.ok?
           datadog_span.set_tags(span.attributes)
@@ -93,6 +90,40 @@ module Datadog
           datadog_span
         end
 
+        # Some special attributes can override Datadog Span fields
+        def span_arguments(span, attributes)
+          if attributes.key?('analytics.event') && (analytics_event = attributes['analytics.event']).respond_to?(:casecmp)
+            attributes[Tracing::Metadata::Ext::Analytics::TAG_SAMPLE_RATE] = analytics_event.casecmp('true') == 0 ? 1 : 0
+          end
+          attributes[Tracing::Metadata::Ext::TAG_KIND] = span.kind || 'internal'
+
+          kwargs = { start_time: ns_to_time(span.start_timestamp) }
+
+          name = if attributes.key?('operation.name')
+                   attributes['operation.name']
+                 elsif (rich_name = Datadog::OpenTelemetry::Trace::Span.enrich_name(span.kind, attributes))
+                   rich_name.downcase
+                 else
+                   span.kind
+                 end
+
+          kwargs[:resource] = attributes.key?('resource.name') ? attributes['resource.name'] : span.name
+          kwargs[:service] = attributes['service.name'] if attributes.key?('service.name')
+          kwargs[:type] = attributes['span.type'] if attributes.key?('span.type')
+
+          attributes.reject! { |key, _| OpenTelemetry::Trace::Span::DATADOG_SPAN_ATTRIBUTE_OVERRIDES.include?(key) }
+
+          # DEV: There's no `flat_map!`; we have to split it into two operations
+          attributes = attributes.map do |key, value|
+            Datadog::OpenTelemetry::Trace::Span.serialize_attribute(key, value)
+          end
+          attributes.flatten!(1)
+
+          kwargs[:tags] = attributes
+
+          [name, kwargs]
+        end
+
         # From nanoseconds, used by OpenTelemetry, to a {Time} object, used by the Datadog Tracer.
         def ns_to_time(timestamp_ns)
           Time.at(timestamp_ns / 1000000000.0)

data/lib/datadog/opentelemetry/sdk/trace/span.rb

@@ -36,6 +36,78 @@ module Datadog
           span.set_error(status.description) if status && status.code == ::OpenTelemetry::Trace::Status::ERROR
         end
 
+        # Serialize values into Datadog span tags and metrics.
+        # Notably, arrays are exploded into many keys, each with
+        # a numeric suffix representing the array index, for example:
+        # `'foo' => ['a','b']` becomes `'foo.0' => 'a', 'foo.1' => 'b'`
+        def self.serialize_attribute(key, value)
+          if value.is_a?(Array)
+            value.flat_map.with_index do |v, idx|
+              serialize_attribute("#{key}.#{idx}", v)
+            end
+          elsif value.is_a?(TrueClass) || value.is_a?(FalseClass)
+            [[key, value.to_s]]
+          else
+            [[key, value]]
+          end
+        end
+
+        # Create a meaningful Datadog operation name from the OpenTelemetry
+        # semantic convention for span kind and span attributes.
+        # @see https://opentelemetry.io/docs/specs/semconv/general/trace/
+
+        # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        def self.enrich_name(kind, attrs)
+          if attrs.key?('http.request.method')
+            return 'http.server.request' if kind == :server
+            return 'http.client.request' if kind == :client
+          end
+
+          return "#{attrs['db.system']}.query" if attrs.key?('db.system') && kind == :client
+
+          if (attrs.key?('messaging.system') || attrs.key?('messaging.operation')) &&
+              [:consumer, :producer, :server, :client].include?(kind)
+
+            return "#{attrs['messaging.system']}.#{attrs['messaging.operation']}"
+          end
+
+          if attrs.key?('rpc.system')
+            if attrs['rpc.system'] == 'aws-api' && kind == :client
+              service = attrs['rpc.service']
+              return "aws.#{service || 'client'}.request"
+            end
+
+            if kind == :client
+              return "#{attrs['rpc.system']}.client.request"
+            elsif kind == :server
+              return "#{attrs['rpc.system']}.server.request"
+            end
+          end
+
+          if attrs.key?('faas.invoked_provider') && attrs.key?('faas.invoked_name') && kind == :client
+            provider = attrs['faas.invoked_provider']
+            name = attrs['faas.invoked_name']
+            return "#{provider}.#{name}.invoke"
+          end
+
+          return "#{attrs['faas.trigger']}.invoke" if attrs.key?('faas.trigger') && kind == :server
+
+          return 'graphql.server.request' if attrs.key?('graphql.operation.type')
+
+          if kind == :server
+            protocol = attrs['network.protocol.name']
+            return protocol ? "#{protocol}.server.request" : 'server.request'
+          end
+
+          if kind == :client
+            protocol = attrs['network.protocol.name']
+            return protocol ? "#{protocol}.client.request" : 'client.request'
+          end
+
+          kind.to_s
+        end
+        # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+
         private
 
         def datadog_set_attribute(key)
@@ -46,10 +118,18 @@ module Datadog
           # DEV: Accesses `@attributes` directly, since using `#attributes`
           # DEV: clones the hash, causing unnecessary overhead.
           if @attributes.key?(key)
-            value = @attributes[key]
-            span.set_tag(key, value)
+            # Try to find a richer operation name, unless an explicit override was provided.
+            if !@attributes.key?('operation.name') && (rich_name = Span.enrich_name(kind, @attributes))
+              span.name = rich_name.downcase
+            end
+
+            Span.serialize_attribute(key, @attributes[key]).each do |new_key, value|
+              override_datadog_values(span, new_key, value)
 
-            span.service = value if key == 'service.name'
+              # When an attribute is used to override a Datadog Span property,
+              # it should NOT be set as a Datadog Span tag.
+              span.set_tag(new_key, value) unless DATADOG_SPAN_ATTRIBUTE_OVERRIDES.include?(new_key)
+            end
           else
             span.clear_tag(key)
 
@@ -61,6 +141,25 @@ module Datadog
           end
         end
 
+        # Some special attributes can override Datadog Span fields beyond tags and metrics.
+        # @return [Boolean] true if the key is a Datadog Span override attribute, false otherwise
+        def override_datadog_values(span, key, value)
+          span.name = value if key == 'operation.name'
+          span.resource = value if key == 'resource.name'
+          span.service = value if key == 'service.name'
+          span.type = value if key == 'span.type'
+
+          if key == 'analytics.event' && value.respond_to?(:casecmp)
+            Datadog::Tracing::Analytics.set_sample_rate(
+              span,
+              value.casecmp('true') == 0 ? 1 : 0
+            )
+          end
+        end
+
+        DATADOG_SPAN_ATTRIBUTE_OVERRIDES = ['analytics.event', 'operation.name', 'resource.name', 'service.name',
+                                            'span.type'].freeze
+
         ::OpenTelemetry::SDK::Trace::Span.prepend(self)
       end
     end

data/lib/datadog/opentracer/text_map_propagator.rb

@@ -33,7 +33,8 @@ module Datadog
           carrier[Tracing::Distributed::Datadog::ORIGIN_KEY] = digest.trace_origin
           carrier[Tracing::Distributed::Datadog::PARENT_ID_KEY] = digest.span_id
           carrier[Tracing::Distributed::Datadog::SAMPLING_PRIORITY_KEY] = digest.trace_sampling_priority
-          carrier[Tracing::Distributed::Datadog::TRACE_ID_KEY] = digest.trace_id
+          carrier[Tracing::Distributed::Datadog::TRACE_ID_KEY] =
+            Datadog::Tracing::Utils::TraceId.to_low_order(digest.trace_id)
 
           nil
         end

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

@@ -62,6 +62,9 @@ module Datadog
           # @see https://opentelemetry.io/docs/concepts/sdk-configuration/general-sdk-configuration/#get_otel__propagators
           PROPAGATION_STYLE_NONE = 'none'
 
+          # Strictly stop at the first successfully serialized style.
+          EXTRACT_FIRST = 'DD_TRACE_PROPAGATION_EXTRACT_FIRST'
+
           ENV_X_DATADOG_TAGS_MAX_LENGTH = 'DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH'
         end
 

data/lib/datadog/tracing/configuration/settings.rb

@@ -63,6 +63,7 @@ module Datadog
                       Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG,
                       Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_MULTI_HEADER,
                       Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_B3_SINGLE_HEADER,
+                      Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT,
                     ]
                   )
                   o.after_set do |styles|
@@ -93,7 +94,10 @@ module Datadog
                   o.deprecated_env Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_INJECT_OLD
                   o.env Tracing::Configuration::Ext::Distributed::ENV_PROPAGATION_STYLE_INJECT
                   # DEV-2.0: Change default value to `tracecontext, Datadog`.
-                  o.default [Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG]
+                  o.default [
+                    Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_DATADOG,
+                    Tracing::Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT,
+                  ]
                   o.after_set do |styles|
                     # Modernize B3 options
                     # DEV-2.0: Can be removed with the removal of deprecated B3 constants.
@@ -142,6 +146,17 @@ module Datadog
                     set_option(:propagation_inject_style, styles)
                   end
                 end
+
+                # Strictly stop at the first successfully serialized style.
+                # This prevents the tracer from enriching the extracted context with information from
+                # other valid propagations styles present in the request.
+                # @default `DD_TRACE_PROPAGATION_EXTRACT_FIRST` environment variable, otherwise `false`.
+                # @return [Boolean]
+                option :propagation_extract_first do |o|
+                  o.env Tracing::Configuration::Ext::Distributed::EXTRACT_FIRST
+                  o.default false
+                  o.type :bool
+                end
               end
 
               # Enable trace collection and span generation.
@@ -177,11 +192,11 @@ module Datadog
 
               # Enable 128 bit trace id generation.
               #
-              # @default `DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED` environment variable, otherwise `false`
+              # @default `DD_TRACE_128_BIT_TRACEID_GENERATION_ENABLED` environment variable, otherwise `true`
               # @return [Boolean]
               option :trace_id_128_bit_generation_enabled do |o|
                 o.env Tracing::Configuration::Ext::ENV_TRACE_ID_128_BIT_GENERATION_ENABLED
-                o.default false
+                o.default true
                 o.type :bool
               end
 

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

@@ -49,7 +49,6 @@ module Datadog
           build_tags(digest).tap do |tags|
             inject_tags!(tags, data) unless tags.empty?
           end
-
           data
         end
 

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

@@ -83,19 +83,40 @@ module Datadog
 
           extracted_trace_digest = nil
 
-          ::Datadog.configuration.tracing.distributed_tracing.propagation_extract_style.each do |style|
+          config = ::Datadog.configuration.tracing.distributed_tracing
+
+          config.propagation_extract_style.each do |style|
             propagator = @propagation_styles[style]
             next if propagator.nil?
 
             begin
-              extracted_trace_digest = propagator.extract(data)
+              if extracted_trace_digest
+                # Return if we are only inspecting the first valid style.
+                next if config.propagation_extract_first
+
+                # Continue parsing styles to find the W3C `tracestate` header, if present.
+                # `tracestate` must always be propagated, as it might contain pass-through data that we don't control.
+                # @see https://www.w3.org/TR/2021/REC-trace-context-1-20211123/#mutating-the-tracestate-field
+                next if style != Configuration::Ext::Distributed::PROPAGATION_STYLE_TRACE_CONTEXT
+
+                if (tracecontext_digest = propagator.extract(data))
+                  # Only parse if it represent the same trace as the successfully extracted one
+                  next unless tracecontext_digest.trace_id == extracted_trace_digest.trace_id
+
+                  # Preserve the `tracestate`
+                  extracted_trace_digest = extracted_trace_digest.merge(
+                    trace_state: tracecontext_digest.trace_state,
+                    trace_state_unknown_fields: tracecontext_digest.trace_state_unknown_fields
+                  )
+                end
+              else
+                extracted_trace_digest = propagator.extract(data)
+              end
             rescue => e
               ::Datadog.logger.error(
                 "Error extracting distributed trace data. Cause: #{e} Location: #{Array(e.backtrace).first}"
               )
             end
-
-            break if extracted_trace_digest
           end
 
           extracted_trace_digest

data/lib/datadog/tracing/trace_digest.rb

@@ -141,6 +141,37 @@ module Datadog
 
         freeze
       end
+
+      # Creates a copy of this object, modifying the provided fields.
+      # @param field_value_pairs [Hash<String>] the fields to be overwritten
+      # @return [TraceDigest] returns a copy of this object with the `field_value_pairs` modified
+      def merge(field_value_pairs)
+        # 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,
+          }.merge!(field_value_pairs)
+        )
+      end
     end
   end
 end

data/lib/ddtrace/version.rb

@@ -3,8 +3,8 @@
 module DDTrace
   module VERSION
     MAJOR = 1
-    MINOR = 16
-    PATCH = 1
+    MINOR = 17
+    PATCH = 0
     PRE = nil
     BUILD = nil
     # PRE and BUILD above are modified for dev gems during gem build GHA workflow

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 1.16.1
+  version: 1.17.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-08 00:00:00.000000000 Z
+date: 2023-11-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: msgpack
@@ -72,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.4.0
 description: |
   ddtrace is Datadog's tracing client for Ruby. It is used to trace requests
   as they flow across web servers, databases and microservices so that developers