libddprof 0.2.0.1.0.beta3 → 0.6.0.1.0

data/vendor/libddprof-0.6.0/x86_64-linux-musl/libddprof-x86_64-alpine-linux-musl/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.6.0/x86_64-linux-musl/libddprof-x86_64-alpine-linux-musl/include/ddprof/ffi.h

@@ -0,0 +1,555 @@
+// 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_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_Vec_u8 failure;
+    };
+  };
+} 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);
+
+/**
+ * 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.
+ * # 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);
+
+/**
+ * Serialize the aggregated profile. Don't forget to clean up the result by
+ * calling ddprof_ffi_SerializeResult_drop.
+ */
+__attribute__((warn_unused_result))
+struct ddprof_ffi_SerializeResult ddprof_ffi_Profile_serialize(const struct ddprof_ffi_Profile *profile);
+
+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.
+ */
+bool ddprof_ffi_Profile_reset(struct ddprof_ffi_Profile *profile);
+
+__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 */

data/vendor/libddprof-0.6.0/x86_64-linux-musl/libddprof-x86_64-alpine-linux-musl/lib/pkgconfig/ddprof_ffi_with_rpath.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. (Dynamic linking variant, sets rpath)
+Version: 0.6.0
+Requires:
+Libs: -L${libdir} -lddprof_ffi -Wl,-rpath,${libdir}
+Libs.private:
+Cflags: -I${includedir}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libddprof
 version: !ruby/object:Gem::Version
-  version: 0.2.0.1.0.beta3
+  version: 0.6.0.1.0
 platform: ruby
 authors:
 - Datadog, Inc.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-02 00:00:00.000000000 Z
+date: 2022-05-16 00:00:00.000000000 Z
 dependencies: []
 description: libddprof contains implementation bits used by Datadog's ddtrace gem
   as part of its Continuous Profiler feature.
@@ -18,14 +18,32 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".rspec"
-- ".standard.yml"
-- README.md
-- Rakefile
-- docker-compose.yml
-- gems.rb
 - lib/libddprof.rb
 - lib/libddprof/version.rb
+- vendor/libddprof-0.6.0/aarch64-linux-musl/libddprof-aarch64-alpine-linux-musl/LICENSE
+- vendor/libddprof-0.6.0/aarch64-linux-musl/libddprof-aarch64-alpine-linux-musl/LICENSE-3rdparty.yml
+- vendor/libddprof-0.6.0/aarch64-linux-musl/libddprof-aarch64-alpine-linux-musl/NOTICE
+- vendor/libddprof-0.6.0/aarch64-linux-musl/libddprof-aarch64-alpine-linux-musl/include/ddprof/ffi.h
+- vendor/libddprof-0.6.0/aarch64-linux-musl/libddprof-aarch64-alpine-linux-musl/lib/libddprof_ffi.so
+- vendor/libddprof-0.6.0/aarch64-linux-musl/libddprof-aarch64-alpine-linux-musl/lib/pkgconfig/ddprof_ffi_with_rpath.pc
+- vendor/libddprof-0.6.0/aarch64-linux/libddprof-aarch64-unknown-linux-gnu/LICENSE
+- vendor/libddprof-0.6.0/aarch64-linux/libddprof-aarch64-unknown-linux-gnu/LICENSE-3rdparty.yml
+- vendor/libddprof-0.6.0/aarch64-linux/libddprof-aarch64-unknown-linux-gnu/NOTICE
+- vendor/libddprof-0.6.0/aarch64-linux/libddprof-aarch64-unknown-linux-gnu/include/ddprof/ffi.h
+- vendor/libddprof-0.6.0/aarch64-linux/libddprof-aarch64-unknown-linux-gnu/lib/libddprof_ffi.so
+- vendor/libddprof-0.6.0/aarch64-linux/libddprof-aarch64-unknown-linux-gnu/lib/pkgconfig/ddprof_ffi_with_rpath.pc
+- vendor/libddprof-0.6.0/x86_64-linux-musl/libddprof-x86_64-alpine-linux-musl/LICENSE
+- vendor/libddprof-0.6.0/x86_64-linux-musl/libddprof-x86_64-alpine-linux-musl/LICENSE-3rdparty.yml
+- vendor/libddprof-0.6.0/x86_64-linux-musl/libddprof-x86_64-alpine-linux-musl/NOTICE
+- vendor/libddprof-0.6.0/x86_64-linux-musl/libddprof-x86_64-alpine-linux-musl/include/ddprof/ffi.h
+- vendor/libddprof-0.6.0/x86_64-linux-musl/libddprof-x86_64-alpine-linux-musl/lib/libddprof_ffi.so
+- vendor/libddprof-0.6.0/x86_64-linux-musl/libddprof-x86_64-alpine-linux-musl/lib/pkgconfig/ddprof_ffi_with_rpath.pc
+- vendor/libddprof-0.6.0/x86_64-linux/libddprof-x86_64-unknown-linux-gnu/LICENSE
+- vendor/libddprof-0.6.0/x86_64-linux/libddprof-x86_64-unknown-linux-gnu/LICENSE-3rdparty.yml
+- vendor/libddprof-0.6.0/x86_64-linux/libddprof-x86_64-unknown-linux-gnu/NOTICE
+- vendor/libddprof-0.6.0/x86_64-linux/libddprof-x86_64-unknown-linux-gnu/include/ddprof/ffi.h
+- vendor/libddprof-0.6.0/x86_64-linux/libddprof-x86_64-unknown-linux-gnu/lib/libddprof_ffi.so
+- vendor/libddprof-0.6.0/x86_64-linux/libddprof-x86_64-unknown-linux-gnu/lib/pkgconfig/ddprof_ffi_with_rpath.pc
 homepage: https://docs.datadoghq.com/tracing/profiler/
 licenses:
 - Apache-2.0
@@ -45,11 +63,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: Library of common code used by Datadog Continuous Profiler for Ruby

data/.rspec

@@ -1,3 +0,0 @@
---format documentation
---color
---require spec_helper

data/.standard.yml

@@ -1,3 +0,0 @@
-# For available configuration options, see:
-#   https://github.com/testdouble/standard
-ruby_version: 2.1

data/README.md

@@ -1,29 +0,0 @@
-# libddprof Ruby gem
-
-`libddprof` provides a shared library containing common code used in the implementation of Datadog's
-[Continuous Profilers](https://docs.datadoghq.com/tracing/profiler/).
-
-**NOTE**: If you're building a new profiler or want to contribute to Datadog's existing profilers, you've come to the
-right place!
-Otherwise, this is possibly not the droid you were looking for.
-
-## Development
-
-Run `bundle exec rake` to run the tests and the style autofixer.
-You can also run `bundle exec pry` for an interactive prompt that will allow you to experiment.
-
-## Releasing a new version to rubygems.org
-
-Note: No Ruby needed to run this! It all runs inside docker :)
-
-1. [ ] Locate the new libddprof release on GitHub: <https://github.com/DataDog/libddprof/releases>
-2. [ ] Update the `LIB_GITHUB_RELEASES` section of the <Rakefile> with the new version
-3. [ ] Update the <lib/libddprof/version.rb> file with the `LIB_VERSION` and `VERSION` to use
-4. [ ] Commit change, open PR, get it merged
-5. [ ] Release by running `docker-compose run push_to_rubygems`.
-    (When asked for rubygems credentials, check your local friendly 1Password.)
-6. [ ] Verify that release shows up correctly on: <https://rubygems.org/gems/libddprof>
-
-## Contributing
-
-See <../CONTRIBUTING.md>.