libdatadog 30.0.0.1.0 → 35.0.0.1.0

data/vendor/{libdatadog-30.0.0/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl → libdatadog-35.0.0/x86_64-linux-musl}/include/datadog/common.h

@@ -489,6 +489,24 @@ typedef struct ddog_prof_ProfileExporter_Result {
   };
 } ddog_prof_ProfileExporter_Result;
 
+/**
+ * A generic result type for when an operation may fail,
+ * but there's nothing to return in the case of success.
+ */
+typedef enum ddog_VoidResult_Tag {
+  DDOG_VOID_RESULT_OK,
+  DDOG_VOID_RESULT_ERR,
+} ddog_VoidResult_Tag;
+
+typedef struct ddog_VoidResult {
+  ddog_VoidResult_Tag tag;
+  union {
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_VoidResult;
+
 typedef struct ddog_HttpStatus {
   uint16_t code;
 } ddog_HttpStatus;
@@ -561,24 +579,6 @@ typedef struct ddog_prof_Result_HandleExporterManager {
   };
 } ddog_prof_Result_HandleExporterManager;
 
-/**
- * A generic result type for when an operation may fail,
- * but there's nothing to return in the case of success.
- */
-typedef enum ddog_VoidResult_Tag {
-  DDOG_VOID_RESULT_OK,
-  DDOG_VOID_RESULT_ERR,
-} ddog_VoidResult_Tag;
-
-typedef struct ddog_VoidResult {
-  ddog_VoidResult_Tag tag;
-  union {
-    struct {
-      struct ddog_Error err;
-    };
-  };
-} ddog_VoidResult;
-
 /**
  * Represents the result of an operation that either succeeds with no value, or fails with an
  * error message. This is like `Result<(), Cow<'static, CStr>` except its representation is
@@ -901,6 +901,10 @@ typedef struct ddog_prof_StringHeader {
  * 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;
 
@@ -934,6 +938,10 @@ 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.
+ *
+ * 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_Function2 {
   ddog_prof_StringId2 name;
@@ -1564,6 +1572,9 @@ typedef enum ddog_TelemetryWorkerBuilderStrProperty {
   DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_HOST_KERNEL_RELEASE,
   DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_HOST_KERNEL_VERSION,
   DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_RUNTIME_ID,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_SESSION_ID,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_PARENT_SESSION_ID,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_ROOT_SESSION_ID,
 } ddog_TelemetryWorkerBuilderStrProperty;
 
 typedef struct ddog_TelemetryWorkerBuilder ddog_TelemetryWorkerBuilder;
@@ -1612,6 +1623,11 @@ typedef struct ddog_ContextKey {
   enum ddog_MetricType _1;
 } ddog_ContextKey;
 
+typedef struct ddog_TraceExporter ddog_TraceExporter;
+typedef struct ddog_TracerSpan ddog_TracerSpan;
+typedef struct ddog_TracerTraceChunks ddog_TracerTraceChunks;
+
+
 /**
  * Represent error codes that `Error` struct can hold
  */
@@ -1652,7 +1668,21 @@ typedef enum ddog_TraceExporterErrorCode {
  */
 typedef struct ddog_TraceExporterResponse ddog_TraceExporterResponse;
 
-typedef struct ddog_TraceExporter ddog_TraceExporter;
+/**
+ * A shared runtime that manages PausableWorkers and provides fork safety hooks.
+ *
+ * The SharedRuntime owns a tokio runtime (on native) and tracks PausableWorkers
+ * spawned on it. It provides methods to safely pause workers before forking and
+ * restart them after fork in both parent and child processes.
+ *
+ * On wasm32, no tokio runtime is created. Workers are spawned via `spawn_local`
+ * on the JS event loop.
+ *
+ * # Mutex lock order
+ * When locking both [Self::runtime] and [Self::workers], the mutex must be locked in the order of
+ * the fields in the struct. When possible avoid holding both locks simultaneously.
+ */
+typedef struct ddog_SharedRuntime ddog_SharedRuntime;
 
 /**
  * The TraceExporterConfig object will hold the configuration properties for the TraceExporter.
@@ -1691,8 +1721,40 @@ typedef struct ddog_TelemetryClientConfig {
    * Defaults to false.
    */
   bool debug_enabled;
+  /**
+   * HTTP header `dd-session-id` (empty = omitted).
+   */
+  ddog_CharSlice session_id;
+  /**
+   * HTTP header `dd-root-session-id` (empty = omitted).
+   */
+  ddog_CharSlice root_session_id;
+  /**
+   * HTTP header `dd-parent-session-id` (empty = omitted).
+   */
+  ddog_CharSlice parent_session_id;
 } ddog_TelemetryClientConfig;
 
+/**
+ * FFI-safe bundle of scalar fields for creating a [`TracerSpan`].
+ *
+ * Passed by reference to [`ddog_tracer_span_new`] so that adding or
+ * changing fields does not break the function signature.
+ */
+typedef struct ddog_TracerSpanFields {
+  ddog_CharSlice service;
+  ddog_CharSlice name;
+  ddog_CharSlice resource;
+  ddog_CharSlice span_type;
+  uint64_t trace_id_low;
+  uint64_t trace_id_high;
+  uint64_t span_id;
+  uint64_t parent_id;
+  int64_t start;
+  int64_t duration;
+  int32_t error;
+} ddog_TracerSpanFields;
+
 typedef enum ddog_LibraryConfigSource {
   DDOG_LIBRARY_CONFIG_SOURCE_LOCAL_STABLE_CONFIG = 0,
   DDOG_LIBRARY_CONFIG_SOURCE_FLEET_STABLE_CONFIG = 1,
@@ -2089,6 +2151,20 @@ typedef struct ddog_ffe_VariantValue {
   };
 } ddog_ffe_VariantValue;
 
+typedef enum ddog_Option_I32_Tag {
+  DDOG_OPTION_I32_SOME_I32,
+  DDOG_OPTION_I32_NONE_I32,
+} ddog_Option_I32_Tag;
+
+typedef struct ddog_Option_I32 {
+  ddog_Option_I32_Tag tag;
+  union {
+    struct {
+      int32_t some;
+    };
+  };
+} ddog_Option_I32;
+
 typedef struct ddog_ffe_KeyValue_BorrowedStr {
   struct ddog_ffe_BorrowedStr key;
   struct ddog_ffe_BorrowedStr value;
@@ -2349,6 +2425,11 @@ typedef struct ddog_crasht_Slice_I32 {
 
 typedef struct ddog_crasht_Config {
   struct ddog_crasht_Slice_CharSlice additional_files;
+  /**
+   * If true, the receiver will collect stack traces for all threads in the crashing process
+   * (not just the crashing thread) using ptrace-based remote unwinding.
+   */
+  bool collect_all_threads;
   bool create_alt_stack;
   bool demangle_names;
   /**
@@ -2356,6 +2437,11 @@ typedef struct ddog_crasht_Config {
    * If None, the crashtracker will infer the agent host from env variables.
    */
   struct ddog_crasht_EndpointConfig endpoint;
+  /**
+   * Maximum number of non-crashing threads to collect when `collect_all_threads` is true.
+   * If 0, uses the default (`libdd_crashtracker::default_max_threads()`).
+   */
+  uintptr_t max_threads;
   /**
    * Optional filename for a unix domain socket if the receiver is used asynchonously
    */

data/vendor/{libdatadog-30.0.0/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl → libdatadog-35.0.0/x86_64-linux-musl}/include/datadog/data-pipeline.h

@@ -10,7 +10,6 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include "common.h"
-
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
@@ -22,11 +21,11 @@ extern "C" {
 void ddog_trace_exporter_error_free(struct ddog_TraceExporterError *error);
 
 /**
- * Return a read-only pointer to the response body. This pointer is only valid as long as
- * `response` is valid.
+ * 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.
  */
-const uint8_t *ddog_trace_exporter_response_get_body(const struct ddog_TraceExporterResponse *response,
-                                                     uintptr_t *out_len);
+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
@@ -145,6 +144,20 @@ struct ddog_TraceExporterError *ddog_trace_exporter_config_set_test_session_toke
 struct ddog_TraceExporterError *ddog_trace_exporter_config_set_connection_timeout(struct ddog_TraceExporterConfig *config,
                                                                                   uint64_t timeout_ms);
 
+/**
+ * Sets a shared runtime for the TraceExporter to use for background workers.
+ *
+ * `handle` must have been initialized with [`ddog_shared_runtime_new`].
+ *
+ * When set, the exporter will use the provided runtime instead of creating its own.
+ * This allows multiple exporters (or other components) to share a single runtime.
+ * The config holds a clone of the `Arc` (increments the strong count), so the
+ * original handle remains valid and must still be freed with
+ * [`ddog_shared_runtime_free`].
+ */
+struct ddog_TraceExporterError *ddog_trace_exporter_config_set_shared_runtime(struct ddog_TraceExporterConfig *config,
+                                                                              struct ddog_SharedRuntime *handle);
+
 /**
  * Enables OTLP HTTP/JSON export and sets the endpoint URL.
  *
@@ -168,7 +181,7 @@ struct ddog_TraceExporterError *ddog_trace_exporter_config_set_otlp_endpoint(str
  * * `out_handle` - The handle to write the TraceExporter instance in.
  * * `config` - The configuration used to set up the TraceExporter handle.
  */
-struct ddog_TraceExporterError *ddog_trace_exporter_new(struct ddog_TraceExporter **out_handle,
+struct ddog_TraceExporterError *ddog_trace_exporter_new(ddog_TraceExporter **out_handle,
                                                         const struct ddog_TraceExporterConfig *config);
 
 /**
@@ -178,7 +191,7 @@ struct ddog_TraceExporterError *ddog_trace_exporter_new(struct ddog_TraceExporte
  *
  * * handle - The handle to the TraceExporter instance.
  */
-void ddog_trace_exporter_free(struct ddog_TraceExporter *handle);
+void ddog_trace_exporter_free(ddog_TraceExporter *handle);
 
 /**
  * Send traces to the Datadog Agent.
@@ -192,10 +205,143 @@ void ddog_trace_exporter_free(struct ddog_TraceExporter *handle);
  * * `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 struct ddog_TraceExporter *handle,
+struct ddog_TraceExporterError *ddog_trace_exporter_send(const ddog_TraceExporter *handle,
                                                          ddog_ByteSlice trace,
                                                          struct ddog_TraceExporterResponse **response_out);
 
+/**
+ * Create a new span with all scalar fields set.
+ *
+ * String fields are copied from the provided slices.  The `meta` and
+ * `metrics` maps start empty; use [`ddog_tracer_span_set_meta`] and
+ * [`ddog_tracer_span_set_metric`] to populate them.
+ *
+ * # Safety
+ *
+ * `out_handle` must point to valid, writable memory for a `Box<TracerSpan>`.
+ * All `CharSlice` fields in `fields` must point to valid memory for their
+ * stated length.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_new(ddog_TracerSpan **out_handle,
+                                                     const struct ddog_TracerSpanFields *fields);
+
+/**
+ * Free a `TracerSpan` and all its contents.
+ *
+ * After this call the handle is invalid and must not be reused.
+ *
+ * # Safety
+ *
+ * `handle` must have been created by [`ddog_tracer_span_new`] and must not
+ * be used after this call.
+ */
+void ddog_tracer_span_free(ddog_TracerSpan *handle);
+
+/**
+ * Add or overwrite a string tag (`meta`) on the span.
+ *
+ * Both `key` and `value` are copied into the span.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid pointer to a `TracerSpan`.
+ * `key` and `value` must point to valid UTF-8 memory.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_set_meta(ddog_TracerSpan *handle,
+                                                          ddog_CharSlice key,
+                                                          ddog_CharSlice value);
+
+/**
+ * Add or overwrite a numeric tag (`metric`) on the span.
+ *
+ * The `key` is copied into the span.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid pointer to a `TracerSpan`.
+ * `key` must point to valid UTF-8 memory.
+ */
+struct ddog_TraceExporterError *ddog_tracer_span_set_metric(ddog_TracerSpan *handle,
+                                                            ddog_CharSlice key,
+                                                            double value);
+
+/**
+ * Create a new empty trace chunks container.
+ *
+ * `capacity` is a hint for the expected number of chunks; pass 0 if
+ * unknown.
+ *
+ * # Safety
+ *
+ * `out_handle` must point to valid, writable memory for a
+ * `Box<TracerTraceChunks>`.
+ */
+struct ddog_TraceExporterError *ddog_tracer_trace_chunks_new(uintptr_t capacity,
+                                                             ddog_TracerTraceChunks **out_handle);
+
+/**
+ * Free a trace chunks container and all its contents.
+ *
+ * After this call the handle is invalid and must not be reused.
+ *
+ * # Safety
+ *
+ * `handle` must have been created by [`ddog_tracer_trace_chunks_new`].
+ */
+void ddog_tracer_trace_chunks_free(ddog_TracerTraceChunks *handle);
+
+/**
+ * Start a new chunk (trace) inside the container.
+ *
+ * Subsequent [`ddog_tracer_trace_chunks_push_span`] calls will append
+ * spans to this chunk until the next `begin_chunk` call.
+ *
+ * `capacity` is a hint for the expected number of spans in this chunk;
+ * pass 0 if unknown.
+ *
+ * # Safety
+ *
+ * `handle` must be a valid pointer to a `TracerTraceChunks`.
+ */
+struct ddog_TraceExporterError *ddog_tracer_trace_chunks_begin_chunk(ddog_TracerTraceChunks *handle,
+                                                                     uintptr_t capacity);
+
+/**
+ * Move a span into the current (last) chunk, consuming the span handle.
+ *
+ * A chunk must have been started with
+ * [`ddog_tracer_trace_chunks_begin_chunk`] before calling this function.
+ *
+ * # Safety
+ *
+ * * `handle` must be a valid pointer to a `TracerTraceChunks`.
+ * * `span` is consumed and must not be used after this call.
+ */
+struct ddog_TraceExporterError *ddog_tracer_trace_chunks_push_span(ddog_TracerTraceChunks *handle,
+                                                                   ddog_TracerSpan *span);
+
+/**
+ * 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.
+ *
+ * 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
+ *
+ * * `exporter` must be a valid `TraceExporter` pointer.
+ * * `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);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus

data/vendor/{libdatadog-30.0.0/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl → libdatadog-35.0.0/x86_64-linux-musl}/include/datadog/ffe.h

@@ -94,22 +94,26 @@ enum ddog_ffe_ErrorCode ddog_ffe_assignment_get_error_code(ddog_ffe_Handle_Resol
 struct ddog_ffe_BorrowedStr ddog_ffe_assignment_get_error_message(ddog_ffe_Handle_ResolutionDetails assignment);
 
 /**
+ * Get the serial_id produced by evaluation.
+ *
+ * Returns `None` if the assignment has no serial_id or evaluation did not produce any value.
+ *
  * # Safety
  * `assignment` must be a valid handle.
  */
-bool ddog_ffe_assignment_get_do_log(ddog_ffe_Handle_ResolutionDetails assignment);
+struct ddog_Option_I32 ddog_ffe_assignment_get_serial_id(ddog_ffe_Handle_ResolutionDetails assignment);
 
 /**
  * # Safety
  * `assignment` must be a valid handle.
  */
-struct ddog_ffe_ArrayMap_BorrowedStr ddog_ffe_assignnment_get_flag_metadata(ddog_ffe_Handle_ResolutionDetails assignment);
+bool ddog_ffe_assignment_get_do_log(ddog_ffe_Handle_ResolutionDetails assignment);
 
 /**
  * # Safety
  * `assignment` must be a valid handle.
  */
-struct ddog_ffe_ArrayMap_BorrowedStr ddog_ffe_assignnment_get_extra_logging(ddog_ffe_Handle_ResolutionDetails assignment);
+struct ddog_ffe_ArrayMap_BorrowedStr ddog_ffe_assignnment_get_flag_metadata(ddog_ffe_Handle_ResolutionDetails assignment);
 
 /**
  * Frees an Assignment handle.

data/vendor/{libdatadog-30.0.0/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl → libdatadog-35.0.0/x86_64-linux-musl}/include/datadog/profiling.h

@@ -140,9 +140,32 @@ struct ddog_prof_ProfileExporter_Result ddog_prof_Exporter_new(ddog_CharSlice pr
  */
 void ddog_prof_Exporter_drop(struct ddog_prof_ProfileExporter *exporter);
 
+/**
+ * Initializes the tokio runtime for the exporter.
+ *
+ * This function creates the tokio runtime used by `ddog_prof_Exporter_send_blocking`.
+ * It can be called ahead of time to ensure the runtime is ready before sending.
+ *
+ * # Thread Affinity
+ *
+ * **Important**: The runtime has thread affinity. This function should be called from
+ * the same thread that will later call `ddog_prof_Exporter_send_blocking`.
+ *
+ * # Arguments
+ * * `exporter` - Borrows the exporter.
+ *
+ * # Safety
+ * The `exporter` must point to a valid ProfileExporter that has not been dropped.
+ */
+DDOG_CHECK_RETURN
+struct ddog_VoidResult ddog_prof_Exporter_init_runtime(struct ddog_prof_ProfileExporter *exporter);
+
 /**
  * Builds a request and sends it, returning the HttpStatus.
  *
+ * Note: If the runtime has not been initialized via `ddog_prof_Exporter_init_runtime`,
+ * it will be lazily initialized on first call.
+ *
  * # Arguments
  * * `exporter` - Borrows the exporter.
  * * `profile` - Takes ownership of the profile.
@@ -1010,6 +1033,19 @@ struct ddog_prof_Status ddog_prof_ProfilesDictionary_get_str(ddog_CharSlice *res
                                                              const struct ddog_prof_ProfilesDictionary *dict,
                                                              ddog_prof_StringId2 string_id);
 
+/**
+ * Tries to get the function value associated with the function id.
+ *
+ * # Safety
+ *
+ *  1. The `function_id` should belong to this dictionary.
+ *  2. The dictionary must be live for the duration of the call.
+ *  3. The result pointer must be valid for [`core::ptr::write`].
+ */
+struct ddog_prof_Status ddog_prof_ProfilesDictionary_get_func(struct ddog_prof_Function2 *result,
+                                                              const struct ddog_prof_ProfilesDictionary *dict,
+                                                              ddog_prof_FunctionId2 function_id);
+
 /**
  * Drops the `ProfilesDictionary` that the handle owns, leaving a valid but
  * useless handle (all operations on it will error). This takes a pointer to

data/vendor/{libdatadog-30.0.0/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu → libdatadog-35.0.0/x86_64-linux-musl}/include/datadog/telemetry.h

@@ -123,6 +123,15 @@ ddog_MaybeError ddog_telemetry_builder_with_str_host_kernel_version(struct ddog_
 ddog_MaybeError ddog_telemetry_builder_with_str_runtime_id(struct ddog_TelemetryWorkerBuilder *telemetry_builder,
                                                            ddog_CharSlice param);
 
+ddog_MaybeError ddog_telemetry_builder_with_str_session_id(struct ddog_TelemetryWorkerBuilder *telemetry_builder,
+                                                           ddog_CharSlice param);
+
+ddog_MaybeError ddog_telemetry_builder_with_str_parent_session_id(struct ddog_TelemetryWorkerBuilder *telemetry_builder,
+                                                                  ddog_CharSlice param);
+
+ddog_MaybeError ddog_telemetry_builder_with_str_root_session_id(struct ddog_TelemetryWorkerBuilder *telemetry_builder,
+                                                                ddog_CharSlice param);
+
 /**
  *      Sets a property from it's string value.
  *
@@ -150,6 +159,12 @@ ddog_MaybeError ddog_telemetry_builder_with_str_runtime_id(struct ddog_Telemetry
  *
  *     * runtime_id
  *
+ *     * session_id
+ *
+ *     * parent_session_id
+ *
+ *     * root_session_id
+ *
  *
  */
 ddog_MaybeError ddog_telemetry_builder_with_property_str(struct ddog_TelemetryWorkerBuilder *telemetry_builder,
@@ -183,6 +198,12 @@ ddog_MaybeError ddog_telemetry_builder_with_property_str(struct ddog_TelemetryWo
  *
  *     * runtime_id
  *
+ *     * session_id
+ *
+ *     * parent_session_id
+ *
+ *     * root_session_id
+ *
  *
  */
 ddog_MaybeError ddog_telemetry_builder_with_str_named_property(struct ddog_TelemetryWorkerBuilder *telemetry_builder,

data/vendor/{libdatadog-30.0.0/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl → libdatadog-35.0.0/x86_64-linux-musl}/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: 30.0.0
+Version: 35.0.0
 Requires:
 Libs: -L${libdir} -ldatadog_profiling -Wl,-rpath,${libdir}
 Libs.private: