datadog 2.39.0 → 2.47.0

data/lib/datadog/tracing/transport/http/telemetry.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "net/http"
+require_relative "../telemetry"
+
+module Datadog
+  module Tracing
+    module Transport
+      module HTTP
+        class Telemetry < Datadog::Tracing::Transport::Telemetry
+          def initialize(client)
+            super(client, source: "ruby")
+          end
+
+          def batch(traces)
+            return unless @client.enabled? && @client.metrics_manager.enabled
+
+            Batch.new(self, traces)
+          rescue
+            nil
+          end
+
+          class Batch
+            def initialize(reporter, traces)
+              @reporter = reporter
+              @remaining_chunks = traces.length
+              @remaining_spans = traces.sum(&:length)
+              @reporter.record(spans_enqueued_for_serialization: @remaining_spans)
+            end
+
+            def record_oversized_drop(span_count)
+              @remaining_chunks -= 1
+              @remaining_spans -= span_count
+              @reporter.record(chunks_dropped_payload_too_large: 1, spans_dropped_payload_too_large: span_count)
+            end
+
+            def serialization_failed
+              @reporter.record(chunks_dropped_serialization_error: @remaining_chunks,
+                spans_dropped_serialization_error: @remaining_spans,)
+            end
+
+            def sent(request, response, chunks, spans, bytes, fallback:)
+              @reporter.record(requests_count: 1)
+              return if fallback
+
+              @remaining_chunks -= chunks
+              @remaining_spans -= spans
+              observations = {} #: Hash[Symbol, Integer]
+              if (status = request.http_status)
+                observations[:responses_count] = 1
+                observations[:status_code] = status
+              end
+              success = status ? status.between?(200, 299) : request.http_success
+              if success
+                observations[:chunks_sent] = chunks
+                observations[:bytes_sent] = bytes
+              elsif status || success == false
+                observations[:errors_status_code] = 1 if status
+                observations[:chunks_dropped_send_failure] = chunks
+                observations[:spans_dropped_api_error] = spans
+              elsif response.is_a?(Core::Transport::InternalErrorResponse)
+                error = response.error
+                if error.is_a?(ArgumentError) || error.is_a?(TypeError)
+                  observations[:chunks_dropped_serialization_error] = chunks
+                  observations[:spans_dropped_serialization_error] = spans
+                else
+                  observations[:chunks_dropped_send_failure] = chunks
+                  observations[:spans_dropped_api_error] = spans
+                  if error.is_a?(::Timeout::Error) || error.is_a?(Errno::ETIMEDOUT)
+                    observations[:errors_timeout] = 1
+                  elsif network_error?(error)
+                    observations[:errors_network] = 1
+                  end
+                end
+              end
+              @reporter.record(observations)
+            rescue
+              nil
+            end
+
+            private
+
+            def network_error?(error)
+              error.is_a?(SystemCallError) || error.is_a?(IOError) || error.is_a?(SocketError) ||
+                error.is_a?(::Net::ProtocolError) || error.is_a?(::Net::HTTPBadResponse) ||
+                error.is_a?(::Net::HTTPHeaderSyntaxError) ||
+                (defined?(::OpenSSL::SSL::SSLError) && error.is_a?(::OpenSSL::SSL::SSLError))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -51,6 +51,8 @@ module Datadog
 
                 # Query for response
                 http_response = super
+                # Delivery succeeded or failed before service-rate parsing can raise.
+                env.request.capture_status(http_response)
 
                 # Process the response
                 response_options = {trace_count: env.request.parcel.trace_count}.tap do |options|

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

@@ -27,7 +27,7 @@ module Datadog
             ENCODED_IDS = [
               :trace_id,
               :span_id,
-              :parent_id
+              :parent_id,
             ].freeze
 
             # Encodes a list of traces

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/telemetry.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../telemetry"
+
+module Datadog
+  module Tracing
+    module Transport
+      module Native
+        class Telemetry < Datadog::Tracing::Transport::Telemetry
+          def initialize(client)
+            super(client, source: "libdatadog")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,395 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "trace_formatter"
+require_relative "statistics"
+require_relative "span_events_negotiation"
+require_relative "native/telemetry"
+
+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
+          include SpanEventsNegotiation
+
+          attr_reader :logger, :url
+
+          def telemetry=(client)
+            @send_mutex.synchronize do
+              if (reporter = @telemetry)
+                reporter.client = client
+              elsif @exporter
+                @telemetry = Telemetry.new(client)
+              end
+            end
+          end
+
+          # @param agent_settings [Datadog::Core::Configuration::AgentSettingsResolver::AgentSettings]
+          #   Agent connection settings, including the request timeout.
+          # @param logger [Logger]
+          def initialize(agent_settings:, logger:)
+            unless Native.supported?
+              raise "Native transport is not supported: #{UNSUPPORTED_REASON}"
+            end
+
+            @logger = logger
+            @telemetry = nil
+
+            # Serializes native sends and is held across a fork. See the
+            # 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
+            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,
+              timeout_milliseconds: agent_settings.timeout_seconds * 1000,
+              tracer_version: tracer_version,
+              language: language,
+              language_version: language_version,
+              language_interpreter: language_interpreter,
+              hostname: hostname,
+              env: env,
+              service: service,
+              version: version,
+              client_computed_stats: !Datadog.configuration.apm.tracing.enabled
+            )
+            @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.
+            #
+            # `@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
+            # `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 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
+            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 = 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
+              # `: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?
+              fork_mutex.unlock if fork_mutex.owned?
+            end
+            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
+              # 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?
+              fork_mutex.unlock if fork_mutex.owned?
+            end
+
+            @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
+            # 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. 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_mutex.synchronize do
+              @send_mutex.synchronize do
+                hooks = @fork_hooks
+                return if hooks.nil?
+
+                begin
+                  @exporter&._native_close
+                ensure
+                  @fork_hooks = nil
+                  @telemetry = nil
+                  @exporter = nil
+                  hooks.each do |stage, block|
+                    Core::Utils::AtForkMonkeyPatch.remove_at_fork(stage, block)
+                  end
+                  ObjectSpace.undefine_finalizer(self)
+                end
+              end
+            end
+
+            nil
+          end
+
+          # 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.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 :fork_hooks_remover
+
+          # 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?
+
+            # Apply trace-level tags to root spans (same as the HTTP transport)
+            traces.each { |trace| TraceFormatter.format!(trace, transport: "native") }
+
+            # 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)
+
+            native_events_supported = native_events_supported?
+            apply_legacy_span_events!(chunks, native_events_supported)
+
+            # 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 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, native_events_supported) do |observations|
+                @telemetry&.record(observations)
+              end
+            end
+
+            # 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
+
+          # Writes each span's events into the legacy JSON +events+ meta tag
+          # when the agent lacks typed-event support, mutating spans in place.
+          #
+          # @param chunks [Array<Array<Datadog::Tracing::Span>>] trace chunks to serialize
+          # @param native_events_supported [Boolean] whether the agent accepts typed events
+          # @return [void]
+          def apply_legacy_span_events!(chunks, native_events_supported)
+            return if native_events_supported
+
+            chunks.each do |spans|
+              spans.each do |span|
+                next if span.events.empty?
+
+                span.set_tag("events", span.events.map(&:to_hash).to_json)
+              end
+            end
+
+            nil
+          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/span_events_negotiation.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Datadog
+  module Tracing
+    module Transport
+      # Shared agent capability negotiation for span event wire formats.
+      module SpanEventsNegotiation
+        private
+
+        # Queries whether the agent accepts typed span events, which selects
+        # between the typed field and legacy JSON metadata. Only successful
+        # capability responses are cached so a later flush can recover.
+        #
+        # The memo is read and written without synchronization, independent of
+        # any lock the including transport holds for its own sends (the native
+        # transport's +@send_mutex+, for example). Two concurrent sends can both
+        # observe it unset and each issue an +agent_info.fetch+; the duplicate
+        # fetch is self-correcting because the last writer wins.
+        #
+        # @return [Boolean] true if typed span events are supported
+        def native_events_supported?
+          return @native_events_supported if defined?(@native_events_supported)
+
+          option = Datadog.configuration.tracing.native_span_events
+          unless option.nil?
+            @native_events_supported = option
+            return option
+          end
+
+          components = Datadog.send(:components, allow_initialization: false)
+          return false unless components
+
+          response = components.agent_info.fetch
+          return false unless response
+
+          @native_events_supported = response.span_events == true
+        end
+      end
+    end
+  end
+end