@point3/node-rdkafka 3.6.0-1

package/deps/librdkafka/src/nanopb/pb_encode.h

@@ -0,0 +1,185 @@
+/* pb_encode.h: Functions to encode protocol buffers. Depends on pb_encode.c.
+ * The main function is pb_encode. You also need an output stream, and the
+ * field descriptions created by nanopb_generator.py.
+ */
+
+#ifndef PB_ENCODE_H_INCLUDED
+#define PB_ENCODE_H_INCLUDED
+
+#include "nanopb/pb.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Structure for defining custom output streams. You will need to provide
+ * a callback function to write the bytes to your storage, which can be
+ * for example a file or a network socket.
+ *
+ * The callback must conform to these rules:
+ *
+ * 1) Return false on IO errors. This will cause encoding to abort.
+ * 2) You can use state to store your own data (e.g. buffer pointer).
+ * 3) pb_write will update bytes_written after your callback runs.
+ * 4) Substreams will modify max_size and bytes_written. Don't use them
+ *    to calculate any pointers.
+ */
+struct pb_ostream_s
+{
+#ifdef PB_BUFFER_ONLY
+    /* Callback pointer is not used in buffer-only configuration.
+     * Having an int pointer here allows binary compatibility but
+     * gives an error if someone tries to assign callback function.
+     * Also, NULL pointer marks a 'sizing stream' that does not
+     * write anything.
+     */
+    const int *callback;
+#else
+    bool (*callback)(pb_ostream_t *stream, const pb_byte_t *buf, size_t count);
+#endif
+    void *state;          /* Free field for use by callback implementation. */
+    size_t max_size;      /* Limit number of output bytes written (or use SIZE_MAX). */
+    size_t bytes_written; /* Number of bytes written so far. */
+    
+#ifndef PB_NO_ERRMSG
+    const char *errmsg;
+#endif
+};
+
+/***************************
+ * Main encoding functions *
+ ***************************/
+
+/* Encode a single protocol buffers message from C structure into a stream.
+ * Returns true on success, false on any failure.
+ * The actual struct pointed to by src_struct must match the description in fields.
+ * All required fields in the struct are assumed to have been filled in.
+ *
+ * Example usage:
+ *    MyMessage msg = {};
+ *    uint8_t buffer[64];
+ *    pb_ostream_t stream;
+ *
+ *    msg.field1 = 42;
+ *    stream = pb_ostream_from_buffer(buffer, sizeof(buffer));
+ *    pb_encode(&stream, MyMessage_fields, &msg);
+ */
+bool pb_encode(pb_ostream_t *stream, const pb_msgdesc_t *fields, const void *src_struct);
+
+/* Extended version of pb_encode, with several options to control the
+ * encoding process:
+ *
+ * PB_ENCODE_DELIMITED:      Prepend the length of message as a varint.
+ *                           Corresponds to writeDelimitedTo() in Google's
+ *                           protobuf API.
+ *
+ * PB_ENCODE_NULLTERMINATED: Append a null byte to the message for termination.
+ *                           NOTE: This behaviour is not supported in most other
+ *                           protobuf implementations, so PB_ENCODE_DELIMITED
+ *                           is a better option for compatibility.
+ */
+#define PB_ENCODE_DELIMITED       0x02U
+#define PB_ENCODE_NULLTERMINATED  0x04U
+bool pb_encode_ex(pb_ostream_t *stream, const pb_msgdesc_t *fields, const void *src_struct, unsigned int flags);
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define pb_encode_delimited(s,f,d) pb_encode_ex(s,f,d, PB_ENCODE_DELIMITED)
+#define pb_encode_nullterminated(s,f,d) pb_encode_ex(s,f,d, PB_ENCODE_NULLTERMINATED)
+
+/* Encode the message to get the size of the encoded data, but do not store
+ * the data. */
+bool pb_get_encoded_size(size_t *size, const pb_msgdesc_t *fields, const void *src_struct);
+
+/**************************************
+ * Functions for manipulating streams *
+ **************************************/
+
+/* Create an output stream for writing into a memory buffer.
+ * The number of bytes written can be found in stream.bytes_written after
+ * encoding the message.
+ *
+ * Alternatively, you can use a custom stream that writes directly to e.g.
+ * a file or a network socket.
+ */
+pb_ostream_t pb_ostream_from_buffer(pb_byte_t *buf, size_t bufsize);
+
+/* Pseudo-stream for measuring the size of a message without actually storing
+ * the encoded data.
+ * 
+ * Example usage:
+ *    MyMessage msg = {};
+ *    pb_ostream_t stream = PB_OSTREAM_SIZING;
+ *    pb_encode(&stream, MyMessage_fields, &msg);
+ *    printf("Message size is %d\n", stream.bytes_written);
+ */
+#ifndef PB_NO_ERRMSG
+#define PB_OSTREAM_SIZING {0,0,0,0,0}
+#else
+#define PB_OSTREAM_SIZING {0,0,0,0}
+#endif
+
+/* Function to write into a pb_ostream_t stream. You can use this if you need
+ * to append or prepend some custom headers to the message.
+ */
+bool pb_write(pb_ostream_t *stream, const pb_byte_t *buf, size_t count);
+
+
+/************************************************
+ * Helper functions for writing field callbacks *
+ ************************************************/
+
+/* Encode field header based on type and field number defined in the field
+ * structure. Call this from the callback before writing out field contents. */
+bool pb_encode_tag_for_field(pb_ostream_t *stream, const pb_field_iter_t *field);
+
+/* Encode field header by manually specifying wire type. You need to use this
+ * if you want to write out packed arrays from a callback field. */
+bool pb_encode_tag(pb_ostream_t *stream, pb_wire_type_t wiretype, uint32_t field_number);
+
+/* Encode an integer in the varint format.
+ * This works for bool, enum, int32, int64, uint32 and uint64 field types. */
+#ifndef PB_WITHOUT_64BIT
+bool pb_encode_varint(pb_ostream_t *stream, uint64_t value);
+#else
+bool pb_encode_varint(pb_ostream_t *stream, uint32_t value);
+#endif
+
+/* Encode an integer in the zig-zagged svarint format.
+ * This works for sint32 and sint64. */
+#ifndef PB_WITHOUT_64BIT
+bool pb_encode_svarint(pb_ostream_t *stream, int64_t value);
+#else
+bool pb_encode_svarint(pb_ostream_t *stream, int32_t value);
+#endif
+
+/* Encode a string or bytes type field. For strings, pass strlen(s) as size. */
+bool pb_encode_string(pb_ostream_t *stream, const pb_byte_t *buffer, size_t size);
+
+/* Encode a fixed32, sfixed32 or float value.
+ * You need to pass a pointer to a 4-byte wide C variable. */
+bool pb_encode_fixed32(pb_ostream_t *stream, const void *value);
+
+#ifndef PB_WITHOUT_64BIT
+/* Encode a fixed64, sfixed64 or double value.
+ * You need to pass a pointer to a 8-byte wide C variable. */
+bool pb_encode_fixed64(pb_ostream_t *stream, const void *value);
+#endif
+
+#ifdef PB_CONVERT_DOUBLE_FLOAT
+/* Encode a float value so that it appears like a double in the encoded
+ * message. */
+bool pb_encode_float_as_double(pb_ostream_t *stream, float value);
+#endif
+
+/* Encode a submessage field.
+ * You need to pass the pb_field_t array and pointer to struct, just like
+ * with pb_encode(). This internally encodes the submessage twice, first to
+ * calculate message size and then to actually write it out.
+ */
+bool pb_encode_submessage(pb_ostream_t *stream, const pb_msgdesc_t *fields, const void *src_struct);
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

package/deps/librdkafka/src/opentelemetry/common.pb.c

@@ -0,0 +1,32 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.8-dev */
+
+#include "opentelemetry/common.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(opentelemetry_proto_common_v1_AnyValue, opentelemetry_proto_common_v1_AnyValue, AUTO)
+
+
+PB_BIND(opentelemetry_proto_common_v1_ArrayValue, opentelemetry_proto_common_v1_ArrayValue, AUTO)
+
+
+PB_BIND(opentelemetry_proto_common_v1_KeyValueList, opentelemetry_proto_common_v1_KeyValueList, AUTO)
+
+
+PB_BIND(opentelemetry_proto_common_v1_KeyValue, opentelemetry_proto_common_v1_KeyValue, AUTO)
+
+
+PB_BIND(opentelemetry_proto_common_v1_InstrumentationScope, opentelemetry_proto_common_v1_InstrumentationScope, AUTO)
+
+
+
+#ifndef PB_CONVERT_DOUBLE_FLOAT
+/* On some platforms (such as AVR), double is really float.
+ * To be able to encode/decode double on these platforms, you need.
+ * to define PB_CONVERT_DOUBLE_FLOAT in pb.h or compiler command line.
+ */
+PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)
+#endif
+

package/deps/librdkafka/src/opentelemetry/common.pb.h

@@ -0,0 +1,170 @@
+/* Automatically generated nanopb header */
+/* Generated by nanopb-0.4.8-dev */
+
+#ifndef PB_OPENTELEMETRY_PROTO_COMMON_V1_OPENTELEMETRY_PROTO_COMMON_V1_COMMON_PB_H_INCLUDED
+#define PB_OPENTELEMETRY_PROTO_COMMON_V1_OPENTELEMETRY_PROTO_COMMON_V1_COMMON_PB_H_INCLUDED
+#include <nanopb/pb.h>
+
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+/* Struct definitions */
+/* ArrayValue is a list of AnyValue messages. We need ArrayValue as a message
+ since oneof in AnyValue does not allow repeated fields. */
+typedef struct _opentelemetry_proto_common_v1_ArrayValue {
+    /* Array of values. The array may be empty (contain 0 elements). */
+    pb_callback_t values;
+} opentelemetry_proto_common_v1_ArrayValue;
+
+/* KeyValueList is a list of KeyValue messages. We need KeyValueList as a message
+ since `oneof` in AnyValue does not allow repeated fields. Everywhere else where we need
+ a list of KeyValue messages (e.g. in Span) we use `repeated KeyValue` directly to
+ avoid unnecessary extra wrapping (which slows down the protocol). The 2 approaches
+ are semantically equivalent. */
+typedef struct _opentelemetry_proto_common_v1_KeyValueList {
+    /* A collection of key/value pairs of key-value pairs. The list may be empty (may
+ contain 0 elements).
+ The keys MUST be unique (it is not allowed to have more than one
+ value with the same key). */
+    pb_callback_t values;
+} opentelemetry_proto_common_v1_KeyValueList;
+
+/* AnyValue is used to represent any type of attribute value. AnyValue may contain a
+ primitive value such as a string or integer or it may contain an arbitrary nested
+ object containing arrays, key-value lists and primitives. */
+typedef struct _opentelemetry_proto_common_v1_AnyValue {
+    pb_size_t which_value;
+    union {
+        pb_callback_t string_value;
+        bool bool_value;
+        int64_t int_value;
+        double double_value;
+        opentelemetry_proto_common_v1_ArrayValue array_value;
+        opentelemetry_proto_common_v1_KeyValueList kvlist_value;
+        pb_callback_t bytes_value;
+    } value;
+} opentelemetry_proto_common_v1_AnyValue;
+
+/* KeyValue is a key-value pair that is used to store Span attributes, Link
+ attributes, etc. */
+typedef struct _opentelemetry_proto_common_v1_KeyValue {
+    pb_callback_t key;
+    bool has_value;
+    opentelemetry_proto_common_v1_AnyValue value;
+} opentelemetry_proto_common_v1_KeyValue;
+
+/* InstrumentationScope is a message representing the instrumentation scope information
+ such as the fully qualified name and version. */
+typedef struct _opentelemetry_proto_common_v1_InstrumentationScope {
+    /* An empty instrumentation scope name means the name is unknown. */
+    pb_callback_t name;
+    pb_callback_t version;
+    /* Additional attributes that describe the scope. [Optional].
+ Attribute keys MUST be unique (it is not allowed to have more than one
+ attribute with the same key). */
+    pb_callback_t attributes;
+    uint32_t dropped_attributes_count;
+} opentelemetry_proto_common_v1_InstrumentationScope;
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Initializer values for message structs */
+#define opentelemetry_proto_common_v1_AnyValue_init_default {0, {{{NULL}, NULL}}}
+#define opentelemetry_proto_common_v1_ArrayValue_init_default {{{NULL}, NULL}}
+#define opentelemetry_proto_common_v1_KeyValueList_init_default {{{NULL}, NULL}}
+#define opentelemetry_proto_common_v1_KeyValue_init_default {{{NULL}, NULL}, false, opentelemetry_proto_common_v1_AnyValue_init_default}
+#define opentelemetry_proto_common_v1_InstrumentationScope_init_default {{{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, 0}
+#define opentelemetry_proto_common_v1_AnyValue_init_zero {0, {{{NULL}, NULL}}}
+#define opentelemetry_proto_common_v1_ArrayValue_init_zero {{{NULL}, NULL}}
+#define opentelemetry_proto_common_v1_KeyValueList_init_zero {{{NULL}, NULL}}
+#define opentelemetry_proto_common_v1_KeyValue_init_zero {{{NULL}, NULL}, false, opentelemetry_proto_common_v1_AnyValue_init_zero}
+#define opentelemetry_proto_common_v1_InstrumentationScope_init_zero {{{NULL}, NULL}, {{NULL}, NULL}, {{NULL}, NULL}, 0}
+
+/* Field tags (for use in manual encoding/decoding) */
+#define opentelemetry_proto_common_v1_ArrayValue_values_tag 1
+#define opentelemetry_proto_common_v1_KeyValueList_values_tag 1
+#define opentelemetry_proto_common_v1_AnyValue_string_value_tag 1
+#define opentelemetry_proto_common_v1_AnyValue_bool_value_tag 2
+#define opentelemetry_proto_common_v1_AnyValue_int_value_tag 3
+#define opentelemetry_proto_common_v1_AnyValue_double_value_tag 4
+#define opentelemetry_proto_common_v1_AnyValue_array_value_tag 5
+#define opentelemetry_proto_common_v1_AnyValue_kvlist_value_tag 6
+#define opentelemetry_proto_common_v1_AnyValue_bytes_value_tag 7
+#define opentelemetry_proto_common_v1_KeyValue_key_tag 1
+#define opentelemetry_proto_common_v1_KeyValue_value_tag 2
+#define opentelemetry_proto_common_v1_InstrumentationScope_name_tag 1
+#define opentelemetry_proto_common_v1_InstrumentationScope_version_tag 2
+#define opentelemetry_proto_common_v1_InstrumentationScope_attributes_tag 3
+#define opentelemetry_proto_common_v1_InstrumentationScope_dropped_attributes_count_tag 4
+
+/* Struct field encoding specification for nanopb */
+#define opentelemetry_proto_common_v1_AnyValue_FIELDLIST(X, a) \
+X(a, CALLBACK, ONEOF,    STRING,   (value,string_value,value.string_value),   1) \
+X(a, STATIC,   ONEOF,    BOOL,     (value,bool_value,value.bool_value),   2) \
+X(a, STATIC,   ONEOF,    INT64,    (value,int_value,value.int_value),   3) \
+X(a, STATIC,   ONEOF,    DOUBLE,   (value,double_value,value.double_value),   4) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (value,array_value,value.array_value),   5) \
+X(a, STATIC,   ONEOF,    MESSAGE,  (value,kvlist_value,value.kvlist_value),   6) \
+X(a, CALLBACK, ONEOF,    BYTES,    (value,bytes_value,value.bytes_value),   7)
+#define opentelemetry_proto_common_v1_AnyValue_CALLBACK pb_default_field_callback
+#define opentelemetry_proto_common_v1_AnyValue_DEFAULT NULL
+#define opentelemetry_proto_common_v1_AnyValue_value_array_value_MSGTYPE opentelemetry_proto_common_v1_ArrayValue
+#define opentelemetry_proto_common_v1_AnyValue_value_kvlist_value_MSGTYPE opentelemetry_proto_common_v1_KeyValueList
+
+#define opentelemetry_proto_common_v1_ArrayValue_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, MESSAGE,  values,            1)
+#define opentelemetry_proto_common_v1_ArrayValue_CALLBACK pb_default_field_callback
+#define opentelemetry_proto_common_v1_ArrayValue_DEFAULT NULL
+#define opentelemetry_proto_common_v1_ArrayValue_values_MSGTYPE opentelemetry_proto_common_v1_AnyValue
+
+#define opentelemetry_proto_common_v1_KeyValueList_FIELDLIST(X, a) \
+X(a, CALLBACK, REPEATED, MESSAGE,  values,            1)
+#define opentelemetry_proto_common_v1_KeyValueList_CALLBACK pb_default_field_callback
+#define opentelemetry_proto_common_v1_KeyValueList_DEFAULT NULL
+#define opentelemetry_proto_common_v1_KeyValueList_values_MSGTYPE opentelemetry_proto_common_v1_KeyValue
+
+#define opentelemetry_proto_common_v1_KeyValue_FIELDLIST(X, a) \
+X(a, CALLBACK, SINGULAR, STRING,   key,               1) \
+X(a, STATIC,   OPTIONAL, MESSAGE,  value,             2)
+#define opentelemetry_proto_common_v1_KeyValue_CALLBACK pb_default_field_callback
+#define opentelemetry_proto_common_v1_KeyValue_DEFAULT NULL
+#define opentelemetry_proto_common_v1_KeyValue_value_MSGTYPE opentelemetry_proto_common_v1_AnyValue
+
+#define opentelemetry_proto_common_v1_InstrumentationScope_FIELDLIST(X, a) \
+X(a, CALLBACK, SINGULAR, STRING,   name,              1) \
+X(a, CALLBACK, SINGULAR, STRING,   version,           2) \
+X(a, CALLBACK, REPEATED, MESSAGE,  attributes,        3) \
+X(a, STATIC,   SINGULAR, UINT32,   dropped_attributes_count,   4)
+#define opentelemetry_proto_common_v1_InstrumentationScope_CALLBACK pb_default_field_callback
+#define opentelemetry_proto_common_v1_InstrumentationScope_DEFAULT NULL
+#define opentelemetry_proto_common_v1_InstrumentationScope_attributes_MSGTYPE opentelemetry_proto_common_v1_KeyValue
+
+extern const pb_msgdesc_t opentelemetry_proto_common_v1_AnyValue_msg;
+extern const pb_msgdesc_t opentelemetry_proto_common_v1_ArrayValue_msg;
+extern const pb_msgdesc_t opentelemetry_proto_common_v1_KeyValueList_msg;
+extern const pb_msgdesc_t opentelemetry_proto_common_v1_KeyValue_msg;
+extern const pb_msgdesc_t opentelemetry_proto_common_v1_InstrumentationScope_msg;
+
+/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
+#define opentelemetry_proto_common_v1_AnyValue_fields &opentelemetry_proto_common_v1_AnyValue_msg
+#define opentelemetry_proto_common_v1_ArrayValue_fields &opentelemetry_proto_common_v1_ArrayValue_msg
+#define opentelemetry_proto_common_v1_KeyValueList_fields &opentelemetry_proto_common_v1_KeyValueList_msg
+#define opentelemetry_proto_common_v1_KeyValue_fields &opentelemetry_proto_common_v1_KeyValue_msg
+#define opentelemetry_proto_common_v1_InstrumentationScope_fields &opentelemetry_proto_common_v1_InstrumentationScope_msg
+
+/* Maximum encoded size of messages (where known) */
+/* opentelemetry_proto_common_v1_AnyValue_size depends on runtime parameters */
+/* opentelemetry_proto_common_v1_ArrayValue_size depends on runtime parameters */
+/* opentelemetry_proto_common_v1_KeyValueList_size depends on runtime parameters */
+/* opentelemetry_proto_common_v1_KeyValue_size depends on runtime parameters */
+/* opentelemetry_proto_common_v1_InstrumentationScope_size depends on runtime parameters */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+#endif

package/deps/librdkafka/src/opentelemetry/metrics.options

@@ -0,0 +1,2 @@
+# Needed to generate callback for data types within Metrics which isn't generated for oneof types by default
+opentelemetry.proto.metrics.v1.Metric submsg_callback:true;

package/deps/librdkafka/src/opentelemetry/metrics.pb.c

@@ -0,0 +1,67 @@
+/* Automatically generated nanopb constant definitions */
+/* Generated by nanopb-0.4.8-dev */
+
+#include "opentelemetry/metrics.pb.h"
+#if PB_PROTO_HEADER_VERSION != 40
+#error Regenerate this file with the current version of nanopb generator.
+#endif
+
+PB_BIND(opentelemetry_proto_metrics_v1_MetricsData, opentelemetry_proto_metrics_v1_MetricsData, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_ResourceMetrics, opentelemetry_proto_metrics_v1_ResourceMetrics, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_ScopeMetrics, opentelemetry_proto_metrics_v1_ScopeMetrics, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_Metric, opentelemetry_proto_metrics_v1_Metric, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_Gauge, opentelemetry_proto_metrics_v1_Gauge, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_Sum, opentelemetry_proto_metrics_v1_Sum, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_Histogram, opentelemetry_proto_metrics_v1_Histogram, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_ExponentialHistogram, opentelemetry_proto_metrics_v1_ExponentialHistogram, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_Summary, opentelemetry_proto_metrics_v1_Summary, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_NumberDataPoint, opentelemetry_proto_metrics_v1_NumberDataPoint, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_HistogramDataPoint, opentelemetry_proto_metrics_v1_HistogramDataPoint, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_ExponentialHistogramDataPoint, opentelemetry_proto_metrics_v1_ExponentialHistogramDataPoint, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_ExponentialHistogramDataPoint_Buckets, opentelemetry_proto_metrics_v1_ExponentialHistogramDataPoint_Buckets, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_SummaryDataPoint, opentelemetry_proto_metrics_v1_SummaryDataPoint, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_SummaryDataPoint_ValueAtQuantile, opentelemetry_proto_metrics_v1_SummaryDataPoint_ValueAtQuantile, AUTO)
+
+
+PB_BIND(opentelemetry_proto_metrics_v1_Exemplar, opentelemetry_proto_metrics_v1_Exemplar, AUTO)
+
+
+
+
+
+#ifndef PB_CONVERT_DOUBLE_FLOAT
+/* On some platforms (such as AVR), double is really float.
+ * To be able to encode/decode double on these platforms, you need.
+ * to define PB_CONVERT_DOUBLE_FLOAT in pb.h or compiler command line.
+ */
+PB_STATIC_ASSERT(sizeof(double) == 8, DOUBLE_MUST_BE_8_BYTES)
+#endif
+