libdatadog 48.0.0.1.1 → 49.0.0.1.1

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

@@ -0,0 +1,1181 @@
+// 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"
+#ifndef DDOG_TRACE_EXPORTER_DEPRECATED
+#if defined(_MSC_VER)
+#define DDOG_TRACE_EXPORTER_DEPRECATED(message) __declspec(deprecated(message))
+#elif defined(__GNUC__) || defined(__clang__)
+#define DDOG_TRACE_EXPORTER_DEPRECATED(message) __attribute__((deprecated(message)))
+#else
+#define DDOG_TRACE_EXPORTER_DEPRECATED(message)
+#endif
+#endif
+
+#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);
+
+/**
+ * Select external observation delivery and disable native telemetry delivery.
+ *
+ * # Safety
+ * `config`, when non-null, must be a live, exclusively borrowed configuration.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_enable_observations(struct ddog_TraceExporterConfig *config);
+
+/**
+ * Send chunks with caller-owned observations on success, failure, or cancellation.
+ * Native telemetry is not submitted for this operation. Both outputs are initialised
+ * before validation; invalid input and contained panics leave zero observations.
+ * `chunks` is consumed on every return, including invalid arguments and panics.
+ *
+ * # Safety
+ * Non-null pointers must be valid for their types. Output slots must be writable,
+ * unaliased, and contain no live owned response. Free a returned response with
+ * `ddog_trace_exporter_response_free`; observations require no cleanup.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_send_trace_chunks_observed(const ddog_TraceExporter *exporter,
+                                                                               ddog_TracerTraceChunks *chunks,
+                                                                               struct ddog_TraceExporterResponse **response_out,
+                                                                               struct ddog_TraceExporterObservations *observations_out,
+                                                                               const ddog_TraceExporterCancelToken *cancel);
+
+/**
+ * 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);
+
+/**
+ * Encode one flat preorder structured value as an owned MessagePack blob.
+ *
+ * On success, `out_handle` receives an owned blob that must be freed with
+ * [`ddog_tracer_encoded_value_free`]. The input is fully validated and must
+ * contain exactly one value. Token byte slices are borrowed only for this
+ * synchronous call; the returned blob does not retain them.
+ *
+ * # Safety
+ *
+ * `tokens` and every byte slice referenced by its tokens must remain valid for
+ * this call. `out_handle` must point to writable memory for a
+ * `Box<TracerEncodedValue>`.
+ */
+struct ddog_TraceExporterError *ddog_tracer_encode_value(struct ddog_Slice_TracerValueToken tokens,
+                                                         struct ddog_TracerEncodedValue **out_handle);
+
+/**
+ * Borrow the bytes in an encoded value. The slice is valid until the blob is
+ * freed.
+ */
+ddog_ByteSlice ddog_tracer_encoded_value_as_slice(const struct ddog_TracerEncodedValue *value);
+
+/**
+ * Free an encoded structured value and its bytes.
+ */
+void ddog_tracer_encoded_value_free(struct ddog_TracerEncodedValue *value);
+
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_new instead")
+void ddog_trace_exporter_config_new(struct ddog_TraceExporterConfig **out_handle);
+
+/**
+ * Frees TraceExporterConfig handle internal resources.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_free instead")
+void ddog_trace_exporter_config_free(struct ddog_TraceExporterConfig *handle);
+
+/**
+ * Sets traces destination.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_url instead")
+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.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_tracer_version instead")
+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.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_language instead")
+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.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_language_version instead")
+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.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_language_interpreter instead")
+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.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_hostname instead")
+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.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_env instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_env(struct ddog_TraceExporterConfig *config,
+                                                                   ddog_CharSlice env);
+
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_app_version instead")
+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.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_service instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_service(struct ddog_TraceExporterConfig *config,
+                                                                       ddog_CharSlice service);
+
+/**
+ * Enables health metrics emission.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_enable_health_metrics instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_enable_health_metrics(struct ddog_TraceExporterConfig *config,
+                                                                                 bool is_enabled);
+
+/**
+ * Enables telemetry metrics.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_enable_telemetry instead")
+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.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_enable_stats instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_compute_stats(struct ddog_TraceExporterConfig *config,
+                                                                             bool is_enabled);
+
+/**
+ * Indicates that the tracer has already marked top-level spans with `_dd.top_level`.
+ * Sets the `Datadog-Client-Computed-Top-Level` header without enabling stats computation.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_client_computed_top_level instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_client_computed_top_level(struct ddog_TraceExporterConfig *config,
+                                                                                         bool client_computed_top_level);
+
+/**
+ * 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).
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_client_computed_stats instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_client_computed_stats(struct ddog_TraceExporterConfig *config,
+                                                                                     bool client_computed_stats);
+
+/**
+ * Shares a mutable metadata handle with the exporter config.
+ *
+ * When set, this supersedes `ddog_trace_exporter_config_set_process_tags` and
+ * `ddog_trace_exporter_config_set_runtime_id`.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_mutable_metadata instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_mutable_metadata(struct ddog_TraceExporterConfig *config,
+                                                                                const ddog_MutableMetadataHandle *metadata);
+
+/**
+ * Sets the process tags to be included in the stats payload.
+ *
+ * This should not be used when `ddog_trace_exporter_config_set_mutable_metadata` is used.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_process_tags instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_process_tags(struct ddog_TraceExporterConfig *config,
+                                                                            ddog_CharSlice process_tags);
+
+/**
+ * Sets the runtime id used in payloads.
+ *
+ * This should not be used when `ddog_trace_exporter_config_set_mutable_metadata` is used.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_runtime_id instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_runtime_id(struct ddog_TraceExporterConfig *config,
+                                                                          ddog_CharSlice runtime_id);
+
+/**
+ * Sets the `X-Datadog-Test-Session-Token` header. Only used for testing with the test agent.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_test_session_token instead")
+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.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_connection_timeout instead")
+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`.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_shared_runtime instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_shared_runtime(struct ddog_TraceExporterConfig *config,
+                                                                              struct ddog_ForkSafeRuntime *handle);
+
+/**
+ * Enables OTLP trace export and sets the endpoint URL.
+ *
+ * When set, traces are sent to this URL using the protocol selected by
+ * `ddog_trace_exporter_config_set_otlp_protocol` 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.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_otlp_endpoint instead")
+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),
+ * `http/protobuf`, or `grpc`; unknown values are rejected. The host language resolves the value
+ * (e.g. from `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL`).
+ * The `grpc` protocol currently supports plaintext `http://` endpoints only.
+ *
+ * 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.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_otlp_protocol instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_otlp_protocol(struct ddog_TraceExporterConfig *config,
+                                                                             ddog_CharSlice protocol);
+
+/**
+ * Sets OTLP trace instrumentation scope metadata.
+ *
+ * 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 scope metadata is ignored.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_otlp_instrumentation_scope instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_otlp_instrumentation_scope(struct ddog_TraceExporterConfig *config,
+                                                                                          ddog_CharSlice name,
+                                                                                          ddog_CharSlice version);
+
+/**
+ * Sets the cardinality limit for client-side stats computation.
+ *
+ * When the number of distinct stats groups exceeds `limit`, additional groups are
+ * aggregated into a sentinel key instead of being tracked individually.
+ * This bounds memory usage when the trace population has very high cardinality.
+ *
+ * Has no effect unless stats computation is enabled via
+ * `ddog_trace_exporter_config_set_compute_stats`.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_stats_cardinality_limit instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_stats_cardinality_limit(struct ddog_TraceExporterConfig *config,
+                                                                                       struct ddog_CardinalityLimitConfig limits);
+
+/**
+ * Returns a `CardinalityLimitConfig` with default values
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_default_stats_cardinality_limit instead")
+struct ddog_CardinalityLimitConfig ddog_trace_exporter_config_default_stats_cardinality_limit(void);
+
+/**
+ * Enables agentless APM trace export and sets the intake URL and API key.
+ *
+ * When set, APM trace spans are sent directly to the Datadog HTTP intake in JSON format
+ * (`POST /v1/input`) instead of through the Datadog Agent. Agentless trace export is mutually
+ * exclusive with both an agent URL ([`ddog_trace_exporter_config_set_url`]) and an OTLP endpoint
+ * ([`ddog_trace_exporter_config_set_otlp_endpoint`]); combining either with this setter causes
+ * [`ddog_trace_exporter_new`] to return an error.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_agentless_endpoint instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_agentless_endpoint(struct ddog_TraceExporterConfig *config,
+                                                                                  ddog_CharSlice url,
+                                                                                  ddog_CharSlice api_key);
+
+/**
+ * Sets the request timeout (in milliseconds) used by the agentless intake transport.
+ *
+ * Defaults to 15 seconds when unset. Calling this without also setting an agentless endpoint
+ * causes [`ddog_trace_exporter_new`] to return an error.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_agentless_timeout instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_agentless_timeout(struct ddog_TraceExporterConfig *config,
+                                                                                 uint64_t timeout_ms);
+
+/**
+ * Sets the span obfuscation configuration from a JSON string.
+ *
+ * `json` is deserialized into `ObfuscationConfig` (the same struct the Datadog Agent uses),
+ * which controls obfuscation of HTTP URLs, SQL resources, Redis/Valkey commands, memcached
+ * commands, credit-card numbers, elasticsearch/opensearch/mongodb bodies, and tag-replace
+ * rules. Obfuscation is applied to every span on the agentless export path (see
+ * [`ddog_trace_exporter_config_set_agentless_endpoint`]); it has no effect on the agent path.
+ *
+ * Returns an error if `json` is not valid UTF-8 or fails to deserialize. Example:
+ * ```c
+ * ddog_trace_exporter_config_set_obfuscation_config(
+ *   cfg, DDOG_CHARSLICE_C(
+ *     "{\"http\":{\"remove_query_string\":true},"
+ *     "\"credit_cards\":{\"enabled\":true}}"));
+ * ```
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_span_obfuscation_config instead")
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_obfuscation_config(struct ddog_TraceExporterConfig *config,
+                                                                                  ddog_CharSlice json);
+
+/**
+ * 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.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_set_output_to_log instead")
+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 using
+ * the configured `http/json`, `http/protobuf`, or `grpc` protocol instead of 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.
+ */
+DDOG_TRACE_EXPORTER_DEPRECATED("Use ddog_trace_exporter_builder_build instead")
+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);
+
+/**
+ * Consumes the exporter and waits at most `timeout_ms` for its workers to flush.
+ * The handle is consumed on success and error. Other workers on a shared runtime
+ * are unaffected. The deadline bounds worker flushing, not runtime destruction:
+ * dropping the last runtime owner can additionally wait for blocking tasks such
+ * as system DNS resolution. Hosts must account for that separately.
+ *
+ * # Safety
+ *
+ * `handle` must be valid and must not be used concurrently or after this call.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_shutdown(ddog_TraceExporter *handle,
+                                                             uint64_t timeout_ms);
+
+/**
+ * Releases the exporter without flushing or stopping its workers.
+ * The caller must also dispose of the runtime that owns those workers. This is
+ * intended for finalisation and failed fork recovery with an exclusively owned runtime.
+ *
+ * # Safety
+ *
+ * `handle` must be valid and must not be used concurrently or after this call.
+ */
+void ddog_trace_exporter_discard(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);
+
+/**
+ * Creates a trace exporter builder. Free it with `ddog_trace_exporter_builder_free`, or
+ * transfer ownership to `ddog_trace_exporter_builder_build` (including on build failure).
+ */
+void ddog_trace_exporter_builder_new(struct ddog_TraceExporterBuilder_ForkSafeRuntime **out_handle);
+
+/**
+ * Frees a builder handle that has not been passed to `ddog_trace_exporter_builder_build`.
+ */
+void ddog_trace_exporter_builder_free(struct ddog_TraceExporterBuilder_ForkSafeRuntime *handle);
+
+/**
+ * Sets traces destination.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_url(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                    ddog_CharSlice url);
+
+/**
+ * Sets tracer's version to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_tracer_version(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                               ddog_CharSlice version);
+
+/**
+ * Sets tracer's language to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_language(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                         ddog_CharSlice lang);
+
+/**
+ * Sets tracer's language version to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_language_version(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                 ddog_CharSlice version);
+
+/**
+ * Sets tracer's language interpreter to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_language_interpreter(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                     ddog_CharSlice interpreter);
+
+/**
+ * Sets hostname information to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_hostname(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                         ddog_CharSlice hostname);
+
+/**
+ * Sets environment information to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_env(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                    ddog_CharSlice env);
+
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_app_version(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                            ddog_CharSlice version);
+
+/**
+ * Sets service name to be included in the headers request.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_service(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                        ddog_CharSlice service);
+
+/**
+ * Enables health metrics emission.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_enable_health_metrics(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder);
+
+/**
+ * Enables telemetry metrics.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_enable_telemetry(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                             const struct ddog_ExporterTelemetryConfig *telemetry_cfg);
+
+/**
+ * Sets optional instrumentation session headers on telemetry requests (`dd-session-id`,
+ * `dd-root-session-id`, `dd-parent-session-id`). Each slice is stored as given; an empty
+ * slice stores an empty session id.
+ *
+ * All three slices are validated before any value is applied: invalid UTF-8 in any of them
+ * returns an error and leaves the builder unchanged.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_telemetry_instrumentation_sessions(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                                   ddog_CharSlice session_id,
+                                                                                                   ddog_CharSlice root_session_id,
+                                                                                                   ddog_CharSlice parent_session_id);
+
+/**
+ * Enables client-side stats computation with the given bucket interval in seconds.
+ * Pass `10` to use the default 10-second bucket interval.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_enable_stats(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                         uint64_t bucket_interval_secs);
+
+/**
+ * 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 with `ddog_trace_exporter_builder_enable_stats`, 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_builder_set_client_computed_stats(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder);
+
+/**
+ * Shares a mutable metadata handle with the exporter builder.
+ *
+ * Replaces metadata previously set by `ddog_trace_exporter_builder_set_process_tags` and
+ * `ddog_trace_exporter_builder_set_runtime_id`. Calling those setters afterwards updates the
+ * shared handle.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_mutable_metadata(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                 const ddog_MutableMetadataHandle *metadata);
+
+/**
+ * Sets the process tags to be included in the stats payload.
+ *
+ * This should not be used when `ddog_trace_exporter_builder_set_mutable_metadata` is used.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_process_tags(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                             ddog_CharSlice process_tags);
+
+/**
+ * Sets the runtime id used in payloads.
+ *
+ * This should not be used when `ddog_trace_exporter_builder_set_mutable_metadata` is used.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_runtime_id(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                           ddog_CharSlice runtime_id);
+
+/**
+ * Sets the `X-Datadog-Test-Session-Token` header. Only used for testing with the test agent.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_test_session_token(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                   ddog_CharSlice token);
+
+/**
+ * Sets the timeout in ms for all agent's connections.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_connection_timeout(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                   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 builder 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_builder_set_shared_runtime(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                               struct ddog_ForkSafeRuntime *handle);
+
+/**
+ * Enables OTLP trace export and sets the endpoint URL.
+ *
+ * When set, traces are sent to this URL using the protocol selected by
+ * `ddog_trace_exporter_builder_set_otlp_protocol` 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_builder_set_otlp_endpoint(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                              ddog_CharSlice url);
+
+/**
+ * Sets the OTLP export protocol. Accepts the OTel-standard values `http/json` (default),
+ * `http/protobuf`, or `grpc`; unknown values are rejected. The host language resolves the value
+ * (e.g. from `OTEL_EXPORTER_OTLP_TRACES_PROTOCOL`).
+ * The `grpc` protocol currently supports plaintext `http://` endpoints only.
+ *
+ * Has no effect unless an OTLP endpoint is also configured via
+ * `ddog_trace_exporter_builder_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 builder or an unaccepted
+ * value, and `ErrorCode::InvalidInput` for a non-UTF-8 string.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_otlp_protocol(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                              ddog_CharSlice protocol);
+
+/**
+ * Sets OTLP trace instrumentation scope metadata.
+ *
+ * Has no effect unless an OTLP endpoint is also configured via
+ * `ddog_trace_exporter_builder_set_otlp_endpoint`; without one, traces are sent to the
+ * Datadog agent and this scope metadata is ignored.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_otlp_instrumentation_scope(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                           ddog_CharSlice name,
+                                                                                           ddog_CharSlice version);
+
+/**
+ * Sets the cardinality limit for client-side stats computation.
+ *
+ * When the number of distinct stats groups exceeds `limit`, additional groups are
+ * aggregated into a sentinel key instead of being tracked individually.
+ * This bounds memory usage when the trace population has very high cardinality.
+ *
+ * Has no effect unless stats computation is enabled via
+ * `ddog_trace_exporter_builder_enable_stats`.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_stats_cardinality_limit(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                        struct ddog_CardinalityLimitConfig limits);
+
+/**
+ * Returns a `CardinalityLimitConfig` with default values
+ */
+struct ddog_CardinalityLimitConfig ddog_trace_exporter_builder_default_stats_cardinality_limit(void);
+
+/**
+ * Enables agentless APM trace export and sets the intake URL and API key.
+ *
+ * When set, APM trace spans are sent directly to the Datadog HTTP intake in JSON format
+ * (`POST /v1/input`) instead of through the Datadog Agent. Agentless trace export is mutually
+ * exclusive with both an agent URL ([`ddog_trace_exporter_builder_set_url`]) and an OTLP endpoint
+ * ([`ddog_trace_exporter_builder_set_otlp_endpoint`]); combining either with this setter causes
+ * [`ddog_trace_exporter_builder_build`] to return an error.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_agentless_endpoint(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                   ddog_CharSlice url,
+                                                                                   ddog_CharSlice api_key);
+
+/**
+ * Sets the request timeout (in milliseconds) used by the agentless intake transport.
+ *
+ * Defaults to 15 seconds when unset. Calling this without also setting an agentless endpoint
+ * causes [`ddog_trace_exporter_builder_build`] to return an error.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_agentless_timeout(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                  uint64_t timeout_ms);
+
+/**
+ * Sets the span obfuscation configuration from a JSON string.
+ *
+ * `json` is deserialized into `ObfuscationConfig` (the same struct the Datadog Agent uses),
+ * which controls obfuscation of HTTP URLs, SQL resources, Redis/Valkey commands, memcached
+ * commands, credit-card numbers, elasticsearch/opensearch/mongodb bodies, and tag-replace
+ * rules. Obfuscation is applied to every span on the agentless export path (see
+ * [`ddog_trace_exporter_builder_set_agentless_endpoint`]); it has no effect on the agent path.
+ *
+ * Returns an error if `json` is not valid UTF-8 or fails to deserialize. Example:
+ * ```c
+ * ddog_trace_exporter_builder_set_span_obfuscation_config(
+ *   cfg, DDOG_CHARSLICE_C(
+ *     "{\"http\":{\"remove_query_string\":true},"
+ *     "\"credit_cards\":{\"enabled\":true}}"));
+ * ```
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_span_obfuscation_config(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                        ddog_CharSlice json);
+
+/**
+ * Set the URL to communicate with a dogstatsd server.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_dogstatsd_url(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                              ddog_CharSlice url);
+
+/**
+ * Set the `Datadog-Meta-Git-Commit-Sha` header.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_git_commit_sha(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                               ddog_CharSlice git_commit_sha);
+
+/**
+ * Set the `Datadog-Container-Id` header.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_container_id(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                             ddog_CharSlice container_id);
+
+/**
+ * Set the `Datadog-Meta-Lang-Interpreter-Vendor` header.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_language_interpreter_vendor(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                            ddog_CharSlice lang_interpreter_vendor);
+
+/**
+ * Set the input format of the trace payloads passed to `ddog_trace_exporter_send`.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_input_format(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                             enum ddog_TraceExporterInputFormat input_format);
+
+/**
+ * Set the output format used to serialize traces.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_output_format(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                              enum ddog_TraceExporterOutputFormat output_format);
+
+/**
+ * Opt in to the V1 trace protocol.
+ *
+ * V1 is only used after runtime negotiation with the agent via `/info`. When the agent does
+ * not advertise the `/v1.0/traces` endpoint, the exporter falls back to V0.4 transparently.
+ * V1 is only compatible with V0.4 input.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_enable_v1_protocol(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder);
+
+/**
+ * Set the header indicating the tracer has computed the top-level tag.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_client_computed_top_level(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder);
+
+/**
+ * Sets whether background workers spawned by this exporter are restarted in the child after
+ * the process `fork()`s. Defaults to `true`.
+ *
+ * Set to `false` if the trace exporter is recreated after the fork to avoid restarting workers
+ * which are going to be discarded anyway.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_restart_after_fork(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                   bool restart_after_fork);
+
+/**
+ * Enables storing and checking the agent payload version used to detect agent rate updates.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_enable_agent_rates_payload_version(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder);
+
+/**
+ * Enables OpenTelemetry trace semantics when converting spans for OTLP export.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_enable_otel_trace_semantics(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder);
+
+/**
+ * Sets the OTLP metrics intake endpoint used to export OTLP metrics. No effect unless an
+ * OTLP endpoint is also configured via `ddog_trace_exporter_builder_set_otlp_endpoint`.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_otlp_metrics_endpoint(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                      ddog_CharSlice url);
+
+/**
+ * Sets the tracer tags to include in requests.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_tracer_tags(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                            struct ddog_ExporterTagList tracer_tags);
+
+/**
+ * Seeds the peer tags used for peer tags aggregation in stats computation (requires stats
+ * computation to be enabled).
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_peer_tags(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                          struct ddog_ExporterTagList peer_tags);
+
+/**
+ * Sets additional metric tag keys.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_additional_metric_tag_keys(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                           struct ddog_ExporterTagList tag_keys);
+
+/**
+ * Sets additional headers or gRPC metadata to include in OTLP trace export requests.
+ *
+ * Headers should be provided as name/value pairs. The host language is responsible for
+ * resolving headers from its configuration (e.g. `OTEL_EXPORTER_OTLP_TRACES_HEADERS`)
+ * before calling this function.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_otlp_headers(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                             struct ddog_ExporterHeaderList headers);
+
+/**
+ * Additional HTTP headers for OTLP trace-metrics requests.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_set_otlp_metrics_headers(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                                     struct ddog_ExporterHeaderList headers);
+
+/**
+ * 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_builder_set_output_to_log(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                              uintptr_t max_line_size);
+
+/**
+ * Create a new TraceExporter instance.
+ *
+ * When an OTLP endpoint is configured via `TraceExporterBuilder<ForkSafeRuntime>`, the exporter
+ * sends traces using the configured `http/json`, `http/protobuf`, or `grpc` protocol instead of
+ * 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.
+ * * `builder` - The builder used to set up the TraceExporter handle. Ownership is transferred to
+ *   this function even on failure; do not reuse or free it after this call.
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_builder_build(struct ddog_TraceExporterBuilder_ForkSafeRuntime *builder,
+                                                                  ddog_TraceExporter **out_handle);
+
+/**
+ * Create a new span with all scalar fields set.
+ *
+ * String fields are copied from the provided slices. The `meta`, `metrics` and `meta_struct`
+ * maps start empty; use [`ddog_tracer_span_set_meta`], [`ddog_tracer_span_set_metric`] and
+ * [`ddog_tracer_span_set_meta_struct_blob`] to populate them.
+ *
+ * Returns an error if `fields` is null, if any string field is not valid UTF-8, or if any of
+ * its slices is malformed.
+ *
+ * # 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.
+ *
+ * Returns an error if `handle` is null, if `key` or `value` is not valid UTF-8, or if either
+ * slice is malformed.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid pointer to a `TracerSpan`. `key` and `value` must point to valid
+ * memory for their stated lengths.
+ */
+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.
+ *
+ * Returns an error if `handle` is null, if `key` is not valid UTF-8, or if the slice is
+ * malformed.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid pointer to a `TracerSpan`. `key` must point to valid memory for its
+ * stated length.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_set_metric(ddog_TracerSpan *handle,
+                                                            ddog_CharSlice key,
+                                                            double value);
+
+/**
+ * Add or overwrite a structured metadata entry (`meta_struct`) on the span.
+ *
+ * The `key` and opaque binary `value` are copied into the span. The value is
+ * not interpreted or validated as MessagePack.
+ *
+ * Returns an error if `handle` is null, if `key` is not valid UTF-8, or if either slice is
+ * malformed.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid pointer to a `TracerSpan`. `key` and `value` must point to valid
+ * memory for their stated lengths.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_set_meta_struct_blob(ddog_TracerSpan *handle,
+                                                                      ddog_CharSlice key,
+                                                                      ddog_ByteSlice value);
+
+/**
+ * Encode and add or overwrite a structured metadata entry (`meta_struct`) on
+ * the span.
+ *
+ * The `key` is copied into the span. The structured-value tokens are fully
+ * validated and encoded directly into the span without exposing an
+ * intermediate blob to the caller. The span is unchanged on failure.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid pointer to a `TracerSpan`. `key` must point to
+ * valid UTF-8 memory. `tokens` and every byte slice referenced by its tokens
+ * must remain valid for this call.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_set_meta_struct(ddog_TracerSpan *handle,
+                                                                 ddog_CharSlice key,
+                                                                 struct ddog_Slice_TracerValueToken tokens);
+
+/**
+ * Replace all span links in one atomic operation.
+ *
+ * The links, attributes, and strings are copied before this function returns.
+ * If any slice or string is invalid, the span's existing links are unchanged.
+ * Link order is preserved.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid pointer to a `TracerSpan`. All slices must point to
+ * valid memory for their stated lengths.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_set_links(ddog_TracerSpan *handle,
+                                                           struct ddog_Slice_TracerSpanLink links);
+
+/**
+ * Create an owned span event.
+ *
+ * The name is copied before this function returns. The event remains detached
+ * until consumed by [`ddog_tracer_span_add_event`].
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_event_new(ddog_TracerSpanEvent **out_handle,
+                                                           ddog_CharSlice name,
+                                                           uint64_t time_unix_nano);
+
+/**
+ * Free a detached span event.
+ */
+void ddog_tracer_span_event_free(ddog_TracerSpanEvent *handle);
+
+/**
+ * Add or overwrite a string event attribute. The key and value are copied.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_event_set_string(ddog_TracerSpanEvent *event,
+                                                                  ddog_CharSlice key,
+                                                                  ddog_CharSlice value);
+
+/**
+ * Add or overwrite a boolean event attribute.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_event_set_bool(ddog_TracerSpanEvent *event,
+                                                                ddog_CharSlice key,
+                                                                bool value);
+
+/**
+ * Add or overwrite a signed integer event attribute.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_event_set_int(ddog_TracerSpanEvent *event,
+                                                               ddog_CharSlice key,
+                                                               int64_t value);
+
+/**
+ * Add or overwrite a double event attribute.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_event_set_double(ddog_TracerSpanEvent *event,
+                                                                  ddog_CharSlice key,
+                                                                  double value);
+
+/**
+ * Add or overwrite a homogeneous string array event attribute.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_event_set_string_array(ddog_TracerSpanEvent *event,
+                                                                        ddog_CharSlice key,
+                                                                        struct ddog_Slice_CharSlice values);
+
+/**
+ * Add or overwrite a homogeneous boolean array event attribute.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_event_set_bool_array(ddog_TracerSpanEvent *event,
+                                                                      ddog_CharSlice key,
+                                                                      struct ddog_Slice_Bool values);
+
+/**
+ * Add or overwrite a homogeneous signed integer array event attribute.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_event_set_int_array(ddog_TracerSpanEvent *event,
+                                                                     ddog_CharSlice key,
+                                                                     struct ddog_Slice_I64 values);
+
+/**
+ * Add or overwrite a homogeneous double array event attribute.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_event_set_double_array(ddog_TracerSpanEvent *event,
+                                                                        ddog_CharSlice key,
+                                                                        struct ddog_Slice_F64 values);
+
+/**
+ * Atomically attach a completed event to a span, consuming the event.
+ *
+ * A non-null `event` is always consumed — moved into the span on success, or
+ * dropped on any error (a null `span`, or an internal panic). Callers must not
+ * use or free the event after this call. On error the span is unchanged.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_add_event(ddog_TracerSpan *span,
+                                                           ddog_TracerSpanEvent *event);
+
+/**
+ * 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. Cancellation is cooperative and only
+ * affects a [`ddog_trace_exporter_send_trace_chunks`] call that is in flight: that send stops
+ * waiting for the agent at its next await point and fails with
+ * [`ExporterErrorCode::IoError`], and the chunks it was sending may be lost.
+ *
+ * Cancelling while no send is using the token has no immediate effect. A send started later with
+ * an already-cancelled token fails the same way without contacting the agent, and cancelling
+ * after a send has 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.
+ *
+ * Computes stats, serializes in the configured output format, and sends to the agent with
+ * retries.
+ *
+ * When `cancel` is non-null, cancelling that token aborts the in-flight request; see
+ * [`ddog_trace_exporter_cancel_token_cancel`].
+ *
+ * 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 */