libdatadog 3.0.0.1.0-x86_64-linux → 5.0.0.1.0-x86_64-linux

data/vendor/{libdatadog-3.0.0/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl → libdatadog-5.0.0/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu}/include/datadog/common.h

@@ -40,6 +40,8 @@
 #  define DDOG_CHECK_RETURN
 #endif
 
+typedef struct ddog_Endpoint ddog_Endpoint;
+
 typedef struct ddog_Tag ddog_Tag;
 
 /**
@@ -70,7 +72,13 @@ typedef struct ddog_Error {
  * so every operation on it is unsafe!
  */
 typedef struct ddog_Slice_CChar {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
   const char *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to.
+   */
   uintptr_t len;
 } ddog_Slice_CChar;
 
@@ -107,14 +115,52 @@ typedef struct ddog_Vec_Tag_ParseResult {
 
 typedef struct ddog_CancellationToken ddog_CancellationToken;
 
-typedef struct ddog_prof_Profile ddog_prof_Profile;
-
 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;
 
+/**
+ * Remember, the data inside of each member is potentially coming from FFI,
+ * so every operation on it is unsafe!
+ */
+typedef struct ddog_Slice_U8 {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
+  const uint8_t *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to.
+   */
+  uintptr_t len;
+} 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_prof_Exporter_File {
+  ddog_CharSlice name;
+  ddog_ByteSlice 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_prof_Exporter_Slice_File {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
+  const struct ddog_prof_Exporter_File *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to.
+   */
+  uintptr_t len;
+} ddog_prof_Exporter_Slice_File;
+
 typedef enum ddog_Endpoint_Tag {
   DDOG_ENDPOINT_AGENT,
   DDOG_ENDPOINT_AGENTLESS,
@@ -177,34 +223,6 @@ typedef struct ddog_Timespec {
   uint32_t nanoseconds;
 } 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 {
-  const uint8_t *ptr;
-  uintptr_t len;
-} 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_prof_Exporter_File {
-  ddog_CharSlice name;
-  ddog_ByteSlice 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_prof_Exporter_Slice_File {
-  const struct ddog_prof_Exporter_File *ptr;
-  uintptr_t len;
-} ddog_prof_Exporter_Slice_File;
-
 typedef struct ddog_HttpStatus {
   uint16_t code;
 } ddog_HttpStatus;
@@ -226,6 +244,34 @@ typedef struct ddog_prof_Exporter_SendResult {
   };
 } ddog_prof_Exporter_SendResult;
 
+/**
+ * Represents a profile. Do not access its member for any reason, only use
+ * the C API functions on this struct.
+ */
+typedef struct ddog_prof_Profile {
+  struct ddog_prof_Profile *inner;
+} ddog_prof_Profile;
+
+/**
+ * Returned by [ddog_prof_Profile_new].
+ */
+typedef enum ddog_prof_Profile_NewResult_Tag {
+  DDOG_PROF_PROFILE_NEW_RESULT_OK,
+  DDOG_PROF_PROFILE_NEW_RESULT_ERR,
+} ddog_prof_Profile_NewResult_Tag;
+
+typedef struct ddog_prof_Profile_NewResult {
+  ddog_prof_Profile_NewResult_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_Profile ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_Profile_NewResult;
+
 typedef struct ddog_prof_ValueType {
   ddog_CharSlice type_;
   ddog_CharSlice unit;
@@ -236,7 +282,13 @@ typedef struct ddog_prof_ValueType {
  * so every operation on it is unsafe!
  */
 typedef struct ddog_prof_Slice_ValueType {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
   const struct ddog_prof_ValueType *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to.
+   */
   uintptr_t len;
 } ddog_prof_Slice_ValueType;
 
@@ -245,22 +297,30 @@ typedef struct ddog_prof_Period {
   int64_t value;
 } ddog_prof_Period;
 
-typedef enum ddog_prof_Profile_AddResult_Tag {
-  DDOG_PROF_PROFILE_ADD_RESULT_OK,
-  DDOG_PROF_PROFILE_ADD_RESULT_ERR,
-} ddog_prof_Profile_AddResult_Tag;
+/**
+ * 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_AddResult {
-  ddog_prof_Profile_AddResult_Tag tag;
+typedef struct ddog_prof_Profile_Result {
+  ddog_prof_Profile_Result_Tag tag;
   union {
     struct {
-      uint64_t ok;
+      /**
+       * 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_AddResult;
+} ddog_prof_Profile_Result;
 
 typedef struct ddog_prof_Mapping {
   /**
@@ -309,31 +369,12 @@ typedef struct ddog_prof_Function {
   int64_t start_line;
 } ddog_prof_Function;
 
-typedef struct ddog_prof_Line {
-  /**
-   * The corresponding profile.Function for this line.
-   */
-  struct ddog_prof_Function function;
-  /**
-   * Line number in source code.
-   */
-  int64_t 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_prof_Slice_Line {
-  const struct ddog_prof_Line *ptr;
-  uintptr_t len;
-} ddog_prof_Slice_Line;
-
 typedef struct ddog_prof_Location {
   /**
    * todo: how to handle unknown mapping?
    */
   struct ddog_prof_Mapping mapping;
+  struct ddog_prof_Function function;
   /**
    * The instruction address for this location, if available.  It
    * should be within [Mapping.memory_start...Mapping.memory_limit]
@@ -342,24 +383,7 @@ typedef struct ddog_prof_Location {
    * the beginning of the instruction if necessary.
    */
   uint64_t address;
-  /**
-   * Multiple line indicates this location has inlined functions,
-   * where the last entry represents the caller into which the
-   * preceding entries were inlined.
-   *
-   * E.g., if memcpy() is inlined into printf:
-   *    line[0].function_name == "memcpy"
-   *    line[1].function_name == "printf"
-   */
-  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
-   * case the line information above represents one of the multiple
-   * symbols. This field must be recomputed when the symbolization state of the
-   * profile changes.
-   */
-  bool is_folded;
+  int64_t line;
 } ddog_prof_Location;
 
 /**
@@ -367,7 +391,13 @@ typedef struct ddog_prof_Location {
  * so every operation on it is unsafe!
  */
 typedef struct ddog_prof_Slice_Location {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
   const struct ddog_prof_Location *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to.
+   */
   uintptr_t len;
 } ddog_prof_Slice_Location;
 
@@ -376,7 +406,13 @@ typedef struct ddog_prof_Slice_Location {
  * so every operation on it is unsafe!
  */
 typedef struct ddog_Slice_I64 {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
   const int64_t *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to.
+   */
   uintptr_t len;
 } ddog_Slice_I64;
 
@@ -404,7 +440,13 @@ typedef struct ddog_prof_Label {
  * so every operation on it is unsafe!
  */
 typedef struct ddog_prof_Slice_Label {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
   const struct ddog_prof_Label *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to.
+   */
   uintptr_t len;
 } ddog_prof_Slice_Label;
 
@@ -429,29 +471,18 @@ typedef struct ddog_prof_Sample {
   struct ddog_prof_Slice_Label labels;
 } ddog_prof_Sample;
 
-typedef enum ddog_prof_Profile_UpscalingRuleAddResult_Tag {
-  DDOG_PROF_PROFILE_UPSCALING_RULE_ADD_RESULT_OK,
-  DDOG_PROF_PROFILE_UPSCALING_RULE_ADD_RESULT_ERR,
-} ddog_prof_Profile_UpscalingRuleAddResult_Tag;
-
-typedef struct ddog_prof_Profile_UpscalingRuleAddResult {
-  ddog_prof_Profile_UpscalingRuleAddResult_Tag tag;
-  union {
-    struct {
-      bool ok;
-    };
-    struct {
-      struct ddog_Error err;
-    };
-  };
-} ddog_prof_Profile_UpscalingRuleAddResult;
-
 /**
  * Remember, the data inside of each member is potentially coming from FFI,
  * so every operation on it is unsafe!
  */
 typedef struct ddog_prof_Slice_Usize {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
   const uintptr_t *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to.
+   */
   uintptr_t len;
 } ddog_prof_Slice_Usize;
 
@@ -493,6 +524,17 @@ void ddog_Error_drop(struct ddog_Error *error);
  */
 ddog_CharSlice ddog_Error_message(const struct ddog_Error *error);
 
+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);
+
+DDOG_CHECK_RETURN
+struct ddog_Error *ddog_endpoint_from_api_key_and_site(ddog_CharSlice api_key,
+                                                       ddog_CharSlice site,
+                                                       struct ddog_Endpoint **endpoint);
+
+void ddog_endpoint_drop(struct ddog_Endpoint*);
+
 DDOG_CHECK_RETURN struct ddog_Vec_Tag ddog_Vec_Tag_new(void);
 
 void ddog_Vec_Tag_drop(struct ddog_Vec_Tag);

data/vendor/{libdatadog-3.0.0 → libdatadog-5.0.0}/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu/include/datadog/profiling.h

@@ -11,6 +11,8 @@
 #include <stdint.h>
 #include "common.h"
 
+DDOG_CHECK_RETURN struct ddog_prof_Exporter_Slice_File ddog_prof_Exporter_Slice_File_empty(void);
+
 /**
  * Creates an endpoint that uses the agent.
  * # Arguments
@@ -74,7 +76,8 @@ DDOG_CHECK_RETURN
 struct ddog_prof_Exporter_Request_BuildResult ddog_prof_Exporter_Request_build(struct ddog_prof_Exporter *exporter,
                                                                                struct ddog_Timespec start,
                                                                                struct ddog_Timespec end,
-                                                                               struct ddog_prof_Exporter_Slice_File files,
+                                                                               struct ddog_prof_Exporter_Slice_File files_to_compress_and_export,
+                                                                               struct ddog_prof_Exporter_Slice_File files_to_export_unmodified,
                                                                                const struct ddog_Vec_Tag *optional_additional_tags,
                                                                                const struct ddog_prof_ProfiledEndpointsStats *optional_endpoints_stats,
                                                                                const ddog_CharSlice *optional_internal_metadata_json,
@@ -170,14 +173,14 @@ void ddog_CancellationToken_drop(struct ddog_CancellationToken *token);
  * and must have the correct number of elements for the slice.
  */
 DDOG_CHECK_RETURN
-struct ddog_prof_Profile *ddog_prof_Profile_new(struct ddog_prof_Slice_ValueType sample_types,
-                                                const struct ddog_prof_Period *period,
-                                                const struct ddog_Timespec *start_time);
+struct ddog_prof_Profile_NewResult ddog_prof_Profile_new(struct ddog_prof_Slice_ValueType sample_types,
+                                                         const struct ddog_prof_Period *period,
+                                                         const struct ddog_Timespec *start_time);
 
 /**
  * # Safety
- * The `profile` can be null, but if non-null it must point to a valid object
- * created by the Rust Global allocator.
+ * The `profile` can be null, but if non-null it must point to a Profile
+ * made by this module, which has not previously been dropped.
  */
 void ddog_prof_Profile_drop(struct ddog_prof_Profile *profile);
 
@@ -187,8 +190,8 @@ void ddog_prof_Profile_drop(struct ddog_prof_Profile *profile);
  * module. All pointers inside the `sample` need to be valid for the duration
  * of this call.
  *
- * If successful, it returns the internal id of the sample (> 0) in the Ok
- * variant. On error, it holds an error message in the error variant.
+ * If successful, it returns the Ok variant.
+ * On error, it holds an error message in the error variant.
  *
  * # Safety
  * The `profile` ptr must point to a valid Profile object created by this
@@ -196,8 +199,9 @@ void ddog_prof_Profile_drop(struct ddog_prof_Profile *profile);
  * This call is _NOT_ thread-safe.
  */
 DDOG_CHECK_RETURN
-struct ddog_prof_Profile_AddResult ddog_prof_Profile_add(struct ddog_prof_Profile *profile,
-                                                         struct ddog_prof_Sample sample);
+struct ddog_prof_Profile_Result ddog_prof_Profile_add(struct ddog_prof_Profile *profile,
+                                                      struct ddog_prof_Sample sample,
+                                                      int64_t timestamp);
 
 /**
  * Associate an endpoint to a given local root span id.
@@ -217,9 +221,10 @@ struct ddog_prof_Profile_AddResult ddog_prof_Profile_add(struct ddog_prof_Profil
  * module.
  * This call is _NOT_ thread-safe.
  */
-void ddog_prof_Profile_set_endpoint(struct ddog_prof_Profile *profile,
-                                    uint64_t local_root_span_id,
-                                    ddog_CharSlice endpoint);
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_Result ddog_prof_Profile_set_endpoint(struct ddog_prof_Profile *profile,
+                                                               uint64_t local_root_span_id,
+                                                               ddog_CharSlice endpoint);
 
 /**
  * Count the number of times an endpoint has been seen.
@@ -233,9 +238,10 @@ void ddog_prof_Profile_set_endpoint(struct ddog_prof_Profile *profile,
  * module.
  * This call is _NOT_ thread-safe.
  */
-void ddog_prof_Profile_add_endpoint_count(struct ddog_prof_Profile *profile,
-                                          ddog_CharSlice endpoint,
-                                          int64_t value);
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_Result ddog_prof_Profile_add_endpoint_count(struct ddog_prof_Profile *profile,
+                                                                     ddog_CharSlice endpoint,
+                                                                     int64_t value);
 
 /**
  * Add a poisson-based upscaling rule which will be use to adjust values and make them
@@ -257,13 +263,13 @@ void ddog_prof_Profile_add_endpoint_count(struct ddog_prof_Profile *profile,
  * This call is _NOT_ thread-safe.
  */
 DDOG_CHECK_RETURN
-struct ddog_prof_Profile_UpscalingRuleAddResult ddog_prof_Profile_add_upscaling_rule_poisson(struct ddog_prof_Profile *profile,
-                                                                                             struct ddog_prof_Slice_Usize offset_values,
-                                                                                             ddog_CharSlice label_name,
-                                                                                             ddog_CharSlice label_value,
-                                                                                             uintptr_t sum_value_offset,
-                                                                                             uintptr_t count_value_offset,
-                                                                                             uint64_t sampling_distance);
+struct ddog_prof_Profile_Result ddog_prof_Profile_add_upscaling_rule_poisson(struct ddog_prof_Profile *profile,
+                                                                             struct ddog_prof_Slice_Usize offset_values,
+                                                                             ddog_CharSlice label_name,
+                                                                             ddog_CharSlice label_value,
+                                                                             uintptr_t sum_value_offset,
+                                                                             uintptr_t count_value_offset,
+                                                                             uint64_t sampling_distance);
 
 /**
  * Add a proportional-based upscaling rule which will be use to adjust values and make them
@@ -284,12 +290,12 @@ struct ddog_prof_Profile_UpscalingRuleAddResult ddog_prof_Profile_add_upscaling_
  * This call is _NOT_ thread-safe.
  */
 DDOG_CHECK_RETURN
-struct ddog_prof_Profile_UpscalingRuleAddResult ddog_prof_Profile_add_upscaling_rule_proportional(struct ddog_prof_Profile *profile,
-                                                                                                  struct ddog_prof_Slice_Usize offset_values,
-                                                                                                  ddog_CharSlice label_name,
-                                                                                                  ddog_CharSlice label_value,
-                                                                                                  uint64_t total_sampled,
-                                                                                                  uint64_t total_real);
+struct ddog_prof_Profile_Result ddog_prof_Profile_add_upscaling_rule_proportional(struct ddog_prof_Profile *profile,
+                                                                                  struct ddog_prof_Slice_Usize offset_values,
+                                                                                  ddog_CharSlice label_name,
+                                                                                  ddog_CharSlice label_value,
+                                                                                  uint64_t total_sampled,
+                                                                                  uint64_t total_real);
 
 /**
  * # Safety
@@ -301,6 +307,7 @@ void ddog_prof_EncodedProfile_drop(struct ddog_prof_EncodedProfile *profile);
 
 /**
  * Serialize the aggregated profile.
+ * Drains the data, and then resets the profile for future use.
  *
  * Don't forget to clean up the ok with `ddog_prof_EncodedProfile_drop` or
  * the error variant with `ddog_Error_drop` when you are done with them.
@@ -314,6 +321,7 @@ void ddog_prof_EncodedProfile_drop(struct ddog_prof_EncodedProfile *profile);
  *                      under anomalous conditions this may fail as system clocks can be adjusted,
  *                      or the programmer accidentally passed an earlier time. The duration of
  *                      the serialized profile will be set to zero for these cases.
+ * * `start_time` - Optional start time for the next profile.
  *
  * # Safety
  * The `profile` must point to a valid profile object.
@@ -321,9 +329,10 @@ void ddog_prof_EncodedProfile_drop(struct ddog_prof_EncodedProfile *profile);
  * The `duration_nanos` must be null or otherwise point to a valid i64.
  */
 DDOG_CHECK_RETURN
-struct ddog_prof_Profile_SerializeResult ddog_prof_Profile_serialize(const struct ddog_prof_Profile *profile,
+struct ddog_prof_Profile_SerializeResult ddog_prof_Profile_serialize(struct ddog_prof_Profile *profile,
                                                                      const struct ddog_Timespec *end_time,
-                                                                     const int64_t *duration_nanos);
+                                                                     const int64_t *duration_nanos,
+                                                                     const struct ddog_Timespec *start_time);
 
 DDOG_CHECK_RETURN struct ddog_Slice_U8 ddog_Vec_U8_as_slice(const struct ddog_Vec_U8 *vec);
 
@@ -341,7 +350,8 @@ DDOG_CHECK_RETURN struct ddog_Slice_U8 ddog_Vec_U8_as_slice(const struct ddog_Ve
  * can be called across an FFI boundary, the compiler cannot enforce this.
  * If `time` is not null, it must point to a valid Timespec object.
  */
-bool ddog_prof_Profile_reset(struct ddog_prof_Profile *profile,
-                             const struct ddog_Timespec *start_time);
+DDOG_CHECK_RETURN
+struct ddog_prof_Profile_Result ddog_prof_Profile_reset(struct ddog_prof_Profile *profile,
+                                                        const struct ddog_Timespec *start_time);
 
 #endif /* DDOG_PROFILING_H */

data/vendor/{libdatadog-3.0.0 → libdatadog-5.0.0}/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu/lib/pkgconfig/datadog_profiling_with_rpath.pc

@@ -10,7 +10,7 @@ includedir=${prefix}/include
 
 Name: datadog_profiling
 Description: Contains common code used to implement Datadog's Continuous Profilers. (Dynamic linking variant, sets rpath)
-Version: 3.0.0
+Version: 
 Requires:
 Libs: -L${libdir} -ldatadog_profiling -Wl,-rpath,${libdir}
 Libs.private: