libdatadog 0.8.0.1.0-x86_64-linux → 1.0.1.1.0-x86_64-linux

Sign up to get free protection for your applications and to get access to all the features.
Files changed (19) hide show
  1. checksums.yaml +4 -4
  2. data/lib/libdatadog/version.rb +1 -1
  3. data/vendor/{libdatadog-0.8.0 → libdatadog-1.0.1}/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu/LICENSE +0 -0
  4. data/vendor/{libdatadog-0.8.0/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl → libdatadog-1.0.1/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu}/LICENSE-3rdparty.yml +245 -15
  5. data/vendor/{libdatadog-0.8.0 → libdatadog-1.0.1}/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu/NOTICE +0 -0
  6. data/vendor/{libdatadog-0.8.0/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl → libdatadog-1.0.1/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu}/include/datadog/common.h +134 -113
  7. data/vendor/{libdatadog-0.8.0 → libdatadog-1.0.1}/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu/include/datadog/profiling.h +69 -35
  8. data/vendor/libdatadog-1.0.1/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu/lib/libdatadog_profiling.so +0 -0
  9. data/vendor/{libdatadog-0.8.0 → libdatadog-1.0.1}/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu/lib/pkgconfig/datadog_profiling_with_rpath.pc +1 -1
  10. data/vendor/{libdatadog-0.8.0 → libdatadog-1.0.1}/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl/LICENSE +0 -0
  11. data/vendor/{libdatadog-0.8.0/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu → libdatadog-1.0.1/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl}/LICENSE-3rdparty.yml +245 -15
  12. data/vendor/{libdatadog-0.8.0 → libdatadog-1.0.1}/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl/NOTICE +0 -0
  13. data/vendor/{libdatadog-0.8.0/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu → libdatadog-1.0.1/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl}/include/datadog/common.h +134 -113
  14. data/vendor/{libdatadog-0.8.0 → libdatadog-1.0.1}/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl/include/datadog/profiling.h +69 -35
  15. data/vendor/libdatadog-1.0.1/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl/lib/libdatadog_profiling.so +0 -0
  16. data/vendor/{libdatadog-0.8.0 → libdatadog-1.0.1}/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl/lib/pkgconfig/datadog_profiling_with_rpath.pc +1 -1
  17. metadata +17 -17
  18. data/vendor/libdatadog-0.8.0/x86_64-linux/libdatadog-x86_64-unknown-linux-gnu/lib/libdatadog_profiling.so +0 -0
  19. data/vendor/libdatadog-0.8.0/x86_64-linux-musl/libdatadog-x86_64-alpine-linux-musl/lib/libdatadog_profiling.so +0 -0
@@ -1,10 +1,11 @@
1
1
  // Unless explicitly stated otherwise all files in this repository are licensed under the Apache License Version 2.0.
2
2
  // This product includes software developed at Datadog (https://www.datadoghq.com/). Copyright 2021-Present Datadog, Inc.
3
3
 
4
-
5
4
  #ifndef DDOG_COMMON_H
6
5
  #define DDOG_COMMON_H
7
6
 
7
+ #pragma once
8
+
8
9
  #include <stdbool.h>
9
10
  #include <stddef.h>
10
11
  #include <stdint.h>
@@ -17,12 +18,23 @@
17
18
  /* NOTE: Compilation fails if you pass in a char* instead of a literal */ ((ddog_CharSlice){ .ptr = "" string, .len = sizeof(string) - 1 })
18
19
  #endif
19
20
 
21
+ #if defined __GNUC__
22
+ # define DDOG_GNUC_VERSION(major) __GNUC__ >= major
23
+ #else
24
+ # define DDOG_GNUC_VERSION(major) (0)
25
+ #endif
26
+
27
+ #if defined __has_attribute
28
+ # define DDOG_HAS_ATTRIBUTE(attribute, major) __has_attribute(attribute)
29
+ #else
30
+ # define DDOG_HAS_ATTRIBUTE(attribute, major) DDOG_GNUC_VERSION(major)
31
+ #endif
32
+
20
33
  #if defined(__cplusplus) && (__cplusplus >= 201703L)
21
34
  # define DDOG_CHECK_RETURN [[nodiscard]]
22
35
  #elif defined(_Check_return_) /* SAL */
23
36
  # define DDOG_CHECK_RETURN _Check_return_
24
- #elif (defined(__has_attribute) && __has_attribute(warn_unused_result)) || \
25
- (defined(__GNUC__) && (__GNUC__ >= 4))
37
+ #elif DDOG_HAS_ATTRIBUTE(warn_unused_result, 4)
26
38
  # define DDOG_CHECK_RETURN __attribute__((__warn_unused_result__))
27
39
  #else
28
40
  # define DDOG_CHECK_RETURN
@@ -33,95 +45,103 @@ typedef struct ddog_Tag ddog_Tag;
33
45
  /**
34
46
  * Holds the raw parts of a Rust Vec; it should only be created from Rust,
35
47
  * never from C.
36
- * The names ptr and len were chosen to minimize conversion from a previous
37
- * Buffer type which this has replaced to become more general.
38
48
  */
39
- typedef struct ddog_Vec_tag {
49
+ typedef struct ddog_Vec_Tag {
40
50
  const struct ddog_Tag *ptr;
41
51
  uintptr_t len;
42
52
  uintptr_t capacity;
43
- } ddog_Vec_tag;
53
+ } ddog_Vec_Tag;
44
54
 
45
55
  /**
46
56
  * Holds the raw parts of a Rust Vec; it should only be created from Rust,
47
57
  * never from C.
48
- * The names ptr and len were chosen to minimize conversion from a previous
49
- * Buffer type which this has replaced to become more general.
50
58
  */
51
- typedef struct ddog_Vec_u8 {
59
+ typedef struct ddog_Vec_U8 {
52
60
  const uint8_t *ptr;
53
61
  uintptr_t len;
54
62
  uintptr_t capacity;
55
- } ddog_Vec_u8;
63
+ } ddog_Vec_U8;
56
64
 
57
- typedef enum ddog_PushTagResult_Tag {
58
- DDOG_PUSH_TAG_RESULT_OK,
59
- DDOG_PUSH_TAG_RESULT_ERR,
60
- } ddog_PushTagResult_Tag;
65
+ typedef enum ddog_Vec_Tag_PushResult_Tag {
66
+ DDOG_VEC_TAG_PUSH_RESULT_OK,
67
+ DDOG_VEC_TAG_PUSH_RESULT_ERR,
68
+ } ddog_Vec_Tag_PushResult_Tag;
61
69
 
62
- typedef struct ddog_PushTagResult {
63
- ddog_PushTagResult_Tag tag;
70
+ typedef struct ddog_Vec_Tag_PushResult {
71
+ ddog_Vec_Tag_PushResult_Tag tag;
64
72
  union {
65
73
  struct {
66
- struct ddog_Vec_u8 err;
74
+ struct ddog_Vec_U8 err;
67
75
  };
68
76
  };
69
- } ddog_PushTagResult;
77
+ } ddog_Vec_Tag_PushResult;
70
78
 
71
79
  /**
72
80
  * Remember, the data inside of each member is potentially coming from FFI,
73
81
  * so every operation on it is unsafe!
74
82
  */
75
- typedef struct ddog_Slice_c_char {
83
+ typedef struct ddog_Slice_CChar {
76
84
  const char *ptr;
77
85
  uintptr_t len;
78
- } ddog_Slice_c_char;
86
+ } ddog_Slice_CChar;
79
87
 
80
- typedef struct ddog_Slice_c_char ddog_CharSlice;
88
+ typedef struct ddog_Slice_CChar ddog_CharSlice;
81
89
 
82
- typedef struct ddog_ParseTagsResult {
83
- struct ddog_Vec_tag tags;
84
- struct ddog_Vec_u8 *error_message;
85
- } ddog_ParseTagsResult;
90
+ typedef struct ddog_Vec_Tag_ParseResult {
91
+ struct ddog_Vec_Tag tags;
92
+ struct ddog_Vec_U8 *error_message;
93
+ } ddog_Vec_Tag_ParseResult;
86
94
 
87
95
  typedef struct ddog_CancellationToken ddog_CancellationToken;
88
96
 
89
- typedef struct ddog_Profile ddog_Profile;
97
+ typedef struct ddog_prof_Profile ddog_prof_Profile;
98
+
99
+ typedef struct ddog_prof_Exporter ddog_prof_Exporter;
90
100
 
91
- typedef struct ddog_ProfileExporter ddog_ProfileExporter;
101
+ typedef struct ddog_prof_ProfiledEndpointsStats ddog_prof_ProfiledEndpointsStats;
92
102
 
93
103
  /**
94
104
  * This type only exists to workaround a bug in cbindgen; may be removed in the
95
105
  * future.
96
106
  */
97
- typedef struct ddog_Request ddog_Request;
107
+ typedef struct ddog_prof_Exporter_Request ddog_prof_Exporter_Request;
108
+
109
+ /**
110
+ * Holds the raw parts of a Rust Vec; it should only be created from Rust,
111
+ * never from C.
112
+ */
113
+ typedef struct ddog_prof_Vec_U8 {
114
+ const uint8_t *ptr;
115
+ uintptr_t len;
116
+ uintptr_t capacity;
117
+ } ddog_prof_Vec_U8;
98
118
 
99
- typedef enum ddog_NewProfileExporterResult_Tag {
100
- DDOG_NEW_PROFILE_EXPORTER_RESULT_OK,
101
- DDOG_NEW_PROFILE_EXPORTER_RESULT_ERR,
102
- } ddog_NewProfileExporterResult_Tag;
119
+ typedef enum ddog_prof_Exporter_NewResult_Tag {
120
+ DDOG_PROF_EXPORTER_NEW_RESULT_OK,
121
+ DDOG_PROF_EXPORTER_NEW_RESULT_ERR,
122
+ } ddog_prof_Exporter_NewResult_Tag;
103
123
 
104
- typedef struct ddog_NewProfileExporterResult {
105
- ddog_NewProfileExporterResult_Tag tag;
124
+ typedef struct ddog_prof_Exporter_NewResult {
125
+ ddog_prof_Exporter_NewResult_Tag tag;
106
126
  union {
107
127
  struct {
108
- struct ddog_ProfileExporter *ok;
128
+ struct ddog_prof_Exporter *ok;
109
129
  };
110
130
  struct {
111
- struct ddog_Vec_u8 err;
131
+ struct ddog_prof_Vec_U8 err;
112
132
  };
113
133
  };
114
- } ddog_NewProfileExporterResult;
134
+ } ddog_prof_Exporter_NewResult;
115
135
 
116
136
  typedef enum ddog_Endpoint_Tag {
117
137
  DDOG_ENDPOINT_AGENT,
118
138
  DDOG_ENDPOINT_AGENTLESS,
119
139
  } ddog_Endpoint_Tag;
120
140
 
121
- typedef struct ddog_Endpoint_ddog_Agentless_Body {
141
+ typedef struct ddog_Endpoint_ddog_prof_Agentless_Body {
122
142
  ddog_CharSlice _0;
123
143
  ddog_CharSlice _1;
124
- } ddog_Endpoint_ddog_Agentless_Body;
144
+ } ddog_Endpoint_ddog_prof_Agentless_Body;
125
145
 
126
146
  typedef struct ddog_Endpoint {
127
147
  ddog_Endpoint_Tag tag;
@@ -129,7 +149,7 @@ typedef struct ddog_Endpoint {
129
149
  struct {
130
150
  ddog_CharSlice agent;
131
151
  };
132
- ddog_Endpoint_ddog_Agentless_Body AGENTLESS;
152
+ ddog_Endpoint_ddog_prof_Agentless_Body AGENTLESS;
133
153
  };
134
154
  } ddog_Endpoint;
135
155
 
@@ -145,71 +165,71 @@ typedef struct ddog_Timespec {
145
165
  * Remember, the data inside of each member is potentially coming from FFI,
146
166
  * so every operation on it is unsafe!
147
167
  */
148
- typedef struct ddog_Slice_u8 {
168
+ typedef struct ddog_Slice_U8 {
149
169
  const uint8_t *ptr;
150
170
  uintptr_t len;
151
- } ddog_Slice_u8;
171
+ } ddog_Slice_U8;
152
172
 
153
173
  /**
154
174
  * Use to represent bytes -- does not need to be valid UTF-8.
155
175
  */
156
- typedef struct ddog_Slice_u8 ddog_ByteSlice;
176
+ typedef struct ddog_Slice_U8 ddog_ByteSlice;
157
177
 
158
- typedef struct ddog_File {
178
+ typedef struct ddog_prof_Exporter_File {
159
179
  ddog_CharSlice name;
160
180
  ddog_ByteSlice file;
161
- } ddog_File;
181
+ } ddog_prof_Exporter_File;
162
182
 
163
183
  /**
164
184
  * Remember, the data inside of each member is potentially coming from FFI,
165
185
  * so every operation on it is unsafe!
166
186
  */
167
- typedef struct ddog_Slice_file {
168
- const struct ddog_File *ptr;
187
+ typedef struct ddog_prof_Exporter_Slice_File {
188
+ const struct ddog_prof_Exporter_File *ptr;
169
189
  uintptr_t len;
170
- } ddog_Slice_file;
190
+ } ddog_prof_Exporter_Slice_File;
171
191
 
172
192
  typedef struct ddog_HttpStatus {
173
193
  uint16_t code;
174
194
  } ddog_HttpStatus;
175
195
 
176
- typedef enum ddog_SendResult_Tag {
177
- DDOG_SEND_RESULT_HTTP_RESPONSE,
178
- DDOG_SEND_RESULT_ERR,
179
- } ddog_SendResult_Tag;
196
+ typedef enum ddog_prof_Exporter_SendResult_Tag {
197
+ DDOG_PROF_EXPORTER_SEND_RESULT_HTTP_RESPONSE,
198
+ DDOG_PROF_EXPORTER_SEND_RESULT_ERR,
199
+ } ddog_prof_Exporter_SendResult_Tag;
180
200
 
181
- typedef struct ddog_SendResult {
182
- ddog_SendResult_Tag tag;
201
+ typedef struct ddog_prof_Exporter_SendResult {
202
+ ddog_prof_Exporter_SendResult_Tag tag;
183
203
  union {
184
204
  struct {
185
205
  struct ddog_HttpStatus http_response;
186
206
  };
187
207
  struct {
188
- struct ddog_Vec_u8 err;
208
+ struct ddog_prof_Vec_U8 err;
189
209
  };
190
210
  };
191
- } ddog_SendResult;
211
+ } ddog_prof_Exporter_SendResult;
192
212
 
193
- typedef struct ddog_ValueType {
213
+ typedef struct ddog_prof_ValueType {
194
214
  ddog_CharSlice type_;
195
215
  ddog_CharSlice unit;
196
- } ddog_ValueType;
216
+ } ddog_prof_ValueType;
197
217
 
198
218
  /**
199
219
  * Remember, the data inside of each member is potentially coming from FFI,
200
220
  * so every operation on it is unsafe!
201
221
  */
202
- typedef struct ddog_Slice_value_type {
203
- const struct ddog_ValueType *ptr;
222
+ typedef struct ddog_prof_Slice_ValueType {
223
+ const struct ddog_prof_ValueType *ptr;
204
224
  uintptr_t len;
205
- } ddog_Slice_value_type;
225
+ } ddog_prof_Slice_ValueType;
206
226
 
207
- typedef struct ddog_Period {
208
- struct ddog_ValueType type_;
227
+ typedef struct ddog_prof_Period {
228
+ struct ddog_prof_ValueType type_;
209
229
  int64_t value;
210
- } ddog_Period;
230
+ } ddog_prof_Period;
211
231
 
212
- typedef struct ddog_Mapping {
232
+ typedef struct ddog_prof_Mapping {
213
233
  /**
214
234
  * Address at which the binary (or DLL) is loaded into memory.
215
235
  */
@@ -234,9 +254,9 @@ typedef struct ddog_Mapping {
234
254
  * it could be the contents of the .note.gnu.build-id field.
235
255
  */
236
256
  ddog_CharSlice build_id;
237
- } ddog_Mapping;
257
+ } ddog_prof_Mapping;
238
258
 
239
- typedef struct ddog_Function {
259
+ typedef struct ddog_prof_Function {
240
260
  /**
241
261
  * Name of the function, in human-readable form if available.
242
262
  */
@@ -254,33 +274,33 @@ typedef struct ddog_Function {
254
274
  * Line number in source file.
255
275
  */
256
276
  int64_t start_line;
257
- } ddog_Function;
277
+ } ddog_prof_Function;
258
278
 
259
- typedef struct ddog_Line {
279
+ typedef struct ddog_prof_Line {
260
280
  /**
261
281
  * The corresponding profile.Function for this line.
262
282
  */
263
- struct ddog_Function function;
283
+ struct ddog_prof_Function function;
264
284
  /**
265
285
  * Line number in source code.
266
286
  */
267
287
  int64_t line;
268
- } ddog_Line;
288
+ } ddog_prof_Line;
269
289
 
270
290
  /**
271
291
  * Remember, the data inside of each member is potentially coming from FFI,
272
292
  * so every operation on it is unsafe!
273
293
  */
274
- typedef struct ddog_Slice_line {
275
- const struct ddog_Line *ptr;
294
+ typedef struct ddog_prof_Slice_Line {
295
+ const struct ddog_prof_Line *ptr;
276
296
  uintptr_t len;
277
- } ddog_Slice_line;
297
+ } ddog_prof_Slice_Line;
278
298
 
279
- typedef struct ddog_Location {
299
+ typedef struct ddog_prof_Location {
280
300
  /**
281
301
  * todo: how to handle unknown mapping?
282
302
  */
283
- struct ddog_Mapping mapping;
303
+ struct ddog_prof_Mapping mapping;
284
304
  /**
285
305
  * The instruction address for this location, if available. It
286
306
  * should be within [Mapping.memory_start...Mapping.memory_limit]
@@ -298,7 +318,7 @@ typedef struct ddog_Location {
298
318
  * line[0].function_name == "memcpy"
299
319
  * line[1].function_name == "printf"
300
320
  */
301
- struct ddog_Slice_line lines;
321
+ struct ddog_prof_Slice_Line lines;
302
322
  /**
303
323
  * Provides an indication that multiple symbols map to this location's
304
324
  * address, for example due to identical code folding by the linker. In that
@@ -307,27 +327,27 @@ typedef struct ddog_Location {
307
327
  * profile changes.
308
328
  */
309
329
  bool is_folded;
310
- } ddog_Location;
330
+ } ddog_prof_Location;
311
331
 
312
332
  /**
313
333
  * Remember, the data inside of each member is potentially coming from FFI,
314
334
  * so every operation on it is unsafe!
315
335
  */
316
- typedef struct ddog_Slice_location {
317
- const struct ddog_Location *ptr;
336
+ typedef struct ddog_prof_Slice_Location {
337
+ const struct ddog_prof_Location *ptr;
318
338
  uintptr_t len;
319
- } ddog_Slice_location;
339
+ } ddog_prof_Slice_Location;
320
340
 
321
341
  /**
322
342
  * Remember, the data inside of each member is potentially coming from FFI,
323
343
  * so every operation on it is unsafe!
324
344
  */
325
- typedef struct ddog_Slice_i64 {
345
+ typedef struct ddog_Slice_I64 {
326
346
  const int64_t *ptr;
327
347
  uintptr_t len;
328
- } ddog_Slice_i64;
348
+ } ddog_Slice_I64;
329
349
 
330
- typedef struct ddog_Label {
350
+ typedef struct ddog_prof_Label {
331
351
  ddog_CharSlice key;
332
352
  /**
333
353
  * At most one of the following must be present
@@ -344,22 +364,22 @@ typedef struct ddog_Label {
344
364
  * and apply appropriate unit conversions to these.
345
365
  */
346
366
  ddog_CharSlice num_unit;
347
- } ddog_Label;
367
+ } ddog_prof_Label;
348
368
 
349
369
  /**
350
370
  * Remember, the data inside of each member is potentially coming from FFI,
351
371
  * so every operation on it is unsafe!
352
372
  */
353
- typedef struct ddog_Slice_label {
354
- const struct ddog_Label *ptr;
373
+ typedef struct ddog_prof_Slice_Label {
374
+ const struct ddog_prof_Label *ptr;
355
375
  uintptr_t len;
356
- } ddog_Slice_label;
376
+ } ddog_prof_Slice_Label;
357
377
 
358
- typedef struct ddog_Sample {
378
+ typedef struct ddog_prof_Sample {
359
379
  /**
360
380
  * The leaf is at locations[0].
361
381
  */
362
- struct ddog_Slice_location locations;
382
+ struct ddog_prof_Slice_Location locations;
363
383
  /**
364
384
  * The type and unit of each value is defined by the corresponding
365
385
  * entry in Profile.sample_type. All samples must have the same
@@ -368,42 +388,43 @@ typedef struct ddog_Sample {
368
388
  * result has a list of values that is the element-wise sum of the
369
389
  * lists of the originals.
370
390
  */
371
- struct ddog_Slice_i64 values;
391
+ struct ddog_Slice_I64 values;
372
392
  /**
373
393
  * label includes additional context for this sample. It can include
374
394
  * things like a thread id, allocation size, etc
375
395
  */
376
- struct ddog_Slice_label labels;
377
- } ddog_Sample;
396
+ struct ddog_prof_Slice_Label labels;
397
+ } ddog_prof_Sample;
378
398
 
379
- typedef struct ddog_EncodedProfile {
399
+ typedef struct ddog_prof_EncodedProfile {
380
400
  struct ddog_Timespec start;
381
401
  struct ddog_Timespec end;
382
- struct ddog_Vec_u8 buffer;
383
- } ddog_EncodedProfile;
402
+ struct ddog_prof_Vec_U8 buffer;
403
+ struct ddog_prof_ProfiledEndpointsStats *endpoints_stats;
404
+ } ddog_prof_EncodedProfile;
384
405
 
385
- typedef enum ddog_SerializeResult_Tag {
386
- DDOG_SERIALIZE_RESULT_OK,
387
- DDOG_SERIALIZE_RESULT_ERR,
388
- } ddog_SerializeResult_Tag;
406
+ typedef enum ddog_prof_Profile_SerializeResult_Tag {
407
+ DDOG_PROF_PROFILE_SERIALIZE_RESULT_OK,
408
+ DDOG_PROF_PROFILE_SERIALIZE_RESULT_ERR,
409
+ } ddog_prof_Profile_SerializeResult_Tag;
389
410
 
390
- typedef struct ddog_SerializeResult {
391
- ddog_SerializeResult_Tag tag;
411
+ typedef struct ddog_prof_Profile_SerializeResult {
412
+ ddog_prof_Profile_SerializeResult_Tag tag;
392
413
  union {
393
414
  struct {
394
- struct ddog_EncodedProfile ok;
415
+ struct ddog_prof_EncodedProfile ok;
395
416
  };
396
417
  struct {
397
- struct ddog_Vec_u8 err;
418
+ struct ddog_prof_Vec_U8 err;
398
419
  };
399
420
  };
400
- } ddog_SerializeResult;
421
+ } ddog_prof_Profile_SerializeResult;
401
422
 
402
- DDOG_CHECK_RETURN struct ddog_Vec_tag ddog_Vec_tag_new(void);
423
+ DDOG_CHECK_RETURN struct ddog_Vec_Tag ddog_Vec_Tag_new(void);
403
424
 
404
- void ddog_Vec_tag_drop(struct ddog_Vec_tag);
425
+ void ddog_Vec_Tag_drop(struct ddog_Vec_Tag);
405
426
 
406
- void ddog_PushTagResult_drop(struct ddog_PushTagResult);
427
+ void ddog_Vec_Tag_PushResult_drop(struct ddog_Vec_Tag_PushResult);
407
428
 
408
429
  /**
409
430
  * Creates a new Tag from the provided `key` and `value` by doing a utf8
@@ -416,15 +437,15 @@ void ddog_PushTagResult_drop(struct ddog_PushTagResult);
416
437
  * `.len` properties claim.
417
438
  */
418
439
  DDOG_CHECK_RETURN
419
- struct ddog_PushTagResult ddog_Vec_tag_push(struct ddog_Vec_tag *vec,
420
- ddog_CharSlice key,
421
- ddog_CharSlice value);
440
+ struct ddog_Vec_Tag_PushResult ddog_Vec_Tag_push(struct ddog_Vec_Tag *vec,
441
+ ddog_CharSlice key,
442
+ ddog_CharSlice value);
422
443
 
423
444
  /**
424
445
  * # Safety
425
446
  * The `string`'s .ptr must point to a valid object at least as large as its
426
447
  * .len property.
427
448
  */
428
- DDOG_CHECK_RETURN struct ddog_ParseTagsResult ddog_Vec_tag_parse(ddog_CharSlice string);
449
+ DDOG_CHECK_RETURN struct ddog_Vec_Tag_ParseResult ddog_Vec_Tag_parse(ddog_CharSlice string);
429
450
 
430
451
  #endif /* DDOG_COMMON_H */