ddtrace 1.2.0 → 1.3.0

data/ext/ddtrace_profiling_native_extension/extconf.rb

@@ -42,7 +42,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,7 +60,8 @@ $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.
@@ -91,6 +93,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 +104,17 @@ add_compiler_flag '-Werror-implicit-function-declaration'
 # For more details see https://gcc.gnu.org/wiki/Visibility
 add_compiler_flag '-fvisibility=hidden'
 
+# 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 it broke the build on Windows and on older Ruby versions (2.2)
   # so instead we just assume that we have the function we need on Linux, and nowhere else
   $defs << '-DHAVE_PTHREAD_GETCPUCLOCKID'
 end
@@ -133,13 +142,12 @@ if RUBY_VERSION < '2.3'
   $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'
+  # ... you couldn't name threads
+  $defs << '-DNO_THREAD_NAMES'
 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}"
+# 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")
 
 unless pkg_config('ddprof_ffi_with_rpath')
@@ -148,19 +156,23 @@ unless pkg_config('ddprof_ffi_with_rpath')
       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
+# 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}"
+  "#{Datadog::Profiling::NativeExtensionHelpers.libdatadog_folder_relative_to_native_lib_folder}"
 Logging.message(" [ddtrace] After pkg-config $LDFLAGS were set to: #{$LDFLAGS.inspect}\n")
 
+Logging.message(" [ddtrace] Using compiler:\n")
+xsystem("#{CONFIG['CC']} --version")
+Logging.message(" [ddtrace] End of compiler information\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
 # the wrong library is never loaded.
@@ -194,13 +206,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 +213,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,12 @@
+#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

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 "helpers.h"
+#include "libdatadog_helpers.h"
 #include "ruby_helpers.h"
 
 // Used to report profiling data to Datadog.
@@ -63,13 +64,13 @@ void http_transport_init(VALUE profiling_module) {
 }
 
 inline static ddprof_ffi_ByteSlice byte_slice_from_ruby_string(VALUE string) {
-  Check_Type(string, T_STRING);
+  ENFORCE_TYPE(string, T_STRING);
   ddprof_ffi_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);
+static VALUE _native_validate_exporter(DDTRACE_UNUSED VALUE _self, VALUE exporter_configuration) {
+  ENFORCE_TYPE(exporter_configuration, T_ARRAY);
   ddprof_ffi_NewProfileExporterV3Result exporter_result = create_exporter(exporter_configuration, rb_ary_new());
 
   VALUE failure_tuple = handle_exporter_failure(exporter_result);
@@ -83,8 +84,8 @@ static VALUE _native_validate_exporter(VALUE self, VALUE exporter_configuration)
 }
 
 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);
+  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
   // to be leaked.
@@ -111,7 +112,7 @@ static VALUE handle_exporter_failure(ddprof_ffi_NewProfileExporterV3Result expor
 }
 
 static ddprof_ffi_EndpointV3 endpoint_from(VALUE exporter_configuration) {
-  Check_Type(exporter_configuration, T_ARRAY);
+  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,13 +123,13 @@ 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));
   } 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));
   }
@@ -136,7 +137,7 @@ static ddprof_ffi_EndpointV3 endpoint_from(VALUE exporter_configuration) {
 
 __attribute__((warn_unused_result))
 static ddprof_ffi_Vec_tag convert_tags(VALUE tags_as_array) {
-  Check_Type(tags_as_array, T_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();
@@ -146,7 +147,7 @@ static ddprof_ffi_Vec_tag convert_tags(VALUE tags_as_array) {
 
     if (!RB_TYPE_P(name_value_pair, T_ARRAY)) {
       ddprof_ffi_Vec_tag_drop(tags);
-      Check_Type(name_value_pair, T_ARRAY);
+      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
@@ -155,8 +156,8 @@ static ddprof_ffi_Vec_tag convert_tags(VALUE tags_as_array) {
 
     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);
+      ENFORCE_TYPE(tag_name, T_STRING);
+      ENFORCE_TYPE(tag_value, T_STRING);
     }
 
     ddprof_ffi_PushTagResult push_result =
@@ -166,7 +167,7 @@ static ddprof_ffi_Vec_tag convert_tags(VALUE tags_as_array) {
       VALUE err_details = ruby_string_from_vec_u8(push_result.err);
       ddprof_ffi_PushTagResult_drop(push_result);
 
-      // libddprof validates tags and may catch invalid tags that ddtrace didn't actually catch.
+      // 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 {
@@ -193,7 +194,7 @@ static void safely_log_failure_to_process_tag(ddprof_ffi_Vec_tag tags, VALUE err
   }
 }
 
-// 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
@@ -229,45 +230,37 @@ 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
+  ddprof_ffi_CancellationToken_drop(cancel_token);
+  ddprof_ffi_NewProfileExporterV3Result_drop(valid_exporter_result);
 
   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);
+    // If we got here send did not run, so we need to explicitly dispose of the request
+    ddprof_ffi_Request_drop(request);
+
+    // Let Ruby propagate the exception. This will not return.
+    rb_jump_tag(pending_exception);
   }
 
   ddprof_ffi_SendResult result = args.result;
   bool success = result.tag == DDPROF_FFI_SEND_RESULT_HTTP_RESPONSE;
 
-  ruby_status = success ? ok_symbol : error_symbol;
-  ruby_result = success ? UINT2NUM(result.http_response.code) : ruby_string_from_vec_u8(result.failure);
+  VALUE ruby_status = success ? ok_symbol : error_symbol;
+  VALUE ruby_result = success ? UINT2NUM(result.http_response.code) : ruby_string_from_vec_u8(result.err);
 
-  // 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.
-
-  // 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);
+  // 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);
 }
 
 static VALUE _native_do_export(
-  VALUE self,
+  DDTRACE_UNUSED VALUE _self,
   VALUE exporter_configuration,
   VALUE upload_timeout_milliseconds,
   VALUE start_timespec_seconds,
@@ -280,18 +273,18 @@ 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);
 

data/ext/ddtrace_profiling_native_extension/{libddprof_helpers.h → libdatadog_helpers.h}

@@ -1,9 +1,10 @@
 #pragma once
 
 #include <ddprof/ffi.h>
+#include "ruby_helpers.h"
 
 inline static ddprof_ffi_CharSlice char_slice_from_ruby_string(VALUE string) {
-  Check_Type(string, T_STRING);
+  ENFORCE_TYPE(string, T_STRING);
   ddprof_ffi_CharSlice char_slice = {.ptr = StringValuePtr(string), .len = RSTRING_LEN(string)};
   return char_slice;
 }

data/ext/ddtrace_profiling_native_extension/native_extension_helpers.rb

@@ -2,7 +2,7 @@
 
 # typed: ignore
 
-require 'libddprof'
+require 'libdatadog'
 require 'pathname'
 
 module Datadog
@@ -22,29 +22,29 @@ module Datadog
       end
 
       # Used as an workaround for a limitation with how dynamic linking works in environments where ddtrace and
-      # libddprof are moved after the extension gets compiled.
+      # libdatadog are moved after the extension gets compiled.
       #
       # Because the libddpprof native library is installed on a non-standard system path, in order for it to be
       # found by the system dynamic linker (e.g. what takes care of dlopen(), which is used to load the profiling
-      # native extension), we need to add a "runpath" -- a list of folders to search for libddprof.
+      # native extension), we need to add a "runpath" -- a list of folders to search for libdatadog.
       #
       # This runpath gets hardcoded at native library linking time. You can look at it using the `readelf` tool in
       # Linux: e.g. `readelf -d ddtrace_profiling_native_extension.2.7.3_x86_64-linux.so`.
       #
-      # In ddtrace 1.1.0, we only set as runpath an absolute path to libddprof. (This gets set automatically by the call
-      # to `pkg_config('ddprof_ffi_with_rpath')` in `extconf.rb`). This worked fine as long as libddprof was **NOT**
+      # In ddtrace 1.1.0, we only set as runpath an absolute path to libdatadog. (This gets set automatically by the call
+      # to `pkg_config('ddprof_ffi_with_rpath')` in `extconf.rb`). This worked fine as long as libdatadog was **NOT**
       # moved from the folder it was present at ddtrace installation/linking time.
       #
       # Unfortunately, environments such as Heroku and AWS Elastic Beanstalk move gems around in the filesystem after
       # installation. Thus, the profiling native extension could not be loaded in these environments
-      # (see https://github.com/DataDog/dd-trace-rb/issues/2067) because libddprof could not be found.
+      # (see https://github.com/DataDog/dd-trace-rb/issues/2067) because libdatadog could not be found.
       #
       # To workaround this issue, this method computes the **relative** path between the folder where the profiling
-      # native extension is going to be installed and the folder where libddprof is installed, and returns it
+      # native extension is going to be installed and the folder where libdatadog is installed, and returns it
       # to be set as an additional runpath. (Yes, you can set multiple runpath folders to be searched).
       #
       # This way, if both gems are moved together (and it turns out that they are in these environments),
-      # the relative path can still be traversed to find libddprof.
+      # the relative path can still be traversed to find libdatadog.
       #
       # This is incredibly awful, and it's kinda bizarre how it's not possible to just find these paths at runtime
       # and set them correctly; rather than needing to set stuff at linking-time and then praying to $deity that
@@ -54,16 +54,16 @@ module Datadog
       # SET DYNAMICALLY**, e.g. it needs to be set at the start of the process (Ruby VM) and thus it's not something
       # we could setup when doing a `require`.
       #
-      def self.libddprof_folder_relative_to_native_lib_folder(
+      def self.libdatadog_folder_relative_to_native_lib_folder(
         current_folder: __dir__,
-        libddprof_pkgconfig_folder: Libddprof.pkgconfig_folder
+        libdatadog_pkgconfig_folder: Libdatadog.pkgconfig_folder
       )
-        return unless libddprof_pkgconfig_folder
+        return unless libdatadog_pkgconfig_folder
 
         profiling_native_lib_folder = "#{current_folder}/../../lib/"
-        libddprof_lib_folder = "#{libddprof_pkgconfig_folder}/../"
+        libdatadog_lib_folder = "#{libdatadog_pkgconfig_folder}/../"
 
-        Pathname.new(libddprof_lib_folder).relative_path_from(Pathname.new(profiling_native_lib_folder)).to_s
+        Pathname.new(libdatadog_lib_folder).relative_path_from(Pathname.new(profiling_native_lib_folder)).to_s
       end
 
       # Used to check if profiler is supported, including user-visible clear messages explaining why their
@@ -86,8 +86,9 @@ module Datadog
             on_macos? ||
             on_unknown_os? ||
             not_on_amd64_or_arm64? ||
+            on_ruby_2_1? ||
             expected_to_use_mjit_but_mjit_is_disabled? ||
-            libddprof_not_usable?
+            libdatadog_not_usable?
         end
 
         # This banner will show up in the logs/terminal while compiling the native extension
@@ -137,6 +138,8 @@ module Datadog
         CONTACT_SUPPORT = [
           'For help solving this issue, please contact Datadog support at',
           '<https://docs.datadoghq.com/help/>.',
+          'You can also check out the Continuous Profiler troubleshooting page at',
+          '<https://dtdg.co/ruby-profiler-troubleshooting>.'
         ].freeze
 
         REPORT_ISSUE = [
@@ -148,9 +151,13 @@ module Datadog
           "Get in touch with us if you're interested in profiling your app!"
         ].freeze
 
+        UPGRADE_RUBY = [
+          'Upgrade to a modern Ruby to enable profiling for your app.'
+        ].freeze
+
         # Validation for this check is done in extconf.rb because it relies on mkmf
-        FAILED_TO_CONFIGURE_LIBDDPROF = explain_issue(
-          'there was a problem in setting up the `libddprof` dependency.',
+        FAILED_TO_CONFIGURE_LIBDATADOG = explain_issue(
+          'there was a problem in setting up the `libdatadog` dependency.',
           suggested: CONTACT_SUPPORT,
         )
 
@@ -242,6 +249,15 @@ module Datadog
           architecture_not_supported unless RUBY_PLATFORM.start_with?('x86_64', 'aarch64')
         end
 
+        private_class_method def self.on_ruby_2_1?
+          ruby_version_not_supported = explain_issue(
+            'the profiler only supports Ruby 2.2 or newer.',
+            suggested: UPGRADE_RUBY,
+          )
+
+          ruby_version_not_supported if RUBY_VERSION.start_with?('2.1.')
+        end
+
         # On some Rubies, we require the mjit header to be present. If Ruby was installed without MJIT support, we also skip
         # building the extension.
         private_class_method def self.expected_to_use_mjit_but_mjit_is_disabled?
@@ -255,17 +271,17 @@ module Datadog
           ruby_without_mjit if CAN_USE_MJIT_HEADER && RbConfig::CONFIG['MJIT_SUPPORT'] != 'yes'
         end
 
-        private_class_method def self.libddprof_not_usable?
+        private_class_method def self.libdatadog_not_usable?
           no_binaries_for_current_platform = explain_issue(
-            'the `libddprof` gem installed on your system is missing binaries for your',
+            'the `libdatadog` gem installed on your system is missing binaries for your',
             'platform variant.',
             "(Your platform: `#{Gem::Platform.local}`)",
             '(Available binaries: ',
-            "`#{Libddprof.available_binaries.join('`, `')}`)",
+            "`#{Libdatadog.available_binaries.join('`, `')}`)",
             suggested: CONTACT_SUPPORT,
           )
 
-          no_binaries_for_current_platform unless Libddprof.pkgconfig_folder
+          no_binaries_for_current_platform unless Libdatadog.pkgconfig_folder
         end
       end
       # rubocop:enable Metrics/ModuleLength

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.c

@@ -13,7 +13,13 @@
   #include RUBY_MJIT_HEADER
 #else
   // On older Rubies, use a copy of the VM internal headers shipped in the debase-ruby_core_source gem
-  #include <vm_core.h>
+
+  // We can't do anything about warnings in VM headers, so we just use this technique to surpress them.
+  // See https://nelkinda.com/blog/suppress-warnings-in-gcc-and-clang/#d11e364 for details.
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wunused-parameter"
+    #include <vm_core.h>
+  #pragma GCC diagnostic pop
   #include <iseq.h>
 #endif
 
@@ -68,7 +74,6 @@ ptrdiff_t stack_depth_for(VALUE thread) {
   #define ccan_list_for_each list_for_each
 #endif
 
-#ifndef USE_LEGACY_LIVING_THREADS_ST // Ruby > 2.1
 // Tries to match rb_thread_list() but that method isn't accessible to extensions
 VALUE ddtrace_thread_list(void) {
   VALUE result = rb_ary_new();
@@ -103,36 +108,25 @@ VALUE ddtrace_thread_list(void) {
 
   return result;
 }
-#else // USE_LEGACY_LIVING_THREADS_ST
-static int ddtrace_thread_list_each(st_data_t thread_object, st_data_t _value, void *result_object);
-
-// Alternative ddtrace_thread_list implementation for Ruby 2.1. In this Ruby version, living threads were stored in a
-// hashmap (st) instead of a list.
-VALUE ddtrace_thread_list() {
-  VALUE result = rb_ary_new();
-  st_foreach(thread_struct_from_object(rb_thread_current())->vm->living_threads, ddtrace_thread_list_each, result);
-  return result;
-}
-
-static int ddtrace_thread_list_each(st_data_t thread_object, st_data_t _value, void *result_object) {
-  VALUE result = (VALUE) result_object;
-  rb_thread_t *thread = thread_struct_from_object((VALUE) thread_object);
-  switch (thread->status) {
-    case THREAD_RUNNABLE:
-    case THREAD_STOPPED:
-    case THREAD_STOPPED_FOREVER:
-      rb_ary_push(result, thread->self);
-    default:
-      break;
-  }
-  return ST_CONTINUE;
-}
-#endif // USE_LEGACY_LIVING_THREADS_ST
 
 bool is_thread_alive(VALUE thread) {
   return thread_struct_from_object(thread)->status != THREAD_KILLED;
 }
 
+// `thread` gets used on all Rubies except 2.2
+// To avoid getting false "unused argument" warnings in setups where it's not used, we need to do this weird dance
+// with diagnostic stuff. See https://nelkinda.com/blog/suppress-warnings-in-gcc-and-clang/#d11e364 for details.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
+VALUE thread_name_for(VALUE thread) {
+  #ifdef NO_THREAD_NAMES
+    return Qnil;
+  #else
+    return thread_struct_from_object(thread)->name;
+  #endif
+}
+#pragma GCC diagnostic pop
+
 // -----------------------------------------------------------------------------
 // The sources below are modified versions of code extracted from the Ruby project.
 // Each function is annotated with its origin, why we imported it, and the changes made.
@@ -174,6 +168,12 @@ bool is_thread_alive(VALUE thread) {
 // Copyright (C) 1993-2012 Yukihiro Matsumoto
 // to support our custom rb_profile_frames (see below)
 // Modifications: None
+//
+// `node_id` gets used depending on Ruby VM compilation settings (USE_ISEQ_NODE_ID being defined).
+// To avoid getting false "unused argument" warnings in setups where it's not used, we need to do this weird dance
+// with diagnostic stuff. See https://nelkinda.com/blog/suppress-warnings-in-gcc-and-clang/#d11e364 for details.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-parameter"
 inline static int
 calc_pos(const rb_iseq_t *iseq, const VALUE *pc, int *lineno, int *node_id)
 {
@@ -217,6 +217,7 @@ calc_pos(const rb_iseq_t *iseq, const VALUE *pc, int *lineno, int *node_id)
         return 1;
     }
 }
+#pragma GCC diagnostic pop
 
 // Taken from upstream vm_backtrace.c at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
 // Copyright (C) 1993-2012 Yukihiro Matsumoto
@@ -620,11 +621,11 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 // * Check thread status and do not sample if thread has been killed.
 //
 // The `rb_profile_frames` function changed quite a bit between Ruby 2.2 and 2.3. Since the change was quite complex
-// I opted not to try to extend support to Ruby 2.2 and below using the same custom function, and instead I started
+// I opted not to try to extend support to Ruby 2.2 using the same custom function, and instead I started
 // anew from the Ruby 2.2 version of the function, applying some of the same fixes that we have for the modern version.
 int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, int *lines, bool* is_ruby_frame)
 {
-    // **IMPORTANT: THIS IS A CUSTOM RB_PROFILE_FRAMES JUST FOR RUBY 2.2 AND BELOW;
+    // **IMPORTANT: THIS IS A CUSTOM RB_PROFILE_FRAMES JUST FOR RUBY 2.2;
     // SEE ABOVE FOR THE FUNCTION THAT GETS USED FOR MODERN RUBIES**
 
     int i;

data/ext/ddtrace_profiling_native_extension/private_vm_api_access.h

@@ -6,11 +6,7 @@
 // so we use PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES to be able to include private_vm_api_access.h on that file
 // without also dragging the incompatible includes
 #ifndef PRIVATE_VM_API_ACCESS_SKIP_RUBY_INCLUDES
-  #ifdef RUBY_2_1_WORKAROUND
-    #include <thread_native.h>
-  #else
-    #include <ruby/thread_native.h>
-  #endif
+  #include <ruby/thread_native.h>
 #endif
 
 #include "extconf.h"
@@ -19,6 +15,7 @@ rb_nativethread_id_t pthread_id_for(VALUE thread);
 ptrdiff_t stack_depth_for(VALUE thread);
 VALUE ddtrace_thread_list(void);
 bool is_thread_alive(VALUE thread);
+VALUE thread_name_for(VALUE thread);
 
 int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, int *lines, bool* is_ruby_frame);
 

data/ext/ddtrace_profiling_native_extension/profiling.c

@@ -1,6 +1,7 @@
 #include <ruby.h>
 
 #include "clock_id.h"
+#include "helpers.h"
 
 // Each class/module here is implemented in their separate file
 void collectors_cpu_and_wall_time_init(VALUE profiling_module);
@@ -10,8 +11,6 @@ void stack_recorder_init(VALUE profiling_module);
 
 static VALUE native_working_p(VALUE self);
 
-#define DDTRACE_EXPORT __attribute__ ((visibility ("default")))
-
 void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
   VALUE datadog_module = rb_define_module("Datadog");
   VALUE profiling_module = rb_define_module_under(datadog_module, "Profiling");
@@ -28,7 +27,7 @@ void DDTRACE_EXPORT Init_ddtrace_profiling_native_extension(void) {
   stack_recorder_init(profiling_module);
 }
 
-static VALUE native_working_p(VALUE self) {
+static VALUE native_working_p(DDTRACE_UNUSED VALUE _self) {
   self_test_clock_id();
 
   return Qtrue;

data/ext/ddtrace_profiling_native_extension/ruby_helpers.c

@@ -0,0 +1,25 @@
+#include "ruby_helpers.h"
+
+void raise_unexpected_type(
+  VALUE value,
+  DDTRACE_UNUSED enum ruby_value_type _type,
+  const char *value_name,
+  const char *type_name,
+  const char *file,
+  int line,
+  const char* function_name
+) {
+  rb_exc_raise(
+    rb_exc_new_str(
+      rb_eTypeError,
+      rb_sprintf("wrong argument %"PRIsVALUE" for '%s' (expected a %s) at %s:%d:in `%s'",
+        rb_inspect(value),
+        value_name,
+        type_name,
+        file,
+        line,
+        function_name
+      )
+    )
+  );
+}