datadog 2.40.0 → 2.42.0

data/lib/datadog/tracing/transport/native.rb

@@ -65,6 +65,10 @@ module Datadog
             # fork-safety note below.
             @send_mutex = Mutex.new
 
+            # Serializes concurrent fork-hook lifecycles. Unlike @send_mutex,
+            # this is held across the fork through the matching completion hook.
+            @fork_mutex = Mutex.new
+
             url = agent_settings.url
             tracer_version = tracer_version_string
             language = Core::Environment::Ext::LANG
@@ -106,8 +110,15 @@ module Datadog
             # also tears down and replaces the runtime, so it must not run while
             # a send is still using that runtime.
             #
-            # `@send_mutex` serializes sends (see #send_traces) and is held
-            # across the fork. The `:before` hook first calls
+            # `@fork_mutex` serializes concurrent forks for this exporter. The
+            # `:before` hook locks it first, then calls `_native_before_fork`,
+            # and finally locks `@send_mutex`, which serializes sends and is
+            # held across the fork. Sends and #close only acquire @send_mutex,
+            # so there is no lock-order inversion.
+            #
+            # `_native_before_fork` must run before locking `@send_mutex` to
+            # pause the runtime before waiting for an in-flight send to drain.
+            # The hook first calls
             # `_native_before_fork` to pause the runtime, THEN locks the mutex.
             # This ordering minimizes the serialized section and is safe to run
             # concurrently with an in-flight send: `block_on` (used by
@@ -136,25 +147,29 @@ module Datadog
             # hooks when it goes away (see #close and the finalizer): otherwise
             # the closures keep the exporter -- and its runtime threads -- alive
             # forever, and every later fork runs them against every
-            # historically-created exporter. The closures intentionally capture
-            # only the `exporter`/`send_mutex` locals (NOT `self`), so the
-            # Transport stays GC-eligible and its finalizer can fire even when
-            # #close was not called explicitly.
+            # historically-created exporter. The closures intentionally close
+            # over only locals (NOT `self`), so the Transport stays GC-eligible and
+            # its finalizer can fire even when #close was not called explicitly.
             send_mutex = @send_mutex
-            before_hook = Core::Utils::AtForkMonkeyPatch.at_fork(:before) do
-              # Pause the runtime first (safe to run concurrently with an
-              # in-flight send), then drain by locking the mutex. The lock must
-              # happen even if `_native_before_fork` raises, so the in-flight
-              # send has returned (dropping the runtime's last `Arc`) before the
-              # fork. Held across the fork; released in :parent/:child.
-              exporter._native_before_fork
-            rescue => e
-              Datadog.logger.warn { "Native transport before-fork preparation failed; traces may not be sent to Datadog: #{e.class}: #{e.message}" }
-            ensure
-              send_mutex.lock
+            fork_mutex = @fork_mutex
+            before_hook = proc do
+              fork_mutex.lock
+
+              begin
+                # Pause the runtime first (safe to run concurrently with an
+                # in-flight send), then wait for it to drain by acquiring the
+                # mutex. The lock must happen even if `_native_before_fork` raises, so the
+                # in-flight send has returned before the fork. Held across the
+                # fork; released in :parent/:child.
+                exporter._native_before_fork
+              rescue => e
+                Datadog.logger.warn { "Native transport before-fork preparation failed; traces may not be sent to Datadog: #{e.class}: #{e.message}" }
+              ensure
+                send_mutex.lock
+              end
             end
-            parent_hook = Core::Utils::AtForkMonkeyPatch.at_fork(:parent) do
-              exporter._native_after_fork_in_parent
+            parent_hook = proc do
+              exporter._native_after_fork_in_parent if fork_mutex.owned?
             rescue => e
               Datadog.logger.warn { "Native transport after-fork reset failed; traces may not be sent to Datadog: #{e.class}: #{e.message}" }
             ensure
@@ -164,9 +179,10 @@ module Datadog
               # between `_native_before_fork` and the lock). Released even if the
               # native call raised, so a failure can't leave the mutex locked.
               send_mutex.unlock if send_mutex.owned?
+              fork_mutex.unlock if fork_mutex.owned?
             end
-            child_hook = Core::Utils::AtForkMonkeyPatch.at_fork(:child) do
-              exporter._native_after_fork_in_child
+            child_hook = proc do
+              exporter._native_after_fork_in_child if fork_mutex.owned?
             rescue => e
               Datadog.logger.warn { "Native transport after-fork reset failed; traces may not be sent to Datadog: #{e.class}: #{e.message}" }
             ensure
@@ -174,61 +190,70 @@ module Datadog
               # lone survivor in the child); the guard only covers `:before`
               # being interrupted mid-lock.
               send_mutex.unlock if send_mutex.owned?
+              fork_mutex.unlock if fork_mutex.owned?
             end
 
-            @fork_hooks = {before: before_hook, parent: parent_hook, child: child_hook}
+            @fork_hooks = Core::Utils::AtForkMonkeyPatch.at_fork_blocks(
+              before: before_hook,
+              parent: parent_hook,
+              child: child_hook
+            )
+            remove_fork_hooks = self.class.send(:fork_hooks_remover, @fork_hooks)
 
             # Fallback so a dropped (un-#close'd) transport doesn't leak its
             # global fork hooks (and, through them, the exporter/runtime). The
-            # finalizer proc is built by a class method capturing ONLY the
+            # removal proc is built by a class method capturing ONLY the
             # stage->block handles, never `self` -- a finalizer that closed over
             # the object it is attached to would keep that object reachable and
-            # never run.
-            ObjectSpace.define_finalizer(self, self.class.send(:finalizer_for, @fork_hooks))
+            # never run. A fork that already copied these callbacks still owns
+            # them through its matching completion stage.
+            ObjectSpace.define_finalizer(
+              self,
+              remove_fork_hooks
+            )
           end
 
           # Deregister this transport's process-global fork hooks and release the
           # native exporter so its runtime can shut down. Idempotent: safe to
           # call multiple times and safe to call after the finalizer has run.
           def close
-            fork_hooks = @fork_hooks
-            @fork_hooks = nil
-            return if fork_hooks.nil?
+            fork_hooks = @send_mutex.synchronize do
+              hooks = @fork_hooks
+              return if hooks.nil?
+
+              @fork_hooks = nil
+              @exporter = nil
+              hooks
+            end
 
             fork_hooks.each do |stage, block|
               Core::Utils::AtForkMonkeyPatch.remove_at_fork(stage, block)
             end
 
-            # Drop our reference to the exporter so that, once the hooks above no
-            # longer pin it, it can be collected and its runtime shut down
-            # cleanly in this (parent) process.
-            @exporter = nil
-
             # The finalizer only exists to deregister the hooks for a transport
             # dropped without #close. We have just done that, so remove it;
-            # otherwise its captured hook blocks keep the exporter (and its
-            # runtime threads) alive until this still-reachable transport is
-            # itself collected.
+            # otherwise its closed-over hook blocks keep the exporter alive until
+            # this transport is itself collected.
             ObjectSpace.undefine_finalizer(self)
 
             nil
           end
 
-          # Builds the finalizer proc for a transport's fork hooks.
+          # Builds the proc that deregisters a transport's fork hooks.
           #
           # Defined as a class method so the proc closes over ONLY the
           # stage->block handles passed in and never over a Transport instance
           # (which would keep the instance reachable and prevent the finalizer
           # from ever running). Removing the hooks unpins the exporter captured
           # by those closures, allowing it (and its runtime) to be freed.
-          def self.finalizer_for(fork_hooks)
+          def self.fork_hooks_remover(fork_hooks)
             proc do
               fork_hooks.each do |stage, block|
                 Core::Utils::AtForkMonkeyPatch.remove_at_fork(stage, block)
               end
             end
           end
-          private_class_method :finalizer_for
+          private_class_method :fork_hooks_remover
 
           # Send a list of traces to the agent.
           #
@@ -240,12 +265,6 @@ module Datadog
           def send_traces(traces)
             return [] if traces.empty?
 
-            # A closed transport has released its exporter; there is nothing to
-            # send through. Raising here is caught below and surfaced as an
-            # InternalErrorResponse, matching the other failure paths.
-            exporter = @exporter
-            raise "Native transport has been closed" if exporter.nil?
-
             # Apply trace-level tags to root spans (same as the HTTP transport)
             traces.each { |trace| TraceFormatter.format!(trace) }
 
@@ -253,9 +272,8 @@ module Datadog
             # Each trace segment becomes one inner array (one trace chunk).
             chunks = traces.map(&:spans)
 
-            # The native exporter only serializes scalar fields plus meta and
-            # metrics; span events, span links, and meta_struct are not yet
-            # converted and would be dropped. Warn (once) so the loss is visible.
+            # Span events and span links are not yet converted and would be
+            # dropped. Warn (once) so the loss is visible.
             warn_unsupported_fields!(chunks)
 
             # Serialize the native send and hold the mutex across it so a
@@ -263,7 +281,14 @@ module Datadog
             # (and `_native_before_fork` cannot tear down the runtime mid-send).
             # `Mutex#synchronize` releases on exception / `rb_jump_tag` via its
             # ensure, so interrupt propagation stays correct.
-            responses = @send_mutex.synchronize { exporter._native_send_traces(chunks) }
+            responses = @send_mutex.synchronize do
+              # Resolve the exporter under the same lock used by #close, so
+              # close either drains this send or prevents it from starting.
+              exporter = @exporter
+              raise "Native transport has been closed" if exporter.nil?
+
+              exporter._native_send_traces(chunks)
+            end
 
             # Update statistics from the response
             responses.each { |response| update_stats_from_response!(response) }
@@ -278,10 +303,10 @@ module Datadog
           private
 
           # Warn, at most once per transport, when a batch contains span fields
-          # the native exporter does not yet convert (span events, span links,
-          # meta_struct). These are silently dropped by the native path; full
-          # support is tracked separately. The check is cheap: the fields are
-          # already-materialized collections on each Span.
+          # the native exporter does not yet convert (span events and span
+          # links). These are silently dropped by the native path; full support
+          # is tracked separately. The check is cheap: the fields are already-
+          # materialized collections on each Span.
           def warn_unsupported_fields!(chunks)
             return if @unsupported_fields_warned
 
@@ -290,7 +315,6 @@ module Datadog
               spans.each do |span|
                 unsupported << "span events" if span.events.any?
                 unsupported << "span links" if span.links.any?
-                unsupported << "meta_struct" unless span.metastruct.to_h.empty?
               end
             end
             return if unsupported.empty?

data/lib/datadog/tracing/writer.rb

@@ -130,7 +130,7 @@ module Datadog
       def stats
         {
           traces_flushed: @traces_flushed,
-          transport: @transport.stats
+          transport: @transport.stats,
         }
       end
 

data/lib/datadog/version.rb

@@ -3,7 +3,7 @@
 module Datadog
   module VERSION
     MAJOR = 2
-    MINOR = 40
+    MINOR = 42
     PATCH = 0
     PRE = nil
     BUILD = nil

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datadog
 version: !ruby/object:Gem::Version
-  version: 2.40.0
+  version: 2.42.0
 platform: ruby
 authors:
 - Datadog, Inc.
@@ -32,7 +32,7 @@ dependencies:
         version: '3.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.5.4
+        version: 3.5.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -42,7 +42,7 @@ dependencies:
         version: '3.5'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.5.4
+        version: 3.5.5
 - !ruby/object:Gem::Dependency
   name: libddwaf
   requirement: !ruby/object:Gem::Requirement
@@ -63,14 +63,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 36.0.0.1.0
+        version: 40.0.0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 36.0.0.1.0
+        version: 40.0.0.2.0
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
@@ -181,6 +181,8 @@ files:
 - ext/libdatadog_api/init.c
 - ext/libdatadog_api/library_config.c
 - ext/libdatadog_api/library_config.h
+- ext/libdatadog_api/otel_thread_context.c
+- ext/libdatadog_api/otel_thread_context.h
 - ext/libdatadog_api/process_discovery.c
 - ext/libdatadog_api/process_discovery.h
 - ext/libdatadog_api/trace_exporter.c
@@ -432,6 +434,7 @@ files:
 - lib/datadog/core/tag_builder.rb
 - lib/datadog/core/tag_normalizer.rb
 - lib/datadog/core/telemetry/component.rb
+- lib/datadog/core/telemetry/configuration_value.rb
 - lib/datadog/core/telemetry/emitter.rb
 - lib/datadog/core/telemetry/event.rb
 - lib/datadog/core/telemetry/event/app_client_configuration_change.rb
@@ -1095,13 +1098,16 @@ files:
 - lib/datadog/tracing/distributed/b3_single.rb
 - lib/datadog/tracing/distributed/baggage.rb
 - lib/datadog/tracing/distributed/datadog.rb
-- lib/datadog/tracing/distributed/datadog_tags_codec.rb
 - lib/datadog/tracing/distributed/fetcher.rb
 - lib/datadog/tracing/distributed/helpers.rb
 - lib/datadog/tracing/distributed/none.rb
 - lib/datadog/tracing/distributed/propagation.rb
 - lib/datadog/tracing/distributed/propagation_policy.rb
 - lib/datadog/tracing/distributed/trace_context.rb
+- lib/datadog/tracing/distributed/trace_state.rb
+- lib/datadog/tracing/distributed/trace_state/datadog.rb
+- lib/datadog/tracing/distributed/trace_state/ext.rb
+- lib/datadog/tracing/distributed/trace_state/open_telemetry.rb
 - lib/datadog/tracing/event.rb
 - lib/datadog/tracing/ext.rb
 - lib/datadog/tracing/flush.rb
@@ -1112,6 +1118,7 @@ files:
 - lib/datadog/tracing/metadata/metastruct.rb
 - lib/datadog/tracing/metadata/metastruct_tagging.rb
 - lib/datadog/tracing/metadata/tagging.rb
+- lib/datadog/tracing/otel_thread_context.rb
 - lib/datadog/tracing/pipeline.rb
 - lib/datadog/tracing/pipeline/span_filter.rb
 - lib/datadog/tracing/pipeline/span_processor.rb
@@ -1165,8 +1172,8 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.40.0/CHANGELOG.md
-  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.40.0
+  changelog_uri: https://github.com/DataDog/dd-trace-rb/blob/v2.42.0/CHANGELOG.md
+  source_code_uri: https://github.com/DataDog/dd-trace-rb/tree/v2.42.0
 post_install_message: 'JRuby support in the datadog gem is deprecated. Details: https://dtdg.co/jruby-deprecation'
 rdoc_options: []
 require_paths:

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

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Datadog
-  module Tracing
-    module Distributed
-      # Encodes and decodes distributed 'x-datadog-tags' tags for transport
-      # to and from external processes.
-      module DatadogTagsCodec
-        # ASCII characters 32-126, except `,`, `=`, and ` `. At least one character.
-        VALID_KEY_CHARS = /\A(?:(?![,= ])[\u0020-\u007E])+\Z/.freeze
-        # ASCII characters 32-126, except `,`. At least one character.
-        VALID_VALUE_CHARS = /\A(?:(?!,)[\u0020-\u007E])+\Z/.freeze
-
-        # Serializes a {Hash<String,String>} into a `x-datadog-tags`-compatible
-        # String.
-        #
-        # @param tags [Hash<String,String>] trace tag hash
-        # @return [String] serialized tags hash
-        # @raise [EncodingError] if tags cannot be serialized to the `x-datadog-tags` format
-        def self.encode(tags)
-          tags.map do |raw_key, raw_value|
-            key = raw_key.to_s
-            value = raw_value.to_s
-
-            raise EncodingError, "Invalid key `#{key}` for value `#{value}`" unless VALID_KEY_CHARS.match?(key)
-            raise EncodingError, "Invalid value `#{value}` for key `#{key}`" unless VALID_VALUE_CHARS.match?(value)
-
-            "#{key}=#{value.strip}"
-          end.join(",")
-        rescue => e
-          raise EncodingError, "Error encoding tags `#{tags}`: `#{e.class}: #{e.message}`"
-        end
-
-        # Deserializes a `x-datadog-tags`-formatted String into a {Hash<String,String>}.
-        #
-        # @param string [String] tags as serialized by {#encode}
-        # @return [Hash<String,String>] decoded input as a hash of strings
-        # @raise [DecodingError] if string does not conform to the `x-datadog-tags` format
-        def self.decode(string)
-          result = (string.split(",").map do |raw_tag|
-            raw_tag.split("=", 2).tap do |raw_key, raw_value|
-              key = raw_key.to_s
-              value = raw_value.to_s
-
-              raise DecodingError, "Invalid key: #{key}" unless VALID_KEY_CHARS.match?(key)
-              raise DecodingError, "Invalid value: #{value}" unless VALID_VALUE_CHARS.match?(value)
-
-              value.strip!
-            end
-          end).to_h
-
-          raise DecodingError, "Invalid empty tags: #{string}" if result.empty? && !string.empty?
-
-          result
-        end
-
-        # An error occurred during distributed tags encoding.
-        # See {#message} for more information.
-        class EncodingError < StandardError
-        end
-
-        # An error occurred during distributed tags decoding.
-        # See {#message} for more information.
-        class DecodingError < StandardError
-        end
-      end
-    end
-  end
-end