stackprof 0.2.16 → 0.2.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 109d5dc07fefb68933ae164c88420aecc662593f9fa96e102a90e7c8d4c605a9
-  data.tar.gz: 7cbd4e6919a160f5e7b680bd0994e9e33097df03c7098ffda7317996a8afb1f6
+  metadata.gz: 6662250e5e20ee3388bfce740a053c83e53fe9304b518ad22f0ce9ffc5d10077
+  data.tar.gz: 7480e1896e253bd530573fc2f66b3d7690db97bee3f892c77729b75c2dc8c94e
 SHA512:
-  metadata.gz: d4c6894359a809ea8e504eca85506179eb598d2b0db6833b1661e08d982efb78ec0fa526e73ba30a7388c443b5b4eb16a466baa7dd3dcd4e139c0bec7b22ab5d
-  data.tar.gz: 040bc4d3c1ffb1f724bce5ca7db4ddeae7af7ecdc526f893f878049bf42c715983802def5a2e8905f6b1016401a478457a237ef0a76dc742e7070780940e762b
+  metadata.gz: 3f92e6401b16f83d9398b94e8b0506f597a785a19e1552245f39e1c77ab0c2d3d40186b8b05f91972b6d899995718c28e1724acff97248d497a3768deed601bb
+  data.tar.gz: 0663a1cdac8730bcbc4dd68750fffa6885b72eca7c37915191b6ff44ff101349ba274648b6641531c1bfff34144179b76d527ca8426db91af2c0536629f6ee65

data/.github/workflows/ci.yml

@@ -0,0 +1,43 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  rubies:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [ ruby-head, '3.0', '2.7', '2.6', '2.5', '2.4', '2.3', '2.2' ]
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Install dependencies
+        run: bundle install
+      - name: Run test
+        run: rake
+      - name: Install gem
+        run: rake install
+  platforms:
+    strategy:
+      matrix:
+        os: [macos]
+        ruby: ['3.0']
+    runs-on: ${{ matrix.os }}-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - name: Install dependencies
+        run: bundle install
+      - name: Run test
+        run: rake
+      - name: Install gem
+        run: rake install

data/README.md

@@ -81,21 +81,21 @@ $ stackprof tmp/stackprof-cpu-*.dump --method 'Object#present?'
 
 For an experimental version of WebUI reporting of stackprof, see [stackprof-webnav](https://github.com/alisnic/stackprof-webnav)
 
-You can generate a flamegraph however additional data must be collected using the `raw: true` flag. Once you've collected results with this flag enabled you can generate a flamegraph:
+To generate flamegraphs with Stackprof, additional data must be collected using the `raw: true` flag. Once you've collected results with this flag enabled, generate a flamegraph with:
 
 ```
 $ stackprof --flamegraph tmp/stackprof-cpu-myapp.dump > tmp/flamegraph
 ```
 
-Once the flamegraph has been generated you can generate a viewer command with:
+After the flamegraph has been generated, you can generate a viewer command with:
 
 ```
 $ stackprof --flamegraph-viewer=tmp/flamegraph
 ```
 
-The `--flamegraph-viewer` command will output the exact shell command you need to run to open the `tmp/flamegraph` you generated with the built in stackprof flamegraph viewer:
+The `--flamegraph-viewer` command will output the exact shell command you need to run in order to open the `tmp/flamegraph` you generated with the built-in stackprof flamegraph viewer:
 
-![](http://i.imgur.com/EwndrgD.png)
+![Flamegraph Viewer](http://i.imgur.com/EwndrgD.png)
 
 Alternatively, you can generate a flamegraph that uses [d3-flame-graph](https://github.com/spiermar/d3-flame-graph):
 
@@ -107,16 +107,16 @@ And just open the result by your browser.
 
 ## Sampling
 
-four sampling modes are supported:
+Four sampling modes are supported:
 
-  - :wall (using `ITIMER_REAL` and `SIGALRM`) [default mode]
-  - :cpu (using `ITIMER_PROF` and `SIGPROF`)
-  - :object (using `RUBY_INTERNAL_EVENT_NEWOBJ`)
-  - :custom (user-defined via `StackProf.sample`)
+  - `:wall` (using `ITIMER_REAL` and `SIGALRM`) [default mode]
+  - `:cpu` (using `ITIMER_PROF` and `SIGPROF`)
+  - `:object` (using `RUBY_INTERNAL_EVENT_NEWOBJ`)
+  - `:custom` (user-defined via `StackProf.sample`)
 
-samplers have a tuneable interval which can be used to reduce overhead or increase granularity:
+Samplers have a tuneable interval which can be used to reduce overhead or increase granularity:
 
-  - wall time: sample every _interval_ microseconds of wallclock time (default: 1000)
+  - Wall time: sample every _interval_ microseconds of wallclock time (default: 1000)
 
 ```ruby
 StackProf.run(mode: :wall, out: 'tmp/stackprof.dump', interval: 1000) do
@@ -124,7 +124,7 @@ StackProf.run(mode: :wall, out: 'tmp/stackprof.dump', interval: 1000) do
 end
 ```
 
-  - cpu time: sample every _interval_ microseconds of cpu activity (default: 1000 = 1 millisecond)
+  - CPU time: sample every _interval_ microseconds of CPU activity (default: 1000 = 1 millisecond)
 
 ```ruby
 StackProf.run(mode: :cpu, out: 'tmp/stackprof.dump', interval: 1000) do
@@ -132,7 +132,7 @@ StackProf.run(mode: :cpu, out: 'tmp/stackprof.dump', interval: 1000) do
 end
 ```
 
-  - object allocation: sample every _interval_ allocations (default: 1)
+  - Object allocation: sample every _interval_ allocations (default: 1)
 
 
 ```ruby
@@ -141,36 +141,36 @@ StackProf.run(mode: :object, out: 'tmp/stackprof.dump', interval: 1) do
 end
 ```
 
-by default, samples taken during garbage collection will show as garbage collection frames
-including both mark and sweep phases. for longer traces, these can leave gaps in a flamegraph
-that are hard to follow and can be disabled by setting the `ignore_gc` option to true.
-garbage collection time will still be present in the profile but not explicitly marked with
+By default, samples taken during garbage collection will show as garbage collection frames
+including both mark and sweep phases. For longer traces, these can leave gaps in a flamegraph
+that are hard to follow. They can be disabled by setting the `ignore_gc` option to true.
+Garbage collection time will still be present in the profile but not explicitly marked with
 its own frame.
 
-samples are taken using a combination of three new C-APIs in ruby 2.1:
+Samples are taken using a combination of three new C-APIs in ruby 2.1:
 
-  - signal handlers enqueue a sampling job using `rb_postponed_job_register_one`.
+  - Signal handlers enqueue a sampling job using `rb_postponed_job_register_one`.
     this ensures callstack samples can be taken safely, in case the VM is garbage collecting
     or in some other inconsistent state during the interruption.
 
-  - stack frames are collected via `rb_profile_frames`, which provides low-overhead C-API access
-    to the VM's call stack. no object allocations occur in this path, allowing stackprof to collect
+  - Stack frames are collected via `rb_profile_frames`, which provides low-overhead C-API access
+    to the VM's call stack. No object allocations occur in this path, allowing stackprof to collect
     callstacks in allocation mode.
 
-  - in allocation mode, samples are taken via `rb_tracepoint_new(RUBY_INTERNAL_EVENT_NEWOBJ)`,
+  - In allocation mode, samples are taken via `rb_tracepoint_new(RUBY_INTERNAL_EVENT_NEWOBJ)`,
     which provides a notification every time the VM allocates a new object.
 
 ## Aggregation
 
-each sample consists of N stack frames, where a frame looks something like `MyClass#method` or `block in MySingleton.method`.
-for each of these frames in the sample, the profiler collects a few pieces of metadata:
+Each sample consists of N stack frames, where a frame looks something like `MyClass#method` or `block in MySingleton.method`.
+For each of these frames in the sample, the profiler collects a few pieces of metadata:
 
-  - samples: number of samples where this was the topmost frame
-  - total_samples: samples where this frame was in the stack
-  - lines: samples per line number in this frame
-  - edges: samples per callee frame (methods invoked by this frame)
+  - `samples`: Number of samples where this was the topmost frame
+  - `total_samples`: Samples where this frame was in the stack
+  - `lines`: Samples per line number in this frame
+  - `edges`: Samples per callee frame (methods invoked by this frame)
 
-the aggregation algorithm is roughly equivalent to the following pseudo code:
+The aggregation algorithm is roughly equivalent to the following pseudo code:
 
 ``` ruby
 trap('PROF') do
@@ -189,16 +189,16 @@ trap('PROF') do
 end
 ```
 
-this technique builds up an incremental callgraph from the samples. on any given frame,
+This technique builds up an incremental call graph from the samples. On any given frame,
 the sum of the outbound edge weights is equal to total samples collected on that frame
 (`frame.total_samples == frame.edges.values.sum`).
 
 ## Reporting
 
-multiple reporting modes are supported:
-  - text
-  - dotgraph
-  - source annotation
+Multiple reporting modes are supported:
+  - Text
+  - Dotgraph
+  - Source annotation
 
 ### `StackProf::Report.new(data).print_text`
 
@@ -217,8 +217,6 @@ multiple reporting modes are supported:
 
 ### `StackProf::Report.new(data).print_graphviz`
 
-![](http://cl.ly/image/2t3l2q0l0B0A/content)
-
 ```
 digraph profile {
   70346498324780 [size=23.5531914893617] [fontsize=23.5531914893617] [shape=box] [label="A#pow\n91 (48.4%)\r"];
@@ -265,8 +263,8 @@ block in A#math (/Users/tmm1/code/stackprof/sample.rb:21)
 
 ## Usage
 
-the profiler is compiled as a C-extension and exposes a simple api: `StackProf.run(mode: [:cpu|:wall|:object])`.
-the `run` method takes a block of code and returns a profile as a simple hash.
+The profiler is compiled as a C-extension and exposes a simple api: `StackProf.run(mode: [:cpu|:wall|:object])`.
+The `run` method takes a block of code and returns a profile as a simple hash.
 
 ``` ruby
 # sample after every 1ms of cpu activity
@@ -275,12 +273,12 @@ profile = StackProf.run(mode: :cpu, interval: 1000) do
 end
 ```
 
-this profile data structure is part of the public API, and is intended to be saved
-(as json/marshal for example) for later processing. the reports above can be generated
+This profile data structure is part of the public API, and is intended to be saved
+(as json/marshal for example) for later processing. The reports above can be generated
 by passing this structure into `StackProf::Report.new`.
 
-the format itself is very simple. it contains a header and a list of frames. each frame has a unique id and
-identifying information such as its name, file and line. the frame also contains sampling data, including per-line
+The format itself is very simple. It contains a header and a list of frames. Each frame has a unique ID and
+identifying information such as its name, file, and line. The frame also contains sampling data, including per-line
 samples, and a list of relationships to other frames represented as weighted edges.
 
 ``` ruby
@@ -307,20 +305,21 @@ samples, and a list of relationships to other frames represented as weighted edg
      :lines=>{8=>1}},
 ```
 
-above, `A#pow` was involved in 91 samples, and in all cases it was at the top of the stack on line 12.
+Above, `A#pow` was involved in 91 samples, and in all cases it was at the top of the stack on line 12.
 
-`A#initialize` was in 185 samples, but it was at the top of the stack in only 1 sample. the rest of the samples are
-divided up between its callee edges. all 91 calls to `A#pow` came from `A#initialize`, as seen by the edge numbered
+`A#initialize` was in 185 samples, but it was at the top of the stack in only 1 sample. The rest of the samples are
+divided up between its callee edges. All 91 calls to `A#pow` came from `A#initialize`, as seen by the edge numbered
 `70346498324780`.
 
 ## Advanced usage
 
-the profiler can be started and stopped manually. results are accumulated until retrieval, across
-multiple start/stop invocations.
+The profiler can be started and stopped manually. Results are accumulated until retrieval, across
+multiple `start`/`stop` invocations.
 
 ``` ruby
-StackProf.running?
+StackProf.running? # => false
 StackProf.start(mode: :cpu)
+StackProf.running? # => true
 StackProf.stop
 StackProf.results('/tmp/some.file')
 ```
@@ -331,14 +330,14 @@ StackProf.results('/tmp/some.file')
 
 Option      | Meaning
 -------     | ---------
-`mode`      | mode of sampling: `:cpu`, `:wall`, `:object`, or `:custom` [c.f.](#sampling)
-`out`       | the target file, which will be overwritten
-`interval`  | mode-relative sample rate [c.f.](#sampling)
+`mode`      | Mode of sampling: `:cpu`, `:wall`, `:object`, or `:custom` [c.f.](#sampling)
+`out`       | The target file, which will be overwritten
+`interval`  | Mode-relative sample rate [c.f.](#sampling)
 `ignore_gc` | Ignore garbage collection frames
-`aggregate` | defaults: `true` - if `false` disables [aggregation](#aggregation)
-`raw`       | defaults `false` - if `true` collects the extra data required by the `--flamegraph` and `--stackcollapse` report types
-`metadata`  | defaults to `{}`. Must be a `Hash`. metadata associated with this profile
-`save_every`| (rack middleware only) write the target file after this many requests
+`aggregate` | Defaults: `true` - if `false` disables [aggregation](#aggregation)
+`raw`       | Defaults `false` - if `true` collects the extra data required by the `--flamegraph` and `--stackcollapse` report types
+`metadata`  | Defaults to `{}`. Must be a `Hash`. metadata associated with this profile
+`save_every`| (Rack middleware only) write the target file after this many requests
 
 ## Todo
 

data/Rakefile

@@ -1,31 +1,17 @@
-task :default => :test
+require "bundler/gem_tasks"
+require "rake/testtask"
 
-# ==========================================================
-# Packaging
-# ==========================================================
-
-GEMSPEC = Gem::Specification::load('stackprof.gemspec')
-
-require 'rubygems/package_task'
-Gem::PackageTask.new(GEMSPEC) do |pkg|
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
 end
 
-# ==========================================================
-# Ruby Extension
-# ==========================================================
+require "rake/extensiontask"
 
-require 'rake/extensiontask'
-Rake::ExtensionTask.new('stackprof', GEMSPEC) do |ext|
-  ext.lib_dir = 'lib/stackprof'
+Rake::ExtensionTask.new("stackprof") do |ext|
+  ext.ext_dir = "ext/stackprof"
+  ext.lib_dir = "lib/stackprof"
 end
-task :build => :compile
 
-# ==========================================================
-# Testing
-# ==========================================================
-
-require 'rake/testtask'
-Rake::TestTask.new 'test' do |t|
-  t.test_files = FileList['test/test_*.rb']
-end
-task :test => :build
+task default: %i(compile test)

data/ext/stackprof/stackprof.c

@@ -7,21 +7,32 @@
 **********************************************************************/
 
 #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 <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)",
@@ -30,6 +41,47 @@ static const char *fake_frame_cstrs[] = {
 
 #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;
@@ -38,6 +90,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;
@@ -54,10 +111,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;
@@ -69,6 +126,9 @@ 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];
 } _stackprof;
@@ -76,7 +136,7 @@ static struct {
 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;
@@ -166,7 +226,7 @@ stackprof_start(int argc, VALUE *argv, VALUE self)
     _stackprof.out = out;
 
     if (raw) {
-	gettimeofday(&_stackprof.last_sample_at, NULL);
+	capture_timestamp(&_stackprof.last_sample_at);
     }
 
     return Qtrue;
@@ -201,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;
 }
 
@@ -234,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)];
@@ -306,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++) {
@@ -314,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]));
 	}
 
@@ -326,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;
@@ -416,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
@@ -475,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++) {
@@ -521,48 +593,59 @@ 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;
+    if (_stackprof.buffer_count > 0) {
+	// Another sample is already pending
+	return;
+    }
+
+    uint64_t start_timestamp = 0;
+    int64_t timestamp_delta = 0;
     int num;
     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;
@@ -571,7 +654,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;
@@ -580,11 +663,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;
@@ -593,34 +676,60 @@ stackprof_record_gc_samples()
     _stackprof.unrecorded_gc_sweeping_samples = 0;
 }
 
+// record the sample previously buffered by stackprof_buffer_sample
 static void
-stackprof_gc_job_handler(void *data)
+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_job_record_gc(void *data)
 {
-    static int in_signal_handler = 0;
-    if (in_signal_handler) return;
     if (!_stackprof.running) return;
 
-    in_signal_handler++;
     stackprof_record_gc_samples();
-    in_signal_handler--;
 }
 
+#ifdef USE_POSTPONED_JOB
+static void
+stackprof_job_sample_and_record(void *data)
+{
+    if (!_stackprof.running) return;
+
+    stackprof_sample_and_record();
+}
+#endif
+
 static void
-stackprof_job_handler(void *data)
+stackprof_job_record_buffer(void *data)
 {
-    static int in_signal_handler = 0;
-    if (in_signal_handler) return;
     if (!_stackprof.running) return;
 
-    in_signal_handler++;
-    stackprof_record_sample();
-    in_signal_handler--;
+    stackprof_record_buffer();
 }
 
 static void
 stackprof_signal_handler(int sig, siginfo_t *sinfo, void *ucontext)
 {
+    static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+
     _stackprof.overall_signals++;
+
+    if (!_stackprof.running) return;
+    if (!ruby_native_thread_p()) return;
+    if (pthread_mutex_trylock(&lock)) return;
+
     if (!_stackprof.ignore_gc && rb_during_gc()) {
 	VALUE mode = rb_gc_latest_gc_info(sym_state);
 	if (mode == sym_marking) {
@@ -629,10 +738,19 @@ 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 {
-	rb_postponed_job_register_one(0, stackprof_job_handler, (void*)0);
+#ifdef 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);
+#endif
     }
+    pthread_mutex_unlock(&lock);
 }
 
 static void
@@ -641,7 +759,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
@@ -651,7 +769,7 @@ stackprof_sample(VALUE self)
 	return Qfalse;
 
     _stackprof.overall_signals++;
-    stackprof_job_handler(0);
+    stackprof_sample_and_record();
     return Qtrue;
 }
 
@@ -730,6 +848,7 @@ Init_stackprof(void)
     S(mode);
     S(interval);
     S(raw);
+    S(raw_sample_timestamps);
     S(raw_timestamp_deltas);
     S(out);
     S(metadata);
@@ -752,9 +871,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);

data/lib/stackprof/report.rb

@@ -95,51 +95,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 +109,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 +150,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
@@ -231,15 +208,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!
@@ -445,7 +414,7 @@ module StackProf
         call, total = info.values_at(:samples, :total_samples)
         break if total < node_minimum || (limit && index >= limit)
 
-        sample = ''
+        sample = ''.dup
         sample << "#{call} (%2.1f%%)\\rof " % (call*100.0/overall_samples) if call < total
         sample << "#{total} (%2.1f%%)\\r" % (total*100.0/overall_samples)
         fontsize = (1.0 * call / max_samples) * 28 + 10

data/lib/stackprof.rb

@@ -1,7 +1,7 @@
 require "stackprof/stackprof"
 
 module StackProf
-  VERSION = '0.2.16'
+  VERSION = '0.2.19'
 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.16'
+  s.version = '0.2.19'
   s.homepage = 'http://github.com/tmm1/stackprof'
 
   s.authors = 'Aman Gupta'

data/test/test_stackprof.rb

@@ -39,16 +39,30 @@ class StackProfTest < MiniTest::Test
     end
     assert_equal :object, profile[:mode]
     assert_equal 1, profile[:interval]
-    assert_equal 2, profile[:samples]
+    if RUBY_VERSION >= '3'
+      assert_equal 4, profile[:samples]
+    else
+      assert_equal 2, profile[:samples]
+    end
 
     frame = profile[:frames].values.first
     assert_includes frame[:name], "StackProfTest#test_object_allocation"
     assert_equal 2, frame[:samples]
     assert_includes [profile_base_line - 2, profile_base_line], frame[:line]
-    assert_equal [1, 1], frame[:lines][profile_base_line+1]
-    assert_equal [1, 1], frame[:lines][profile_base_line+2]
+    if RUBY_VERSION >= '3'
+      assert_equal [2, 1], frame[:lines][profile_base_line+1]
+      assert_equal [2, 1], frame[:lines][profile_base_line+2]
+    else
+      assert_equal [1, 1], frame[:lines][profile_base_line+1]
+      assert_equal [1, 1], frame[:lines][profile_base_line+2]
+    end
     frame = profile[:frames].values[1] if RUBY_VERSION < '2.3'
-    assert_equal [2, 0], frame[:lines][profile_base_line]
+
+    if RUBY_VERSION >= '3'
+      assert_equal [4, 0], frame[:lines][profile_base_line]
+    else
+      assert_equal [2, 0], frame[:lines][profile_base_line]
+    end
   end
 
   def test_object_allocation_interval
@@ -64,8 +78,14 @@ class StackProfTest < MiniTest::Test
     end
 
     assert_operator profile[:samples], :>=, 1
-    frame = profile[:frames].values.first
-    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
@@ -74,7 +94,11 @@ class StackProfTest < MiniTest::Test
     end
 
     frame = profile[:frames].values.first
-    assert_equal "StackProfTest#idle", frame[:name]
+    if RUBY_VERSION >= '3'
+      assert_equal "IO.select", frame[:name]
+    else
+      assert_equal "StackProfTest#idle", frame[:name]
+    end
     assert_in_delta 200, frame[:samples], 25
   end
 
@@ -89,24 +113,51 @@ class StackProfTest < MiniTest::Test
     assert_equal :custom, profile[:mode]
     assert_equal 10, profile[:samples]
 
-    frame = profile[:frames].values.first
+    offset = RUBY_VERSION >= '3' ? 1 : 0
+    frame = profile[:frames].values[offset]
     assert_includes frame[:name], "StackProfTest#test_custom"
     assert_includes [profile_base_line-2, profile_base_line+1], frame[:line]
-    assert_equal [10, 10], frame[:lines][profile_base_line+2]
+
+    if RUBY_VERSION >= '3'
+      assert_equal [10, 0], frame[:lines][profile_base_line+2]
+    else
+      assert_equal [10, 10], frame[:lines][profile_base_line+2]
+    end
   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
-    assert_includes profile[:frames][raw[-2]][:name], 'StackProfTest#test_raw'
+
+    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
@@ -178,7 +229,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)" }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stackprof
 version: !ruby/object:Gem::Version
-  version: 0.2.16
+  version: 0.2.19
 platform: ruby
 authors:
 - Aman Gupta
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-10-22 00:00:00.000000000 Z
+date: 2022-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -63,10 +63,9 @@ extensions:
 - ext/stackprof/extconf.rb
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
-- ".travis.yml"
 - CHANGELOG.md
-- Dockerfile
 - Gemfile
 - LICENSE
 - README.md
@@ -95,10 +94,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/tmm1/stackprof/issues
-  changelog_uri: https://github.com/tmm1/stackprof/blob/v0.2.16/CHANGELOG.md
-  documentation_uri: https://www.rubydoc.info/gems/stackprof/0.2.16
-  source_code_uri: https://github.com/tmm1/stackprof/tree/v0.2.16
-post_install_message:
+  changelog_uri: https://github.com/tmm1/stackprof/blob/v0.2.19/CHANGELOG.md
+  documentation_uri: https://www.rubydoc.info/gems/stackprof/0.2.19
+  source_code_uri: https://github.com/tmm1/stackprof/tree/v0.2.19
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -113,8 +112,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.0.rc.2
-signing_key:
+rubygems_version: 3.0.3.1
+signing_key: 
 specification_version: 4
 summary: sampling callstack-profiler for ruby 2.2+
 test_files: []

data/.travis.yml

@@ -1,21 +0,0 @@
-sudo: required
-
-services:
-  - docker
-
-language: general
-
-env:
-  matrix:
-    - RVM_RUBY_VERSION=2.2
-    - RVM_RUBY_VERSION=2.3
-    - RVM_RUBY_VERSION=2.4
-    - RVM_RUBY_VERSION=2.5
-    - RVM_RUBY_VERSION=2.6
-    - RVM_RUBY_VERSION=ruby-head
-
-before_install:
-- sudo docker build -t stackprof-$RVM_RUBY_VERSION --build-arg=RVM_RUBY_VERSION=$RVM_RUBY_VERSION .
-
-script:
-- sudo docker run --name stackprof-$RVM_RUBY_VERSION stackprof-$RVM_RUBY_VERSION

data/Dockerfile

@@ -1,21 +0,0 @@
-FROM ubuntu:16.04
-ARG DEBIAN_FRONTEND=noninteractive
-RUN apt-get update -q && \
-    apt-get install -qy \
-      curl ca-certificates gnupg2 dirmngr build-essential \
-      gawk git autoconf automake pkg-config \
-      bison libffi-dev libgdbm-dev libncurses5-dev libsqlite3-dev libtool \
-      libyaml-dev sqlite3 zlib1g-dev libgmp-dev libreadline-dev libssl-dev \
-      ruby --no-install-recommends && \
-    apt-get clean
-
-RUN gpg2 --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB
-RUN curl -sSL https://get.rvm.io | bash -s
-ARG RVM_RUBY_VERSION=ruby-head
-RUN /bin/bash -l -c "echo $RVM_RUBY_VERSION"
-RUN /bin/bash -l -c ". /etc/profile.d/rvm.sh && rvm install $RVM_RUBY_VERSION --binary || rvm install $RVM_RUBY_VERSION"
-ADD . /stackprof/
-WORKDIR /stackprof/
-RUN /bin/bash -l -c ". /etc/profile.d/rvm.sh && gem install bundler:1.16.0"
-RUN /bin/bash -l -c ". /etc/profile.d/rvm.sh && bundle install"
-CMD /bin/bash -l -c ". /etc/profile.d/rvm.sh && bundle exec rake"