libddprof 0.2.0.beta1-x86_64-linux

data/vendor/libddprof-0.2.0/x86_64-linux/libddprof-x86_64-unknown-linux-gnu/NOTICE

@@ -0,0 +1,4 @@
+Datadog libddprof
+Copyright 2021 Datadog, Inc.
+
+This product includes software developed at Datadog (<https://www.datadoghq.com/>).

data/vendor/libddprof-0.2.0/x86_64-linux/libddprof-x86_64-unknown-linux-gnu/cmake/DDProfConfig.cmake

@@ -0,0 +1,41 @@
+# 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.
+include(FindPackageHandleStandardArgs)
+
+if (DEFINED ENV{DDProf_ROOT})
+  set(DDProf_ROOT "$ENV{DDProf_ROOT}")
+else ()
+  # If the environment variable is not set, maybe we are part of a build
+  set(DDProf_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/..")
+endif ()
+
+find_path(DDProf_INCLUDE_DIR ddprof/ffi.h
+  HINTS ${DDProf_ROOT}/include
+)
+
+find_library(DDProf_FFI_LIBRARY NAMES ddprof_ffi
+  HINTS ${DDProf_ROOT}/lib
+)
+
+find_package_handle_standard_args(DDProf DEFAULT_MSG
+  DDProf_FFI_LIBRARY
+  DDProf_INCLUDE_DIR
+)
+
+if (DDProf_FOUND)
+  set(DDProf_INCLUDE_DIRS ${DDProf_INCLUDE_DIR})
+  set(DDProf_LIBRARIES ${DDProf_FFI_LIBRARY}  -ldl -lrt -lpthread -lc -lm -lrt -lpthread -lutil -ldl -lutil)
+  mark_as_advanced(
+    DDProf_ROOT
+    DDProf_FFI_LIBRARY
+    DDProf_INCLUDE_DIR
+  )
+
+  add_library(ddprof-ffi INTERFACE)
+  target_include_directories(ddprof-ffi INTERFACE ${DDProf_INCLUDE_DIRS})
+  target_link_libraries(ddprof-ffi INTERFACE ${DDProf_LIBRARIES})
+  target_compile_features(ddprof-ffi INTERFACE c_std_11)
+  add_library(DDProf::FFI ALIAS ddprof-ffi)
+else ()
+  set(DDProf_ROOT "" CACHE STRING "Directory containing libddprof")
+endif ()

data/vendor/libddprof-0.2.0/x86_64-linux/libddprof-x86_64-unknown-linux-gnu/include/ddprof/ffi.h

@@ -0,0 +1,455 @@
+// 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>
+
+typedef struct ddprof_ffi_Exporter ddprof_ffi_Exporter;
+
+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;
+
+/**
+ * Buffer holds the raw parts of a Rust Vec; it should only be created from
+ * Rust, never from C.
+ */
+typedef struct ddprof_ffi_Buffer {
+  const uint8_t *ptr;
+  size_t len;
+  size_t capacity;
+} ddprof_ffi_Buffer;
+
+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_Buffer err;
+    };
+  };
+} ddprof_ffi_NewProfileExporterV3Result;
+
+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_FAILURE,
+} 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_Buffer failure;
+    };
+  };
+} ddprof_ffi_SendResult;
+
+typedef struct ddprof_ffi_Slice_u8 {
+  const uint8_t *ptr;
+  size_t len;
+} ddprof_ffi_Slice_u8;
+
+typedef struct ddprof_ffi_Slice_u8 ddprof_ffi_ByteSlice;
+
+typedef struct ddprof_ffi_Field {
+  const char *name;
+  ddprof_ffi_ByteSlice value;
+} ddprof_ffi_Field;
+
+typedef struct ddprof_ffi_Slice_field {
+  const struct ddprof_ffi_Field *ptr;
+  size_t len;
+} ddprof_ffi_Slice_field;
+
+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_ByteSlice _0;
+  ddprof_ffi_ByteSlice _1;
+} ddprof_ffi_EndpointV3_ddprof_ffi_Agentless_Body;
+
+typedef struct ddprof_ffi_EndpointV3 {
+  ddprof_ffi_EndpointV3_Tag tag;
+  union {
+    struct {
+      ddprof_ffi_ByteSlice agent;
+    };
+    ddprof_ffi_EndpointV3_ddprof_ffi_Agentless_Body AGENTLESS;
+  };
+} ddprof_ffi_EndpointV3;
+
+typedef struct ddprof_ffi_Tag {
+  ddprof_ffi_ByteSlice name;
+  ddprof_ffi_ByteSlice value;
+} ddprof_ffi_Tag;
+
+typedef struct ddprof_ffi_Slice_tag {
+  const struct ddprof_ffi_Tag *ptr;
+  size_t len;
+} ddprof_ffi_Slice_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;
+
+typedef struct ddprof_ffi_File {
+  ddprof_ffi_ByteSlice name;
+  struct ddprof_ffi_Buffer *file;
+} ddprof_ffi_File;
+
+typedef struct ddprof_ffi_Slice_file {
+  const struct ddprof_ffi_File *ptr;
+  size_t len;
+} ddprof_ffi_Slice_file;
+
+typedef struct ddprof_ffi_Slice_c_char {
+  const char *ptr;
+  size_t len;
+} ddprof_ffi_Slice_c_char;
+
+typedef struct ddprof_ffi_ValueType {
+  struct ddprof_ffi_Slice_c_char type_;
+  struct ddprof_ffi_Slice_c_char unit;
+} ddprof_ffi_ValueType;
+
+typedef struct ddprof_ffi_Slice_value_type {
+  const struct ddprof_ffi_ValueType *ptr;
+  size_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]".
+   */
+  struct ddprof_ffi_Slice_c_char 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.
+   */
+  struct ddprof_ffi_Slice_c_char build_id;
+} ddprof_ffi_Mapping;
+
+typedef struct ddprof_ffi_Function {
+  /**
+   * Name of the function, in human-readable form if available.
+   */
+  struct ddprof_ffi_Slice_c_char name;
+  /**
+   * Name of the function, as identified by the system.
+   * For instance, it can be a C++ mangled name.
+   */
+  struct ddprof_ffi_Slice_c_char system_name;
+  /**
+   * Source file containing the function.
+   */
+  struct ddprof_ffi_Slice_c_char 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;
+
+typedef struct ddprof_ffi_Slice_line {
+  const struct ddprof_ffi_Line *ptr;
+  size_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;
+
+typedef struct ddprof_ffi_Slice_location {
+  const struct ddprof_ffi_Location *ptr;
+  size_t len;
+} ddprof_ffi_Slice_location;
+
+typedef struct ddprof_ffi_Slice_i64 {
+  const int64_t *ptr;
+  size_t len;
+} ddprof_ffi_Slice_i64;
+
+typedef struct ddprof_ffi_Label {
+  struct ddprof_ffi_Slice_c_char key;
+  /**
+   * At most one of the following must be present
+   */
+  struct ddprof_ffi_Slice_c_char 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.
+   */
+  struct ddprof_ffi_Slice_c_char num_unit;
+} ddprof_ffi_Label;
+
+typedef struct ddprof_ffi_Slice_label {
+  const struct ddprof_ffi_Label *ptr;
+  size_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_Buffer buffer;
+} ddprof_ffi_EncodedProfile;
+
+void ddprof_ffi_NewProfileExporterV3Result_dtor(struct ddprof_ffi_NewProfileExporterV3Result result);
+
+/**
+ * Create a new Exporter, initializing the TLS stack.
+ */
+struct ddprof_ffi_Exporter *ddprof_ffi_Exporter_new(void);
+
+/**
+ * # Safety
+ * All pointers must point to valid objects for that type. If they are used as
+ * arrays, such as in Slice, then they must be valid for the associated number
+ * of elements. All pointers must be aligned.
+ */
+struct ddprof_ffi_SendResult ddprof_ffi_Exporter_send(struct ddprof_ffi_Exporter *exporter_ptr,
+                                                      const char *http_method,
+                                                      const char *url,
+                                                      struct ddprof_ffi_Slice_field headers,
+                                                      ddprof_ffi_ByteSlice body,
+                                                      uint64_t timeout_ms);
+
+/**
+ * Clears the contents of the Buffer, leaving length and capacity of 0.
+ * # Safety
+ * The `buffer` must be created by Rust, or null.
+ */
+void ddprof_ffi_Buffer_reset(struct ddprof_ffi_Buffer *buffer);
+
+/**
+ * Destroys the Exporter.
+ */
+void ddprof_ffi_Exporter_delete(struct ddprof_ffi_Exporter *exporter);
+
+/**
+ * Creates an endpoint that uses the agent.
+ * # Arguments
+ * * `base_url` - a ByteSlice which contains a URL with scheme, host, and port
+ *                e.g. "https://agent:8126/"
+ */
+struct ddprof_ffi_EndpointV3 ddprof_ffi_EndpointV3_agent(ddprof_ffi_ByteSlice base_url);
+
+/**
+ * Creates an endpoint that uses the Datadog intake directly aka agentless.
+ * # Arguments
+ * * `site` - a ByteSlice which contains a host and port e.g.
+ *            "datadoghq.com"
+ * * `api_key` - A ByteSlice which contains the Datadog API key.
+ */
+struct ddprof_ffi_EndpointV3 ddprof_ffi_EndpointV3_agentless(ddprof_ffi_ByteSlice site,
+                                                             ddprof_ffi_ByteSlice api_key);
+
+struct ddprof_ffi_NewProfileExporterV3Result ddprof_ffi_ProfileExporterV3_new(ddprof_ffi_ByteSlice family,
+                                                                              struct ddprof_ffi_Slice_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,
+                                                              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
+ *
+ * # Safety
+ * If the `exporter` and `request` are non-null, then they need to have been
+ * created by apis in this module.
+ */
+struct ddprof_ffi_SendResult ddprof_ffi_ProfileExporterV3_send(struct ddprof_ffi_ProfileExporterV3 *exporter,
+                                                               struct ddprof_ffi_Request *request);
+
+/**
+ * Create a new profile with the given sample types. Must call
+ * `ddprof_ffi_Profile_free` when you are done with the profile.
+ * # 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);
+
+/**
+ * # 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);
+
+/**
+ * Destroys the `encoded_profile`
+ * # Safety
+ * Only safe on profiles created by `ddprof_ffi_Profile_serialize`.
+ */
+void ddprof_ffi_EncodedProfile_delete(struct ddprof_ffi_EncodedProfile *encoded_profile);
+
+/**
+ * Serialize the aggregated profile. Be sure to check the return value and if
+ * it's non-null then call `ddprof_ffi_EncodedProfile_delete` on it once
+ * done with it.
+ * result to free it.
+ */
+__attribute__((warn_unused_result))
+struct ddprof_ffi_EncodedProfile *ddprof_ffi_Profile_serialize(const struct ddprof_ffi_Profile *profile);
+
+/**
+ * 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.
+ */
+bool ddprof_ffi_Profile_reset(struct ddprof_ffi_Profile *profile);
+
+/**
+ * # Safety
+ * Only pass buffers which were created by ddprof routines; do not create one
+ * in C and then pass it in. Only call this once per buffer.
+ */
+void ddprof_ffi_Buffer_free(struct ddprof_ffi_Buffer *buffer);
+
+#endif /* DDPROF_FFI_H */

data/vendor/libddprof-0.2.0/x86_64-linux/libddprof-x86_64-unknown-linux-gnu/lib/pkgconfig/ddprof_ffi.pc

@@ -0,0 +1,17 @@
+# 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.
+
+prefix=${pcfiledir}/../..
+exec_prefix=${prefix}
+libdir=${exec_prefix}/lib
+includedir=${prefix}/include
+
+Name: ddprof_ffi
+Description: Contains common code used to implement Datadog's Continuous Profilers.
+Version: 0.2.0
+Requires:
+Libs: -L${libdir} -lddprof_ffi  -ldl -lrt -lpthread -lc -lm -lrt -lpthread -lutil -ldl -lutil
+Libs.private:
+Cflags: -I${includedir}