stackprof 0.2.25 → 0.2.27

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b299eb696cf0c2748e931532afab3f90bab1c94447ff1c844bce0eda878a93c6
-  data.tar.gz: bd2c389baa8253fc06beda425abc87762b9bca425c6bc5046655610fb9852e79
+  metadata.gz: f919a966335bef57faaa01c783e1b204c435a2ba1d35f03ff6bf33302dfe34c9
+  data.tar.gz: 679b2bc9c1cc4c9f89638e5ab05c864cb8e9bf10f53e6ae2047cfc835575eb5a
 SHA512:
-  metadata.gz: 322e506fc77bd964f39e7b3f0c5584e57efdec8e1dcc432cdea924536e334234d916a1d5e1ff085e2e5210a49751897ca36a4b1bd007468a5b16184151129be3
-  data.tar.gz: 3234d4159c78119a9238200d1f4516280cbd1e0cfe3affca1c4fa4827b805ecf154e38857c917fafe7aed042d67525bb7e6c5fce85a039e30cde4672ae08f97e
+  metadata.gz: fb21acb48e4ea36eed09b5e82bb2780941a30ce973430acb10184df16893179dfd1d8e5092d546f1814b947d0693f10d2dacd526a4383b1b61cd64f75379b3f4
+  data.tar.gz: '08112358f745eeacf16b4df2ca4627daccf2ee5fefc31975530859891a57049148025f36f63bd72fed1bb6a1650a0837a9a5a8e4ba6e506c912c5abdd0d9ab38'

data/.github/workflows/ci.yml

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

data/ext/stackprof/stackprof.c

@@ -91,7 +91,19 @@ typedef struct {
     int64_t delta_usec;
 } sample_time_t;
 
+/* We need to ensure that various memory operations are visible across
+ * threads.  Ruby doesn't offer a portable way to do this sort of detection
+ * across all the Ruby versions we support, so we use something that casts a
+ * wide net (Clang, along with ICC, defines __GNUC__). */
+#if defined(__GNUC__) && defined(__ATOMIC_SEQ_CST)
+#define STACKPROF_HAVE_ATOMICS 1
+#else
+#define STACKPROF_HAVE_ATOMICS 0
+#endif
+
 static struct {
+    /* Access this field with the `STACKPROF_RUNNING` macro, below, since we
+     * can't properly express that this field has an atomic type. */
     int running;
     int raw;
     int aggregate;
@@ -102,7 +114,7 @@ static struct {
     VALUE metadata;
     int ignore_gc;
 
-    VALUE *raw_samples;
+    uint64_t *raw_samples;
     size_t raw_samples_len;
     size_t raw_samples_capa;
     size_t raw_sample_index;
@@ -120,6 +132,8 @@ static struct {
     size_t unrecorded_gc_sweeping_samples;
     st_table *frames;
 
+    timestamp_t gc_start_timestamp;
+
     VALUE fake_frame_names[TOTAL_FAKE_FRAMES];
     VALUE empty_string;
 
@@ -131,9 +145,15 @@ static struct {
     pthread_t target_thread;
 } _stackprof;
 
+#if STACKPROF_HAVE_ATOMICS
+#define STACKPROF_RUNNING() __atomic_load_n(&_stackprof.running, __ATOMIC_ACQUIRE)
+#else
+#define STACKPROF_RUNNING() _stackprof.running
+#endif
+
 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_version, sym_mode, sym_interval, sym_raw, sym_raw_lines, sym_metadata, sym_frames, sym_ignore_gc, sym_out;
 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;
@@ -152,7 +172,7 @@ stackprof_start(int argc, VALUE *argv, VALUE self)
     int raw = 0, aggregate = 1;
     VALUE metadata_val;
 
-    if (_stackprof.running)
+    if (STACKPROF_RUNNING())
 	return Qfalse;
 
     rb_scan_args(argc, argv, "0:", &opts);
@@ -215,7 +235,6 @@ stackprof_start(int argc, VALUE *argv, VALUE self)
 	rb_raise(rb_eArgError, "unknown profiler mode");
     }
 
-    _stackprof.running = 1;
     _stackprof.raw = raw;
     _stackprof.aggregate = aggregate;
     _stackprof.mode = mode;
@@ -224,6 +243,13 @@ stackprof_start(int argc, VALUE *argv, VALUE self)
     _stackprof.metadata = metadata;
     _stackprof.out = out;
     _stackprof.target_thread = pthread_self();
+    /* We need to ensure previous initialization stores are visible across
+     * threads. */
+#if STACKPROF_HAVE_ATOMICS
+    __atomic_store_n(&_stackprof.running, 1, __ATOMIC_SEQ_CST);
+#else
+    _stackprof.running = 1;
+#endif
 
     if (raw) {
 	capture_timestamp(&_stackprof.last_sample_at);
@@ -238,9 +264,15 @@ stackprof_stop(VALUE self)
     struct sigaction sa;
     struct itimerval timer;
 
+#if STACKPROF_HAVE_ATOMICS
+    int was_running = __atomic_exchange_n(&_stackprof.running, 0, __ATOMIC_SEQ_CST);
+    if (!was_running)
+        return Qfalse;
+#else
     if (!_stackprof.running)
 	return Qfalse;
     _stackprof.running = 0;
+#endif
 
     if (_stackprof.mode == sym_object) {
 	rb_tracepoint_disable(objtracer);
@@ -349,7 +381,7 @@ stackprof_results(int argc, VALUE *argv, VALUE self)
 {
     VALUE results, frames;
 
-    if (!_stackprof.frames || _stackprof.running)
+    if (!_stackprof.frames || STACKPROF_RUNNING())
 	return Qnil;
 
     results = rb_hash_new();
@@ -374,14 +406,23 @@ stackprof_results(int argc, VALUE *argv, VALUE self)
 	size_t len, n, o;
 	VALUE raw_sample_timestamps, raw_timestamp_deltas;
 	VALUE raw_samples = rb_ary_new_capa(_stackprof.raw_samples_len);
+	VALUE raw_lines = rb_ary_new_capa(_stackprof.raw_samples_len);
 
 	for (n = 0; n < _stackprof.raw_samples_len; n++) {
 	    len = (size_t)_stackprof.raw_samples[n];
 	    rb_ary_push(raw_samples, SIZET2NUM(len));
+	    rb_ary_push(raw_lines, SIZET2NUM(len));
+
+	    for (o = 0, n++; o < len; n++, o++) {
+		// Line is in the upper 16 bits
+		rb_ary_push(raw_lines, INT2NUM(_stackprof.raw_samples[n] >> 48));
+
+		VALUE frame = _stackprof.raw_samples[n] & ~((uint64_t)0xFFFF << 48);
+		rb_ary_push(raw_samples, PTR2NUM(frame));
+	    }
 
-	    for (o = 0, n++; o < len; n++, o++)
-		rb_ary_push(raw_samples, PTR2NUM(_stackprof.raw_samples[n]));
 	    rb_ary_push(raw_samples, SIZET2NUM((size_t)_stackprof.raw_samples[n]));
+	    rb_ary_push(raw_lines, SIZET2NUM((size_t)_stackprof.raw_samples[n]));
 	}
 
 	free(_stackprof.raw_samples);
@@ -391,6 +432,7 @@ stackprof_results(int argc, VALUE *argv, VALUE self)
 	_stackprof.raw_sample_index = 0;
 
 	rb_hash_aset(results, sym_raw, raw_samples);
+	rb_hash_aset(results, sym_raw_lines, raw_lines);
 
 	raw_sample_timestamps = rb_ary_new_capa(_stackprof.raw_sample_times_len);
 	raw_timestamp_deltas = rb_ary_new_capa(_stackprof.raw_sample_times_len);
@@ -443,7 +485,7 @@ stackprof_run(int argc, VALUE *argv, VALUE self)
 static VALUE
 stackprof_running_p(VALUE self)
 {
-    return _stackprof.running ? Qtrue : Qfalse;
+    return STACKPROF_RUNNING() ? Qtrue : Qfalse;
 }
 
 static inline frame_data_t *
@@ -520,7 +562,12 @@ stackprof_record_sample_for_stack(int num, uint64_t sample_timestamp, int64_t ti
 	     * in the frames buffer that came from Ruby. */
 	    for (i = num-1, n = 0; i >= 0; i--, n++) {
 		VALUE frame = _stackprof.frames_buffer[i];
-		if (_stackprof.raw_samples[_stackprof.raw_sample_index + 1 + n] != frame)
+		int line = _stackprof.lines_buffer[i];
+
+		// Encode the line in to the upper 16 bits.
+		uint64_t key = ((uint64_t)line << 48) | (uint64_t)frame;
+
+		if (_stackprof.raw_samples[_stackprof.raw_sample_index + 1 + n] != key)
 		    break;
 	    }
 	    if (i == -1) {
@@ -538,7 +585,12 @@ stackprof_record_sample_for_stack(int num, uint64_t sample_timestamp, int64_t ti
 	    _stackprof.raw_samples[_stackprof.raw_samples_len++] = (VALUE)num;
 	    for (i = num-1; i >= 0; i--) {
 		VALUE frame = _stackprof.frames_buffer[i];
-		_stackprof.raw_samples[_stackprof.raw_samples_len++] = frame;
+		int line = _stackprof.lines_buffer[i];
+
+		// Encode the line in to the upper 16 bits.
+		uint64_t key = ((uint64_t)line << 48) | (uint64_t)frame;
+
+		_stackprof.raw_samples[_stackprof.raw_samples_len++] = key;
 	    }
 	    _stackprof.raw_samples[_stackprof.raw_samples_len++] = (VALUE)1;
 	}
@@ -626,6 +678,7 @@ stackprof_buffer_sample(void)
     _stackprof.buffer_time.delta_usec = timestamp_delta;
 }
 
+// Postponed job
 void
 stackprof_record_gc_samples(void)
 {
@@ -633,8 +686,7 @@ stackprof_record_gc_samples(void)
     uint64_t start_timestamp = 0;
     size_t i;
     if (_stackprof.raw) {
-	struct timestamp_t t;
-	capture_timestamp(&t);
+	struct timestamp_t t = _stackprof.gc_start_timestamp;
 	start_timestamp = timestamp_usec(&t);
 
 	// We don't know when the GC samples were actually marked, so let's
@@ -697,7 +749,7 @@ stackprof_sample_and_record(void)
 static void
 stackprof_job_record_gc(void *data)
 {
-    if (!_stackprof.running) return;
+    if (!STACKPROF_RUNNING()) return;
 
     stackprof_record_gc_samples();
 }
@@ -705,7 +757,7 @@ stackprof_job_record_gc(void *data)
 static void
 stackprof_job_sample_and_record(void *data)
 {
-    if (!_stackprof.running) return;
+    if (!STACKPROF_RUNNING()) return;
 
     stackprof_sample_and_record();
 }
@@ -713,7 +765,7 @@ stackprof_job_sample_and_record(void *data)
 static void
 stackprof_job_record_buffer(void *data)
 {
-    if (!_stackprof.running) return;
+    if (!STACKPROF_RUNNING()) return;
 
     stackprof_record_buffer();
 }
@@ -725,7 +777,7 @@ stackprof_signal_handler(int sig, siginfo_t *sinfo, void *ucontext)
 
     _stackprof.overall_signals++;
 
-    if (!_stackprof.running) return;
+    if (!STACKPROF_RUNNING()) 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
@@ -756,6 +808,10 @@ stackprof_signal_handler(int sig, siginfo_t *sinfo, void *ucontext)
 	} else if (mode == sym_sweeping) {
 	    _stackprof.unrecorded_gc_sweeping_samples++;
 	}
+	if(!_stackprof.unrecorded_gc_samples) {
+	    // record start
+	    capture_timestamp(&_stackprof.gc_start_timestamp);
+	}
 	_stackprof.unrecorded_gc_samples++;
 	rb_postponed_job_register_one(0, stackprof_job_record_gc, (void*)0);
     } else {
@@ -784,7 +840,7 @@ stackprof_newobj_handler(VALUE tpval, void *data)
 static VALUE
 stackprof_sample(VALUE self)
 {
-    if (!_stackprof.running)
+    if (!STACKPROF_RUNNING())
 	return Qfalse;
 
     _stackprof.overall_signals++;
@@ -812,16 +868,23 @@ stackprof_gc_mark(void *data)
     if (_stackprof.frames)
 	st_foreach(_stackprof.frames, frame_mark_i, 0);
 
-    for (int i = 0; i < _stackprof.buffer_count; i++) {
+    int i;
+    for (i = 0; i < _stackprof.buffer_count; i++) {
         rb_gc_mark(_stackprof.frames_buffer[i]);
     }
 }
 
+static size_t
+stackprof_memsize(const void *data)
+{
+    return sizeof(_stackprof);
+}
+
 static void
 stackprof_atfork_prepare(void)
 {
     struct itimerval timer;
-    if (_stackprof.running) {
+    if (STACKPROF_RUNNING()) {
 	if (_stackprof.mode == sym_wall || _stackprof.mode == sym_cpu) {
 	    memset(&timer, 0, sizeof(timer));
 	    setitimer(_stackprof.mode == sym_wall ? ITIMER_REAL : ITIMER_PROF, &timer, 0);
@@ -833,7 +896,7 @@ static void
 stackprof_atfork_parent(void)
 {
     struct itimerval timer;
-    if (_stackprof.running) {
+    if (STACKPROF_RUNNING()) {
 	if (_stackprof.mode == sym_wall || _stackprof.mode == sym_cpu) {
 	    timer.it_interval.tv_sec = 0;
 	    timer.it_interval.tv_usec = NUM2LONG(_stackprof.interval);
@@ -862,6 +925,15 @@ stackprof_at_exit(ruby_vm_t* vm)
     ruby_vm_running = 0;
 }
 
+static const rb_data_type_t stackprof_type = {
+    "StackProf",
+    {
+        stackprof_gc_mark,
+        NULL,
+        stackprof_memsize,
+    }
+};
+
 void
 Init_stackprof(void)
 {
@@ -893,6 +965,7 @@ Init_stackprof(void)
     S(mode);
     S(interval);
     S(raw);
+    S(raw_lines);
     S(raw_sample_timestamps);
     S(raw_timestamp_deltas);
     S(out);
@@ -908,8 +981,8 @@ Init_stackprof(void)
     /* Need to run this to warm the symbol table before we call this during GC */
     rb_gc_latest_gc_info(sym_state);
 
-    gc_hook = Data_Wrap_Struct(rb_cObject, stackprof_gc_mark, NULL, &_stackprof);
     rb_global_variable(&gc_hook);
+    gc_hook = TypedData_Wrap_Struct(rb_cObject, &stackprof_type, &_stackprof);
 
     _stackprof.raw_samples = NULL;
     _stackprof.raw_samples_len = 0;

data/lib/stackprof.rb

@@ -5,7 +5,11 @@ else
 end
 
 if defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?
-  StackProf.use_postponed_job!
+  if RUBY_VERSION < "3.3"
+    # On 3.3 we don't need postponed jobs:
+    # https://github.com/ruby/ruby/commit/a1dc1a3de9683daf5a543d6f618e17aabfcb8708
+    StackProf.use_postponed_job!
+  end
 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
@@ -14,7 +18,7 @@ elsif RUBY_VERSION == "3.2.0"
 end
 
 module StackProf
-  VERSION = '0.2.25'
+  VERSION = '0.2.27'
 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.25'
+  s.version = '0.2.27'
   s.homepage = 'http://github.com/tmm1/stackprof'
 
   s.authors = 'Aman Gupta'
@@ -29,6 +29,5 @@ Gem::Specification.new do |s|
   s.license = 'MIT'
 
   s.add_development_dependency 'rake-compiler', '~> 0.9'
-  s.add_development_dependency 'mocha', '~> 0.14'
   s.add_development_dependency 'minitest', '~> 5.0'
 end

data/test/test_middleware.rb

@@ -2,9 +2,9 @@ $:.unshift File.expand_path('../../lib', __FILE__)
 require 'stackprof'
 require 'stackprof/middleware'
 require 'minitest/autorun'
-require 'mocha/setup'
+require 'tmpdir'
 
-class StackProf::MiddlewareTest < MiniTest::Test
+class StackProf::MiddlewareTest < Minitest::Test
 
   def test_path_default
     StackProf::Middleware.new(Object.new)
@@ -19,23 +19,36 @@ class StackProf::MiddlewareTest < MiniTest::Test
   end
 
   def test_save_default
-    StackProf::Middleware.new(Object.new)
-
-    StackProf.stubs(:results).returns({ mode: 'foo' })
-    FileUtils.expects(:mkdir_p).with('tmp/')
-    File.expects(:open).with(regexp_matches(/^tmp\/stackprof-foo/), 'wb')
-
-    StackProf::Middleware.save
+    middleware = StackProf::Middleware.new(->(env) { 100.times { Object.new } },
+                                          save_every: 1,
+                                          enabled: true)
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) { middleware.call({}) }
+      dir = File.join(dir, "tmp")
+      assert File.directory? dir
+      profile = Dir.entries(dir).reject { |x| File.directory?(x) }.first
+      assert profile
+      assert_equal "stackprof", profile.split("-")[0]
+      assert_equal "cpu", profile.split("-")[1]
+      assert_equal Process.pid.to_s, profile.split("-")[2]
+    end
   end
 
   def test_save_custom
-    StackProf::Middleware.new(Object.new, { path: 'foo/' })
-
-    StackProf.stubs(:results).returns({ mode: 'foo' })
-    FileUtils.expects(:mkdir_p).with('foo/')
-    File.expects(:open).with(regexp_matches(/^foo\/stackprof-foo/), 'wb')
-
-    StackProf::Middleware.save
+    middleware = StackProf::Middleware.new(->(env) { 100.times { Object.new } },
+                                          path: "foo/",
+                                          save_every: 1,
+                                          enabled: true)
+    Dir.mktmpdir do |dir|
+      Dir.chdir(dir) { middleware.call({}) }
+      dir = File.join(dir, "foo")
+      assert File.directory? dir
+      profile = Dir.entries(dir).reject { |x| File.directory?(x) }.first
+      assert profile
+      assert_equal "stackprof", profile.split("-")[0]
+      assert_equal "cpu", profile.split("-")[1]
+      assert_equal Process.pid.to_s, profile.split("-")[2]
+    end
   end
 
   def test_enabled_should_use_a_proc_if_passed
@@ -70,4 +83,4 @@ class StackProf::MiddlewareTest < MiniTest::Test
     StackProf::Middleware.new(Object.new, metadata: metadata)
     assert_equal metadata, StackProf::Middleware.metadata
   end
-end
+end unless RUBY_ENGINE == 'truffleruby'

data/test/test_report.rb

@@ -2,7 +2,7 @@ $:.unshift File.expand_path('../../lib', __FILE__)
 require 'stackprof'
 require 'minitest/autorun'
 
-class ReportDumpTest < MiniTest::Test
+class ReportDumpTest < Minitest::Test
   require 'stringio'
 
   def test_dump_to_stdout
@@ -33,7 +33,7 @@ class ReportDumpTest < MiniTest::Test
   end
 end
 
-class ReportReadTest < MiniTest::Test
+class ReportReadTest < Minitest::Test
   require 'pathname'
 
   def test_from_file_read_json

data/test/test_stackprof.rb

@@ -4,7 +4,7 @@ require 'minitest/autorun'
 require 'tempfile'
 require 'pathname'
 
-class StackProfTest < MiniTest::Test
+class StackProfTest < Minitest::Test
   def setup
     Object.new # warm some caches to avoid flakiness
   end
@@ -93,6 +93,7 @@ class StackProfTest < MiniTest::Test
   end
 
   def test_walltime
+    GC.disable
     profile = StackProf.run(mode: :wall) do
       idle
     end
@@ -104,6 +105,8 @@ class StackProfTest < MiniTest::Test
       assert_equal "StackProfTest#idle", frame[:name]
     end
     assert_in_delta 200, frame[:samples], 25
+  ensure
+    GC.enable
   end
 
   def test_custom
@@ -142,10 +145,13 @@ class StackProfTest < MiniTest::Test
     after_monotonic = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
 
     raw = profile[:raw]
+    raw_lines = profile[:raw_lines]
     assert_equal 10, raw[-1]
     assert_equal raw[0] + 2, raw.size
+    assert_equal 10, raw_lines[-1] # seen 10 times
 
     offset = RUBY_VERSION >= '3' ? -3 : -2
+    assert_equal 140, raw_lines[offset] # sample caller is on 140
     assert_includes profile[:frames][raw[offset]][:name], 'StackProfTest#test_raw'
 
     assert_equal 10, profile[:raw_sample_timestamps].size
@@ -241,8 +247,12 @@ class StackProfTest < MiniTest::Test
     assert marking_frame
     assert sweeping_frame
 
-    assert_equal gc_frame[:total_samples], profile[:gc_samples]
-    assert_equal profile[:gc_samples], [gc_frame, marking_frame, sweeping_frame].map{|x| x[:samples] }.inject(:+)
+    # We can't guarantee a certain number of GCs to run, so just assert
+    # that it's within some kind of delta
+    assert_in_delta gc_frame[:total_samples], profile[:gc_samples], 2
+
+    # Lazy marking / sweeping can cause this math to not add up, so also use a delta
+    assert_in_delta profile[:gc_samples], [gc_frame, marking_frame, sweeping_frame].map{|x| x[:samples] }.inject(:+), 2
 
     assert_operator profile[:gc_samples], :>, 0
     assert_operator profile[:missed_samples], :<=, 25

data/test/test_truffleruby.rb

@@ -3,7 +3,7 @@ require 'stackprof'
 require 'minitest/autorun'
 
 if RUBY_ENGINE == 'truffleruby'
-  class StackProfTruffleRubyTest < MiniTest::Test
+  class StackProfTruffleRubyTest < Minitest::Test
     def test_error
       error = assert_raises RuntimeError do
         StackProf.run(mode: :cpu) do

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: stackprof
 version: !ruby/object:Gem::Version
-  version: 0.2.25
+  version: 0.2.27
 platform: ruby
 authors:
 - Aman Gupta
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-06 00:00:00.000000000 Z
+date: 2025-01-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -24,20 +23,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
-- !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.14'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.14'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -99,10 +84,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/tmm1/stackprof/issues
-  changelog_uri: https://github.com/tmm1/stackprof/blob/v0.2.25/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/stackprof/0.2.25
-  source_code_uri: https://github.com/tmm1/stackprof/tree/v0.2.25
-post_install_message: 
+  changelog_uri: https://github.com/tmm1/stackprof/blob/v0.2.27/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/stackprof/0.2.27
+  source_code_uri: https://github.com/tmm1/stackprof/tree/v0.2.27
 rdoc_options: []
 require_paths:
 - lib
@@ -117,8 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.7.0.dev
 specification_version: 4
 summary: sampling callstack-profiler for ruby 2.2+
 test_files: []