backtracie 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14ea35393497d5cb266920ef4da5b21b116ef1c4c25624da3c52fcd89dddcd7d
-  data.tar.gz: 4d954ba9c6527707fcec413b320f6a80fa11a42f19743a94ed79a6d42871b95e
+  metadata.gz: 887db5ff6ff55d3cf758d7ad192d5a01400a6c31ba6e46067073cf4bff0d34ac
+  data.tar.gz: 4b6b131ebfa4071b5dc222ca9758b30b22f8175c373de2813c85c2bd732a8a5c
 SHA512:
-  metadata.gz: 072ac1862f8211ba37358f5d20dbc9ff3ffa176559d50d176d8d05f5e3940b9e18865e4a358b170915afa63980f3811deef6313400219048ce9587259e869a98
-  data.tar.gz: 13db93efa6360ef1edb00277d7730fd837ba4aca67ca8a1bc8f61ecf8369d35968263630f5cbe458309452726d26ee03b57eab3e927987245b5b3b5f7c11f032
+  metadata.gz: 36e6e23f5eeeef37f14ca586891b9bdd06c44b5dc1b0ab984858f298ff87fb94f38eff9702521fb163587dd9771b73d3f208f98ce059d018a055830320fcc00d
+  data.tar.gz: 1b598ed425ae8ee01a51228c15886dc246c4324a8d4371c54fa36b49d6b66e08ffebff26af201cf3d756867aa7f3ae27dac791454984ebddb641ae0c693b021e

data/.editorconfig

@@ -9,6 +9,10 @@ end_of_line = lf
 insert_final_newline = true
 trim_trailing_whitespace = true
 
+[*.h]
+indent_style = space
+indent_size = 2
+
 [*.c]
 indent_style = space
 indent_size = 2

data/README.adoc

@@ -4,8 +4,13 @@
 :toclevels: 4
 :toc-title:
 
+A Ruby gem for beautiful backtraces.
+
+Aims to offer alternatives to `Thread#backtrace`, `Thread#backtrace_locations`, `Kernel#caller` and `Kernel#caller_locations` with similar (or better!?) performance, but with better metadata (such as class names).
+
 image:https://img.shields.io/badge/Contributor%20Covenant-2.0-4baaaa.svg["Contributor Covenant", link="CODE_OF_CONDUCT.adoc"]
 image:https://badge.fury.io/rb/backtracie.svg["Gem Version", link="https://badge.fury.io/rb/backtracie"]
+image:https://github.com/ivoanjo/backtracie/actions/workflows/test.yml/badge.svg["CI Status", link="https://github.com/ivoanjo/backtracie/actions/workflows/test.yml"]
 
 [discrete]
 == Contents
@@ -39,7 +44,75 @@ This gem is versioned according to http://semver.org/spec/v2.0.0.html[Semantic V
 
 == Usage
 
-TODO
+Currently, `backtracie` exposes two APIs:
+
+* `Backtracie.backtrace_locations(thread)`: Returns an array representing the backtrace of the given `thread`. Similar to `Thread#backtrace_locations`.
+* `Backtracie.caller_locations`: Returns an array representing the backtrace of the current thread, starting from the caller of the current method. the Similar to `Kernel#caller_locations`.
+
+These methods, inspired by their original Ruby counterparts, return arrays of `Backtracie::Location` items. These items return A LOT more information than Ruby usually exposes:
+
+[source,ruby]
+----
+$ bundle exec pry
+[1] pry(main)> require 'backtracie'
+
+[2] pry(main)> class Example
+[2] pry(main)*   def foo
+[2] pry(main)*     bar
+[2] pry(main)*   end
+[2] pry(main)*   def bar
+[2] pry(main)*     Backtracie.caller_locations.first
+[2] pry(main)*   end
+[2] pry(main)* end
+
+[3] pry(main)> Example.new.foo
+=> #<Backtracie::Location:0x0000561b236c9208
+ @absolute_path="(pry)",
+ @base_label="foo",
+ @debug=
+  {:ruby_frame?=>true,
+   :should_use_iseq=>false,
+   :should_use_cfunc_name=>false,
+   :vm_method_type=>0,
+   :line_number=>3,
+   :called_id=>:foo,
+   :defined_class_refinement?=>false,
+   :self_class=>Example,
+   :real_class=>Example,
+   :self=>#<Example:0x0000561b236f3a08>,
+   :self_class_singleton?=>false,
+   :iseq_is_block?=>false,
+   :iseq_is_eval?=>false,
+   :cfunc_name=>nil,
+   :iseq=>
+    {:path=>"(pry)",
+     :absolute_path=>"(pry)",
+     :label=>"foo",
+     :base_label=>"foo",
+     :full_label=>"foo",
+     :first_lineno=>2,
+     :classpath=>nil,
+     :singleton_method_p=>false,
+     :method_name=>"foo",
+     :qualified_method_name=>"foo"},
+   :callable_method_entry=>
+    {:path=>"(pry)",
+     :absolute_path=>"(pry)",
+     :label=>"foo",
+     :base_label=>"foo",
+     :full_label=>"Example#foo",
+     :first_lineno=>2,
+     :classpath=>"Example",
+     :singleton_method_p=>false,
+     :method_name=>"foo",
+     :qualified_method_name=>"Example#foo"}},
+ @label="foo",
+ @lineno=3,
+ @path="(pry)",
+ @qualified_method_name="Example#foo">
+----
+
+This information can be used to to create much richer stack traces than the ones exposed by Ruby, including details such as class and module names, if methods are singletons, etc.
 
 == Development
 
@@ -49,13 +122,16 @@ To open a console with the gem loaded, run `bundle console`.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to https://rubygems.org[rubygems.org].
 
+To test on specific Ruby versions you can use docker. E.g. to test on Ruby 2.6, use `docker-compose run ruby-2.6`.
+To test on all rubies using docker, you can use `bundle exec rake test-all`.
+
 == Feedback and success stories
 
 Your feedback is welcome!
 
 == Contributing
 
-Bug reports and pull requests are welcome on GitLab at https://github.com/ivoanjo/backtracie.
+Bug reports and pull requests are welcome at https://github.com/ivoanjo/backtracie.
 
 This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the http://contributor-covenant.org[Contributor Covenant] code of conduct.
 
@@ -64,3 +140,27 @@ Maintained with ❤️ by https://ivoanjo.me/[Ivo Anjo].
 == Code of Conduct
 
 Everyone interacting in the backtracie project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the link:CODE_OF_CONDUCT.adoc[code of conduct].
+
+== Interesting Links
+
+Here's some gems that are doing similar things to `backtracie`:
+
+* https://github.com/tmm1/stackprof: A sampling call-stack profiler for Ruby
+* https://github.com/ko1/pretty_backtrace: Pretty your exception backtrace
+* https://github.com/Shopify/stack_frames: This library allows backtraces to be captured and accessed without object allocations by leveraging MRI's profile frames API
+
+Other interesting links on this matter:
+
+* https://github.com/ruby/ruby/pull/3299: vm_backtrace.c: let rb_profile_frames show cfunc frames
+* https://github.com/ruby/ruby/pull/2713: Fix use of the rb_profile_frames start parameter
+* https://github.com/rake-compiler/rake-compiler:  Provide a standard and simplified way to build and package Ruby C and Java extensions using Rake as glue.
+* https://github.com/ko1/rubyhackchallenge: "Ruby Hack Challenge" (RHC) is a short guide to hack MRI (Matz Ruby Interpreter) internals
+* https://docs.ruby-lang.org/en/3.0.0/doc/extension_rdoc.html: Creating Extension Libraries for Ruby
+* https://ruby-hacking-guide.github.io/: Ruby Hacking Guide
+  ** This is one of the most through and deep guides out there to the MRI internals. Very detailed and in depth, but outdated.
+* http://patshaughnessy.net/ruby-under-a-microscope: Book with a really good introduction to MRI internals.
+
+My blog posts on better backtraces:
+
+* https://ivoanjo.me/blog/2020/07/05/ruby-experiment-include-class-names-in-backtraces/: ruby experiment: include class names in backtraces
+* https://ivoanjo.me/blog/2020/07/19/better-backtraces-in-ruby-using-tracepoint/: better backtraces in ruby using tracepoint

data/backtracie.gemspec

@@ -32,12 +32,18 @@ Gem::Specification.new do |spec|
   spec.description = "Ruby gem for beautiful backtraces"
   spec.homepage = "https://github.com/ivoanjo/backtracie"
   spec.license = "LGPL-3.0+"
-  spec.required_ruby_version = ">= 3.0.0"
+  spec.required_ruby_version = ">= 2.3.0"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features)/}) }
+    `git ls-files -z`.split("\x0")
+      .reject { |f| f.match(%r{\A(?:test|spec|features|[.]github)/}) }
+      .reject { |f|
+        ["gems.rb", ".whitesource", ".ruby-version", ".gitignore", ".rspec", ".standard.yml",
+          "DEVELOPMENT_NOTES.adoc", "Rakefile", "docker-compose.yml", "bin/console"].include?(f)
+      }
   end
   spec.require_paths = ["lib", "ext"]
+  spec.extensions = ["ext/backtracie_native_extension/extconf.rb"]
 end

data/ext/backtracie_native_extension/backtracie.c

@@ -16,44 +16,56 @@
 // You should have received a copy of the GNU Lesser General Public License
 // along with backtracie.  If not, see <http://www.gnu.org/licenses/>.
 
+#include <stdbool.h>
+
 #include "ruby/ruby.h"
 #include "ruby/debug.h"
 
 #include "extconf.h"
 
-#include "ruby_3.0.0.h"
-
-// Constants
+#include "ruby_shards.h"
 
 #define MAX_STACK_DEPTH 2000 // FIXME: Need to handle when this is not enough
 
-// Globals
+#define VALUE_COUNT(array) (sizeof(array) / sizeof(VALUE))
+#define SAFE_NAVIGATION(function, maybe_nil) ((maybe_nil) != Qnil ? function(maybe_nil) : Qnil)
 
+static VALUE main_object_instance = Qnil;
+static ID ensure_object_is_thread_id;
+static ID to_s_id;
+static ID current_id;
+static ID backtrace_locations_id;
 static VALUE backtracie_module = Qnil;
 static VALUE backtracie_location_class = Qnil;
 
-// Function headers
-
 static VALUE primitive_caller_locations(VALUE self);
 static VALUE primitive_backtrace_locations(VALUE self, VALUE thread);
-static VALUE caller_locations(VALUE self, VALUE thread, int ignored_stack_top_frames);
-inline static VALUE new_location(VALUE absolute_path, VALUE base_label, VALUE label, VALUE lineno, VALUE path, VALUE debug);
-static bool is_ruby_frame(VALUE ruby_frame);
-static VALUE ruby_frame_to_location(VALUE frame, VALUE last_ruby_line, VALUE correct_label);
-static VALUE cfunc_frame_to_location(VALUE frame, VALUE last_ruby_frame, VALUE last_ruby_line);
-static VALUE debug_frame(VALUE frame, VALUE type);
-
-// Macros
-
-#define VALUE_COUNT(array) (sizeof(array) / sizeof(VALUE))
+static VALUE collect_backtrace_locations(VALUE self, VALUE thread, int ignored_stack_top_frames);
+inline static VALUE new_location(VALUE absolute_path, VALUE base_label, VALUE label, VALUE lineno, VALUE path, VALUE qualified_method_name, VALUE debug);
+static VALUE ruby_frame_to_location(raw_location *the_location);
+static VALUE qualified_method_name_for_location(raw_location *the_location);
+static VALUE cfunc_frame_to_location(raw_location *the_location, raw_location *last_ruby_location);
+static VALUE frame_from_location(raw_location *the_location);
+static VALUE qualified_method_name_for_block(raw_location *the_location);
+static VALUE qualified_method_name_from_self(raw_location *the_location);
+static bool is_self_class_singleton(raw_location *the_location);
+static bool is_defined_class_a_refinement(raw_location *the_location);
+static VALUE debug_raw_location(raw_location *the_location);
+static VALUE debug_frame(VALUE frame);
+static inline VALUE to_boolean(bool value) ;
 
 void Init_backtracie_native_extension(void) {
+  main_object_instance = backtracie_rb_vm_top_self();
+  ensure_object_is_thread_id = rb_intern("ensure_object_is_thread");
+  to_s_id = rb_intern("to_s");
+  current_id = rb_intern("current");
+  backtrace_locations_id = rb_intern("backtrace_locations");
+
   backtracie_module = rb_const_get(rb_cObject, rb_intern("Backtracie"));
   rb_global_variable(&backtracie_module);
 
   rb_define_module_function(backtracie_module, "backtrace_locations", primitive_backtrace_locations, 1);
 
-  // We need to keep a reference to Backtracie::Locations around, to create new instances
   backtracie_location_class = rb_const_get(backtracie_module, rb_intern("Location"));
   rb_global_variable(&backtracie_location_class);
 
@@ -63,24 +75,30 @@ void Init_backtracie_native_extension(void) {
 }
 
 // Get array of Backtracie::Locations for a given thread; if thread is nil, returns for the current thread
-static VALUE caller_locations(VALUE self, VALUE thread, int ignored_stack_top_frames) {
+static VALUE collect_backtrace_locations(VALUE self, VALUE thread, int ignored_stack_top_frames) {
   int stack_depth = 0;
-  VALUE frames[MAX_STACK_DEPTH];
-  VALUE correct_labels[MAX_STACK_DEPTH];
-  int lines[MAX_STACK_DEPTH];
+  raw_location raw_locations[MAX_STACK_DEPTH];
 
-  if (thread == Qnil) {
-    // Get for own thread
-    stack_depth = modified_rb_profile_frames(0, MAX_STACK_DEPTH, frames, correct_labels, lines);
-  } else {
-    stack_depth = modified_rb_profile_frames_for_thread(thread, 0, MAX_STACK_DEPTH, frames, correct_labels, lines);
-  }
-
-  // Ignore the last frame -- seems to be an uninteresting VM frame. MRI itself seems to ignore the last frame in
-  // the implementation of backtrace_collect()
-  int ignored_stack_bottom_frames = 1;
+  #ifndef PRE_MJIT_RUBY
+    if (thread == Qnil) {
+      // Get for own thread
+      stack_depth = backtracie_rb_profile_frames(MAX_STACK_DEPTH, raw_locations);
+    } else {
+      stack_depth = backtracie_rb_profile_frames_for_thread(thread, MAX_STACK_DEPTH, raw_locations);
+    }
+  #else
+    VALUE current_thread = rb_funcall(rb_cThread, current_id, 0);
+
+    if (thread == Qnil || thread == current_thread) {
+      thread = current_thread;
+      // Since we're going to sample the current thread, we don't want Thread#backtrace_locations to show up
+      // on the stack (as we want to match the exact depth we get from MRI), so we ignore one extra frame
+      ignored_stack_top_frames++;
+    }
 
-  stack_depth -= ignored_stack_bottom_frames;
+    VALUE locations_array = rb_funcall(thread, backtrace_locations_id, 0);
+    stack_depth = backtracie_profile_frames_from_ruby_locations(locations_array, raw_locations);
+  #endif
 
   VALUE locations = rb_ary_new_capa(stack_depth - ignored_stack_top_frames);
 
@@ -88,22 +106,16 @@ static VALUE caller_locations(VALUE self, VALUE thread, int ignored_stack_top_fr
   // Kernel#caller_locations is to instead use the path and line number of the last Ruby frame seen.
   // Thus, we keep that frame here to able to replicate that behavior.
   // (This is why we also iterate the frames array backwards below -- so that it's easier to keep the last_ruby_frame)
-  VALUE last_ruby_frame = Qnil;
-  VALUE last_ruby_line = Qnil;
+  raw_location *last_ruby_location = 0;
 
   for (int i = stack_depth - 1; i >= ignored_stack_top_frames; i--) {
-    VALUE frame = frames[i];
-    int line = lines[i];
-
     VALUE location = Qnil;
 
-    if (is_ruby_frame(frame)) {
-      last_ruby_frame = frame;
-      last_ruby_line = INT2FIX(line);
-
-      location = ruby_frame_to_location(frame, last_ruby_line, correct_labels[i]);
+    if (raw_locations[i].is_ruby_frame) {
+      last_ruby_location = &raw_locations[i];
+      location = ruby_frame_to_location(&raw_locations[i]);
     } else {
-      location = cfunc_frame_to_location(frame, last_ruby_frame, last_ruby_line);
+      location = cfunc_frame_to_location(&raw_locations[i], last_ruby_location);
     }
 
     rb_ary_store(locations, i - ignored_stack_top_frames, location);
@@ -119,67 +131,241 @@ static VALUE primitive_caller_locations(VALUE self) {
   // * the frame from the caller itself (since we're replicating the semantics of Kernel#caller_locations)
   int ignored_stack_top_frames = 3;
 
-  return caller_locations(self, Qnil, ignored_stack_top_frames);
+  return collect_backtrace_locations(self, Qnil, ignored_stack_top_frames);
 }
 
 static VALUE primitive_backtrace_locations(VALUE self, VALUE thread) {
-  rb_funcall(backtracie_module, rb_intern("ensure_object_is_thread"), 1, thread);
+  rb_funcall(backtracie_module, ensure_object_is_thread_id, 1, thread);
 
   int ignored_stack_top_frames = 0;
 
-  return caller_locations(self, thread, ignored_stack_top_frames);
+  return collect_backtrace_locations(self, thread, ignored_stack_top_frames);
 }
 
-inline static VALUE new_location(VALUE absolute_path, VALUE base_label, VALUE label, VALUE lineno, VALUE path, VALUE debug) {
-  VALUE arguments[] = { absolute_path, base_label, label, lineno, path, debug };
+inline static VALUE new_location(
+  VALUE absolute_path,
+  VALUE base_label,
+  VALUE label,
+  VALUE lineno,
+  VALUE path,
+  VALUE qualified_method_name,
+  VALUE debug
+) {
+  VALUE arguments[] = { absolute_path, base_label, label, lineno, path, qualified_method_name, debug };
   return rb_class_new_instance(VALUE_COUNT(arguments), arguments, backtracie_location_class);
 }
 
-static bool is_ruby_frame(VALUE frame) {
-  VALUE absolute_path = rb_profile_frame_absolute_path(frame);
+static VALUE ruby_frame_to_location(raw_location *the_location) {
+  VALUE frame = frame_from_location(the_location);
 
-  return (rb_profile_frame_path(frame) != Qnil || absolute_path != Qnil) &&
-    (rb_funcall(absolute_path, rb_intern("=="), 1, rb_str_new2("<cfunc>")) == Qfalse);
-}
-
-static VALUE ruby_frame_to_location(VALUE frame, VALUE last_ruby_line, VALUE correct_label) {
   return new_location(
     rb_profile_frame_absolute_path(frame),
     rb_profile_frame_base_label(frame),
-    rb_profile_frame_label(correct_label),
-    last_ruby_line,
+    rb_profile_frame_label(the_location->iseq),
+    INT2FIX(the_location->line_number),
     rb_profile_frame_path(frame),
-    debug_frame(frame, rb_str_new2("ruby_frame"))
+    qualified_method_name_for_location(the_location),
+    debug_raw_location(the_location)
   );
 }
 
-static VALUE cfunc_frame_to_location(VALUE frame, VALUE last_ruby_frame, VALUE last_ruby_line) {
-  VALUE method_name = rb_profile_frame_method_name(frame); // Replaces label and base_label in cfuncs
+static VALUE qualified_method_name_for_location(raw_location *the_location) {
+  VALUE frame = frame_from_location(the_location);
+  VALUE defined_class = backtracie_defined_class(the_location);
+  VALUE qualified_method_name = Qnil;
+
+  if (is_defined_class_a_refinement(the_location)) {
+    qualified_method_name = backtracie_refinement_name(the_location);
+    rb_str_concat(qualified_method_name, rb_str_new2("#"));
+    rb_str_concat(qualified_method_name, rb_profile_frame_label(frame));
+  } else if (is_self_class_singleton(the_location)) {
+    qualified_method_name = qualified_method_name_from_self(the_location);
+  } else if (backtracie_iseq_is_block(the_location) || backtracie_iseq_is_eval(the_location)) {
+    qualified_method_name = qualified_method_name_for_block(the_location);
+  } else if (defined_class != Qnil && rb_mod_name(defined_class) == Qnil) {
+    // Instance of an anonymous class. Let's find it a name
+    VALUE superclass = defined_class;
+    VALUE superclass_name = Qnil;
+    do {
+      superclass = RCLASS_SUPER(superclass);
+      superclass_name = rb_mod_name(superclass);
+    } while (superclass_name == Qnil);
+
+    qualified_method_name = rb_str_new2("");
+    rb_str_concat(qualified_method_name, superclass_name);
+    rb_str_concat(qualified_method_name, rb_str_new2("$anonymous#"));
+    rb_str_concat(qualified_method_name, rb_profile_frame_base_label(frame_from_location(the_location)));
+  } else {
+    qualified_method_name = backtracie_rb_profile_frame_qualified_method_name(frame);
+
+    if (qualified_method_name == Qnil) {
+      qualified_method_name = qualified_method_name_from_self(the_location);
+    }
+  }
+
+  if (backtracie_iseq_is_block(the_location) || backtracie_iseq_is_eval(the_location)) {
+    rb_str_concat(qualified_method_name, rb_str_new2("{block}"));
+  }
+
+  return qualified_method_name;
+}
+
+static VALUE cfunc_frame_to_location(raw_location *the_location, raw_location *last_ruby_location) {
+  VALUE last_ruby_frame =
+    last_ruby_location != 0 ? frame_from_location(last_ruby_location) : Qnil;
+
+  // Replaces label and base_label in cfuncs
+  VALUE method_name =
+    the_location->should_use_cfunc_name ?
+      the_location->cfunc_name : backtracie_rb_profile_frame_method_name(the_location->callable_method_entry);
 
   return new_location(
-    last_ruby_frame != Qnil ? rb_profile_frame_absolute_path(last_ruby_frame) : Qnil,
+    SAFE_NAVIGATION(rb_profile_frame_absolute_path, last_ruby_frame),
     method_name,
     method_name,
-    last_ruby_line,
-    last_ruby_frame != Qnil ? rb_profile_frame_path(last_ruby_frame) : Qnil,
-    debug_frame(frame, rb_str_new2("cfunc_frame"))
+    last_ruby_location != 0 ? INT2FIX(last_ruby_location->line_number) : Qnil,
+    SAFE_NAVIGATION(rb_profile_frame_path, last_ruby_frame),
+    backtracie_rb_profile_frame_qualified_method_name(the_location->callable_method_entry),
+    debug_raw_location(the_location)
   );
 }
 
-// Used to dump all the things we get from the rb_profile_frames API, for debugging
-static VALUE debug_frame(VALUE frame, VALUE type) {
+static VALUE frame_from_location(raw_location *the_location) {
+  return \
+    the_location->should_use_iseq ||
+    // This one is somewhat weird, but the regular MRI Ruby APIs seem to pick the iseq for evals as well
+    backtracie_iseq_is_eval(the_location) ?
+      the_location->iseq : the_location->callable_method_entry;
+}
+
+static VALUE qualified_method_name_for_block(raw_location *the_location) {
+  VALUE class_name = backtracie_rb_profile_frame_classpath(the_location->callable_method_entry);
+  VALUE method_name = backtracie_called_id(the_location);
+  VALUE is_singleton_method = rb_profile_frame_singleton_method_p(the_location->iseq);
+
+  VALUE name = rb_str_new2("");
+  rb_str_concat(name, class_name);
+  rb_str_concat(name, is_singleton_method ? rb_str_new2(".") : rb_str_new2("#"));
+  rb_str_concat(name, rb_sym2str(method_name));
+
+  return name;
+}
+
+static VALUE qualified_method_name_from_self(raw_location *the_location) {
+  if (the_location->self == Qnil) return Qnil;
+
+  VALUE self_class = rb_class_of(the_location->self);
+  bool is_self_class_singleton = FL_TEST(self_class, FL_SINGLETON);
+
+  VALUE name = rb_str_new2("");
+  if (is_self_class_singleton) {
+    if (the_location->self == main_object_instance) {
+      rb_str_concat(name, rb_str_new2("Object$<main>#"));
+    } else {
+      // Crawl up the hierarchy to find a real class
+      VALUE the_class = rb_class_real(self_class);
+
+      // This is similar to BetterBacktraceHelper's self_class_module_or_class?
+      // If the real class of this object is the actual class Class or the class Module,
+      // it means that this is a method being directly called on a given Class/Module,
+      // e.g. Kernel.puts or BasicObject.name. In this case, Ruby already sets the name
+      // correctly, so we just delegate.
+      if (the_class == rb_cModule || the_class == rb_cClass) {
+        // Is the class/module is anonymous?
+        if (rb_mod_name(the_location->self) == Qnil) {
+          rb_str_concat(name, rb_funcall(the_class, to_s_id, 0));
+          rb_str_concat(name, rb_str_new2("$singleton."));
+        } else {
+          return SAFE_NAVIGATION(backtracie_rb_profile_frame_qualified_method_name, the_location->callable_method_entry);
+        }
+      } else {
+        rb_str_concat(name, rb_funcall(the_class, to_s_id, 0));
+        rb_str_concat(name, rb_str_new2("$singleton#"));
+      }
+    }
+  } else {
+    // Not very sure if this branch of the if is ever reached, and if it would be for a instance or static call, so
+    // let's just have these defaults and revisit as needed
+    rb_str_concat(name, rb_funcall(self_class, to_s_id, 0));
+    rb_str_concat(name, rb_str_new2("#"));
+  }
+
+  if (backtracie_iseq_is_block(the_location) || backtracie_iseq_is_eval(the_location)) {
+    // Nothing to do, {block} will be appended in qualified_method_name_for_location which called us
+  } else {
+    rb_str_concat(name, rb_profile_frame_base_label(frame_from_location(the_location)));
+  }
+
+  return name;
+}
+
+static bool is_self_class_singleton(raw_location *the_location) {
+  return the_location->self != Qnil && FL_TEST(rb_class_of(the_location->self), FL_SINGLETON);
+}
+
+static bool is_defined_class_a_refinement(raw_location *the_location) {
+  VALUE defined_class = backtracie_defined_class(the_location);
+
+  return defined_class != Qnil && FL_TEST(rb_class_of(defined_class), RMODULE_IS_REFINEMENT);
+}
+
+static VALUE debug_raw_location(raw_location *the_location) {
+  VALUE self_class = SAFE_NAVIGATION(rb_class_of, the_location->self);
+
   VALUE arguments[] = {
-    rb_profile_frame_path(frame),
-    rb_profile_frame_absolute_path(frame),
-    rb_profile_frame_label(frame),
-    rb_profile_frame_base_label(frame),
-    rb_profile_frame_full_label(frame),
-    rb_profile_frame_first_lineno(frame),
-    rb_profile_frame_classpath(frame),
-    rb_profile_frame_singleton_method_p(frame),
-    rb_profile_frame_method_name(frame),
-    rb_profile_frame_qualified_method_name(frame),
-    type
+    ID2SYM(rb_intern("ruby_frame?"))  ,             /* => */ to_boolean(the_location->is_ruby_frame),
+    ID2SYM(rb_intern("should_use_iseq")),           /* => */ to_boolean(the_location->should_use_iseq),
+    ID2SYM(rb_intern("should_use_cfunc_name")),     /* => */ to_boolean(the_location->should_use_cfunc_name),
+    ID2SYM(rb_intern("vm_method_type")),            /* => */ INT2FIX(the_location->vm_method_type),
+    ID2SYM(rb_intern("line_number")),               /* => */ INT2FIX(the_location->line_number),
+    ID2SYM(rb_intern("called_id")),                 /* => */ backtracie_called_id(the_location),
+    // TODO: On Ruby < 3.0, running be pry -e 'require "backtracie"; Backtracie.caller_locations' with this being
+    // exposed causes a VM segfault inside the pretty printing code
+    // ID2SYM(rb_intern("defined_class")),             /* => */ backtracie_defined_class(the_location),
+    ID2SYM(rb_intern("defined_class_refinement?")), /* => */ to_boolean(is_defined_class_a_refinement(the_location)),
+    ID2SYM(rb_intern("self_class")),                /* => */ self_class,
+    ID2SYM(rb_intern("real_class")),                /* => */ SAFE_NAVIGATION(rb_class_real, self_class),
+    ID2SYM(rb_intern("self")),                      /* => */ the_location->self,
+    ID2SYM(rb_intern("self_class_singleton?")),     /* => */ to_boolean(is_self_class_singleton(the_location)),
+    ID2SYM(rb_intern("iseq_is_block?")),            /* => */ to_boolean(backtracie_iseq_is_block(the_location)),
+    ID2SYM(rb_intern("iseq_is_eval?")),             /* => */ to_boolean(backtracie_iseq_is_eval(the_location)),
+    ID2SYM(rb_intern("cfunc_name")),                /* => */ the_location->cfunc_name,
+    ID2SYM(rb_intern("iseq")),                      /* => */ debug_frame(the_location->iseq),
+    ID2SYM(rb_intern("callable_method_entry")),     /* => */ debug_frame(the_location->callable_method_entry)
+  };
+
+  VALUE debug_hash = rb_hash_new();
+  #ifndef PRE_MJIT_RUBY
+  // FIXME: Hack, need to actually fix this
+  rb_hash_bulk_insert(VALUE_COUNT(arguments), arguments, debug_hash);
+  #endif
+  return debug_hash;
+}
+
+static VALUE debug_frame(VALUE frame) {
+  if (frame == Qnil) return Qnil;
+
+  VALUE arguments[] = {
+    ID2SYM(rb_intern("path")),                  /* => */ rb_profile_frame_path(frame),
+    ID2SYM(rb_intern("absolute_path")),         /* => */ rb_profile_frame_absolute_path(frame),
+    ID2SYM(rb_intern("label")),                 /* => */ rb_profile_frame_label(frame),
+    ID2SYM(rb_intern("base_label")),            /* => */ rb_profile_frame_base_label(frame),
+    ID2SYM(rb_intern("full_label")),            /* => */ rb_profile_frame_full_label(frame),
+    ID2SYM(rb_intern("first_lineno")),          /* => */ rb_profile_frame_first_lineno(frame),
+    ID2SYM(rb_intern("classpath")),             /* => */ backtracie_rb_profile_frame_classpath(frame),
+    ID2SYM(rb_intern("singleton_method_p")),    /* => */ rb_profile_frame_singleton_method_p(frame),
+    ID2SYM(rb_intern("method_name")),           /* => */ rb_profile_frame_method_name(frame),
+    ID2SYM(rb_intern("qualified_method_name")), /* => */ backtracie_rb_profile_frame_qualified_method_name(frame)
   };
-  return rb_ary_new_from_values(VALUE_COUNT(arguments), arguments);
+
+  VALUE debug_hash = rb_hash_new();
+  #ifndef PRE_MJIT_RUBY
+  // FIXME: Hack, need to actually fix this
+  rb_hash_bulk_insert(VALUE_COUNT(arguments), arguments, debug_hash);
+  #endif
+  return debug_hash;
+}
+
+static inline VALUE to_boolean(bool value) {
+  return value ? Qtrue : Qfalse;
 }