libdatadog 0.8.0.1.0 → 1.0.1.1.0

data/vendor/{libdatadog-0.8.0/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl → libdatadog-1.0.1/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu}/include/datadog/common.h

@@ -1,10 +1,11 @@
 // Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
 // This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021-Present Datadog, Inc.
 
-
 #ifndef DDOG_COMMON_H
 #define DDOG_COMMON_H
 
+#pragma once
+
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
@@ -17,12 +18,23 @@
 /* NOTE: Compilation fails if you pass in a char* instead of a literal */ ((ddog_CharSlice){ .ptr = "" string, .len = sizeof(string) - 1 })
 #endif
 
+#if defined __GNUC__
+#  define DDOG_GNUC_VERSION(major) __GNUC__ >= major
+#else
+#  define DDOG_GNUC_VERSION(major) (0)
+#endif
+
+#if defined __has_attribute
+#  define DDOG_HAS_ATTRIBUTE(attribute, major) __has_attribute(attribute)
+#else
+#  define DDOG_HAS_ATTRIBUTE(attribute, major) DDOG_GNUC_VERSION(major)
+#endif
+
 #if defined(__cplusplus) && (__cplusplus >= 201703L)
 #  define DDOG_CHECK_RETURN [[nodiscard]]
 #elif defined(_Check_return_) /* SAL */
 #  define DDOG_CHECK_RETURN _Check_return_
-#elif (defined(__has_attribute) && __has_attribute(warn_unused_result)) || \
-      (defined(__GNUC__) && (__GNUC__ >= 4))
+#elif DDOG_HAS_ATTRIBUTE(warn_unused_result, 4)
 #  define DDOG_CHECK_RETURN __attribute__((__warn_unused_result__))
 #else
 #  define DDOG_CHECK_RETURN
@@ -33,95 +45,103 @@ typedef struct ddog_Tag ddog_Tag;
 /**
  * Holds the raw parts of a Rust Vec; it should only be created from Rust,
  * never from C.
- * The names ptr and len were chosen to minimize conversion from a previous
- * Buffer type which this has replaced to become more general.
  */
-typedef struct ddog_Vec_tag {
+typedef struct ddog_Vec_Tag {
   const struct ddog_Tag *ptr;
   uintptr_t len;
   uintptr_t capacity;
-} ddog_Vec_tag;
+} ddog_Vec_Tag;
 
 /**
  * Holds the raw parts of a Rust Vec; it should only be created from Rust,
  * never from C.
- * The names ptr and len were chosen to minimize conversion from a previous
- * Buffer type which this has replaced to become more general.
  */
-typedef struct ddog_Vec_u8 {
+typedef struct ddog_Vec_U8 {
   const uint8_t *ptr;
   uintptr_t len;
   uintptr_t capacity;
-} ddog_Vec_u8;
+} ddog_Vec_U8;
 
-typedef enum ddog_PushTagResult_Tag {
-  DDOG_PUSH_TAG_RESULT_OK,
-  DDOG_PUSH_TAG_RESULT_ERR,
-} ddog_PushTagResult_Tag;
+typedef enum ddog_Vec_Tag_PushResult_Tag {
+  DDOG_VEC_TAG_PUSH_RESULT_OK,
+  DDOG_VEC_TAG_PUSH_RESULT_ERR,
+} ddog_Vec_Tag_PushResult_Tag;
 
-typedef struct ddog_PushTagResult {
-  ddog_PushTagResult_Tag tag;
+typedef struct ddog_Vec_Tag_PushResult {
+  ddog_Vec_Tag_PushResult_Tag tag;
   union {
     struct {
-      struct ddog_Vec_u8 err;
+      struct ddog_Vec_U8 err;
     };
   };
-} ddog_PushTagResult;
+} ddog_Vec_Tag_PushResult;
 
 /**
  * Remember, the data inside of each member is potentially coming from FFI,
  * so every operation on it is unsafe!
  */
-typedef struct ddog_Slice_c_char {
+typedef struct ddog_Slice_CChar {
   const char *ptr;
   uintptr_t len;
-} ddog_Slice_c_char;
+} ddog_Slice_CChar;
 
-typedef struct ddog_Slice_c_char ddog_CharSlice;
+typedef struct ddog_Slice_CChar ddog_CharSlice;
 
-typedef struct ddog_ParseTagsResult {
-  struct ddog_Vec_tag tags;
-  struct ddog_Vec_u8 *error_message;
-} ddog_ParseTagsResult;
+typedef struct ddog_Vec_Tag_ParseResult {
+  struct ddog_Vec_Tag tags;
+  struct ddog_Vec_U8 *error_message;
+} ddog_Vec_Tag_ParseResult;
 
 typedef struct ddog_CancellationToken ddog_CancellationToken;
 
-typedef struct ddog_Profile ddog_Profile;
+typedef struct ddog_prof_Profile ddog_prof_Profile;
+
+typedef struct ddog_prof_Exporter ddog_prof_Exporter;
 
-typedef struct ddog_ProfileExporter ddog_ProfileExporter;
+typedef struct ddog_prof_ProfiledEndpointsStats ddog_prof_ProfiledEndpointsStats;
 
 /**
  * This type only exists to workaround a bug in cbindgen; may be removed in the
  * future.
  */
-typedef struct ddog_Request ddog_Request;
+typedef struct ddog_prof_Exporter_Request ddog_prof_Exporter_Request;
+
+/**
+ * Holds the raw parts of a Rust Vec; it should only be created from Rust,
+ * never from C.
+ */
+typedef struct ddog_prof_Vec_U8 {
+  const uint8_t *ptr;
+  uintptr_t len;
+  uintptr_t capacity;
+} ddog_prof_Vec_U8;
 
-typedef enum ddog_NewProfileExporterResult_Tag {
-  DDOG_NEW_PROFILE_EXPORTER_RESULT_OK,
-  DDOG_NEW_PROFILE_EXPORTER_RESULT_ERR,
-} ddog_NewProfileExporterResult_Tag;
+typedef enum ddog_prof_Exporter_NewResult_Tag {
+  DDOG_PROF_EXPORTER_NEW_RESULT_OK,
+  DDOG_PROF_EXPORTER_NEW_RESULT_ERR,
+} ddog_prof_Exporter_NewResult_Tag;
 
-typedef struct ddog_NewProfileExporterResult {
-  ddog_NewProfileExporterResult_Tag tag;
+typedef struct ddog_prof_Exporter_NewResult {
+  ddog_prof_Exporter_NewResult_Tag tag;
   union {
     struct {
-      struct ddog_ProfileExporter *ok;
+      struct ddog_prof_Exporter *ok;
     };
     struct {
-      struct ddog_Vec_u8 err;
+      struct ddog_prof_Vec_U8 err;
     };
   };
-} ddog_NewProfileExporterResult;
+} ddog_prof_Exporter_NewResult;
 
 typedef enum ddog_Endpoint_Tag {
   DDOG_ENDPOINT_AGENT,
   DDOG_ENDPOINT_AGENTLESS,
 } ddog_Endpoint_Tag;
 
-typedef struct ddog_Endpoint_ddog_Agentless_Body {
+typedef struct ddog_Endpoint_ddog_prof_Agentless_Body {
   ddog_CharSlice _0;
   ddog_CharSlice _1;
-} ddog_Endpoint_ddog_Agentless_Body;
+} ddog_Endpoint_ddog_prof_Agentless_Body;
 
 typedef struct ddog_Endpoint {
   ddog_Endpoint_Tag tag;
@@ -129,7 +149,7 @@ typedef struct ddog_Endpoint {
     struct {
       ddog_CharSlice agent;
     };
-    ddog_Endpoint_ddog_Agentless_Body AGENTLESS;
+    ddog_Endpoint_ddog_prof_Agentless_Body AGENTLESS;
   };
 } ddog_Endpoint;
 
@@ -145,71 +165,71 @@ typedef struct ddog_Timespec {
  * Remember, the data inside of each member is potentially coming from FFI,
  * so every operation on it is unsafe!
  */
-typedef struct ddog_Slice_u8 {
+typedef struct ddog_Slice_U8 {
   const uint8_t *ptr;
   uintptr_t len;
-} ddog_Slice_u8;
+} ddog_Slice_U8;
 
 /**
  * Use to represent bytes -- does not need to be valid UTF-8.
  */
-typedef struct ddog_Slice_u8 ddog_ByteSlice;
+typedef struct ddog_Slice_U8 ddog_ByteSlice;
 
-typedef struct ddog_File {
+typedef struct ddog_prof_Exporter_File {
   ddog_CharSlice name;
   ddog_ByteSlice file;
-} ddog_File;
+} ddog_prof_Exporter_File;
 
 /**
  * Remember, the data inside of each member is potentially coming from FFI,
  * so every operation on it is unsafe!
  */
-typedef struct ddog_Slice_file {
-  const struct ddog_File *ptr;
+typedef struct ddog_prof_Exporter_Slice_File {
+  const struct ddog_prof_Exporter_File *ptr;
   uintptr_t len;
-} ddog_Slice_file;
+} ddog_prof_Exporter_Slice_File;
 
 typedef struct ddog_HttpStatus {
   uint16_t code;
 } ddog_HttpStatus;
 
-typedef enum ddog_SendResult_Tag {
-  DDOG_SEND_RESULT_HTTP_RESPONSE,
-  DDOG_SEND_RESULT_ERR,
-} ddog_SendResult_Tag;
+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;
 
-typedef struct ddog_SendResult {
-  ddog_SendResult_Tag tag;
+typedef struct ddog_prof_Exporter_SendResult {
+  ddog_prof_Exporter_SendResult_Tag tag;
   union {
     struct {
       struct ddog_HttpStatus http_response;
     };
     struct {
-      struct ddog_Vec_u8 err;
+      struct ddog_prof_Vec_U8 err;
     };
   };
-} ddog_SendResult;
+} ddog_prof_Exporter_SendResult;
 
-typedef struct ddog_ValueType {
+typedef struct ddog_prof_ValueType {
   ddog_CharSlice type_;
   ddog_CharSlice unit;
-} ddog_ValueType;
+} ddog_prof_ValueType;
 
 /**
  * Remember, the data inside of each member is potentially coming from FFI,
  * so every operation on it is unsafe!
  */
-typedef struct ddog_Slice_value_type {
-  const struct ddog_ValueType *ptr;
+typedef struct ddog_prof_Slice_ValueType {
+  const struct ddog_prof_ValueType *ptr;
   uintptr_t len;
-} ddog_Slice_value_type;
+} ddog_prof_Slice_ValueType;
 
-typedef struct ddog_Period {
-  struct ddog_ValueType type_;
+typedef struct ddog_prof_Period {
+  struct ddog_prof_ValueType type_;
   int64_t value;
-} ddog_Period;
+} ddog_prof_Period;
 
-typedef struct ddog_Mapping {
+typedef struct ddog_prof_Mapping {
   /**
    * Address at which the binary (or DLL) is loaded into memory.
    */
@@ -234,9 +254,9 @@ typedef struct ddog_Mapping {
    * it could be the contents of the .note.gnu.build-id field.
    */
   ddog_CharSlice build_id;
-} ddog_Mapping;
+} ddog_prof_Mapping;
 
-typedef struct ddog_Function {
+typedef struct ddog_prof_Function {
   /**
    * Name of the function, in human-readable form if available.
    */
@@ -254,33 +274,33 @@ typedef struct ddog_Function {
    * Line number in source file.
    */
   int64_t start_line;
-} ddog_Function;
+} ddog_prof_Function;
 
-typedef struct ddog_Line {
+typedef struct ddog_prof_Line {
   /**
    * The corresponding profile.Function for this line.
    */
-  struct ddog_Function function;
+  struct ddog_prof_Function function;
   /**
    * Line number in source code.
    */
   int64_t line;
-} ddog_Line;
+} ddog_prof_Line;
 
 /**
  * Remember, the data inside of each member is potentially coming from FFI,
  * so every operation on it is unsafe!
  */
-typedef struct ddog_Slice_line {
-  const struct ddog_Line *ptr;
+typedef struct ddog_prof_Slice_Line {
+  const struct ddog_prof_Line *ptr;
   uintptr_t len;
-} ddog_Slice_line;
+} ddog_prof_Slice_Line;
 
-typedef struct ddog_Location {
+typedef struct ddog_prof_Location {
   /**
    * todo: how to handle unknown mapping?
    */
-  struct ddog_Mapping mapping;
+  struct ddog_prof_Mapping mapping;
   /**
    * The instruction address for this location, if available.  It
    * should be within [Mapping.memory_start...Mapping.memory_limit]
@@ -298,7 +318,7 @@ typedef struct ddog_Location {
    *    line[0].function_name == "memcpy"
    *    line[1].function_name == "printf"
    */
-  struct ddog_Slice_line lines;
+  struct ddog_prof_Slice_Line lines;
   /**
    * Provides an indication that multiple symbols map to this location's
    * address, for example due to identical code folding by the linker. In that
@@ -307,27 +327,27 @@ typedef struct ddog_Location {
    * profile changes.
    */
   bool is_folded;
-} ddog_Location;
+} ddog_prof_Location;
 
 /**
  * Remember, the data inside of each member is potentially coming from FFI,
  * so every operation on it is unsafe!
  */
-typedef struct ddog_Slice_location {
-  const struct ddog_Location *ptr;
+typedef struct ddog_prof_Slice_Location {
+  const struct ddog_prof_Location *ptr;
   uintptr_t len;
-} ddog_Slice_location;
+} ddog_prof_Slice_Location;
 
 /**
  * Remember, the data inside of each member is potentially coming from FFI,
  * so every operation on it is unsafe!
  */
-typedef struct ddog_Slice_i64 {
+typedef struct ddog_Slice_I64 {
   const int64_t *ptr;
   uintptr_t len;
-} ddog_Slice_i64;
+} ddog_Slice_I64;
 
-typedef struct ddog_Label {
+typedef struct ddog_prof_Label {
   ddog_CharSlice key;
   /**
    * At most one of the following must be present
@@ -344,22 +364,22 @@ typedef struct ddog_Label {
    * and apply appropriate unit conversions to these.
    */
   ddog_CharSlice num_unit;
-} ddog_Label;
+} ddog_prof_Label;
 
 /**
  * Remember, the data inside of each member is potentially coming from FFI,
  * so every operation on it is unsafe!
  */
-typedef struct ddog_Slice_label {
-  const struct ddog_Label *ptr;
+typedef struct ddog_prof_Slice_Label {
+  const struct ddog_prof_Label *ptr;
   uintptr_t len;
-} ddog_Slice_label;
+} ddog_prof_Slice_Label;
 
-typedef struct ddog_Sample {
+typedef struct ddog_prof_Sample {
   /**
    * The leaf is at locations[0].
    */
-  struct ddog_Slice_location locations;
+  struct ddog_prof_Slice_Location locations;
   /**
    * The type and unit of each value is defined by the corresponding
    * entry in Profile.sample_type. All samples must have the same
@@ -368,42 +388,43 @@ typedef struct ddog_Sample {
    * result has a list of values that is the element-wise sum of the
    * lists of the originals.
    */
-  struct ddog_Slice_i64 values;
+  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_Slice_label labels;
-} ddog_Sample;
+  struct ddog_prof_Slice_Label labels;
+} ddog_prof_Sample;
 
-typedef struct ddog_EncodedProfile {
+typedef struct ddog_prof_EncodedProfile {
   struct ddog_Timespec start;
   struct ddog_Timespec end;
-  struct ddog_Vec_u8 buffer;
-} ddog_EncodedProfile;
+  struct ddog_prof_Vec_U8 buffer;
+  struct ddog_prof_ProfiledEndpointsStats *endpoints_stats;
+} ddog_prof_EncodedProfile;
 
-typedef enum ddog_SerializeResult_Tag {
-  DDOG_SERIALIZE_RESULT_OK,
-  DDOG_SERIALIZE_RESULT_ERR,
-} ddog_SerializeResult_Tag;
+typedef enum ddog_prof_Profile_SerializeResult_Tag {
+  DDOG_PROF_PROFILE_SERIALIZE_RESULT_OK,
+  DDOG_PROF_PROFILE_SERIALIZE_RESULT_ERR,
+} ddog_prof_Profile_SerializeResult_Tag;
 
-typedef struct ddog_SerializeResult {
-  ddog_SerializeResult_Tag tag;
+typedef struct ddog_prof_Profile_SerializeResult {
+  ddog_prof_Profile_SerializeResult_Tag tag;
   union {
     struct {
-      struct ddog_EncodedProfile ok;
+      struct ddog_prof_EncodedProfile ok;
     };
     struct {
-      struct ddog_Vec_u8 err;
+      struct ddog_prof_Vec_U8 err;
     };
   };
-} ddog_SerializeResult;
+} ddog_prof_Profile_SerializeResult;
 
-DDOG_CHECK_RETURN struct ddog_Vec_tag ddog_Vec_tag_new(void);
+DDOG_CHECK_RETURN struct ddog_Vec_Tag ddog_Vec_Tag_new(void);
 
-void ddog_Vec_tag_drop(struct ddog_Vec_tag);
+void ddog_Vec_Tag_drop(struct ddog_Vec_Tag);
 
-void ddog_PushTagResult_drop(struct ddog_PushTagResult);
+void ddog_Vec_Tag_PushResult_drop(struct ddog_Vec_Tag_PushResult);
 
 /**
  * Creates a new Tag from the provided `key` and `value` by doing a utf8
@@ -416,15 +437,15 @@ void ddog_PushTagResult_drop(struct ddog_PushTagResult);
  * `.len` properties claim.
  */
 DDOG_CHECK_RETURN
-struct ddog_PushTagResult ddog_Vec_tag_push(struct ddog_Vec_tag *vec,
-                                            ddog_CharSlice key,
-                                            ddog_CharSlice value);
+struct ddog_Vec_Tag_PushResult ddog_Vec_Tag_push(struct ddog_Vec_Tag *vec,
+                                                 ddog_CharSlice key,
+                                                 ddog_CharSlice value);
 
 /**
  * # Safety
  * The `string`'s .ptr must point to a valid object at least as large as its
  * .len property.
  */
-DDOG_CHECK_RETURN struct ddog_ParseTagsResult ddog_Vec_tag_parse(ddog_CharSlice string);
+DDOG_CHECK_RETURN struct ddog_Vec_Tag_ParseResult ddog_Vec_Tag_parse(ddog_CharSlice string);
 
 #endif /* DDOG_COMMON_H */