ddtrace 1.8.0 → 1.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '02285d37473e8fe6c731e55ae7864860a311e2b6d509f56a41f31094cd198f09'
-  data.tar.gz: 8857a0f43f96fef23309cd7fced88b846d5ad48834b6c87d0f40181cc3bd5dd9
+  metadata.gz: 1ba4a81593411a12abfa1665b3910e49e35429b1b266779e93accb0f84a478d2
+  data.tar.gz: e72362dc1a1e682a3c52b8af8017fcd12e60d353843cdd129f65a55dbb0c312d
 SHA512:
-  metadata.gz: afcde0e01258f5ab997fa6bcfa51c29a82f0e730258056a9efae86130445dbd63471269c047878b1ee554cc4ec956fe6e95a597ce65930e73549b0e32cbec50c
-  data.tar.gz: 292867c7c22146d0bd3147bb8863dd51fc89200a08efe640f05ae053fb93bdaeb068eefb6c89466b40ebbe749174844aa6b874c5a2b6aae30cb5055c9f2dc3cd
+  metadata.gz: a083b23cfadccc78e67a5aa2a3ae067bc868e4721d92d1fb9fcbadc7536332fabd20f6638fb157712e5e909afd3e3e505a2011838a4f0e98dbebaa64a38f7db6
+  data.tar.gz: 81b27dbbf685c01ee99ab79a8774aefca4a2feb93363a41e1a3465b01b1b07f571d5bdd75a73880658ae05254a3d742651bdf8df98fd48c040f73bb6a16702d0

data/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 ## [Unreleased]
 
+## [1.9.0] - 2023-01-30
+
+As of ddtrace 1.9.0, CPU Profiling 2.0 is now in opt-in (that is, disabled by default) public beta. For more details, check the release notes.
+
+Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v1.9.0
+
+### Added
+
+* Tracing: Add `Stripe` instrumentation ([#2557][])
+* Tracing: Add configurable response codes considered as errors for `Net/HTTP`, `httprb` and `httpclient` ([#2501][], [#2576][])([@caramcc][])
+* Tracing: Flexible header matching for HTTP propagator ([#2504][])
+* Tracing: `OpenTelemetry` Traces support ([#2496][])
+* Tracing: W3C: Propagate unknown values as-is ([#2485][])
+* Appsec: Add event kit API ([#2512][])
+* Profiling: Allow profiler development on arm64 macOS ([#2573][])
+* Core: Add `profiling_enabled` state to environment logger output ([#2541][])
+* Core: Add 'type' to `OptionDefinition` ([#2493][])
+* Allow `debase-ruby_core_source` 3.2.0 to be used ([#2526][])
+
+### Changed
+
+* Profiling: Upgrade to `libdatadog` to `1.0.1.1.0` ([#2530][])
+* Appsec: Update appsec rules `1.4.3` ([#2580][])
+* Ci: Update CI Visibility metadata extraction ([#2586][])
+
+### Fixed
+
+* Profiling: Fix wrong `libdatadog` version being picked during profiler build ([#2531][])
+* Tracing: Support `PG` calls with a block ([#2522][])
+* Ci: Fix error in `teamcity` env vars ([#2562][])
+
 ## [1.8.0] - 2022-12-14
 
 Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v1.8.0
@@ -2250,7 +2281,8 @@ Release notes: https://github.com/DataDog/dd-trace-rb/releases/tag/v0.3.1
 
 Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 
-[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.8.0...master
+[Unreleased]: https://github.com/DataDog/dd-trace-rb/compare/v1.9.0...master
+[1.9.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.8.0...v1.9.0
 [1.8.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.7.0...v1.8.0
 [1.7.0]: https://github.com/DataDog/dd-trace-rb/compare/v1.6.1...v1.7.0
 [1.6.1]: https://github.com/DataDog/dd-trace-rb/compare/v1.6.0...v1.6.1
@@ -3210,7 +3242,24 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [#2469]: https://github.com/DataDog/dd-trace-rb/issues/2469
 [#2470]: https://github.com/DataDog/dd-trace-rb/issues/2470
 [#2473]: https://github.com/DataDog/dd-trace-rb/issues/2473
+[#2485]: https://github.com/DataDog/dd-trace-rb/issues/2485
 [#2489]: https://github.com/DataDog/dd-trace-rb/issues/2489
+[#2493]: https://github.com/DataDog/dd-trace-rb/issues/2493
+[#2496]: https://github.com/DataDog/dd-trace-rb/issues/2496
+[#2501]: https://github.com/DataDog/dd-trace-rb/issues/2501
+[#2504]: https://github.com/DataDog/dd-trace-rb/issues/2504
+[#2512]: https://github.com/DataDog/dd-trace-rb/issues/2512
+[#2522]: https://github.com/DataDog/dd-trace-rb/issues/2522
+[#2526]: https://github.com/DataDog/dd-trace-rb/issues/2526
+[#2530]: https://github.com/DataDog/dd-trace-rb/issues/2530
+[#2531]: https://github.com/DataDog/dd-trace-rb/issues/2531
+[#2541]: https://github.com/DataDog/dd-trace-rb/issues/2541
+[#2557]: https://github.com/DataDog/dd-trace-rb/issues/2557
+[#2562]: https://github.com/DataDog/dd-trace-rb/issues/2562
+[#2573]: https://github.com/DataDog/dd-trace-rb/issues/2573
+[#2576]: https://github.com/DataDog/dd-trace-rb/issues/2576
+[#2580]: https://github.com/DataDog/dd-trace-rb/issues/2580
+[#2586]: https://github.com/DataDog/dd-trace-rb/issues/2586
 [@AdrianLC]: https://github.com/AdrianLC
 [@Azure7111]: https://github.com/Azure7111
 [@BabyGroot]: https://github.com/BabyGroot
@@ -3249,6 +3298,7 @@ Git diff: https://github.com/DataDog/dd-trace-rb/compare/v0.3.0...v0.3.1
 [@brafales]: https://github.com/brafales
 [@bzf]: https://github.com/bzf
 [@callumj]: https://github.com/callumj
+[@caramcc]: https://github.com/caramcc
 [@carlallen]: https://github.com/carlallen
 [@chychkan]: https://github.com/chychkan
 [@cjford]: https://github.com/cjford

data/ext/ddtrace_profiling_native_extension/collectors_cpu_and_wall_time.c

@@ -147,7 +147,7 @@ static void trigger_sample_for_thread(
   struct cpu_and_wall_time_collector_state *state,
   VALUE thread,
   struct per_thread_context *thread_context,
-  ddog_Slice_i64 metric_values_slice,
+  ddog_Slice_I64 metric_values_slice,
   sample_type type
 );
 static VALUE _native_thread_list(VALUE self);
@@ -366,7 +366,7 @@ void cpu_and_wall_time_collector_sample(VALUE self_instance, long current_monoto
       state,
       thread,
       thread_context,
-      (ddog_Slice_i64) {.ptr = metric_values, .len = ENABLED_VALUE_TYPES_COUNT},
+      (ddog_Slice_I64) {.ptr = metric_values, .len = ENABLED_VALUE_TYPES_COUNT},
       SAMPLE_REGULAR
     );
   }
@@ -520,7 +520,7 @@ VALUE cpu_and_wall_time_collector_sample_after_gc(VALUE self_instance) {
       state,
       thread,
       thread_context,
-      (ddog_Slice_i64) {.ptr = metric_values, .len = ENABLED_VALUE_TYPES_COUNT},
+      (ddog_Slice_I64) {.ptr = metric_values, .len = ENABLED_VALUE_TYPES_COUNT},
       SAMPLE_IN_GC
     );
 
@@ -549,24 +549,24 @@ static void trigger_sample_for_thread(
   struct cpu_and_wall_time_collector_state *state,
   VALUE thread,
   struct per_thread_context *thread_context,
-  ddog_Slice_i64 metric_values_slice,
+  ddog_Slice_I64 metric_values_slice,
   sample_type type
 ) {
   int max_label_count =
     1 + // thread id
     1 + // thread name
     2;  // local root span id and span id
-  ddog_Label labels[max_label_count];
+  ddog_prof_Label labels[max_label_count];
   int label_pos = 0;
 
-  labels[label_pos++] = (ddog_Label) {
+  labels[label_pos++] = (ddog_prof_Label) {
     .key = DDOG_CHARSLICE_C("thread id"),
     .str = thread_context->thread_id_char_slice
   };
 
   VALUE thread_name = thread_name_for(thread);
   if (thread_name != Qnil) {
-    labels[label_pos++] = (ddog_Label) {
+    labels[label_pos++] = (ddog_prof_Label) {
       .key = DDOG_CHARSLICE_C("thread name"),
       .str = char_slice_from_ruby_string(thread_name)
     };
@@ -576,8 +576,8 @@ static void trigger_sample_for_thread(
   trace_identifiers_for(state, thread, &trace_identifiers_result);
 
   if (trace_identifiers_result.valid) {
-    labels[label_pos++] = (ddog_Label) {.key = DDOG_CHARSLICE_C("local root span id"), .str = trace_identifiers_result.local_root_span_id};
-    labels[label_pos++] = (ddog_Label) {.key = DDOG_CHARSLICE_C("span id"), .num = trace_identifiers_result.span_id};
+    labels[label_pos++] = (ddog_prof_Label) {.key = DDOG_CHARSLICE_C("local root span id"), .str = trace_identifiers_result.local_root_span_id};
+    labels[label_pos++] = (ddog_prof_Label) {.key = DDOG_CHARSLICE_C("span id"), .num = trace_identifiers_result.span_id};
 
     if (trace_identifiers_result.trace_endpoint != Qnil) {
       // The endpoint gets recorded in a different way because it is mutable in the tracer and can change during a
@@ -610,7 +610,7 @@ static void trigger_sample_for_thread(
     state->sampling_buffer,
     state->recorder_instance,
     metric_values_slice,
-    (ddog_Slice_label) {.ptr = labels, .len = label_pos},
+    (ddog_prof_Slice_Label) {.ptr = labels, .len = label_pos},
     type
   );
 }

data/ext/ddtrace_profiling_native_extension/collectors_stack.c

@@ -22,8 +22,8 @@ struct sampling_buffer {
   VALUE *stack_buffer;
   int *lines_buffer;
   bool *is_ruby_frame;
-  ddog_Location *locations;
-  ddog_Line *lines;
+  ddog_prof_Location *locations;
+  ddog_prof_Line *lines;
 }; // Note: typedef'd in the header to sampling_buffer
 
 static VALUE _native_sample(
@@ -39,8 +39,8 @@ static void maybe_add_placeholder_frames_omitted(VALUE thread, sampling_buffer*
 static void record_placeholder_stack_in_native_code(
   sampling_buffer* buffer,
   VALUE recorder_instance,
-  ddog_Slice_i64 metric_values,
-  ddog_Slice_label labels,
+  ddog_Slice_I64 metric_values,
+  ddog_prof_Slice_Label labels,
   sampling_buffer *record_buffer,
   int extra_frames_in_record_buffer
 );
@@ -48,8 +48,8 @@ static void sample_thread_internal(
   VALUE thread,
   sampling_buffer* buffer,
   VALUE recorder_instance,
-  ddog_Slice_i64 metric_values,
-  ddog_Slice_label labels,
+  ddog_Slice_I64 metric_values,
+  ddog_prof_Slice_Label labels,
   sampling_buffer *record_buffer,
   int extra_frames_in_record_buffer
 );
@@ -96,12 +96,12 @@ static VALUE _native_sample(
   }
 
   long labels_count = RARRAY_LEN(labels_array);
-  ddog_Label labels[labels_count];
+  ddog_prof_Label labels[labels_count];
 
   for (int i = 0; i < labels_count; i++) {
     VALUE key_str_pair = rb_ary_entry(labels_array, i);
 
-    labels[i] = (ddog_Label) {
+    labels[i] = (ddog_prof_Label) {
       .key = char_slice_from_ruby_string(rb_ary_entry(key_str_pair, 0)),
       .str = char_slice_from_ruby_string(rb_ary_entry(key_str_pair, 1))
     };
@@ -116,8 +116,8 @@ static VALUE _native_sample(
     thread,
     buffer,
     recorder_instance,
-    (ddog_Slice_i64) {.ptr = metric_values, .len = ENABLED_VALUE_TYPES_COUNT},
-    (ddog_Slice_label) {.ptr = labels, .len = labels_count},
+    (ddog_Slice_I64) {.ptr = metric_values, .len = ENABLED_VALUE_TYPES_COUNT},
+    (ddog_prof_Slice_Label) {.ptr = labels, .len = labels_count},
     RTEST(in_gc) ? SAMPLE_IN_GC : SAMPLE_REGULAR
   );
 
@@ -130,8 +130,8 @@ void sample_thread(
   VALUE thread,
   sampling_buffer* buffer,
   VALUE recorder_instance,
-  ddog_Slice_i64 metric_values,
-  ddog_Slice_label labels,
+  ddog_Slice_I64 metric_values,
+  ddog_prof_Slice_Label labels,
   sample_type type
 ) {
   // Samples thread into recorder
@@ -146,8 +146,8 @@ void sample_thread(
   if (type == SAMPLE_IN_GC) {
     ddog_CharSlice function_name = DDOG_CHARSLICE_C("");
     ddog_CharSlice function_filename = DDOG_CHARSLICE_C("Garbage Collection");
-    buffer->lines[0] = (ddog_Line) {
-      .function = (ddog_Function) {.name = function_name, .filename = function_filename},
+    buffer->lines[0] = (ddog_prof_Line) {
+      .function = (ddog_prof_Function) {.name = function_name, .filename = function_filename},
       .line = 0
     };
     // To avoid changing sample_thread_internal, we just prepare a new buffer struct that uses the same underlying storage as the
@@ -192,8 +192,8 @@ static void sample_thread_internal(
   VALUE thread,
   sampling_buffer* buffer,
   VALUE recorder_instance,
-  ddog_Slice_i64 metric_values,
-  ddog_Slice_label labels,
+  ddog_Slice_I64 metric_values,
+  ddog_prof_Slice_Label labels,
   sampling_buffer *record_buffer,
   int extra_frames_in_record_buffer
 ) {
@@ -257,8 +257,8 @@ static void sample_thread_internal(
     name = NIL_P(name) ? missing_string : name;
     filename = NIL_P(filename) ? missing_string : filename;
 
-    buffer->lines[i] = (ddog_Line) {
-      .function = (ddog_Function) {
+    buffer->lines[i] = (ddog_prof_Line) {
+      .function = (ddog_prof_Function) {
         .name = char_slice_from_ruby_string(name),
         .filename = char_slice_from_ruby_string(filename)
       },
@@ -278,8 +278,8 @@ static void sample_thread_internal(
 
   record_sample(
     recorder_instance,
-    (ddog_Sample) {
-      .locations = (ddog_Slice_location) {.ptr = record_buffer->locations, .len = captured_frames + extra_frames_in_record_buffer},
+    (ddog_prof_Sample) {
+      .locations = (ddog_prof_Slice_Location) {.ptr = record_buffer->locations, .len = captured_frames + extra_frames_in_record_buffer},
       .values = metric_values,
       .labels = labels,
     }
@@ -301,8 +301,8 @@ static void maybe_add_placeholder_frames_omitted(VALUE thread, sampling_buffer*
   // `record_sample`. So be careful where it gets allocated. (We do have tests for this, at least!)
   ddog_CharSlice function_name = DDOG_CHARSLICE_C("");
   ddog_CharSlice function_filename = {.ptr = frames_omitted_message, .len = strlen(frames_omitted_message)};
-  buffer->lines[buffer->max_frames - 1] = (ddog_Line) {
-    .function = (ddog_Function) {.name = function_name, .filename = function_filename},
+  buffer->lines[buffer->max_frames - 1] = (ddog_prof_Line) {
+    .function = (ddog_prof_Function) {.name = function_name, .filename = function_filename},
     .line = 0,
   };
 }
@@ -330,22 +330,22 @@ static void maybe_add_placeholder_frames_omitted(VALUE thread, sampling_buffer*
 static void record_placeholder_stack_in_native_code(
   sampling_buffer* buffer,
   VALUE recorder_instance,
-  ddog_Slice_i64 metric_values,
-  ddog_Slice_label labels,
+  ddog_Slice_I64 metric_values,
+  ddog_prof_Slice_Label labels,
   sampling_buffer *record_buffer,
   int extra_frames_in_record_buffer
 ) {
   ddog_CharSlice function_name = DDOG_CHARSLICE_C("");
   ddog_CharSlice function_filename = DDOG_CHARSLICE_C("In native code");
-  buffer->lines[0] = (ddog_Line) {
-    .function = (ddog_Function) {.name = function_name, .filename = function_filename},
+  buffer->lines[0] = (ddog_prof_Line) {
+    .function = (ddog_prof_Function) {.name = function_name, .filename = function_filename},
     .line = 0
   };
 
   record_sample(
     recorder_instance,
-    (ddog_Sample) {
-      .locations = (ddog_Slice_location) {.ptr = record_buffer->locations, .len = 1 + extra_frames_in_record_buffer},
+    (ddog_prof_Sample) {
+      .locations = (ddog_prof_Slice_Location) {.ptr = record_buffer->locations, .len = 1 + extra_frames_in_record_buffer},
       .values = metric_values,
       .labels = labels,
     }
@@ -364,14 +364,14 @@ sampling_buffer *sampling_buffer_new(unsigned int max_frames) {
   buffer->stack_buffer  = ruby_xcalloc(max_frames, sizeof(VALUE));
   buffer->lines_buffer  = ruby_xcalloc(max_frames, sizeof(int));
   buffer->is_ruby_frame = ruby_xcalloc(max_frames, sizeof(bool));
-  buffer->locations     = ruby_xcalloc(max_frames, sizeof(ddog_Location));
-  buffer->lines         = ruby_xcalloc(max_frames, sizeof(ddog_Line));
+  buffer->locations     = ruby_xcalloc(max_frames, sizeof(ddog_prof_Location));
+  buffer->lines         = ruby_xcalloc(max_frames, sizeof(ddog_prof_Line));
 
   // Currently we have a 1-to-1 correspondence between lines and locations, so we just initialize the locations once
   // here and then only mutate the contents of the lines.
   for (unsigned int i = 0; i < max_frames; i++) {
-    ddog_Slice_line lines = (ddog_Slice_line) {.ptr = &buffer->lines[i], .len = 1};
-    buffer->locations[i] = (ddog_Location) {.lines = lines};
+    ddog_prof_Slice_Line lines = (ddog_prof_Slice_Line) {.ptr = &buffer->lines[i], .len = 1};
+    buffer->locations[i] = (ddog_prof_Location) {.lines = lines};
   }
 
   return buffer;

data/ext/ddtrace_profiling_native_extension/collectors_stack.h

@@ -10,8 +10,8 @@ void sample_thread(
   VALUE thread,
   sampling_buffer* buffer,
   VALUE recorder_instance,
-  ddog_Slice_i64 metric_values,
-  ddog_Slice_label labels,
+  ddog_Slice_I64 metric_values,
+  ddog_prof_Slice_Label labels,
   sample_type type
 );
 sampling_buffer *sampling_buffer_new(unsigned int max_frames);

data/ext/ddtrace_profiling_native_extension/http_transport.c

@@ -20,20 +20,20 @@ static VALUE http_transport_class = Qnil;
 static VALUE library_version_string = Qnil;
 
 struct call_exporter_without_gvl_arguments {
-  ddog_ProfileExporter *exporter;
-  ddog_Request *request;
+  ddog_prof_Exporter *exporter;
+  ddog_prof_Exporter_Request *request;
   ddog_CancellationToken *cancel_token;
-  ddog_SendResult result;
+  ddog_prof_Exporter_SendResult result;
   bool send_ran;
 };
 
 inline static ddog_ByteSlice byte_slice_from_ruby_string(VALUE string);
 static VALUE _native_validate_exporter(VALUE self, VALUE exporter_configuration);
-static ddog_NewProfileExporterResult create_exporter(VALUE exporter_configuration, VALUE tags_as_array);
-static VALUE handle_exporter_failure(ddog_NewProfileExporterResult exporter_result);
+static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration, VALUE tags_as_array);
+static VALUE handle_exporter_failure(ddog_prof_Exporter_NewResult exporter_result);
 static ddog_Endpoint endpoint_from(VALUE exporter_configuration);
-static ddog_Vec_tag convert_tags(VALUE tags_as_array);
-static void safely_log_failure_to_process_tag(ddog_Vec_tag tags, VALUE err_details);
+static ddog_Vec_Tag convert_tags(VALUE tags_as_array);
+static void safely_log_failure_to_process_tag(ddog_Vec_Tag tags, VALUE err_details);
 static VALUE _native_do_export(
   VALUE self,
   VALUE exporter_configuration,
@@ -76,46 +76,46 @@ inline static ddog_ByteSlice byte_slice_from_ruby_string(VALUE string) {
 
 static VALUE _native_validate_exporter(DDTRACE_UNUSED VALUE _self, VALUE exporter_configuration) {
   ENFORCE_TYPE(exporter_configuration, T_ARRAY);
-  ddog_NewProfileExporterResult exporter_result = create_exporter(exporter_configuration, rb_ary_new());
+  ddog_prof_Exporter_NewResult exporter_result = create_exporter(exporter_configuration, rb_ary_new());
 
   VALUE failure_tuple = handle_exporter_failure(exporter_result);
   if (!NIL_P(failure_tuple)) return failure_tuple;
 
   // We don't actually need the exporter for now -- we just wanted to validate that we could create it with the
   // settings we were given
-  ddog_NewProfileExporterResult_drop(exporter_result);
+  ddog_prof_Exporter_NewResult_drop(exporter_result);
 
   return rb_ary_new_from_args(2, ok_symbol, Qnil);
 }
 
-static ddog_NewProfileExporterResult create_exporter(VALUE exporter_configuration, VALUE tags_as_array) {
+static ddog_prof_Exporter_NewResult create_exporter(VALUE exporter_configuration, VALUE tags_as_array) {
   ENFORCE_TYPE(exporter_configuration, T_ARRAY);
   ENFORCE_TYPE(tags_as_array, T_ARRAY);
 
-  // This needs to be called BEFORE convert_tags since it can raise an exception and thus cause the ddog_Vec_tag
+  // This needs to be called BEFORE convert_tags since it can raise an exception and thus cause the ddog_Vec_Tag
   // to be leaked.
   ddog_Endpoint endpoint = endpoint_from(exporter_configuration);
 
-  ddog_Vec_tag tags = convert_tags(tags_as_array);
+  ddog_Vec_Tag tags = convert_tags(tags_as_array);
 
   ddog_CharSlice library_name = DDOG_CHARSLICE_C("dd-trace-rb");
   ddog_CharSlice library_version = char_slice_from_ruby_string(library_version_string);
   ddog_CharSlice profiling_family = DDOG_CHARSLICE_C("ruby");
 
-  ddog_NewProfileExporterResult exporter_result =
-    ddog_ProfileExporter_new(library_name, library_version, profiling_family, &tags, endpoint);
+  ddog_prof_Exporter_NewResult exporter_result =
+    ddog_prof_Exporter_new(library_name, library_version, profiling_family, &tags, endpoint);
 
-  ddog_Vec_tag_drop(tags);
+  ddog_Vec_Tag_drop(tags);
 
   return exporter_result;
 }
 
-static VALUE handle_exporter_failure(ddog_NewProfileExporterResult exporter_result) {
-  if (exporter_result.tag == DDOG_NEW_PROFILE_EXPORTER_RESULT_OK) return Qnil;
+static VALUE handle_exporter_failure(ddog_prof_Exporter_NewResult exporter_result) {
+  if (exporter_result.tag == DDOG_PROF_EXPORTER_NEW_RESULT_OK) return Qnil;
 
-  VALUE err_details = ruby_string_from_vec_u8(exporter_result.err);
+  VALUE err_details = ruby_string_from_prof_vec_u8(exporter_result.err);
 
-  ddog_NewProfileExporterResult_drop(exporter_result);
+  ddog_prof_Exporter_NewResult_drop(exporter_result);
 
   return rb_ary_new_from_args(2, error_symbol, err_details);
 }
@@ -145,17 +145,17 @@ static ddog_Endpoint endpoint_from(VALUE exporter_configuration) {
 }
 
 __attribute__((warn_unused_result))
-static ddog_Vec_tag convert_tags(VALUE tags_as_array) {
+static ddog_Vec_Tag convert_tags(VALUE tags_as_array) {
   ENFORCE_TYPE(tags_as_array, T_ARRAY);
 
   long tags_count = RARRAY_LEN(tags_as_array);
-  ddog_Vec_tag tags = ddog_Vec_tag_new();
+  ddog_Vec_Tag tags = ddog_Vec_Tag_new();
 
   for (long i = 0; i < tags_count; i++) {
     VALUE name_value_pair = rb_ary_entry(tags_as_array, i);
 
     if (!RB_TYPE_P(name_value_pair, T_ARRAY)) {
-      ddog_Vec_tag_drop(tags);
+      ddog_Vec_Tag_drop(tags);
       ENFORCE_TYPE(name_value_pair, T_ARRAY);
     }
 
@@ -164,23 +164,23 @@ static ddog_Vec_tag convert_tags(VALUE tags_as_array) {
     VALUE tag_value = rb_ary_entry(name_value_pair, 1);
 
     if (!(RB_TYPE_P(tag_name, T_STRING) && RB_TYPE_P(tag_value, T_STRING))) {
-      ddog_Vec_tag_drop(tags);
+      ddog_Vec_Tag_drop(tags);
       ENFORCE_TYPE(tag_name, T_STRING);
       ENFORCE_TYPE(tag_value, T_STRING);
     }
 
-    ddog_PushTagResult push_result =
-      ddog_Vec_tag_push(&tags, char_slice_from_ruby_string(tag_name), char_slice_from_ruby_string(tag_value));
+    ddog_Vec_Tag_PushResult push_result =
+      ddog_Vec_Tag_push(&tags, char_slice_from_ruby_string(tag_name), char_slice_from_ruby_string(tag_value));
 
-    if (push_result.tag == DDOG_PUSH_TAG_RESULT_ERR) {
+    if (push_result.tag == DDOG_VEC_TAG_PUSH_RESULT_ERR) {
       VALUE err_details = ruby_string_from_vec_u8(push_result.err);
-      ddog_PushTagResult_drop(push_result);
+      ddog_Vec_Tag_PushResult_drop(push_result);
 
       // libdatadog validates tags and may catch invalid tags that ddtrace didn't actually catch.
       // We warn users about such tags, and then just ignore them.
       safely_log_failure_to_process_tag(tags, err_details);
     } else {
-      ddog_PushTagResult_drop(push_result);
+      ddog_Vec_Tag_PushResult_drop(push_result);
     }
   }
 
@@ -193,12 +193,12 @@ static VALUE log_failure_to_process_tag(VALUE err_details) {
 
 // Since we are calling into Ruby code, it may raise an exception. This method ensure that dynamically-allocated tags
 // get cleaned before propagating the exception.
-static void safely_log_failure_to_process_tag(ddog_Vec_tag tags, VALUE err_details) {
+static void safely_log_failure_to_process_tag(ddog_Vec_Tag tags, VALUE err_details) {
   int exception_state;
   rb_protect(log_failure_to_process_tag, err_details, &exception_state);
 
   if (exception_state) {           // An exception was raised
-    ddog_Vec_tag_drop(tags); // clean up
+    ddog_Vec_Tag_drop(tags); // clean up
     rb_jump_tag(exception_state);  // "Re-raise" exception
   }
 }
@@ -206,17 +206,18 @@ static void safely_log_failure_to_process_tag(ddog_Vec_tag tags, VALUE err_detai
 // Note: This function handles a bunch of libdatadog dynamically-allocated objects, so it MUST not use any Ruby APIs
 // which can raise exceptions, otherwise the objects will be leaked.
 static VALUE perform_export(
-  ddog_NewProfileExporterResult valid_exporter_result, // Must be called with a valid exporter result
+  ddog_prof_Exporter_NewResult valid_exporter_result, // Must be called with a valid exporter result
   ddog_Timespec start,
   ddog_Timespec finish,
-  ddog_Slice_file slice_files,
-  ddog_Vec_tag *additional_tags,
+  ddog_prof_Exporter_Slice_File slice_files,
+  ddog_Vec_Tag *additional_tags,
   uint64_t timeout_milliseconds
 ) {
-  ddog_ProfileExporter *exporter = valid_exporter_result.ok;
+  ddog_prof_Exporter *exporter = valid_exporter_result.ok;
   ddog_CancellationToken *cancel_token = ddog_CancellationToken_new();
-  ddog_Request *request =
-    ddog_ProfileExporter_build(exporter, start, finish, slice_files, additional_tags, timeout_milliseconds);
+  ddog_prof_ProfiledEndpointsStats *endpoints_stats = NULL; // Not in use yet
+  ddog_prof_Exporter_Request *request =
+    ddog_prof_Exporter_Request_build(exporter, start, finish, slice_files, additional_tags, endpoints_stats, timeout_milliseconds);
 
   // We'll release the Global VM Lock while we're calling send, so that the Ruby VM can continue to work while this
   // is pending
@@ -246,23 +247,23 @@ static VALUE perform_export(
 
   // Cleanup exporter and token, no longer needed
   ddog_CancellationToken_drop(cancel_token);
-  ddog_NewProfileExporterResult_drop(valid_exporter_result);
+  ddog_prof_Exporter_NewResult_drop(valid_exporter_result);
 
   if (pending_exception) {
     // If we got here send did not run, so we need to explicitly dispose of the request
-    ddog_Request_drop(request);
+    ddog_prof_Exporter_Request_drop(request);
 
     // Let Ruby propagate the exception. This will not return.
     rb_jump_tag(pending_exception);
   }
 
-  ddog_SendResult result = args.result;
-  bool success = result.tag == DDOG_SEND_RESULT_HTTP_RESPONSE;
+  ddog_prof_Exporter_SendResult result = args.result;
+  bool success = result.tag == DDOG_PROF_EXPORTER_SEND_RESULT_HTTP_RESPONSE;
 
   VALUE ruby_status = success ? ok_symbol : error_symbol;
-  VALUE ruby_result = success ? UINT2NUM(result.http_response.code) : ruby_string_from_vec_u8(result.err);
+  VALUE ruby_result = success ? UINT2NUM(result.http_response.code) : ruby_string_from_prof_vec_u8(result.err);
 
-  ddog_SendResult_drop(args.result);
+  ddog_prof_Exporter_SendResult_drop(args.result);
   // The request itself does not need to be freed as libdatadog takes care of it as part of sending.
 
   return rb_ary_new_from_args(2, ruby_status, ruby_result);
@@ -303,23 +304,23 @@ static VALUE _native_do_export(
     {.seconds = NUM2LONG(finish_timespec_seconds), .nanoseconds = NUM2UINT(finish_timespec_nanoseconds)};
 
   int files_to_report = 1 + (have_code_provenance ? 1 : 0);
-  ddog_File files[files_to_report];
-  ddog_Slice_file slice_files = {.ptr = files, .len = files_to_report};
+  ddog_prof_Exporter_File files[files_to_report];
+  ddog_prof_Exporter_Slice_File slice_files = {.ptr = files, .len = files_to_report};
 
-  files[0] = (ddog_File) {
+  files[0] = (ddog_prof_Exporter_File) {
     .name = char_slice_from_ruby_string(pprof_file_name),
     .file = byte_slice_from_ruby_string(pprof_data)
   };
   if (have_code_provenance) {
-    files[1] = (ddog_File) {
+    files[1] = (ddog_prof_Exporter_File) {
       .name = char_slice_from_ruby_string(code_provenance_file_name),
       .file = byte_slice_from_ruby_string(code_provenance_data)
     };
   }
 
-  ddog_Vec_tag *null_additional_tags = NULL;
+  ddog_Vec_Tag *null_additional_tags = NULL;
 
-  ddog_NewProfileExporterResult exporter_result = create_exporter(exporter_configuration, tags_as_array);
+  ddog_prof_Exporter_NewResult exporter_result = create_exporter(exporter_configuration, tags_as_array);
   // Note: Do not add anything that can raise exceptions after this line, as otherwise the exporter memory will leak
 
   VALUE failure_tuple = handle_exporter_failure(exporter_result);
@@ -331,7 +332,7 @@ static VALUE _native_do_export(
 static void *call_exporter_without_gvl(void *call_args) {
   struct call_exporter_without_gvl_arguments *args = (struct call_exporter_without_gvl_arguments*) call_args;
 
-  args->result = ddog_ProfileExporter_send(args->exporter, args->request, args->cancel_token);
+  args->result = ddog_prof_Exporter_send(args->exporter, args->request, args->cancel_token);
   args->send_ran = true;
 
   return NULL; // Unused

data/ext/ddtrace_profiling_native_extension/libdatadog_helpers.h

@@ -9,6 +9,10 @@ inline static ddog_CharSlice char_slice_from_ruby_string(VALUE string) {
   return char_slice;
 }
 
-inline static VALUE ruby_string_from_vec_u8(ddog_Vec_u8 string) {
+inline static VALUE ruby_string_from_vec_u8(ddog_Vec_U8 string) {
+  return rb_str_new((char *) string.ptr, string.len);
+}
+
+inline static VALUE ruby_string_from_prof_vec_u8(ddog_prof_Vec_U8 string) {
   return rb_str_new((char *) string.ptr, string.len);
 }