ddtrace 1.2.0 → 1.10.1

data/ext/ddtrace_profiling_native_extension/collectors_thread_context.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <ruby.h>
+
+void thread_context_collector_sample(
+  VALUE self_instance,
+  long current_monotonic_wall_time_ns,
+  VALUE profiler_overhead_stack_thread
+);
+void thread_context_collector_sample_allocation(VALUE self_instance, unsigned int sample_weight);
+VALUE thread_context_collector_sample_after_gc(VALUE self_instance);
+void thread_context_collector_on_gc_start(VALUE self_instance);
+void thread_context_collector_on_gc_finish(VALUE self_instance);
+VALUE enforce_thread_context_collector_instance(VALUE object);

data/ext/ddtrace_profiling_native_extension/extconf.rb

@@ -1,5 +1,3 @@
-# typed: ignore
-
 # rubocop:disable Style/StderrPuts
 # rubocop:disable Style/GlobalVars
 
@@ -28,7 +26,7 @@ def skip_building_extension!(reason)
   if fail_install_if_missing_extension
     require 'mkmf'
     Logging.message(
-      ' [ddtrace] Failure cause: ' \
+      '[ddtrace] Failure cause: ' \
       "#{Datadog::Profiling::NativeExtensionHelpers::Supported.render_skipped_reason_file(**reason)}\n"
     )
   else
@@ -42,7 +40,8 @@ unless Datadog::Profiling::NativeExtensionHelpers::Supported.supported?
   skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported.unsupported_reason)
 end
 
-$stderr.puts(%(
+$stderr.puts(
+  %(
 +------------------------------------------------------------------------------+
 | ** Preparing to build the ddtrace profiling native extension... **           |
 |                                                                              |
@@ -59,12 +58,17 @@ $stderr.puts(%(
 | Thanks for using ddtrace! You rock!                                          |
 +------------------------------------------------------------------------------+
 
-))
+)
+)
 
 # NOTE: we MUST NOT require 'mkmf' before we check the #skip_building_extension? because the require triggers checks
 # that may fail on an environment not properly setup for building Ruby extensions.
 require 'mkmf'
 
+Logging.message("[ddtrace] Using compiler:\n")
+xsystem("#{CONFIG['CC']} -v")
+Logging.message("[ddtrace] End of compiler information\n")
+
 # mkmf on modern Rubies actually has an append_cflags that does something similar
 # (see https://github.com/ruby/ruby/pull/5760), but as usual we need a bit more boilerplate to deal with legacy Rubies
 def add_compiler_flag(flag)
@@ -75,13 +79,17 @@ def add_compiler_flag(flag)
   end
 end
 
+# Because we can't control what compiler versions our customers use, shipping with -Werror by default is a no-go.
+# But we can enable it in CI, so that we quickly spot any new warnings that just got introduced.
+add_compiler_flag '-Werror' if ENV['DDTRACE_CI'] == 'true'
+
 # Older gcc releases may not default to C99 and we need to ask for this. This is also used:
 # * by upstream Ruby -- search for gnu99 in the codebase
 # * by msgpack, another ddtrace dependency
 #   (https://github.com/msgpack/msgpack-ruby/blob/18ce08f6d612fe973843c366ac9a0b74c4e50599/ext/msgpack/extconf.rb#L8)
 add_compiler_flag '-std=gnu99'
 
-# Gets really noisy when we include the MJIT header, let's omit it
+# Gets really noisy when we include the MJIT header, let's omit it (TODO: Use #pragma GCC diagnostic instead?)
 add_compiler_flag '-Wno-unused-function'
 
 # Allow defining variables at any point in a function
@@ -91,6 +99,9 @@ add_compiler_flag '-Wno-declaration-after-statement'
 # cause a segfault later. Let's ensure that never happens.
 add_compiler_flag '-Werror-implicit-function-declaration'
 
+# Warn on unused parameters to functions. Use `DDTRACE_UNUSED` to mark things as known-to-not-be-used.
+add_compiler_flag '-Wunused-parameter'
+
 # The native extension is not intended to expose any symbols/functions for other native libraries to use;
 # the sole exception being `Init_ddtrace_profiling_native_extension` which needs to be visible for Ruby to call it when
 # it `dlopen`s the library.
@@ -99,13 +110,20 @@ add_compiler_flag '-Werror-implicit-function-declaration'
 # For more details see https://gcc.gnu.org/wiki/Visibility
 add_compiler_flag '-fvisibility=hidden'
 
+# Avoid legacy C definitions
+add_compiler_flag '-Wold-style-definition'
+
+# Enable all other compiler warnings
+add_compiler_flag '-Wall'
+add_compiler_flag '-Wextra'
+
 if RUBY_PLATFORM.include?('linux')
   # Supposedly, the correct way to do this is
   # ```
   # have_library 'pthread'
   # have_func 'pthread_getcpuclockid'
   # ```
-  # but it broke the build on Windows and on older Ruby versions (2.1 and 2.2)
+  # but a) it broke the build on Windows, b) on older Ruby versions (2.2 and below) and c) It's slower to build
   # so instead we just assume that we have the function we need on Linux, and nowhere else
   $defs << '-DHAVE_PTHREAD_GETCPUCLOCKID'
 end
@@ -113,12 +131,27 @@ end
 # On older Rubies, there was no struct rb_native_thread. See private_vm_api_acccess.c for details.
 $defs << '-DNO_RB_NATIVE_THREAD' if RUBY_VERSION < '3.2'
 
+# On older Rubies, there was no struct rb_thread_sched (it was struct rb_global_vm_lock_struct)
+$defs << '-DNO_RB_THREAD_SCHED' if RUBY_VERSION < '3.2'
+
+# On older Rubies, there was no tid member in the internal thread structure
+$defs << '-DNO_THREAD_TID' if RUBY_VERSION < '3.1'
+
 # On older Rubies, we need to use a backported version of this function. See private_vm_api_access.h for details.
 $defs << '-DUSE_BACKPORTED_RB_PROFILE_FRAME_METHOD_NAME' if RUBY_VERSION < '3'
 
+# On older Rubies, there are no Ractors
+$defs << '-DNO_RACTORS' if RUBY_VERSION < '3'
+
+# On older Rubies, rb_global_vm_lock_struct did not include the owner field
+$defs << '-DNO_GVL_OWNER' if RUBY_VERSION < '2.6'
+
 # On older Rubies, we need to use rb_thread_t instead of rb_execution_context_t
 $defs << '-DUSE_THREAD_INSTEAD_OF_EXECUTION_CONTEXT' if RUBY_VERSION < '2.5'
 
+# On older Rubies, extensions can't use GET_VM()
+$defs << '-DNO_GET_VM' if RUBY_VERSION < '2.5'
+
 # On older Rubies...
 if RUBY_VERSION < '2.4'
   # ...we need to use RUBY_VM_NORMAL_ISEQ_P instead of VM_FRAME_RUBYFRAME_P
@@ -127,39 +160,33 @@ if RUBY_VERSION < '2.4'
   $defs << '-DUSE_LEGACY_RB_VM_FRAME_METHOD_ENTRY'
 end
 
-# For REALLY OLD Rubies...
-if RUBY_VERSION < '2.3'
-  # ...there was no rb_time_timespec_new function
-  $defs << '-DNO_RB_TIME_TIMESPEC_NEW'
-  # ...the VM changed enough that we need an alternative legacy rb_profile_frames
-  $defs << '-DUSE_LEGACY_RB_PROFILE_FRAMES'
-end
-
-# In Ruby 2.1, living_threads were stored in a hashmap (st)
-$defs << '-DUSE_LEGACY_LIVING_THREADS_ST' if RUBY_VERSION < '2.2'
-
-# If we got here, libddprof is available and loaded
-ENV['PKG_CONFIG_PATH'] = "#{ENV['PKG_CONFIG_PATH']}:#{Libddprof.pkgconfig_folder}"
-Logging.message(" [ddtrace] PKG_CONFIG_PATH set to #{ENV['PKG_CONFIG_PATH'].inspect}\n")
+# If we got here, libdatadog is available and loaded
+ENV['PKG_CONFIG_PATH'] = "#{ENV['PKG_CONFIG_PATH']}:#{Libdatadog.pkgconfig_folder}"
+Logging.message("[ddtrace] PKG_CONFIG_PATH set to #{ENV['PKG_CONFIG_PATH'].inspect}\n")
+$stderr.puts("Using libdatadog #{Libdatadog::VERSION} from #{Libdatadog.pkgconfig_folder}")
 
-unless pkg_config('ddprof_ffi_with_rpath')
+unless pkg_config('datadog_profiling_with_rpath')
   skip_building_extension!(
     if Datadog::Profiling::NativeExtensionHelpers::Supported.pkg_config_missing?
       Datadog::Profiling::NativeExtensionHelpers::Supported::PKG_CONFIG_IS_MISSING
     else
       # Less specific error message
-      Datadog::Profiling::NativeExtensionHelpers::Supported::FAILED_TO_CONFIGURE_LIBDDPROF
+      Datadog::Profiling::NativeExtensionHelpers::Supported::FAILED_TO_CONFIGURE_LIBDATADOG
     end
   )
 end
 
-# See comments on the helper method being used for why we need to additionally set this
+unless have_type('atomic_int', ['stdatomic.h'])
+  skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported::COMPILER_ATOMIC_MISSING)
+end
+
+# See comments on the helper method being used for why we need to additionally set this.
 # The extremely excessive escaping around ORIGIN below seems to be correct and was determined after a lot of
 # experimentation. We need to get these special characters across a lot of tools untouched...
 $LDFLAGS += \
   ' -Wl,-rpath,$$$\\\\{ORIGIN\\}/' \
-  "#{Datadog::Profiling::NativeExtensionHelpers.libddprof_folder_relative_to_native_lib_folder}"
-Logging.message(" [ddtrace] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
+  "#{Datadog::Profiling::NativeExtensionHelpers.libdatadog_folder_relative_to_native_lib_folder}"
+Logging.message("[ddtrace] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
 
 # Tag the native extension library with the Ruby version and Ruby platform.
 # This makes it easier for development (avoids "oops I forgot to rebuild when I switched my Ruby") and ensures that
@@ -194,13 +221,6 @@ else
   # This gem ships source code copies of these VM headers for the different Ruby VM versions;
   # see https://github.com/ruby-debug/debase-ruby_core_source for details
 
-  thread_native_for_ruby_2_1 = proc { true }
-  if RUBY_VERSION < '2.2'
-    # This header became public in Ruby 2.2, but we need to pull it from the private headers folder for 2.1
-    thread_native_for_ruby_2_1 = proc { have_header('thread_native.h') }
-    $defs << '-DRUBY_2_1_WORKAROUND'
-  end
-
   create_header
 
   require 'debase/ruby_core_source'
@@ -208,7 +228,7 @@ else
 
   Debase::RubyCoreSource
     .create_makefile_with_core(
-      proc { have_header('vm_core.h') && have_header('iseq.h') && thread_native_for_ruby_2_1.call },
+      proc { have_header('vm_core.h') && have_header('iseq.h') },
       EXTENSION_NAME,
     )
 end

data/ext/ddtrace_profiling_native_extension/helpers.h

@@ -0,0 +1,17 @@
+#pragma once
+
+// Used to mark symbols to be exported to the outside of the extension.
+// Consider very carefully before tagging a function with this.
+#define DDTRACE_EXPORT __attribute__ ((visibility ("default")))
+
+// Used to mark function arguments that are deliberately left unused
+#ifdef __GNUC__
+  #define DDTRACE_UNUSED  __attribute__((unused))
+#else
+  #define DDTRACE_UNUSED
+#endif
+
+// @ivoanjo: After trying to read through https://stackoverflow.com/questions/3437404/min-and-max-in-c I decided I
+// don't like C and I just implemented this as a function.
+inline static uint64_t uint64_max_of(uint64_t a, uint64_t b) { return a > b ? a : b; }
+inline static uint64_t uint64_min_of(uint64_t a, uint64_t b) { return a > b ? b : a; }

data/ext/ddtrace_profiling_native_extension/http_transport.c

@@ -1,7 +1,8 @@
 #include <ruby.h>
 #include <ruby/thread.h>
-#include <ddprof/ffi.h>
-#include "libddprof_helpers.h"
+#include <datadog/profiling.h>
+#include "helpers.h"
+#include "libdatadog_helpers.h"
 #include "ruby_helpers.h"
 
 // Used to report profiling data to Datadog.
@@ -16,22 +17,23 @@ static ID agent_id; // id of :agent in Ruby
 static ID log_failure_to_process_tag_id; // id of :log_failure_to_process_tag in Ruby
 
 static VALUE http_transport_class = Qnil;
+static VALUE library_version_string = Qnil;
 
 struct call_exporter_without_gvl_arguments {
-  ddprof_ffi_ProfileExporterV3 *exporter;
-  ddprof_ffi_Request *request;
-  ddprof_ffi_CancellationToken *cancel_token;
-  ddprof_ffi_SendResult result;
+  ddog_prof_Exporter *exporter;
+  ddog_prof_Exporter_Request_BuildResult *build_result;
+  ddog_CancellationToken *cancel_token;
+  ddog_prof_Exporter_SendResult result;
   bool send_ran;
 };
 
-inline static ddprof_ffi_ByteSlice byte_slice_from_ruby_string(VALUE string);
+inline static ddog_ByteSlice byte_slice_from_ruby_string(VALUE string);
 static VALUE _native_validate_exporter(VALUE self, VALUE exporter_configuration);
-static ddprof_ffi_NewProfileExporterV3Result create_exporter(VALUE exporter_configuration, VALUE tags_as_array);
-static VALUE handle_exporter_failure(ddprof_ffi_NewProfileExporterV3Result exporter_result);
-static ddprof_ffi_EndpointV3 endpoint_from(VALUE exporter_configuration);
-static ddprof_ffi_Vec_tag convert_tags(VALUE tags_as_array);
-static void safely_log_failure_to_process_tag(ddprof_ffi_Vec_tag tags, VALUE err_details);
+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 VALUE _native_do_export(
   VALUE self,
   VALUE exporter_configuration,
@@ -48,6 +50,7 @@ static VALUE _native_do_export(
 );
 static void *call_exporter_without_gvl(void *call_args);
 static void interrupt_exporter_call(void *cancel_token);
+static VALUE ddtrace_version(void);
 
 void http_transport_init(VALUE profiling_module) {
   http_transport_class = rb_define_class_under(profiling_module, "HttpTransport", rb_cObject);
@@ -60,58 +63,61 @@ void http_transport_init(VALUE profiling_module) {
   agentless_id = rb_intern_const("agentless");
   agent_id = rb_intern_const("agent");
   log_failure_to_process_tag_id = rb_intern_const("log_failure_to_process_tag");
+
+  library_version_string = ddtrace_version();
+  rb_global_variable(&library_version_string);
 }
 
-inline static ddprof_ffi_ByteSlice byte_slice_from_ruby_string(VALUE string) {
-  Check_Type(string, T_STRING);
-  ddprof_ffi_ByteSlice byte_slice = {.ptr = (uint8_t *) StringValuePtr(string), .len = RSTRING_LEN(string)};
+inline static ddog_ByteSlice byte_slice_from_ruby_string(VALUE string) {
+  ENFORCE_TYPE(string, T_STRING);
+  ddog_ByteSlice byte_slice = {.ptr = (uint8_t *) StringValuePtr(string), .len = RSTRING_LEN(string)};
   return byte_slice;
 }
 
-static VALUE _native_validate_exporter(VALUE self, VALUE exporter_configuration) {
-  Check_Type(exporter_configuration, T_ARRAY);
-  ddprof_ffi_NewProfileExporterV3Result exporter_result = create_exporter(exporter_configuration, rb_ary_new());
+static VALUE _native_validate_exporter(DDTRACE_UNUSED VALUE _self, VALUE exporter_configuration) {
+  ENFORCE_TYPE(exporter_configuration, T_ARRAY);
+  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
-  ddprof_ffi_NewProfileExporterV3Result_drop(exporter_result);
+  ddog_prof_Exporter_drop(exporter_result.ok);
 
   return rb_ary_new_from_args(2, ok_symbol, Qnil);
 }
 
-static ddprof_ffi_NewProfileExporterV3Result create_exporter(VALUE exporter_configuration, VALUE tags_as_array) {
-  Check_Type(exporter_configuration, T_ARRAY);
-  Check_Type(tags_as_array, T_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 ddprof_ffi_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.
-  ddprof_ffi_EndpointV3 endpoint = endpoint_from(exporter_configuration);
+  ddog_Endpoint endpoint = endpoint_from(exporter_configuration);
+
+  ddog_Vec_Tag tags = convert_tags(tags_as_array);
 
-  ddprof_ffi_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");
 
-  ddprof_ffi_NewProfileExporterV3Result exporter_result =
-    ddprof_ffi_ProfileExporterV3_new(DDPROF_FFI_CHARSLICE_C("ruby"), &tags, endpoint);
+  ddog_prof_Exporter_NewResult exporter_result =
+    ddog_prof_Exporter_new(library_name, library_version, profiling_family, &tags, endpoint);
 
-  ddprof_ffi_Vec_tag_drop(tags);
+  ddog_Vec_Tag_drop(tags);
 
   return exporter_result;
 }
 
-static VALUE handle_exporter_failure(ddprof_ffi_NewProfileExporterV3Result exporter_result) {
-  if (exporter_result.tag == DDPROF_FFI_NEW_PROFILE_EXPORTER_V3_RESULT_OK) return Qnil;
-
-  VALUE err_details = ruby_string_from_vec_u8(exporter_result.err);
-
-  ddprof_ffi_NewProfileExporterV3Result_drop(exporter_result);
-
-  return rb_ary_new_from_args(2, error_symbol, err_details);
+static VALUE handle_exporter_failure(ddog_prof_Exporter_NewResult exporter_result) {
+  return exporter_result.tag == DDOG_PROF_EXPORTER_NEW_RESULT_OK ?
+    Qnil :
+    rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&exporter_result.err));
 }
 
-static ddprof_ffi_EndpointV3 endpoint_from(VALUE exporter_configuration) {
-  Check_Type(exporter_configuration, T_ARRAY);
+static ddog_Endpoint endpoint_from(VALUE exporter_configuration) {
+  ENFORCE_TYPE(exporter_configuration, T_ARRAY);
 
   ID working_mode = SYM2ID(rb_ary_entry(exporter_configuration, 0)); // SYM2ID verifies its input so we can do this safely
 
@@ -122,31 +128,31 @@ static ddprof_ffi_EndpointV3 endpoint_from(VALUE exporter_configuration) {
   if (working_mode == agentless_id) {
     VALUE site = rb_ary_entry(exporter_configuration, 1);
     VALUE api_key = rb_ary_entry(exporter_configuration, 2);
-    Check_Type(site, T_STRING);
-    Check_Type(api_key, T_STRING);
+    ENFORCE_TYPE(site, T_STRING);
+    ENFORCE_TYPE(api_key, T_STRING);
 
-    return ddprof_ffi_EndpointV3_agentless(char_slice_from_ruby_string(site), char_slice_from_ruby_string(api_key));
+    return ddog_Endpoint_agentless(char_slice_from_ruby_string(site), char_slice_from_ruby_string(api_key));
   } else { // agent_id
     VALUE base_url = rb_ary_entry(exporter_configuration, 1);
-    Check_Type(base_url, T_STRING);
+    ENFORCE_TYPE(base_url, T_STRING);
 
-    return ddprof_ffi_EndpointV3_agent(char_slice_from_ruby_string(base_url));
+    return ddog_Endpoint_agent(char_slice_from_ruby_string(base_url));
   }
 }
 
 __attribute__((warn_unused_result))
-static ddprof_ffi_Vec_tag convert_tags(VALUE tags_as_array) {
-  Check_Type(tags_as_array, T_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);
-  ddprof_ffi_Vec_tag tags = ddprof_ffi_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)) {
-      ddprof_ffi_Vec_tag_drop(tags);
-      Check_Type(name_value_pair, T_ARRAY);
+      ddog_Vec_Tag_drop(tags);
+      ENFORCE_TYPE(name_value_pair, T_ARRAY);
     }
 
     // Note: We can index the array without checking its size first because rb_ary_entry returns Qnil if out of bounds
@@ -154,23 +160,18 @@ static ddprof_ffi_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))) {
-      ddprof_ffi_Vec_tag_drop(tags);
-      Check_Type(tag_name, T_STRING);
-      Check_Type(tag_value, T_STRING);
+      ddog_Vec_Tag_drop(tags);
+      ENFORCE_TYPE(tag_name, T_STRING);
+      ENFORCE_TYPE(tag_value, T_STRING);
     }
 
-    ddprof_ffi_PushTagResult push_result =
-      ddprof_ffi_Vec_tag_push(&tags, char_slice_from_ruby_string(tag_name), char_slice_from_ruby_string(tag_value));
-
-    if (push_result.tag == DDPROF_FFI_PUSH_TAG_RESULT_ERR) {
-      VALUE err_details = ruby_string_from_vec_u8(push_result.err);
-      ddprof_ffi_PushTagResult_drop(push_result);
+    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));
 
-      // libddprof validates tags and may catch invalid tags that ddtrace didn't actually catch.
+    if (push_result.tag == DDOG_VEC_TAG_PUSH_RESULT_ERR) {
+      // 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 {
-      ddprof_ffi_PushTagResult_drop(push_result);
+      safely_log_failure_to_process_tag(tags, get_error_details_and_drop(&push_result.err));
     }
   }
 
@@ -183,35 +184,41 @@ 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(ddprof_ffi_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
-    ddprof_ffi_Vec_tag_drop(tags); // clean up
+    ddog_Vec_Tag_drop(tags); // clean up
     rb_jump_tag(exception_state);  // "Re-raise" exception
   }
 }
 
-// Note: This function handles a bunch of libddprof dynamically-allocated objects, so it MUST not use any Ruby APIs
+// 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(
-  ddprof_ffi_NewProfileExporterV3Result valid_exporter_result, // Must be called with a valid exporter result
-  ddprof_ffi_Timespec start,
-  ddprof_ffi_Timespec finish,
-  ddprof_ffi_Slice_file slice_files,
-  ddprof_ffi_Vec_tag *additional_tags,
+  ddog_prof_Exporter *exporter,
+  ddog_Timespec start,
+  ddog_Timespec finish,
+  ddog_prof_Exporter_Slice_File slice_files,
+  ddog_Vec_Tag *additional_tags,
   uint64_t timeout_milliseconds
 ) {
-  ddprof_ffi_ProfileExporterV3 *exporter = valid_exporter_result.ok;
-  ddprof_ffi_CancellationToken *cancel_token = ddprof_ffi_CancellationToken_new();
-  ddprof_ffi_Request *request =
-    ddprof_ffi_ProfileExporterV3_build(exporter, start, finish, slice_files, additional_tags, timeout_milliseconds);
+  ddog_prof_ProfiledEndpointsStats *endpoints_stats = NULL; // Not in use yet
+  ddog_prof_Exporter_Request_BuildResult build_result =
+    ddog_prof_Exporter_Request_build(exporter, start, finish, slice_files, additional_tags, endpoints_stats, timeout_milliseconds);
+
+  if (build_result.tag == DDOG_PROF_EXPORTER_REQUEST_BUILD_RESULT_ERR) {
+    ddog_prof_Exporter_drop(exporter);
+    return rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&build_result.err));
+  }
+
+  ddog_CancellationToken *cancel_token = ddog_CancellationToken_new();
 
   // 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
   struct call_exporter_without_gvl_arguments args =
-    {.exporter = exporter, .request = request, .cancel_token = cancel_token, .send_ran = false};
+    {.exporter = exporter, .build_result = &build_result, .cancel_token = cancel_token, .send_ran = false};
 
   // We use rb_thread_call_without_gvl2 instead of rb_thread_call_without_gvl as the gvl2 variant never raises any
   // exceptions.
@@ -229,45 +236,34 @@ static VALUE perform_export(
 
   while (!args.send_ran && !pending_exception) {
     rb_thread_call_without_gvl2(call_exporter_without_gvl, &args, interrupt_exporter_call, cancel_token);
+
+    // To make sure we don't leak memory, we never check for pending exceptions if send ran
     if (!args.send_ran) pending_exception = check_if_pending_exception();
   }
 
-  VALUE ruby_status;
-  VALUE ruby_result;
+  // Cleanup exporter and token, no longer needed
+  ddog_CancellationToken_drop(cancel_token);
+  ddog_prof_Exporter_drop(exporter);
 
   if (pending_exception) {
-    // We're in a weird situation that libddprof doesn't quite support. The ddprof_ffi_Request payload is dynamically
-    // allocated and needs to be freed, but libddprof doesn't have an API for dropping a request.
-    //
-    // There's plans to add a `ddprof_ffi_Request_drop`
-    // (https://github.com/DataDog/dd-trace-rb/pull/1923#discussion_r882096221); once that happens, we can use it here.
-    //
-    // As a workaround, we get libddprof to clean up the request by asking for the send to be cancelled, and then calling
-    // it anyway. This will make libddprof free the request and return immediately which gets us the expected effect.
-    interrupt_exporter_call((void *) cancel_token);
-    call_exporter_without_gvl((void *) &args);
-  }
-
-  ddprof_ffi_SendResult result = args.result;
-  bool success = result.tag == DDPROF_FFI_SEND_RESULT_HTTP_RESPONSE;
+    // If we got here send did not run, so we need to explicitly dispose of the request
+    ddog_prof_Exporter_Request_drop(&build_result.ok);
 
-  ruby_status = success ? ok_symbol : error_symbol;
-  ruby_result = success ? UINT2NUM(result.http_response.code) : ruby_string_from_vec_u8(result.failure);
+    // Let Ruby propagate the exception. This will not return.
+    rb_jump_tag(pending_exception);
+  }
 
-  // Clean up all dynamically-allocated things
-  ddprof_ffi_SendResult_drop(args.result);
-  ddprof_ffi_CancellationToken_drop(cancel_token);
-  ddprof_ffi_NewProfileExporterV3Result_drop(valid_exporter_result);
-  // The request itself does not need to be freed as libddprof takes care of it.
+  // The request itself does not need to be freed as libdatadog takes ownership of it as part of sending.
 
-  // We've cleaned up everything, so if there's an exception to be raised, let's have it
-  if (pending_exception) rb_jump_tag(pending_exception);
+  ddog_prof_Exporter_SendResult result = args.result;
 
-  return rb_ary_new_from_args(2, ruby_status, ruby_result);
+  return result.tag == DDOG_PROF_EXPORTER_SEND_RESULT_HTTP_RESPONSE ?
+    rb_ary_new_from_args(2, ok_symbol, UINT2NUM(result.http_response.code)) :
+    rb_ary_new_from_args(2, error_symbol, get_error_details_and_drop(&result.err));
 }
 
 static VALUE _native_do_export(
-  VALUE self,
+  DDTRACE_UNUSED VALUE _self,
   VALUE exporter_configuration,
   VALUE upload_timeout_milliseconds,
   VALUE start_timespec_seconds,
@@ -280,56 +276,56 @@ static VALUE _native_do_export(
   VALUE code_provenance_data,
   VALUE tags_as_array
 ) {
-  Check_Type(upload_timeout_milliseconds, T_FIXNUM);
-  Check_Type(start_timespec_seconds, T_FIXNUM);
-  Check_Type(start_timespec_nanoseconds, T_FIXNUM);
-  Check_Type(finish_timespec_seconds, T_FIXNUM);
-  Check_Type(finish_timespec_nanoseconds, T_FIXNUM);
-  Check_Type(pprof_file_name, T_STRING);
-  Check_Type(pprof_data, T_STRING);
-  Check_Type(code_provenance_file_name, T_STRING);
+  ENFORCE_TYPE(upload_timeout_milliseconds, T_FIXNUM);
+  ENFORCE_TYPE(start_timespec_seconds, T_FIXNUM);
+  ENFORCE_TYPE(start_timespec_nanoseconds, T_FIXNUM);
+  ENFORCE_TYPE(finish_timespec_seconds, T_FIXNUM);
+  ENFORCE_TYPE(finish_timespec_nanoseconds, T_FIXNUM);
+  ENFORCE_TYPE(pprof_file_name, T_STRING);
+  ENFORCE_TYPE(pprof_data, T_STRING);
+  ENFORCE_TYPE(code_provenance_file_name, T_STRING);
 
   // Code provenance can be disabled and in that case will be set to nil
   bool have_code_provenance = !NIL_P(code_provenance_data);
-  if (have_code_provenance) Check_Type(code_provenance_data, T_STRING);
+  if (have_code_provenance) ENFORCE_TYPE(code_provenance_data, T_STRING);
 
   uint64_t timeout_milliseconds = NUM2ULONG(upload_timeout_milliseconds);
 
-  ddprof_ffi_Timespec start =
+  ddog_Timespec start =
     {.seconds = NUM2LONG(start_timespec_seconds), .nanoseconds = NUM2UINT(start_timespec_nanoseconds)};
-  ddprof_ffi_Timespec finish =
+  ddog_Timespec finish =
     {.seconds = NUM2LONG(finish_timespec_seconds), .nanoseconds = NUM2UINT(finish_timespec_nanoseconds)};
 
   int files_to_report = 1 + (have_code_provenance ? 1 : 0);
-  ddprof_ffi_File files[files_to_report];
-  ddprof_ffi_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] = (ddprof_ffi_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] = (ddprof_ffi_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)
     };
   }
 
-  ddprof_ffi_Vec_tag *null_additional_tags = NULL;
+  ddog_Vec_Tag *null_additional_tags = NULL;
 
-  ddprof_ffi_NewProfileExporterV3Result 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);
   if (!NIL_P(failure_tuple)) return failure_tuple;
 
-  return perform_export(exporter_result, start, finish, slice_files, null_additional_tags, timeout_milliseconds);
+  return perform_export(exporter_result.ok, start, finish, slice_files, null_additional_tags, timeout_milliseconds);
 }
 
 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 = ddprof_ffi_ProfileExporterV3_send(args->exporter, args->request, args->cancel_token);
+  args->result = ddog_prof_Exporter_send(args->exporter, &args->build_result->ok, args->cancel_token);
   args->send_ran = true;
 
   return NULL; // Unused
@@ -337,5 +333,15 @@ static void *call_exporter_without_gvl(void *call_args) {
 
 // Called by Ruby when it wants to interrupt call_exporter_without_gvl above, e.g. when the app wants to exit cleanly
 static void interrupt_exporter_call(void *cancel_token) {
-  ddprof_ffi_CancellationToken_cancel((ddprof_ffi_CancellationToken *) cancel_token);
+  ddog_CancellationToken_cancel((ddog_CancellationToken *) cancel_token);
+}
+
+static VALUE ddtrace_version(void) {
+  VALUE ddtrace_module = rb_const_get(rb_cObject, rb_intern("DDTrace"));
+  ENFORCE_TYPE(ddtrace_module, T_MODULE);
+  VALUE version_module = rb_const_get(ddtrace_module, rb_intern("VERSION"));
+  ENFORCE_TYPE(version_module, T_MODULE);
+  VALUE version_string = rb_const_get(version_module, rb_intern("STRING"));
+  ENFORCE_TYPE(version_string, T_STRING);
+  return version_string;
 }