libdatadog 36.0.0.1.0 → 37.0.0.1.0

data/vendor/libdatadog-37.0.0/x86_64-linux/include/datadog/data-pipeline.h

@@ -0,0 +1,425 @@
+// Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+
+#ifndef DDOG_DATA_PIPELINE_H
+#define DDOG_DATA_PIPELINE_H
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include "common.h"
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+/**
+ * Frees `error` and all its contents. After being called error will not point to a valid memory
+ * address so any further actions on it could lead to undefined behavior.
+ */
+void ddog_trace_exporter_error_free(struct ddog_TraceExporterError *error);
+
+/**
+ * Return a borrowed view of the response body.  The returned slice is
+ * only valid as long as `response` is alive.  Returns an empty slice
+ * when `response` is null or the body is absent.
+ */
+ddog_ByteSlice ddog_trace_exporter_response_get_body(const struct ddog_TraceExporterResponse *response);
+
+/**
+ * Free `response` and all its contents. After being called response will not point to a valid
+ * memory address so any further actions on it could lead to undefined behavior.
+ */
+void ddog_trace_exporter_response_free(struct ddog_TraceExporterResponse *response);
+
+void ddog_trace_exporter_config_new(struct ddog_TraceExporterConfig **out_handle);
+
+/**
+ * Frees TraceExporterConfig handle internal resources.
+ */
+void ddog_trace_exporter_config_free(struct ddog_TraceExporterConfig *handle);
+
+/**
+ * Sets traces destination.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_url(struct ddog_TraceExporterConfig *config,
+                                                                   ddog_CharSlice url);
+
+/**
+ * Sets tracer's version to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_tracer_version(struct ddog_TraceExporterConfig *config,
+                                                                              ddog_CharSlice version);
+
+/**
+ * Sets tracer's language to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_language(struct ddog_TraceExporterConfig *config,
+                                                                        ddog_CharSlice lang);
+
+/**
+ * Sets tracer's language version to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_lang_version(struct ddog_TraceExporterConfig *config,
+                                                                            ddog_CharSlice version);
+
+/**
+ * Sets tracer's language interpreter to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_lang_interpreter(struct ddog_TraceExporterConfig *config,
+                                                                                ddog_CharSlice interpreter);
+
+/**
+ * Sets hostname information to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_hostname(struct ddog_TraceExporterConfig *config,
+                                                                        ddog_CharSlice hostname);
+
+/**
+ * Sets environment information to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_env(struct ddog_TraceExporterConfig *config,
+                                                                   ddog_CharSlice env);
+
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_version(struct ddog_TraceExporterConfig *config,
+                                                                       ddog_CharSlice version);
+
+/**
+ * Sets service name to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_service(struct ddog_TraceExporterConfig *config,
+                                                                       ddog_CharSlice service);
+
+/**
+ * Enables health metrics emission.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_enable_health_metrics(struct ddog_TraceExporterConfig *config,
+                                                                                 bool is_enabled);
+
+/**
+ * Enables telemetry metrics.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_enable_telemetry(struct ddog_TraceExporterConfig *config,
+                                                                            const struct ddog_TelemetryClientConfig *telemetry_cfg);
+
+/**
+ * Set client-side stats computation status.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_compute_stats(struct ddog_TraceExporterConfig *config,
+                                                                             bool is_enabled);
+
+/**
+ * Sets `Datadog-Client-Computed-Stats` header to `true`.
+ * This indicates that the upstream system has already computed the stats,
+ * and no further stats computation should be performed.
+ *
+ * <div class="warning">
+ * This method must not be used when `compute_stats` is enabled, as it could
+ * result in duplicate stats computation.
+ * </div>
+ *
+ * A common use case is in Application Security Monitoring (ASM) scenarios:
+ * when APM is disabled but ASM is enabled, setting this header to `true`
+ * ensures that no stats are computed at any level (exporter or agent).
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_client_computed_stats(struct ddog_TraceExporterConfig *config,
+                                                                                     bool client_computed_stats);
+
+/**
+ * Sets the process tags to be included in the stats payload.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_process_tags(struct ddog_TraceExporterConfig *config,
+                                                                            ddog_CharSlice process_tags);
+
+/**
+ * Sets the `X-Datadog-Test-Session-Token` header. Only used for testing with the test agent.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_test_session_token(struct ddog_TraceExporterConfig *config,
+                                                                                  ddog_CharSlice token);
+
+/**
+ * Sets the timeout in ms for all agent's connections.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_connection_timeout(struct ddog_TraceExporterConfig *config,
+                                                                                  uint64_t timeout_ms);
+
+/**
+ * Sets a shared runtime for the TraceExporter to use for background workers.
+ *
+ * `handle` must have been initialized with [`ddog_shared_runtime_new`].
+ *
+ * When set, the exporter will use the provided runtime instead of creating its own.
+ * This allows multiple exporters (or other components) to share a single runtime.
+ * The config holds a clone of the `Arc` (increments the strong count), so the
+ * original handle remains valid and must still be freed with
+ * [`ddog_shared_runtime_free`].
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_shared_runtime(struct ddog_TraceExporterConfig *config,
+                                                                              struct ddog_ForkSafeRuntime *handle);
+
+/**
+ * Enables OTLP HTTP/JSON export and sets the endpoint URL.
+ *
+ * When set, traces are sent to this URL in OTLP HTTP/JSON format instead of the Datadog
+ * agent. The host language is responsible for resolving the endpoint from its configuration
+ * (e.g. `OTEL_EXPORTER_OTLP_TRACES_ENDPOINT`) before calling this function.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_otlp_endpoint(struct ddog_TraceExporterConfig *config,
+                                                                             ddog_CharSlice url);
+
+/**
+ * Sets the OTLP export protocol. Accepts the OTel-standard values `http/json` (default) or
+ * `http/protobuf`; `grpc` is rejected as not yet supported. The host language resolves the value
+ * (e.g. from `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL`).
+ *
+ * Has no effect unless an OTLP endpoint is also configured via
+ * `ddog_trace_exporter_config_set_otlp_endpoint`; without one, traces are sent to the
+ * Datadog agent and this protocol selection is ignored.
+ *
+ * Returns `None` on success, `ErrorCode::InvalidArgument` for a null config or an unaccepted
+ * value, and `ErrorCode::InvalidInput` for a non-UTF-8 string.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_otlp_protocol(struct ddog_TraceExporterConfig *config,
+                                                                             ddog_CharSlice protocol);
+
+/**
+ * Configure the exporter to write traces as newline-delimited JSON to stdout (the Datadog
+ * Forwarder "log exporter" path) instead of sending them to a Datadog agent. Used in serverless
+ * environments (e.g. AWS Lambda) when no agent is reachable.
+ *
+ * `max_line_size` overrides the per-line byte cap; pass `0` to use the default (256 KiB, the AWS
+ * CloudWatch Logs limit). When enabled, agent-specific behavior (agent-info polling, client-side
+ * stats, V1 negotiation) is bypassed.
+ *
+ * In this mode each span's `meta` is serialized to process stdout (and thus captured by CloudWatch
+ * Logs in Lambda); `meta_struct` is excluded because it holds raw msgpack the log intake cannot
+ * interpret.
+ *
+ * Writes are synchronous/blocking on stdout, so this mode targets single-threaded / current-thread
+ * serverless runtimes (e.g. AWS Lambda) where a blocking write won't stall a shared async reactor.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_output_to_log(struct ddog_TraceExporterConfig *config,
+                                                                             uintptr_t max_line_size);
+
+/**
+ * Create a new TraceExporter instance.
+ *
+ * When an OTLP endpoint is configured via `TraceExporterConfig`, the exporter sends traces to
+ * that endpoint in OTLP over HTTP — JSON or protobuf per the configured protocol — instead of
+ * to the Datadog agent. The same payload (e.g. MessagePack) is passed to
+ * `ddog_trace_exporter_send`; the library decodes and converts it to OTLP when OTLP is enabled.
+ *
+ * # Arguments
+ *
+ * * `out_handle` - The handle to write the TraceExporter instance in.
+ * * `config` - The configuration used to set up the TraceExporter handle.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_new(ddog_TraceExporter **out_handle,
+                                                        const struct ddog_TraceExporterConfig *config);
+
+/**
+ * Free the TraceExporter instance.
+ *
+ * # Arguments
+ *
+ * * handle - The handle to the TraceExporter instance.
+ */
+void ddog_trace_exporter_free(ddog_TraceExporter *handle);
+
+/**
+ * Send traces to the Datadog Agent.
+ *
+ * # Arguments
+ *
+ * * `handle` - The handle to the TraceExporter instance.
+ * * `trace` - The traces to send to the Datadog Agent in the input format used to create the
+ *   TraceExporter. The memory for the trace must be valid for the life of the call to this
+ *   function.
+ * * `trace_count` - The number of traces to send to the Datadog Agent.
+ * * `response_out` - Optional handle to store a pointer to the agent response information.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_send(const ddog_TraceExporter *handle,
+                                                         ddog_ByteSlice trace,
+                                                         struct ddog_TraceExporterResponse **response_out);
+
+/**
+ * Create a new span with all scalar fields set.
+ *
+ * String fields are copied from the provided slices.  The `meta` and
+ * `metrics` maps start empty; use [`ddog_tracer_span_set_meta`] and
+ * [`ddog_tracer_span_set_metric`] to populate them.
+ *
+ * # Safety
+ *
+ * `out_handle` must point to valid, writable memory for a `Box<TracerSpan>`.
+ * All `CharSlice` fields in `fields` must point to valid memory for their
+ * stated length.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_new(ddog_TracerSpan **out_handle,
+                                                     const struct ddog_TracerSpanFields *fields);
+
+/**
+ * Free a `TracerSpan` and all its contents.
+ *
+ * After this call the handle is invalid and must not be reused.
+ *
+ * # Safety
+ *
+ * `handle` must have been created by [`ddog_tracer_span_new`] and must not
+ * be used after this call.
+ */
+void ddog_tracer_span_free(ddog_TracerSpan *handle);
+
+/**
+ * Add or overwrite a string tag (`meta`) on the span.
+ *
+ * Both `key` and `value` are copied into the span.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid pointer to a `TracerSpan`.
+ * `key` and `value` must point to valid UTF-8 memory.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_set_meta(ddog_TracerSpan *handle,
+                                                          ddog_CharSlice key,
+                                                          ddog_CharSlice value);
+
+/**
+ * Add or overwrite a numeric tag (`metric`) on the span.
+ *
+ * The `key` is copied into the span.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid pointer to a `TracerSpan`.
+ * `key` must point to valid UTF-8 memory.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_set_metric(ddog_TracerSpan *handle,
+                                                            ddog_CharSlice key,
+                                                            double value);
+
+/**
+ * Create a new empty trace chunks container.
+ *
+ * `capacity` is a hint for the expected number of chunks; pass 0 if
+ * unknown.
+ *
+ * # Safety
+ *
+ * `out_handle` must point to valid, writable memory for a
+ * `Box<TracerTraceChunks>`.
+ */
+struct ddog_TraceExporterError *ddog_tracer_trace_chunks_new(uintptr_t capacity,
+                                                             ddog_TracerTraceChunks **out_handle);
+
+/**
+ * Free a trace chunks container and all its contents.
+ *
+ * After this call the handle is invalid and must not be reused.
+ *
+ * # Safety
+ *
+ * `handle` must have been created by [`ddog_tracer_trace_chunks_new`].
+ */
+void ddog_tracer_trace_chunks_free(ddog_TracerTraceChunks *handle);
+
+/**
+ * Start a new chunk (trace) inside the container.
+ *
+ * Subsequent [`ddog_tracer_trace_chunks_push_span`] calls will append
+ * spans to this chunk until the next `begin_chunk` call.
+ *
+ * `capacity` is a hint for the expected number of spans in this chunk;
+ * pass 0 if unknown.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid pointer to a `TracerTraceChunks`.
+ */
+struct ddog_TraceExporterError *ddog_tracer_trace_chunks_begin_chunk(ddog_TracerTraceChunks *handle,
+                                                                     uintptr_t capacity);
+
+/**
+ * Move a span into the current (last) chunk, consuming the span handle.
+ *
+ * A chunk must have been started with
+ * [`ddog_tracer_trace_chunks_begin_chunk`] before calling this function.
+ *
+ * # Safety
+ *
+ * * `handle` must be a valid pointer to a `TracerTraceChunks`.
+ * * `span` is consumed and must not be used after this call.
+ */
+struct ddog_TraceExporterError *ddog_tracer_trace_chunks_push_span(ddog_TracerTraceChunks *handle,
+                                                                   ddog_TracerSpan *span);
+
+/**
+ * Create a new cancellation token.
+ *
+ * The returned token must be freed with
+ * [`ddog_trace_exporter_cancel_token_drop`].
+ */
+ddog_TraceExporterCancelToken *ddog_trace_exporter_cancel_token_new(void);
+
+/**
+ * Cancel a cancellation token.
+ *
+ * All clones of the same token observe the cancellation. If a
+ * [`ddog_trace_exporter_send_trace_chunks`] call is using this token at the
+ * time of cancellation, that send stops waiting for the agent at its next
+ * await point and returns an error; the trace chunks it was sending may be
+ * lost.
+ *
+ * Cancellation only affects a send that is in progress. If no send is using
+ * the token, cancelling it has no immediate effect: a send started afterwards
+ * with an already-cancelled token returns an error without contacting the
+ * agent, and a token cancelled after its send has already finished does
+ * nothing.
+ */
+void ddog_trace_exporter_cancel_token_cancel(const ddog_TraceExporterCancelToken *token);
+
+/**
+ * Free a cancellation token.
+ *
+ * After this call the token is invalid and must not be reused.
+ */
+void ddog_trace_exporter_cancel_token_drop(ddog_TraceExporterCancelToken *token);
+
+/**
+ * Send trace chunks through a [`TraceExporter`], consuming the chunks.
+ *
+ * This calls `TraceExporter::send_trace_chunks` which processes stats,
+ * serializes in the configured output format, and sends to the agent
+ * with retry logic.
+ *
+ * When `cancel` is non-null, cancelling that token (via
+ * [`ddog_trace_exporter_cancel_token_cancel`]) while the send is in progress
+ * aborts the in-flight request and returns an error with code
+ * [`ExporterErrorCode::IoError`]. Cancellation is cooperative: it only takes
+ * effect while a request is actually in flight. A token that is already
+ * cancelled when the send starts makes this function return that error
+ * immediately, and cancelling after the send has finished has no effect.
+ * Cancelling an in-flight send may cause the trace chunks being sent to be
+ * lost.
+ *
+ * On success, if `response_out` is non-null, a heap-allocated
+ * [`ExporterResponse`] is written there.  The caller owns it and must
+ * free it with `ddog_trace_exporter_response_free`.
+ *
+ * # Safety
+ *
+ * * `chunks` is consumed and must not be used after this call.
+ * * If `response_out` is non-null it must point to valid writable memory for a
+ *   `Box<ExporterResponse>`.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_send_trace_chunks(const ddog_TraceExporter *exporter,
+                                                                      ddog_TracerTraceChunks *chunks,
+                                                                      struct ddog_TraceExporterResponse **response_out,
+                                                                      const ddog_TraceExporterCancelToken *cancel);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus
+
+#endif  /* DDOG_DATA_PIPELINE_H */

data/vendor/libdatadog-37.0.0/x86_64-linux/include/datadog/shared-runtime.h

@@ -0,0 +1,91 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+
+#ifndef DDOG_SHARED_RUNTIME_H
+#define DDOG_SHARED_RUNTIME_H
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+/**
+ * Frees a `SharedRuntimeFFIError`. After this call the pointer is invalid.
+ */
+void ddog_shared_runtime_error_free(struct ddog_SharedRuntimeFFIError *error);
+
+/**
+ * Create a new `ForkSafeRuntime`.
+ *
+ * On success writes a raw handle into `*out_handle` and returns `None`.
+ * On failure leaves `*out_handle` unchanged and returns an error.
+ *
+ * The caller owns the handle and must eventually pass it to
+ * [`ddog_shared_runtime_free`] (or another consumer that takes ownership).
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_new(const struct ddog_ForkSafeRuntime **out_handle);
+
+/**
+ * Free a handle, decrementing the `Arc` strong count.
+ *
+ * The underlying runtime may not be dropped if other components are still using it.
+ * Use [`ddog_shared_runtime_shutdown`] to cleanly stop workers.
+ */
+void ddog_shared_runtime_free(const struct ddog_ForkSafeRuntime *handle);
+
+/**
+ * Must be called in the parent process before `fork()`.
+ *
+ * Pauses all workers so that no background threads are running during the
+ * fork, preventing deadlocks in the child process.
+ *
+ * Returns an error if `handle` is null.
+ * The handle must have been initialized with `ddog_shared_runtime_new`.
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_before_fork(const struct ddog_ForkSafeRuntime *handle);
+
+/**
+ * Must be called in the parent process after `fork()`.
+ *
+ * Restarts all workers that were paused by [`ddog_shared_runtime_before_fork`].
+ *
+ * Returns `None` on success, or an error if workers could not be restarted.
+ * The handle must have been initialized with `ddog_shared_runtime_new`.
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_after_fork_parent(const struct ddog_ForkSafeRuntime *handle);
+
+/**
+ * Must be called in the child process after `fork()`.
+ *
+ * Creates a fresh tokio runtime and restarts all workers. The original
+ * runtime cannot be safely reused after a fork.
+ *
+ * Returns `None` on success, or an error if the runtime could not be
+ * reinitialized.
+ * The handle must have been initialized with `ddog_shared_runtime_new`.
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_after_fork_child(const struct ddog_ForkSafeRuntime *handle);
+
+/**
+ * Shut down the `ForkSafeRuntime`, stopping all workers.
+ *
+ * `timeout_ms` is the maximum time to wait for workers to stop, in
+ * milliseconds.  Pass `0` for no timeout.
+ *
+ * Returns `None` on success, or `SharedRuntimeErrorCode::ShutdownTimedOut`
+ * if the timeout was reached.
+ * The handle must have been initialized with `ddog_shared_runtime_new`.
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_shutdown(const struct ddog_ForkSafeRuntime *handle,
+                                                                uint64_t timeout_ms);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus
+
+#endif  /* DDOG_SHARED_RUNTIME_H */

data/vendor/libdatadog-37.0.0/x86_64-linux/lib/pkgconfig/datadog_profiling_with_rpath.pc

@@ -0,0 +1,15 @@
+# Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
+# SPDX-License-Identifier: Apache-2.0
+
+prefix=${pcfiledir}/../..
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: datadog_profiling
+Description: Contains common code used to implement Datadog's Continuous Profilers. (Dynamic linking variant, sets rpath)
+Version: 37.0.0
+Requires:
+Libs: -L${libdir} -ldatadog_profiling -Wl,-rpath,${libdir}
+Libs.private:
+Cflags: -I${includedir}

data/vendor/{libdatadog-36.0.0 → libdatadog-37.0.0}/x86_64-linux-musl/LICENSE-3rdparty.csv

@@ -125,6 +125,7 @@ dispatch2,https://github.com/madsmtm/objc2,Zlib OR Apache-2.0 OR MIT,"Mads Marqu
 displaydoc,https://github.com/yaahc/displaydoc,MIT OR Apache-2.0,Jane Lusby <jlusby@yaah.dev>
 dyn-clone,https://github.com/dtolnay/dyn-clone,MIT OR Apache-2.0,David Tolnay <dtolnay@gmail.com>
 either,https://github.com/rayon-rs/either,MIT OR Apache-2.0,bluss
+elf,https://github.com/cole14/rust-elf,MIT OR Apache-2.0,Christopher Cole <chris.cole.09@gmail.com>
 encoding_rs,https://github.com/hsivonen/encoding_rs,(Apache-2.0 OR MIT) AND BSD-3-Clause,Henri Sivonen <hsivonen@hsivonen.fi>
 enum-as-inner,https://github.com/bluejekyll/enum-as-inner,MIT OR Apache-2.0,Benjamin Fry <benjaminfry@me.com>
 equivalent,https://github.com/cuviper/equivalent,Apache-2.0 OR MIT,The equivalent Authors

data/vendor/{libdatadog-36.0.0/aarch64-linux → libdatadog-37.0.0/x86_64-linux-musl}/include/datadog/common.h

@@ -1670,20 +1670,13 @@ typedef enum ddog_TraceExporterErrorCode {
 typedef struct ddog_TraceExporterResponse ddog_TraceExporterResponse;
 
 /**
- * A shared runtime that manages PausableWorkers and provides fork safety hooks.
+ * Owns a tokio runtime and manages [`PausableWorker`]s on it.
  *
- * The SharedRuntime owns a tokio runtime (on native) and tracks PausableWorkers
- * spawned on it. It provides methods to safely pause workers before forking and
- * restart them after fork in both parent and child processes.
- *
- * On wasm32, no tokio runtime is created. Workers are spawned via `spawn_local`
- * on the JS event loop.
- *
- * # Mutex lock order
- * When locking both [Self::runtime] and [Self::workers], the mutex must be locked in the order of
- * the fields in the struct. When possible avoid holding both locks simultaneously.
+ * Supports the full fork protocol ([`before_fork`](Self::before_fork) /
+ * [`after_fork_parent`](Self::after_fork_parent) /
+ * [`after_fork_child`](Self::after_fork_child)) and synchronous [`shutdown`](Self::shutdown).
  */
-typedef struct ddog_SharedRuntime ddog_SharedRuntime;
+typedef struct ddog_ForkSafeRuntime ddog_ForkSafeRuntime;
 
 /**
  * The TraceExporterConfig object will hold the configuration properties for the TraceExporter.
@@ -2234,7 +2227,7 @@ typedef struct ddog_ffe_AttributePair {
 } ddog_ffe_AttributePair;
 
 /**
- * Error codes for SharedRuntime FFI operations.
+ * Error codes for ForkSafeRuntime FFI operations.
  */
 typedef enum ddog_SharedRuntimeErrorCode {
   /**
@@ -2268,7 +2261,7 @@ typedef enum ddog_SharedRuntimeErrorCode {
 } ddog_SharedRuntimeErrorCode;
 
 /**
- * Error returned by SharedRuntime FFI functions.
+ * Error returned by ForkSafeRuntime FFI functions.
  */
 typedef struct ddog_SharedRuntimeFFIError {
   enum ddog_SharedRuntimeErrorCode code;

data/vendor/{libdatadog-36.0.0 → libdatadog-37.0.0}/x86_64-linux-musl/include/datadog/data-pipeline.h

@@ -156,7 +156,7 @@ struct ddog_TraceExporterError *ddog_trace_exporter_config_set_connection_timeou
  * [`ddog_shared_runtime_free`].
  */
 struct ddog_TraceExporterError *ddog_trace_exporter_config_set_shared_runtime(struct ddog_TraceExporterConfig *config,
-                                                                              struct ddog_SharedRuntime *handle);
+                                                                              struct ddog_ForkSafeRuntime *handle);
 
 /**
  * Enables OTLP HTTP/JSON export and sets the endpoint URL.
@@ -168,13 +168,47 @@ struct ddog_TraceExporterError *ddog_trace_exporter_config_set_shared_runtime(st
 struct ddog_TraceExporterError *ddog_trace_exporter_config_set_otlp_endpoint(struct ddog_TraceExporterConfig *config,
                                                                              ddog_CharSlice url);
 
+/**
+ * Sets the OTLP export protocol. Accepts the OTel-standard values `http/json` (default) or
+ * `http/protobuf`; `grpc` is rejected as not yet supported. The host language resolves the value
+ * (e.g. from `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL`).
+ *
+ * Has no effect unless an OTLP endpoint is also configured via
+ * `ddog_trace_exporter_config_set_otlp_endpoint`; without one, traces are sent to the
+ * Datadog agent and this protocol selection is ignored.
+ *
+ * Returns `None` on success, `ErrorCode::InvalidArgument` for a null config or an unaccepted
+ * value, and `ErrorCode::InvalidInput` for a non-UTF-8 string.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_otlp_protocol(struct ddog_TraceExporterConfig *config,
+                                                                             ddog_CharSlice protocol);
+
+/**
+ * Configure the exporter to write traces as newline-delimited JSON to stdout (the Datadog
+ * Forwarder "log exporter" path) instead of sending them to a Datadog agent. Used in serverless
+ * environments (e.g. AWS Lambda) when no agent is reachable.
+ *
+ * `max_line_size` overrides the per-line byte cap; pass `0` to use the default (256 KiB, the AWS
+ * CloudWatch Logs limit). When enabled, agent-specific behavior (agent-info polling, client-side
+ * stats, V1 negotiation) is bypassed.
+ *
+ * In this mode each span's `meta` is serialized to process stdout (and thus captured by CloudWatch
+ * Logs in Lambda); `meta_struct` is excluded because it holds raw msgpack the log intake cannot
+ * interpret.
+ *
+ * Writes are synchronous/blocking on stdout, so this mode targets single-threaded / current-thread
+ * serverless runtimes (e.g. AWS Lambda) where a blocking write won't stall a shared async reactor.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_output_to_log(struct ddog_TraceExporterConfig *config,
+                                                                             uintptr_t max_line_size);
+
 /**
  * Create a new TraceExporter instance.
  *
- * When an OTLP endpoint is configured via `TraceExporterConfig`, the exporter sends traces in
- * OTLP HTTP/JSON to that endpoint instead of the Datadog agent. The same payload (e.g.
- * MessagePack) is passed to `ddog_trace_exporter_send`; the library decodes and converts to
- * OTLP when OTLP is enabled.
+ * When an OTLP endpoint is configured via `TraceExporterConfig`, the exporter sends traces to
+ * that endpoint in OTLP over HTTP — JSON or protobuf per the configured protocol — instead of
+ * to the Datadog agent. The same payload (e.g. MessagePack) is passed to
+ * `ddog_trace_exporter_send`; the library decodes and converts it to OTLP when OTLP is enabled.
  *
  * # Arguments
  *