libdatadog 30.0.0.1.0 → 33.0.0.1.0

data/vendor/{libdatadog-30.0.0/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl → libdatadog-33.0.0/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu}/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,9 @@ typedef struct ddog_ContextKey {
   enum ddog_MetricType _1;
 } ddog_ContextKey;
 
+typedef struct ddog_TraceExporter ddog_TraceExporter;
+
+
 /**
  * Represent error codes that `Error` struct can hold
  */
@@ -1652,7 +1666,18 @@ 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 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.
+ *
+ * # 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,6 +1716,18 @@ 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;
 
 typedef enum ddog_LibraryConfigSource {
@@ -2089,6 +2126,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 +2400,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 +2412,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/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl → libdatadog-33.0.0/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu}/include/datadog/data-pipeline.h

@@ -10,7 +10,6 @@
 #include <stdint.h>
 #include <stdlib.h>
 #include "common.h"
-
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
@@ -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,7 +205,7 @@ 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);
 

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