libdatadog 16.0.1.1.0-aarch64-linux → 19.1.0.1.0-aarch64-linux

data/vendor/{libdatadog-16.0.1 → libdatadog-19.1.0}/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl/include/datadog/common.h

@@ -257,14 +257,18 @@ typedef struct ddog_Vec_Tag_ParseResult {
   struct ddog_Error *error_message;
 } ddog_Vec_Tag_ParseResult;
 
-typedef struct ddog_CancellationToken ddog_CancellationToken;
+typedef struct ddog_prof_EncodedProfile ddog_prof_EncodedProfile;
 
 typedef struct ddog_prof_Exporter ddog_prof_Exporter;
 
-typedef struct ddog_prof_ProfiledEndpointsStats ddog_prof_ProfiledEndpointsStats;
-
 typedef struct ddog_prof_Exporter_Request ddog_prof_Exporter_Request;
 
+/**
+ * A tag is a combination of a wire_type, stored in the least significant
+ * three bits, and the field number that is defined in the .proto file.
+ */
+typedef struct ddog_Tag ddog_Tag;
+
 typedef struct ddog_Slice_U8 {
   /**
    * Should be non-null and suitably aligned for the underlying type. It is
@@ -327,84 +331,124 @@ typedef struct ddog_prof_Endpoint {
   };
 } ddog_prof_Endpoint;
 
-typedef enum ddog_prof_Exporter_NewResult_Tag {
-  DDOG_PROF_EXPORTER_NEW_RESULT_OK,
-  DDOG_PROF_EXPORTER_NEW_RESULT_ERR,
-} ddog_prof_Exporter_NewResult_Tag;
+/**
+ * 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_ProfileExporter {
+  struct ddog_prof_Exporter *inner;
+} ddog_prof_ProfileExporter;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_ProfileExporter_Result_Tag {
+  DDOG_PROF_PROFILE_EXPORTER_RESULT_OK_HANDLE_PROFILE_EXPORTER,
+  DDOG_PROF_PROFILE_EXPORTER_RESULT_ERR_HANDLE_PROFILE_EXPORTER,
+} ddog_prof_ProfileExporter_Result_Tag;
 
-typedef struct ddog_prof_Exporter_NewResult {
-  ddog_prof_Exporter_NewResult_Tag tag;
+typedef struct ddog_prof_ProfileExporter_Result {
+  ddog_prof_ProfileExporter_Result_Tag tag;
   union {
     struct {
-      struct ddog_prof_Exporter *ok;
+      struct ddog_prof_ProfileExporter ok;
     };
     struct {
       struct ddog_Error err;
     };
   };
-} ddog_prof_Exporter_NewResult;
+} ddog_prof_ProfileExporter_Result;
 
-typedef enum ddog_prof_Option_Error_Tag {
-  DDOG_PROF_OPTION_ERROR_SOME_ERROR,
-  DDOG_PROF_OPTION_ERROR_NONE_ERROR,
-} ddog_prof_Option_Error_Tag;
+/**
+ * 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_prof_Option_Error {
-  ddog_prof_Option_Error_Tag tag;
+typedef struct ddog_VoidResult {
+  ddog_VoidResult_Tag tag;
   union {
     struct {
-      struct ddog_Error some;
+      struct ddog_Error err;
     };
   };
-} ddog_prof_Option_Error;
+} ddog_VoidResult;
 
-typedef struct ddog_prof_Option_Error ddog_prof_MaybeError;
+/**
+ * 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_Request {
+  struct ddog_prof_Exporter_Request *inner;
+} ddog_prof_Request;
 
-typedef enum ddog_prof_Exporter_Request_BuildResult_Tag {
-  DDOG_PROF_EXPORTER_REQUEST_BUILD_RESULT_OK,
-  DDOG_PROF_EXPORTER_REQUEST_BUILD_RESULT_ERR,
-} ddog_prof_Exporter_Request_BuildResult_Tag;
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_Request_Result_Tag {
+  DDOG_PROF_REQUEST_RESULT_OK_HANDLE_REQUEST,
+  DDOG_PROF_REQUEST_RESULT_ERR_HANDLE_REQUEST,
+} ddog_prof_Request_Result_Tag;
 
-typedef struct ddog_prof_Exporter_Request_BuildResult {
-  ddog_prof_Exporter_Request_BuildResult_Tag tag;
+typedef struct ddog_prof_Request_Result {
+  ddog_prof_Request_Result_Tag tag;
   union {
     struct {
-      struct ddog_prof_Exporter_Request *ok;
+      struct ddog_prof_Request ok;
     };
     struct {
       struct ddog_Error err;
     };
   };
-} ddog_prof_Exporter_Request_BuildResult;
+} ddog_prof_Request_Result;
 
 /**
- * Represents time since the Unix Epoch in seconds plus nanoseconds.
+ * 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_Timespec {
-  int64_t seconds;
-  uint32_t nanoseconds;
-} ddog_Timespec;
+typedef struct ddog_prof_EncodedProfile {
+  struct ddog_prof_EncodedProfile *inner;
+} ddog_prof_EncodedProfile;
 
 typedef struct ddog_HttpStatus {
   uint16_t code;
 } ddog_HttpStatus;
 
-typedef enum ddog_prof_Exporter_SendResult_Tag {
-  DDOG_PROF_EXPORTER_SEND_RESULT_HTTP_RESPONSE,
-  DDOG_PROF_EXPORTER_SEND_RESULT_ERR,
-} ddog_prof_Exporter_SendResult_Tag;
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_Result_HttpStatus_Tag {
+  DDOG_PROF_RESULT_HTTP_STATUS_OK_HTTP_STATUS,
+  DDOG_PROF_RESULT_HTTP_STATUS_ERR_HTTP_STATUS,
+} ddog_prof_Result_HttpStatus_Tag;
 
-typedef struct ddog_prof_Exporter_SendResult {
-  ddog_prof_Exporter_SendResult_Tag tag;
+typedef struct ddog_prof_Result_HttpStatus {
+  ddog_prof_Result_HttpStatus_Tag tag;
   union {
     struct {
-      struct ddog_HttpStatus http_response;
+      struct ddog_HttpStatus ok;
     };
     struct {
       struct ddog_Error err;
     };
   };
-} ddog_prof_Exporter_SendResult;
+} ddog_prof_Result_HttpStatus;
+
+typedef struct ddog_OpaqueCancellationToken ddog_prof_TokioCancellationToken;
+
+/**
+ * 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_CancellationToken {
+  ddog_prof_TokioCancellationToken *inner;
+} ddog_CancellationToken;
 
 /**
  * Represents a profile. Do not access its member for any reason, only use
@@ -537,10 +581,6 @@ typedef struct ddog_prof_Function {
    */
   ddog_CharSlice filename;
   struct ddog_prof_ManagedStringId filename_id;
-  /**
-   * Line number in source file.
-   */
-  int64_t start_line;
 } ddog_prof_Function;
 
 typedef struct ddog_prof_Location {
@@ -659,12 +699,26 @@ typedef struct ddog_prof_Slice_Usize {
   uintptr_t len;
 } ddog_prof_Slice_Usize;
 
-typedef struct ddog_prof_EncodedProfile {
-  struct ddog_Timespec start;
-  struct ddog_Timespec end;
-  struct ddog_Vec_U8 buffer;
-  struct ddog_prof_ProfiledEndpointsStats *endpoints_stats;
-} ddog_prof_EncodedProfile;
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_Result_ByteSlice_Tag {
+  DDOG_PROF_RESULT_BYTE_SLICE_OK_BYTE_SLICE,
+  DDOG_PROF_RESULT_BYTE_SLICE_ERR_BYTE_SLICE,
+} ddog_prof_Result_ByteSlice_Tag;
+
+typedef struct ddog_prof_Result_ByteSlice {
+  ddog_prof_Result_ByteSlice_Tag tag;
+  union {
+    struct {
+      ddog_ByteSlice ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_Result_ByteSlice;
 
 typedef enum ddog_prof_Profile_SerializeResult_Tag {
   DDOG_PROF_PROFILE_SERIALIZE_RESULT_OK,
@@ -683,53 +737,205 @@ typedef struct ddog_prof_Profile_SerializeResult {
   };
 } ddog_prof_Profile_SerializeResult;
 
-typedef enum ddog_prof_ManagedStringStorageNewResult_Tag {
-  DDOG_PROF_MANAGED_STRING_STORAGE_NEW_RESULT_OK,
-  DDOG_PROF_MANAGED_STRING_STORAGE_NEW_RESULT_ERR,
-} ddog_prof_ManagedStringStorageNewResult_Tag;
+/**
+ * Represents time since the Unix Epoch in seconds plus nanoseconds.
+ */
+typedef struct ddog_Timespec {
+  int64_t seconds;
+  uint32_t nanoseconds;
+} ddog_Timespec;
 
-typedef struct ddog_prof_ManagedStringStorageNewResult {
-  ddog_prof_ManagedStringStorageNewResult_Tag tag;
+/**
+ * Opaque identifier for the profiler generation
+ */
+typedef struct ddog_prof_Generation {
+  uint64_t id;
+} ddog_prof_Generation;
+
+typedef struct OpaqueFunctionId {
+  uint32_t _0;
+} OpaqueFunctionId;
+
+typedef struct ddog_prof_FunctionId {
+  struct ddog_prof_Generation generation;
+  struct OpaqueFunctionId id;
+} ddog_prof_FunctionId;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_FunctionId_Result_Tag {
+  DDOG_PROF_FUNCTION_ID_RESULT_OK_GENERATIONAL_ID_FUNCTION_ID,
+  DDOG_PROF_FUNCTION_ID_RESULT_ERR_GENERATIONAL_ID_FUNCTION_ID,
+} ddog_prof_FunctionId_Result_Tag;
+
+typedef struct ddog_prof_FunctionId_Result {
+  ddog_prof_FunctionId_Result_Tag tag;
   union {
     struct {
-      struct ddog_prof_ManagedStringStorage ok;
+      struct ddog_prof_FunctionId ok;
     };
     struct {
       struct ddog_Error err;
     };
   };
-} ddog_prof_ManagedStringStorageNewResult;
+} ddog_prof_FunctionId_Result;
 
-typedef enum ddog_prof_ManagedStringStorageInternResult_Tag {
-  DDOG_PROF_MANAGED_STRING_STORAGE_INTERN_RESULT_OK,
-  DDOG_PROF_MANAGED_STRING_STORAGE_INTERN_RESULT_ERR,
-} ddog_prof_ManagedStringStorageInternResult_Tag;
+/**
+ * Represents an offset into the Profile's string table. Note that it cannot
+ * exceed u32 because an entire protobuf message must not be larger than or
+ * equal to 2 GiB. By the time you encode the tag and length prefix for each
+ * string, there's no way to get this many unique-ish strings without first
+ * exceeding the protobuf 2 GiB limit.
+ *
+ * A value of 0 means "no string" or "empty string" (they are synonymous).
+ */
+typedef struct OpaqueStringId {
+  uint32_t _0;
+} OpaqueStringId;
+#define OpaqueStringId_ZERO (OpaqueStringId){ ._0 = 0 }
 
-typedef struct ddog_prof_ManagedStringStorageInternResult {
-  ddog_prof_ManagedStringStorageInternResult_Tag tag;
+typedef struct OpaqueStringId OpaqueStringId;
+
+typedef struct ddog_prof_StringId {
+  struct ddog_prof_Generation generation;
+  OpaqueStringId id;
+} ddog_prof_StringId;
+
+typedef struct OpaqueLabelId {
+  uint32_t _0;
+} OpaqueLabelId;
+
+typedef struct ddog_prof_LabelId {
+  struct ddog_prof_Generation generation;
+  struct OpaqueLabelId id;
+} ddog_prof_LabelId;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_LabelId_Result_Tag {
+  DDOG_PROF_LABEL_ID_RESULT_OK_GENERATIONAL_ID_LABEL_ID,
+  DDOG_PROF_LABEL_ID_RESULT_ERR_GENERATIONAL_ID_LABEL_ID,
+} ddog_prof_LabelId_Result_Tag;
+
+typedef struct ddog_prof_LabelId_Result {
+  ddog_prof_LabelId_Result_Tag tag;
   union {
     struct {
-      struct ddog_prof_ManagedStringId ok;
+      struct ddog_prof_LabelId ok;
     };
     struct {
       struct ddog_Error err;
     };
   };
-} ddog_prof_ManagedStringStorageInternResult;
+} ddog_prof_LabelId_Result;
 
-typedef struct ddog_prof_Slice_CharSlice {
+typedef struct OpaqueLabelSetId {
+  uint32_t _0;
+} OpaqueLabelSetId;
+
+typedef struct ddog_prof_LabelSetId {
+  struct ddog_prof_Generation generation;
+  struct OpaqueLabelSetId id;
+} ddog_prof_LabelSetId;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_LabelSetId_Result_Tag {
+  DDOG_PROF_LABEL_SET_ID_RESULT_OK_GENERATIONAL_ID_LABEL_SET_ID,
+  DDOG_PROF_LABEL_SET_ID_RESULT_ERR_GENERATIONAL_ID_LABEL_SET_ID,
+} ddog_prof_LabelSetId_Result_Tag;
+
+typedef struct ddog_prof_LabelSetId_Result {
+  ddog_prof_LabelSetId_Result_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_LabelSetId ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_LabelSetId_Result;
+
+typedef struct ddog_prof_Slice_LabelId {
   /**
    * 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 ddog_CharSlice *ptr;
+  const struct ddog_prof_LabelId *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;
+} ddog_prof_Slice_LabelId;
+
+typedef struct OpaqueLocationId {
+  uint32_t _0;
+} OpaqueLocationId;
+
+typedef struct ddog_prof_LocationId {
+  struct ddog_prof_Generation generation;
+  struct OpaqueLocationId id;
+} ddog_prof_LocationId;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_LocationId_Result_Tag {
+  DDOG_PROF_LOCATION_ID_RESULT_OK_GENERATIONAL_ID_LOCATION_ID,
+  DDOG_PROF_LOCATION_ID_RESULT_ERR_GENERATIONAL_ID_LOCATION_ID,
+} ddog_prof_LocationId_Result_Tag;
+
+typedef struct ddog_prof_LocationId_Result {
+  ddog_prof_LocationId_Result_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_LocationId ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_LocationId_Result;
+
+typedef struct OpaqueMappingId {
+  uint32_t _0;
+} OpaqueMappingId;
+
+typedef struct ddog_prof_MappingId {
+  struct ddog_prof_Generation generation;
+  struct OpaqueMappingId id;
+} ddog_prof_MappingId;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_StringId_Result_Tag {
+  DDOG_PROF_STRING_ID_RESULT_OK_GENERATIONAL_ID_STRING_ID,
+  DDOG_PROF_STRING_ID_RESULT_ERR_GENERATIONAL_ID_STRING_ID,
+} ddog_prof_StringId_Result_Tag;
+
+typedef struct ddog_prof_StringId_Result {
+  ddog_prof_StringId_Result_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_StringId ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_StringId_Result;
 
 typedef struct ddog_prof_Slice_ManagedStringId {
   /**
@@ -745,6 +951,170 @@ typedef struct ddog_prof_Slice_ManagedStringId {
   uintptr_t len;
 } ddog_prof_Slice_ManagedStringId;
 
+typedef struct ddog_prof_MutSlice_GenerationalIdStringId {
+  /**
+   * 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.
+   */
+  struct ddog_prof_StringId *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_prof_MutSlice_GenerationalIdStringId;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_MappingId_Result_Tag {
+  DDOG_PROF_MAPPING_ID_RESULT_OK_GENERATIONAL_ID_MAPPING_ID,
+  DDOG_PROF_MAPPING_ID_RESULT_ERR_GENERATIONAL_ID_MAPPING_ID,
+} ddog_prof_MappingId_Result_Tag;
+
+typedef struct ddog_prof_MappingId_Result {
+  ddog_prof_MappingId_Result_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_MappingId ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_MappingId_Result;
+
+typedef struct OpaqueStackTraceId {
+  uint32_t _0;
+} OpaqueStackTraceId;
+
+typedef struct ddog_prof_StackTraceId {
+  struct ddog_prof_Generation generation;
+  struct OpaqueStackTraceId id;
+} ddog_prof_StackTraceId;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_StackTraceId_Result_Tag {
+  DDOG_PROF_STACK_TRACE_ID_RESULT_OK_GENERATIONAL_ID_STACK_TRACE_ID,
+  DDOG_PROF_STACK_TRACE_ID_RESULT_ERR_GENERATIONAL_ID_STACK_TRACE_ID,
+} ddog_prof_StackTraceId_Result_Tag;
+
+typedef struct ddog_prof_StackTraceId_Result {
+  ddog_prof_StackTraceId_Result_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_StackTraceId ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_StackTraceId_Result;
+
+typedef struct ddog_prof_Slice_LocationId {
+  /**
+   * 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_LocationId *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_LocationId;
+
+typedef struct ddog_prof_Slice_CharSlice {
+  /**
+   * 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 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;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_prof_Result_Generation_Tag {
+  DDOG_PROF_RESULT_GENERATION_OK_GENERATION,
+  DDOG_PROF_RESULT_GENERATION_ERR_GENERATION,
+} ddog_prof_Result_Generation_Tag;
+
+typedef struct ddog_prof_Result_Generation {
+  ddog_prof_Result_Generation_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_Generation ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_Result_Generation;
+
+typedef enum ddog_prof_ManagedStringStorageNewResult_Tag {
+  DDOG_PROF_MANAGED_STRING_STORAGE_NEW_RESULT_OK,
+  DDOG_PROF_MANAGED_STRING_STORAGE_NEW_RESULT_ERR,
+} ddog_prof_ManagedStringStorageNewResult_Tag;
+
+typedef struct ddog_prof_ManagedStringStorageNewResult {
+  ddog_prof_ManagedStringStorageNewResult_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_ManagedStringStorage ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_ManagedStringStorageNewResult;
+
+typedef enum ddog_prof_ManagedStringStorageInternResult_Tag {
+  DDOG_PROF_MANAGED_STRING_STORAGE_INTERN_RESULT_OK,
+  DDOG_PROF_MANAGED_STRING_STORAGE_INTERN_RESULT_ERR,
+} ddog_prof_ManagedStringStorageInternResult_Tag;
+
+typedef struct ddog_prof_ManagedStringStorageInternResult {
+  ddog_prof_ManagedStringStorageInternResult_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_ManagedStringId ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_ManagedStringStorageInternResult;
+
+typedef enum ddog_prof_Option_Error_Tag {
+  DDOG_PROF_OPTION_ERROR_SOME_ERROR,
+  DDOG_PROF_OPTION_ERROR_NONE_ERROR,
+} ddog_prof_Option_Error_Tag;
+
+typedef struct ddog_prof_Option_Error {
+  ddog_prof_Option_Error_Tag tag;
+  union {
+    struct {
+      struct ddog_Error some;
+    };
+  };
+} ddog_prof_Option_Error;
+
+typedef struct ddog_prof_Option_Error ddog_prof_MaybeError;
+
 typedef enum ddog_StringWrapperResult_Tag {
   DDOG_STRING_WRAPPER_RESULT_OK,
   DDOG_STRING_WRAPPER_RESULT_ERR,
@@ -762,12 +1132,16 @@ typedef struct ddog_StringWrapperResult {
   };
 } ddog_StringWrapperResult;
 
+typedef struct ddog_prof_StringId ddog_prof_StringId;
+
 typedef enum ddog_ConfigurationOrigin {
   DDOG_CONFIGURATION_ORIGIN_ENV_VAR,
   DDOG_CONFIGURATION_ORIGIN_CODE,
   DDOG_CONFIGURATION_ORIGIN_DD_CONFIG,
   DDOG_CONFIGURATION_ORIGIN_REMOTE_CONFIG,
   DDOG_CONFIGURATION_ORIGIN_DEFAULT,
+  DDOG_CONFIGURATION_ORIGIN_LOCAL_STABLE_CONFIG,
+  DDOG_CONFIGURATION_ORIGIN_FLEET_STABLE_CONFIG,
 } ddog_ConfigurationOrigin;
 
 typedef enum ddog_LogLevel {
@@ -899,6 +1273,7 @@ typedef enum ddog_crasht_OpTypes {
 
 /**
  * See https://man7.org/linux/man-pages/man2/sigaction.2.html
+ * MUST REMAIN IN SYNC WITH THE ENUM IN emit_sigcodes.c
  */
 typedef enum ddog_crasht_SiCodes {
   DDOG_CRASHT_SI_CODES_BUS_ADRALN,
@@ -906,6 +1281,14 @@ typedef enum ddog_crasht_SiCodes {
   DDOG_CRASHT_SI_CODES_BUS_MCEERR_AO,
   DDOG_CRASHT_SI_CODES_BUS_MCEERR_AR,
   DDOG_CRASHT_SI_CODES_BUS_OBJERR,
+  DDOG_CRASHT_SI_CODES_ILL_BADSTK,
+  DDOG_CRASHT_SI_CODES_ILL_COPROC,
+  DDOG_CRASHT_SI_CODES_ILL_ILLADR,
+  DDOG_CRASHT_SI_CODES_ILL_ILLOPC,
+  DDOG_CRASHT_SI_CODES_ILL_ILLOPN,
+  DDOG_CRASHT_SI_CODES_ILL_ILLTRP,
+  DDOG_CRASHT_SI_CODES_ILL_PRVOPC,
+  DDOG_CRASHT_SI_CODES_ILL_PRVREG,
   DDOG_CRASHT_SI_CODES_SEGV_ACCERR,
   DDOG_CRASHT_SI_CODES_SEGV_BNDERR,
   DDOG_CRASHT_SI_CODES_SEGV_MAPERR,
@@ -926,10 +1309,37 @@ typedef enum ddog_crasht_SiCodes {
  * See https://man7.org/linux/man-pages/man7/signal.7.html
  */
 typedef enum ddog_crasht_SignalNames {
+  DDOG_CRASHT_SIGNAL_NAMES_SIGHUP,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGINT,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGQUIT,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGILL,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGTRAP,
   DDOG_CRASHT_SIGNAL_NAMES_SIGABRT,
   DDOG_CRASHT_SIGNAL_NAMES_SIGBUS,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGFPE,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGKILL,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGUSR1,
   DDOG_CRASHT_SIGNAL_NAMES_SIGSEGV,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGUSR2,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGPIPE,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGALRM,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGTERM,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGCHLD,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGCONT,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGSTOP,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGTSTP,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGTTIN,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGTTOU,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGURG,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGXCPU,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGXFSZ,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGVTALRM,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGPROF,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGWINCH,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGIO,
   DDOG_CRASHT_SIGNAL_NAMES_SIGSYS,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGEMT,
+  DDOG_CRASHT_SIGNAL_NAMES_SIGINFO,
   DDOG_CRASHT_SIGNAL_NAMES_UNKNOWN,
 } ddog_crasht_SignalNames;
 
@@ -946,6 +1356,12 @@ typedef enum ddog_crasht_StacktraceCollection {
    */
   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;
@@ -958,31 +1374,6 @@ typedef struct ddog_crasht_StackFrame ddog_crasht_StackFrame;
 
 typedef struct ddog_crasht_StackTrace ddog_crasht_StackTrace;
 
-/**
- * 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 {
-      /**
-       * 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_VoidResult;
-
 typedef struct ddog_crasht_Slice_CharSlice {
   /**
    * Should be non-null and suitably aligned for the underlying type. It is
@@ -997,26 +1388,49 @@ typedef struct ddog_crasht_Slice_CharSlice {
   uintptr_t len;
 } ddog_crasht_Slice_CharSlice;
 
+typedef struct ddog_crasht_Slice_I32 {
+  /**
+   * 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 int32_t *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_crasht_Slice_I32;
+
 typedef struct ddog_crasht_Config {
   struct ddog_crasht_Slice_CharSlice additional_files;
   bool create_alt_stack;
-  bool use_alt_stack;
+  bool demangle_names;
   /**
    * The endpoint to send the crash report to (can be a file://).
    * If None, the crashtracker will infer the agent host from env variables.
    */
   const struct ddog_Endpoint *endpoint;
+  /**
+   * Optional filename for a unix domain socket if the receiver is used asynchonously
+   */
+  ddog_CharSlice optional_unix_socket_filename;
   enum ddog_crasht_StacktraceCollection resolve_frames;
+  /**
+   * The set of signals we should be registered for.
+   * If empty, use the default set.
+   */
+  struct ddog_crasht_Slice_I32 signals;
   /**
    * Timeout in milliseconds before the signal handler starts tearing things down to return.
+   * If 0, uses the default timeout as specified in
+   * `datadog_crashtracker::shared::constants::DD_CRASHTRACK_DEFAULT_TIMEOUT`. Otherwise, uses
+   * the specified timeout value.
    * This is given as a uint32_t, but the actual timeout needs to fit inside of an i32 (max
    * 2^31-1). This is a limitation of the various interfaces used to guarantee the timeout.
    */
   uint32_t timeout_ms;
-  /**
-   * Optional filename for a unix domain socket if the receiver is used asynchonously
-   */
-  ddog_CharSlice optional_unix_socket_filename;
+  bool use_alt_stack;
 } ddog_crasht_Config;
 
 typedef struct ddog_crasht_EnvVar {
@@ -1062,6 +1476,20 @@ typedef struct ddog_crasht_Metadata {
   const struct ddog_Vec_Tag *tags;
 } ddog_crasht_Metadata;
 
+typedef struct ddog_crasht_Slice_CInt {
+  /**
+   * 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 int *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_crasht_Slice_CInt;
+
 /**
  * A generic result type for when an operation may fail,
  * or may return <T> in case of success.
@@ -1204,8 +1632,20 @@ typedef enum ddog_TraceExporterErrorCode {
   DDOG_TRACE_EXPORTER_ERROR_CODE_NETWORK_UNKNOWN,
   DDOG_TRACE_EXPORTER_ERROR_CODE_SERDE,
   DDOG_TRACE_EXPORTER_ERROR_CODE_TIMED_OUT,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_INTERNAL,
+  DDOG_TRACE_EXPORTER_ERROR_CODE_PANIC,
 } ddog_TraceExporterErrorCode;
 
+/**
+ * Structure containing the agent response to a trace payload
+ * MUST be freed with `ddog_trace_exporter_response_free`
+ *
+ * If the agent payload version is enabled on the trace exporter, and
+ * the agent response indicates that the payload version hasn't changed,
+ * the body will be empty.
+ */
+typedef struct ddog_TraceExporterResponse ddog_TraceExporterResponse;
+
 /**
  * The TraceExporter ingest traces from the tracers serialized as messagepack and forward them to
  * the agent while applying some transformation.
@@ -1236,7 +1676,7 @@ typedef struct ddog_TraceExporter ddog_TraceExporter;
 typedef struct ddog_TraceExporterConfig ddog_TraceExporterConfig;
 
 /**
- * Stucture that contains error information that `TraceExporter` API can return.
+ * Structure that contains error information that `TraceExporter` API can return.
  */
 typedef struct ddog_TraceExporterError {
   enum ddog_TraceExporterErrorCode code;
@@ -1244,31 +1684,28 @@ typedef struct ddog_TraceExporterError {
 } ddog_TraceExporterError;
 
 /**
- * `AgentResponse` structure holds agent response information upon successful request.
+ * FFI compatible configuration for the TelemetryClient.
  */
-typedef struct ddog_AgentResponse {
+typedef struct ddog_TelemetryClientConfig {
   /**
-   * Sampling rate for the current service.
+   * How often telemetry should be sent, in milliseconds.
    */
-  double rate;
-} ddog_AgentResponse;
-
-typedef enum ddog_LibraryConfigName {
-  DDOG_LIBRARY_CONFIG_NAME_DD_APM_TRACING_ENABLED,
-  DDOG_LIBRARY_CONFIG_NAME_DD_RUNTIME_METRICS_ENABLED,
-  DDOG_LIBRARY_CONFIG_NAME_DD_LOGS_INJECTION,
-  DDOG_LIBRARY_CONFIG_NAME_DD_PROFILING_ENABLED,
-  DDOG_LIBRARY_CONFIG_NAME_DD_DATA_STREAMS_ENABLED,
-  DDOG_LIBRARY_CONFIG_NAME_DD_APPSEC_ENABLED,
-  DDOG_LIBRARY_CONFIG_NAME_DD_IAST_ENABLED,
-  DDOG_LIBRARY_CONFIG_NAME_DD_DYNAMIC_INSTRUMENTATION_ENABLED,
-  DDOG_LIBRARY_CONFIG_NAME_DD_DATA_JOBS_ENABLED,
-  DDOG_LIBRARY_CONFIG_NAME_DD_APPSEC_SCA_ENABLED,
-  DDOG_LIBRARY_CONFIG_NAME_DD_TRACE_DEBUG,
-  DDOG_LIBRARY_CONFIG_NAME_DD_SERVICE,
-  DDOG_LIBRARY_CONFIG_NAME_DD_ENV,
-  DDOG_LIBRARY_CONFIG_NAME_DD_VERSION,
-} ddog_LibraryConfigName;
+  uint64_t interval;
+  /**
+   * A V4 UUID that represents a tracer session. This ID should:
+   * - Be generated when the tracer starts
+   * - Be identical within the context of a host (i.e. multiple threads/processes that belong to
+   *   a single instrumented app should share the same runtime_id)
+   * - Be associated with traces to allow correlation between traces and telemetry data
+   */
+  ddog_CharSlice runtime_id;
+  /**
+   * Whether to enable debug mode for telemetry.
+   * When enabled, sets the DD-Telemetry-Debug-Enabled header to true.
+   * Defaults to false.
+   */
+  bool debug_enabled;
+} ddog_TelemetryClientConfig;
 
 typedef enum ddog_LibraryConfigSource {
   DDOG_LIBRARY_CONFIG_SOURCE_LOCAL_STABLE_CONFIG = 0,
@@ -1328,8 +1765,10 @@ typedef struct ddog_CString {
 } ddog_CString;
 
 typedef struct ddog_LibraryConfig {
-  enum ddog_LibraryConfigName name;
+  struct ddog_CString name;
   struct ddog_CString value;
+  enum ddog_LibraryConfigSource source;
+  struct ddog_CString config_id;
 } ddog_LibraryConfig;
 
 /**
@@ -1363,13 +1802,130 @@ typedef struct ddog_Result_VecLibraryConfig {
   };
 } ddog_Result_VecLibraryConfig;
 
+/**
+ * C-compatible representation of an anonymous file handle
+ */
+typedef struct ddog_TracerMemfdHandle {
+  /**
+   * File descriptor (relevant only on Linux)
+   */
+  int fd;
+} ddog_TracerMemfdHandle;
+
+/**
+ * A generic result type for when an operation may fail,
+ * or may return <T> in case of success.
+ */
+typedef enum ddog_Result_TracerMemfdHandle_Tag {
+  DDOG_RESULT_TRACER_MEMFD_HANDLE_OK_TRACER_MEMFD_HANDLE,
+  DDOG_RESULT_TRACER_MEMFD_HANDLE_ERR_TRACER_MEMFD_HANDLE,
+} ddog_Result_TracerMemfdHandle_Tag;
+
+typedef struct ddog_Result_TracerMemfdHandle {
+  ddog_Result_TracerMemfdHandle_Tag tag;
+  union {
+    struct {
+      struct ddog_TracerMemfdHandle ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_Result_TracerMemfdHandle;
+
+/**
+ * Log level for filtering log events.
+ */
+typedef enum ddog_LogEventLevel {
+  /**
+   * The "trace" level.
+   *
+   * Designates very low priority, often extremely verbose, information.
+   */
+  DDOG_LOG_EVENT_LEVEL_TRACE = 0,
+  /**
+   * The "debug" level.
+   *
+   * Designates lower priority information.
+   */
+  DDOG_LOG_EVENT_LEVEL_DEBUG = 1,
+  /**
+   * The "info" level.
+   *
+   * Designates useful information.
+   */
+  DDOG_LOG_EVENT_LEVEL_INFO = 2,
+  /**
+   * The "warn" level.
+   *
+   * Designates hazardous situations.
+   */
+  DDOG_LOG_EVENT_LEVEL_WARN = 3,
+  /**
+   * The "error" level.
+   *
+   * Designates very serious errors.
+   */
+  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.
+ */
+typedef struct ddog_StdConfig {
+  /**
+   * Target stream (stdout or stderr)
+   */
+  enum ddog_StdTarget target;
+} ddog_StdConfig;
+
+/**
+ * Configuration for file output.
+ */
+typedef struct ddog_FileConfig {
+  /**
+   * Path to the log file
+   */
+  ddog_CharSlice path;
+  /**
+   * Maximum total number of files (current + rotated) to keep on disk.
+   * When this limit is exceeded, the oldest rotated files are deleted.
+   * Set to 0 to disable file cleanup.
+   */
+  uint64_t max_files;
+  /**
+   * Maximum size in bytes for each log file.
+   * Set to 0 to disable size-based rotation.
+   */
+  uint64_t max_size_bytes;
+} ddog_FileConfig;
+
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
 /**
+ * Drops the error. It should not be used after this, though the
+ * implementation tries to limit the damage in the case of use-after-free and
+ * double-free scenarios.
+ *
  * # Safety
- * Only pass null or a valid reference to a `ddog_Error`.
+ *
+ * Only pass null or a pointer to a valid, mutable `ddog_Error`.
  */
 void ddog_Error_drop(struct ddog_Error *error);
 
@@ -1475,16 +2031,23 @@ struct ddog_Option_U32 ddog_Option_U32_some(uint32_t v);
 struct ddog_Option_U32 ddog_Option_U32_none(void);
 
 /**
+ * Drops a `ddog_StringWrapper`. It should not be used after this, though the
+ * implementation tries to limit the damage in the case of use-after-free and
+ * double-free scenarios.
+ *
  * # Safety
- * Only pass null or a valid reference to a `ddog_StringWrapper`.
+ *
+ * Only pass null or a pointer to a valid, mutable `ddog_StringWrapper`.
  */
 void ddog_StringWrapper_drop(struct ddog_StringWrapper *s);
 
 /**
- * Returns a CharSlice of the message that is valid until the StringWrapper
- * is dropped.
+ * Returns a CharSlice of the message.
+ *
  * # Safety
+ *
  * Only pass null or a valid reference to a `ddog_StringWrapper`.
+ * The string should not be mutated nor dropped while the CharSlice is alive.
  */
 ddog_CharSlice ddog_StringWrapper_message(const struct ddog_StringWrapper *s);