libdatadog 33.0.0.1.0 → 36.0.0.1.0

data/vendor/{libdatadog-33.0.0/arm64-darwin/libdatadog-aarch64-apple-darwin → libdatadog-36.0.0/aarch64-linux-musl}/include/datadog/profiling.h

@@ -488,6 +488,24 @@ struct ddog_prof_Profile_Result ddog_prof_Profile_add_endpoint_count(struct ddog
                                                                      ddog_CharSlice endpoint,
                                                                      int64_t value);
 
+/**
+ * Set whether "local root span id" labels should be omitted when serializing.
+ *
+ * This is an experimental setting and defaults to false.
+ *
+ * # Arguments
+ * * `profile` - a reference to the profile being configured.
+ * * `omit` - true to omit the label from serialized pprof samples.
+ *
+ * # Safety
+ * The `profile` ptr must point to a valid Profile object created by this
+ * module.
+ * This call is _NOT_ thread-safe.
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_Result ddog_prof_Profile_set_omit_local_root_span_id_when_serializing(struct ddog_prof_Profile *profile,
+                                                                                               bool omit);
+
 /**
  * Add a poisson-based upscaling rule which will be use to adjust values and make them
  * closer to reality.

data/vendor/libdatadog-36.0.0/aarch64-linux-musl/include/datadog/shared-runtime.h

@@ -0,0 +1,91 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+
+#ifndef DDOG_SHARED_RUNTIME_H
+#define DDOG_SHARED_RUNTIME_H
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+/**
+ * Frees a `SharedRuntimeFFIError`. After this call the pointer is invalid.
+ */
+void ddog_shared_runtime_error_free(struct ddog_SharedRuntimeFFIError *error);
+
+/**
+ * Create a new `SharedRuntime`.
+ *
+ * On success writes a raw handle into `*out_handle` and returns `None`.
+ * On failure leaves `*out_handle` unchanged and returns an error.
+ *
+ * The caller owns the handle and must eventually pass it to
+ * [`ddog_shared_runtime_free`] (or another consumer that takes ownership).
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_new(const struct ddog_SharedRuntime **out_handle);
+
+/**
+ * Free a handle, decrementing the `Arc` strong count.
+ *
+ * The underlying runtime may not be dropped if other components are still using it.
+ * Use [`ddog_shared_runtime_shutdown`] to cleanly stop workers.
+ */
+void ddog_shared_runtime_free(const struct ddog_SharedRuntime *handle);
+
+/**
+ * Must be called in the parent process before `fork()`.
+ *
+ * Pauses all workers so that no background threads are running during the
+ * fork, preventing deadlocks in the child process.
+ *
+ * Returns an error if `handle` is null.
+ * The handle must have been initialized with `ddog_shared_runtime_new`.
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_before_fork(const struct ddog_SharedRuntime *handle);
+
+/**
+ * Must be called in the parent process after `fork()`.
+ *
+ * Restarts all workers that were paused by [`ddog_shared_runtime_before_fork`].
+ *
+ * Returns `None` on success, or an error if workers could not be restarted.
+ * The handle must have been initialized with `ddog_shared_runtime_new`.
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_after_fork_parent(const struct ddog_SharedRuntime *handle);
+
+/**
+ * Must be called in the child process after `fork()`.
+ *
+ * Creates a fresh tokio runtime and restarts all workers. The original
+ * runtime cannot be safely reused after a fork.
+ *
+ * Returns `None` on success, or an error if the runtime could not be
+ * reinitialized.
+ * The handle must have been initialized with `ddog_shared_runtime_new`.
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_after_fork_child(const struct ddog_SharedRuntime *handle);
+
+/**
+ * Shut down the `SharedRuntime`, stopping all workers.
+ *
+ * `timeout_ms` is the maximum time to wait for workers to stop, in
+ * milliseconds.  Pass `0` for no timeout.
+ *
+ * Returns `None` on success, or `SharedRuntimeErrorCode::ShutdownTimedOut`
+ * if the timeout was reached.
+ * The handle must have been initialized with `ddog_shared_runtime_new`.
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_shutdown(const struct ddog_SharedRuntime *handle,
+                                                                uint64_t timeout_ms);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus
+
+#endif  /* DDOG_SHARED_RUNTIME_H */

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

data/vendor/{libdatadog-33.0.0/arm64-darwin/libdatadog-aarch64-apple-darwin → libdatadog-36.0.0/arm64-darwin}/LICENSE-3rdparty.csv

@@ -229,6 +229,7 @@ linux-raw-sys,https://github.com/sunfishcode/linux-raw-sys,Apache-2.0 WITH LLVM-
 litemap,https://github.com/unicode-org/icu4x,Unicode-3.0,The ICU4X Project Developers
 lock_api,https://github.com/Amanieu/parking_lot,MIT OR Apache-2.0,Amanieu d'Antras <amanieu@gmail.com>
 log,https://github.com/rust-lang/log,MIT OR Apache-2.0,The Rust Project Developers
+lru,https://github.com/jeromefroe/lru-rs,MIT,Jerome Froelich <jeromefroelic@hotmail.com>
 manual_future,https://github.com/dmarcuse/manual_future,MIT,Dominic Marcuse <dominic@marcuse.us>
 matchers,https://github.com/hawkw/matchers,MIT,Eliza Weisman <eliza@buoyant.io>
 matchit,https://github.com/ibraheemdev/matchit,MIT AND BSD-3-Clause,Ibraheem Ahmed <ibraheem@ibraheem.ca>
@@ -304,6 +305,7 @@ proc-macro-crate,https://github.com/bkchr/proc-macro-crate,MIT OR Apache-2.0,Bas
 proc-macro-error,https://gitlab.com/CreepySkeleton/proc-macro-error,MIT OR Apache-2.0,CreepySkeleton <creepy-skeleton@yandex.ru>
 proc-macro-error-attr,https://gitlab.com/CreepySkeleton/proc-macro-error,MIT OR Apache-2.0,CreepySkeleton <creepy-skeleton@yandex.ru>
 proc-macro2,https://github.com/dtolnay/proc-macro2,MIT OR Apache-2.0,"David Tolnay <dtolnay@gmail.com>, Alex Crichton <alex@alexcrichton.com>"
+proc-macro2-diagnostics,https://github.com/SergioBenitez/proc-macro2-diagnostics,MIT OR Apache-2.0,Sergio Benitez <sb@sergio.bz>
 prost,https://github.com/tokio-rs/prost,Apache-2.0,"Dan Burkert <dan@danburkert.com>, Lucio Franco <luciofranco14@gmail.com>, Casper Meijn <casper@meijn.net>, Tokio Contributors <team@tokio.rs>"
 prost-derive,https://github.com/tokio-rs/prost,Apache-2.0,"Dan Burkert <dan@danburkert.com>, Lucio Franco <luciofranco14@gmail.com>, Casper Meijn <casper@meijn.net>, Tokio Contributors <team@tokio.rs>"
 prost-types,https://github.com/tokio-rs/prost,Apache-2.0,"Dan Burkert <dan@danburkert.com>, Lucio Franco <luciofranco14@gmail.com>, Casper Meijn <casper@meijn.net>, Tokio Contributors <team@tokio.rs>"
@@ -427,6 +429,7 @@ target-triple,https://github.com/dtolnay/target-triple,MIT OR Apache-2.0,David T
 tempfile,https://github.com/Stebalien/tempfile,MIT OR Apache-2.0,"Steven Allen <steven@stebalien.com>, The Rust Project Developers, Ashley Mannix <ashleymannix@live.com.au>, Jason White <me@jasonwhite.io>"
 termcolor,https://github.com/BurntSushi/termcolor,Unlicense OR MIT,Andrew Gallant <jamslam@gmail.com>
 test-case-macros,https://github.com/frondeus/test-case,MIT,"Marcin Sas-Szymanski <marcin.sas-szymanski@anixe.pl>, Wojciech Polak <frondeus@gmail.com>, Łukasz Biel <lukasz.p.biel@gmail.com>"
+thin-vec,https://github.com/mozilla/thin-vec,MIT OR Apache-2.0,Aria Beingessner <a.beingessner@gmail.com>
 thiserror,https://github.com/dtolnay/thiserror,MIT OR Apache-2.0,David Tolnay <dtolnay@gmail.com>
 thiserror-impl,https://github.com/dtolnay/thiserror,MIT OR Apache-2.0,David Tolnay <dtolnay@gmail.com>
 thread_local,https://github.com/Amanieu/thread_local-rs,MIT OR Apache-2.0,Amanieu d'Antras <amanieu@gmail.com>

data/vendor/{libdatadog-33.0.0/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl → libdatadog-36.0.0/arm64-darwin}/include/datadog/common.h

@@ -1624,6 +1624,9 @@ typedef struct ddog_ContextKey {
 } ddog_ContextKey;
 
 typedef struct ddog_TraceExporter ddog_TraceExporter;
+typedef struct ddog_TracerSpan ddog_TracerSpan;
+typedef struct ddog_TracerTraceChunks ddog_TracerTraceChunks;
+typedef struct ddog_TraceExporterCancelToken ddog_TraceExporterCancelToken;
 
 
 /**
@@ -1669,9 +1672,12 @@ typedef struct ddog_TraceExporterResponse ddog_TraceExporterResponse;
 /**
  * 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.
+ * 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
@@ -1730,6 +1736,26 @@ typedef struct ddog_TelemetryClientConfig {
   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,
@@ -2207,6 +2233,52 @@ typedef struct ddog_ffe_AttributePair {
   struct ddog_ffe_AttributeValue value;
 } ddog_ffe_AttributePair;
 
+/**
+ * Error codes for SharedRuntime FFI operations.
+ */
+typedef enum ddog_SharedRuntimeErrorCode {
+  /**
+   * Invalid argument provided (e.g. null handle).
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_INVALID_ARGUMENT,
+  /**
+   * The runtime is not available or in an invalid state.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_RUNTIME_UNAVAILABLE,
+  /**
+   * Failed to acquire a lock on internal state.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_LOCK_FAILED,
+  /**
+   * A worker operation failed.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_WORKER_ERROR,
+  /**
+   * Failed to create the tokio runtime.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_RUNTIME_CREATION,
+  /**
+   * Shutdown timed out.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_SHUTDOWN_TIMED_OUT,
+  /**
+   * An unexpected panic occurred inside the FFI call.
+   */
+  DDOG_SHARED_RUNTIME_ERROR_CODE_PANIC,
+} ddog_SharedRuntimeErrorCode;
+
+/**
+ * Error returned by SharedRuntime FFI functions.
+ */
+typedef struct ddog_SharedRuntimeFFIError {
+  enum ddog_SharedRuntimeErrorCode code;
+  /**
+   * The error message is always defined when the error is returned by a ddog_shared_runtime
+   * ffi.
+   */
+  char *msg;
+} ddog_SharedRuntimeFFIError;
+
 typedef enum ddog_crasht_BuildIdType {
   DDOG_CRASHT_BUILD_ID_TYPE_GNU,
   DDOG_CRASHT_BUILD_ID_TYPE_GO,

data/vendor/{libdatadog-33.0.0/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl → libdatadog-36.0.0/arm64-darwin}/include/datadog/crashtracker.h

@@ -170,6 +170,25 @@ struct ddog_VoidResult ddog_crasht_report_unhandled_exception(ddog_CharSlice err
                                                               ddog_CharSlice error_message,
                                                               struct ddog_crasht_Handle_StackTrace *runtime_stack);
 
+/**
+ * Register the expected PID of the socket-based crash receiver
+ *
+ * When `collect_all_threads` is enabled and the receiver is reached via a Unix
+ * socket, the crash handler will only grant ptrace permission if the socket
+ * peer's PID matches this registered value.
+ *
+ * Call this after establishing a trusted connection to the sidecar
+ *
+ * # Safety
+ *   This function is safe to call from any thread at any time.
+ */
+void ddog_crasht_set_expected_receiver_pid(int32_t pid);
+
+/**
+ * Returns the currently registered expected receiver PID, or 0 if unset.
+ */
+int32_t ddog_crasht_get_expected_receiver_pid(void);
+
 /**
  * Removes all existing additional tags
  * Expected to be used after a fork, to reset the additional tags on the child

data/vendor/{libdatadog-33.0.0/arm64-darwin/libdatadog-aarch64-apple-darwin → libdatadog-36.0.0/arm64-darwin}/include/datadog/data-pipeline.h

@@ -21,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
@@ -209,6 +209,181 @@ struct ddog_TraceExporterError *ddog_trace_exporter_send(const ddog_TraceExporte
                                                          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);
+
+/**
+ * Create a new cancellation token.
+ *
+ * The returned token must be freed with
+ * [`ddog_trace_exporter_cancel_token_drop`].
+ */
+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.
+ *
+ * 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.
+ */
+void ddog_trace_exporter_cancel_token_cancel(const ddog_TraceExporterCancelToken *token);
+
+/**
+ * Free a cancellation token.
+ *
+ * After this call the token is invalid and must not be reused.
+ */
+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.
+ *
+ * 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
+ *
+ * * `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,
+                                                                      const ddog_TraceExporterCancelToken *cancel);
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif  // __cplusplus

data/vendor/{libdatadog-33.0.0/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu → libdatadog-36.0.0/arm64-darwin}/include/datadog/profiling.h

@@ -488,6 +488,24 @@ struct ddog_prof_Profile_Result ddog_prof_Profile_add_endpoint_count(struct ddog
                                                                      ddog_CharSlice endpoint,
                                                                      int64_t value);
 
+/**
+ * Set whether "local root span id" labels should be omitted when serializing.
+ *
+ * This is an experimental setting and defaults to false.
+ *
+ * # Arguments
+ * * `profile` - a reference to the profile being configured.
+ * * `omit` - true to omit the label from serialized pprof samples.
+ *
+ * # Safety
+ * The `profile` ptr must point to a valid Profile object created by this
+ * module.
+ * This call is _NOT_ thread-safe.
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_Result ddog_prof_Profile_set_omit_local_root_span_id_when_serializing(struct ddog_prof_Profile *profile,
+                                                                                               bool omit);
+
 /**
  * Add a poisson-based upscaling rule which will be use to adjust values and make them
  * closer to reality.

data/vendor/libdatadog-36.0.0/arm64-darwin/include/datadog/shared-runtime.h

@@ -0,0 +1,91 @@
+// Copyright 2025-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
+
+#ifndef DDOG_SHARED_RUNTIME_H
+#define DDOG_SHARED_RUNTIME_H
+
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
+/**
+ * Frees a `SharedRuntimeFFIError`. After this call the pointer is invalid.
+ */
+void ddog_shared_runtime_error_free(struct ddog_SharedRuntimeFFIError *error);
+
+/**
+ * Create a new `SharedRuntime`.
+ *
+ * On success writes a raw handle into `*out_handle` and returns `None`.
+ * On failure leaves `*out_handle` unchanged and returns an error.
+ *
+ * The caller owns the handle and must eventually pass it to
+ * [`ddog_shared_runtime_free`] (or another consumer that takes ownership).
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_new(const struct ddog_SharedRuntime **out_handle);
+
+/**
+ * Free a handle, decrementing the `Arc` strong count.
+ *
+ * The underlying runtime may not be dropped if other components are still using it.
+ * Use [`ddog_shared_runtime_shutdown`] to cleanly stop workers.
+ */
+void ddog_shared_runtime_free(const struct ddog_SharedRuntime *handle);
+
+/**
+ * Must be called in the parent process before `fork()`.
+ *
+ * Pauses all workers so that no background threads are running during the
+ * fork, preventing deadlocks in the child process.
+ *
+ * Returns an error if `handle` is null.
+ * The handle must have been initialized with `ddog_shared_runtime_new`.
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_before_fork(const struct ddog_SharedRuntime *handle);
+
+/**
+ * Must be called in the parent process after `fork()`.
+ *
+ * Restarts all workers that were paused by [`ddog_shared_runtime_before_fork`].
+ *
+ * Returns `None` on success, or an error if workers could not be restarted.
+ * The handle must have been initialized with `ddog_shared_runtime_new`.
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_after_fork_parent(const struct ddog_SharedRuntime *handle);
+
+/**
+ * Must be called in the child process after `fork()`.
+ *
+ * Creates a fresh tokio runtime and restarts all workers. The original
+ * runtime cannot be safely reused after a fork.
+ *
+ * Returns `None` on success, or an error if the runtime could not be
+ * reinitialized.
+ * The handle must have been initialized with `ddog_shared_runtime_new`.
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_after_fork_child(const struct ddog_SharedRuntime *handle);
+
+/**
+ * Shut down the `SharedRuntime`, stopping all workers.
+ *
+ * `timeout_ms` is the maximum time to wait for workers to stop, in
+ * milliseconds.  Pass `0` for no timeout.
+ *
+ * Returns `None` on success, or `SharedRuntimeErrorCode::ShutdownTimedOut`
+ * if the timeout was reached.
+ * The handle must have been initialized with `ddog_shared_runtime_new`.
+ */
+struct ddog_SharedRuntimeFFIError *ddog_shared_runtime_shutdown(const struct ddog_SharedRuntime *handle,
+                                                                uint64_t timeout_ms);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus
+
+#endif  /* DDOG_SHARED_RUNTIME_H */

data/vendor/{libdatadog-33.0.0/arm64-darwin/libdatadog-aarch64-apple-darwin → libdatadog-36.0.0/arm64-darwin}/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: 33.0.0
+Version: 36.0.0
 Requires:
 Libs: -L${libdir} -ldatadog_profiling -Wl,-rpath,${libdir}
 Libs.private: