libdatadog 38.0.0.1.0 → 40.0.0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: acf5bfce73d30f51bff48c4c624ef033bc1907a8ed14cd10ccf74da199a1b34e
-  data.tar.gz: 1ce9406014b9cea0d221ac36008dcb6b02d1884a2d55249a1fb843be240c6087
+  metadata.gz: d504f44b27d92cdae236776497e54dc9410352658f00ca566402ed501fb1e37c
+  data.tar.gz: b14c06df3f9039faafea968db80f88daf6c496eb6a98ad7c3f33ac00ed44ddd5
 SHA512:
-  metadata.gz: 3df08279edf1e21b9db5856c3ca90a6cf4488a9963f242c3bdb03a3320f16b965acc534e9b4dd2f7c74223b2e13afc940c40f87b090bc44afd90c669c5040f24
-  data.tar.gz: a02d9031f0490f31c2de9c4b07f0dabd8c1d4e274364487f719b073acbdc6aa9daddde42dd1df537f395f4983c89d0c58ca18f270249ebdbbc8c98a88ab8c2f5
+  metadata.gz: c8021d4c49389571171674b3ecde28baed658bd930b4a09891ada8cdf655af4d059d008b9ef42466275842f48bdb7b4a732623409bdeee2a7f1fbcd76a696cf5
+  data.tar.gz: 33fe4d6fda2ada6275064b17e4facffb0377c9120fd11cf3fc52fe4136fc4153a816321760e59bea25f3d8f1a44e2a2ffaabcbf76fd4baf2fe19a65dfe1c1724

data/lib/libdatadog/version.rb

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

data/vendor/{libdatadog-38.0.0/aarch64-linux-musl → libdatadog-40.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>

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

@@ -1501,6 +1501,9 @@ typedef enum ddog_ConfigurationOrigin {
   DDOG_CONFIGURATION_ORIGIN_LOCAL_STABLE_CONFIG,
   DDOG_CONFIGURATION_ORIGIN_FLEET_STABLE_CONFIG,
   DDOG_CONFIGURATION_ORIGIN_CALCULATED,
+  DDOG_CONFIGURATION_ORIGIN_OTEL_ENV_VAR,
+  DDOG_CONFIGURATION_ORIGIN_INI,
+  DDOG_CONFIGURATION_ORIGIN_UNKNOWN,
 } ddog_ConfigurationOrigin;
 
 typedef enum ddog_LogLevel {
@@ -1521,12 +1524,17 @@ typedef enum ddog_MetricNamespace {
   DDOG_METRIC_NAMESPACE_TELEMETRY,
   DDOG_METRIC_NAMESPACE_APM,
   DDOG_METRIC_NAMESPACE_SIDECAR,
+  DDOG_METRIC_NAMESPACE_CIVISIBILITY,
+  DDOG_METRIC_NAMESPACE_MLOBS,
+  DDOG_METRIC_NAMESPACE_DDTRACEAPI,
+  DDOG_METRIC_NAMESPACE_AI_GUARD,
 } ddog_MetricNamespace;
 
 typedef enum ddog_MetricType {
   DDOG_METRIC_TYPE_GAUGE,
   DDOG_METRIC_TYPE_COUNT,
   DDOG_METRIC_TYPE_DISTRIBUTION,
+  DDOG_METRIC_TYPE_RATE,
 } ddog_MetricType;
 
 typedef enum ddog_TelemetryWorkerBuilderBoolProperty {
@@ -1609,10 +1617,38 @@ 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;
+typedef uint8_t ddog_TracerValueKind;
 
 
+#define DDOG_TRACER_VALUE_NIL 0
+
+#define DDOG_TRACER_VALUE_BOOL 1
+
+#define DDOG_TRACER_VALUE_I64 2
+
+#define DDOG_TRACER_VALUE_U64 3
+
+#define DDOG_TRACER_VALUE_F64 4
+
+#define DDOG_TRACER_VALUE_STRING 5
+
+#define DDOG_TRACER_VALUE_BINARY 6
+
+#define DDOG_TRACER_VALUE_ARRAY 7
+
+#define DDOG_TRACER_VALUE_MAP 8
+
+#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
  */
@@ -1669,6 +1705,11 @@ typedef struct ddog_ForkSafeRuntime ddog_ForkSafeRuntime;
  */
 typedef struct ddog_TraceExporterConfig ddog_TraceExporterConfig;
 
+/**
+ * Opaque owned MessagePack blob produced from structured-value tokens.
+ */
+typedef struct ddog_TracerEncodedValue ddog_TracerEncodedValue;
+
 /**
  * Structure that contains error information that `TraceExporter` API can return.
  */
@@ -1677,6 +1718,39 @@ typedef struct ddog_TraceExporterError {
   char *msg;
 } ddog_TraceExporterError;
 
+/**
+ * One value in a flat preorder representation of a structured value.
+ *
+ * Scalar tokens use the corresponding scalar field. String and binary tokens
+ * use `bytes`. Array and map tokens use `child_count`; a map is followed by
+ * two values per entry (key, then value). All other fields must be ignored.
+ * `kind` remains a raw integer so malformed C input can be rejected without
+ * constructing an invalid Rust enum discriminant.
+ */
+typedef struct ddog_TracerValueToken {
+  uint8_t kind;
+  uint8_t bool_value;
+  uint32_t child_count;
+  int64_t i64_value;
+  uint64_t u64_value;
+  double f64_value;
+  ddog_ByteSlice bytes;
+} ddog_TracerValueToken;
+
+typedef struct ddog_Slice_TracerValueToken {
+  /**
+   * 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_TracerValueToken *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_TracerValueToken;
+
 /**
  * FFI compatible configuration for the TelemetryClient.
  */
@@ -1713,6 +1787,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`].
  *
@@ -1733,6 +1833,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,
@@ -1775,20 +1965,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-38.0.0 → libdatadog-40.0.0}/aarch64-linux/include/datadog/data-pipeline.h

@@ -33,6 +33,34 @@ ddog_ByteSlice ddog_trace_exporter_response_get_body(const struct ddog_TraceExpo
  */
 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);
+
 void ddog_trace_exporter_config_new(struct ddog_TraceExporterConfig **out_handle);
 
 /**
@@ -205,7 +233,12 @@ struct ddog_TraceExporterError *ddog_trace_exporter_config_set_otlp_instrumentat
  * `ddog_trace_exporter_config_set_compute_stats`.
  */
 struct ddog_TraceExporterError *ddog_trace_exporter_config_set_stats_cardinality_limit(struct ddog_TraceExporterConfig *config,
-                                                                                       uintptr_t limit);
+                                                                                       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
@@ -270,9 +303,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
  *
@@ -300,10 +336,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,
@@ -314,15 +353,150 @@ 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);
+
+/**
+ * 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.
  *
@@ -389,17 +563,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);
 
@@ -413,19 +584,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

data/vendor/{libdatadog-38.0.0/arm64-darwin → libdatadog-40.0.0/aarch64-linux}/lib/pkgconfig/datadog_profiling_with_rpath.pc

@@ -8,7 +8,7 @@ includedir=${prefix}/include
 
 Name: datadog_profiling
 Description: Contains common code used to implement Datadog's Continuous Profilers. (Dynamic linking variant, sets rpath)
-Version: 38.0.0
+Version: 40.0.0
 Requires:
 Libs: -L${libdir} -ldatadog_profiling -Wl,-rpath,${libdir}
 Libs.private:

data/vendor/{libdatadog-38.0.0/aarch64-linux → libdatadog-40.0.0/aarch64-linux-musl}/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>