libdatadog 24.0.0.1.0 → 25.0.0.1.0

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

@@ -257,10 +257,40 @@ typedef struct ddog_Vec_Tag_ParseResult {
   struct ddog_Error *error_message;
 } ddog_Vec_Tag_ParseResult;
 
+#define ddog_prof_Set_SIZE_HINT (1024 * 1024)
+
+typedef enum ddog_prof_Utf8Option {
+  /**
+   * The string is assumed to be valid UTF-8. If it's not, the behavior
+   * is undefined.
+   */
+  DDOG_PROF_UTF8_OPTION_ASSUME,
+  /**
+   * The string is converted to UTF-8 using lossy conversion.
+   */
+  DDOG_PROF_UTF8_OPTION_CONVERT_LOSSY,
+  /**
+   * The string is validated to be UTF-8. If it's not, an error is
+   * returned.
+   */
+  DDOG_PROF_UTF8_OPTION_VALIDATE,
+} ddog_prof_Utf8Option;
+
 typedef struct ddog_prof_EncodedProfile ddog_prof_EncodedProfile;
 
 typedef struct ddog_prof_Exporter ddog_prof_Exporter;
 
+/**
+ * `ProfilesDictionary` contains data which are common to multiple profiles,
+ * whether that's multiple profiles simultaneously or multiple profiles
+ * through time.
+ *
+ * The current implementation is thread-safe, though there has been some
+ * discussion about making that optional, as some libraries will call these
+ * APIs in places where a mutex is already employed.
+ */
+typedef struct ddog_prof_ProfilesDictionary ddog_prof_ProfilesDictionary;
+
 typedef struct ddog_prof_Exporter_Request ddog_prof_Exporter_Request;
 
 typedef struct ddog_Slice_U8 {
@@ -444,6 +474,55 @@ typedef struct ddog_CancellationToken {
   ddog_prof_TokioCancellationToken *inner;
 } ddog_CancellationToken;
 
+/**
+ * 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
+ * smaller, and is FFI-stable.
+ *
+ * The OK status is guaranteed to have a representation of `{ 0, null }`.
+ *
+ * # Ownership
+ *
+ * A `ProfileStatus` owns its error message data. When a `ProfileStatus` with an error is
+ * created, it takes ownership of the error string (either as a static reference or heap
+ * allocation). The caller is responsible for eventually calling [`ddog_prof_Status_drop`] to
+ * free any heap-allocated memory. This is safe to call on OK as well; it does nothing.
+ *
+ * # FFI Safety
+ *
+ * This type is `#[repr(C)]` and safe to pass across FFI boundaries. The C side must treat
+ * this as an opaque struct and use the provided FFI functions to inspect and drop it.
+ */
+typedef struct ddog_prof_Status {
+  /**
+   * Bitflags indicating the storage type of the error message.
+   * This is only meaningful when `err` is non-null. When `err` is
+   * null (indicating OK), this field is ignored (but typically 0).
+   * - `FLAG_STATIC` (0): Error message points to static data that must not be freed.
+   * - `FLAG_ALLOCATED` (1): Error message is heap-allocated and owned by this `ProfileStatus`.
+   *   Must be freed via [`ddog_prof_Status_drop`].
+   */
+  size_t flags;
+  /**
+   * Pointer to a null-terminated UTF-8 error message string.
+   * - If null: indicates OK (success). Check this from C to determine if the operation
+   *   succeeded.
+   * - If non-null and `flags == FLAG_STATIC`: points to static data with lifetime `'static`.
+   *   Must not be freed.
+   * - If non-null and `flags == FLAG_ALLOCATED`: points to heap-allocated data owned by this
+   *   `ProfileStatus`. Must be freed by [`ddog_prof_Status_drop`].
+   *
+   * # Safety Invariant
+   *
+   * When non-null, `err` must point to a valid, null-terminated C
+   * string in UTF-8 encoding. The pointer remains valid for the
+   * lifetime of this `ProfileStatus` or until [`ddog_prof_Status_drop`]
+   * is called.
+   */
+  const char *err;
+} ddog_prof_Status;
+#define ddog_prof_Status_OK (ddog_prof_Status){ .flags = 0, .err = (ddog_prof_null){  } }
+
 /**
  * Represents a profile. Do not access its member for any reason, only use
  * the C API functions on this struct.
@@ -502,6 +581,23 @@ typedef struct ddog_prof_Period {
   int64_t value;
 } ddog_prof_Period;
 
+/**
+ * Opaque FFI handle to an `Arc<T>`'s inner `T`.
+ *
+ * Safety rules for implementors/callers:
+ * - Do not create multiple owning `Arc<T>`s from the same raw pointer.
+ * - Always restore the original `Arc` with `into_raw` after any `from_raw`.
+ * - Use `as_inner()` to validate non-null before performing raw round-trips.
+ *
+ * From Rust, use [`ArcHandle::try_clone`] to make a reference-counted copy.
+ * From the C FFI, the handle should probably be renamed to avoid generics
+ * bloat garbage, and a *_try_clone API should be provided.
+ *
+ * Use [`ArcHandle::drop_resource`] to drop the resource and move this handle
+ * into the empty handle state, which is the default state.
+ */
+typedef struct ddog_prof_ProfilesDictionary *ddog_prof_ProfilesDictionaryHandle;
+
 typedef struct ddog_prof_ManagedStringStorage {
   const void *inner;
 } ddog_prof_ManagedStringStorage;
@@ -685,6 +781,159 @@ typedef struct ddog_prof_Sample {
   struct ddog_prof_Slice_Label labels;
 } ddog_prof_Sample;
 
+/**
+ * Represents what StringIds point to. Its definition is intentionally
+ * obscured; the actual layout is being hidden. This is here so that
+ * cbindgen will generate a unique type as opposed to relying on `void *` or
+ * similar. We want StringId2, FunctionId2, and MappingId2 to all point to
+ * unique so that compilers will distinguish between them and provide some
+ * type safety.
+ */
+typedef struct ddog_prof_StringHeader {
+  uint8_t _0;
+} ddog_prof_StringHeader;
+
+/**
+ * An FFI-safe string ID where a null StringId2 maps to `StringRef::EMPTY`.
+ * The representation is ensured to be a  pointer for ABI stability, but
+ * callers should not generally dereference this pointer. When using the id,
+ * the caller needs to be sure that the `ProfilesDictionary` or string set it
+ * refers to is the same one that the operations are performed on; it is not
+ * generally guaranteed that ids from one dictionary/set can be used in
+ * 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.
+ */
+typedef struct ddog_prof_StringHeader *ddog_prof_StringId2;
+
+/**
+ * An FFI-safe version of the Mapping which allows null. Be sure to maintain
+ * layout-compatibility with it, except that StringId2 may be null.
+ */
+typedef struct ddog_prof_Mapping2 {
+  uint64_t memory_start;
+  uint64_t memory_limit;
+  uint64_t file_offset;
+  ddog_prof_StringId2 filename;
+  ddog_prof_StringId2 build_id;
+} ddog_prof_Mapping2;
+
+/**
+ * An FFI-safe representation of a "handle" to a mapping which has been
+ * stored in the `ProfilesDictionary`. The representation is ensured to be a
+ * pointer for ABI stability, but callers should not generally dereference
+ * this pointer. When using the id, the caller needs to be sure that the
+ * `ProfilesDictionary` it refers to is the same one that the operations are
+ * 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.
+ */
+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.
+ */
+typedef struct ddog_prof_Function2 {
+  ddog_prof_StringId2 name;
+  ddog_prof_StringId2 system_name;
+  ddog_prof_StringId2 file_name;
+} ddog_prof_Function2;
+
+/**
+ * An FFI-safe representation of a "handle" to a function which has been
+ * stored in the `ProfilesDictionary`. The representation is ensured to be a
+ * pointer for ABI stability, but callers should not generally dereference
+ * this pointer. When using the id, the caller needs to be sure that the
+ * `ProfilesDictionary` it refers to is the same one that the operations are
+ * 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.
+ */
+typedef struct ddog_prof_Function2 *ddog_prof_FunctionId2;
+
+typedef struct ddog_prof_Location2 {
+  ddog_prof_MappingId2 mapping;
+  ddog_prof_FunctionId2 function;
+  /**
+   * The instruction address for this location, if available.  It
+   * should be within [Mapping.memory_start...Mapping.memory_limit]
+   * for the corresponding mapping. A non-leaf address may be in the
+   * middle of a call instruction. It is up to display tools to find
+   * the beginning of the instruction if necessary.
+   */
+  uint64_t address;
+  int64_t line;
+} ddog_prof_Location2;
+
+typedef struct ddog_prof_Slice_Location2 {
+  /**
+   * 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_Location2 *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_Location2;
+
+typedef struct ddog_prof_Label2 {
+  ddog_prof_StringId2 key;
+  /**
+   * At most one of `.str` and `.num` should not be empty.
+   */
+  ddog_CharSlice str;
+  int64_t num;
+  /**
+   * Should only be present when num is present.
+   * Specifies the units of num.
+   * Use arbitrary string (for example, "requests") as a custom count unit.
+   * If no unit is specified, consumer may apply heuristic to deduce the unit.
+   * Consumers may also  interpret units like "bytes" and "kilobytes" as memory
+   * units and units like "seconds" and "nanoseconds" as time units,
+   * and apply appropriate unit conversions to these.
+   */
+  ddog_CharSlice num_unit;
+} ddog_prof_Label2;
+
+typedef struct ddog_prof_Slice_Label2 {
+  /**
+   * 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_Label2 *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_Label2;
+
+typedef struct ddog_prof_Sample2 {
+  /**
+   * The leaf is at locations[0].
+   */
+  struct ddog_prof_Slice_Location2 locations;
+  /**
+   * The type and unit of each value is defined by the corresponding
+   * entry in Profile.sample_type. All samples must have the same
+   * number of values, the same as the length of Profile.sample_type.
+   * When aggregating multiple samples into a single sample, the
+   * result has a list of values that is the element-wise sum of the
+   * lists of the originals.
+   */
+  struct ddog_Slice_I64 values;
+  /**
+   * label includes additional context for this sample. It can include
+   * things like a thread id, allocation size, etc
+   */
+  struct ddog_prof_Slice_Label2 labels;
+} ddog_prof_Sample2;
+
 typedef struct ddog_prof_Slice_Usize {
   /**
    * Should be non-null and suitably aligned for the underlying type. It is
@@ -1142,14 +1391,43 @@ typedef enum ddog_ConfigurationOrigin {
   DDOG_CONFIGURATION_ORIGIN_DEFAULT,
   DDOG_CONFIGURATION_ORIGIN_LOCAL_STABLE_CONFIG,
   DDOG_CONFIGURATION_ORIGIN_FLEET_STABLE_CONFIG,
+  DDOG_CONFIGURATION_ORIGIN_CALCULATED,
 } ddog_ConfigurationOrigin;
 
+typedef enum ddog_TelemetryWorkerBuilderEndpointProperty {
+  DDOG_TELEMETRY_WORKER_BUILDER_ENDPOINT_PROPERTY_CONFIG_ENDPOINT,
+} ddog_TelemetryWorkerBuilderEndpointProperty;
+
+typedef enum ddog_TelemetryWorkerBuilderStrProperty {
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_SERVICE_VERSION,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_ENV,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_RUNTIME_NAME,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_RUNTIME_VERSION,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_RUNTIME_PATCHES,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_HOST_CONTAINER_ID,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_HOST_OS,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_HOST_KERNEL_NAME,
+  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_TelemetryWorkerBuilderStrProperty;
+
+typedef enum ddog_TelemetryWorkerBuilderBoolProperty {
+  DDOG_TELEMETRY_WORKER_BUILDER_BOOL_PROPERTY_CONFIG_TELEMETRY_DEBUG_LOGGING_ENABLED,
+} ddog_TelemetryWorkerBuilderBoolProperty;
+
 typedef enum ddog_LogLevel {
   DDOG_LOG_LEVEL_ERROR,
   DDOG_LOG_LEVEL_WARN,
   DDOG_LOG_LEVEL_DEBUG,
 } ddog_LogLevel;
 
+typedef enum ddog_MetricType {
+  DDOG_METRIC_TYPE_GAUGE,
+  DDOG_METRIC_TYPE_COUNT,
+  DDOG_METRIC_TYPE_DISTRIBUTION,
+} ddog_MetricType;
+
 typedef enum ddog_MetricNamespace {
   DDOG_METRIC_NAMESPACE_TRACERS,
   DDOG_METRIC_NAMESPACE_PROFILERS,
@@ -1164,34 +1442,6 @@ typedef enum ddog_MetricNamespace {
   DDOG_METRIC_NAMESPACE_SIDECAR,
 } ddog_MetricNamespace;
 
-typedef enum ddog_MetricType {
-  DDOG_METRIC_TYPE_GAUGE,
-  DDOG_METRIC_TYPE_COUNT,
-  DDOG_METRIC_TYPE_DISTRIBUTION,
-} ddog_MetricType;
-
-typedef enum ddog_TelemetryWorkerBuilderBoolProperty {
-  DDOG_TELEMETRY_WORKER_BUILDER_BOOL_PROPERTY_CONFIG_TELEMETRY_DEBUG_LOGGING_ENABLED,
-} ddog_TelemetryWorkerBuilderBoolProperty;
-
-typedef enum ddog_TelemetryWorkerBuilderEndpointProperty {
-  DDOG_TELEMETRY_WORKER_BUILDER_ENDPOINT_PROPERTY_CONFIG_ENDPOINT,
-} ddog_TelemetryWorkerBuilderEndpointProperty;
-
-typedef enum ddog_TelemetryWorkerBuilderStrProperty {
-  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_SERVICE_VERSION,
-  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_ENV,
-  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_RUNTIME_NAME,
-  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_RUNTIME_VERSION,
-  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_RUNTIME_PATCHES,
-  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_HOST_CONTAINER_ID,
-  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_HOST_OS,
-  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_HOST_KERNEL_NAME,
-  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_TelemetryWorkerBuilderStrProperty;
-
 typedef struct ddog_TelemetryWorkerBuilder ddog_TelemetryWorkerBuilder;
 
 /**
@@ -1205,6 +1455,20 @@ typedef struct ddog_TelemetryWorkerBuilder ddog_TelemetryWorkerBuilder;
  */
 typedef struct ddog_TelemetryWorkerHandle ddog_TelemetryWorkerHandle;
 
+typedef enum ddog_Option_U64_Tag {
+  DDOG_OPTION_U64_SOME_U64,
+  DDOG_OPTION_U64_NONE_U64,
+} ddog_Option_U64_Tag;
+
+typedef struct ddog_Option_U64 {
+  ddog_Option_U64_Tag tag;
+  union {
+    struct {
+      uint64_t some;
+    };
+  };
+} ddog_Option_U64;
+
 typedef enum ddog_Option_Bool_Tag {
   DDOG_OPTION_BOOL_SOME_BOOL,
   DDOG_OPTION_BOOL_NONE_BOOL,
@@ -1455,6 +1719,20 @@ typedef struct ddog_Result_TracerMemfdHandle {
   };
 } ddog_Result_TracerMemfdHandle;
 
+/**
+ * Target for standard stream output.
+ */
+typedef enum ddog_StdTarget {
+  /**
+   * Write to standard output (stdout).
+   */
+  DDOG_STD_TARGET_OUT,
+  /**
+   * Write to standard error (stderr).
+   */
+  DDOG_STD_TARGET_ERR,
+} ddog_StdTarget;
+
 /**
  * Log level for filtering log events.
  */
@@ -1491,20 +1769,6 @@ typedef enum ddog_LogEventLevel {
   DDOG_LOG_EVENT_LEVEL_ERROR = 4,
 } ddog_LogEventLevel;
 
-/**
- * Target for standard stream output.
- */
-typedef enum ddog_StdTarget {
-  /**
-   * Write to standard output (stdout).
-   */
-  DDOG_STD_TARGET_OUT,
-  /**
-   * Write to standard error (stderr).
-   */
-  DDOG_STD_TARGET_ERR,
-} ddog_StdTarget;
-
 /**
  * Configuration for standard stream output.
  */
@@ -1558,37 +1822,238 @@ typedef struct ddsketch_Handle_DDSketch {
   struct ddsketch_DDSketch *inner;
 } ddsketch_Handle_DDSketch;
 
-typedef enum ddog_crasht_BuildIdType {
-  DDOG_CRASHT_BUILD_ID_TYPE_GNU,
-  DDOG_CRASHT_BUILD_ID_TYPE_GO,
-  DDOG_CRASHT_BUILD_ID_TYPE_PDB,
-  DDOG_CRASHT_BUILD_ID_TYPE_SHA1,
-} ddog_crasht_BuildIdType;
+typedef enum ddog_ffe_ExpectedFlagType {
+  DDOG_FFE_EXPECTED_FLAG_TYPE_STRING,
+  DDOG_FFE_EXPECTED_FLAG_TYPE_INTEGER,
+  DDOG_FFE_EXPECTED_FLAG_TYPE_FLOAT,
+  DDOG_FFE_EXPECTED_FLAG_TYPE_BOOLEAN,
+  DDOG_FFE_EXPECTED_FLAG_TYPE_OBJECT,
+  DDOG_FFE_EXPECTED_FLAG_TYPE_NUMBER,
+  DDOG_FFE_EXPECTED_FLAG_TYPE_ANY,
+} ddog_ffe_ExpectedFlagType;
+
+typedef enum ddog_ffe_Reason {
+  DDOG_FFE_REASON_STATIC,
+  DDOG_FFE_REASON_DEFAULT,
+  DDOG_FFE_REASON_TARGETING_MATCH,
+  DDOG_FFE_REASON_SPLIT,
+  DDOG_FFE_REASON_DISABLED,
+  DDOG_FFE_REASON_ERROR,
+} ddog_ffe_Reason;
+
+typedef enum ddog_ffe_ErrorCode {
+  DDOG_FFE_ERROR_CODE_OK,
+  DDOG_FFE_ERROR_CODE_TYPE_MISMATCH,
+  DDOG_FFE_ERROR_CODE_PARSE_ERROR,
+  DDOG_FFE_ERROR_CODE_FLAG_NOT_FOUND,
+  DDOG_FFE_ERROR_CODE_TARGETING_KEY_MISSING,
+  DDOG_FFE_ERROR_CODE_INVALID_CONTEXT,
+  DDOG_FFE_ERROR_CODE_PROVIDER_NOT_READY,
+  DDOG_FFE_ERROR_CODE_GENERAL,
+} ddog_ffe_ErrorCode;
 
 /**
- * Result type for runtime callback registration
+ * Remote configuration for the feature flagging client. It's a central piece that defines client
+ * behavior.
  */
-typedef enum ddog_crasht_CallbackResult {
-  DDOG_CRASHT_CALLBACK_RESULT_OK,
-  DDOG_CRASHT_CALLBACK_RESULT_ERROR,
-} ddog_crasht_CallbackResult;
+typedef struct ddog_ffe_Configuration ddog_ffe_Configuration;
 
-typedef enum ddog_crasht_DemangleOptions {
-  DDOG_CRASHT_DEMANGLE_OPTIONS_COMPLETE,
-  DDOG_CRASHT_DEMANGLE_OPTIONS_NAME_ONLY,
-} ddog_crasht_DemangleOptions;
+/**
+ * `Subject` is a bundle of subject attributes and a key.
+ */
+typedef struct ddog_ffe_EvaluationContext ddog_ffe_EvaluationContext;
 
-typedef enum ddog_crasht_ErrorKind {
-  DDOG_CRASHT_ERROR_KIND_PANIC,
-  DDOG_CRASHT_ERROR_KIND_UNHANDLED_EXCEPTION,
-  DDOG_CRASHT_ERROR_KIND_UNIX_SIGNAL,
-} ddog_crasht_ErrorKind;
+/**
+ * Opaque type representing a result of evaluation.
+ */
+typedef struct ddog_ffe_ResolutionDetails ddog_ffe_ResolutionDetails;
 
-typedef enum ddog_crasht_FileType {
-  DDOG_CRASHT_FILE_TYPE_APK,
-  DDOG_CRASHT_FILE_TYPE_ELF,
-  DDOG_CRASHT_FILE_TYPE_PE,
-} ddog_crasht_FileType;
+/**
+ * An opaque handle for a resource. The inner fields must not be dereferenced.
+ *
+ * This is similar to `libdd_common_ffi::Handle` but only allows shared access to internal
+ * resource, so it's safe to share between thread or access concurrently (if the underlying type
+ * is).
+ *
+ * # Ownership
+ *
+ * `Handle::free()` must be called exactly once on any created Handle. Failure to do that will
+ * result in a memory leak.
+ */
+typedef struct ddog_ffe_ResolutionDetails *ddog_ffe_Handle_ResolutionDetails;
+
+/**
+ * An opaque handle for a resource. The inner fields must not be dereferenced.
+ *
+ * This is similar to `libdd_common_ffi::Handle` but only allows shared access to internal
+ * resource, so it's safe to share between thread or access concurrently (if the underlying type
+ * is).
+ *
+ * # Ownership
+ *
+ * `Handle::free()` must be called exactly once on any created Handle. Failure to do that will
+ * result in a memory leak.
+ */
+typedef struct ddog_ffe_Configuration *ddog_ffe_Handle_Configuration;
+
+/**
+ * An opaque handle for a resource. The inner fields must not be dereferenced.
+ *
+ * This is similar to `libdd_common_ffi::Handle` but only allows shared access to internal
+ * resource, so it's safe to share between thread or access concurrently (if the underlying type
+ * is).
+ *
+ * # Ownership
+ *
+ * `Handle::free()` must be called exactly once on any created Handle. Failure to do that will
+ * result in a memory leak.
+ */
+typedef struct ddog_ffe_EvaluationContext *ddog_ffe_Handle_EvaluationContext;
+
+/**
+ * A string that has been borrowed. Beware that it is NOT nul-terminated!
+ *
+ * # Ownership
+ *
+ * This string is non-owning. You must not free `ptr`.
+ *
+ * # Safety
+ *
+ * - The string is not NUL-terminated, it can only be used with API that accept the len as an
+ *   additional parameter.
+ * - The value must not be used after the value it borrowed from has been moved, modified, or
+ *   freed.
+ */
+typedef struct ddog_ffe_BorrowedStr {
+  /**
+   * May be NULL if `len` is `0`.
+   */
+  const uint8_t *ptr;
+  uintptr_t len;
+} ddog_ffe_BorrowedStr;
+
+typedef enum ddog_ffe_VariantValue_Tag {
+  /**
+   * Evaluation did not produce any value.
+   */
+  DDOG_FFE_VARIANT_VALUE_NONE,
+  DDOG_FFE_VARIANT_VALUE_STRING,
+  DDOG_FFE_VARIANT_VALUE_INTEGER,
+  DDOG_FFE_VARIANT_VALUE_FLOAT,
+  DDOG_FFE_VARIANT_VALUE_BOOLEAN,
+  DDOG_FFE_VARIANT_VALUE_OBJECT,
+} ddog_ffe_VariantValue_Tag;
+
+typedef struct ddog_ffe_VariantValue {
+  ddog_ffe_VariantValue_Tag tag;
+  union {
+    struct {
+      struct ddog_ffe_BorrowedStr string;
+    };
+    struct {
+      int64_t integer;
+    };
+    struct {
+      double float_;
+    };
+    struct {
+      bool boolean;
+    };
+    struct {
+      struct ddog_ffe_BorrowedStr object;
+    };
+  };
+} ddog_ffe_VariantValue;
+
+typedef struct ddog_ffe_KeyValue_BorrowedStr {
+  struct ddog_ffe_BorrowedStr key;
+  struct ddog_ffe_BorrowedStr value;
+} ddog_ffe_KeyValue_BorrowedStr;
+
+typedef struct ddog_ffe_ArrayMap_BorrowedStr {
+  const struct ddog_ffe_KeyValue_BorrowedStr *elements;
+  uintptr_t count;
+} ddog_ffe_ArrayMap_BorrowedStr;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_ffe_Result_HandleConfiguration_Tag {
+  DDOG_FFE_RESULT_HANDLE_CONFIGURATION_OK_HANDLE_CONFIGURATION,
+  DDOG_FFE_RESULT_HANDLE_CONFIGURATION_ERR_HANDLE_CONFIGURATION,
+} ddog_ffe_Result_HandleConfiguration_Tag;
+
+typedef struct ddog_ffe_Result_HandleConfiguration {
+  ddog_ffe_Result_HandleConfiguration_Tag tag;
+  union {
+    struct {
+      ddog_ffe_Handle_Configuration ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_ffe_Result_HandleConfiguration;
+
+/**
+ * # Safety
+ * - `string` must be a valid C string.
+ */
+typedef enum ddog_ffe_AttributeValue_Tag {
+  DDOG_FFE_ATTRIBUTE_VALUE_STRING,
+  DDOG_FFE_ATTRIBUTE_VALUE_NUMBER,
+  DDOG_FFE_ATTRIBUTE_VALUE_BOOLEAN,
+} ddog_ffe_AttributeValue_Tag;
+
+typedef struct ddog_ffe_AttributeValue {
+  ddog_ffe_AttributeValue_Tag tag;
+  union {
+    struct {
+      const char *string;
+    };
+    struct {
+      double number;
+    };
+    struct {
+      bool boolean;
+    };
+  };
+} ddog_ffe_AttributeValue;
+
+/**
+ * Represents a key-value pair for attributes.
+ *
+ * # Safety
+ * - `name` must be a valid C string.
+ */
+typedef struct ddog_ffe_AttributePair {
+  const char *name;
+  struct ddog_ffe_AttributeValue value;
+} ddog_ffe_AttributePair;
+
+/**
+ * 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_crasht_StacktraceCollection {
+  /**
+   * Stacktrace collection occurs in the
+   */
+  DDOG_CRASHT_STACKTRACE_COLLECTION_DISABLED,
+  DDOG_CRASHT_STACKTRACE_COLLECTION_WITHOUT_SYMBOLS,
+  /**
+   * This option uses `backtrace::resolve_frame_unsynchronized()` to gather symbol information
+   * and also unwind inlined functions. Enabling this feature will not only provide symbolic
+   * details, but may also yield additional or less stack frames compared to other
+   * configurations.
+   */
+  DDOG_CRASHT_STACKTRACE_COLLECTION_ENABLED_WITH_INPROCESS_SYMBOLS,
+  DDOG_CRASHT_STACKTRACE_COLLECTION_ENABLED_WITH_SYMBOLS_IN_RECEIVER,
+} ddog_crasht_StacktraceCollection;
 
 /**
  * This enum represents operations a the tracked library might be engaged in.
@@ -1613,6 +2078,12 @@ typedef enum ddog_crasht_OpTypes {
   DDOG_CRASHT_OP_TYPES_SIZE,
 } ddog_crasht_OpTypes;
 
+typedef enum ddog_crasht_ErrorKind {
+  DDOG_CRASHT_ERROR_KIND_PANIC,
+  DDOG_CRASHT_ERROR_KIND_UNHANDLED_EXCEPTION,
+  DDOG_CRASHT_ERROR_KIND_UNIX_SIGNAL,
+} ddog_crasht_ErrorKind;
+
 /**
  * See https://man7.org/linux/man-pages/man2/sigaction.2.html
  * MUST REMAIN IN SYNC WITH THE ENUM IN emit_sigcodes.c
@@ -1685,28 +2156,31 @@ typedef enum ddog_crasht_SignalNames {
   DDOG_CRASHT_SIGNAL_NAMES_UNKNOWN,
 } ddog_crasht_SignalNames;
 
+typedef enum ddog_crasht_BuildIdType {
+  DDOG_CRASHT_BUILD_ID_TYPE_GNU,
+  DDOG_CRASHT_BUILD_ID_TYPE_GO,
+  DDOG_CRASHT_BUILD_ID_TYPE_PDB,
+  DDOG_CRASHT_BUILD_ID_TYPE_SHA1,
+} ddog_crasht_BuildIdType;
+
+typedef enum ddog_crasht_FileType {
+  DDOG_CRASHT_FILE_TYPE_APK,
+  DDOG_CRASHT_FILE_TYPE_ELF,
+  DDOG_CRASHT_FILE_TYPE_PE,
+} ddog_crasht_FileType;
+
+typedef enum ddog_crasht_DemangleOptions {
+  DDOG_CRASHT_DEMANGLE_OPTIONS_COMPLETE,
+  DDOG_CRASHT_DEMANGLE_OPTIONS_NAME_ONLY,
+} ddog_crasht_DemangleOptions;
+
 /**
- * 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.
+ * Result type for runtime callback registration
  */
-typedef enum ddog_crasht_StacktraceCollection {
-  /**
-   * Stacktrace collection occurs in the
-   */
-  DDOG_CRASHT_STACKTRACE_COLLECTION_DISABLED,
-  DDOG_CRASHT_STACKTRACE_COLLECTION_WITHOUT_SYMBOLS,
-  /**
-   * This option uses `backtrace::resolve_frame_unsynchronized()` to gather symbol information
-   * and also unwind inlined functions. Enabling this feature will not only provide symbolic
-   * details, but may also yield additional or less stack frames compared to other
-   * configurations.
-   */
-  DDOG_CRASHT_STACKTRACE_COLLECTION_ENABLED_WITH_INPROCESS_SYMBOLS,
-  DDOG_CRASHT_STACKTRACE_COLLECTION_ENABLED_WITH_SYMBOLS_IN_RECEIVER,
-} ddog_crasht_StacktraceCollection;
+typedef enum ddog_crasht_CallbackResult {
+  DDOG_CRASHT_CALLBACK_RESULT_OK,
+  DDOG_CRASHT_CALLBACK_RESULT_ERROR,
+} ddog_crasht_CallbackResult;
 
 typedef struct ddog_crasht_CrashInfo ddog_crasht_CrashInfo;
 
@@ -1886,13 +2360,17 @@ typedef struct  ddog_crasht_CrashInfoBuilder_NewResult {
   };
 }  ddog_crasht_CrashInfoBuilder_NewResult;
 
-typedef enum ddog_crasht_CrashInfo_NewResult_Tag {
-  DDOG_CRASHT_CRASH_INFO_NEW_RESULT_OK,
-  DDOG_CRASHT_CRASH_INFO_NEW_RESULT_ERR,
-} ddog_crasht_CrashInfo_NewResult_Tag;
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_crasht_Result_HandleCrashInfo_Tag {
+  DDOG_CRASHT_RESULT_HANDLE_CRASH_INFO_OK_HANDLE_CRASH_INFO,
+  DDOG_CRASHT_RESULT_HANDLE_CRASH_INFO_ERR_HANDLE_CRASH_INFO,
+} ddog_crasht_Result_HandleCrashInfo_Tag;
 
-typedef struct ddog_crasht_CrashInfo_NewResult {
-  ddog_crasht_CrashInfo_NewResult_Tag tag;
+typedef struct ddog_crasht_Result_HandleCrashInfo {
+  ddog_crasht_Result_HandleCrashInfo_Tag tag;
   union {
     struct {
       struct ddog_crasht_Handle_CrashInfo ok;
@@ -1901,7 +2379,9 @@ typedef struct ddog_crasht_CrashInfo_NewResult {
       struct ddog_Error err;
     };
   };
-} ddog_crasht_CrashInfo_NewResult;
+} ddog_crasht_Result_HandleCrashInfo;
+
+typedef struct ddog_crasht_Result_HandleCrashInfo ddog_crasht_CrashInfo_NewResult;
 
 typedef struct ddog_crasht_OsInfo {
   ddog_CharSlice architecture;