libdatadog 26.0.0.1.0-aarch64-linux → 28.0.0.1.0-aarch64-linux

data/vendor/{libdatadog-26.0.0 → libdatadog-28.0.0}/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu/include/datadog/common.h

@@ -263,6 +263,92 @@ typedef struct ddog_prof_Function2 *ddog_prof_FunctionId2;
 
 #define ddog_prof_Set_SIZE_HINT (1024 * 1024)
 
+/**
+ * Sample types supported by Datadog's profilers.
+ *
+ * Variants are sourced from:
+ * - **dd-trace-rb**: `stack_recorder.c` (`all_value_types`)
+ * - **dd-trace-py**: `dd_wrapper/include/types.hpp`
+ * - **dd-trace-php**: `profiling/src/profiling/samples.rs` (I/O profiling)
+ * - **dd-trace-dotnet**: Sample type definitions for allocations, locks, CPU, walltime,
+ *   exceptions, live objects, HTTP requests
+ * - **pprof-nodejs**: `profile-serializer.ts` (value type functions)
+ */
+typedef enum ddog_prof_SampleType {
+  DDOG_PROF_SAMPLE_TYPE_ALLOC_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_ALLOC_SAMPLES_UNSCALED,
+  DDOG_PROF_SAMPLE_TYPE_ALLOC_SIZE,
+  DDOG_PROF_SAMPLE_TYPE_ALLOC_SPACE,
+  DDOG_PROF_SAMPLE_TYPE_CPU_TIME,
+  DDOG_PROF_SAMPLE_TYPE_CPU_SAMPLES,
+  /**
+   * Legacy: Use `CpuTime` instead for consistency with naming scheme
+   */
+  DDOG_PROF_SAMPLE_TYPE_CPU_LEGACY,
+  /**
+   * Legacy: Use `CpuSamples` instead for consistency with naming scheme
+   */
+  DDOG_PROF_SAMPLE_TYPE_CPU_SAMPLE_LEGACY,
+  DDOG_PROF_SAMPLE_TYPE_EXCEPTION_SAMPLES,
+  /**
+   * Legacy: Use `ExceptionSamples` instead for consistency with naming scheme
+   */
+  DDOG_PROF_SAMPLE_TYPE_EXCEPTION_LEGACY,
+  DDOG_PROF_SAMPLE_TYPE_FILE_IO_READ_SIZE,
+  DDOG_PROF_SAMPLE_TYPE_FILE_IO_READ_SIZE_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_FILE_IO_READ_TIME,
+  DDOG_PROF_SAMPLE_TYPE_FILE_IO_READ_TIME_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_FILE_IO_WRITE_SIZE,
+  DDOG_PROF_SAMPLE_TYPE_FILE_IO_WRITE_SIZE_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_FILE_IO_WRITE_TIME,
+  DDOG_PROF_SAMPLE_TYPE_FILE_IO_WRITE_TIME_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_GPU_ALLOC_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_GPU_FLOPS,
+  DDOG_PROF_SAMPLE_TYPE_GPU_FLOPS_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_GPU_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_GPU_SPACE,
+  DDOG_PROF_SAMPLE_TYPE_GPU_TIME,
+  DDOG_PROF_SAMPLE_TYPE_HEAP_LIVE_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_HEAP_LIVE_SIZE,
+  DDOG_PROF_SAMPLE_TYPE_HEAP_SPACE,
+  DDOG_PROF_SAMPLE_TYPE_INUSE_OBJECTS,
+  DDOG_PROF_SAMPLE_TYPE_INUSE_SPACE,
+  DDOG_PROF_SAMPLE_TYPE_LOCK_ACQUIRE,
+  DDOG_PROF_SAMPLE_TYPE_LOCK_ACQUIRE_WAIT,
+  DDOG_PROF_SAMPLE_TYPE_LOCK_COUNT,
+  DDOG_PROF_SAMPLE_TYPE_LOCK_RELEASE,
+  DDOG_PROF_SAMPLE_TYPE_LOCK_RELEASE_HOLD,
+  DDOG_PROF_SAMPLE_TYPE_LOCK_TIME,
+  /**
+   * Legacy: Use `InuseObjects` instead for consistency with naming scheme
+   */
+  DDOG_PROF_SAMPLE_TYPE_OBJECTS_LEGACY,
+  DDOG_PROF_SAMPLE_TYPE_REQUEST_TIME,
+  DDOG_PROF_SAMPLE_TYPE_SAMPLE,
+  DDOG_PROF_SAMPLE_TYPE_SOCKET_READ_SIZE,
+  DDOG_PROF_SAMPLE_TYPE_SOCKET_READ_SIZE_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_SOCKET_READ_TIME,
+  DDOG_PROF_SAMPLE_TYPE_SOCKET_READ_TIME_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_SOCKET_WRITE_SIZE,
+  DDOG_PROF_SAMPLE_TYPE_SOCKET_WRITE_SIZE_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_SOCKET_WRITE_TIME,
+  DDOG_PROF_SAMPLE_TYPE_SOCKET_WRITE_TIME_SAMPLES,
+  /**
+   * Legacy: Use specific space variants (`InuseSpace`, `HeapSpace`, `AllocSpace`) instead
+   */
+  DDOG_PROF_SAMPLE_TYPE_SPACE_LEGACY,
+  DDOG_PROF_SAMPLE_TYPE_TIMELINE,
+  DDOG_PROF_SAMPLE_TYPE_WALL_SAMPLES,
+  DDOG_PROF_SAMPLE_TYPE_WALL_TIME,
+  /**
+   * 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,
+} ddog_prof_SampleType;
+
 typedef enum ddog_prof_Utf8Option {
   /**
    * The string is assumed to be valid UTF-8. If it's not, the behavior
@@ -284,6 +370,8 @@ 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;
 
 /**
@@ -344,12 +432,14 @@ typedef enum ddog_prof_Endpoint_Tag {
 typedef struct ddog_prof_Endpoint_ddog_prof_Agent_Body {
   ddog_CharSlice _0;
   uint64_t _1;
+  bool _2;
 } ddog_prof_Endpoint_ddog_prof_Agent_Body;
 
 typedef struct ddog_prof_Endpoint_ddog_prof_Agentless_Body {
   ddog_CharSlice _0;
   ddog_CharSlice _1;
   uint64_t _2;
+  bool _3;
 } ddog_prof_Endpoint_ddog_prof_Agentless_Body;
 
 typedef struct ddog_prof_Endpoint {
@@ -435,6 +525,53 @@ typedef struct ddog_CancellationToken {
   ddog_prof_TokioCancellationToken *inner;
 } ddog_CancellationToken;
 
+/**
+ * Represents an object that should only be referred to by its handle.
+ * Do not access its member for any reason, only use the C API functions on this struct.
+ */
+typedef struct ddog_prof_Handle_ExporterManager {
+  struct ddog_prof_ExporterManager *inner;
+} ddog_prof_Handle_ExporterManager;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_Result_HandleExporterManager_Tag {
+  DDOG_PROF_RESULT_HANDLE_EXPORTER_MANAGER_OK_HANDLE_EXPORTER_MANAGER,
+  DDOG_PROF_RESULT_HANDLE_EXPORTER_MANAGER_ERR_HANDLE_EXPORTER_MANAGER,
+} ddog_prof_Result_HandleExporterManager_Tag;
+
+typedef struct ddog_prof_Result_HandleExporterManager {
+  ddog_prof_Result_HandleExporterManager_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_Handle_ExporterManager ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} 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
@@ -516,27 +653,22 @@ typedef struct ddog_prof_Profile_NewResult {
   };
 } ddog_prof_Profile_NewResult;
 
-typedef struct ddog_prof_ValueType {
-  ddog_CharSlice type_;
-  ddog_CharSlice unit;
-} ddog_prof_ValueType;
-
-typedef struct ddog_prof_Slice_ValueType {
+typedef struct ddog_prof_Slice_SampleType {
   /**
    * 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_prof_ValueType *ptr;
+  const enum ddog_prof_SampleType *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_Slice_ValueType;
+} ddog_prof_Slice_SampleType;
 
 typedef struct ddog_prof_Period {
-  struct ddog_prof_ValueType type_;
+  enum ddog_prof_SampleType sample_type;
   int64_t value;
 } ddog_prof_Period;
 
@@ -786,6 +918,9 @@ typedef struct ddog_prof_Mapping2 {
  * 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;
 
@@ -808,9 +943,18 @@ typedef struct ddog_prof_Function2 {
  * 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.
+ *
+ * `Eq`/`Hash` comparisons use those handle values, so they are intended for
+ * data that comes from the same `ProfilesDictionary`.
+ */
 typedef struct ddog_prof_Location2 {
   ddog_prof_MappingId2 mapping;
   ddog_prof_FunctionId2 function;
@@ -1145,24 +1289,6 @@ typedef struct ddog_prof_StringId_Result {
   };
 } ddog_prof_StringId_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_prof_Slice_ManagedStringId {
   /**
    * Should be non-null and suitably aligned for the underlying type. It is
@@ -2283,6 +2409,14 @@ typedef struct ddog_crasht_Slice_CInt {
   uintptr_t len;
 } ddog_crasht_Slice_CInt;
 
+/**
+ * Represents an object that should only be referred to by its handle.
+ * Do not access its member for any reason, only use the C API functions on this struct.
+ */
+typedef struct ddog_crasht_Handle_StackTrace {
+  struct ddog_crasht_StackTrace *inner;
+} ddog_crasht_Handle_StackTrace;
+
 /**
  * A generic result type for when an operation may fail,
  * or may return <T> in case of success.
@@ -2369,6 +2503,10 @@ typedef struct ddog_crasht_OsInfo {
 
 typedef struct ddog_crasht_ProcInfo {
   uint32_t pid;
+  /**
+   * Optional crashing thread id; 0 means unset.
+   */
+  uint32_t tid;
 } ddog_crasht_ProcInfo;
 
 typedef struct ddog_crasht_SigInfo {
@@ -2384,14 +2522,6 @@ typedef struct ddog_crasht_Span {
   ddog_CharSlice thread_name;
 } ddog_crasht_Span;
 
-/**
- * Represents an object that should only be referred to by its handle.
- * Do not access its member for any reason, only use the C API functions on this struct.
- */
-typedef struct ddog_crasht_Handle_StackTrace {
-  struct ddog_crasht_StackTrace *inner;
-} ddog_crasht_Handle_StackTrace;
-
 typedef struct ddog_crasht_ThreadData {
   bool crashed;
   ddog_CharSlice name;
@@ -2591,6 +2721,13 @@ void ddog_endpoint_set_timeout(struct ddog_Endpoint *endpoint, uint64_t millis);
 
 void ddog_endpoint_set_test_token(struct ddog_Endpoint *endpoint, ddog_CharSlice token);
 
+/**
+ * Set whether to use the system DNS resolver when building the reqwest client.
+ * If false, the default in-process resolver is used.
+ */
+void ddog_endpoint_set_use_system_resolver(struct ddog_Endpoint *endpoint,
+                                           bool use_system_resolver);
+
 void ddog_endpoint_drop(struct ddog_Endpoint*);
 
 struct ddog_Option_U32 ddog_Option_U32_some(uint32_t v);

data/vendor/{libdatadog-26.0.0/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl → libdatadog-28.0.0/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu}/include/datadog/crashtracker.h

@@ -131,6 +131,45 @@ struct ddog_VoidResult ddog_crasht_init_without_receiver(struct ddog_crasht_Conf
  */
 struct ddog_crasht_Slice_CInt ddog_crasht_default_signals(void);
 
+/**
+ * Report an unhandled exception as a crash event.
+ *
+ * This function sends a crash report for an unhandled exception detected
+ * by the runtime. It is intended to be called when the process is in a
+ * terminal state due to an unhandled exception.
+ *
+ * # Parameters
+ * - `error_type`: Optional type/class of the exception (e.g. "NullPointerException"). Pass empty
+ *   CharSlice for unknown.
+ * - `error_message`: Optional error message. Pass empty CharSlice for no message.
+ * - `runtime_stack`: Stack trace from the runtime. Consumed by this call.
+ *
+ * If the crash-tracker has not been initialized, this function is a no-op.
+ *
+ * # Side effects
+ *   This function disables the signal-based crash handler before performing
+ *   any work. This means that if the process receives a fatal signal (SIGSEGV)
+ *   during or after this call, the crashtracker will not produce a
+ *   second crash report. The previous signal handler (if any) will still be
+ *   chained.
+ *
+ * # Failure mode
+ *   If a fatal signal occurs while this function is in progress, the calling
+ *   process is in an unrecoverable state; the crashtracker cannot report the
+ *   secondary fault and the caller's own signal handler (if any) will execute
+ *   in a potentially corrupted context. Callers should treat this function as a
+ *   terminal operation and exit shortly after it returns.
+ *
+ * # Safety
+ *   Crash-tracking functions are not reentrant.
+ *   No other crash-handler functions should be called concurrently.
+ *   The `runtime_stack` handle must be valid and will be consumed.
+ */
+DDOG_CHECK_RETURN
+struct ddog_VoidResult ddog_crasht_report_unhandled_exception(ddog_CharSlice error_type,
+                                                              ddog_CharSlice error_message,
+                                                              struct ddog_crasht_Handle_StackTrace *runtime_stack);
+
 /**
  * Removes all existing additional tags
  * Expected to be used after a fork, to reset the additional tags on the child
@@ -646,12 +685,27 @@ DDOG_CHECK_RETURN
 struct ddog_VoidResult ddog_crasht_CrashInfoBuilder_with_message(struct ddog_crasht_Handle_CrashInfoBuilder *builder,
                                                                  ddog_CharSlice message);
 
+/**
+ * # Safety
+ * The `builder` can be null, but if non-null it must point to a Builder made by this module,
+ * which has not previously been dropped.
+ * The CharSlice must be valid.
+ */
+DDOG_CHECK_RETURN
+struct ddog_VoidResult ddog_crasht_CrashInfoBuilder_with_thread_name(struct ddog_crasht_Handle_CrashInfoBuilder *builder,
+                                                                     ddog_CharSlice thread_name);
+
 /**
  * # Safety
  * The `builder` can be null, but if non-null it must point to a Builder made by this module,
  * which has not previously been dropped.
  * All arguments must be valid.
- * This method requires that the builder has a UUID, siginfo, and metadata set
+ * This method requires that the builder has `metadata` and `kind` set
+ * Applications can add `message` or `sig_info` to the builder to provide additional context.
+ * If set, the data will be used to derive the crash ping message in the order of
+ * - an explicit message set with `with_message`
+ * - sig_info set with `with_sig_info`
+ * - kind set with `with_kind`
  */
 DDOG_CHECK_RETURN
 struct ddog_VoidResult ddog_crasht_CrashInfoBuilder_upload_ping_to_endpoint(struct ddog_crasht_Handle_CrashInfoBuilder *builder,

data/vendor/{libdatadog-26.0.0 → libdatadog-28.0.0}/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu/include/datadog/data-pipeline.h

@@ -173,7 +173,6 @@ void ddog_trace_exporter_free(struct ddog_TraceExporter *handle);
  */
 struct ddog_TraceExporterError *ddog_trace_exporter_send(const struct ddog_TraceExporter *handle,
                                                          ddog_ByteSlice trace,
-                                                         uintptr_t trace_count,
                                                          struct ddog_TraceExporterResponse **response_out);
 
 #ifdef __cplusplus

data/vendor/{libdatadog-26.0.0/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl → libdatadog-28.0.0/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu}/include/datadog/profiling.h

@@ -63,8 +63,12 @@ DDOG_CHECK_RETURN struct ddog_prof_Exporter_Slice_File ddog_prof_Exporter_Slice_
  * # Arguments
  * * `base_url` - Contains a URL with scheme, host, and port e.g. "https://agent:8126/".
  * * `timeout_ms` - Timeout in milliseconds. Use 0 for default timeout (3000ms).
+ * * `use_system_resolver` - If true, use the system DNS resolver (less fork-safe). If false, the
+ *   default in-process resolver is used (fork-safe).
  */
-struct ddog_prof_Endpoint ddog_prof_Endpoint_agent(ddog_CharSlice base_url, uint64_t timeout_ms);
+struct ddog_prof_Endpoint ddog_prof_Endpoint_agent(ddog_CharSlice base_url,
+                                                   uint64_t timeout_ms,
+                                                   bool use_system_resolver);
 
 /**
  * Creates an endpoint that uses the Datadog intake directly aka agentless.
@@ -72,10 +76,13 @@ struct ddog_prof_Endpoint ddog_prof_Endpoint_agent(ddog_CharSlice base_url, uint
  * * `site` - Contains a host and port e.g. "datadoghq.com".
  * * `api_key` - Contains the Datadog API key.
  * * `timeout_ms` - Timeout in milliseconds. Use 0 for default timeout (3000ms).
+ * * `use_system_resolver` - If true, use the system DNS resolver (less fork-safe). If false, the
+ *   default in-process resolver is used (fork-safe).
  */
 struct ddog_prof_Endpoint ddog_prof_Endpoint_agentless(ddog_CharSlice site,
                                                        ddog_CharSlice api_key,
-                                                       uint64_t timeout_ms);
+                                                       uint64_t timeout_ms,
+                                                       bool use_system_resolver);
 
 /**
  * Creates an endpoint that writes to a file.
@@ -99,7 +106,8 @@ struct ddog_prof_Endpoint ddog_Endpoint_file(ddog_CharSlice filename);
  * * `family` - Profile family, e.g. "ruby"
  * * `tags` - Tags to include with every profile reported by this exporter. It's also possible to
  *   include profile-specific tags, see `additional_tags` on `profile_exporter_build`.
- * * `endpoint` - Configuration for reporting data
+ * * `endpoint` - Configuration for reporting data (includes use_system_resolver for
+ *   Agent/Agentless).
  * # Safety
  * All pointers must refer to valid objects of the correct types.
  */
@@ -120,9 +128,6 @@ void ddog_prof_Exporter_drop(struct ddog_prof_ProfileExporter *exporter);
 
 /**
  * Builds a request and sends it, returning the HttpStatus.
- * This is a more efficient version of calling `ddog_prof_Exporter_Request_build`
- * followed by `ddog_prof_Exporter_send`, as it avoids exposing the intermediate
- * `Request` object.
  *
  * # Arguments
  * * `exporter` - Borrows the exporter.
@@ -196,6 +201,112 @@ bool ddog_CancellationToken_cancel(struct ddog_CancellationToken *cancel);
  */
 void ddog_CancellationToken_drop(struct ddog_CancellationToken *token);
 
+/**
+ * Creates a new ExporterManager with a background worker thread.
+ *
+ * The ExporterManager provides asynchronous profle export capabilities through a
+ * background worker thread and bounded channel.
+ *
+ * # Arguments
+ * * `exporter` - Takes ownership of the ProfileExporter to use for sending profiles.
+ *
+ * # Safety
+ * The `exporter` must point to a valid ProfileExporter that has not been dropped.
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_Result_HandleExporterManager ddog_prof_ExporterManager_new(struct ddog_prof_ProfileExporter *exporter);
+
+/**
+ * Queues a profile to be sent asynchronously by the background worker thread.
+ *
+ * **Important**: This function resets the profile and queues the *previous* profile data.
+ * After calling this, the profile will be empty and ready for new samples.
+ *
+ * # Arguments
+ * * `manager` - Borrows the ExporterManager.
+ * * `profile` - Takes ownership of the profile to send.
+ * * `files_to_compress_and_export` - Files to compress and attach to the profile.
+ * * `optional_additional_tags` - Additional tags to include with this profile.
+ * * `optional_process_tags` - Process-level tags as a comma-separated string.
+ * * `optional_internal_metadata_json` - Internal metadata as a JSON string.
+ * * `optional_info_json` - System info as a JSON string.
+ *
+ * # Safety
+ * All non-null arguments MUST have been created by APIs in this module.
+ */
+DDOG_CHECK_RETURN
+struct ddog_VoidResult ddog_prof_ExporterManager_queue(struct ddog_prof_Handle_ExporterManager *manager,
+                                                       struct ddog_prof_EncodedProfile *profile,
+                                                       struct ddog_prof_Exporter_Slice_File files_to_compress_and_export,
+                                                       const struct ddog_Vec_Tag *optional_additional_tags,
+                                                       const ddog_CharSlice *optional_process_tags,
+                                                       const ddog_CharSlice *optional_internal_metadata_json,
+                                                       const ddog_CharSlice *optional_info_json);
+
+/**
+ * Aborts the manager, stopping the worker thread and returning inflight requests.
+ *
+ * **Note**: This consumes the manager - it cannot be used after calling abort.
+ *
+ * # Arguments
+ * * `manager` - Takes ownership of the ExporterManager.
+ *
+ * # Safety
+ * The `manager` must point to a valid ExporterManager that has not been dropped.
+ */
+DDOG_CHECK_RETURN
+struct ddog_VoidResult ddog_prof_ExporterManager_abort(struct ddog_prof_Handle_ExporterManager *manager);
+
+/**
+ * Suspends the manager before forking (prefork).
+ *
+ * **Note**: This consumes the manager - it cannot be used after calling prefork.
+ *
+ * # Arguments
+ * * `manager` - Takes ownership of the ExporterManager.
+ *
+ * # Safety
+ * The `manager` must point to a valid ExporterManager that has not been dropped.
+ */
+DDOG_CHECK_RETURN
+struct ddog_VoidResult ddog_prof_ExporterManager_prefork(struct ddog_prof_Handle_ExporterManager *manager);
+
+/**
+ * Creates a new manager in the child process after forking (postfork_child).
+ *
+ * Inflight requests from the parent are discarded in the child.
+ *
+ * # Arguments
+ * * `suspended` - Takes ownership of the suspended ExporterManager.
+ *
+ * # Safety
+ * The `suspended` must point to a valid suspended ExporterManager that has not been dropped.
+ */
+DDOG_CHECK_RETURN
+struct ddog_VoidResult ddog_prof_ExporterManager_postfork_child(struct ddog_prof_Handle_ExporterManager *suspended);
+
+/**
+ * Creates a new manager in the parent process after forking (postfork_parent).
+ *
+ * Inflight requests from before the fork are re-queued in the new manager.
+ *
+ * # Arguments
+ * * `suspended` - Takes ownership of the suspended ExporterManager.
+ *
+ * # Safety
+ * The `suspended` must point to a valid suspended ExporterManager that has not been dropped.
+ */
+DDOG_CHECK_RETURN
+struct ddog_VoidResult ddog_prof_ExporterManager_postfork_parent(struct ddog_prof_Handle_ExporterManager *suspended);
+
+/**
+ * # Safety
+ * The `manager` may be null, but if non-null the pointer must point to a
+ * valid `ExporterManager` object made by the Rust Global allocator that
+ * has not already been dropped.
+ */
+void ddog_prof_ExporterManager_drop(struct ddog_prof_Handle_ExporterManager *manager);
+
 /**
  * Frees any error associated with the status, and replaces it with an OK.
  *
@@ -210,7 +321,7 @@ void ddog_prof_Status_drop(struct ddog_prof_Status *status);
  * `ddog_prof_Profile_drop` when you are done with the profile.
  *
  * # Arguments
- * * `sample_types`
+ * * `sample_types` - A slice of SampleType enums
  * * `period` - Optional period of the profile. Passing None/null translates to zero values.
  * * `start_time` - Optional time the profile started at. Passing None/null will use the current
  *   time.
@@ -220,7 +331,7 @@ void ddog_prof_Status_drop(struct ddog_prof_Status *status);
  * and must have the correct number of elements for the slice.
  */
 DDOG_CHECK_RETURN
-struct ddog_prof_Profile_NewResult ddog_prof_Profile_new(struct ddog_prof_Slice_ValueType sample_types,
+struct ddog_prof_Profile_NewResult ddog_prof_Profile_new(struct ddog_prof_Slice_SampleType sample_types,
                                                          const struct ddog_prof_Period *period);
 
 /**
@@ -230,7 +341,7 @@ struct ddog_prof_Profile_NewResult ddog_prof_Profile_new(struct ddog_prof_Slice_
  * # Arguments
  * * `out` - a non-null pointer to an uninitialized Profile.
  * * `dict`: a valid reference to a ProfilesDictionary handle.
- * * `sample_types`
+ * * `sample_types` - A slice of SampleType enums
  * * `period` - Optional period of the profile. Passing None/null translates to zero values.
  *
  * # Safety
@@ -246,7 +357,7 @@ struct ddog_prof_Profile_NewResult ddog_prof_Profile_new(struct ddog_prof_Slice_
 DDOG_CHECK_RETURN
 struct ddog_prof_Status ddog_prof_Profile_with_dictionary(struct ddog_prof_Profile *out,
                                                           const ddog_prof_ProfilesDictionaryHandle *dict,
-                                                          struct ddog_prof_Slice_ValueType sample_types,
+                                                          struct ddog_prof_Slice_SampleType sample_types,
                                                           const struct ddog_prof_Period *period);
 
 /**
@@ -254,7 +365,7 @@ struct ddog_prof_Status ddog_prof_Profile_with_dictionary(struct ddog_prof_Profi
  * TODO: @ivoanjo Should this take a `*mut ManagedStringStorage` like Profile APIs do?
  */
 DDOG_CHECK_RETURN
-struct ddog_prof_Profile_NewResult ddog_prof_Profile_with_string_storage(struct ddog_prof_Slice_ValueType sample_types,
+struct ddog_prof_Profile_NewResult ddog_prof_Profile_with_string_storage(struct ddog_prof_Slice_SampleType sample_types,
                                                                          const struct ddog_prof_Period *period,
                                                                          struct ddog_prof_ManagedStringStorage string_storage);
 
@@ -826,6 +937,11 @@ struct ddog_prof_Status ddog_prof_ProfilesDictionary_insert_mapping(ddog_prof_Ma
 /**
  * Inserts a UTF-8 string into the dictionary string table.
  *
+ * Copies the string into the internal buffer--strings are arena allocated
+ * and not individually allocated. On success, the [`StringId2`] written to
+ * the `string_id` out parameter is valid as long as this dictionary is alive.
+ * It should only be passed back to the dictionary that created it.
+ *
  * # Safety
  *
  * - `string_id` must be non-null and valid for writes of `StringId`.

data/vendor/{libdatadog-26.0.0 → libdatadog-28.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: 26.0.0
+Version: 28.0.0
 Requires:
 Libs: -L${libdir} -ldatadog_profiling -Wl,-rpath,${libdir}
 Libs.private: