libdatadog 0.7.0.1.1-aarch64-linux → 0.8.0.1.0-aarch64-linux

data/vendor/libdatadog-0.7.0/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl/include/ddprof/ffi.h

@@ -1,591 +0,0 @@
-// 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 DDPROF_FFI_H
-#define DDPROF_FFI_H
-
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#define DDPROF_FFI_CHARSLICE_C(string) \
-  /* NOTE: Compilation fails if you pass in a char* instead of a literal */ ((ddprof_ffi_CharSlice) {.ptr = "" string, .len = sizeof(string) - 1})
-
-typedef struct ddprof_ffi_CancellationToken ddprof_ffi_CancellationToken;
-
-typedef struct ddprof_ffi_Profile ddprof_ffi_Profile;
-
-typedef struct ddprof_ffi_ProfileExporterV3 ddprof_ffi_ProfileExporterV3;
-
-/**
- * This type only exists to workaround a bug in cbindgen; may be removed in the
- * future.
- */
-typedef struct ddprof_ffi_Request ddprof_ffi_Request;
-
-typedef struct ddprof_ffi_Tag ddprof_ffi_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 ddprof_ffi_Vec_u8 {
-  const uint8_t *ptr;
-  uintptr_t len;
-  uintptr_t capacity;
-} ddprof_ffi_Vec_u8;
-
-typedef enum ddprof_ffi_NewProfileExporterV3Result_Tag {
-  DDPROF_FFI_NEW_PROFILE_EXPORTER_V3_RESULT_OK,
-  DDPROF_FFI_NEW_PROFILE_EXPORTER_V3_RESULT_ERR,
-} ddprof_ffi_NewProfileExporterV3Result_Tag;
-
-typedef struct ddprof_ffi_NewProfileExporterV3Result {
-  ddprof_ffi_NewProfileExporterV3Result_Tag tag;
-  union {
-    struct {
-      struct ddprof_ffi_ProfileExporterV3 *ok;
-    };
-    struct {
-      struct ddprof_ffi_Vec_u8 err;
-    };
-  };
-} ddprof_ffi_NewProfileExporterV3Result;
-
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
-typedef struct ddprof_ffi_Slice_c_char {
-  const char *ptr;
-  uintptr_t len;
-} ddprof_ffi_Slice_c_char;
-
-typedef struct ddprof_ffi_Slice_c_char ddprof_ffi_CharSlice;
-
-typedef enum ddprof_ffi_EndpointV3_Tag {
-  DDPROF_FFI_ENDPOINT_V3_AGENT,
-  DDPROF_FFI_ENDPOINT_V3_AGENTLESS,
-} ddprof_ffi_EndpointV3_Tag;
-
-typedef struct ddprof_ffi_EndpointV3_ddprof_ffi_Agentless_Body {
-  ddprof_ffi_CharSlice _0;
-  ddprof_ffi_CharSlice _1;
-} ddprof_ffi_EndpointV3_ddprof_ffi_Agentless_Body;
-
-typedef struct ddprof_ffi_EndpointV3 {
-  ddprof_ffi_EndpointV3_Tag tag;
-  union {
-    struct {
-      ddprof_ffi_CharSlice agent;
-    };
-    ddprof_ffi_EndpointV3_ddprof_ffi_Agentless_Body AGENTLESS;
-  };
-} ddprof_ffi_EndpointV3;
-
-/**
- * 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 ddprof_ffi_Vec_tag {
-  const struct ddprof_ffi_Tag *ptr;
-  uintptr_t len;
-  uintptr_t capacity;
-} ddprof_ffi_Vec_tag;
-
-/**
- * Represents time since the Unix Epoch in seconds plus nanoseconds.
- */
-typedef struct ddprof_ffi_Timespec {
-  int64_t seconds;
-  uint32_t nanoseconds;
-} ddprof_ffi_Timespec;
-
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
-typedef struct ddprof_ffi_Slice_u8 {
-  const uint8_t *ptr;
-  uintptr_t len;
-} ddprof_ffi_Slice_u8;
-
-/**
- * Use to represent bytes -- does not need to be valid UTF-8.
- */
-typedef struct ddprof_ffi_Slice_u8 ddprof_ffi_ByteSlice;
-
-typedef struct ddprof_ffi_File {
-  ddprof_ffi_CharSlice name;
-  ddprof_ffi_ByteSlice file;
-} ddprof_ffi_File;
-
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
-typedef struct ddprof_ffi_Slice_file {
-  const struct ddprof_ffi_File *ptr;
-  uintptr_t len;
-} ddprof_ffi_Slice_file;
-
-typedef struct ddprof_ffi_HttpStatus {
-  uint16_t code;
-} ddprof_ffi_HttpStatus;
-
-typedef enum ddprof_ffi_SendResult_Tag {
-  DDPROF_FFI_SEND_RESULT_HTTP_RESPONSE,
-  DDPROF_FFI_SEND_RESULT_ERR,
-} ddprof_ffi_SendResult_Tag;
-
-typedef struct ddprof_ffi_SendResult {
-  ddprof_ffi_SendResult_Tag tag;
-  union {
-    struct {
-      struct ddprof_ffi_HttpStatus http_response;
-    };
-    struct {
-      struct ddprof_ffi_Vec_u8 err;
-    };
-  };
-} ddprof_ffi_SendResult;
-
-typedef struct ddprof_ffi_ValueType {
-  ddprof_ffi_CharSlice type_;
-  ddprof_ffi_CharSlice unit;
-} ddprof_ffi_ValueType;
-
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
-typedef struct ddprof_ffi_Slice_value_type {
-  const struct ddprof_ffi_ValueType *ptr;
-  uintptr_t len;
-} ddprof_ffi_Slice_value_type;
-
-typedef struct ddprof_ffi_Period {
-  struct ddprof_ffi_ValueType type_;
-  int64_t value;
-} ddprof_ffi_Period;
-
-typedef struct ddprof_ffi_Mapping {
-  /**
-   * Address at which the binary (or DLL) is loaded into memory.
-   */
-  uint64_t memory_start;
-  /**
-   * The limit of the address range occupied by this mapping.
-   */
-  uint64_t memory_limit;
-  /**
-   * Offset in the binary that corresponds to the first mapped address.
-   */
-  uint64_t file_offset;
-  /**
-   * The object this entry is loaded from.  This can be a filename on
-   * disk for the main binary and shared libraries, or virtual
-   * abstractions like "[vdso]".
-   */
-  ddprof_ffi_CharSlice filename;
-  /**
-   * A string that uniquely identifies a particular program version
-   * with high probability. E.g., for binaries generated by GNU tools,
-   * it could be the contents of the .note.gnu.build-id field.
-   */
-  ddprof_ffi_CharSlice build_id;
-} ddprof_ffi_Mapping;
-
-typedef struct ddprof_ffi_Function {
-  /**
-   * Name of the function, in human-readable form if available.
-   */
-  ddprof_ffi_CharSlice name;
-  /**
-   * Name of the function, as identified by the system.
-   * For instance, it can be a C++ mangled name.
-   */
-  ddprof_ffi_CharSlice system_name;
-  /**
-   * Source file containing the function.
-   */
-  ddprof_ffi_CharSlice filename;
-  /**
-   * Line number in source file.
-   */
-  int64_t start_line;
-} ddprof_ffi_Function;
-
-typedef struct ddprof_ffi_Line {
-  /**
-   * The corresponding profile.Function for this line.
-   */
-  struct ddprof_ffi_Function function;
-  /**
-   * Line number in source code.
-   */
-  int64_t line;
-} ddprof_ffi_Line;
-
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
-typedef struct ddprof_ffi_Slice_line {
-  const struct ddprof_ffi_Line *ptr;
-  uintptr_t len;
-} ddprof_ffi_Slice_line;
-
-typedef struct ddprof_ffi_Location {
-  /**
-   * todo: how to handle unknown mapping?
-   */
-  struct ddprof_ffi_Mapping mapping;
-  /**
-   * 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;
-  /**
-   * 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 ddprof_ffi_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;
-} ddprof_ffi_Location;
-
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
-typedef struct ddprof_ffi_Slice_location {
-  const struct ddprof_ffi_Location *ptr;
-  uintptr_t len;
-} ddprof_ffi_Slice_location;
-
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
-typedef struct ddprof_ffi_Slice_i64 {
-  const int64_t *ptr;
-  uintptr_t len;
-} ddprof_ffi_Slice_i64;
-
-typedef struct ddprof_ffi_Label {
-  ddprof_ffi_CharSlice key;
-  /**
-   * At most one of the following must be present
-   */
-  ddprof_ffi_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.
-   */
-  ddprof_ffi_CharSlice num_unit;
-} ddprof_ffi_Label;
-
-/**
- * Remember, the data inside of each member is potentially coming from FFI,
- * so every operation on it is unsafe!
- */
-typedef struct ddprof_ffi_Slice_label {
-  const struct ddprof_ffi_Label *ptr;
-  uintptr_t len;
-} ddprof_ffi_Slice_label;
-
-typedef struct ddprof_ffi_Sample {
-  /**
-   * The leaf is at locations[0].
-   */
-  struct ddprof_ffi_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
-   * 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 ddprof_ffi_Slice_i64 values;
-  /**
-   * label includes additional context for this sample. It can include
-   * things like a thread id, allocation size, etc
-   */
-  struct ddprof_ffi_Slice_label labels;
-} ddprof_ffi_Sample;
-
-typedef struct ddprof_ffi_EncodedProfile {
-  struct ddprof_ffi_Timespec start;
-  struct ddprof_ffi_Timespec end;
-  struct ddprof_ffi_Vec_u8 buffer;
-} ddprof_ffi_EncodedProfile;
-
-typedef enum ddprof_ffi_SerializeResult_Tag {
-  DDPROF_FFI_SERIALIZE_RESULT_OK,
-  DDPROF_FFI_SERIALIZE_RESULT_ERR,
-} ddprof_ffi_SerializeResult_Tag;
-
-typedef struct ddprof_ffi_SerializeResult {
-  ddprof_ffi_SerializeResult_Tag tag;
-  union {
-    struct {
-      struct ddprof_ffi_EncodedProfile ok;
-    };
-    struct {
-      struct ddprof_ffi_Vec_u8 err;
-    };
-  };
-} ddprof_ffi_SerializeResult;
-
-typedef enum ddprof_ffi_PushTagResult_Tag {
-  DDPROF_FFI_PUSH_TAG_RESULT_OK,
-  DDPROF_FFI_PUSH_TAG_RESULT_ERR,
-} ddprof_ffi_PushTagResult_Tag;
-
-typedef struct ddprof_ffi_PushTagResult {
-  ddprof_ffi_PushTagResult_Tag tag;
-  union {
-    struct {
-      struct ddprof_ffi_Vec_u8 err;
-    };
-  };
-} ddprof_ffi_PushTagResult;
-
-typedef struct ddprof_ffi_ParseTagsResult {
-  struct ddprof_ffi_Vec_tag tags;
-  struct ddprof_ffi_Vec_u8 *error_message;
-} ddprof_ffi_ParseTagsResult;
-
-void ddprof_ffi_NewProfileExporterV3Result_drop(struct ddprof_ffi_NewProfileExporterV3Result result);
-
-/**
- * Creates an endpoint that uses the agent.
- * # Arguments
- * * `base_url` - Contains a URL with scheme, host, and port e.g. "https://agent:8126/".
- */
-struct ddprof_ffi_EndpointV3 ddprof_ffi_EndpointV3_agent(ddprof_ffi_CharSlice base_url);
-
-/**
- * Creates an endpoint that uses the Datadog intake directly aka agentless.
- * # Arguments
- * * `site` - Contains a host and port e.g. "datadoghq.com".
- * * `api_key` - Contains the Datadog API key.
- */
-struct ddprof_ffi_EndpointV3 ddprof_ffi_EndpointV3_agentless(ddprof_ffi_CharSlice site,
-                                                             ddprof_ffi_CharSlice api_key);
-
-__attribute__((warn_unused_result))
-struct ddprof_ffi_NewProfileExporterV3Result ddprof_ffi_ProfileExporterV3_new(ddprof_ffi_CharSlice family,
-                                                                              const struct ddprof_ffi_Vec_tag *tags,
-                                                                              struct ddprof_ffi_EndpointV3 endpoint);
-
-void ddprof_ffi_ProfileExporterV3_delete(struct ddprof_ffi_ProfileExporterV3 *exporter);
-
-/**
- * Builds a Request object based on the profile data supplied.
- *
- * # Safety
- * The `exporter` and the files inside of the `files` slice need to have been
- * created by this module.
- */
-struct ddprof_ffi_Request *ddprof_ffi_ProfileExporterV3_build(struct ddprof_ffi_ProfileExporterV3 *exporter,
-                                                              struct ddprof_ffi_Timespec start,
-                                                              struct ddprof_ffi_Timespec end,
-                                                              struct ddprof_ffi_Slice_file files,
-                                                              const struct ddprof_ffi_Vec_tag *additional_tags,
-                                                              uint64_t timeout_ms);
-
-/**
- * Sends the request, returning the HttpStatus.
- *
- * # Arguments
- * * `exporter` - borrows the exporter for sending the request
- * * `request` - takes ownership of the request
- * * `cancel` - borrows the cancel, if any
- *
- * # Safety
- * All non-null arguments MUST have been created by created by apis in this module.
- */
-__attribute__((warn_unused_result))
-struct ddprof_ffi_SendResult ddprof_ffi_ProfileExporterV3_send(struct ddprof_ffi_ProfileExporterV3 *exporter,
-                                                               struct ddprof_ffi_Request *request,
-                                                               struct ddprof_ffi_CancellationToken *cancel);
-
-void ddprof_ffi_Request_drop(struct ddprof_ffi_Request *_request);
-
-/**
- * Can be passed as an argument to send and then be used to asynchronously cancel it from a different thread.
- */
-__attribute__((warn_unused_result))
-struct ddprof_ffi_CancellationToken *ddprof_ffi_CancellationToken_new(void);
-
-/**
- * A cloned CancellationToken is connected to the CancellationToken it was created from.
- * Either the cloned or the original token can be used to cancel or provided as arguments to send.
- * The useful part is that they have independent lifetimes and can be dropped separately.
- *
- * Thus, it's possible to do something like:
- * ```c
- * cancel_t1 = ddprof_ffi_CancellationToken_new();
- * cancel_t2 = ddprof_ffi_CancellationToken_clone(cancel_t1);
- *
- * // On thread t1:
- *     ddprof_ffi_ProfileExporterV3_send(..., cancel_t1);
- *     ddprof_ffi_CancellationToken_drop(cancel_t1);
- *
- * // On thread t2:
- *     ddprof_ffi_CancellationToken_cancel(cancel_t2);
- *     ddprof_ffi_CancellationToken_drop(cancel_t2);
- * ```
- *
- * Without clone, both t1 and t2 would need to synchronize to make sure neither was using the cancel
- * before it could be dropped. With clone, there is no need for such synchronization, both threads
- * have their own cancel and should drop that cancel after they are done with it.
- */
-__attribute__((warn_unused_result))
-struct ddprof_ffi_CancellationToken *ddprof_ffi_CancellationToken_clone(struct ddprof_ffi_CancellationToken *cancel);
-
-/**
- * Cancel send that is being called in another thread with the given token.
- * Note that cancellation is a terminal state; cancelling a token more than once does nothing.
- * Returns `true` if token was successfully cancelled.
- */
-bool ddprof_ffi_CancellationToken_cancel(struct ddprof_ffi_CancellationToken *cancel);
-
-void ddprof_ffi_CancellationToken_drop(struct ddprof_ffi_CancellationToken *_cancel);
-
-void ddprof_ffi_SendResult_drop(struct ddprof_ffi_SendResult result);
-
-/**
- * Create a new profile with the given sample types. Must call
- * `ddprof_ffi_Profile_free` when you are done with the profile.
- *
- * # Arguments
- * * `sample_types`
- * * `period` - Optional period of the profile. Passing None/null translates to zero values.
- * * `start_time` - Optional time the profile started at. Passing None/null will use the current
- *                  time.
- *
- * # Safety
- * All slices must be have pointers that are suitably aligned for their type
- * and must have the correct number of elements for the slice.
- */
-__attribute__((warn_unused_result))
-struct ddprof_ffi_Profile *ddprof_ffi_Profile_new(struct ddprof_ffi_Slice_value_type sample_types,
-                                                  const struct ddprof_ffi_Period *period,
-                                                  const struct ddprof_ffi_Timespec *start_time);
-
-/**
- * # Safety
- * The `profile` must point to an object created by another FFI routine in this
- * module, such as `ddprof_ffi_Profile_with_sample_types`.
- */
-void ddprof_ffi_Profile_free(struct ddprof_ffi_Profile *_profile);
-
-/**
- * # Safety
- * The `profile` ptr must point to a valid Profile object created by this
- * module. All pointers inside the `sample` need to be valid for the duration
- * of this call.
- * This call is _NOT_ thread-safe.
- */
-uint64_t ddprof_ffi_Profile_add(struct ddprof_ffi_Profile *profile,
-                                struct ddprof_ffi_Sample sample);
-
-/**
- * Serialize the aggregated profile. Don't forget to clean up the result by
- * calling ddprof_ffi_SerializeResult_drop.
- *
- * # Arguments
- * * `profile` - a reference to the profile being serialized.
- * * `end_time` - optional end time of the profile. If None/null is passed, the current time will
- *                be used.
- * * `duration_nanos` - Optional duration of the profile. Passing None or a negative duration will
- *                      mean the duration will based on the end time minus the start time, but
- *                      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.
- *
- * # Safety
- * The `profile` must point to a valid profile object.
- * The `end_time` must be null or otherwise point to a valid TimeSpec object.
- * The `duration_nanos` must be null or otherwise point to a valid i64.
- */
-struct ddprof_ffi_SerializeResult ddprof_ffi_Profile_serialize(const struct ddprof_ffi_Profile *profile,
-                                                               const struct ddprof_ffi_Timespec *end_time,
-                                                               const int64_t *duration_nanos);
-
-void ddprof_ffi_SerializeResult_drop(struct ddprof_ffi_SerializeResult _result);
-
-__attribute__((warn_unused_result))
-struct ddprof_ffi_Slice_u8 ddprof_ffi_Vec_u8_as_slice(const struct ddprof_ffi_Vec_u8 *vec);
-
-/**
- * Resets all data in `profile` except the sample types and period. Returns
- * true if it successfully reset the profile and false otherwise. The profile
- * remains valid if false is returned.
- *
- * # Arguments
- * * `profile` - A mutable reference to the profile to be reset.
- * * `start_time` - The time of the profile (after reset). Pass None/null to use the current time.
- *
- * # Safety
- * The `profile` must meet all the requirements of a mutable reference to the profile. Given this
- * 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 ddprof_ffi_Profile_reset(struct ddprof_ffi_Profile *profile,
-                              const struct ddprof_ffi_Timespec *start_time);
-
-__attribute__((warn_unused_result)) struct ddprof_ffi_Vec_tag ddprof_ffi_Vec_tag_new(void);
-
-void ddprof_ffi_Vec_tag_drop(struct ddprof_ffi_Vec_tag);
-
-void ddprof_ffi_PushTagResult_drop(struct ddprof_ffi_PushTagResult);
-
-/**
- * Creates a new Tag from the provided `key` and `value` by doing a utf8
- * lossy conversion, and pushes into the `vec`. The strings `key` and `value`
- * are cloned to avoid FFI lifetime issues.
- *
- * # Safety
- * The `vec` must be a valid reference.
- * The CharSlices `key` and `value` must point to at least many bytes as their
- * `.len` properties claim.
- */
-__attribute__((warn_unused_result))
-struct ddprof_ffi_PushTagResult ddprof_ffi_Vec_tag_push(struct ddprof_ffi_Vec_tag *vec,
-                                                        ddprof_ffi_CharSlice key,
-                                                        ddprof_ffi_CharSlice value);
-
-__attribute__((warn_unused_result))
-struct ddprof_ffi_ParseTagsResult ddprof_ffi_Vec_tag_parse(ddprof_ffi_CharSlice string);
-
-#endif /* DDPROF_FFI_H */