datadog 2.36.0 → 2.40.0

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Datadog
+  module Tracing
+    module Transport
+      module Native
+        # Response from the native trace exporter.
+        #
+        # Constructed by the C extension after a send completes (or fails).
+        # Implements the same predicate interface as the HTTP transport's
+        # response so callers can treat both uniformly.
+        class Response
+          SERVICE_RATE_KEY = "rate_by_service"
+
+          attr_reader :trace_count, :payload
+
+          def initialize(ok:, internal_error: false, server_error: false, client_error: false,
+            not_found: false, unsupported: false, trace_count: 0, payload: nil)
+            @ok = ok
+            @internal_error = internal_error
+            @server_error = server_error
+            @client_error = client_error
+            @not_found = not_found
+            @unsupported = unsupported
+            @trace_count = trace_count
+            @payload = payload
+          end
+
+          def ok?
+            @ok
+          end
+
+          def internal_error?
+            @internal_error
+          end
+
+          def server_error?
+            @server_error
+          end
+
+          def client_error?
+            @client_error
+          end
+
+          def not_found?
+            @not_found
+          end
+
+          def unsupported?
+            @unsupported
+          end
+
+          # Parse the agent's JSON response body and extract the
+          # +rate_by_service+ map.  Returns +nil+ when the payload
+          # is absent or does not contain sampling rates.
+          def service_rates
+            payload = @payload
+            return nil if payload.nil? || payload.empty?
+
+            parsed = JSON.parse(payload)
+            parsed[SERVICE_RATE_KEY] if parsed.is_a?(Hash)
+          rescue JSON::ParserError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,363 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "trace_formatter"
+require_relative "statistics"
+
+module Datadog
+  module Tracing
+    module Transport
+      # Transport backed by the native trace exporter (Rust via C FFI).
+      #
+      # Converts Ruby Span objects directly to Rust spans and delegates
+      # serialization and sending to the Rust data pipeline, which handles
+      # stats computation, msgpack encoding, and HTTP transport with retry
+      # logic.
+      #
+      # Implements the same +send_traces+ / +stats+ interface as
+      # {Datadog::Tracing::Transport::Traces::Transport} so it can be used
+      # as a drop-in replacement via the +Writer+'s +:transport+ option.
+      module Native
+        # Returns +nil+ when the native extension is available, or a +String+
+        # describing why it is not.
+        UNSUPPORTED_REASON = begin
+          require "datadog/core"
+          Datadog::Core::LIBDATADOG_API_FAILURE
+        rescue => e
+          e.message
+        end
+
+        def self.supported?
+          UNSUPPORTED_REASON.nil?
+        end
+
+        # +TraceExporter+ and +TracerSpan+ are defined by the C extension in
+        # +ext/libdatadog_api/trace_exporter.c+ and become available after the
+        # native extension is loaded. +Response+ is a plain Ruby class (see
+        # +native/response.rb+); the C side only resolves and instantiates it.
+        #
+        # The hierarchy is:
+        #   Datadog::Tracing::Transport::Native::TraceExporter (C)
+        #   Datadog::Tracing::Transport::Native::TracerSpan (C)
+        #   Datadog::Tracing::Transport::Native::Response (Ruby)
+
+        # Drop-in transport that delegates to the native trace exporter.
+        class Transport
+          include Statistics
+
+          attr_reader :logger
+
+          # @param agent_settings [Datadog::Core::Configuration::AgentSettingsResolver::AgentSettings]
+          #   Agent connection settings (provides +#url+).
+          # @param logger [Logger]
+          def initialize(agent_settings:, logger:)
+            unless Native.supported?
+              raise "Native transport is not supported: #{UNSUPPORTED_REASON}"
+            end
+
+            @logger = logger
+
+            # Guards the one-shot warning about span fields the native exporter
+            # does not yet convert (see #warn_unsupported_fields!).
+            @unsupported_fields_warned = false
+
+            # Serializes native sends and is held across a fork. See the
+            # fork-safety note below.
+            @send_mutex = Mutex.new
+
+            url = agent_settings.url
+            tracer_version = tracer_version_string
+            language = Core::Environment::Ext::LANG
+            language_version = Core::Environment::Ext::LANG_VERSION
+            language_interpreter = Core::Environment::Ext::LANG_INTERPRETER
+            hostname = begin
+              Core::Environment::Socket.hostname
+            rescue
+              nil
+            end
+            env = Datadog.configuration.env
+            service = Datadog.configuration.service
+            version = Datadog.configuration.version
+
+            exporter = Native::TraceExporter._native_new(
+              url: url,
+              tracer_version: tracer_version,
+              language: language,
+              language_version: language_version,
+              language_interpreter: language_interpreter,
+              hostname: hostname,
+              env: env,
+              service: service,
+              version: version
+            )
+            @exporter = exporter
+
+            # Fork safety: the native exporter owns a long-lived tokio runtime
+            # with background worker threads. Around a fork we must quiesce the
+            # runtime before forking and restore it afterwards in both the parent
+            # and the child (where the inherited runtime is dead).
+            #
+            # A libdatadog Rust call must NOT be interrupted by `fork()`. A
+            # native send releases the GVL during the Rust
+            # `ddog_trace_exporter_send_trace_chunks` call, so if another thread
+            # forks while a (typically the writer/`AsyncTransport`) thread is
+            # mid-send, the child would inherit a half-completed send and
+            # Rust-internal locks, deadlocking or crashing. `_native_before_fork`
+            # 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
+            # `_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
+            # `send_trace_chunks`) only briefly locks the runtime mutex to clone
+            # the `Arc<Runtime>` (or build a throwaway `current_thread` runtime
+            # if it has been taken) and then drives the send on its own clone
+            # holding no mutex, while `_native_before_fork` just `take()`s the
+            # shared `Arc` and pauses workers -- so neither deadlocks the other.
+            # Locking the mutex AFTER `_native_before_fork` still guarantees the
+            # drain: it BLOCKS until any in-flight send finishes (bounded by the
+            # exporter's request timeout), which drops the send's last `Arc` and
+            # fully shuts the runtime down, and prevents new sends from starting.
+            # The lock is released in the `:parent` and `:child` hooks. In
+            # practice only one writer thread sends, so serializing adds no real
+            # contention.
+            #
+            # Note: the `:before` block runs before genuine forks (web-server
+            # workers, `Process.daemon`) that go through `Process._fork`. It
+            # does NOT run for `system`/backtick/`IO.popen`/`Process.spawn`,
+            # which spawn via `posix_spawn`/`vfork`+`exec` and replace the
+            # process image rather than carrying over the parent's work. Keeping
+            # it cheap is still worthwhile since real forks can be frequent.
+            #
+            # The hooks below are process-global and are never auto-removed by
+            # the fork machinery, so each transport must deregister its own
+            # 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.
+            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
+            end
+            parent_hook = Core::Utils::AtForkMonkeyPatch.at_fork(:parent) do
+              exporter._native_after_fork_in_parent
+            rescue => e
+              Datadog.logger.warn { "Native transport after-fork reset failed; traces may not be sent to Datadog: #{e.class}: #{e.message}" }
+            ensure
+              # `:before`'s ensure always locks the mutex on the forking thread
+              # before any fork outcome, so it is normally owned here; the guard
+              # only covers `:before` being interrupted mid-lock (e.g. a kill
+              # 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?
+            end
+            child_hook = Core::Utils::AtForkMonkeyPatch.at_fork(:child) do
+              exporter._native_after_fork_in_child
+            rescue => e
+              Datadog.logger.warn { "Native transport after-fork reset failed; traces may not be sent to Datadog: #{e.class}: #{e.message}" }
+            ensure
+              # See the :parent hook: normally owned (the forking thread is the
+              # lone survivor in the child); the guard only covers `:before`
+              # being interrupted mid-lock.
+              send_mutex.unlock if send_mutex.owned?
+            end
+
+            @fork_hooks = {before: before_hook, parent: parent_hook, child: child_hook}
+
+            # 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
+            # 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))
+          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.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.
+            ObjectSpace.undefine_finalizer(self)
+
+            nil
+          end
+
+          # Builds the finalizer proc for 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)
+            proc do
+              fork_hooks.each do |stage, block|
+                Core::Utils::AtForkMonkeyPatch.remove_at_fork(stage, block)
+              end
+            end
+          end
+          private_class_method :finalizer_for
+
+          # Send a list of traces to the agent.
+          #
+          # Each trace is a {Datadog::Tracing::TraceSegment} whose +#spans+
+          # returns an +Array+ of {Datadog::Tracing::Span}.
+          #
+          # @param traces [Array<Datadog::Tracing::TraceSegment>]
+          # @return [Array<Response>] one response per batch sent
+          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) }
+
+            # Build the Array<Array<Span>> structure expected by the C extension.
+            # 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.
+            warn_unsupported_fields!(chunks)
+
+            # Serialize the native send and hold the mutex across it so a
+            # concurrent fork's :before hook blocks until this send drains
+            # (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) }
+
+            # Update statistics from the response
+            responses.each { |response| update_stats_from_response!(response) }
+
+            responses
+          rescue => e
+            logger.debug { "Native transport error: #{e.class} #{e.message}" }
+            update_stats_from_exception!(e)
+            [InternalErrorResponse.new(e)]
+          end
+
+          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.
+          def warn_unsupported_fields!(chunks)
+            return if @unsupported_fields_warned
+
+            unsupported = []
+            chunks.each do |spans|
+              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?
+
+            @unsupported_fields_warned = true
+            fields = unsupported.uniq.join(", ")
+            logger.warn do
+              "Native transport does not yet support: #{fields}. This data will not be sent to Datadog. " \
+                "Unset DD_EXPERIMENTAL_NATIVE_TRANSPORT_ENABLED to use the default transport if you rely on these."
+            end
+          end
+
+          def tracer_version_string
+            defined?(Datadog::VERSION::STRING) ? Datadog::VERSION::STRING : "unknown"
+          end
+        end
+
+        # Response for internal errors (exceptions raised before reaching
+        # the native transport).
+        class InternalErrorResponse
+          attr_reader :error
+
+          def initialize(error)
+            @error = error
+          end
+
+          def ok?
+            false
+          end
+
+          def internal_error?
+            true
+          end
+
+          def server_error?
+            false
+          end
+
+          def client_error?
+            false
+          end
+
+          def not_found?
+            false
+          end
+
+          def unsupported?
+            false
+          end
+
+          def payload
+            nil
+          end
+
+          def trace_count
+            0
+          end
+
+          def service_rates
+            nil
+          end
+
+          def inspect
+            "#<#{self.class} error=#{error.inspect}>"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'msgpack'
-require 'datadog/tracing/utils'
+require "json"
+require "msgpack"
+require "datadog/tracing/utils"
 
 module Datadog
   module Tracing
@@ -76,10 +76,10 @@ module Datadog
           if span.stopped?
             packer.write_map_header(number_of_elements_to_write + 2) # Set header with how many elements in the map
 
-            packer.write('start')
+            packer.write("start")
             packer.write(time_nano(span.start_time))
 
-            packer.write('duration')
+            packer.write("duration")
             packer.write(duration_nano(span.duration))
           else
             packer.write_map_header(number_of_elements_to_write) # Set header with how many elements in the map
@@ -88,40 +88,40 @@ module Datadog
           if span.events.any?
             if @native_events_supported
               # Use top-level field for native events
-              packer.write('span_events')
+              packer.write("span_events")
               packer.write(span.events.map(&:to_native_format))
             else
               # Serialize span events as meta tags
-              span.set_tag('events', span.events.map(&:to_hash).to_json)
+              span.set_tag("events", span.events.map(&:to_hash).to_json)
             end
           end
 
           # DEV: We use strings as keys here, instead of symbols, as
           # DEV: MessagePack will ultimately convert them to strings.
           # DEV: By providing strings directly, we skip this indirection operation.
-          packer.write('span_id')
+          packer.write("span_id")
           packer.write(span.id)
-          packer.write('parent_id')
+          packer.write("parent_id")
           packer.write(span.parent_id)
-          packer.write('trace_id')
+          packer.write("trace_id")
           packer.write(@trace_id)
-          packer.write('name')
+          packer.write("name")
           packer.write(span.name)
-          packer.write('service')
+          packer.write("service")
           packer.write(span.service)
-          packer.write('resource')
+          packer.write("resource")
           packer.write(span.resource)
-          packer.write('type')
+          packer.write("type")
           packer.write(span.type)
-          packer.write('meta')
+          packer.write("meta")
           packer.write(span.meta)
-          packer.write('metrics')
+          packer.write("metrics")
           packer.write(span.metrics)
-          packer.write('meta_struct')
+          packer.write("meta_struct")
           packer.write(span.metastruct)
-          packer.write('span_links')
+          packer.write("span_links")
           packer.write(span.links.map(&:to_hash))
-          packer.write('error')
+          packer.write("error")
           packer.write(span.status)
           packer
         end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../../core/metrics/metric'
-require_relative '../../core/diagnostics/health'
+require_relative "../../core/metrics/metric"
+require_relative "../../core/diagnostics/health"
 
 module Datadog
   module Tracing

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

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../../core/environment/identity'
-require_relative '../../core/environment/process'
-require_relative '../../core/environment/socket'
-require_relative '../../core/environment/git'
-require_relative '../../core/git/ext'
-require_relative '../../core/runtime/ext'
-require_relative '../metadata/ext'
-require_relative '../trace_segment'
+require_relative "../../core/environment/identity"
+require_relative "../../core/environment/process"
+require_relative "../../core/environment/socket"
+require_relative "../../core/environment/git"
+require_relative "../../core/git/ext"
+require_relative "../../core/runtime/ext"
+require_relative "../metadata/ext"
+require_relative "../trace_segment"
 
 module Datadog
   module Tracing
@@ -117,7 +117,7 @@ module Datadog
 
           root_span.set_tag(
             Tracing::Metadata::Ext::Distributed::TAG_KNUTH_SAMPLING_RATE,
-            format('%.6f', (rate * 1e6).round / 1e6.to_f).sub(/\.?0+\z/, '')
+            format("%.6f", (rate * 1e6).round / 1e6).sub(/\.?0+\z/, "")
           )
         end
 
@@ -213,7 +213,7 @@ module Datadog
         def tag_apm_tracing_disabled!
           return if trace.apm_tracing_enabled
 
-          root_span.set_tag(Tracing::Metadata::Ext::TAG_APM_ENABLED, 0)
+          trace.spans.each { |span| span.set_metric(Tracing::Metadata::Ext::TAG_APM_ENABLED, 0) }
         end
 
         def tag_git_repository_url!

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

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_relative '../../core/chunker'
-require_relative '../../core/transport/parcel'
-require_relative '../../core/transport/request'
-require_relative '../../core/transport/transport'
-require_relative '../../core/utils/enumerable_compat'
-require_relative 'http/client'
-require_relative 'serializable_trace'
-require_relative 'trace_formatter'
+require_relative "../../core/chunker"
+require_relative "../../core/transport/parcel"
+require_relative "../../core/transport/request"
+require_relative "../../core/transport/transport"
+require_relative "../../core/utils/enumerable_compat"
+require_relative "http/client"
+require_relative "serializable_trace"
+require_relative "trace_formatter"
 
 module Datadog
   module Tracing

data/lib/datadog/tracing/utils.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative '../core/utils/forking'
-require_relative '../core/utils/time'
+require_relative "../core/utils/forking"
+require_relative "../core/utils/time"
 
 module Datadog
   module Tracing

data/lib/datadog/tracing/workers.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'buffer'
-require_relative 'pipeline'
+require_relative "buffer"
+require_relative "pipeline"
 
 module Datadog
   module Tracing

data/lib/datadog/tracing/writer.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
-require_relative 'event'
-require_relative 'runtime/metrics'
-require_relative 'workers'
+require_relative "event"
+require_relative "runtime/metrics"
+require_relative "workers"
 
-require_relative 'transport/http'
+require_relative "transport/http"
 
 module Datadog
   module Tracing
@@ -122,7 +122,7 @@ module Datadog
         if worker_local
           worker_local.enqueue_trace(trace)
         elsif !@stopped
-          logger.debug('Writer either failed to start or was stopped before #write could complete')
+          logger.debug("Writer either failed to start or was stopped before #write could complete")
         end
       end
 
@@ -173,10 +173,23 @@ module Datadog
       def stop_worker
         @stopped = true
 
-        return if @worker.nil?
+        if @worker
+          @worker.stop
+          @worker = nil
+        end
 
-        @worker.stop
-        @worker = nil
+        # Stopping a writer is permanent: once `@stopped` is set, `#start`
+        # refuses to spin up a new worker, so this writer (and the transport it
+        # owns) is being discarded for good. Forks do not stop the writer
+        # (`#start` re-creates the worker for the new pid while reusing the same
+        # transport), so this only runs on real teardown/reconfiguration.
+        #
+        # Deterministically release transports that hold native resources
+        # (e.g. the native trace exporter's Rust runtime and process-global
+        # fork hooks) instead of waiting on the GC finalizer. The default HTTP
+        # transport has no `#close` and is left untouched. `#close` is
+        # idempotent, so repeated `#stop` calls are safe.
+        @transport.close if @transport.respond_to?(:close)
 
         true
       end