RubyGems - ddtrace - Versions diffs - 1.15.0 → 1.17.0 - Mend

ddtrace 1.15.0 → 1.17.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (30) hide show

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 18896f24a83a74a5ea6f4adfb3baad9fec922f0d3c3e8d087d28805744584d40
-  data.tar.gz: 173d93233e49670ed94a9d3cd7501f50c596ceb7624293e4c1992513e6121fa6
+  metadata.gz: 2da890705f074bf11ffaa1b5099472a4695d318fc1a1a98238d61a061d6582ec
+  data.tar.gz: 8c6db62249ee456939c3eacdeddb0f985148e9daa78adb844144d8da1191e8bb
 SHA512:
-  metadata.gz: 174e727aad6f68b2873e88ac71b5a563075c501f4fbd75cad563735c765962d5753f6025a0a75c257f12a7a89fc83713e3ff249f2e2815803786ed709e35daff
-  data.tar.gz: bc2bbcc9d601473e871dee51e53745045b37204bb902dd2f29deac2ea4c94bdc7aa6c016eecfd2648ccac13393b612400c9167bdbd115271893e561fcb12a8ce
+  metadata.gz: a70b6856159a46f30a4ff67bc672011bb016b2aa7b1562834957a325eee90be681f9d0e153ef94c97a4ce675f7b63ac9f5a68f5573b4b9144ee40cf89a70395f
+  data.tar.gz: 0d8d1a5d2ee255e53daab1cea7e82ec6f61c8e4a67b89ab1293853786d634c6cde2407a1ea0ceb4ff8bbb3391940dec5bdcfc56dd4b55b7b3826e35bdcff84eb

data/CHANGELOG.md CHANGED Viewed

@@ -2,134 +2,128 @@
 ## [Unreleased]
-## [1.15.0] - 2023-10-09
+## [1.17.0] - 2023-11-22
-### Highlights
+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`
-#### Timeline view for Profiler beta
+And to increase interoperability with `tracecontext`, 128-bit Trace ID generation is now the default.
-As of ddtrace 1.15.0, the Profiler now supports gathering data for the new
-[Timeline view](https://docs.datadoghq.com/profiler/profile_visualizations/#timeline-view).
+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).
-The Timeline view allows you to look at time-based patterns and work distribution over the period of a single profile: you can look at what individual threads were doing, and when 🎉
+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).
-You can use the timeline view both when looking at individual profiles, as well as when scoped to a given trace.
+### Added
-You can enable it:
+* OpenTelemetry: Parse OpenTelemetry semantic conventions to Datadog's ([#3273][])
+* OpenTelemetry: Support span reserved attribute overrides ([#3262][])
+* Tracing: Ensure W3C `tracestate` is always propagated ([#3255][])
-* Using an environment variable by setting `DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED=true`
-* Or via code by adding to your `Datadog.configure` block:
+### Changed
-```ruby
-Datadog.configure do |c|
-  # … existing configuration …
-  c.profiling.advanced.experimental_timeline_enabled = true
-end
-```
+* 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
-Give it a try, let us know what you think!
+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.
-(Note: We do not recommend enabling this feature prior to 1.15.0!)
+### Fixed
+*  Appsec: [Revert parse response body fix introduced in 1.16.0](https://github.com/DataDog/dd-trace-rb/pull/3153) ([#3252][])
-#### google-protobuf dependency is no longer needed by the Profiler
+## [1.16.1] - 2023-11-08
-As of ddtrace version 1.15.0, the `google-protobuf` gem is no longer needed to enable the Profiler.
+### Fixed
-If you've added this gem to your `Gemfile`/`gems.rb` file as part of enabling the Profiler, you can
-remove it now. (If you're curious, we've internally replaced this dependency with the `libdatadog` gem.)
+* Tracing: Fix `concurrent-ruby` future propagation without `active_trace` ([#3242][])
+* Tracing: Fix host injection error handling  ([#3240][])
-#### Configure blocking responses for AppSec via configuration or Remote Configuration
+## [1.16.0] - 2023-11-03
-As of dd-trace-rb 1.15.0, AppSec supports configuring the blocking response.
+**This release includes a security change for the Tracing Redis integration:**
-You can configure the blocking response via:
-- Using the ENV variables: `DD_APPSEC_HTTP_BLOCKED_TEMPLATE_HTML=#{file_name}`, and `DD_APPSEC_HTTP_BLOCKED_TEMPLATE_JSON=#{file_name}`
-- Via code by adding to your `Datadog.configure` block:
+Currently, the Datadog Agent removes command arguments from the resource name. However there are cases, like Redis compressed keys, where this obfuscation cannot correctly remove command arguments. To safeguard that situation, the resource name set by the tracer will only be the command (e.g. `SET`) with no arguments. To retain the previous behavior and keep arguments in the span resource, with the potential risk of some command arguments not being fully obfuscated, set ``DD_REDIS_COMMAND_ARGS=true`` or set the option `c.instrument :redis, command_args: true`.
-```ruby
-Datadog.configure do |c|
-  # … existing configuration …
-  c.appsec.block.templates.html = "#{file_name}"
-  c.appsec.block.templates.json = "#{file_name}"
-end
-```
+### Added
-- Using the Remote configuration UI. This option allow you to configure the status code and the blocking behaviour. You can redirect malicious attacker to custome pages.
-  You can find more information on the [official documentation](https://docs.datadoghq.com/security/application_security/threats/protection/#customize-protection-behavior)
+* Tracing: Propagate trace through `Concurrent::Promises.future` ([#1522][])
+* Core: Name `Datadog::Core::Remote::Worker` thread ([#3207][])
-#### Configure agentless mode for CI visibility
+### Changed
-If you are using CI visibility with a cloud CI provider without access to the underlying worker nodes, such as GitHub Actions or CircleCI, configure the library to use the Agentless mode.
+* Tracing: Redis - Omit command arguments from span.resource by default ([#3235][])
+* Ci-app: Bump `datadog-ci` dependency from 0.2.0 to 0.3.0 ([#3223][])
-For this, set the following environment variables:
-- DD_CIVISIBILITY_AGENTLESS_ENABLED=true
-- DD_API_KEY=<your_api_key>
+### Fixed
-Additionally, configure which Datadog site you want to send your data to:
-- DD_SITE (default: datadoghq.com)
+* Appsec: ASM parse response body  ([#3153][])
+* Appsec: ASM make sure to append content type and length information ([#3204][])
+* Appsec: Make sure function that checks content-type header value accepts nil content-type header value ([#3234][])
+* Profiling: Shut down profiler if any components failed ([#3197][])
+* Tracing: Fix `ActiveSupport` instrumentation of custom cache stores ([#3206][])
-You can also enable agentless mode with `Datadog.configure` block:
+## [1.15.0] - 2023-10-09
-```ruby
-Datadog.configure do |c|
-  # … existing configuration …
-  c.ci.agentless_mode_enabled = true
-  # don't forget to set DD_API_KEY env variable!
-end
-```
+### Highlights
+* Timeline view for Profiler beta
+* Configure AppSec blocking responses via configuration or Remote Configuration
+* CI visibility to configure with agentless mode
+For more details, check the [release notes](https://github.com/DataDog/dd-trace-rb/releases/tag/v1.15.0)
 ### Added
-* Profiling: Import java-profiler PID controller and port it to C ([#3190][])
-* Tracing: Support Opensearch 3 ([#3189][])
-* bump datadog-ci dependency to 0.2 ([#3186][])
 * Enable allocation counting feature by default for some Ruby 3 versions ([#3176][])
-* Tracing: Introduce async configuration for test mode to use standard writer when needed ([#3158][])
-* Appsec: Update AppSec rules to 1.8.0 ([#3140][])
-* Appsec: Update AppSec rules to 1.7.2 ([#3139][])
-* Appsec: ASM API security. Schema extraction ([#3131][], [#3166][], [#3177][])
-* Tracing: peer.service adjustment for sql propagation with DBM ([#3127][])
-* Ci-app: CI visibility: validate git tags ([#3100][])
-* Appsec: Enable configuring blocking response via Remote Configuration  ([#3099][])
+* Detect `WebMock` `Cucumber` and `Rails.env` to disable telemetry and remote configuration for development environment ([#3065][], [#3062][], [#3145][])
+* Profiling: Import java-profiler PID controller and port it to C ([#3190][])
 * Profiling: Record allocation type when sampling objects ([#3096][])
-* Appsec: Uppgrade libddwaf-rb version to 1.11.0 ([#3087][])
-* Profiling: Mergequeue-status: removed: Include 'ruby vm type' in profiler allocation samples ([#3074][])
-* Detect WebMock to disable telemetry and remote configuration  ([#3065][])
-* Ensure Rails testing is considered a development environment ([#3062][])
+* Profiling: Include `ruby vm type` in profiler allocation samples ([#3074][])
+* Tracing: Support `Rack` 3 ([#3132][])
+* Tracing: Support `Opensearch` 3 ([#3189][])
+* Tracing: `grpc` adds `client_error_handler` option ([#3095][])
+* Tracing: Add `async` option for `test_mode` configuration ([#3158][])
 * Tracing: Implements `_dd.base_service` tag ([#3018][])
 * Appsec: Allow blocking response template configuration via ENV variables  ([#2975][])
-* Ci-app: agentless mode ([#3186][])
+* Appsec: ASM API security. Schema extraction ([#3131][], [#3166][], [#3177][])
+* Appsec: Enable configuring blocking response via Remote Configuration  ([#3099][])
+* Ci-app: Validate git tags ([#3100][])
+* Ci-app: Add agentless mode ([#3186][])
 ### Changed
-* Appsec: skip passing waf addresses when the value is empty ([#3188][])
-* Tracing: Disable memcached command tag by default ([#3171][])
-* Profiling: Upgrade to libdatadog 5 ([#3169][])
+* Appsec: Skip passing waf addresses when the value is empty ([#3188][])
 * Profiling: Restore support for Ruby 3.3 ([#3167][])
-* Bump debase-ruby_core_source dependency to 3.2.2 ([#3163][])
 * Profiling: Add approximate thread state categorization for timeline ([#3162][])
-* Tracing: remove variable helpers module from our configuration DSL ([#3152][])
-* Profiling: Tracing: ekump/decouple core transport ([#3150][])
-* Test:Remove explicit dependency on `addressable` ([#3148][])
-* Detect Cucumber as a development environment ([#3145][])
-* Tracing: rename core configuration option on_set to after_set ([#3107][])
-* Profiling: Upgrade to libdatadog 4 ([#3104][])
 * Profiling: Wire up allocation sampling into `CpuAndWallTimeWorker` ([#3103][])
-* Tracing: rename experimental_default_proc to default_proc ([#3091][])
-* remove `delegate_to` configuration option from our DSL ([#3086][])
-* Ci-app: Fix Datadog::CI::Environment to support the new CI specs ([#3080][])
+* Tracing: `dalli` disable memcached command tag by default ([#3171][])
 * Tracing: Use first valid extracted style for distributed tracing ([#2879][])
+* Tracing: Rename configuration option `on_set` to `after_set` ([#3107][])
+* Tracing: Rename `experimental_default_proc` to `default_proc` ([#3091][])
+* Tracing: Use `peer.service` for sql comment propagation ([#3127][])
+* Ci-app: Fix `Datadog::CI::Environment` to support the new CI specs ([#3080][])
+* Bump `datadog-ci` dependency to 0.2 ([#3186][])
+* Bump `debase-ruby_core_source` dependency to 3.2.2 ([#3163][])
+* Upgrade `libdatadog` 5 ([#3169][], [#3104][])
+* Upgrade `libddwaf-rb` 1.11.0 ([#3087][])
+* Update AppSec rules to 1.8.0 ([#3140][], [#3139][])
 ### Fixed
 * Profiling: Add workaround for incorrect invoke location when logging gem is in use ([#3183][])
-* Profiling: Fix missing endpoint profiling when request_queuing is enabled in rack instrumentation ([#3109][])
-* Appsec: Fix a bug with ASM span tags reporting the number of WAF failed loaded rules ([#3106][])
+* Profiling: Fix missing endpoint profiling when `request_queuing` is enabled in `rack` instrumentation ([#3109][])
+* Appsec: Span tags reporting the number of WAF failed loaded rules ([#3106][])
 * Tracing: Fix tagging with empty data ([#3102][])
-* Tracing: fix(grpc): allow custom error_handler for client interceptor ([#3095][])
-* Tracing: Correctly set `rails.cache.backend` span tag for multiple stores ([#3060][])
+* Tracing: Fix `rails.cache.backend` span tag with multiple stores ([#3060][])
 ### Removed
 * Profiling: Remove legacy profiler codepath ([#3172][])
-* Ci-app: remove CI module and add a dependency on datadog-ci gem ([#3128][])
-* Tracing: Remove `depends_on` from Core Configuration option ([#3085][])
+* Ci-app: Remove CI module and add a dependency on [`datadog-ci` gem](https://github.com/DataDog/datadog-ci-rb) ([#3128][])
+* Tracing: Remove `depends_on` option from configuration DSL ([#3085][])
+* Tracing: Remove `delegate_to` option from configuration DSL ([#3086][])
 ## [1.14.0] - 2023-08-24
@@ -2663,7 +2657,12 @@ 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.15.0...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
 [1.14.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.13.1...1.14.0
 [1.13.1]: https://github.com/DataDog/dd-trace-rb/compare/v1.13.0...1.13.1
@@ -3401,6 +3400,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#1509]: https://github.com/DataDog/dd-trace-rb/issues/1509
 [#1510]: https://github.com/DataDog/dd-trace-rb/issues/1510
 [#1511]: https://github.com/DataDog/dd-trace-rb/issues/1511
+[#1522]: https://github.com/DataDog/dd-trace-rb/issues/1522
 [#1523]: https://github.com/DataDog/dd-trace-rb/issues/1523
 [#1524]: https://github.com/DataDog/dd-trace-rb/issues/1524
 [#1529]: https://github.com/DataDog/dd-trace-rb/issues/1529
@@ -3842,12 +3842,14 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#3127]: https://github.com/DataDog/dd-trace-rb/issues/3127
 [#3128]: https://github.com/DataDog/dd-trace-rb/issues/3128
 [#3131]: https://github.com/DataDog/dd-trace-rb/issues/3131
+[#3132]: https://github.com/DataDog/dd-trace-rb/issues/3132
 [#3139]: https://github.com/DataDog/dd-trace-rb/issues/3139
 [#3140]: https://github.com/DataDog/dd-trace-rb/issues/3140
 [#3145]: https://github.com/DataDog/dd-trace-rb/issues/3145
 [#3148]: https://github.com/DataDog/dd-trace-rb/issues/3148
 [#3150]: https://github.com/DataDog/dd-trace-rb/issues/3150
 [#3152]: https://github.com/DataDog/dd-trace-rb/issues/3152
+[#3153]: https://github.com/DataDog/dd-trace-rb/issues/3153
 [#3158]: https://github.com/DataDog/dd-trace-rb/issues/3158
 [#3162]: https://github.com/DataDog/dd-trace-rb/issues/3162
 [#3163]: https://github.com/DataDog/dd-trace-rb/issues/3163
@@ -3863,6 +3865,23 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#3188]: https://github.com/DataDog/dd-trace-rb/issues/3188
 [#3189]: https://github.com/DataDog/dd-trace-rb/issues/3189
 [#3190]: https://github.com/DataDog/dd-trace-rb/issues/3190
+[#3197]: https://github.com/DataDog/dd-trace-rb/issues/3197
+[#3204]: https://github.com/DataDog/dd-trace-rb/issues/3204
+[#3206]: https://github.com/DataDog/dd-trace-rb/issues/3206
+[#3207]: https://github.com/DataDog/dd-trace-rb/issues/3207
+[#3223]: https://github.com/DataDog/dd-trace-rb/issues/3223
+[#3234]: https://github.com/DataDog/dd-trace-rb/issues/3234
+[#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/contrib/rack/gateway/request.rb CHANGED Viewed

@@ -40,9 +40,13 @@ module Datadog
             end
             def headers
-              request.env.each_with_object({}) do |(k, v), h|
-                h[k.gsub(/^HTTP_/, '').downcase.tr('_', '-')] = v if k =~ /^HTTP_/
+              result = request.env.each_with_object({}) do |(k, v), h|
+                h[k.gsub(/^HTTP_/, '').downcase!.tr('_', '-')] = v if k =~ /^HTTP_/
               end
+              result['content-type'] = request.content_type if request.content_type
+              result['content-length'] = request.content_length if request.content_length
+              result
             end
             def body

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

@@ -70,7 +70,7 @@ module Datadog
               request_return[2],
               request_return[0],
               request_return[1],
-              scope: scope
+              scope: scope,
             )
             _response_return, response_response = Instrumentation.gateway.push('rack.response', gateway_response)

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

@@ -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/core/remote/worker.rb CHANGED Viewed

@@ -28,7 +28,9 @@ module Datadog
           @starting = true
-          @thr = Thread.new { poll(@interval) }
+          thread = Thread.new { poll(@interval) }
+          thread.name = self.class.name unless Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.3')
+          @thr = thread
           @started = true
           @starting = false

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

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

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

@@ -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/profiling/collectors/cpu_and_wall_time_worker.rb CHANGED Viewed

@@ -53,7 +53,7 @@ module Datadog
           @idle_sampling_helper = idle_sampling_helper
         end
-        def start
+        def start(on_failure_proc: nil)
           @start_stop_mutex.synchronize do
             return if @worker_thread && @worker_thread.alive?
@@ -74,6 +74,7 @@ module Datadog
                   'CpuAndWallTimeWorker thread error. ' \
                   "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
                 )
+                on_failure_proc&.call
               end
             end
             @worker_thread.name = self.class.name # Repeated from above to make sure thread gets named asap

data/lib/datadog/profiling/profiler.rb CHANGED Viewed

@@ -21,18 +21,42 @@ module Datadog
           scheduler.reset_after_fork
         end
-        worker.start
-        scheduler.start
+        worker.start(on_failure_proc: proc { component_failed(:worker) })
+        scheduler.start(on_failure_proc: proc { component_failed(:scheduler) })
       end
       def shutdown!
         Datadog.logger.debug('Shutting down profiler')
+        stop_worker
+        stop_scheduler
+      end
+      private
+      def stop_worker
         worker.stop
+      end
+      def stop_scheduler
         scheduler.enabled = false
         scheduler.stop(true)
       end
+      def component_failed(failed_component)
+        Datadog.logger.warn(
+          "Detected issue with profiler (#{failed_component} component), stopping profiling. " \
+          'See previous log messages for details.'
+        )
+        if failed_component == :worker
+          stop_scheduler
+        elsif failed_component == :scheduler
+          stop_worker
+        else
+          raise ArgumentError, "Unexpected failed_component: #{failed_component.inspect}"
+        end
+      end
     end
   end
 end

data/lib/datadog/profiling/scheduler.rb CHANGED Viewed

@@ -45,20 +45,27 @@ module Datadog
         self.enabled = enabled
       end
-      def start
-        perform
+      def start(on_failure_proc: nil)
+        perform(on_failure_proc)
       end
-      def perform
-        # A profiling flush may be called while the VM is shutting down, to report the last profile. When we do so,
-        # we impose a strict timeout. This means this last profile may or may not be sent, depending on if the flush can
-        # successfully finish in the strict timeout.
-        # This can be somewhat confusing (why did it not get reported?), so let's at least log what happened.
-        interrupted = true
+      def perform(on_failure_proc)
         begin
+          # A profiling flush may be called while the VM is shutting down, to report the last profile. When we do so,
+          # we impose a strict timeout. This means this last profile may or may not be sent, depending on if the flush can
+          # successfully finish in the strict timeout.
+          # This can be somewhat confusing (why did it not get reported?), so let's at least log what happened.
+          interrupted = true
           flush_and_wait
           interrupted = false
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          Datadog.logger.warn(
+            'Profiling::Scheduler thread error. ' \
+            "Cause: #{e.class.name} #{e.message} Location: #{Array(e.backtrace).first}"
+          )
+          on_failure_proc&.call
+          raise
         ensure
           Datadog.logger.debug('#flush was interrupted or failed before it could complete') if interrupted
         end

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

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

@@ -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/contrib/active_support/cache/instrumentation.rb CHANGED Viewed

@@ -101,7 +101,9 @@ module Datadog
                 # DEV: String#underscore is available through ActiveSupport, and is
                 # DEV: the exact reverse operation to `#camelize`.
-                @store_name = self.class.name.underscore.match(%r{active_support/cache/(.*)})[1]
+                # DEV: String#demodulize is available through ActiveSupport, and is
+                # DEV: used to remove the module ('*::') part of a constant name.
+                @store_name = self.class.name.demodulize.underscore
               end
             end

data/lib/datadog/tracing/contrib/concurrent_ruby/context_composite_executor_service.rb CHANGED Viewed

@@ -6,7 +6,7 @@ module Datadog
   module Tracing
     module Contrib
       module ConcurrentRuby
-        # wraps existing executor to carry over trace context
+        # Wraps existing executor to carry over trace context
         class ContextCompositeExecutorService
           include Concurrent::ExecutorService
@@ -16,20 +16,20 @@ module Datadog
             @composited_executor = composited_executor
           end
-          # post method runs the task within composited executor - in a different thread
+          # post method runs the task within composited executor - in a different thread. The original arguments are
+          # captured to be propagated to the composited executor post method
           def post(*args, &task)
-            tracer = Tracing.send(:tracer)
-            parent_context = tracer.provider.context
-            @composited_executor.post(*args) do
-              begin
-                original_context = tracer.provider.context
-                tracer.provider.context = parent_context
-                yield
-              ensure
-                # Restore context in case the current thread gets reused
-                tracer.provider.context = original_context
-              end
+            digest = Tracing.active_trace && Tracing.active_trace.to_digest
+            executor = @composited_executor.is_a?(Symbol) ? Concurrent.executor(@composited_executor) : @composited_executor
+            # Pass the original arguments to the composited executor, which
+            # pushes them (possibly transformed) as block args
+            executor.post(*args) do |*block_args|
+              Tracing.continue_trace!(digest)
+              # Pass the executor-provided block args as they should have been
+              # originally passed without composition, see ChainPromise#on_resolvable
+              yield(*block_args)
             end
           end

data/lib/datadog/tracing/contrib/concurrent_ruby/future_patch.rb CHANGED Viewed

@@ -8,17 +8,10 @@ module Datadog
       module ConcurrentRuby
         # This patches the Future - to wrap executor service using ContextCompositeExecutorService
         module FuturePatch
-          def self.included(base)
-            base.class_eval do
-              alias_method :ns_initialize_without_datadog, :ns_initialize
-              remove_method(:ns_initialize)
+          def ns_initialize(value, opts)
+            super(value, opts)
-              def ns_initialize(value, opts)
-                ns_initialize_without_datadog(value, opts)
-                @executor = ContextCompositeExecutorService.new(@executor)
-              end
-            end
+            @executor = ContextCompositeExecutorService.new(@executor)
           end
         end
       end

data/lib/datadog/tracing/contrib/concurrent_ruby/integration.rb CHANGED Viewed

@@ -20,7 +20,8 @@ module Datadog
           end
           def self.loaded?
-            !defined?(::Concurrent::Future).nil?
+            # Concurrent::Future is deprecated in favour of Concurrent::Promises::Future
+            !defined?(::Concurrent::Promises::Future).nil? || !defined?(::Concurrent::Future).nil?
           end
           def self.compatible?

data/lib/datadog/tracing/contrib/concurrent_ruby/patcher.rb CHANGED Viewed

@@ -19,11 +19,18 @@ module Datadog
           def patch
             require_relative 'future_patch'
             patch_future
+            require_relative 'promises_future_patch'
+            patch_promises_future
           end
           # Propagate tracing context in Concurrent::Future
           def patch_future
-            ::Concurrent::Future.include(FuturePatch)
+            ::Concurrent::Future.prepend(FuturePatch) if defined?(::Concurrent::Future)
+          end
+          # Propagate tracing context in Concurrent::Promises::Future
+          def patch_promises_future
+            ::Concurrent::Promises.singleton_class.prepend(PromisesFuturePatch) if defined?(::Concurrent::Promises::Future)
           end
         end
       end

data/lib/datadog/tracing/contrib/concurrent_ruby/promises_future_patch.rb ADDED Viewed

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require_relative 'context_composite_executor_service'
+module Datadog
+  module Tracing
+    module Contrib
+      module ConcurrentRuby
+        # This patches the Future - to wrap executor service using ContextCompositeExecutorService
+        module PromisesFuturePatch
+          def future_on(default_executor, *args, &task)
+            unless default_executor.is_a?(ContextCompositeExecutorService)
+              default_executor = ContextCompositeExecutorService.new(default_executor)
+            end
+            super(default_executor, *args, &task)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/datadog/tracing/contrib/redis/configuration/settings.rb CHANGED Viewed

@@ -32,7 +32,7 @@ module Datadog
             option :command_args do |o|
               o.type :bool
               o.env Ext::ENV_COMMAND_ARGS
-              o.default true
+              o.default false
             end
             option :service_name do |o|

data/lib/datadog/tracing/contrib/redis/instrumentation.rb CHANGED Viewed

@@ -3,6 +3,7 @@ require_relative 'configuration/resolver'
 require_relative 'ext'
 require_relative 'quantize'
 require_relative 'tags'
+require_relative 'trace_middleware'
 module Datadog
   module Tracing
@@ -17,31 +18,11 @@ module Datadog
           # InstanceMethods - implementing instrumentation
           module InstanceMethods
             def call(*args, &block)
-              show_command_args = command_args?
-              Tracing.trace(Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-                span.service = service_name
-                span.span_type = Contrib::Redis::Ext::TYPE
-                span.resource = get_command(args, show_command_args)
-                Contrib::Redis::Tags.set_common_tags(self, span, show_command_args)
-                super
-              end
+              TraceMiddleware.call(self, args[0], service_name, command_args?) { super }
             end
             def call_pipeline(*args, &block)
-              show_command_args = command_args?
-              Tracing.trace(Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-                span.service = service_name
-                span.span_type = Contrib::Redis::Ext::TYPE
-                commands = get_pipeline_commands(args, show_command_args)
-                span.resource = commands.any? ? commands.join("\n") : '(none)'
-                span.set_metric Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
-                Contrib::Redis::Tags.set_common_tags(self, span, show_command_args)
-                super
-              end
+              TraceMiddleware.call_pipelined(self, args[0].commands, service_name, command_args?) { super }
             end
             private
@@ -59,22 +40,6 @@ module Datadog
                 datadog_configuration[:service_name]
             end
-            def get_command(args, show_command_args)
-              if show_command_args
-                Contrib::Redis::Quantize.format_command_args(*args)
-              else
-                Contrib::Redis::Quantize.get_verb(*args)
-              end
-            end
-            def get_pipeline_commands(args, show_command_args)
-              if show_command_args
-                args[0].commands.map { |c| Contrib::Redis::Quantize.format_command_args(c) }
-              else
-                args[0].commands.map { |c| Contrib::Redis::Quantize.get_verb(c) }
-              end
-            end
             def datadog_configuration
               Datadog.configuration.tracing[:redis, options]
             end

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

@@ -12,7 +12,7 @@ module Datadog
         # Tags handles generic common tags assignment.
         module Tags
           class << self
-            def set_common_tags(client, span, show_command_args)
+            def set_common_tags(client, span, raw_command)
               if datadog_configuration[:peer_service]
                 span.set_tag(
                   Tracing::Metadata::Ext::TAG_PEER_SERVICE,
@@ -42,7 +42,7 @@ module Datadog
               span.set_tag Ext::TAG_DATABASE_INDEX, client.db.to_s
               span.set_tag Ext::TAG_DB, client.db
-              span.set_tag Ext::TAG_RAW_COMMAND, span.resource if show_command_args
+              span.set_tag Ext::TAG_RAW_COMMAND, raw_command
               Contrib::SpanAttributeSchema.set_peer_service!(span, Ext::PEER_SERVICE_SOURCES)
             end

data/lib/datadog/tracing/contrib/redis/trace_middleware.rb CHANGED Viewed

@@ -9,55 +9,68 @@ module Datadog
       module Redis
         # Instrumentation for Redis 5+
         module TraceMiddleware
-          def call(commands, redis_config)
-            Tracing.trace(Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-              datadog_configuration = resolve(redis_config)
-              resource = get_command(commands, datadog_configuration[:command_args])
+          # Instruments {RedisClient::ConnectionMixin#call}.
+          def call(command, redis_config)
+            config = resolve(redis_config)
+            TraceMiddleware.call(redis_config, command, config[:service_name], config[:command_args]) { super }
+          end
+          # Instruments {RedisClient::ConnectionMixin#call_pipelined}.
+          def call_pipelined(commands, redis_config)
+            config = resolve(redis_config)
+            TraceMiddleware.call_pipelined(redis_config, commands, config[:service_name], config[:command_args]) { super }
+          end
-              span.service = datadog_configuration[:service_name]
-              span.span_type = Contrib::Redis::Ext::TYPE
-              span.resource = resource
+          class << self
+            def call(client, command, service_name, command_args)
+              Tracing.trace(Redis::Ext::SPAN_COMMAND, type: Redis::Ext::TYPE, service: service_name) do |span|
+                raw_command = get_command(command, true)
+                span.resource = command_args ? raw_command : get_command(command, false)
-              Contrib::Redis::Tags.set_common_tags(redis_config, span, datadog_configuration[:command_args])
+                Contrib::Redis::Tags.set_common_tags(client, span, raw_command)
-              super
+                yield
+              end
             end
-          end
-          def call_pipelined(commands, redis_config)
-            Tracing.trace(Contrib::Redis::Ext::SPAN_COMMAND) do |span|
-              datadog_configuration = resolve(redis_config)
-              pipelined_commands = get_pipeline_commands(commands, datadog_configuration[:command_args])
+            def call_pipelined(client, commands, service_name, command_args)
+              Tracing.trace(Redis::Ext::SPAN_COMMAND, type: Redis::Ext::TYPE, service: service_name) do |span|
+                raw_command = get_pipeline_commands(commands, true)
+                span.resource = command_args ? raw_command : get_pipeline_commands(commands, false)
-              span.service = datadog_configuration[:service_name]
-              span.span_type = Contrib::Redis::Ext::TYPE
-              span.resource = pipelined_commands.join("\n")
-              span.set_metric Contrib::Redis::Ext::METRIC_PIPELINE_LEN, pipelined_commands.length
+                span.set_metric Contrib::Redis::Ext::METRIC_PIPELINE_LEN, commands.length
-              Contrib::Redis::Tags.set_common_tags(redis_config, span, datadog_configuration[:command_args])
+                Contrib::Redis::Tags.set_common_tags(client, span, raw_command)
-              super
+                yield
+              end
             end
-          end
-          private
+            private
-          def get_command(commands, boolean)
-            if boolean
-              Contrib::Redis::Quantize.format_command_args(commands)
-            else
-              Contrib::Redis::Quantize.get_verb(commands)
+            # Quantizes a single Redis command
+            def get_command(command, command_args)
+              if command_args
+                Contrib::Redis::Quantize.format_command_args(command)
+              else
+                Contrib::Redis::Quantize.get_verb(command)
+              end
             end
-          end
-          def get_pipeline_commands(commands, boolean)
-            if boolean
-              commands.map { |c| Contrib::Redis::Quantize.format_command_args(c) }
-            else
-              commands.map { |c| Contrib::Redis::Quantize.get_verb(c) }
+            # Quantizes a multi-command Redis pipeline execution
+            def get_pipeline_commands(commands, command_args)
+              list = if command_args
+                       commands.map { |c| Contrib::Redis::Quantize.format_command_args(c) }
+                     else
+                       commands.map { |c| Contrib::Redis::Quantize.get_verb(c) }
+                     end
+              list.empty? ? '(none)' : list.join("\n")
             end
           end
+          private
           def resolve(redis_config)
             custom = redis_config.custom[:datadog] || {}

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

@@ -137,6 +137,12 @@ module Datadog
           private
           def instrumented_integrations
+            # `instrumented_integrations` method is added only if tracing contrib extensions are required.
+            # If tracing is used in manual mode without integrations enabled this method does not exist.
+            # CI visibility gem datadog-ci uses Datadog::Tracer without requiring datadog/tracing/contrib folder
+            # nor enabling any integrations by default which causes EnvironmentCollector to fail.
+            return {} unless Datadog.configuration.tracing.respond_to?(:instrumented_integrations)
             Datadog.configuration.tracing.instrumented_integrations
           end

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

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

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

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

@@ -3,7 +3,7 @@
 module DDTrace
   module VERSION
     MAJOR = 1
-    MINOR = 15
+    MINOR = 17
     PATCH = 0
     PRE = nil
     BUILD = nil

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ddtrace
 version: !ruby/object:Gem::Version
-  version: 1.15.0
+  version: 1.17.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-09 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.2.0
+        version: 0.4.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.2.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
@@ -514,6 +514,7 @@ files:
 - lib/datadog/tracing/contrib/concurrent_ruby/future_patch.rb
 - lib/datadog/tracing/contrib/concurrent_ruby/integration.rb
 - lib/datadog/tracing/contrib/concurrent_ruby/patcher.rb
+- lib/datadog/tracing/contrib/concurrent_ruby/promises_future_patch.rb
 - lib/datadog/tracing/contrib/configurable.rb
 - lib/datadog/tracing/contrib/configuration/resolver.rb
 - lib/datadog/tracing/contrib/configuration/resolvers/pattern_resolver.rb
@@ -889,7 +890,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Datadog tracing code for your Ruby applications