libdatadog 37.0.0.1.0 → 39.0.0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d2caf139a67b432139f30d9d681b3424eb67869848eec2ea844775a67b0b5cf
-  data.tar.gz: b7d172117d328f5dab3be10fdcae6c42dbe8029899a8229318360fa158bff45a
+  metadata.gz: 114157501f296f5eb2152369ebe115b1a012dc530da5317b026ea859d3c649bc
+  data.tar.gz: f0faabc0acd20de92b2e86c95eaab93765ec9af0d56fb30a7ebfa513aa70a56e
 SHA512:
-  metadata.gz: 16371759dc1728b47790494fb7c9ae5ac9270f916e58eb31560c9adef9bd30f6524db35776603e97405d691361a387f0eca0af3e82cbbeabc0f4f0920d5680c1
-  data.tar.gz: a28575cef31af7fbe63b6ef832f770ef3ff8fe8afb4fc97dae1da95842ceafcb74c6e72c3740c09e12065910236576289667dfd8ffa35627019cade41bacba94
+  metadata.gz: 1a71140391443f4325242a4198b4e2b14037f919709ded517642c22b39d6126d3e5da3bed9ab63d3299b1a715418a60e575a9cdb860521fbe7b970cabbe1fc61
+  data.tar.gz: bf748dd1cae615c0d284cf465cb9529c857add3c2ed8aa61d5ce9bca6d6995efe48b95280c23517684a9839a03d86f0c05c34bc77967d051f243e588bc4bfc77

data/lib/libdatadog/version.rb

@@ -2,7 +2,7 @@
 
 module Libdatadog
   # Current libdatadog version
-  LIB_VERSION = "37.0.0"
+  LIB_VERSION = "39.0.0"
 
   GEM_MAJOR_VERSION = "1"
   GEM_MINOR_VERSION = "0"

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

@@ -220,7 +220,7 @@ js-sys,https://github.com/rustwasm/wasm-bindgen/tree/master/crates/js-sys,MIT OR
 kernel32-sys,https://github.com/retep998/winapi-rs,MIT,Peter Atashian <retep998@gmail.com>
 kv-log-macro,https://github.com/yoshuawuyts/kv-log-macro,MIT OR Apache-2.0,Yoshua Wuyts <yoshuawuyts@gmail.com>
 lazy_static,https://github.com/rust-lang-nursery/lazy-static.rs,MIT OR Apache-2.0,Marvin Löbel <loebel.marvin@gmail.com>
-libc,https://github.com/rust-lang/libc,MIT OR Apache-2.0,The Rust Project Developers
+libc,https://github.com/rust-lang/libc,MIT OR Apache-2.0,The libc Authors
 libdd-libunwind-sys,https://github.com/DataDog/libdatadog/tree/main/libdd-libunwind-sys,Apache-2.0,The libdd-libunwind-sys Authors
 libloading,https://github.com/nagisa/rust_libloading,ISC,Simonas Kazlauskas <libloading@kazlauskas.me>
 libredox,https://gitlab.redox-os.org/redox-os/libredox,MIT,4lDO2 <4lDO2@protonmail.com>
@@ -375,6 +375,7 @@ semver,https://github.com/dtolnay/semver,MIT OR Apache-2.0,David Tolnay <dtolnay
 sendfd,https://github.com/standard-ai/sendfd,Apache-2.0 OR BSD-3-Clause,"Simonas Kazlauskas <simonas@standard.ai>, Bernardo Meurer <bernardo@standard.ai>, Léo Gaspard <leo@standard.ai>"
 serde,https://github.com/serde-rs/serde,MIT OR Apache-2.0,"Erick Tryzelaar <erick.tryzelaar@gmail.com>, David Tolnay <dtolnay@gmail.com>"
 serde-bool,https://github.com/x52dev/serde-utils,MIT OR Apache-2.0,Rob Ede <robjtede@icloud.com>
+serde-transcode,https://github.com/sfackler/serde-transcode,MIT OR Apache-2.0,Steven Fackler <sfackler@palantir.com>
 serde_bytes,https://github.com/serde-rs/bytes,MIT OR Apache-2.0,David Tolnay <dtolnay@gmail.com>
 serde_core,https://github.com/serde-rs/serde,MIT OR Apache-2.0,"Erick Tryzelaar <erick.tryzelaar@gmail.com>, David Tolnay <dtolnay@gmail.com>"
 serde_derive,https://github.com/serde-rs/serde,MIT OR Apache-2.0,"Erick Tryzelaar <erick.tryzelaar@gmail.com>, David Tolnay <dtolnay@gmail.com>"
@@ -497,6 +498,7 @@ wasm-bindgen-macro,https://github.com/rustwasm/wasm-bindgen/tree/master/crates/m
 wasm-bindgen-macro-support,https://github.com/rustwasm/wasm-bindgen/tree/master/crates/macro-support,MIT OR Apache-2.0,The wasm-bindgen Developers
 wasm-bindgen-shared,https://github.com/rustwasm/wasm-bindgen/tree/master/crates/shared,MIT OR Apache-2.0,The wasm-bindgen Developers
 web-sys,https://github.com/rustwasm/wasm-bindgen/tree/master/crates/web-sys,MIT OR Apache-2.0,The wasm-bindgen Developers
+web-time,https://github.com/daxpedda/web-time,MIT OR Apache-2.0,The web-time Authors
 webpki-root-certs,https://github.com/rustls/webpki-roots,CDLA-Permissive-2.0,The webpki-root-certs Authors
 webpki-roots,https://github.com/rustls/webpki-roots,CDLA-Permissive-2.0,The webpki-roots Authors
 widestring,https://github.com/VoidStarKat/widestring-rs,MIT OR Apache-2.0,The widestring Authors

data/vendor/libdatadog-39.0.0/aarch64-linux/NOTICE

@@ -0,0 +1,12 @@
+Datadog libdatadog
+Copyright 2021-2022 Datadog, Inc.
+
+This product includes software developed at Datadog (<https://www.datadoghq.com/>).
+
+--
+
+This product bundles a copy of the libbpf/usdt single-header USDT
+library in `libdd-profiling-heap-sampler/vendor/usdt.h`. That file is licensed
+under the BSD 2-Clause License, Copyright (c) 2024 Meta Platforms, Inc.
+and affiliates. The SPDX identifier and copyright notice are retained
+verbatim in the file header. Upstream: <https://github.com/libbpf/usdt>.

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

@@ -279,6 +279,14 @@ typedef struct ddog_prof_Function2 *ddog_prof_FunctionId2;
  * - **dd-trace-dotnet**: Sample type definitions for allocations, locks, CPU, walltime,
  *   exceptions, live objects, HTTP requests
  * - **pprof-nodejs**: `profile-serializer.ts` (value type functions)
+ *
+ * # Adding new types
+ *
+ * To prototype a new profile type without a libdatadog release, use one of
+ * the `Custom1` through `Custom5` slots and configure its concrete `(type,
+ * unit)` string pair on the profile before serialization. Once the type is
+ * stable and agreed upon across profiler teams, add a dedicated variant here
+ * so callers can use the type-safe path.
  */
 typedef enum ddog_prof_SampleType {
   DDOG_PROF_SAMPLE_TYPE_ALLOC_SAMPLES,
@@ -351,9 +359,31 @@ typedef enum ddog_prof_SampleType {
    * Legacy: Use `WallTime` instead for consistency with naming scheme
    */
   DDOG_PROF_SAMPLE_TYPE_WALL_LEGACY,
-  DDOG_PROF_SAMPLE_TYPE_EXPERIMENTAL_COUNT,
-  DDOG_PROF_SAMPLE_TYPE_EXPERIMENTAL_NANOSECONDS,
-  DDOG_PROF_SAMPLE_TYPE_EXPERIMENTAL_BYTES,
+  /**
+   * Custom profile type slot. Configure its concrete `(type, unit)` on the profile before
+   * serialization.
+   */
+  DDOG_PROF_SAMPLE_TYPE_CUSTOM1,
+  /**
+   * Custom profile type slot. Configure its concrete `(type, unit)` on the profile before
+   * serialization.
+   */
+  DDOG_PROF_SAMPLE_TYPE_CUSTOM2,
+  /**
+   * Custom profile type slot. Configure its concrete `(type, unit)` on the profile before
+   * serialization.
+   */
+  DDOG_PROF_SAMPLE_TYPE_CUSTOM3,
+  /**
+   * Custom profile type slot. Configure its concrete `(type, unit)` on the profile before
+   * serialization.
+   */
+  DDOG_PROF_SAMPLE_TYPE_CUSTOM4,
+  /**
+   * Custom profile type slot. Configure its concrete `(type, unit)` on the profile before
+   * serialization.
+   */
+  DDOG_PROF_SAMPLE_TYPE_CUSTOM5,
 } ddog_prof_SampleType;
 
 typedef enum ddog_prof_Utf8Option {
@@ -375,8 +405,6 @@ typedef enum ddog_prof_Utf8Option {
 
 typedef struct ddog_OpaqueCancellationToken ddog_OpaqueCancellationToken;
 
-typedef struct ddog_prof_EncodedProfile ddog_prof_EncodedProfile;
-
 typedef struct ddog_prof_ExporterManager ddog_prof_ExporterManager;
 
 typedef struct ddog_prof_Exporter ddog_prof_Exporter;
@@ -891,23 +919,6 @@ typedef struct ddog_prof_StringHeader {
   uint8_t _0;
 } ddog_prof_StringHeader;
 
-/**
- * An FFI-safe string ID where a null StringId2 maps to `StringRef::EMPTY`.
- * The representation is ensured to be a  pointer for ABI stability, but
- * callers should not generally dereference this pointer. When using the id,
- * the caller needs to be sure that the `ProfilesDictionary` or string set it
- * refers to is the same one that the operations are performed on; it is not
- * generally guaranteed that ids from one dictionary/set can be used in
- * another, even if it happens to work by implementation detail. There is an
- * exception is for well-known strings, which are considered present in every
- * string set.
- *
- * Equality and hashing are defined by pointer identity, so they are only
- * meaningful when comparing ids that originate from the same
- * `ProfilesDictionary`.
- */
-typedef struct ddog_prof_StringHeader *ddog_prof_StringId2;
-
 /**
  * An FFI-safe version of the Mapping which allows null. Be sure to maintain
  * layout-compatibility with it, except that StringId2 may be null.
@@ -920,21 +931,6 @@ typedef struct ddog_prof_Mapping2 {
   ddog_prof_StringId2 build_id;
 } ddog_prof_Mapping2;
 
-/**
- * An FFI-safe representation of a "handle" to a mapping which has been
- * stored in the `ProfilesDictionary`. The representation is ensured to be a
- * pointer for ABI stability, but callers should not generally dereference
- * this pointer. When using the id, the caller needs to be sure that the
- * `ProfilesDictionary` it refers to is the same one that the operations are
- * performed on; it is not generally guaranteed that ids from one dictionary
- * can be used in another dictionary, even if it happens to work by
- * implementation detail.
- *
- * `Eq`/`Hash` and other comparisons are based on this handle value, and are
- * only intended for ids produced by the same `ProfilesDictionary`.
- */
-typedef struct ddog_prof_Mapping2 *ddog_prof_MappingId2;
-
 /**
  * An FFI-safe version of the Function which allows null. Be sure to maintain
  * layout-compatibility with it, except that StringId2 may be null.
@@ -949,21 +945,6 @@ typedef struct ddog_prof_Function2 {
   ddog_prof_StringId2 file_name;
 } ddog_prof_Function2;
 
-/**
- * An FFI-safe representation of a "handle" to a function which has been
- * stored in the `ProfilesDictionary`. The representation is ensured to be a
- * pointer for ABI stability, but callers should not generally dereference
- * this pointer. When using the id, the caller needs to be sure that the
- * `ProfilesDictionary` it refers to is the same one that the operations are
- * performed on; it is not generally guaranteed that ids from one dictionary
- * can be used in another dictionary, even if it happens to work by
- * implementation detail.
- *
- * `Eq`/`Hash` and other comparisons are based on this handle value, and are
- * only intended for ids produced by the same `ProfilesDictionary`.
- */
-typedef struct ddog_prof_Function2 *ddog_prof_FunctionId2;
-
 /**
  * A location keyed by `MappingId2`/`FunctionId2` handles.
  *
@@ -1163,8 +1144,6 @@ typedef struct OpaqueStringId {
 } OpaqueStringId;
 #define OpaqueStringId_ZERO (OpaqueStringId){  }
 
-typedef struct OpaqueStringId OpaqueStringId;
-
 typedef struct ddog_prof_StringId {
   struct ddog_prof_Generation generation;
   OpaqueStringId id;
@@ -1513,8 +1492,6 @@ typedef struct ddog_StringWrapperResult {
   };
 } ddog_StringWrapperResult;
 
-typedef struct ddog_prof_StringId ddog_prof_StringId;
-
 typedef enum ddog_ConfigurationOrigin {
   DDOG_CONFIGURATION_ORIGIN_ENV_VAR,
   DDOG_CONFIGURATION_ORIGIN_CODE,
@@ -1586,9 +1563,10 @@ typedef struct ddog_TelemetryWorkerBuilder ddog_TelemetryWorkerBuilder;
  * The worker won't send data to the agent until you call `TelemetryWorkerHandle::send_start`
  *
  * To stop the worker, call `TelemetryWorkerHandle::send_stop` which trigger flush asynchronously
- * then `TelemetryWorkerHandle::wait_for_shutdown`
+ * then `TelemetryWorkerHandle::wait_for_shutdown` (native only — wasm callers rely on the
+ * SharedRuntime worker JoinHandle instead).
  */
-typedef struct ddog_TelemetryWorkerHandle ddog_TelemetryWorkerHandle;
+typedef struct ddog_TelemetryWorkerHandle_NativeCapabilities ddog_TelemetryWorkerHandle_NativeCapabilities;
 
 typedef enum ddog_Option_U64_Tag {
   DDOG_OPTION_U64_SOME_U64,
@@ -1604,6 +1582,12 @@ typedef struct ddog_Option_U64 {
   };
 } ddog_Option_U64;
 
+/**
+ * FFI-facing alias: the C ABI surface is native-only, so the worker handle is
+ * always pinned to [`NativeCapabilities`].
+ */
+typedef struct ddog_TelemetryWorkerHandle_NativeCapabilities ddog_TelemetryWorkerHandle;
+
 typedef enum ddog_Option_Bool_Tag {
   DDOG_OPTION_BOOL_SOME_BOOL,
   DDOG_OPTION_BOOL_NONE_BOOL,
@@ -1625,10 +1609,19 @@ typedef struct ddog_ContextKey {
 
 typedef struct ddog_TraceExporter ddog_TraceExporter;
 typedef struct ddog_TracerSpan ddog_TracerSpan;
+typedef struct ddog_TracerSpanEvent ddog_TracerSpanEvent;
 typedef struct ddog_TracerTraceChunks ddog_TracerTraceChunks;
 typedef struct ddog_TraceExporterCancelToken ddog_TraceExporterCancelToken;
 
 
+#define ddog_CollapsedFieldSet_RESOURCE_NAME (1 << 0)
+
+#define ddog_CollapsedFieldSet_HTTP_ENDPOINT (1 << 1)
+
+#define ddog_CollapsedFieldSet_PEER_TAGS (1 << 2)
+
+#define ddog_CollapsedFieldSet_ADDITIONAL_TAGS (1 << 3)
+
 /**
  * Represent error codes that `Error` struct can hold
  */
@@ -1729,6 +1722,32 @@ typedef struct ddog_TelemetryClientConfig {
   ddog_CharSlice parent_session_id;
 } ddog_TelemetryClientConfig;
 
+/**
+ * Config to override the default stats cardinality limit values
+ */
+typedef struct ddog_CardinalityLimitConfig {
+  /**
+   * The whole-key cardinality limit (defaults to 7000)
+   */
+  uintptr_t whole_key_limit;
+  /**
+   * The per-field cardinality limit for the Resource field (defaults to 1024)
+   */
+  uintptr_t resource_limit;
+  /**
+   * The per-field cardinality limit for the HttpEndpoint field (defaults to 512)
+   */
+  uintptr_t http_endpoint_limit;
+  /**
+   * The per-field cardinality limit for the PeerTags field (defaults to 512)
+   */
+  uintptr_t peer_tags_limit;
+  /**
+   * The per-field cardinality limit for the AdditionalTags field (defaults to 100)
+   */
+  uintptr_t additional_tags_limit;
+} ddog_CardinalityLimitConfig;
+
 /**
  * FFI-safe bundle of scalar fields for creating a [`TracerSpan`].
  *
@@ -1749,6 +1768,96 @@ typedef struct ddog_TracerSpanFields {
   int32_t error;
 } ddog_TracerSpanFields;
 
+/**
+ * A string attribute belonging to a [`TracerSpanLink`].
+ */
+typedef struct ddog_TracerSpanLinkAttribute {
+  ddog_CharSlice key;
+  ddog_CharSlice value;
+} ddog_TracerSpanLinkAttribute;
+
+typedef struct ddog_Slice_TracerSpanLinkAttribute {
+  /**
+   * Should be non-null and suitably aligned for the underlying type. It is
+   * allowed but not recommended for the pointer to be null when the len is
+   * zero.
+   */
+  const struct ddog_TracerSpanLinkAttribute *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_Slice_TracerSpanLinkAttribute;
+
+/**
+ * FFI-safe representation of one complete span link.
+ */
+typedef struct ddog_TracerSpanLink {
+  uint64_t trace_id_low;
+  uint64_t trace_id_high;
+  uint64_t span_id;
+  struct ddog_Slice_TracerSpanLinkAttribute attributes;
+  ddog_CharSlice tracestate;
+  uint32_t flags;
+} ddog_TracerSpanLink;
+
+typedef struct ddog_Slice_TracerSpanLink {
+  /**
+   * Should be non-null and suitably aligned for the underlying type. It is
+   * allowed but not recommended for the pointer to be null when the len is
+   * zero.
+   */
+  const struct ddog_TracerSpanLink *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_Slice_TracerSpanLink;
+
+typedef struct ddog_Slice_CharSlice {
+  /**
+   * Should be non-null and suitably aligned for the underlying type. It is
+   * allowed but not recommended for the pointer to be null when the len is
+   * zero.
+   */
+  const ddog_CharSlice *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_Slice_CharSlice;
+
+typedef struct ddog_Slice_Bool {
+  /**
+   * Should be non-null and suitably aligned for the underlying type. It is
+   * allowed but not recommended for the pointer to be null when the len is
+   * zero.
+   */
+  const bool *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_Slice_Bool;
+
+typedef struct ddog_Slice_F64 {
+  /**
+   * Should be non-null and suitably aligned for the underlying type. It is
+   * allowed but not recommended for the pointer to be null when the len is
+   * zero.
+   */
+  const double *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_Slice_F64;
+
 typedef enum ddog_LibraryConfigSource {
   DDOG_LIBRARY_CONFIG_SOURCE_LOCAL_STABLE_CONFIG = 0,
   DDOG_LIBRARY_CONFIG_SOURCE_FLEET_STABLE_CONFIG = 1,
@@ -1791,20 +1900,6 @@ typedef struct ddog_CStr {
   uintptr_t length;
 } ddog_CStr;
 
-typedef struct ddog_Slice_CharSlice {
-  /**
-   * Should be non-null and suitably aligned for the underlying type. It is
-   * allowed but not recommended for the pointer to be null when the len is
-   * zero.
-   */
-  const ddog_CharSlice *ptr;
-  /**
-   * The number of elements (not bytes) that `.ptr` points to. Must be less
-   * than or equal to [isize::MAX].
-   */
-  uintptr_t len;
-} ddog_Slice_CharSlice;
-
 typedef struct ddog_ProcessInfo {
   struct ddog_Slice_CharSlice args;
   struct ddog_Slice_CharSlice envp;

data/vendor/{libdatadog-37.0.0/arm64-darwin → libdatadog-39.0.0/aarch64-linux}/include/datadog/data-pipeline.h

@@ -183,6 +183,35 @@ struct ddog_TraceExporterError *ddog_trace_exporter_config_set_otlp_endpoint(str
 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.
+ */
+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`.
+ */
+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
+ */
+struct ddog_CardinalityLimitConfig ddog_trace_exporter_config_default_stats_cardinality_limit(void);
+
 /**
  * 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
@@ -246,9 +275,12 @@ struct ddog_TraceExporterError *ddog_trace_exporter_send(const ddog_TraceExporte
 /**
  * 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.
+ * 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
  *
@@ -276,10 +308,13 @@ void ddog_tracer_span_free(ddog_TracerSpan *handle);
  *
  * 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 UTF-8 memory.
+ * `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,
@@ -290,15 +325,132 @@ struct ddog_TraceExporterError *ddog_tracer_span_set_meta(ddog_TracerSpan *handl
  *
  * 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 UTF-8 memory.
+ * `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);
+
+/**
+ * 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.
  *
@@ -365,17 +517,14 @@ 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.
+ * 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.
  *
- * 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.
+ * 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);
 
@@ -389,19 +538,11 @@ 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.
+ * 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