libdatadog 29.0.0.1.0 → 33.0.0.1.0

data/vendor/{libdatadog-29.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

@@ -39,6 +39,12 @@
 #  define DDOG_CHECK_RETURN
 #endif
 
+#ifdef _WIN32
+#define LIBDD_DLLIMPORT __declspec(dllimport)
+#else
+#define LIBDD_DLLIMPORT
+#endif
+
 /**
  * Default value for the timeout field in milliseconds.
  */
@@ -483,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;
@@ -555,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
@@ -895,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;
 
@@ -928,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;
@@ -1418,6 +1432,20 @@ typedef struct ddog_prof_Result_Generation {
   };
 } ddog_prof_Result_Generation;
 
+typedef struct ddog_prof_MutSlice_StringId2 {
+  /**
+   * 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.
+   */
+  ddog_prof_StringId2 *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_prof_MutSlice_StringId2;
+
 typedef enum ddog_prof_ManagedStringStorageNewResult_Tag {
   DDOG_PROF_MANAGED_STRING_STORAGE_NEW_RESULT_OK,
   DDOG_PROF_MANAGED_STRING_STORAGE_NEW_RESULT_ERR,
@@ -1544,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;
@@ -1592,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
  */
@@ -1632,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.
@@ -1671,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 {
@@ -2069,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;
@@ -2305,6 +2376,14 @@ typedef struct ddog_crasht_Slice_CharSlice {
   uintptr_t len;
 } ddog_crasht_Slice_CharSlice;
 
+typedef struct ddog_crasht_EndpointConfig {
+  ddog_CharSlice url;
+  ddog_CharSlice api_key;
+  ddog_CharSlice test_token;
+  uint64_t timeout;
+  bool use_system_resolver;
+} ddog_crasht_EndpointConfig;
+
 typedef struct ddog_crasht_Slice_I32 {
   /**
    * Should be non-null and suitably aligned for the underlying type. It is
@@ -2321,13 +2400,23 @@ 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;
   /**
    * The endpoint to send the crash report to (can be a file://).
    * If None, the crashtracker will infer the agent host from env variables.
    */
-  const struct ddog_Endpoint *endpoint;
+  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-29.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,15 +144,44 @@ 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.
+ *
+ * When set, traces are sent to this URL in OTLP HTTP/JSON format 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_config_set_otlp_endpoint(struct ddog_TraceExporterConfig *config,
+                                                                             ddog_CharSlice url);
+
 /**
  * Create a new TraceExporter instance.
  *
+ * When an OTLP endpoint is configured via `TraceExporterConfig`, the exporter sends traces in
+ * OTLP HTTP/JSON to that endpoint instead of the Datadog agent. The same payload (e.g.
+ * MessagePack) is passed to `ddog_trace_exporter_send`; the library decodes and converts 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.
  */
-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);
 
 /**
@@ -163,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.
@@ -177,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-29.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-29.0.0 → libdatadog-33.0.0}/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu/include/datadog/profiling.h

@@ -19,42 +19,56 @@ struct TokioCancellationToken;
 extern "C" {
 #endif // __cplusplus
 
-extern const ddog_prof_StringId ddog_INTERNED_EMPTY_STRING;
+extern LIBDD_DLLIMPORT const ddog_prof_StringId ddog_INTERNED_EMPTY_STRING;
 
 /**
  * A StringId that represents the empty string.
  * This is always available in every string set and can be used without
  * needing to insert it into a string set.
  */
-extern const ddog_prof_StringId2 DDOG_PROF_STRINGID2_EMPTY;
+extern LIBDD_DLLIMPORT const ddog_prof_StringId2 DDOG_PROF_STRINGID2_EMPTY;
 
 /**
  * A StringId that represents the string "end_timestamp_ns".
  * This is always available in every string set and can be used without
  * needing to insert it into a string set.
  */
-extern const ddog_prof_StringId2 DDOG_PROF_STRINGID2_END_TIMESTAMP_NS;
+extern LIBDD_DLLIMPORT const ddog_prof_StringId2 DDOG_PROF_STRINGID2_END_TIMESTAMP_NS;
 
 /**
  * A StringId that represents the string "local root span id".
  * This is always available in every string set and can be used without
  * needing to insert it into a string set.
  */
-extern const ddog_prof_StringId2 DDOG_PROF_STRINGID2_LOCAL_ROOT_SPAN_ID;
+extern LIBDD_DLLIMPORT const ddog_prof_StringId2 DDOG_PROF_STRINGID2_LOCAL_ROOT_SPAN_ID;
 
 /**
  * A StringId that represents the string "trace endpoint".
  * This is always available in every string set and can be used without
  * needing to insert it into a string set.
  */
-extern const ddog_prof_StringId2 DDOG_PROF_STRINGID2_TRACE_ENDPOINT;
+extern LIBDD_DLLIMPORT const ddog_prof_StringId2 DDOG_PROF_STRINGID2_TRACE_ENDPOINT;
 
 /**
  * A StringId that represents the string "span id".
  * This is always available in every string set and can be used without
  * needing to insert it into a string set.
  */
-extern const ddog_prof_StringId2 DDOG_PROF_STRINGID2_SPAN_ID;
+extern LIBDD_DLLIMPORT const ddog_prof_StringId2 DDOG_PROF_STRINGID2_SPAN_ID;
+
+/**
+ * A StringId that represents the string "thread id".
+ * This is always available in every string set and can be used without
+ * needing to insert it into a string set.
+ */
+extern LIBDD_DLLIMPORT const ddog_prof_StringId2 DDOG_PROF_STRINGID2_THREAD_ID;
+
+/**
+ * A StringId that represents the string "thread name".
+ * This is always available in every string set and can be used without
+ * needing to insert it into a string set.
+ */
+extern LIBDD_DLLIMPORT const ddog_prof_StringId2 DDOG_PROF_STRINGID2_THREAD_NAME;
 
 DDOG_CHECK_RETURN struct ddog_prof_Exporter_Slice_File ddog_prof_Exporter_Slice_File_empty(void);
 
@@ -126,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.
@@ -954,6 +991,29 @@ struct ddog_prof_Status ddog_prof_ProfilesDictionary_insert_str(ddog_prof_String
                                                                 ddog_CharSlice byte_slice,
                                                                 enum ddog_prof_Utf8Option utf8_option);
 
+/**
+ * Inserts a batch of UTF-8 strings into the dictionary string table.
+ *
+ * On success, each element of `string_ids` corresponds to the same-index element of
+ * `strings`. The length of `string_ids` must equal the length of `strings`; a
+ * mismatch is an error.
+ *
+ * On failure the number of entries written to `string_ids` is unspecified; callers
+ * must not read any element of `string_ids`.
+ *
+ * # Safety
+ *
+ * - `dict` must refer to a live dictionary.
+ * - `strings` must be a valid slice for the duration of the call.
+ * - `string_ids` must be a valid writable slice of `StringId2` with the same length as `strings`.
+ * - The UTF-8 policy indicated by `utf8_option` must be respected by the caller for every string
+ *   in `strings`.
+ */
+struct ddog_prof_Status ddog_prof_ProfilesDictionary_insert_strs(struct ddog_prof_MutSlice_StringId2 string_ids,
+                                                                 const struct ddog_prof_ProfilesDictionary *dict,
+                                                                 struct ddog_prof_Slice_CharSlice strings,
+                                                                 enum ddog_prof_Utf8Option utf8_option);
+
 /**
  * Tries to get the string value associated with the string id. Fails if the
  * handle has been taken from, or the result param is null.
@@ -973,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-29.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-29.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: 29.0.0
+Version: 33.0.0
 Requires:
 Libs: -L${libdir} -ldatadog_profiling -Wl,-rpath,${libdir}
 Libs.private: