datadog 2.1.0 → 2.3.0

data/ext/datadog_profiling_native_extension/extconf.rb

@@ -1,11 +1,16 @@
 # rubocop:disable Style/StderrPuts
 # rubocop:disable Style/GlobalVars
 
-require_relative 'native_extension_helpers'
+require_relative "native_extension_helpers"
+require_relative "../libdatadog_extconf_helpers"
 
 SKIPPED_REASON_FILE = "#{__dir__}/skipped_reason.txt".freeze
 # Not a problem if the file doesn't exist or we can't delete it
-File.delete(SKIPPED_REASON_FILE) rescue nil
+begin
+  File.delete(SKIPPED_REASON_FILE)
+rescue
+  nil
+end
 
 def skip_building_extension!(reason)
   fail_install_if_missing_extension =
@@ -24,13 +29,13 @@ def skip_building_extension!(reason)
   )
 
   if fail_install_if_missing_extension
-    require 'mkmf'
+    require "mkmf"
     Logging.message(
-      '[datadog] Failure cause: ' \
+      "[datadog] Failure cause: " \
       "#{Datadog::Profiling::NativeExtensionHelpers::Supported.render_skipped_reason_file(**reason)}\n"
     )
   else
-    File.write('Makefile', 'all install clean: # dummy makefile that does nothing')
+    File.write("Makefile", "all install clean: # dummy makefile that does nothing")
   end
 
   exit
@@ -63,17 +68,17 @@ $stderr.puts(
 
 # 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'
+require "mkmf"
 
 Logging.message("[datadog] Using compiler:\n")
-xsystem("#{CONFIG['CC']} -v")
+xsystem("#{CONFIG["CC"]} -v")
 Logging.message("[datadog] 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)
   if try_cflags(flag)
-    $CFLAGS << ' ' << flag
+    $CFLAGS << " " << flag
   else
     $stderr.puts("WARNING: '#{flag}' not accepted by compiler, skipping it")
   end
@@ -81,23 +86,23 @@ 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['DATADOG_GEM_CI'] == 'true'
+add_compiler_flag "-Werror" if ENV["DATADOG_GEM_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 datadog gem dependency
 #   (https://github.com/msgpack/msgpack-ruby/blob/18ce08f6d612fe973843c366ac9a0b74c4e50599/ext/msgpack/extconf.rb#L8)
-add_compiler_flag '-std=gnu99'
+add_compiler_flag "-std=gnu99"
 
 # 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'
+add_compiler_flag "-Wno-unused-function"
 
 # Allow defining variables at any point in a function
-add_compiler_flag '-Wno-declaration-after-statement'
+add_compiler_flag "-Wno-declaration-after-statement"
 
 # If we forget to include a Ruby header, the function call may still appear to work, but then
 # cause a segfault later. Let's ensure that never happens.
-add_compiler_flag '-Werror-implicit-function-declaration'
+add_compiler_flag "-Werror-implicit-function-declaration"
 
 # The native extension is not intended to expose any symbols/functions for other native libraries to use;
 # the sole exception being `Init_datadog_profiling_native_extension` which needs to be visible for Ruby to call it when
@@ -105,22 +110,22 @@ add_compiler_flag '-Werror-implicit-function-declaration'
 #
 # By setting this compiler flag, we tell it to assume that everything is private unless explicitly stated.
 # For more details see https://gcc.gnu.org/wiki/Visibility
-add_compiler_flag '-fvisibility=hidden'
+add_compiler_flag "-fvisibility=hidden"
 
 # Avoid legacy C definitions
-add_compiler_flag '-Wold-style-definition'
+add_compiler_flag "-Wold-style-definition"
 
 # Enable all other compiler warnings
-add_compiler_flag '-Wall'
-add_compiler_flag '-Wextra'
+add_compiler_flag "-Wall"
+add_compiler_flag "-Wextra"
 
-if ENV['DDTRACE_DEBUG']
-  $defs << '-DDD_DEBUG'
-  CONFIG['optflags'] = '-O0'
-  CONFIG['debugflags'] = '-ggdb3'
+if ENV["DDTRACE_DEBUG"] == "true"
+  $defs << "-DDD_DEBUG"
+  CONFIG["optflags"] = "-O0"
+  CONFIG["debugflags"] = "-ggdb3"
 end
 
-if RUBY_PLATFORM.include?('linux')
+if RUBY_PLATFORM.include?("linux")
   # Supposedly, the correct way to do this is
   # ```
   # have_library 'pthread'
@@ -128,77 +133,77 @@ if RUBY_PLATFORM.include?('linux')
   # ```
   # but 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'
+  $defs << "-DHAVE_PTHREAD_GETCPUCLOCKID"
+
+  # Not available on macOS
+  $defs << "-DHAVE_CLOCK_MONOTONIC_COARSE"
 end
 
-have_func 'malloc_stats'
+have_func "malloc_stats"
 
 # On older Rubies, rb_postponed_job_preregister/rb_postponed_job_trigger did not exist
-$defs << '-DNO_POSTPONED_TRIGGER' if RUBY_VERSION < '3.3'
+$defs << "-DNO_POSTPONED_TRIGGER" if RUBY_VERSION < "3.3"
 
 # On older Rubies, M:N threads were not available
-$defs << '-DNO_MN_THREADS_AVAILABLE' if RUBY_VERSION < '3.3'
+$defs << "-DNO_MN_THREADS_AVAILABLE" if RUBY_VERSION < "3.3"
 
 # On older Rubies, we did not need to include the ractor header (this was built into the MJIT header)
-$defs << '-DNO_RACTOR_HEADER_INCLUDE' if RUBY_VERSION < '3.3'
+$defs << "-DNO_RACTOR_HEADER_INCLUDE" if RUBY_VERSION < "3.3"
 
 # On older Rubies, some of the Ractor internal APIs were directly accessible
-$defs << '-DUSE_RACTOR_INTERNAL_APIS_DIRECTLY' if RUBY_VERSION < '3.3'
+$defs << "-DUSE_RACTOR_INTERNAL_APIS_DIRECTLY" if RUBY_VERSION < "3.3"
 
 # 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'
+$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'
+$defs << "-DNO_RB_THREAD_SCHED" if RUBY_VERSION < "3.2"
 
 # On older Rubies, the first_lineno inside a location was a VALUE and not a int (https://github.com/ruby/ruby/pull/6430)
-$defs << '-DNO_INT_FIRST_LINENO' if RUBY_VERSION < '3.2'
+$defs << "-DNO_INT_FIRST_LINENO" if RUBY_VERSION < "3.2"
 
 # On older Rubies, "pop" was not a primitive operation
-$defs << '-DNO_PRIMITIVE_POP' if RUBY_VERSION < '3.2'
+$defs << "-DNO_PRIMITIVE_POP" 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'
+$defs << "-DNO_THREAD_TID" if RUBY_VERSION < "3.1"
 
 # On older Rubies, there was no jit_return member on the rb_control_frame_t struct
-$defs << '-DNO_JIT_RETURN' if RUBY_VERSION < '3.1'
+$defs << "-DNO_JIT_RETURN" if RUBY_VERSION < "3.1"
 
 # On older Rubies, rb_gc_force_recycle allowed to free objects in a way that
 # would be invisible to free tracepoints, finalizers and without cleaning
 # obj_to_id_tbl mappings.
-$defs << '-DHAVE_WORKING_RB_GC_FORCE_RECYCLE' 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'
+$defs << "-DHAVE_WORKING_RB_GC_FORCE_RECYCLE" if RUBY_VERSION < "3.1"
 
 # On older Rubies, there are no Ractors
-$defs << '-DNO_RACTORS' if RUBY_VERSION < '3'
+$defs << "-DNO_RACTORS" if RUBY_VERSION < "3"
 
 # On older Rubies, rb_imemo_name did not exist
-$defs << '-DNO_IMEMO_NAME' if RUBY_VERSION < '3'
+$defs << "-DNO_IMEMO_NAME" if RUBY_VERSION < "3"
 
 # On older Rubies, objects would not move
-$defs << '-DNO_T_MOVED' if RUBY_VERSION < '2.7'
+$defs << "-DNO_T_MOVED" if RUBY_VERSION < "2.7"
 
 # On older Rubies, there was no RUBY_SEEN_OBJ_ID flag
-$defs << '-DNO_SEEN_OBJ_ID_FLAG' if RUBY_VERSION < '2.7'
+$defs << "-DNO_SEEN_OBJ_ID_FLAG" if RUBY_VERSION < "2.7"
 
 # On older Rubies, rb_global_vm_lock_struct did not include the owner field
-$defs << '-DNO_GVL_OWNER' if RUBY_VERSION < '2.6'
+$defs << "-DNO_GVL_OWNER" if RUBY_VERSION < "2.6"
 
 # On older Rubies, there was no thread->invoke_arg
-$defs << '-DNO_THREAD_INVOKE_ARG' if RUBY_VERSION < '2.6'
+$defs << "-DNO_THREAD_INVOKE_ARG" if RUBY_VERSION < "2.6"
 
 # If we got here, libdatadog is available and loaded
-ENV['PKG_CONFIG_PATH'] = "#{ENV['PKG_CONFIG_PATH']}:#{Libdatadog.pkgconfig_folder}"
-Logging.message("[datadog] PKG_CONFIG_PATH set to #{ENV['PKG_CONFIG_PATH'].inspect}\n")
+ENV["PKG_CONFIG_PATH"] = "#{ENV["PKG_CONFIG_PATH"]}:#{Libdatadog.pkgconfig_folder}"
+Logging.message("[datadog] PKG_CONFIG_PATH set to #{ENV["PKG_CONFIG_PATH"].inspect}\n")
 $stderr.puts("Using libdatadog #{Libdatadog::VERSION} from #{Libdatadog.pkgconfig_folder}")
 
-unless pkg_config('datadog_profiling_with_rpath')
+unless pkg_config("datadog_profiling_with_rpath")
   Logging.message("[datadog] Ruby detected the pkg-config command is #{$PKGCONFIG.inspect}\n")
 
   skip_building_extension!(
-    if Datadog::Profiling::NativeExtensionHelpers::Supported.pkg_config_missing?
+    if Datadog::LibdatadogExtconfHelpers.pkg_config_missing?
       Datadog::Profiling::NativeExtensionHelpers::Supported::PKG_CONFIG_IS_MISSING
     else
       # Less specific error message
@@ -207,16 +212,18 @@ unless pkg_config('datadog_profiling_with_rpath')
   )
 end
 
-unless have_type('atomic_int', ['stdatomic.h'])
+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.
+# See comments on the helper methods 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.libdatadog_folder_relative_to_native_lib_folder}"
+extra_relative_rpaths = [
+  Datadog::LibdatadogExtconfHelpers.libdatadog_folder_relative_to_native_lib_folder(current_folder: __dir__),
+  *Datadog::LibdatadogExtconfHelpers.libdatadog_folder_relative_to_ruby_extensions_folders,
+]
+extra_relative_rpaths.each { |folder| $LDFLAGS += " -Wl,-rpath,$$$\\\\{ORIGIN\\}/#{folder.to_str}" }
 Logging.message("[datadog] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
 
 # Tag the native extension library with the Ruby version and Ruby platform.
@@ -235,8 +242,8 @@ if Datadog::Profiling::NativeExtensionHelpers::CAN_USE_MJIT_HEADER
   # use the MJIT header.
   # Finally, the `COMMON_HEADERS` conflict with the MJIT header so we need to temporarily disable them for this check.
   original_common_headers = MakeMakefile::COMMON_HEADERS
-  MakeMakefile::COMMON_HEADERS = ''.freeze
-  unless have_macro('RUBY_MJIT_H', mjit_header_file_name)
+  MakeMakefile::COMMON_HEADERS = "".freeze
+  unless have_macro("RUBY_MJIT_H", mjit_header_file_name)
     skip_building_extension!(Datadog::Profiling::NativeExtensionHelpers::Supported::COMPILATION_BROKEN)
   end
   MakeMakefile::COMMON_HEADERS = original_common_headers
@@ -248,7 +255,7 @@ if Datadog::Profiling::NativeExtensionHelpers::CAN_USE_MJIT_HEADER
 
   # Warn on unused parameters to functions. Use `DDTRACE_UNUSED` to mark things as known-to-not-be-used.
   # See the comment on the same flag below for why this is done last.
-  add_compiler_flag '-Wunused-parameter'
+  add_compiler_flag "-Wunused-parameter"
 
   create_makefile EXTENSION_NAME
 else
@@ -259,23 +266,23 @@ else
 
   create_header
 
-  require 'debase/ruby_core_source'
-  dir_config('ruby') # allow user to pass in non-standard core include directory
+  require "debase/ruby_core_source"
+  dir_config("ruby") # allow user to pass in non-standard core include directory
 
   Debase::RubyCoreSource
     .create_makefile_with_core(
       proc do
         headers_available =
-          have_header('vm_core.h') &&
-          have_header('iseq.h') &&
-          (RUBY_VERSION < '3.3' || have_header('ractor_core.h'))
+          have_header("vm_core.h") &&
+          have_header("iseq.h") &&
+          (RUBY_VERSION < "3.3" || have_header("ractor_core.h"))
 
         if headers_available
           # Warn on unused parameters to functions. Use `DDTRACE_UNUSED` to mark things as known-to-not-be-used.
           # This is added as late as possible because in some Rubies we support (e.g. 3.3), adding this flag before
           # checking if internal VM headers are available causes those checks to fail because of this warning (and not
           # because the headers are not available.)
-          add_compiler_flag '-Wunused-parameter'
+          add_compiler_flag "-Wunused-parameter"
         end
 
         headers_available

data/ext/datadog_profiling_native_extension/heap_recorder.c

@@ -166,6 +166,12 @@ struct heap_recorder {
     size_t objects_frozen;
   } stats_last_update;
 };
+
+struct end_heap_allocation_args {
+  struct heap_recorder *heap_recorder;
+  ddog_prof_Slice_Location locations;
+};
+
 static heap_record* get_or_create_heap_record(heap_recorder*, ddog_prof_Slice_Location);
 static void cleanup_heap_record_if_unused(heap_recorder*, heap_record*);
 static void on_committed_object_record_cleanup(heap_recorder *heap_recorder, object_record *record);
@@ -176,6 +182,7 @@ static int st_object_records_iterate(st_data_t, st_data_t, st_data_t);
 static int st_object_records_debug(st_data_t key, st_data_t value, st_data_t extra);
 static int update_object_record_entry(st_data_t*, st_data_t*, st_data_t, int);
 static void commit_recording(heap_recorder*, heap_record*, recording);
+static VALUE end_heap_allocation_recording(VALUE end_heap_allocation_args);
 
 // ==========================
 // Heap Recorder External API
@@ -219,7 +226,7 @@ void heap_recorder_free(heap_recorder *heap_recorder) {
   st_foreach(heap_recorder->heap_records, st_heap_record_entry_free, 0);
   st_free_table(heap_recorder->heap_records);
 
-  if (heap_recorder->active_recording.object_record != NULL) {
+  if (heap_recorder->active_recording.object_record != NULL && heap_recorder->active_recording.object_record != &SKIPPED_RECORD) {
     // If there's a partial object record, clean it up as well
     object_record_free(heap_recorder->active_recording.object_record);
   }
@@ -340,9 +347,28 @@ void start_heap_allocation_recording(heap_recorder *heap_recorder, VALUE new_obj
   };
 }
 
-void end_heap_allocation_recording(struct heap_recorder *heap_recorder, ddog_prof_Slice_Location locations) {
+// end_heap_allocation_recording_with_rb_protect gets called while the stack_recorder is holding one of the profile
+// locks. To enable us to correctly unlock the profile on exception, we wrap the call to end_heap_allocation_recording
+// with an rb_protect.
+__attribute__((warn_unused_result))
+int end_heap_allocation_recording_with_rb_protect(struct heap_recorder *heap_recorder, ddog_prof_Slice_Location locations) {
+  int exception_state;
+  struct end_heap_allocation_args end_heap_allocation_args = {
+    .heap_recorder = heap_recorder,
+    .locations = locations,
+  };
+  rb_protect(end_heap_allocation_recording, (VALUE) &end_heap_allocation_args, &exception_state);
+  return exception_state;
+}
+
+static VALUE end_heap_allocation_recording(VALUE end_heap_allocation_args) {
+  struct end_heap_allocation_args *args = (struct end_heap_allocation_args *) end_heap_allocation_args;
+
+  struct heap_recorder *heap_recorder = args->heap_recorder;
+  ddog_prof_Slice_Location locations = args->locations;
+
   if (heap_recorder == NULL) {
-    return;
+    return Qnil;
   }
 
   recording active_recording = heap_recorder->active_recording;
@@ -356,15 +382,16 @@ void end_heap_allocation_recording(struct heap_recorder *heap_recorder, ddog_pro
   // data required for committing though.
   heap_recorder->active_recording = (recording) {0};
 
-  if (active_recording.object_record == &SKIPPED_RECORD) {
-    // special marker when we decided to skip due to sampling
-    return;
+  if (active_recording.object_record == &SKIPPED_RECORD) { // special marker when we decided to skip due to sampling
+    return Qnil;
   }
 
   heap_record *heap_record = get_or_create_heap_record(heap_recorder, locations);
 
   // And then commit the new allocation.
   commit_recording(heap_recorder, heap_record, active_recording);
+
+  return Qnil;
 }
 
 void heap_recorder_prepare_iteration(heap_recorder *heap_recorder) {
@@ -815,6 +842,7 @@ VALUE object_record_inspect(object_record *record) {
   if (!ruby_ref_from_id(LONG2NUM(record->obj_id), &ref)) {
     rb_str_catf(inspect, "object=<invalid>");
   } else {
+    rb_str_catf(inspect, "value=%p ", (void *) ref);
     VALUE ruby_inspect = ruby_safe_inspect(ref);
     if (ruby_inspect != Qnil) {
       rb_str_catf(inspect, "object=%"PRIsVALUE, ruby_inspect);

data/ext/datadog_profiling_native_extension/heap_recorder.h

@@ -114,7 +114,9 @@ void start_heap_allocation_recording(heap_recorder *heap_recorder, VALUE new_obj
 // @param locations The stacktrace representing the location of the allocation.
 //
 // WARN: It is illegal to call this without previously having called ::start_heap_allocation_recording.
-void end_heap_allocation_recording(heap_recorder *heap_recorder, ddog_prof_Slice_Location locations);
+// WARN: This method rescues exceptions with `rb_protect`, returning the exception state integer for the caller to handle.
+__attribute__((warn_unused_result))
+int end_heap_allocation_recording_with_rb_protect(heap_recorder *heap_recorder, ddog_prof_Slice_Location locations);
 
 // Update the heap recorder to reflect the latest state of the VM and prepare internal structures
 // for efficient iteration.

data/ext/datadog_profiling_native_extension/helpers.h

@@ -2,22 +2,11 @@
 
 #include <stdint.h>
 
-// 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; }
-inline static long long_max_of(long a, long b) { return a > b ? a : b; }
-inline static long long_min_of(long a, long b) { return a > b ? b : a; }
-inline static double double_max_of(double a, double b) { return a > b ? a : b; }
-inline static double double_min_of(double a, double b) { return a > b ? b : a; }
+static inline uint64_t uint64_max_of(uint64_t a, uint64_t b) { return a > b ? a : b; }
+static inline uint64_t uint64_min_of(uint64_t a, uint64_t b) { return a > b ? b : a; }
+static inline long long_max_of(long a, long b) { return a > b ? a : b; }
+static inline long long_min_of(long a, long b) { return a > b ? b : a; }
+static inline double double_max_of(double a, double b) { return a > b ? a : b; }
+static inline double double_min_of(double a, double b) { return a > b ? b : a; }

data/ext/datadog_profiling_native_extension/http_transport.c

@@ -21,7 +21,7 @@ struct call_exporter_without_gvl_arguments {
   bool send_ran;
 };
 
-inline static ddog_ByteSlice byte_slice_from_ruby_string(VALUE string);
+static inline ddog_ByteSlice byte_slice_from_ruby_string(VALUE string);
 static VALUE _native_validate_exporter(VALUE self, VALUE exporter_configuration);
 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);
@@ -53,11 +53,11 @@ void http_transport_init(VALUE profiling_module) {
   ok_symbol = ID2SYM(rb_intern_const("ok"));
   error_symbol = ID2SYM(rb_intern_const("error"));
 
-  library_version_string = ddtrace_version();
+  library_version_string = datadog_gem_version();
   rb_global_variable(&library_version_string);
 }
 
-inline static ddog_ByteSlice byte_slice_from_ruby_string(VALUE string) {
+static inline 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;

data/ext/datadog_profiling_native_extension/libdatadog_helpers.c

@@ -2,8 +2,6 @@
 
 #include <ruby.h>
 
-static VALUE log_failure_to_process_tag(VALUE err_details);
-
 const char *ruby_value_type_to_string(enum ruby_value_type type) {
   return ruby_value_type_to_char_slice(type).ptr;
 }
@@ -62,87 +60,3 @@ size_t read_ddogerr_string_and_drop(ddog_Error *error, char *string, size_t capa
   ddog_Error_drop(error);
   return error_msg_size;
 }
-
-__attribute__((warn_unused_result))
-ddog_prof_Endpoint endpoint_from(VALUE exporter_configuration) {
-  ENFORCE_TYPE(exporter_configuration, T_ARRAY);
-
-  VALUE exporter_working_mode = rb_ary_entry(exporter_configuration, 0);
-  ENFORCE_TYPE(exporter_working_mode, T_SYMBOL);
-  ID working_mode = SYM2ID(exporter_working_mode);
-
-  ID agentless_id = rb_intern("agentless");
-  ID agent_id = rb_intern("agent");
-
-  if (working_mode != agentless_id && working_mode != agent_id) {
-    rb_raise(rb_eArgError, "Failed to initialize transport: Unexpected working mode, expected :agentless or :agent");
-  }
-
-  if (working_mode == agentless_id) {
-    VALUE site = rb_ary_entry(exporter_configuration, 1);
-    VALUE api_key = rb_ary_entry(exporter_configuration, 2);
-    ENFORCE_TYPE(site, T_STRING);
-    ENFORCE_TYPE(api_key, T_STRING);
-
-    return ddog_prof_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);
-    ENFORCE_TYPE(base_url, T_STRING);
-
-    return ddog_prof_Endpoint_agent(char_slice_from_ruby_string(base_url));
-  }
-}
-
-__attribute__((warn_unused_result))
-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();
-
-  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);
-      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
-    VALUE tag_name = rb_ary_entry(name_value_pair, 0);
-    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);
-      ENFORCE_TYPE(tag_name, T_STRING);
-      ENFORCE_TYPE(tag_value, T_STRING);
-    }
-
-    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_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.
-
-      int exception_state;
-      rb_protect(log_failure_to_process_tag, get_error_details_and_drop(&push_result.err), &exception_state);
-
-      // Since we are calling into Ruby code, it may raise an exception. Ensure that dynamically-allocated tags
-      // get cleaned before propagating the exception.
-      if (exception_state) {
-        ddog_Vec_Tag_drop(tags);
-        rb_jump_tag(exception_state);  // "Re-raise" exception
-      }
-    }
-  }
-
-  return tags;
-}
-
-static VALUE log_failure_to_process_tag(VALUE err_details) {
-  VALUE datadog_module = rb_const_get(rb_cObject, rb_intern("Datadog"));
-  VALUE logger = rb_funcall(datadog_module, rb_intern("logger"), 0);
-
-  return rb_funcall(logger, rb_intern("warn"), 1, rb_sprintf("Failed to add tag to profiling request: %"PRIsVALUE, err_details));
-}

data/ext/datadog_profiling_native_extension/libdatadog_helpers.h

@@ -3,27 +3,10 @@
 #include <datadog/profiling.h>
 #include "ruby_helpers.h"
 
-inline static ddog_CharSlice char_slice_from_ruby_string(VALUE string) {
-  ENFORCE_TYPE(string, T_STRING);
-  ddog_CharSlice char_slice = {.ptr = StringValuePtr(string), .len = RSTRING_LEN(string)};
-  return char_slice;
-}
-
-inline static VALUE ruby_string_from_vec_u8(ddog_Vec_U8 string) {
+static inline 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_error(const ddog_Error *error) {
-  ddog_CharSlice char_slice = ddog_Error_message(error);
-  return rb_str_new(char_slice.ptr, char_slice.len);
-}
-
-inline static VALUE get_error_details_and_drop(ddog_Error *error) {
-  VALUE result = ruby_string_from_error(error);
-  ddog_Error_drop(error);
-  return result;
-}
-
 // Utility function to be able to extract an error cstring from a ddog_Error.
 // Returns the amount of characters written to string (which are necessarily
 // bounded by capacity - 1 since the string will be null-terminated).
@@ -37,10 +20,6 @@ ddog_CharSlice ruby_value_type_to_char_slice(enum ruby_value_type type);
 
 // Returns a dynamically allocated string from the provided char slice.
 // WARN: The returned string must be explicitly freed with ruby_xfree.
-inline static char* string_from_char_slice(ddog_CharSlice slice) {
+static inline char* string_from_char_slice(ddog_CharSlice slice) {
   return ruby_strndup(slice.ptr, slice.len);
 }
-
-ddog_prof_Endpoint endpoint_from(VALUE exporter_configuration);
-
-ddog_Vec_Tag convert_tags(VALUE tags_as_array);