libdatadog 7.0.0.1.0 → 9.0.0.1.0

data/vendor/{libdatadog-7.0.0/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl → libdatadog-9.0.0/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu}/include/datadog/common.h

@@ -83,6 +83,32 @@ typedef struct ddog_Slice_CChar {
  */
 typedef struct ddog_Slice_CChar ddog_CharSlice;
 
+typedef enum ddog_Option_Error_Tag {
+  DDOG_OPTION_ERROR_SOME_ERROR,
+  DDOG_OPTION_ERROR_NONE_ERROR,
+} ddog_Option_Error_Tag;
+
+typedef struct ddog_Option_Error {
+  ddog_Option_Error_Tag tag;
+  union {
+    struct {
+      struct ddog_Error some;
+    };
+  };
+} ddog_Option_Error;
+
+typedef struct ddog_Option_Error ddog_MaybeError;
+
+/**
+ * A wrapper for returning owned strings from FFI
+ */
+typedef struct ddog_StringWrapper {
+  /**
+   * This is a String stuffed into the vec.
+   */
+  struct ddog_Vec_U8 message;
+} ddog_StringWrapper;
+
 /**
  * Holds the raw parts of a Rust Vec; it should only be created from Rust,
  * never from C.
@@ -112,14 +138,10 @@ typedef struct ddog_Vec_Tag_ParseResult {
   struct ddog_Error *error_message;
 } ddog_Vec_Tag_ParseResult;
 
-typedef enum ddog_prof_CrashtrackerResolveFrames {
-  DDOG_PROF_CRASHTRACKER_RESOLVE_FRAMES_NEVER,
-  /**
-   * Resolving frames in process is experimental, and can fail/crash
-   */
-  DDOG_PROF_CRASHTRACKER_RESOLVE_FRAMES_EXPERIMENTAL_IN_PROCESS,
-  DDOG_PROF_CRASHTRACKER_RESOLVE_FRAMES_IN_RECEIVER,
-} ddog_prof_CrashtrackerResolveFrames;
+typedef enum ddog_prof_DemangleOptions {
+  DDOG_PROF_DEMANGLE_OPTIONS_COMPLETE,
+  DDOG_PROF_DEMANGLE_OPTIONS_NAME_ONLY,
+} ddog_prof_DemangleOptions;
 
 /**
  * This enum represents operations a profiler might be engaged in.
@@ -143,6 +165,22 @@ typedef enum ddog_prof_ProfilingOpTypes {
   DDOG_PROF_PROFILING_OP_TYPES_SIZE,
 } ddog_prof_ProfilingOpTypes;
 
+/**
+ * Stacktrace collection occurs in the context of a crashing process.
+ * If the stack is sufficiently corruputed, it is possible (but unlikely),
+ * for stack trace collection itself to crash.
+ * We recommend fully enabling stacktrace collection, but having an environment
+ * variable to allow downgrading the collector.
+ */
+typedef enum ddog_prof_StacktraceCollection {
+  /**
+   * Stacktrace collection occurs in the
+   */
+  DDOG_PROF_STACKTRACE_COLLECTION_DISABLED,
+  DDOG_PROF_STACKTRACE_COLLECTION_WITHOUT_SYMBOLS,
+  DDOG_PROF_STACKTRACE_COLLECTION_ENABLED,
+} ddog_prof_StacktraceCollection;
+
 typedef struct ddog_CancellationToken ddog_CancellationToken;
 
 typedef struct ddog_prof_Exporter ddog_prof_Exporter;
@@ -152,16 +190,16 @@ typedef struct ddog_prof_ProfiledEndpointsStats ddog_prof_ProfiledEndpointsStats
 typedef struct ddog_prof_Exporter_Request ddog_prof_Exporter_Request;
 
 /**
- * A generic result type for when a profiling operation may fail, but there's
- * nothing to return in the case of success.
+ * A generic result type for when a crashtracking operation may fail,
+ * but there's nothing to return in the case of success.
  */
-typedef enum ddog_prof_Profile_Result_Tag {
-  DDOG_PROF_PROFILE_RESULT_OK,
-  DDOG_PROF_PROFILE_RESULT_ERR,
-} ddog_prof_Profile_Result_Tag;
+typedef enum ddog_prof_CrashtrackerResult_Tag {
+  DDOG_PROF_CRASHTRACKER_RESULT_OK,
+  DDOG_PROF_CRASHTRACKER_RESULT_ERR,
+} ddog_prof_CrashtrackerResult_Tag;
 
-typedef struct ddog_prof_Profile_Result {
-  ddog_prof_Profile_Result_Tag tag;
+typedef struct ddog_prof_CrashtrackerResult {
+  ddog_prof_CrashtrackerResult_Tag tag;
   union {
     struct {
       /**
@@ -174,11 +212,24 @@ typedef struct ddog_prof_Profile_Result {
       struct ddog_Error err;
     };
   };
-} ddog_prof_Profile_Result;
+} ddog_prof_CrashtrackerResult;
+
+typedef struct ddog_prof_Slice_CharSlice {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
+  const ddog_CharSlice *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_CharSlice;
 
 typedef enum ddog_prof_Endpoint_Tag {
   DDOG_PROF_ENDPOINT_AGENT,
   DDOG_PROF_ENDPOINT_AGENTLESS,
+  DDOG_PROF_ENDPOINT_FILE,
 } ddog_prof_Endpoint_Tag;
 
 typedef struct ddog_prof_Endpoint_ddog_prof_Agentless_Body {
@@ -193,19 +244,44 @@ typedef struct ddog_prof_Endpoint {
       ddog_CharSlice agent;
     };
     ddog_prof_Endpoint_ddog_prof_Agentless_Body AGENTLESS;
+    struct {
+      ddog_CharSlice file;
+    };
   };
 } ddog_prof_Endpoint;
 
 typedef struct ddog_prof_CrashtrackerConfiguration {
-  /**
-   * Should the crashtracker attempt to collect a stacktrace for the crash
-   */
-  bool collect_stacktrace;
+  struct ddog_prof_Slice_CharSlice additional_files;
   bool create_alt_stack;
   /**
-   * The endpoint to send the crash repor to (can be a file://)
+   * The endpoint to send the crash report to (can be a file://)
    */
   struct ddog_prof_Endpoint endpoint;
+  enum ddog_prof_StacktraceCollection resolve_frames;
+  uint64_t timeout_secs;
+} ddog_prof_CrashtrackerConfiguration;
+
+typedef struct ddog_prof_EnvVar {
+  ddog_CharSlice key;
+  ddog_CharSlice val;
+} ddog_prof_EnvVar;
+
+typedef struct ddog_prof_Slice_EnvVar {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
+  const struct ddog_prof_EnvVar *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_EnvVar;
+
+typedef struct ddog_prof_CrashtrackerReceiverConfig {
+  struct ddog_prof_Slice_CharSlice args;
+  struct ddog_prof_Slice_EnvVar env;
+  ddog_CharSlice path_to_receiver_binary;
   /**
    * Optional filename to forward stderr to (useful for logging/debugging)
    */
@@ -214,12 +290,7 @@ typedef struct ddog_prof_CrashtrackerConfiguration {
    * Optional filename to forward stdout to (useful for logging/debugging)
    */
   ddog_CharSlice optional_stdout_filename;
-  ddog_CharSlice path_to_receiver_binary;
-  /**
-   * Whether/when we should attempt to resolve frames
-   */
-  enum ddog_prof_CrashtrackerResolveFrames resolve_frames;
-} ddog_prof_CrashtrackerConfiguration;
+} ddog_prof_CrashtrackerReceiverConfig;
 
 typedef struct ddog_prof_CrashtrackerMetadata {
   ddog_CharSlice profiling_library_name;
@@ -231,6 +302,122 @@ typedef struct ddog_prof_CrashtrackerMetadata {
   const struct ddog_Vec_Tag *tags;
 } ddog_prof_CrashtrackerMetadata;
 
+/**
+ * Represents a CrashInfo. Do not access its member for any reason, only use
+ * the C API functions on this struct.
+ */
+typedef struct ddog_prof_CrashInfo {
+  struct ddog_prof_CrashInfo *inner;
+} ddog_prof_CrashInfo;
+
+/**
+ * Returned by [ddog_prof_Profile_new].
+ */
+typedef enum ddog_prof_CrashInfoNewResult_Tag {
+  DDOG_PROF_CRASH_INFO_NEW_RESULT_OK,
+  DDOG_PROF_CRASH_INFO_NEW_RESULT_ERR,
+} ddog_prof_CrashInfoNewResult_Tag;
+
+typedef struct ddog_prof_CrashInfoNewResult {
+  ddog_prof_CrashInfoNewResult_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_CrashInfo ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_CrashInfoNewResult;
+
+typedef struct ddog_prof_SigInfo {
+  uint64_t signum;
+  ddog_CharSlice signame;
+} ddog_prof_SigInfo;
+
+typedef enum ddog_prof_Option_U32_Tag {
+  DDOG_PROF_OPTION_U32_SOME_U32,
+  DDOG_PROF_OPTION_U32_NONE_U32,
+} ddog_prof_Option_U32_Tag;
+
+typedef struct ddog_prof_Option_U32 {
+  ddog_prof_Option_U32_Tag tag;
+  union {
+    struct {
+      uint32_t some;
+    };
+  };
+} ddog_prof_Option_U32;
+
+typedef struct ddog_prof_StackFrameNames {
+  struct ddog_prof_Option_U32 colno;
+  ddog_CharSlice filename;
+  struct ddog_prof_Option_U32 lineno;
+  ddog_CharSlice name;
+} ddog_prof_StackFrameNames;
+
+typedef struct ddog_prof_Slice_StackFrameNames {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
+  const struct ddog_prof_StackFrameNames *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_StackFrameNames;
+
+typedef struct ddog_prof_StackFrame {
+  uintptr_t ip;
+  uintptr_t module_base_address;
+  struct ddog_prof_Slice_StackFrameNames names;
+  uintptr_t sp;
+  uintptr_t symbol_address;
+} ddog_prof_StackFrame;
+
+typedef struct ddog_prof_Slice_StackFrame {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
+  const struct ddog_prof_StackFrame *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_StackFrame;
+
+/**
+ * A wrapper for returning owned strings from FFI
+ */
+typedef struct ddog_prof_StringWrapper {
+  /**
+   * This is a String stuffed into the vec.
+   */
+  struct ddog_Vec_U8 message;
+} ddog_prof_StringWrapper;
+
+/**
+ * Returned by [ddog_prof_Profile_new].
+ */
+typedef enum ddog_prof_StringWrapperResult_Tag {
+  DDOG_PROF_STRING_WRAPPER_RESULT_OK,
+  DDOG_PROF_STRING_WRAPPER_RESULT_ERR,
+} ddog_prof_StringWrapperResult_Tag;
+
+typedef struct ddog_prof_StringWrapperResult {
+  ddog_prof_StringWrapperResult_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_StringWrapper ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_StringWrapperResult;
+
 typedef struct ddog_Slice_U8 {
   /**
    * Must be non-null and suitably aligned for the underlying type.
@@ -378,6 +565,31 @@ typedef struct ddog_prof_Period {
   int64_t value;
 } ddog_prof_Period;
 
+/**
+ * A generic result type for when a profiling operation may fail, but there's
+ * nothing to return in the case of success.
+ */
+typedef enum ddog_prof_Profile_Result_Tag {
+  DDOG_PROF_PROFILE_RESULT_OK,
+  DDOG_PROF_PROFILE_RESULT_ERR,
+} ddog_prof_Profile_Result_Tag;
+
+typedef struct ddog_prof_Profile_Result {
+  ddog_prof_Profile_Result_Tag tag;
+  union {
+    struct {
+      /**
+       * Do not use the value of Ok. This value only exists to overcome
+       * Rust -> C code generation.
+       */
+      bool ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_Profile_Result;
+
 typedef struct ddog_prof_Mapping {
   /**
    * Address at which the binary (or DLL) is loaded into memory.
@@ -618,27 +830,11 @@ typedef struct ddog_TelemetryWorkerBuilder ddog_TelemetryWorkerBuilder;
  *
  * The worker won't send data to the agent until you call `TelemetryWorkerHandle::send_start`
  *
- * To stop the worker, call `TelemetryWorkerHandle::send_stop` which trigger flush aynchronously
+ * To stop the worker, call `TelemetryWorkerHandle::send_stop` which trigger flush asynchronously
  * then `TelemetryWorkerHandle::wait_for_shutdown`
  */
 typedef struct ddog_TelemetryWorkerHandle ddog_TelemetryWorkerHandle;
 
-typedef enum ddog_Option_VecU8_Tag {
-  DDOG_OPTION_VEC_U8_SOME_VEC_U8,
-  DDOG_OPTION_VEC_U8_NONE_VEC_U8,
-} ddog_Option_VecU8_Tag;
-
-typedef struct ddog_Option_VecU8 {
-  ddog_Option_VecU8_Tag tag;
-  union {
-    struct {
-      struct ddog_Vec_U8 some;
-    };
-  };
-} ddog_Option_VecU8;
-
-typedef struct ddog_Option_VecU8 ddog_MaybeError;
-
 typedef enum ddog_Option_Bool_Tag {
   DDOG_OPTION_BOOL_SOME_BOOL,
   DDOG_OPTION_BOOL_NONE_BOOL,
@@ -676,6 +872,8 @@ void ddog_Error_drop(struct ddog_Error *error);
  */
 ddog_CharSlice ddog_Error_message(const struct ddog_Error *error);
 
+void ddog_MaybeError_drop(ddog_MaybeError);
+
 DDOG_CHECK_RETURN struct ddog_Endpoint *ddog_endpoint_from_url(ddog_CharSlice url);
 
 DDOG_CHECK_RETURN struct ddog_Endpoint *ddog_endpoint_from_api_key(ddog_CharSlice api_key);
@@ -687,6 +885,20 @@ struct ddog_Error *ddog_endpoint_from_api_key_and_site(ddog_CharSlice api_key,
 
 void ddog_endpoint_drop(struct ddog_Endpoint*);
 
+/**
+ * # Safety
+ * Only pass null or a valid reference to a `ddog_StringWrapper`.
+ */
+void ddog_StringWrapper_drop(struct ddog_StringWrapper *s);
+
+/**
+ * Returns a CharSlice of the message that is valid until the StringWrapper
+ * is dropped.
+ * # Safety
+ * Only pass null or a valid reference to a `ddog_StringWrapper`.
+ */
+ddog_CharSlice ddog_StringWrapper_message(const struct ddog_StringWrapper *s);
+
 DDOG_CHECK_RETURN struct ddog_Vec_Tag ddog_Vec_Tag_new(void);
 
 void ddog_Vec_Tag_drop(struct ddog_Vec_Tag);

data/vendor/{libdatadog-7.0.0 → libdatadog-9.0.0}/aarch64-linux/libdatadog-aarch64-unknown-linux-gnu/include/datadog/profiling.h

@@ -16,23 +16,251 @@
 extern "C" {
 #endif // __cplusplus
 
+/**
+ * Cleans up after the crash-tracker:
+ * Unregister the crash handler, restore the previous handler (if any), and
+ * shut down the receiver.  Note that the use of this function is optional:
+ * the receiver will automatically shutdown when the pipe is closed on program
+ * exit.
+ *
+ * # Preconditions
+ *     This function assumes that the crash-tracker has previously been
+ *     initialized.
+ * # Safety
+ *     Crash-tracking functions are not reentrant.
+ *     No other crash-handler functions should be called concurrently.
+ * # Atomicity
+ *     This function is not atomic. A crash during its execution may lead to
+ *     unexpected crash-handling behaviour.
+ */
+DDOG_CHECK_RETURN struct ddog_prof_CrashtrackerResult ddog_prof_Crashtracker_shutdown(void);
+
+/**
+ * Reinitialize the crash-tracking infrastructure after a fork.
+ * This should be one of the first things done after a fork, to minimize the
+ * chance that a crash occurs between the fork, and this call.
+ * In particular, reset the counters that track the profiler state machine,
+ * and start a new receiver to collect data from this fork.
+ * NOTE: An alternative design would be to have a 1:many sidecar listening on a
+ * socket instead of 1:1 receiver listening on a pipe, but the only real
+ * advantage would be to have fewer processes in `ps -a`.
+ *
+ * # Preconditions
+ *     This function assumes that the crash-tracker has previously been
+ *     initialized.
+ * # Safety
+ *     Crash-tracking functions are not reentrant.
+ *     No other crash-handler functions should be called concurrently.
+ * # Atomicity
+ *     This function is not atomic. A crash during its execution may lead to
+ *     unexpected crash-handling behaviour.
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_CrashtrackerResult ddog_prof_Crashtracker_update_on_fork(struct ddog_prof_CrashtrackerConfiguration config,
+                                                                          struct ddog_prof_CrashtrackerReceiverConfig receiver_config,
+                                                                          struct ddog_prof_CrashtrackerMetadata metadata);
+
+/**
+ * Receives data from a crash collector via a pipe on `stdin`, formats it into
+ * `CrashInfo` json, and emits it to the endpoint/file defined in `config`.
+ *
+ * At a high-level, this exists because doing anything in a
+ * signal handler is dangerous, so we fork a sidecar to do the stuff we aren't
+ * allowed to do in the handler.
+ *
+ * See comments in [profiling/crashtracker/mod.rs] for a full architecture
+ * description.
+ * # Safety
+ * No safety concerns
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_CrashtrackerResult ddog_prof_Crashtracker_receiver_entry_point(void);
+
+/**
+ * Initialize the crash-tracking infrastructure.
+ *
+ * # Preconditions
+ *     None.
+ * # Safety
+ *     Crash-tracking functions are not reentrant.
+ *     No other crash-handler functions should be called concurrently.
+ * # Atomicity
+ *     This function is not atomic. A crash during its execution may lead to
+ *     unexpected crash-handling behaviour.
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_CrashtrackerResult ddog_prof_Crashtracker_init(struct ddog_prof_CrashtrackerConfiguration config,
+                                                                struct ddog_prof_CrashtrackerReceiverConfig receiver_config,
+                                                                struct ddog_prof_CrashtrackerMetadata metadata);
+
+/**
+ * Resets all counters to 0.
+ * Expected to be used after a fork, to reset the counters on the child
+ * ATOMICITY:
+ *     This is NOT ATOMIC.
+ *     Should only be used when no conflicting updates can occur,
+ *     e.g. after a fork but before profiling ops start on the child.
+ * # Safety
+ * No safety concerns.
+ */
+DDOG_CHECK_RETURN struct ddog_prof_CrashtrackerResult ddog_prof_Crashtracker_reset_counters(void);
+
+/**
+ * Atomically increments the count associated with `op`.
+ * Useful for tracking what operations were occuring when a crash occurred.
+ *
+ * # Safety
+ * No safety concerns.
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_CrashtrackerResult ddog_prof_Crashtracker_begin_profiling_op(enum ddog_prof_ProfilingOpTypes op);
+
+/**
+ * Atomically decrements the count associated with `op`.
+ * Useful for tracking what operations were occuring when a crash occurred.
+ *
+ * # Safety
+ * No safety concerns.
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_CrashtrackerResult ddog_prof_Crashtracker_end_profiling_op(enum ddog_prof_ProfilingOpTypes op);
+
+/**
+ * Create a new crashinfo, and returns an opaque reference to it.
+ * # Safety
+ * No safety issues.
+ */
+DDOG_CHECK_RETURN struct ddog_prof_CrashInfoNewResult ddog_crashinfo_new(void);
+
+/**
+ * # Safety
+ * The `crash_info` can be null, but if non-null it must point to a CrashInfo
+ * made by this module, which has not previously been dropped.
+ */
+void ddog_crashinfo_drop(struct ddog_prof_CrashInfo *crashinfo);
+
+/**
+ * Adds a "counter" variable, with the given value.  Useful for determining if
+ * "interesting" operations were occurring when the crash did.
+ *
+ * # Safety
+ * `crashinfo` must be a valid pointer to a `CrashInfo` object.
+ * `name` should be a valid reference to a utf8 encoded String.
+ * The string is copied into the crashinfo, so it does not need to outlive this
+ * call.
+ */
 DDOG_CHECK_RETURN
-struct ddog_prof_Profile_Result ddog_prof_Crashtracker_begin_profiling_op(enum ddog_prof_ProfilingOpTypes op);
+struct ddog_prof_CrashtrackerResult ddog_crashinfo_add_counter(struct ddog_prof_CrashInfo *crashinfo,
+                                                               ddog_CharSlice name,
+                                                               int64_t val);
 
+/**
+ * Adds the contents of "file" to the crashinfo
+ *
+ * # Safety
+ * `crashinfo` must be a valid pointer to a `CrashInfo` object.
+ * `name` should be a valid reference to a utf8 encoded String.
+ * The string is copied into the crashinfo, so it does not need to outlive this
+ * call.
+ */
 DDOG_CHECK_RETURN
-struct ddog_prof_Profile_Result ddog_prof_Crashtracker_end_profiling_op(enum ddog_prof_ProfilingOpTypes op);
+struct ddog_prof_CrashtrackerResult ddog_crashinfo_add_file(struct ddog_prof_CrashInfo *crashinfo,
+                                                            ddog_CharSlice name);
 
-DDOG_CHECK_RETURN struct ddog_prof_Profile_Result ddog_prof_Crashtracker_shutdown(void);
+/**
+ * Adds the tag with given "key" and "value" to the crashinfo
+ *
+ * # Safety
+ * `crashinfo` must be a valid pointer to a `CrashInfo` object.
+ * `key` should be a valid reference to a utf8 encoded String.
+ * `value` should be a valid reference to a utf8 encoded String.
+ * The string is copied into the crashinfo, so it does not need to outlive this
+ * call.
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_CrashtrackerResult ddog_crashinfo_add_tag(struct ddog_prof_CrashInfo *crashinfo,
+                                                           ddog_CharSlice key,
+                                                           ddog_CharSlice value);
 
+/**
+ * Sets the crashinfo metadata
+ *
+ * # Safety
+ * `crashinfo` must be a valid pointer to a `CrashInfo` object.
+ * All references inside `metadata` must be valid.
+ * Strings are copied into the crashinfo, and do not need to outlive this call.
+ */
 DDOG_CHECK_RETURN
-struct ddog_prof_Profile_Result ddog_prof_Crashtracker_update_on_fork(struct ddog_prof_CrashtrackerConfiguration config,
-                                                                      struct ddog_prof_CrashtrackerMetadata metadata);
+struct ddog_prof_CrashtrackerResult ddog_crashinfo_set_metadata(struct ddog_prof_CrashInfo *crashinfo,
+                                                                struct ddog_prof_CrashtrackerMetadata metadata);
 
-DDOG_CHECK_RETURN struct ddog_prof_Profile_Result ddog_prof_Crashtracker_receiver_entry_point(void);
+/**
+ * Sets the crashinfo siginfo
+ *
+ * # Safety
+ * `crashinfo` must be a valid pointer to a `CrashInfo` object.
+ * All references inside `metadata` must be valid.
+ * Strings are copied into the crashinfo, and do not need to outlive this call.
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_CrashtrackerResult ddog_crashinfo_set_siginfo(struct ddog_prof_CrashInfo *crashinfo,
+                                                               struct ddog_prof_SigInfo siginfo);
 
+/**
+ * If `thread_id` is empty, sets `stacktrace` as the default stacktrace.
+ * Otherwise, adds an additional stacktrace with id "thread_id".
+ *
+ * # Safety
+ * `crashinfo` must be a valid pointer to a `CrashInfo` object.
+ * All references inside `stacktraces` must be valid.
+ * Strings are copied into the crashinfo, and do not need to outlive this call.
+ */
 DDOG_CHECK_RETURN
-struct ddog_prof_Profile_Result ddog_prof_Crashtracker_init(struct ddog_prof_CrashtrackerConfiguration config,
-                                                            struct ddog_prof_CrashtrackerMetadata metadata);
+struct ddog_prof_CrashtrackerResult ddog_crashinfo_set_stacktrace(struct ddog_prof_CrashInfo *crashinfo,
+                                                                  ddog_CharSlice thread_id,
+                                                                  struct ddog_prof_Slice_StackFrame stacktrace);
+
+/**
+ * Sets the timestamp to the given unix timestamp
+ *
+ * # Safety
+ * `crashinfo` must be a valid pointer to a `CrashInfo` object.
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_CrashtrackerResult ddog_crashinfo_set_timestamp(struct ddog_prof_CrashInfo *crashinfo,
+                                                                 int64_t secs,
+                                                                 uint32_t nsecs);
+
+/**
+ * Sets the timestamp to the current time
+ *
+ * # Safety
+ * `crashinfo` must be a valid pointer to a `CrashInfo` object.
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_CrashtrackerResult ddog_crashinfo_set_timestamp_to_now(struct ddog_prof_CrashInfo *crashinfo);
+
+/**
+ * Exports `crashinfo` to the backend at `endpoint`
+ * Note that we support the "file://" endpoint for local file output.
+ * # Safety
+ * `crashinfo` must be a valid pointer to a `CrashInfo` object.
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_CrashtrackerResult ddog_crashinfo_upload_to_endpoint(struct ddog_prof_CrashInfo *crashinfo,
+                                                                      struct ddog_prof_CrashtrackerConfiguration config);
+
+/**
+ * Demangles the string "name".
+ * If demangling fails, returns an empty string ""
+ *
+ * # Safety
+ * `name` should be a valid reference to a utf8 encoded String.
+ * The string is copied into the result, and does not need to outlive this call
+ */
+DDOG_CHECK_RETURN
+struct ddog_prof_StringWrapperResult ddog_demangle(ddog_CharSlice name,
+                                                   enum ddog_prof_DemangleOptions options);
 
 DDOG_CHECK_RETURN struct ddog_prof_Exporter_Slice_File ddog_prof_Exporter_Slice_File_empty(void);
 
@@ -51,6 +279,15 @@ struct ddog_prof_Endpoint ddog_prof_Endpoint_agent(ddog_CharSlice base_url);
  */
 struct ddog_prof_Endpoint ddog_prof_Endpoint_agentless(ddog_CharSlice site, ddog_CharSlice api_key);
 
+/**
+ * Creates an endpoint that writes to a file.
+ * Useful for local debugging.
+ * Currently only supported by the crashtracker.
+ * # Arguments
+ * * `filename` - Path to the output file "/tmp/file.txt".
+ */
+struct ddog_prof_Endpoint ddog_Endpoint_file(ddog_CharSlice filename);
+
 /**
  * Creates a new exporter to be used to report profiling data.
  * # Arguments