stackprof 0.2.17 → 0.2.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b55691b8d1966ba4b2b2458a4908b2a2d5b65f2074dfe3b3b1b6350f752704ec
-  data.tar.gz: 79e2a0508a1c722f39cc61d39b0577cfb5520669a7a2db4cadac6c49dcb1267a
+  metadata.gz: 90e33127951d53147b6a65704446ec812999df9525d868865029ee1c7450445d
+  data.tar.gz: 19a5f104482f355cb1957b71b18b15b9ca9bb981cfcc109688366e53704c5711
 SHA512:
-  metadata.gz: 2fa22779f03c332a3680f526bf1df29553588773fabeb00da327af3525018e535e973bafd990254c6ad50516faf5e8b1d087bb7c208c99d0b512d99ccdef53bb
-  data.tar.gz: 73ba1328c793b0c0c4657e7826f4bf2cd52102c61a2ca2e3e0b1c5240ffe96ee0ec328ea831b1592c10b4e13c6aec2bb9d28fd05e93ddef999d5131e55124362
+  metadata.gz: 17610238200852f97afcc730efd9171c46c3a001ff7d5b82cb65fc92f96d9d2b206474bcecc7eeee1981365d2a07fd4dad460edc54a8bc9c8b1e6c7412f7cde3
+  data.tar.gz: 35cc1394b526edd0782468b06d54f66eb1ff10e5741becf486f68f0b141511fad9db622816004a4ae2e1a59cff048abe2d5697848eff127640663e9246f33cca

data/.github/workflows/ci.yml

@@ -8,7 +8,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ ruby-head, '3.0', '2.7', '2.6', '2.5', '2.4', '2.3', '2.2' ]
+        ruby: [ ruby-head, '3.1', '3.0', '2.7', '2.6', '2.5', '2.4', '2.3', '2.2', truffleruby ]
     steps:
       - name: Checkout
         uses: actions/checkout@v2

data/Rakefile

@@ -7,11 +7,21 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList["test/**/test_*.rb"]
 end
 
-require "rake/extensiontask"
+if RUBY_ENGINE == "truffleruby"
+  task :compile do
+    # noop
+  end
 
-Rake::ExtensionTask.new("stackprof") do |ext|
-  ext.ext_dir = "ext/stackprof"
-  ext.lib_dir = "lib/stackprof"
+  task :clean do
+    # noop
+  end
+else
+  require "rake/extensiontask"
+
+  Rake::ExtensionTask.new("stackprof") do |ext|
+    ext.ext_dir = "ext/stackprof"
+    ext.lib_dir = "lib/stackprof"
+  end
 end
 
 task default: %i(compile test)

data/bin/stackprof

@@ -2,94 +2,128 @@
 require 'optparse'
 require 'stackprof'
 
-options = {}
+banner = <<-END
+Usage: stackprof run [--mode=MODE|--out=FILE|--interval=INTERVAL|--format=FORMAT] -- COMMAND
+Usage: stackprof [file.dump]+ [--text|--method=NAME|--callgrind|--graphviz]
+END
 
-parser = OptionParser.new(ARGV) do |o|
-  o.banner = "Usage: stackprof [file.dump]+ [--text|--method=NAME|--callgrind|--graphviz]"
+if ARGV.first == "run"
+  ARGV.shift
+  env = {}
+  parser = OptionParser.new(banner) do |o|
+    o.on('--mode [MODE]', String, 'Mode of sampling: cpu, wall, object, default to wall') do |mode|
+      env["STACKPROF_MODE"] = mode
+    end
 
-  o.on('--text', 'Text summary per method (default)'){ options[:format] = :text }
-  o.on('--json', 'JSON output (use with web viewers)'){ options[:format] = :json }
-  o.on('--files', 'List of files'){ |f| options[:format] = :files }
-  o.on('--limit [num]', Integer, 'Limit --text, --files, or --graphviz output to N entries'){ |n| options[:limit] = n }
-  o.on('--sort-total', "Sort --text or --files output on total samples\n\n"){ options[:sort] = true }
-  o.on('--method [grep]', 'Zoom into specified method'){ |f| options[:format] = :method; options[:filter] = f }
-  o.on('--file [grep]', "Show annotated code for specified file"){ |f| options[:format] = :file; options[:filter] = f }
-  o.on('--walk', "Walk the stacktrace interactively\n\n"){ |f| options[:walk] = true }
-  o.on('--callgrind', 'Callgrind output (use with kcachegrind, stackprof-gprof2dot.py)'){ options[:format] = :callgrind }
-  o.on('--graphviz', "Graphviz output (use with dot)"){ options[:format] = :graphviz }
-  o.on('--node-fraction [frac]', OptionParser::DecimalNumeric, 'Drop nodes representing less than [frac] fraction of samples'){ |n| options[:node_fraction] = n }
-  o.on('--stackcollapse', 'stackcollapse.pl compatible output (use with stackprof-flamegraph.pl)'){ options[:format] = :stackcollapse }
-  o.on('--timeline-flamegraph', "timeline-flamegraph output (js)"){ options[:format] = :timeline_flamegraph }
-  o.on('--alphabetical-flamegraph', "alphabetical-flamegraph output (js)"){ options[:format] = :alphabetical_flamegraph }
-  o.on('--flamegraph', "alias to --timeline-flamegraph"){ options[:format] = :timeline_flamegraph }
-  o.on('--flamegraph-viewer [f.js]', String, "open html viewer for flamegraph output"){ |file|
-    puts("open file://#{File.expand_path('../../lib/stackprof/flamegraph/viewer.html', __FILE__)}?data=#{File.expand_path(file)}")
-    exit
-  }
-  o.on('--d3-flamegraph', "flamegraph output (html using d3-flame-graph)\n\n"){ options[:format] = :d3_flamegraph }
-  o.on('--select-files []', String, 'Show results of matching files'){ |path| (options[:select_files] ||= []) << File.expand_path(path) }
-  o.on('--reject-files []', String, 'Exclude results of matching files'){ |path| (options[:reject_files] ||= []) << File.expand_path(path) }
-  o.on('--select-names []', Regexp, 'Show results of matching method names'){ |regexp| (options[:select_names] ||= []) << regexp }
-  o.on('--reject-names []', Regexp, 'Exclude results of matching method names'){ |regexp| (options[:reject_names] ||= []) << regexp }
-  o.on('--dump', 'Print marshaled profile dump (combine multiple profiles)'){ options[:format] = :dump }
-  o.on('--debug', 'Pretty print raw profile data'){ options[:format] = :debug }
-end
+    o.on('--out [FILENAME]', String, 'The target file, which will be overwritten. Defaults to a random temporary file') do |out|
+      env['STACKPROF_OUT'] = out
+    end
 
-parser.parse!
-parser.abort(parser.help) if ARGV.empty?
+    o.on('--interval [MILLISECONDS]', Integer, 'Mode-relative sample rate') do |interval|
+      env['STACKPROF_INTERVAL'] = interval.to_s
+    end
 
-reports = []
-while ARGV.size > 0
-  begin
-    file = ARGV.pop
-    reports << StackProf::Report.new(Marshal.load(IO.binread(file)))
-  rescue TypeError => e
-    STDERR.puts "** error parsing #{file}: #{e.inspect}"
+    o.on('--raw', 'collects the extra data required by the --flamegraph and --stackcollapse report types') do |raw|
+      env['STACKPROF_RAW'] = raw.to_s
+    end
+
+    o.on('--ignore-gc', 'Ignore garbage collection frames') do |gc|
+      env['STACKPROF_IGNORE_GC'] = gc.to_s
+    end
   end
-end
-report = reports.inject(:+)
+  parser.parse!
+  parser.abort(parser.help) if ARGV.empty?
+  stackprof_path = File.expand_path('../lib', __dir__)
+  env['RUBYOPT'] = "-I #{stackprof_path} -r stackprof/autorun #{ENV['RUBYOPT']}"
+  Kernel.exec(env, *ARGV)
+else
+  options = {}
 
-default_options = {
-  :format => :text,
-  :sort => false,
-  :limit => 30
-}
+  parser = OptionParser.new(banner) do |o|
+    o.on('--text', 'Text summary per method (default)'){ options[:format] = :text }
+    o.on('--json', 'JSON output (use with web viewers)'){ options[:format] = :json }
+    o.on('--files', 'List of files'){ |f| options[:format] = :files }
+    o.on('--limit [num]', Integer, 'Limit --text, --files, or --graphviz output to N entries'){ |n| options[:limit] = n }
+    o.on('--sort-total', "Sort --text or --files output on total samples\n\n"){ options[:sort] = true }
+    o.on('--method [grep]', 'Zoom into specified method'){ |f| options[:format] = :method; options[:filter] = f }
+    o.on('--file [grep]', "Show annotated code for specified file"){ |f| options[:format] = :file; options[:filter] = f }
+    o.on('--walk', "Walk the stacktrace interactively\n\n"){ |f| options[:walk] = true }
+    o.on('--callgrind', 'Callgrind output (use with kcachegrind, stackprof-gprof2dot.py)'){ options[:format] = :callgrind }
+    o.on('--graphviz', "Graphviz output (use with dot)"){ options[:format] = :graphviz }
+    o.on('--node-fraction [frac]', OptionParser::DecimalNumeric, 'Drop nodes representing less than [frac] fraction of samples'){ |n| options[:node_fraction] = n }
+    o.on('--stackcollapse', 'stackcollapse.pl compatible output (use with stackprof-flamegraph.pl)'){ options[:format] = :stackcollapse }
+    o.on('--timeline-flamegraph', "timeline-flamegraph output (js)"){ options[:format] = :timeline_flamegraph }
+    o.on('--alphabetical-flamegraph', "alphabetical-flamegraph output (js)"){ options[:format] = :alphabetical_flamegraph }
+    o.on('--flamegraph', "alias to --timeline-flamegraph"){ options[:format] = :timeline_flamegraph }
+    o.on('--flamegraph-viewer [f.js]', String, "open html viewer for flamegraph output"){ |file|
+      puts("open file://#{File.expand_path('../../lib/stackprof/flamegraph/viewer.html', __FILE__)}?data=#{File.expand_path(file)}")
+      exit
+    }
+    o.on('--d3-flamegraph', "flamegraph output (html using d3-flame-graph)\n\n"){ options[:format] = :d3_flamegraph }
+    o.on('--select-files []', String, 'Show results of matching files'){ |path| (options[:select_files] ||= []) << File.expand_path(path) }
+    o.on('--reject-files []', String, 'Exclude results of matching files'){ |path| (options[:reject_files] ||= []) << File.expand_path(path) }
+    o.on('--select-names []', Regexp, 'Show results of matching method names'){ |regexp| (options[:select_names] ||= []) << regexp }
+    o.on('--reject-names []', Regexp, 'Exclude results of matching method names'){ |regexp| (options[:reject_names] ||= []) << regexp }
+    o.on('--dump', 'Print marshaled profile dump (combine multiple profiles)'){ options[:format] = :dump }
+    o.on('--debug', 'Pretty print raw profile data'){ options[:format] = :debug }
+  end
 
-if options[:format] == :graphviz
-  default_options[:limit] = 120
-  default_options[:node_fraction] = 0.005
-end
+  parser.parse!
+  parser.abort(parser.help) if ARGV.empty?
 
-options = default_options.merge(options)
-options.delete(:limit) if options[:limit] == 0
+  reports = []
+  while ARGV.size > 0
+    begin
+      file = ARGV.pop
+      reports << StackProf::Report.from_file(file)
+    rescue TypeError => e
+      STDERR.puts "** error parsing #{file}: #{e.inspect}"
+    end
+  end
+  report = reports.inject(:+)
 
-case options[:format]
-when :text
-  report.print_text(options[:sort], options[:limit], options[:select_files], options[:reject_files], options[:select_names], options[:reject_names])
-when :json
-  report.print_json
-when :debug
-  report.print_debug
-when :dump
-  report.print_dump
-when :callgrind
-  report.print_callgrind
-when :graphviz
-  report.print_graphviz(options)
-when :stackcollapse
-  report.print_stackcollapse
-when :timeline_flamegraph
-  report.print_timeline_flamegraph
-when :alphabetical_flamegraph
-  report.print_alphabetical_flamegraph
-when :d3_flamegraph
-  report.print_d3_flamegraph
-when :method
-  options[:walk] ? report.walk_method(options[:filter]) : report.print_method(options[:filter])
-when :file
-  report.print_file(options[:filter])
-when :files
-  report.print_files(options[:sort], options[:limit])
-else
-  raise ArgumentError, "unknown format: #{options[:format]}"
+  default_options = {
+    :format => :text,
+    :sort => false,
+    :limit => 30
+  }
+
+  if options[:format] == :graphviz
+    default_options[:limit] = 120
+    default_options[:node_fraction] = 0.005
+  end
+
+  options = default_options.merge(options)
+  options.delete(:limit) if options[:limit] == 0
+
+  case options[:format]
+  when :text
+    report.print_text(options[:sort], options[:limit], options[:select_files], options[:reject_files], options[:select_names], options[:reject_names])
+  when :json
+    report.print_json
+  when :debug
+    report.print_debug
+  when :dump
+    report.print_dump
+  when :callgrind
+    report.print_callgrind
+  when :graphviz
+    report.print_graphviz(options)
+  when :stackcollapse
+    report.print_stackcollapse
+  when :timeline_flamegraph
+    report.print_timeline_flamegraph
+  when :alphabetical_flamegraph
+    report.print_alphabetical_flamegraph
+  when :d3_flamegraph
+    report.print_d3_flamegraph
+  when :method
+    options[:walk] ? report.walk_method(options[:filter]) : report.print_method(options[:filter])
+  when :file
+    report.print_file(options[:filter])
+  when :files
+    report.print_files(options[:sort], options[:limit])
+  else
+    raise ArgumentError, "unknown format: #{options[:format]}"
+  end
 end

data/ext/stackprof/extconf.rb

@@ -1,4 +1,10 @@
 require 'mkmf'
+
+if RUBY_ENGINE == 'truffleruby'
+  File.write('Makefile', dummy_makefile($srcdir).join(""))
+  return
+end
+
 if have_func('rb_postponed_job_register_one') &&
    have_func('rb_profile_frames') &&
    have_func('rb_tracepoint_new') &&

data/ext/stackprof/stackprof.c

@@ -7,37 +7,77 @@
 **********************************************************************/
 
 #include <ruby/ruby.h>
+#include <ruby/version.h>
 #include <ruby/debug.h>
 #include <ruby/st.h>
 #include <ruby/io.h>
 #include <ruby/intern.h>
+#include <ruby/vm.h>
 #include <signal.h>
 #include <sys/time.h>
+#include <time.h>
 #include <pthread.h>
 
 #define BUF_SIZE 2048
 #define MICROSECONDS_IN_SECOND 1000000
+#define NANOSECONDS_IN_SECOND 1000000000
 
 #define FAKE_FRAME_GC    INT2FIX(0)
 #define FAKE_FRAME_MARK  INT2FIX(1)
 #define FAKE_FRAME_SWEEP INT2FIX(2)
 
-/*
- * As of Ruby 3.0, it should be safe to read stack frames at any time
- * See https://github.com/ruby/ruby/commit/0e276dc458f94d9d79a0f7c7669bde84abe80f21
- */
-#if RUBY_API_VERSION_MAJOR < 3
-  #define USE_POSTPONED_JOB
-#endif
-
 static const char *fake_frame_cstrs[] = {
 	"(garbage collection)",
 	"(marking)",
 	"(sweeping)",
 };
 
+static int stackprof_use_postponed_job = 1;
+static int ruby_vm_running = 0;
+
 #define TOTAL_FAKE_FRAMES (sizeof(fake_frame_cstrs) / sizeof(char *))
 
+#ifdef _POSIX_MONOTONIC_CLOCK
+  #define timestamp_t timespec
+  typedef struct timestamp_t timestamp_t;
+
+  static void capture_timestamp(timestamp_t *ts) {
+      clock_gettime(CLOCK_MONOTONIC, ts);
+  }
+
+  static int64_t delta_usec(timestamp_t *start, timestamp_t *end) {
+      int64_t result = MICROSECONDS_IN_SECOND * (end->tv_sec - start->tv_sec);
+      if (end->tv_nsec < start->tv_nsec) {
+	  result -= MICROSECONDS_IN_SECOND;
+	  result += (NANOSECONDS_IN_SECOND + end->tv_nsec - start->tv_nsec) / 1000;
+      } else {
+	  result += (end->tv_nsec - start->tv_nsec) / 1000;
+      }
+      return result;
+  }
+
+  static uint64_t timestamp_usec(timestamp_t *ts) {
+      return (MICROSECONDS_IN_SECOND * ts->tv_sec) + (ts->tv_nsec / 1000);
+  }
+#else
+  #define timestamp_t timeval
+  typedef struct timestamp_t timestamp_t;
+
+  static void capture_timestamp(timestamp_t *ts) {
+      gettimeofday(ts, NULL);
+  }
+
+  static int64_t delta_usec(timestamp_t *start, timestamp_t *end) {
+      struct timeval diff;
+      timersub(end, start, &diff);
+      return (MICROSECONDS_IN_SECOND * diff.tv_sec) + diff.tv_usec;
+  }
+
+  static uint64_t timestamp_usec(timestamp_t *ts) {
+      return (MICROSECONDS_IN_SECOND * ts.tv_sec) + diff.tv_usec
+  }
+#endif
+
 typedef struct {
     size_t total_samples;
     size_t caller_samples;
@@ -46,6 +86,11 @@ typedef struct {
     st_table *lines;
 } frame_data_t;
 
+typedef struct {
+    uint64_t timestamp_usec;
+    int64_t delta_usec;
+} sample_time_t;
+
 static struct {
     int running;
     int raw;
@@ -62,10 +107,10 @@ static struct {
     size_t raw_samples_capa;
     size_t raw_sample_index;
 
-    struct timeval last_sample_at;
-    int *raw_timestamp_deltas;
-    size_t raw_timestamp_deltas_len;
-    size_t raw_timestamp_deltas_capa;
+    struct timestamp_t last_sample_at;
+    sample_time_t *raw_sample_times;
+    size_t raw_sample_times_len;
+    size_t raw_sample_times_capa;
 
     size_t overall_signals;
     size_t overall_samples;
@@ -77,14 +122,19 @@ static struct {
 
     VALUE fake_frame_names[TOTAL_FAKE_FRAMES];
     VALUE empty_string;
+
+    int buffer_count;
+    sample_time_t buffer_time;
     VALUE frames_buffer[BUF_SIZE];
     int lines_buffer[BUF_SIZE];
+
+    pthread_t target_thread;
 } _stackprof;
 
 static VALUE sym_object, sym_wall, sym_cpu, sym_custom, sym_name, sym_file, sym_line;
 static VALUE sym_samples, sym_total_samples, sym_missed_samples, sym_edges, sym_lines;
 static VALUE sym_version, sym_mode, sym_interval, sym_raw, sym_metadata, sym_frames, sym_ignore_gc, sym_out;
-static VALUE sym_aggregate, sym_raw_timestamp_deltas, sym_state, sym_marking, sym_sweeping;
+static VALUE sym_aggregate, sym_raw_sample_timestamps, sym_raw_timestamp_deltas, sym_state, sym_marking, sym_sweeping;
 static VALUE sym_gc_samples, objtracer;
 static VALUE gc_hook;
 static VALUE rb_mStackProf;
@@ -100,6 +150,7 @@ stackprof_start(int argc, VALUE *argv, VALUE self)
     VALUE opts = Qnil, mode = Qnil, interval = Qnil, metadata = rb_hash_new(), out = Qfalse;
     int ignore_gc = 0;
     int raw = 0, aggregate = 1;
+    VALUE metadata_val;
 
     if (_stackprof.running)
 	return Qfalse;
@@ -114,7 +165,7 @@ stackprof_start(int argc, VALUE *argv, VALUE self)
 	    ignore_gc = 1;
 	}
 
-	VALUE metadata_val = rb_hash_aref(opts, sym_metadata);
+	metadata_val = rb_hash_aref(opts, sym_metadata);
 	if (RTEST(metadata_val)) {
 	    if (!RB_TYPE_P(metadata_val, T_HASH))
 		rb_raise(rb_eArgError, "metadata should be a hash");
@@ -172,9 +223,10 @@ stackprof_start(int argc, VALUE *argv, VALUE self)
     _stackprof.ignore_gc = ignore_gc;
     _stackprof.metadata = metadata;
     _stackprof.out = out;
+    _stackprof.target_thread = pthread_self();
 
     if (raw) {
-	gettimeofday(&_stackprof.last_sample_at, NULL);
+	capture_timestamp(&_stackprof.last_sample_at);
     }
 
     return Qtrue;
@@ -209,13 +261,19 @@ stackprof_stop(VALUE self)
     return Qtrue;
 }
 
+#if SIZEOF_VOIDP == SIZEOF_LONG
+#  define PTR2NUM(x) (LONG2NUM((long)(x)))
+#else
+#  define PTR2NUM(x) (LL2NUM((LONG_LONG)(x)))
+#endif
+
 static int
 frame_edges_i(st_data_t key, st_data_t val, st_data_t arg)
 {
     VALUE edges = (VALUE)arg;
 
     intptr_t weight = (intptr_t)val;
-    rb_hash_aset(edges, rb_obj_id((VALUE)key), INT2FIX(weight));
+    rb_hash_aset(edges, PTR2NUM(key), INT2FIX(weight));
     return ST_CONTINUE;
 }
 
@@ -242,7 +300,7 @@ frame_i(st_data_t key, st_data_t val, st_data_t arg)
     VALUE name, file, edges, lines;
     VALUE line;
 
-    rb_hash_aset(results, rb_obj_id(frame), details);
+    rb_hash_aset(results, PTR2NUM(frame), details);
 
     if (FIXNUM_P(frame)) {
 	name = _stackprof.fake_frame_names[FIX2INT(frame)];
@@ -314,7 +372,7 @@ stackprof_results(int argc, VALUE *argv, VALUE self)
 
     if (_stackprof.raw && _stackprof.raw_samples_len) {
 	size_t len, n, o;
-	VALUE raw_timestamp_deltas;
+	VALUE raw_sample_timestamps, raw_timestamp_deltas;
 	VALUE raw_samples = rb_ary_new_capa(_stackprof.raw_samples_len);
 
 	for (n = 0; n < _stackprof.raw_samples_len; n++) {
@@ -322,7 +380,7 @@ stackprof_results(int argc, VALUE *argv, VALUE self)
 	    rb_ary_push(raw_samples, SIZET2NUM(len));
 
 	    for (o = 0, n++; o < len; n++, o++)
-		rb_ary_push(raw_samples, rb_obj_id(_stackprof.raw_samples[n]));
+		rb_ary_push(raw_samples, PTR2NUM(_stackprof.raw_samples[n]));
 	    rb_ary_push(raw_samples, SIZET2NUM((size_t)_stackprof.raw_samples[n]));
 	}
 
@@ -334,17 +392,20 @@ stackprof_results(int argc, VALUE *argv, VALUE self)
 
 	rb_hash_aset(results, sym_raw, raw_samples);
 
-	raw_timestamp_deltas = rb_ary_new_capa(_stackprof.raw_timestamp_deltas_len);
+	raw_sample_timestamps = rb_ary_new_capa(_stackprof.raw_sample_times_len);
+	raw_timestamp_deltas = rb_ary_new_capa(_stackprof.raw_sample_times_len);
 
-	for (n = 0; n < _stackprof.raw_timestamp_deltas_len; n++) {
-	    rb_ary_push(raw_timestamp_deltas, INT2FIX(_stackprof.raw_timestamp_deltas[n]));
+	for (n = 0; n < _stackprof.raw_sample_times_len; n++) {
+	    rb_ary_push(raw_sample_timestamps, ULL2NUM(_stackprof.raw_sample_times[n].timestamp_usec));
+	    rb_ary_push(raw_timestamp_deltas, LL2NUM(_stackprof.raw_sample_times[n].delta_usec));
 	}
 
-	free(_stackprof.raw_timestamp_deltas);
-	_stackprof.raw_timestamp_deltas = NULL;
-	_stackprof.raw_timestamp_deltas_len = 0;
-	_stackprof.raw_timestamp_deltas_capa = 0;
+	free(_stackprof.raw_sample_times);
+	_stackprof.raw_sample_times = NULL;
+	_stackprof.raw_sample_times_len = 0;
+	_stackprof.raw_sample_times_capa = 0;
 
+	rb_hash_aset(results, sym_raw_sample_timestamps, raw_sample_timestamps);
 	rb_hash_aset(results, sym_raw_timestamp_deltas, raw_timestamp_deltas);
 
 	_stackprof.raw = 0;
@@ -424,14 +485,14 @@ st_numtable_increment(st_table *table, st_data_t key, size_t increment)
 }
 
 void
-stackprof_record_sample_for_stack(int num, int timestamp_delta)
+stackprof_record_sample_for_stack(int num, uint64_t sample_timestamp, int64_t timestamp_delta)
 {
     int i, n;
     VALUE prev_frame = Qnil;
 
     _stackprof.overall_samples++;
 
-    if (_stackprof.raw) {
+    if (_stackprof.raw && num > 0) {
 	int found = 0;
 
 	/* If there's no sample buffer allocated, then allocate one.  The buffer
@@ -483,20 +544,23 @@ stackprof_record_sample_for_stack(int num, int timestamp_delta)
 	}
 
 	/* If there's no timestamp delta buffer, allocate one */
-	if (!_stackprof.raw_timestamp_deltas) {
-	    _stackprof.raw_timestamp_deltas_capa = 100;
-	    _stackprof.raw_timestamp_deltas = malloc(sizeof(int) * _stackprof.raw_timestamp_deltas_capa);
-	    _stackprof.raw_timestamp_deltas_len = 0;
+	if (!_stackprof.raw_sample_times) {
+	    _stackprof.raw_sample_times_capa = 100;
+	    _stackprof.raw_sample_times = malloc(sizeof(sample_time_t) * _stackprof.raw_sample_times_capa);
+	    _stackprof.raw_sample_times_len = 0;
 	}
 
 	/* Double the buffer size if it's too small */
-	while (_stackprof.raw_timestamp_deltas_capa <= _stackprof.raw_timestamp_deltas_len + 1) {
-	    _stackprof.raw_timestamp_deltas_capa *= 2;
-	    _stackprof.raw_timestamp_deltas = realloc(_stackprof.raw_timestamp_deltas, sizeof(int) * _stackprof.raw_timestamp_deltas_capa);
+	while (_stackprof.raw_sample_times_capa <= _stackprof.raw_sample_times_len + 1) {
+	    _stackprof.raw_sample_times_capa *= 2;
+	    _stackprof.raw_sample_times = realloc(_stackprof.raw_sample_times, sizeof(sample_time_t) * _stackprof.raw_sample_times_capa);
 	}
 
-	/* Store the time delta (which is the amount of time between samples) */
-	_stackprof.raw_timestamp_deltas[_stackprof.raw_timestamp_deltas_len++] = timestamp_delta;
+	/* Store the time delta (which is the amount of microseconds between samples). */
+	_stackprof.raw_sample_times[_stackprof.raw_sample_times_len++] = (sample_time_t) {
+	    .timestamp_usec = sample_timestamp,
+	    .delta_usec = timestamp_delta,
+        };
     }
 
     for (i = 0; i < num; i++) {
@@ -529,48 +593,60 @@ stackprof_record_sample_for_stack(int num, int timestamp_delta)
     }
 
     if (_stackprof.raw) {
-	gettimeofday(&_stackprof.last_sample_at, NULL);
+	capture_timestamp(&_stackprof.last_sample_at);
     }
 }
 
+// buffer the current profile frames
+// This must be async-signal-safe
+// Returns immediately if another set of frames are already in the buffer
 void
-stackprof_record_sample()
+stackprof_buffer_sample(void)
 {
-    int timestamp_delta = 0;
+    uint64_t start_timestamp = 0;
+    int64_t timestamp_delta = 0;
     int num;
+
+    if (_stackprof.buffer_count > 0) {
+	// Another sample is already pending
+	return;
+    }
+
     if (_stackprof.raw) {
-	struct timeval t;
-	struct timeval diff;
-	gettimeofday(&t, NULL);
-	timersub(&t, &_stackprof.last_sample_at, &diff);
-	timestamp_delta = (1000 * diff.tv_sec) + diff.tv_usec;
+	struct timestamp_t t;
+	capture_timestamp(&t);
+	start_timestamp = timestamp_usec(&t);
+	timestamp_delta = delta_usec(&_stackprof.last_sample_at, &t);
     }
+
     num = rb_profile_frames(0, sizeof(_stackprof.frames_buffer) / sizeof(VALUE), _stackprof.frames_buffer, _stackprof.lines_buffer);
-    stackprof_record_sample_for_stack(num, timestamp_delta);
+
+    _stackprof.buffer_count = num;
+    _stackprof.buffer_time.timestamp_usec = start_timestamp;
+    _stackprof.buffer_time.delta_usec = timestamp_delta;
 }
 
 void
-stackprof_record_gc_samples()
+stackprof_record_gc_samples(void)
 {
-    int delta_to_first_unrecorded_gc_sample = 0;
-    int i;
+    int64_t delta_to_first_unrecorded_gc_sample = 0;
+    uint64_t start_timestamp = 0;
+    size_t i;
     if (_stackprof.raw) {
-	struct timeval t;
-	struct timeval diff;
-	gettimeofday(&t, NULL);
-	timersub(&t, &_stackprof.last_sample_at, &diff);
+	struct timestamp_t t;
+	capture_timestamp(&t);
+	start_timestamp = timestamp_usec(&t);
 
 	// We don't know when the GC samples were actually marked, so let's
 	// assume that they were marked at a perfectly regular interval.
-	delta_to_first_unrecorded_gc_sample = (1000 * diff.tv_sec + diff.tv_usec) - (_stackprof.unrecorded_gc_samples - 1) * NUM2LONG(_stackprof.interval);
+	delta_to_first_unrecorded_gc_sample = delta_usec(&_stackprof.last_sample_at, &t) - (_stackprof.unrecorded_gc_samples - 1) * NUM2LONG(_stackprof.interval);
 	if (delta_to_first_unrecorded_gc_sample < 0) {
 	    delta_to_first_unrecorded_gc_sample = 0;
 	}
     }
 
-
     for (i = 0; i < _stackprof.unrecorded_gc_samples; i++) {
-	int timestamp_delta = i == 0 ? delta_to_first_unrecorded_gc_sample : NUM2LONG(_stackprof.interval);
+	int64_t timestamp_delta = i == 0 ? delta_to_first_unrecorded_gc_sample : NUM2LONG(_stackprof.interval);
 
       if (_stackprof.unrecorded_gc_marking_samples) {
         _stackprof.frames_buffer[0] = FAKE_FRAME_MARK;
@@ -579,7 +655,7 @@ stackprof_record_gc_samples()
         _stackprof.lines_buffer[1] = 0;
         _stackprof.unrecorded_gc_marking_samples--;
 
-        stackprof_record_sample_for_stack(2, timestamp_delta);
+        stackprof_record_sample_for_stack(2, start_timestamp, timestamp_delta);
       } else if (_stackprof.unrecorded_gc_sweeping_samples) {
         _stackprof.frames_buffer[0] = FAKE_FRAME_SWEEP;
         _stackprof.lines_buffer[0] = 0;
@@ -588,11 +664,11 @@ stackprof_record_gc_samples()
 
         _stackprof.unrecorded_gc_sweeping_samples--;
 
-        stackprof_record_sample_for_stack(2, timestamp_delta);
+        stackprof_record_sample_for_stack(2, start_timestamp, timestamp_delta);
       } else {
         _stackprof.frames_buffer[0] = FAKE_FRAME_GC;
         _stackprof.lines_buffer[0] = 0;
-        stackprof_record_sample_for_stack(1, timestamp_delta);
+        stackprof_record_sample_for_stack(1, start_timestamp, timestamp_delta);
       }
     }
     _stackprof.during_gc += _stackprof.unrecorded_gc_samples;
@@ -601,8 +677,25 @@ stackprof_record_gc_samples()
     _stackprof.unrecorded_gc_sweeping_samples = 0;
 }
 
+// record the sample previously buffered by stackprof_buffer_sample
+static void
+stackprof_record_buffer(void)
+{
+    stackprof_record_sample_for_stack(_stackprof.buffer_count, _stackprof.buffer_time.timestamp_usec, _stackprof.buffer_time.delta_usec);
+
+    // reset the buffer
+    _stackprof.buffer_count = 0;
+}
+
+static void
+stackprof_sample_and_record(void)
+{
+    stackprof_buffer_sample();
+    stackprof_record_buffer();
+}
+
 static void
-stackprof_gc_job_handler(void *data)
+stackprof_job_record_gc(void *data)
 {
     if (!_stackprof.running) return;
 
@@ -610,11 +703,19 @@ stackprof_gc_job_handler(void *data)
 }
 
 static void
-stackprof_job_handler(void *data)
+stackprof_job_sample_and_record(void *data)
 {
     if (!_stackprof.running) return;
 
-    stackprof_record_sample();
+    stackprof_sample_and_record();
+}
+
+static void
+stackprof_job_record_buffer(void *data)
+{
+    if (!_stackprof.running) return;
+
+    stackprof_record_buffer();
 }
 
 static void
@@ -625,7 +726,27 @@ stackprof_signal_handler(int sig, siginfo_t *sinfo, void *ucontext)
     _stackprof.overall_signals++;
 
     if (!_stackprof.running) return;
-    if (!ruby_native_thread_p()) return;
+
+    // There's a possibility that the signal handler is invoked *after* the Ruby
+    // VM has been shut down (e.g. after ruby_cleanup(0)). In this case, things
+    // that rely on global VM state (e.g. rb_during_gc) will segfault.
+    if (!ruby_vm_running) return;
+
+    if (_stackprof.mode == sym_wall) {
+        // In "wall" mode, the SIGALRM signal will arrive at an arbitrary thread.
+        // In order to provide more useful results, especially under threaded web
+        // servers, we want to forward this signal to the original thread
+        // StackProf was started from.
+        // According to POSIX.1-2008 TC1 pthread_kill and pthread_self should be
+        // async-signal-safe.
+        if (pthread_self() != _stackprof.target_thread) {
+            pthread_kill(_stackprof.target_thread, sig);
+            return;
+        }
+    } else {
+        if (!ruby_native_thread_p()) return;
+    }
+
     if (pthread_mutex_trylock(&lock)) return;
 
     if (!_stackprof.ignore_gc && rb_during_gc()) {
@@ -636,13 +757,17 @@ stackprof_signal_handler(int sig, siginfo_t *sinfo, void *ucontext)
 	    _stackprof.unrecorded_gc_sweeping_samples++;
 	}
 	_stackprof.unrecorded_gc_samples++;
-	rb_postponed_job_register_one(0, stackprof_gc_job_handler, (void*)0);
+	rb_postponed_job_register_one(0, stackprof_job_record_gc, (void*)0);
     } else {
-#ifdef USE_POSTPONED_JOB
-	rb_postponed_job_register_one(0, stackprof_job_handler, (void*)0);
-#else
-	stackprof_job_handler(0);
-#endif
+        if (stackprof_use_postponed_job) {
+            rb_postponed_job_register_one(0, stackprof_job_sample_and_record, (void*)0);
+        } else {
+            // Buffer a sample immediately, if an existing sample exists this will
+            // return immediately
+            stackprof_buffer_sample();
+            // Enqueue a job to record the sample
+            rb_postponed_job_register_one(0, stackprof_job_record_buffer, (void*)0);
+        }
     }
     pthread_mutex_unlock(&lock);
 }
@@ -653,7 +778,7 @@ stackprof_newobj_handler(VALUE tpval, void *data)
     _stackprof.overall_signals++;
     if (RTEST(_stackprof.interval) && _stackprof.overall_signals % NUM2LONG(_stackprof.interval))
 	return;
-    stackprof_job_handler(0);
+    stackprof_sample_and_record();
 }
 
 static VALUE
@@ -663,7 +788,7 @@ stackprof_sample(VALUE self)
 	return Qfalse;
 
     _stackprof.overall_signals++;
-    stackprof_job_handler(0);
+    stackprof_sample_and_record();
     return Qtrue;
 }
 
@@ -720,10 +845,32 @@ stackprof_atfork_child(void)
     stackprof_stop(rb_mStackProf);
 }
 
+static VALUE
+stackprof_use_postponed_job_l(VALUE self)
+{
+    stackprof_use_postponed_job = 1;
+    return Qnil;
+}
+
+static void
+stackprof_at_exit(ruby_vm_t* vm)
+{
+    ruby_vm_running = 0;
+}
+
 void
 Init_stackprof(void)
 {
     size_t i;
+   /*
+    * As of Ruby 3.0, it should be safe to read stack frames at any time, unless YJIT is enabled
+    * See https://github.com/ruby/ruby/commit/0e276dc458f94d9d79a0f7c7669bde84abe80f21
+    */
+    stackprof_use_postponed_job = RUBY_API_VERSION_MAJOR < 3;
+
+    ruby_vm_running = 1;
+    ruby_vm_at_exit(stackprof_at_exit);
+
 #define S(name) sym_##name = ID2SYM(rb_intern(#name));
     S(object);
     S(custom);
@@ -742,6 +889,7 @@ Init_stackprof(void)
     S(mode);
     S(interval);
     S(raw);
+    S(raw_sample_timestamps);
     S(raw_timestamp_deltas);
     S(out);
     S(metadata);
@@ -764,9 +912,9 @@ Init_stackprof(void)
     _stackprof.raw_samples_capa = 0;
     _stackprof.raw_sample_index = 0;
 
-    _stackprof.raw_timestamp_deltas = NULL;
-    _stackprof.raw_timestamp_deltas_len = 0;
-    _stackprof.raw_timestamp_deltas_capa = 0;
+    _stackprof.raw_sample_times = NULL;
+    _stackprof.raw_sample_times_len = 0;
+    _stackprof.raw_sample_times_capa = 0;
 
     _stackprof.empty_string = rb_str_new_cstr("");
     rb_global_variable(&_stackprof.empty_string);
@@ -783,6 +931,7 @@ Init_stackprof(void)
     rb_define_singleton_method(rb_mStackProf, "stop", stackprof_stop, 0);
     rb_define_singleton_method(rb_mStackProf, "results", stackprof_results, -1);
     rb_define_singleton_method(rb_mStackProf, "sample", stackprof_sample, 0);
+    rb_define_singleton_method(rb_mStackProf, "use_postponed_job!", stackprof_use_postponed_job_l, 0);
 
     pthread_atfork(stackprof_atfork_prepare, stackprof_atfork_parent, stackprof_atfork_child);
 }

data/lib/stackprof/autorun.rb

@@ -0,0 +1,19 @@
+require "stackprof"
+
+options = {}
+options[:mode] = ENV["STACKPROF_MODE"].to_sym if ENV.key?("STACKPROF_MODE")
+options[:interval] = Integer(ENV["STACKPROF_INTERVAL"]) if ENV.key?("STACKPROF_INTERVAL")
+options[:raw] = true if ENV["STACKPROF_RAW"]
+options[:ignore_gc] = true if ENV["STACKPROF_IGNORE_GC"]
+
+at_exit do
+  StackProf.stop
+  output_path = ENV.fetch("STACKPROF_OUT") do
+    require "tempfile"
+    Tempfile.create(["stackprof", ".dump"]).path
+  end
+  StackProf.results(output_path)
+  $stderr.puts("StackProf results dumped at: #{output_path}")
+end
+
+StackProf.start(**options)

data/lib/stackprof/report.rb

@@ -1,10 +1,44 @@
 # frozen_string_literal: true
 
 require 'pp'
-require 'digest/md5'
+require 'digest/sha2'
+require 'json'
 
 module StackProf
   class Report
+    MARSHAL_SIGNATURE = "\x04\x08"
+
+    class << self
+      def from_file(file)
+        if (content = IO.binread(file)).start_with?(MARSHAL_SIGNATURE)
+          new(Marshal.load(content))
+        else
+          from_json(JSON.parse(content))
+        end
+      end
+
+      def from_json(json)
+        new(parse_json(json))
+      end
+
+      def parse_json(json)
+        json.keys.each do |key|
+          value = json.delete(key)
+          from_json(value) if value.is_a?(Hash)
+
+          new_key = case key
+          when /\A[0-9]*\z/
+            key.to_i
+          else
+            key.to_sym
+          end
+
+          json[new_key] = value
+        end
+        json
+      end
+    end
+
     def initialize(data)
       @data = data
     end
@@ -18,7 +52,7 @@ module StackProf
     def normalized_frames
       id2hash = {}
       @data[:frames].each do |frame, info|
-        id2hash[frame.to_s] = info[:hash] = Digest::MD5.hexdigest("#{info[:name]}#{info[:file]}#{info[:line]}")
+        id2hash[frame.to_s] = info[:hash] = Digest::SHA256.hexdigest("#{info[:name]}#{info[:file]}#{info[:line]}")
       end
       @data[:frames].inject(Hash.new) do |hash, (frame, info)|
         info = hash[id2hash[frame.to_s]] = info.dup
@@ -95,51 +129,10 @@ module StackProf
       print_flamegraph(f, skip_common, true)
     end
 
-    StackCursor = Struct.new(:raw, :idx, :length) do
-      def weight
-        @weight ||= raw[1 + idx + length]
-      end
-
-      def [](i)
-        if i >= length
-          nil
-        else
-          raw[1 + idx + i]
-        end
-      end
-
-      def <=>(other)
-        i = 0
-        while i < length && i < other.length
-          if self[i] != other[i]
-            return self[i] <=> other[i]
-          end
-          i += 1
-        end
-
-        return length <=> other.length
-      end
-    end
-
     def print_flamegraph(f, skip_common, alphabetical=false)
       raise "profile does not include raw samples (add `raw: true` to collecting StackProf.run)" unless raw = data[:raw]
 
-      stacks = []
-      max_x = 0
-      max_y = 0
-
-      idx = 0
-      loop do
-        len = raw[idx]
-        break unless len
-        max_y = len if len > max_y
-
-        stack = StackCursor.new(raw, idx, len)
-        stacks << stack
-        max_x += stack.weight
-
-        idx += len + 2
-      end
+      stacks, max_x, max_y = flamegraph_stacks(raw)
 
       stacks.sort! if alphabetical
 
@@ -150,7 +143,7 @@ module StackProf
         x = 0
 
         stacks.each do |stack|
-          weight = stack.weight
+          weight = stack.last
           cell = stack[y] unless y == stack.length-1
 
           if cell.nil?
@@ -191,6 +184,24 @@ module StackProf
       f.puts '])'
     end
 
+    def flamegraph_stacks(raw)
+      stacks = []
+      max_x = 0
+      max_y = 0
+      idx = 0
+
+      while len = raw[idx]
+        idx += 1
+        max_y = len if len > max_y
+        stack = raw.slice(idx, len+1)
+        idx += len+1
+        stacks << stack
+        max_x += stack.last
+      end
+
+      return stacks, max_x, max_y
+    end
+
     def flamegraph_row(f, x, y, weight, addr)
       frame = @data[:frames][addr]
       f.print ',' if @rows_started
@@ -214,7 +225,7 @@ module StackProf
           end
         else
           frame = @data[:frames][val]
-          child_name = "#{ frame[:name] } : #{ frame[:file] }"
+          child_name = "#{ frame[:name] } : #{ frame[:file] } : #{ frame[:line] }"
           child_data = convert_to_d3_flame_graph_format(child_name, child_stacks, depth + 1)
           weight += child_data["value"]
           children << child_data
@@ -231,15 +242,7 @@ module StackProf
     def print_d3_flamegraph(f=STDOUT, skip_common=true)
       raise "profile does not include raw samples (add `raw: true` to collecting StackProf.run)" unless raw = data[:raw]
 
-      stacks = []
-      max_x = 0
-      max_y = 0
-      while len = raw.shift
-        max_y = len if len > max_y
-        stack = raw.slice!(0, len+1)
-        stacks << stack
-        max_x += stack.last
-      end
+      stacks, * = flamegraph_stacks(raw)
 
       # d3-flame-grpah supports only alphabetical flamegraph
       stacks.sort!

data/lib/stackprof/truffleruby.rb

@@ -0,0 +1,37 @@
+module StackProf
+  # Define the same methods as stackprof.c
+  class << self
+    def running?
+      false
+    end
+
+    def run(*args)
+      unimplemented
+    end
+
+    def start(*args)
+      unimplemented
+    end
+
+    def stop
+      unimplemented
+    end
+
+    def results(*args)
+      unimplemented
+    end
+
+    def sample
+      unimplemented
+    end
+
+    def use_postponed_job!
+      # noop
+    end
+
+    private def unimplemented
+      raise "Use --cpusampler=flamegraph or --cpusampler instead of StackProf on TruffleRuby.\n" \
+            "See https://www.graalvm.org/tools/profiling/ and `ruby --help:cpusampler` for more details."
+    end
+  end
+end

data/lib/stackprof.rb

@@ -1,7 +1,20 @@
-require "stackprof/stackprof"
+if RUBY_ENGINE == 'truffleruby'
+  require "stackprof/truffleruby"
+else
+  require "stackprof/stackprof"
+end
+
+if defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?
+  StackProf.use_postponed_job!
+elsif RUBY_VERSION == "3.2.0"
+  # 3.2.0 crash is the signal is received at the wrong time.
+  # Fixed in https://github.com/ruby/ruby/pull/7116
+  # The fix is backported in 3.2.1: https://bugs.ruby-lang.org/issues/19336
+  StackProf.use_postponed_job!
+end
 
 module StackProf
-  VERSION = '0.2.17'
+  VERSION = '0.2.24'
 end
 
 StackProf.autoload :Report, "stackprof/report.rb"

data/stackprof.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = 'stackprof'
-  s.version = '0.2.17'
+  s.version = '0.2.24'
   s.homepage = 'http://github.com/tmm1/stackprof'
 
   s.authors = 'Aman Gupta'

data/test/fixtures/profile.dump

@@ -0,0 +1 @@
+{:	modeI"cpu:ET

data/test/fixtures/profile.json

@@ -0,0 +1 @@
+{ "mode": "cpu" }

data/test/test_report.rb

@@ -32,3 +32,27 @@ class ReportDumpTest < MiniTest::Test
     assert_equal expected, Marshal.load(marshal_data)
   end
 end
+
+class ReportReadTest < MiniTest::Test
+  require 'pathname'
+
+  def test_from_file_read_json
+    file = fixture("profile.json")
+    report = StackProf::Report.from_file(file)
+
+    assert_equal({ mode: "cpu" }, report.data)
+  end
+
+  def test_from_file_read_marshal
+    file = fixture("profile.dump")
+    report = StackProf::Report.from_file(file)
+
+    assert_equal({ mode: "cpu" }, report.data)
+  end
+
+  private
+
+  def fixture(name)
+    Pathname.new(__dir__).join("fixtures", name)
+  end
+end

data/test/test_stackprof.rb

@@ -5,6 +5,10 @@ require 'tempfile'
 require 'pathname'
 
 class StackProfTest < MiniTest::Test
+  def setup
+    Object.new # warm some caches to avoid flakiness
+  end
+
   def test_info
     profile = StackProf.run{}
     assert_equal 1.2, profile[:version]
@@ -78,9 +82,14 @@ class StackProfTest < MiniTest::Test
     end
 
     assert_operator profile[:samples], :>=, 1
-    offset = RUBY_VERSION >= '3' ? 1 : 0
-    frame = profile[:frames].values[offset]
-    assert_includes frame[:name], "StackProfTest#math"
+    if RUBY_VERSION >= '3'
+      assert profile[:frames].values.take(2).map { |f|
+        f[:name].include? "StackProfTest#math"
+      }.any?
+    else
+      frame = profile[:frames].values.first
+      assert_includes frame[:name], "StackProfTest#math"
+    end
   end
 
   def test_walltime
@@ -121,19 +130,38 @@ class StackProfTest < MiniTest::Test
   end
 
   def test_raw
+    before_monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+
     profile = StackProf.run(mode: :custom, raw: true) do
       10.times do
         StackProf.sample
+        sleep 0.0001
       end
     end
 
+    after_monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+
     raw = profile[:raw]
     assert_equal 10, raw[-1]
     assert_equal raw[0] + 2, raw.size
 
     offset = RUBY_VERSION >= '3' ? -3 : -2
     assert_includes profile[:frames][raw[offset]][:name], 'StackProfTest#test_raw'
+
+    assert_equal 10, profile[:raw_sample_timestamps].size
+    profile[:raw_sample_timestamps].each_cons(2) do |t1, t2|
+      assert_operator t1, :>, before_monotonic
+      assert_operator t2, :>=, t1
+      assert_operator t2, :<, after_monotonic
+    end
+
     assert_equal 10, profile[:raw_timestamp_deltas].size
+    total_duration = after_monotonic - before_monotonic
+    assert_operator profile[:raw_timestamp_deltas].inject(&:+), :<, total_duration
+
+    profile[:raw_timestamp_deltas].each do |delta|
+      assert_operator delta, :>, 0
+    end
   end
 
   def test_metadata
@@ -205,7 +233,6 @@ class StackProfTest < MiniTest::Test
       end
     end
 
-    raw = profile[:raw]
     gc_frame = profile[:frames].values.find{ |f| f[:name] == "(garbage collection)" }
     marking_frame = profile[:frames].values.find{ |f| f[:name] == "(marking)" }
     sweeping_frame = profile[:frames].values.find{ |f| f[:name] == "(sweeping)" }
@@ -281,4 +308,4 @@ class StackProfTest < MiniTest::Test
     r.close
     w.close
   end
-end
+end unless RUBY_ENGINE == 'truffleruby'

data/test/test_truffleruby.rb

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'stackprof'
+require 'minitest/autorun'
+
+if RUBY_ENGINE == 'truffleruby'
+  class StackProfTruffleRubyTest < MiniTest::Test
+    def test_error
+      error = assert_raises RuntimeError do
+        StackProf.run(mode: :cpu) do
+          unreacheable
+        end
+      end
+
+      assert_match(/TruffleRuby/, error.message)
+      assert_match(/--cpusampler/, error.message)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stackprof
 version: !ruby/object:Gem::Version
-  version: 0.2.17
+  version: 0.2.24
 platform: ruby
 authors:
 - Aman Gupta
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-05-03 00:00:00.000000000 Z
+date: 2023-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -76,15 +76,20 @@ files:
 - ext/stackprof/extconf.rb
 - ext/stackprof/stackprof.c
 - lib/stackprof.rb
+- lib/stackprof/autorun.rb
 - lib/stackprof/flamegraph/flamegraph.js
 - lib/stackprof/flamegraph/viewer.html
 - lib/stackprof/middleware.rb
 - lib/stackprof/report.rb
+- lib/stackprof/truffleruby.rb
 - sample.rb
 - stackprof.gemspec
+- test/fixtures/profile.dump
+- test/fixtures/profile.json
 - test/test_middleware.rb
 - test/test_report.rb
 - test/test_stackprof.rb
+- test/test_truffleruby.rb
 - vendor/FlameGraph/README
 - vendor/FlameGraph/flamegraph.pl
 - vendor/gprof2dot/gprof2dot.py
@@ -94,10 +99,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/tmm1/stackprof/issues
-  changelog_uri: https://github.com/tmm1/stackprof/blob/v0.2.17/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/stackprof/0.2.17
-  source_code_uri: https://github.com/tmm1/stackprof/tree/v0.2.17
-post_install_message:
+  changelog_uri: https://github.com/tmm1/stackprof/blob/v0.2.24/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/stackprof/0.2.24
+  source_code_uri: https://github.com/tmm1/stackprof/tree/v0.2.24
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -112,8 +117,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: sampling callstack-profiler for ruby 2.2+
 test_files: []