libdatadog 6.0.0.2.0-aarch64-linux → 9.0.0.1.0-aarch64-linux

data/vendor/{libdatadog-6.0.0 → libdatadog-9.0.0}/aarch64-linux-musl/libdatadog-aarch64-alpine-linux-musl/include/datadog/common.h

@@ -1,5 +1,6 @@
-// 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.
+// Copyright 2021-Present Datadog, Inc. https://www.datadoghq.com/
+// SPDX-License-Identifier: Apache-2.0
+
 
 #ifndef DDOG_COMMON_H
 #define DDOG_COMMON_H
@@ -10,13 +11,11 @@
 #include <stddef.h>
 #include <stdint.h>
 
-#if defined(_MSC_VER)
-#define DDOG_CHARSLICE_C(string) \
-/* NOTE: Compilation fails if you pass in a char* instead of a literal */ {.ptr = "" string, .len = sizeof(string) - 1}
-#else
 #define DDOG_CHARSLICE_C(string) \
 /* NOTE: Compilation fails if you pass in a char* instead of a literal */ ((ddog_CharSlice){ .ptr = "" string, .len = sizeof(string) - 1 })
-#endif
+
+#define DDOG_CHARSLICE_C_BARE(string) \
+/* NOTE: Compilation fails if you pass in a char* instead of a literal */ { .ptr = "" string, .len = sizeof(string) - 1 }
 
 #if defined __GNUC__
 #  define DDOG_GNUC_VERSION(major) __GNUC__ >= major
@@ -84,6 +83,32 @@ typedef struct ddog_Slice_CChar {
  */
 typedef struct ddog_Slice_CChar ddog_CharSlice;
 
+typedef enum ddog_Option_Error_Tag {
+  DDOG_OPTION_ERROR_SOME_ERROR,
+  DDOG_OPTION_ERROR_NONE_ERROR,
+} ddog_Option_Error_Tag;
+
+typedef struct ddog_Option_Error {
+  ddog_Option_Error_Tag tag;
+  union {
+    struct {
+      struct ddog_Error some;
+    };
+  };
+} ddog_Option_Error;
+
+typedef struct ddog_Option_Error ddog_MaybeError;
+
+/**
+ * A wrapper for returning owned strings from FFI
+ */
+typedef struct ddog_StringWrapper {
+  /**
+   * This is a String stuffed into the vec.
+   */
+  struct ddog_Vec_U8 message;
+} ddog_StringWrapper;
+
 /**
  * Holds the raw parts of a Rust Vec; it should only be created from Rust,
  * never from C.
@@ -113,14 +138,10 @@ typedef struct ddog_Vec_Tag_ParseResult {
   struct ddog_Error *error_message;
 } ddog_Vec_Tag_ParseResult;
 
-typedef enum ddog_prof_CrashtrackerResolveFrames {
-  DDOG_PROF_CRASHTRACKER_RESOLVE_FRAMES_NEVER,
-  /**
-   * Resolving frames is experimental, and can fail/crash
-   */
-  DDOG_PROF_CRASHTRACKER_RESOLVE_FRAMES_EXPERIMENTAL_IN_PROCESS,
-  DDOG_PROF_CRASHTRACKER_RESOLVE_FRAMES_EXPERIMENTAL_IN_RECEIVER,
-} ddog_prof_CrashtrackerResolveFrames;
+typedef enum ddog_prof_DemangleOptions {
+  DDOG_PROF_DEMANGLE_OPTIONS_COMPLETE,
+  DDOG_PROF_DEMANGLE_OPTIONS_NAME_ONLY,
+} ddog_prof_DemangleOptions;
 
 /**
  * This enum represents operations a profiler might be engaged in.
@@ -144,6 +165,22 @@ typedef enum ddog_prof_ProfilingOpTypes {
   DDOG_PROF_PROFILING_OP_TYPES_SIZE,
 } ddog_prof_ProfilingOpTypes;
 
+/**
+ * Stacktrace collection occurs in the context of a crashing process.
+ * If the stack is sufficiently corruputed, it is possible (but unlikely),
+ * for stack trace collection itself to crash.
+ * We recommend fully enabling stacktrace collection, but having an environment
+ * variable to allow downgrading the collector.
+ */
+typedef enum ddog_prof_StacktraceCollection {
+  /**
+   * Stacktrace collection occurs in the
+   */
+  DDOG_PROF_STACKTRACE_COLLECTION_DISABLED,
+  DDOG_PROF_STACKTRACE_COLLECTION_WITHOUT_SYMBOLS,
+  DDOG_PROF_STACKTRACE_COLLECTION_ENABLED,
+} ddog_prof_StacktraceCollection;
+
 typedef struct ddog_CancellationToken ddog_CancellationToken;
 
 typedef struct ddog_prof_Exporter ddog_prof_Exporter;
@@ -153,16 +190,16 @@ typedef struct ddog_prof_ProfiledEndpointsStats ddog_prof_ProfiledEndpointsStats
 typedef struct ddog_prof_Exporter_Request ddog_prof_Exporter_Request;
 
 /**
- * A generic result type for when a profiling operation may fail, but there's
- * nothing to return in the case of success.
+ * A generic result type for when a crashtracking 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 enum ddog_prof_CrashtrackerResult_Tag {
+  DDOG_PROF_CRASHTRACKER_RESULT_OK,
+  DDOG_PROF_CRASHTRACKER_RESULT_ERR,
+} ddog_prof_CrashtrackerResult_Tag;
 
-typedef struct ddog_prof_Profile_Result {
-  ddog_prof_Profile_Result_Tag tag;
+typedef struct ddog_prof_CrashtrackerResult {
+  ddog_prof_CrashtrackerResult_Tag tag;
   union {
     struct {
       /**
@@ -175,34 +212,76 @@ typedef struct ddog_prof_Profile_Result {
       struct ddog_Error err;
     };
   };
-} ddog_prof_Profile_Result;
+} ddog_prof_CrashtrackerResult;
 
-typedef enum ddog_Endpoint_Tag {
-  DDOG_ENDPOINT_AGENT,
-  DDOG_ENDPOINT_AGENTLESS,
-} ddog_Endpoint_Tag;
+typedef struct ddog_prof_Slice_CharSlice {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
+  const ddog_CharSlice *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_prof_Slice_CharSlice;
 
-typedef struct ddog_Endpoint_ddog_prof_Agentless_Body {
+typedef enum ddog_prof_Endpoint_Tag {
+  DDOG_PROF_ENDPOINT_AGENT,
+  DDOG_PROF_ENDPOINT_AGENTLESS,
+  DDOG_PROF_ENDPOINT_FILE,
+} ddog_prof_Endpoint_Tag;
+
+typedef struct ddog_prof_Endpoint_ddog_prof_Agentless_Body {
   ddog_CharSlice _0;
   ddog_CharSlice _1;
-} ddog_Endpoint_ddog_prof_Agentless_Body;
+} ddog_prof_Endpoint_ddog_prof_Agentless_Body;
 
-typedef struct ddog_Endpoint {
-  ddog_Endpoint_Tag tag;
+typedef struct ddog_prof_Endpoint {
+  ddog_prof_Endpoint_Tag tag;
   union {
     struct {
       ddog_CharSlice agent;
     };
-    ddog_Endpoint_ddog_prof_Agentless_Body AGENTLESS;
+    ddog_prof_Endpoint_ddog_prof_Agentless_Body AGENTLESS;
+    struct {
+      ddog_CharSlice file;
+    };
   };
-} ddog_Endpoint;
+} ddog_prof_Endpoint;
 
 typedef struct ddog_prof_CrashtrackerConfiguration {
+  struct ddog_prof_Slice_CharSlice additional_files;
   bool create_alt_stack;
   /**
-   * The endpoint to send the crash repor to (can be a file://)
+   * The endpoint to send the crash report to (can be a file://)
+   */
+  struct ddog_prof_Endpoint endpoint;
+  enum ddog_prof_StacktraceCollection resolve_frames;
+  uint64_t timeout_secs;
+} ddog_prof_CrashtrackerConfiguration;
+
+typedef struct ddog_prof_EnvVar {
+  ddog_CharSlice key;
+  ddog_CharSlice val;
+} ddog_prof_EnvVar;
+
+typedef struct ddog_prof_Slice_EnvVar {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
+  const struct ddog_prof_EnvVar *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
    */
-  struct ddog_Endpoint endpoint;
+  uintptr_t len;
+} ddog_prof_Slice_EnvVar;
+
+typedef struct ddog_prof_CrashtrackerReceiverConfig {
+  struct ddog_prof_Slice_CharSlice args;
+  struct ddog_prof_Slice_EnvVar env;
+  ddog_CharSlice path_to_receiver_binary;
   /**
    * Optional filename to forward stderr to (useful for logging/debugging)
    */
@@ -211,12 +290,7 @@ typedef struct ddog_prof_CrashtrackerConfiguration {
    * Optional filename to forward stdout to (useful for logging/debugging)
    */
   ddog_CharSlice optional_stdout_filename;
-  ddog_CharSlice path_to_receiver_binary;
-  /**
-   * Whether/when we should attempt to resolve frames
-   */
-  enum ddog_prof_CrashtrackerResolveFrames resolve_frames;
-} ddog_prof_CrashtrackerConfiguration;
+} ddog_prof_CrashtrackerReceiverConfig;
 
 typedef struct ddog_prof_CrashtrackerMetadata {
   ddog_CharSlice profiling_library_name;
@@ -228,6 +302,122 @@ typedef struct ddog_prof_CrashtrackerMetadata {
   const struct ddog_Vec_Tag *tags;
 } ddog_prof_CrashtrackerMetadata;
 
+/**
+ * Represents a CrashInfo. Do not access its member for any reason, only use
+ * the C API functions on this struct.
+ */
+typedef struct ddog_prof_CrashInfo {
+  struct ddog_prof_CrashInfo *inner;
+} ddog_prof_CrashInfo;
+
+/**
+ * Returned by [ddog_prof_Profile_new].
+ */
+typedef enum ddog_prof_CrashInfoNewResult_Tag {
+  DDOG_PROF_CRASH_INFO_NEW_RESULT_OK,
+  DDOG_PROF_CRASH_INFO_NEW_RESULT_ERR,
+} ddog_prof_CrashInfoNewResult_Tag;
+
+typedef struct ddog_prof_CrashInfoNewResult {
+  ddog_prof_CrashInfoNewResult_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_CrashInfo ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_CrashInfoNewResult;
+
+typedef struct ddog_prof_SigInfo {
+  uint64_t signum;
+  ddog_CharSlice signame;
+} ddog_prof_SigInfo;
+
+typedef enum ddog_prof_Option_U32_Tag {
+  DDOG_PROF_OPTION_U32_SOME_U32,
+  DDOG_PROF_OPTION_U32_NONE_U32,
+} ddog_prof_Option_U32_Tag;
+
+typedef struct ddog_prof_Option_U32 {
+  ddog_prof_Option_U32_Tag tag;
+  union {
+    struct {
+      uint32_t some;
+    };
+  };
+} ddog_prof_Option_U32;
+
+typedef struct ddog_prof_StackFrameNames {
+  struct ddog_prof_Option_U32 colno;
+  ddog_CharSlice filename;
+  struct ddog_prof_Option_U32 lineno;
+  ddog_CharSlice name;
+} ddog_prof_StackFrameNames;
+
+typedef struct ddog_prof_Slice_StackFrameNames {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
+  const struct ddog_prof_StackFrameNames *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_prof_Slice_StackFrameNames;
+
+typedef struct ddog_prof_StackFrame {
+  uintptr_t ip;
+  uintptr_t module_base_address;
+  struct ddog_prof_Slice_StackFrameNames names;
+  uintptr_t sp;
+  uintptr_t symbol_address;
+} ddog_prof_StackFrame;
+
+typedef struct ddog_prof_Slice_StackFrame {
+  /**
+   * Must be non-null and suitably aligned for the underlying type.
+   */
+  const struct ddog_prof_StackFrame *ptr;
+  /**
+   * The number of elements (not bytes) that `.ptr` points to. Must be less
+   * than or equal to [isize::MAX].
+   */
+  uintptr_t len;
+} ddog_prof_Slice_StackFrame;
+
+/**
+ * A wrapper for returning owned strings from FFI
+ */
+typedef struct ddog_prof_StringWrapper {
+  /**
+   * This is a String stuffed into the vec.
+   */
+  struct ddog_Vec_U8 message;
+} ddog_prof_StringWrapper;
+
+/**
+ * Returned by [ddog_prof_Profile_new].
+ */
+typedef enum ddog_prof_StringWrapperResult_Tag {
+  DDOG_PROF_STRING_WRAPPER_RESULT_OK,
+  DDOG_PROF_STRING_WRAPPER_RESULT_ERR,
+} ddog_prof_StringWrapperResult_Tag;
+
+typedef struct ddog_prof_StringWrapperResult {
+  ddog_prof_StringWrapperResult_Tag tag;
+  union {
+    struct {
+      struct ddog_prof_StringWrapper ok;
+    };
+    struct {
+      struct ddog_Error err;
+    };
+  };
+} ddog_prof_StringWrapperResult;
+
 typedef struct ddog_Slice_U8 {
   /**
    * Must be non-null and suitably aligned for the underlying type.
@@ -375,6 +565,31 @@ typedef struct ddog_prof_Period {
   int64_t value;
 } ddog_prof_Period;
 
+/**
+ * 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_Result {
+  ddog_prof_Profile_Result_Tag tag;
+  union {
+    struct {
+      /**
+       * 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_Result;
+
 typedef struct ddog_prof_Mapping {
   /**
    * Address at which the binary (or DLL) is loaded into memory.
@@ -551,6 +766,98 @@ typedef struct ddog_prof_Profile_SerializeResult {
   };
 } ddog_prof_Profile_SerializeResult;
 
+typedef enum ddog_ConfigurationOrigin {
+  DDOG_CONFIGURATION_ORIGIN_ENV_VAR,
+  DDOG_CONFIGURATION_ORIGIN_CODE,
+  DDOG_CONFIGURATION_ORIGIN_DD_CONFIG,
+  DDOG_CONFIGURATION_ORIGIN_REMOTE_CONFIG,
+  DDOG_CONFIGURATION_ORIGIN_DEFAULT,
+} ddog_ConfigurationOrigin;
+
+typedef enum ddog_LogLevel {
+  DDOG_LOG_LEVEL_ERROR,
+  DDOG_LOG_LEVEL_WARN,
+  DDOG_LOG_LEVEL_DEBUG,
+} ddog_LogLevel;
+
+typedef enum ddog_MetricNamespace {
+  DDOG_METRIC_NAMESPACE_TRACERS,
+  DDOG_METRIC_NAMESPACE_PROFILERS,
+  DDOG_METRIC_NAMESPACE_RUM,
+  DDOG_METRIC_NAMESPACE_APPSEC,
+  DDOG_METRIC_NAMESPACE_IDE_PLUGINS,
+  DDOG_METRIC_NAMESPACE_LIVE_DEBUGGER,
+  DDOG_METRIC_NAMESPACE_IAST,
+  DDOG_METRIC_NAMESPACE_GENERAL,
+  DDOG_METRIC_NAMESPACE_TELEMETRY,
+  DDOG_METRIC_NAMESPACE_APM,
+  DDOG_METRIC_NAMESPACE_SIDECAR,
+} ddog_MetricNamespace;
+
+typedef enum ddog_MetricType {
+  DDOG_METRIC_TYPE_GAUGE,
+  DDOG_METRIC_TYPE_COUNT,
+  DDOG_METRIC_TYPE_DISTRIBUTION,
+} ddog_MetricType;
+
+typedef enum ddog_TelemetryWorkerBuilderBoolProperty {
+  DDOG_TELEMETRY_WORKER_BUILDER_BOOL_PROPERTY_CONFIG_TELEMETRY_DEBUG_LOGGING_ENABLED,
+} ddog_TelemetryWorkerBuilderBoolProperty;
+
+typedef enum ddog_TelemetryWorkerBuilderEndpointProperty {
+  DDOG_TELEMETRY_WORKER_BUILDER_ENDPOINT_PROPERTY_CONFIG_ENDPOINT,
+} ddog_TelemetryWorkerBuilderEndpointProperty;
+
+typedef enum ddog_TelemetryWorkerBuilderStrProperty {
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_SERVICE_VERSION,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_ENV,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_RUNTIME_NAME,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_RUNTIME_VERSION,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_APPLICATION_RUNTIME_PATCHES,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_HOST_CONTAINER_ID,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_HOST_OS,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_HOST_KERNEL_NAME,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_HOST_KERNEL_RELEASE,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_HOST_KERNEL_VERSION,
+  DDOG_TELEMETRY_WORKER_BUILDER_STR_PROPERTY_RUNTIME_ID,
+} ddog_TelemetryWorkerBuilderStrProperty;
+
+typedef struct ddog_TelemetryWorkerBuilder ddog_TelemetryWorkerBuilder;
+
+/**
+ * TelemetryWorkerHandle is a handle which allows interactions with the telemetry worker.
+ * The handle is safe to use across threads.
+ *
+ * The worker won't send data to the agent until you call `TelemetryWorkerHandle::send_start`
+ *
+ * To stop the worker, call `TelemetryWorkerHandle::send_stop` which trigger flush asynchronously
+ * then `TelemetryWorkerHandle::wait_for_shutdown`
+ */
+typedef struct ddog_TelemetryWorkerHandle ddog_TelemetryWorkerHandle;
+
+typedef enum ddog_Option_Bool_Tag {
+  DDOG_OPTION_BOOL_SOME_BOOL,
+  DDOG_OPTION_BOOL_NONE_BOOL,
+} ddog_Option_Bool_Tag;
+
+typedef struct ddog_Option_Bool {
+  ddog_Option_Bool_Tag tag;
+  union {
+    struct {
+      bool some;
+    };
+  };
+} ddog_Option_Bool;
+
+typedef struct ddog_ContextKey {
+  uint32_t _0;
+  enum ddog_MetricType _1;
+} ddog_ContextKey;
+
+#ifdef __cplusplus
+extern "C" {
+#endif // __cplusplus
+
 /**
  * # Safety
  * Only pass null or a valid reference to a `ddog_Error`.
@@ -565,6 +872,8 @@ void ddog_Error_drop(struct ddog_Error *error);
  */
 ddog_CharSlice ddog_Error_message(const struct ddog_Error *error);
 
+void ddog_MaybeError_drop(ddog_MaybeError);
+
 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);
@@ -576,6 +885,20 @@ struct ddog_Error *ddog_endpoint_from_api_key_and_site(ddog_CharSlice api_key,
 
 void ddog_endpoint_drop(struct ddog_Endpoint*);
 
+/**
+ * # Safety
+ * Only pass null or a valid reference to a `ddog_StringWrapper`.
+ */
+void ddog_StringWrapper_drop(struct ddog_StringWrapper *s);
+
+/**
+ * Returns a CharSlice of the message that is valid until the StringWrapper
+ * is dropped.
+ * # Safety
+ * Only pass null or a valid reference to a `ddog_StringWrapper`.
+ */
+ddog_CharSlice ddog_StringWrapper_message(const struct ddog_StringWrapper *s);
+
 DDOG_CHECK_RETURN struct ddog_Vec_Tag ddog_Vec_Tag_new(void);
 
 void ddog_Vec_Tag_drop(struct ddog_Vec_Tag);
@@ -602,4 +925,8 @@ struct ddog_Vec_Tag_PushResult ddog_Vec_Tag_push(struct ddog_Vec_Tag *vec,
  */
 DDOG_CHECK_RETURN struct ddog_Vec_Tag_ParseResult ddog_Vec_Tag_parse(ddog_CharSlice string);
 
+#ifdef __cplusplus
+} // extern "C"
+#endif // __cplusplus
+
 #endif /* DDOG_COMMON_H */