datadog 2.1.0 → 2.3.0

data/ext/datadog_profiling_native_extension/native_extension_helpers.rb

@@ -1,77 +1,26 @@
 # frozen_string_literal: true
 
-require 'rubygems'
-require 'pathname'
-
 module Datadog
   module Profiling
     # Helpers for extconf.rb
     module NativeExtensionHelpers
       # Can be set when customers want to skip compiling the native extension entirely
-      ENV_NO_EXTENSION = 'DD_PROFILING_NO_EXTENSION'
+      ENV_NO_EXTENSION = "DD_PROFILING_NO_EXTENSION"
       # Can be set to force rubygems to fail gem installation when profiling extension could not be built
-      ENV_FAIL_INSTALL_IF_MISSING_EXTENSION = 'DD_PROFILING_FAIL_INSTALL_IF_MISSING_EXTENSION'
+      ENV_FAIL_INSTALL_IF_MISSING_EXTENSION = "DD_PROFILING_FAIL_INSTALL_IF_MISSING_EXTENSION"
 
       # The MJIT header was introduced on 2.6 and removed on 3.3; for other Rubies we rely on debase-ruby_core_source
-      CAN_USE_MJIT_HEADER = RUBY_VERSION.start_with?('2.6', '2.7', '3.0.', '3.1.', '3.2.')
-
-      LIBDATADOG_VERSION = '~> 9.0.0.1.0'
+      CAN_USE_MJIT_HEADER = RUBY_VERSION.start_with?("2.6", "2.7", "3.0.", "3.1.", "3.2.")
 
       def self.fail_install_if_missing_extension?
-        ENV[ENV_FAIL_INSTALL_IF_MISSING_EXTENSION].to_s.strip.downcase == 'true'
-      end
-
-      # Used as an workaround for a limitation with how dynamic linking works in environments where the datadog gem and
-      # 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 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 datadog_profiling_native_extension.2.7.3_x86_64-linux.so`.
-      #
-      # In older versions of the datadog gem, we only set as runpath an absolute path to libdatadog.
-      # (This gets set automatically by the call
-      # to `pkg_config('datadog_profiling_with_rpath')` in `extconf.rb`). This worked fine as long as libdatadog was **NOT**
-      # moved from the folder it was present at datadog gem 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 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 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 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
-      # weird moves don't happen.
-      #
-      # As a curiosity, `LD_LIBRARY_PATH` can be used to influence the folders that get searched but **CANNOT BE
-      # 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.libdatadog_folder_relative_to_native_lib_folder(
-        current_folder: __dir__,
-        libdatadog_pkgconfig_folder: Libdatadog.pkgconfig_folder
-      )
-        return unless libdatadog_pkgconfig_folder
-
-        profiling_native_lib_folder = "#{current_folder}/../../lib/"
-        libdatadog_lib_folder = "#{libdatadog_pkgconfig_folder}/../"
-
-        Pathname.new(libdatadog_lib_folder).relative_path_from(Pathname.new(profiling_native_lib_folder)).to_s
+        ENV[ENV_FAIL_INSTALL_IF_MISSING_EXTENSION].to_s.strip.downcase == "true"
       end
 
       # Used to check if profiler is supported, including user-visible clear messages explaining why their
       # system may not be supported.
       module Supported
         private_class_method def self.explain_issue(*reason, suggested:)
-          { reason: reason, suggested: suggested }
+          {reason: reason, suggested: suggested}
         end
 
         def self.supported?
@@ -97,16 +46,16 @@ module Datadog
           outcome =
             if fail_install
               [
-                'Failing installation immediately because the ',
+                "Failing installation immediately because the ",
                 "`#{ENV_FAIL_INSTALL_IF_MISSING_EXTENSION}` environment variable is set",
-                'to `true`.',
-                'When contacting support, please include the <mkmf.log> file that is shown ',
-                'below.',
+                "to `true`.",
+                "When contacting support, please include the <mkmf.log> file that is shown ",
+                "below.",
               ]
             else
               [
-                'The Datadog Continuous Profiler will not be available,',
-                'but all other datadog features will work fine!',
+                "The Datadog Continuous Profiler will not be available,",
+                "but all other datadog features will work fine!",
               ]
             end
 
@@ -124,22 +73,14 @@ module Datadog
 
         # This will be saved in a file to later be presented while operating the gem
         def self.render_skipped_reason_file(reason:, suggested:)
-          [*reason, *suggested].join(' ')
-        end
-
-        # mkmf sets $PKGCONFIG after the `pkg_config` gets used in extconf.rb. When `pkg_config` is unsuccessful, we use
-        # this helper to decide if we can show more specific error message vs a generic "something went wrong".
-        def self.pkg_config_missing?(command: $PKGCONFIG) # rubocop:disable Style/GlobalVars
-          pkg_config_available = command && xsystem("#{command} --version")
-
-          pkg_config_available != true
+          [*reason, *suggested].join(" ")
         end
 
         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>.'
+          "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
 
         GET_IN_TOUCH = [
@@ -147,83 +88,83 @@ module Datadog
         ].freeze
 
         UPGRADE_RUBY = [
-          'Upgrade to a modern Ruby to enable profiling for your app.'
+          "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_LIBDATADOG = explain_issue(
-          'there was a problem in setting up the `libdatadog` dependency.',
+          "there was a problem in setting up the `libdatadog` dependency.",
           suggested: CONTACT_SUPPORT,
         )
 
         # Validation for this check is done in extconf.rb because it relies on mkmf
         COMPILATION_BROKEN = explain_issue(
-          'compilation of the Ruby VM just-in-time header failed.',
-          'Your C compiler or Ruby VM just-in-time compiler seem to be broken.',
+          "compilation of the Ruby VM just-in-time header failed.",
+          "Your C compiler or Ruby VM just-in-time compiler seem to be broken.",
           suggested: CONTACT_SUPPORT,
         )
 
         # Validation for this check is done in extconf.rb because it relies on mkmf
         PKG_CONFIG_IS_MISSING = explain_issue(
           # ----------------------------------------------------------------------------+
-          'the `pkg-config` system tool is missing.',
-          'This issue can usually be fixed by installing one of the following:',
-          'the `pkg-config` package on Homebrew and Debian/Ubuntu-based Linux;',
-          'the `pkgconf` package on Arch and Alpine-based Linux;',
-          'the `pkgconf-pkg-config` package on Fedora/Red Hat-based Linux.',
-          '(Tip: When fixing this, ensure `pkg-config` is installed **before**',
-          'running `bundle install`, and remember to clear any installed gems cache).',
+          "the `pkg-config` system tool is missing.",
+          "This issue can usually be fixed by installing one of the following:",
+          "the `pkg-config` package on Homebrew and Debian/Ubuntu-based Linux;",
+          "the `pkgconf` package on Arch and Alpine-based Linux;",
+          "the `pkgconf-pkg-config` package on Fedora/Red Hat-based Linux.",
+          "(Tip: When fixing this, ensure `pkg-config` is installed **before**",
+          "running `bundle install`, and remember to clear any installed gems cache).",
           suggested: CONTACT_SUPPORT,
         )
 
         # Validation for this check is done in extconf.rb because it relies on mkmf
         COMPILER_ATOMIC_MISSING = explain_issue(
-          'your C compiler is missing support for the <stdatomic.h> header.',
-          'This issue can usually be fixed by upgrading to a later version of your',
-          'operating system image or compiler.',
+          "your C compiler is missing support for the <stdatomic.h> header.",
+          "This issue can usually be fixed by upgrading to a later version of your",
+          "operating system image or compiler.",
           suggested: CONTACT_SUPPORT,
         )
 
         private_class_method def self.disabled_via_env?
           report_disabled = [
-            'If you needed to use this, please tell us why on',
-            '<https://github.com/DataDog/dd-trace-rb/issues/new> so we can fix it :)',
+            "If you needed to use this, please tell us why on",
+            "<https://github.com/DataDog/dd-trace-rb/issues/new> so we can fix it :)",
           ].freeze
 
           disabled_via_env = explain_issue(
-            'the `DD_PROFILING_NO_EXTENSION` environment variable is/was set to',
-            '`true` during installation.',
+            "the `DD_PROFILING_NO_EXTENSION` environment variable is/was set to",
+            "`true` during installation.",
             suggested: report_disabled,
           )
 
-          return unless ENV[ENV_NO_EXTENSION].to_s.strip.downcase == 'true'
+          return unless ENV[ENV_NO_EXTENSION].to_s.strip.downcase == "true"
 
           disabled_via_env
         end
 
         private_class_method def self.on_jruby?
           jruby_not_supported = explain_issue(
-            'JRuby is not supported by the Datadog Continuous Profiler.',
+            "JRuby is not supported by the Datadog Continuous Profiler.",
             suggested: GET_IN_TOUCH,
           )
 
-          jruby_not_supported if RUBY_ENGINE == 'jruby'
+          jruby_not_supported if RUBY_ENGINE == "jruby"
         end
 
         private_class_method def self.on_truffleruby?
           truffleruby_not_supported = explain_issue(
-            'TruffleRuby is not supported by the datadog gem.',
+            "TruffleRuby is not supported by the datadog gem.",
             suggested: GET_IN_TOUCH,
           )
 
-          truffleruby_not_supported if RUBY_ENGINE == 'truffleruby'
+          truffleruby_not_supported if RUBY_ENGINE == "truffleruby"
         end
 
         # See https://docs.datadoghq.com/tracing/setup_overview/setup/ruby/#microsoft-windows-support for current
         # state of Windows support in the datadog gem.
         private_class_method def self.on_windows?
           windows_not_supported = explain_issue(
-            'Microsoft Windows is not supported by the Datadog Continuous Profiler.',
+            "Microsoft Windows is not supported by the Datadog Continuous Profiler.",
             suggested: GET_IN_TOUCH,
           )
 
@@ -232,72 +173,66 @@ module Datadog
 
         private_class_method def self.on_macos?
           macos_not_supported = explain_issue(
-            'macOS is currently not supported by the Datadog Continuous Profiler.',
+            "macOS is currently not supported by the Datadog Continuous Profiler.",
             suggested: GET_IN_TOUCH,
           )
           # For development only; not supported otherwise
-          macos_testing_override = ENV['DD_PROFILING_MACOS_TESTING'] == 'true'
+          macos_testing_override = ENV["DD_PROFILING_MACOS_TESTING"] == "true"
 
-          macos_not_supported if RUBY_PLATFORM.include?('darwin') && !macos_testing_override
+          macos_not_supported if RUBY_PLATFORM.include?("darwin") && !macos_testing_override
         end
 
         private_class_method def self.on_unknown_os?
           unknown_os_not_supported = explain_issue(
-            'your operating system is not supported by the Datadog Continuous Profiler.',
+            "your operating system is not supported by the Datadog Continuous Profiler.",
             suggested: GET_IN_TOUCH,
           )
 
-          unknown_os_not_supported unless RUBY_PLATFORM.include?('darwin') || RUBY_PLATFORM.include?('linux')
+          unknown_os_not_supported unless RUBY_PLATFORM.include?("darwin") || RUBY_PLATFORM.include?("linux")
         end
 
         private_class_method def self.on_unsupported_cpu_arch?
           architecture_not_supported = explain_issue(
-            'your CPU architecture is not supported by the Datadog Continuous Profiler.',
+            "your CPU architecture is not supported by the Datadog Continuous Profiler.",
             suggested: GET_IN_TOUCH,
           )
 
-          architecture_not_supported unless RUBY_PLATFORM.start_with?('x86_64', 'aarch64', 'arm64')
+          architecture_not_supported unless RUBY_PLATFORM.start_with?("x86_64", "aarch64", "arm64")
         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?
           ruby_without_mjit = explain_issue(
-            'your Ruby has been compiled without JIT support (--disable-jit-support).',
-            'The profiling native extension requires a Ruby compiled with JIT support,',
-            'even if the JIT is not in use by the application itself.',
+            "your Ruby has been compiled without JIT support (--disable-jit-support).",
+            "The profiling native extension requires a Ruby compiled with JIT support,",
+            "even if the JIT is not in use by the application itself.",
             suggested: CONTACT_SUPPORT,
           )
 
-          ruby_without_mjit if CAN_USE_MJIT_HEADER && RbConfig::CONFIG['MJIT_SUPPORT'] != 'yes'
+          ruby_without_mjit if CAN_USE_MJIT_HEADER && RbConfig::CONFIG["MJIT_SUPPORT"] != "yes"
         end
 
         private_class_method def self.libdatadog_not_available?
-          begin
-            gem 'libdatadog', LIBDATADOG_VERSION
-            require 'libdatadog'
-            nil
-          # rubocop:disable Lint/RescueException
-          rescue Exception => e
+          Datadog::LibdatadogExtconfHelpers.try_loading_libdatadog do |exception|
             explain_issue(
-              'there was an exception during loading of the `libdatadog` gem:',
-              e.class.name,
-              *e.message.split("\n"),
-              *Array(e.backtrace),
-              '.',
+              "there was an exception during loading of the `libdatadog` gem:",
+              exception.class.name,
+              *exception.message.split("\n"),
+              *Array(exception.backtrace),
+              ".",
               suggested: CONTACT_SUPPORT,
             )
           end
-          # rubocop:enable Lint/RescueException
         end
 
         private_class_method def self.libdatadog_not_usable?
           no_binaries_for_current_platform = explain_issue(
-            'the `libdatadog` gem installed on your system is missing binaries for your',
-            'platform variant.',
+            "the `libdatadog` gem installed on your system is missing binaries for your",
+            "platform variant.",
             "(Your platform: `#{Libdatadog.current_platform}`)",
-            '(Available binaries:',
-            "`#{Libdatadog.available_binaries.join('`, `')}`)",
+            "(Available binaries:",
+            "`#{Libdatadog.available_binaries.join("`, `")}`)",
             suggested: CONTACT_SUPPORT,
           )
 

data/ext/datadog_profiling_native_extension/private_vm_api_access.c

@@ -311,7 +311,7 @@ VALUE thread_name_for(VALUE thread) {
 // 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
+static inline int
 calc_pos(const rb_iseq_t *iseq, const VALUE *pc, int *lineno, int *node_id)
 {
     VM_ASSERT(iseq);
@@ -364,7 +364,7 @@ calc_pos(const rb_iseq_t *iseq, const VALUE *pc, int *lineno, int *node_id)
 // Copyright (C) 1993-2012 Yukihiro Matsumoto
 // to support our custom rb_profile_frames (see below)
 // Modifications: None
-inline static int
+static inline int
 calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 {
     int lineno;
@@ -376,8 +376,8 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 // Copyright (C) 1993-2012 Yukihiro Matsumoto
 // Modifications:
 // * Renamed rb_profile_frames => ddtrace_rb_profile_frames
-// * Add thread argument
-// * Add is_ruby_frame argument
+// * Add thread argument (this is now upstream, actually!)
+// * Add frame_flags.is_ruby_frame argument
 // * Removed `if (lines)` tests -- require/assume that like `buff`, `lines` is always specified
 // * Skip dummy frame that shows up in main thread
 // * Add `end_cfp == NULL` and `end_cfp <= cfp` safety checks. These are used in a bunch of places in
@@ -392,6 +392,9 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 //   was called from.
 // * Imported fix from https://github.com/ruby/ruby/pull/7116 to avoid sampling threads that are still being created
 // * Imported fix from https://github.com/ruby/ruby/pull/8415 to avoid potential crash when using YJIT.
+// * Add frame_flags.same_frame and logic to skip redoing work if the buffer already contains the same data we're collecting
+// * Skipped use of rb_callable_method_entry_t (cme) for Ruby frames as it doesn't impact us.
+// * Imported fix from https://github.com/ruby/ruby/pull/8280 to keep us closer to upstream
 //
 // What is rb_profile_frames?
 // `rb_profile_frames` is a Ruby VM debug API added for use by profilers for sampling the stack trace of a Ruby thread.
@@ -421,8 +424,7 @@ calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
 //    and friends). We've found quite a few situations where the data from rb_profile_frames and the reference APIs
 //    disagree, and quite a few of them seem oversights/bugs (speculation from my part) rather than deliberate
 //    decisions.
-int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, int *lines, bool* is_ruby_frame)
-{
+int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *stack_buffer) {
     int i;
     // Modified from upstream: Instead of using `GET_EC` to collect info from the current thread,
     // support sampling any thread (including the current) passed as an argument
@@ -466,7 +468,7 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
     // See comment on `record_placeholder_stack_in_native_code` for a full explanation of what this means (and why we don't just return 0)
     if (end_cfp <= cfp) return PLACEHOLDER_STACK_IN_NATIVE_CODE;
 
-    for (i=0; i<limit && cfp != end_cfp;) {
+    for (i=0; i<limit && cfp != end_cfp; cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp)) {
         if (cfp->iseq && !cfp->pc) {
           // Fix: Do nothing -- this frame should not be used
           //
@@ -479,164 +481,88 @@ int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, VALUE *buff, i
                 continue;
             }
 
-            /* record frame info */
-            cme = rb_vm_frame_method_entry(cfp);
+            stack_buffer[i].same_frame =
+              stack_buffer[i].is_ruby_frame &&
+              stack_buffer[i].as.ruby_frame.iseq == (VALUE) cfp->iseq &&
+              stack_buffer[i].as.ruby_frame.caching_pc == cfp->pc;
 
-            if (cme && cme->def->type == VM_METHOD_TYPE_ISEQ &&
-              // Fix: Do not use callable method entry when iseq is for an eval.
-              // TL;DR: This fix is needed for us to match the Ruby reference API information in the
-              // "when sampling an eval/instance eval inside an object" spec.
-              //
-              // Longer note:
-              // When a frame is a ruby frame (VM_FRAME_RUBYFRAME_P above), we can get information about it
-              // by introspecting both the callable method entry, as well as the iseq directly.
-              // Often they match... but sometimes they provide different info (as in the "iseq for an eval" situation
-              // here).
-              // If my reading of vm_backtrace.c is correct, the actual Ruby stack trace API **never** uses the
-              // callable method entry for Ruby frames, but only for VM_METHOD_TYPE_CFUNC (see `backtrace_each` method
-              // on that file).
-              // So... why does `rb_profile_frames` do something different? Is it a bug? Is it because it exposes
-              // more information than the Ruby stack frame API?
-              // As a final note, the `backtracie` gem (https://github.com/ivoanjo/backtracie) can be used to introspect
-              // the full metadata provided by both the callable method entry as well as the iseq, and is really useful
-              // to debug and learn more about these differences.
-              cfp->iseq->body->type != ISEQ_TYPE_EVAL) {
-                buff[i] = (VALUE)cme;
-            }
-            else {
-                buff[i] = (VALUE)cfp->iseq;
+            if (stack_buffer[i].same_frame) { // Nothing to do, buffer already contains this frame
+              i++;
+              continue;
             }
 
+            // dd-trace-rb NOTE:
+            // Upstream Ruby has code here to retrieve the rb_callable_method_entry_t (cme) and in some cases to use it
+            // instead of the iseq.
+            // In practice, they are usually the same; the difference is that when you have e.g. block, one gets you a
+            // reference to the block, and the other to the method containing the block.
+            // This would be important if we used `rb_profile_frame_label` and wanted the "block in foo" label instead
+            // of just "foo". But we're currently using `rb_profile_frame_base_label` which I believe is always the same
+            // between the rb_callable_method_entry_t and the iseq. Thus, to simplify a bit our logic and reduce a bit
+            // the overhead, we always use the iseq here.
+            //
+            // @ivoanjo: I've left the upstream Ruby code commented out below for reference, so it's more obvious that
+            // we're diverging, and we can easily compare and experiment with the upstream version in the future.
+            //
+            // cme = rb_vm_frame_method_entry(cfp);
+
+            // if (cme && cme->def->type == VM_METHOD_TYPE_ISEQ &&
+            //   // Fix: Do not use callable method entry when iseq is for an eval.
+            //   // TL;DR: This fix is needed for us to match the Ruby reference API information in the
+            //   // "when sampling an eval/instance eval inside an object" spec.
+            //   cfp->iseq->body->type != ISEQ_TYPE_EVAL) {
+            //     buff[i] = (VALUE)cme;
+            // }
+            // else {
+            stack_buffer[i].as.ruby_frame.iseq = (VALUE)cfp->iseq;
+            stack_buffer[i].as.ruby_frame.caching_pc = (void *) cfp->pc;
+            // }
+
             // The topmost frame may not have an updated PC because the JIT
             // may not have set one.  The JIT compiler will update the PC
             // before entering a new function (so that `caller` will work),
             // so only the topmost frame could possibly have an out of date PC
             #ifndef NO_JIT_RETURN
               if (cfp == top && cfp->jit_return) {
-                lines[i] = 0;
+                stack_buffer[i].as.ruby_frame.line = 0;
               } else {
-                lines[i] = calc_lineno(cfp->iseq, cfp->pc);
+                stack_buffer[i].as.ruby_frame.line = calc_lineno(cfp->iseq, cfp->pc);
               }
             #else // Ruby < 3.1
-              lines[i] = calc_lineno(cfp->iseq, cfp->pc);
+              stack_buffer[i].as.ruby_frame.line = calc_lineno(cfp->iseq, cfp->pc);
             #endif
 
-            is_ruby_frame[i] = true;
+            stack_buffer[i].is_ruby_frame = true;
             i++;
         }
         else {
             cme = rb_vm_frame_method_entry(cfp);
             if (cme && cme->def->type == VM_METHOD_TYPE_CFUNC) {
-                buff[i] = (VALUE)cme;
-                lines[i] = 0;
-                is_ruby_frame[i] = false;
+                if (start > 0) {
+                    start--;
+                    continue;
+                }
+
+                stack_buffer[i].same_frame =
+                  !stack_buffer[i].is_ruby_frame &&
+                  stack_buffer[i].as.native_frame.caching_cme == (VALUE) cme;
+
+                if (stack_buffer[i].same_frame) { // Nothing to do, buffer already contains this frame
+                  i++;
+                  continue;
+                }
+
+                stack_buffer[i].as.native_frame.caching_cme = (VALUE)cme;
+                stack_buffer[i].as.native_frame.method_id = cme->def->original_id;
+                stack_buffer[i].is_ruby_frame = false;
                 i++;
             }
         }
-        cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
     }
 
     return i;
 }
 
-#ifdef USE_BACKPORTED_RB_PROFILE_FRAME_METHOD_NAME
-
-// Taken from upstream vm_backtrace.c at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
-// Copyright (C) 1993-2012 Yukihiro Matsumoto
-// to support our custom rb_profile_frame_method_name (see below)
-// Modifications: None
-static VALUE
-id2str(ID id)
-{
-    VALUE str = rb_id2str(id);
-    if (!str) return Qnil;
-    return str;
-}
-#define rb_id2str(id) id2str(id)
-
-// Taken from upstream vm_backtrace.c at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
-// Copyright (C) 1993-2012 Yukihiro Matsumoto
-// to support our custom rb_profile_frame_method_name (see below)
-// Modifications: None
-static const rb_iseq_t *
-frame2iseq(VALUE frame)
-{
-    if (NIL_P(frame)) return NULL;
-
-    if (RB_TYPE_P(frame, T_IMEMO)) {
-    switch (imemo_type(frame)) {
-      case imemo_iseq:
-        return (const rb_iseq_t *)frame;
-      case imemo_ment:
-        {
-        const rb_callable_method_entry_t *cme = (rb_callable_method_entry_t *)frame;
-        switch (cme->def->type) {
-          case VM_METHOD_TYPE_ISEQ:
-            return cme->def->body.iseq.iseqptr;
-          default:
-            return NULL;
-        }
-        }
-      default:
-        break;
-    }
-    }
-    rb_bug("frame2iseq: unreachable");
-}
-
-// Taken from upstream vm_backtrace.c at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
-// Copyright (C) 1993-2012 Yukihiro Matsumoto
-// to support our custom rb_profile_frame_method_name (see below)
-// Modifications: None
-static const rb_callable_method_entry_t *
-cframe(VALUE frame)
-{
-    if (NIL_P(frame)) return NULL;
-
-    if (RB_TYPE_P(frame, T_IMEMO)) {
-    switch (imemo_type(frame)) {
-      case imemo_ment:
-            {
-        const rb_callable_method_entry_t *cme = (rb_callable_method_entry_t *)frame;
-        switch (cme->def->type) {
-          case VM_METHOD_TYPE_CFUNC:
-            return cme;
-          default:
-            return NULL;
-        }
-            }
-          default:
-            return NULL;
-        }
-    }
-
-    return NULL;
-}
-
-// Taken from upstream vm_backtrace.c at commit 5f10bd634fb6ae8f74a4ea730176233b0ca96954 (March 2022, Ruby 3.2 trunk)
-// Copyright (C) 1993-2012 Yukihiro Matsumoto
-//
-// Ruby 3.0 finally added support for showing CFUNC frames (frames for methods written using native code)
-// in stack traces gathered via `rb_profile_frames` (https://github.com/ruby/ruby/pull/3299).
-// To access this information on older Rubies, beyond using our custom `ddtrace_rb_profile_frames` above, we also need
-// to backport the Ruby 3.0+ version of `rb_profile_frame_method_name`.
-//
-// Modifications:
-// * Renamed rb_profile_frame_method_name => ddtrace_rb_profile_frame_method_name
-VALUE
-ddtrace_rb_profile_frame_method_name(VALUE frame)
-{
-    const rb_callable_method_entry_t *cme = cframe(frame);
-    if (cme) {
-        ID mid = cme->def->original_id;
-        return id2str(mid);
-    }
-    const rb_iseq_t *iseq = frame2iseq(frame);
-    return iseq ? rb_iseq_method_name(iseq) : Qnil;
-}
-
-#endif // USE_BACKPORTED_RB_PROFILE_FRAME_METHOD_NAME
-
 // Support code for older Rubies that cannot use the MJIT header
 #ifndef RUBY_MJIT_HEADER
 

data/ext/datadog_profiling_native_extension/private_vm_api_access.h

@@ -18,6 +18,22 @@ typedef struct {
   rb_nativethread_id_t owner;
 } current_gvl_owner;
 
+typedef struct frame_info {
+  union {
+    struct {
+      VALUE iseq;
+      void *caching_pc; // For caching only
+      int line;
+    } ruby_frame;
+    struct {
+      VALUE caching_cme; // For caching only
+      ID method_id;
+    } native_frame;
+  } as;
+  bool is_ruby_frame : 1;
+  bool same_frame : 1;
+} frame_info;
+
 rb_nativethread_id_t pthread_id_for(VALUE thread);
 bool is_current_thread_holding_the_gvl(void);
 current_gvl_owner gvl_owner(void);
@@ -27,20 +43,10 @@ void ddtrace_thread_list(VALUE result_array);
 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);
+int ddtrace_rb_profile_frames(VALUE thread, int start, int limit, frame_info *stack_buffer);
 // Returns true if the current thread belongs to the main Ractor or if Ruby has no Ractor support
 bool ddtrace_rb_ractor_main_p(void);
 
-// Ruby 3.0 finally added support for showing CFUNC frames (frames for methods written using native code)
-// in stack traces gathered via `rb_profile_frames` (https://github.com/ruby/ruby/pull/3299).
-// To access this information on older Rubies, beyond using our custom `ddtrace_rb_profile_frames` above, we also need
-// to backport the Ruby 3.0+ version of `rb_profile_frame_method_name`.
-#ifdef USE_BACKPORTED_RB_PROFILE_FRAME_METHOD_NAME
-  VALUE ddtrace_rb_profile_frame_method_name(VALUE frame);
-#else // Ruby > 3.0, just use the stock functionality
-  #define ddtrace_rb_profile_frame_method_name rb_profile_frame_method_name
-#endif
-
 // See comment on `record_placeholder_stack_in_native_code` for a full explanation of what this means (and why we don't just return 0)
 #define PLACEHOLDER_STACK_IN_NATIVE_CODE -1