stackprof 0.2.11 → 0.2.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 88f62f89ebff2c249b7eaabcb330f12997f09120
-  data.tar.gz: 629071b6584701d830b827e5d4b9b0951eaa0282
+SHA256:
+  metadata.gz: 109d5dc07fefb68933ae164c88420aecc662593f9fa96e102a90e7c8d4c605a9
+  data.tar.gz: 7cbd4e6919a160f5e7b680bd0994e9e33097df03c7098ffda7317996a8afb1f6
 SHA512:
-  metadata.gz: d02684e9bd77e2b561f626a69a897e1ec2c89b870b30ef54709165cc1debb966a56127f3053d7a27e81cc7c3c62fef50865ebd5bcbfd6d2b28630add6280e479
-  data.tar.gz: 2d5d70aaa53080112d8f794d1d5412cd8225f451f43431f30209e42854b5de8246ff77347ef39496c2b55b447d6cf114116b81dc2eb458adea16a5d9ce03606e
+  metadata.gz: d4c6894359a809ea8e504eca85506179eb598d2b0db6833b1661e08d982efb78ec0fa526e73ba30a7388c443b5b4eb16a466baa7dd3dcd4e139c0bec7b22ab5d
+  data.tar.gz: 040bc4d3c1ffb1f724bce5ca7db4ddeae7af7ecdc526f893f878049bf42c715983802def5a2e8905f6b1016401a478457a237ef0a76dc742e7070780940e762b

data/.gitignore

@@ -2,3 +2,5 @@
 /lib/stackprof/stackprof.bundle
 /lib/stackprof/stackprof.so
 *.sw?
+/pkg
+/Gemfile.lock

data/.travis.yml

@@ -1,8 +1,21 @@
-sudo: false
-language: ruby
-rvm:
-  - 2.1
-  - 2.2
-  - 2.3
-  - 2.4
-  - ruby-head
+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/CHANGELOG.md

@@ -0,0 +1,14 @@
+# 0.2.16
+
+* [flamegraph.pl] Update to latest version
+* Add option to ignore GC frames
+* Handle source code not being available
+* Freeze strings in report.rb
+* Use a cursor object instead of array slicing
+* ArgumentError on interval <1 or >1m
+* fix variable name.
+* Fix default mode comment in readme
+
+# 0.2.15
+
+* Mark the metadata object before the GC is invoked to prevent it from being garbage collected.

data/Dockerfile

@@ -0,0 +1,21 @@
+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"

data/README.md

@@ -1,13 +1,17 @@
-## stackprof
+# Stackprof
 
-a sampling call-stack profiler for ruby 2.1+
+A sampling call-stack profiler for Ruby.
 
-inspired heavily by [gperftools](https://code.google.com/p/gperftools/),
-and written as a replacement for [perftools.rb](https://github.com/tmm1/perftools.rb)
+Inspired heavily by [gperftools](https://code.google.com/p/gperftools/), and written as a replacement for [perftools.rb](https://github.com/tmm1/perftools.rb).
 
-### getting started
+## Requirements
 
-#### Install
+* Ruby 2.2+
+* Linux-based OS
+
+## Getting Started
+
+### Install
 
 In your Gemfile add:
 
@@ -18,7 +22,7 @@ gem 'stackprof'
 Then run `$ bundle install`. Alternatively you can run `$ gem install stackprof`.
 
 
-#### Run
+### Run
 
 in ruby:
 
@@ -93,12 +97,20 @@ The `--flamegraph-viewer` command will output the exact shell command you need t
 
 ![](http://i.imgur.com/EwndrgD.png)
 
-### sampling
+Alternatively, you can generate a flamegraph that uses [d3-flame-graph](https://github.com/spiermar/d3-flame-graph):
+
+```
+$ stackprof --d3-flamegraph tmp/stackprof-cpu-myapp.dump > flamegraph.html
+```
+
+And just open the result by your browser.
+
+## Sampling
 
 four sampling modes are supported:
 
-  - :wall (using `ITIMER_REAL` and `SIGALRM`)
-  - :cpu (using `ITIMER_PROF` and `SIGPROF`) [default mode]
+  - :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`)
 
@@ -129,6 +141,12 @@ 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
+its own frame.
+
 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`.
@@ -142,7 +160,7 @@ samples are taken using a combination of three new C-APIs in ruby 2.1:
   - 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
+## 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:
@@ -175,14 +193,14 @@ this technique builds up an incremental callgraph from the samples. on any given
 the sum of the outbound edge weights is equal to total samples collected on that frame
 (`frame.total_samples == frame.edges.values.sum`).
 
-### reporting
+## Reporting
 
 multiple reporting modes are supported:
   - text
   - dotgraph
   - source annotation
 
-#### `StackProf::Report.new(data).print_text`
+### `StackProf::Report.new(data).print_text`
 
 ```
      TOTAL    (pct)     SAMPLES    (pct)     FRAME
@@ -197,7 +215,7 @@ multiple reporting modes are supported:
        188 (100.0%)           0   (0.0%)     <main>
 ```
 
-#### `StackProf::Report.new(data).print_graphviz`
+### `StackProf::Report.new(data).print_graphviz`
 
 ![](http://cl.ly/image/2t3l2q0l0B0A/content)
 
@@ -223,7 +241,7 @@ digraph profile {
 }
 ```
 
-#### `StackProf::Report.new(data).print_method(/pow|newobj|math/)`
+### `StackProf::Report.new(data).print_method(/pow|newobj|math/)`
 
 ```
 A#pow (/Users/tmm1/code/stackprof/sample.rb:11)
@@ -245,7 +263,7 @@ block in A#math (/Users/tmm1/code/stackprof/sample.rb:21)
                          |    23  |     end
 ```
 
-### usage
+## 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.
@@ -295,7 +313,7 @@ above, `A#pow` was involved in 91 samples, and in all cases it was at the top of
 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
+## Advanced usage
 
 the profiler can be started and stopped manually. results are accumulated until retrieval, across
 multiple start/stop invocations.
@@ -307,7 +325,7 @@ StackProf.stop
 StackProf.results('/tmp/some.file')
 ```
 
-### all options
+## All options
 
 `StackProf.run` accepts an options hash. Currently, the following options are recognized:
 
@@ -316,11 +334,13 @@ 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)
+`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
 
-### todo
+## Todo
 
 * file/iseq blacklist
 * restore signal handlers on stop

data/bin/stackprof

@@ -8,6 +8,7 @@ parser = OptionParser.new(ARGV) do |o|
   o.banner = "Usage: stackprof [file.dump]+ [--text|--method=NAME|--callgrind|--graphviz]"
 
   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 }
@@ -18,11 +19,14 @@ parser = OptionParser.new(ARGV) do |o|
   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('--flamegraph', "timeline-flamegraph output (js)"){ options[:format] = :flamegraph }
-  o.on('--flamegraph-viewer [f.js]', String, "open html viewer for flamegraph output\n\n"){ |file|
+  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 }
@@ -62,6 +66,8 @@ 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
@@ -72,8 +78,12 @@ when :graphviz
   report.print_graphviz(options)
 when :stackcollapse
   report.print_stackcollapse
-when :flamegraph
-  report.print_flamegraph
+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

data/ext/stackprof/stackprof.c

@@ -16,11 +16,24 @@
 #include <pthread.h>
 
 #define BUF_SIZE 2048
+#define MICROSECONDS_IN_SECOND 1000000
+
+#define FAKE_FRAME_GC    INT2FIX(0)
+#define FAKE_FRAME_MARK  INT2FIX(1)
+#define FAKE_FRAME_SWEEP INT2FIX(2)
+
+static const char *fake_frame_cstrs[] = {
+	"(garbage collection)",
+	"(marking)",
+	"(sweeping)",
+};
+
+#define TOTAL_FAKE_FRAMES (sizeof(fake_frame_cstrs) / sizeof(char *))
 
 typedef struct {
     size_t total_samples;
     size_t caller_samples;
-    int already_accounted_in_total;
+    size_t seen_at_sample_number;
     st_table *edges;
     st_table *lines;
 } frame_data_t;
@@ -33,6 +46,8 @@ static struct {
     VALUE mode;
     VALUE interval;
     VALUE out;
+    VALUE metadata;
+    int ignore_gc;
 
     VALUE *raw_samples;
     size_t raw_samples_len;
@@ -48,10 +63,11 @@ static struct {
     size_t overall_samples;
     size_t during_gc;
     size_t unrecorded_gc_samples;
+    size_t unrecorded_gc_marking_samples;
+    size_t unrecorded_gc_sweeping_samples;
     st_table *frames;
 
-    VALUE fake_gc_frame;
-    VALUE fake_gc_frame_name;
+    VALUE fake_frame_names[TOTAL_FAKE_FRAMES];
     VALUE empty_string;
     VALUE frames_buffer[BUF_SIZE];
     int lines_buffer[BUF_SIZE];
@@ -59,7 +75,8 @@ 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_frames, sym_out, sym_aggregate, sym_raw_timestamp_deltas;
+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_gc_samples, objtracer;
 static VALUE gc_hook;
 static VALUE rb_mStackProf;
@@ -72,7 +89,8 @@ stackprof_start(int argc, VALUE *argv, VALUE self)
 {
     struct sigaction sa;
     struct itimerval timer;
-    VALUE opts = Qnil, mode = Qnil, interval = Qnil, out = Qfalse;
+    VALUE opts = Qnil, mode = Qnil, interval = Qnil, metadata = rb_hash_new(), out = Qfalse;
+    int ignore_gc = 0;
     int raw = 0, aggregate = 1;
 
     if (_stackprof.running)
@@ -84,6 +102,17 @@ stackprof_start(int argc, VALUE *argv, VALUE self)
 	mode = rb_hash_aref(opts, sym_mode);
 	interval = rb_hash_aref(opts, sym_interval);
 	out = rb_hash_aref(opts, sym_out);
+	if (RTEST(rb_hash_aref(opts, sym_ignore_gc))) {
+	    ignore_gc = 1;
+	}
+
+	VALUE 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");
+
+	    metadata = metadata_val;
+	}
 
 	if (RTEST(rb_hash_aref(opts, sym_raw)))
 	    raw = 1;
@@ -92,6 +121,10 @@ stackprof_start(int argc, VALUE *argv, VALUE self)
     }
     if (!RTEST(mode)) mode = sym_wall;
 
+    if (!NIL_P(interval) && (NUM2INT(interval) < 1 || NUM2INT(interval) >= MICROSECONDS_IN_SECOND)) {
+        rb_raise(rb_eArgError, "interval is a number of microseconds between 1 and 1 million");
+    }
+
     if (!_stackprof.frames) {
 	_stackprof.frames = st_init_numtable();
 	_stackprof.overall_signals = 0;
@@ -128,6 +161,8 @@ stackprof_start(int argc, VALUE *argv, VALUE self)
     _stackprof.aggregate = aggregate;
     _stackprof.mode = mode;
     _stackprof.interval = interval;
+    _stackprof.ignore_gc = ignore_gc;
+    _stackprof.metadata = metadata;
     _stackprof.out = out;
 
     if (raw) {
@@ -201,8 +236,8 @@ frame_i(st_data_t key, st_data_t val, st_data_t arg)
 
     rb_hash_aset(results, rb_obj_id(frame), details);
 
-    if (frame == _stackprof.fake_gc_frame) {
-	name = _stackprof.fake_gc_frame_name;
+    if (FIXNUM_P(frame)) {
+	name = _stackprof.fake_frame_names[FIX2INT(frame)];
 	file = _stackprof.empty_string;
 	line = INT2FIX(0);
     } else {
@@ -258,6 +293,9 @@ stackprof_results(int argc, VALUE *argv, VALUE self)
     rb_hash_aset(results, sym_samples, SIZET2NUM(_stackprof.overall_samples));
     rb_hash_aset(results, sym_gc_samples, SIZET2NUM(_stackprof.during_gc));
     rb_hash_aset(results, sym_missed_samples, SIZET2NUM(_stackprof.overall_signals - _stackprof.overall_samples));
+    rb_hash_aset(results, sym_metadata, _stackprof.metadata);
+
+    _stackprof.metadata = Qnil;
 
     frames = rb_hash_new();
     rb_hash_aset(results, sym_frames, frames);
@@ -268,6 +306,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_samples = rb_ary_new_capa(_stackprof.raw_samples_len);
 
 	for (n = 0; n < _stackprof.raw_samples_len; n++) {
@@ -287,7 +326,7 @@ stackprof_results(int argc, VALUE *argv, VALUE self)
 
 	rb_hash_aset(results, sym_raw, raw_samples);
 
-	VALUE raw_timestamp_deltas = rb_ary_new_capa(_stackprof.raw_timestamp_deltas_len);
+	raw_timestamp_deltas = rb_ary_new_capa(_stackprof.raw_timestamp_deltas_len);
 
 	for (n = 0; n < _stackprof.raw_timestamp_deltas_len; n++) {
 	    rb_ary_push(raw_timestamp_deltas, INT2FIX(_stackprof.raw_timestamp_deltas[n]));
@@ -308,11 +347,12 @@ stackprof_results(int argc, VALUE *argv, VALUE self)
 
     if (RTEST(_stackprof.out)) {
 	VALUE file;
-	if (RB_TYPE_P(_stackprof.out, T_STRING)) {
-	    file = rb_file_open_str(_stackprof.out, "w");
-	} else {
+	if (rb_respond_to(_stackprof.out, rb_intern("to_io"))) {
 	    file = rb_io_check_io(_stackprof.out);
+	} else {
+	    file = rb_file_open_str(_stackprof.out, "w");
 	}
+
 	rb_marshal_dump(results, file);
 	rb_io_flush(file);
 	_stackprof.out = Qnil;
@@ -386,17 +426,29 @@ stackprof_record_sample_for_stack(int num, int timestamp_delta)
     if (_stackprof.raw) {
 	int found = 0;
 
+	/* If there's no sample buffer allocated, then allocate one.  The buffer
+	 * format is the number of frames (num), then the list of frames (from
+	 * `_stackprof.raw_samples`), followed by the number of times this
+	 * particular stack has been seen in a row.  Each "new" stack is added
+	 * to the end of the buffer, but if the previous stack is the same as
+	 * the current stack, the counter will be incremented. */
 	if (!_stackprof.raw_samples) {
 	    _stackprof.raw_samples_capa = num * 100;
 	    _stackprof.raw_samples = malloc(sizeof(VALUE) * _stackprof.raw_samples_capa);
 	}
 
+	/* If we can't fit all the samples in the buffer, double the buffer size. */
 	while (_stackprof.raw_samples_capa <= _stackprof.raw_samples_len + (num + 2)) {
 	    _stackprof.raw_samples_capa *= 2;
 	    _stackprof.raw_samples = realloc(_stackprof.raw_samples, sizeof(VALUE) * _stackprof.raw_samples_capa);
 	}
 
+	/* If we've seen this stack before in the last sample, then increment the "seen" count. */
 	if (_stackprof.raw_samples_len > 0 && _stackprof.raw_samples[_stackprof.raw_sample_index] == (VALUE)num) {
+	    /* The number of samples could have been the same, but the stack
+	     * might be different, so we need to check the stack here.  Stacks
+	     * in the raw buffer are stored in the opposite direction of stacks
+	     * 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)
@@ -408,7 +460,11 @@ stackprof_record_sample_for_stack(int num, int timestamp_delta)
 	    }
 	}
 
+	/* If we haven't seen the stack, then add it to the buffer along with
+	 * the length of the stack and a 1 for the "seen" count */
 	if (!found) {
+	    /* Bump the `raw_sample_index` up so that the next iteration can
+	     * find the previously recorded stack size. */
 	    _stackprof.raw_sample_index = _stackprof.raw_samples_len;
 	    _stackprof.raw_samples[_stackprof.raw_samples_len++] = (VALUE)num;
 	    for (i = num-1; i >= 0; i--) {
@@ -418,33 +474,32 @@ stackprof_record_sample_for_stack(int num, int timestamp_delta)
 	    _stackprof.raw_samples[_stackprof.raw_samples_len++] = (VALUE)1;
 	}
 
+	/* 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;
 	}
 
+	/* 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);
 	}
 
+	/* Store the time delta (which is the amount of time between samples) */
 	_stackprof.raw_timestamp_deltas[_stackprof.raw_timestamp_deltas_len++] = timestamp_delta;
     }
 
-    for (i = 0; i < num; i++) {
-	VALUE frame = _stackprof.frames_buffer[i];
-	sample_for(frame)->already_accounted_in_total = 0;
-    }
-
     for (i = 0; i < num; i++) {
 	int line = _stackprof.lines_buffer[i];
 	VALUE frame = _stackprof.frames_buffer[i];
 	frame_data_t *frame_data = sample_for(frame);
 
-	if (!frame_data->already_accounted_in_total)
+	if (frame_data->seen_at_sample_number != _stackprof.overall_samples) {
 	    frame_data->total_samples++;
-	frame_data->already_accounted_in_total = 1;
+	}
+	frame_data->seen_at_sample_number = _stackprof.overall_samples;
 
 	if (i == 0) {
 	    frame_data->caller_samples++;
@@ -455,10 +510,10 @@ stackprof_record_sample_for_stack(int num, int timestamp_delta)
 	}
 
 	if (_stackprof.aggregate && line > 0) {
-	    if (!frame_data->lines)
-		frame_data->lines = st_init_numtable();
 	    size_t half = (size_t)1<<(8*SIZEOF_SIZE_T/2);
 	    size_t increment = i == 0 ? half + 1 : half;
+	    if (!frame_data->lines)
+		frame_data->lines = st_init_numtable();
 	    st_numtable_increment(frame_data->lines, (st_data_t)line, increment);
 	}
 
@@ -474,14 +529,15 @@ void
 stackprof_record_sample()
 {
     int timestamp_delta = 0;
+    int num;
     if (_stackprof.raw) {
 	struct timeval t;
-	gettimeofday(&t, NULL);
 	struct timeval diff;
+	gettimeofday(&t, NULL);
 	timersub(&t, &_stackprof.last_sample_at, &diff);
 	timestamp_delta = (1000 * diff.tv_sec) + diff.tv_usec;
     }
-    int num = rb_profile_frames(0, sizeof(_stackprof.frames_buffer) / sizeof(VALUE), _stackprof.frames_buffer, _stackprof.lines_buffer);
+    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);
 }
 
@@ -489,31 +545,52 @@ void
 stackprof_record_gc_samples()
 {
     int delta_to_first_unrecorded_gc_sample = 0;
+    int i;
     if (_stackprof.raw) {
 	struct timeval t;
-	gettimeofday(&t, NULL);
 	struct timeval diff;
+	gettimeofday(&t, NULL);
 	timersub(&t, &_stackprof.last_sample_at, &diff);
 
 	// 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) * _stackprof.interval;
+	delta_to_first_unrecorded_gc_sample = (1000 * diff.tv_sec + diff.tv_usec) - (_stackprof.unrecorded_gc_samples - 1) * NUM2LONG(_stackprof.interval);
 	if (delta_to_first_unrecorded_gc_sample < 0) {
 	    delta_to_first_unrecorded_gc_sample = 0;
 	}
     }
 
-    int i;
-
-    _stackprof.frames_buffer[0] = _stackprof.fake_gc_frame;
-    _stackprof.lines_buffer[0] = 0;
 
     for (i = 0; i < _stackprof.unrecorded_gc_samples; i++) {
-	int timestamp_delta = i == 0 ? delta_to_first_unrecorded_gc_sample : _stackprof.interval;
-	stackprof_record_sample_for_stack(1, timestamp_delta);
+	int 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;
+        _stackprof.lines_buffer[0] = 0;
+        _stackprof.frames_buffer[1] = FAKE_FRAME_GC;
+        _stackprof.lines_buffer[1] = 0;
+        _stackprof.unrecorded_gc_marking_samples--;
+
+        stackprof_record_sample_for_stack(2, timestamp_delta);
+      } else if (_stackprof.unrecorded_gc_sweeping_samples) {
+        _stackprof.frames_buffer[0] = FAKE_FRAME_SWEEP;
+        _stackprof.lines_buffer[0] = 0;
+        _stackprof.frames_buffer[1] = FAKE_FRAME_GC;
+        _stackprof.lines_buffer[1] = 0;
+
+        _stackprof.unrecorded_gc_sweeping_samples--;
+
+        stackprof_record_sample_for_stack(2, timestamp_delta);
+      } else {
+        _stackprof.frames_buffer[0] = FAKE_FRAME_GC;
+        _stackprof.lines_buffer[0] = 0;
+        stackprof_record_sample_for_stack(1, timestamp_delta);
+      }
     }
     _stackprof.during_gc += _stackprof.unrecorded_gc_samples;
     _stackprof.unrecorded_gc_samples = 0;
+    _stackprof.unrecorded_gc_marking_samples = 0;
+    _stackprof.unrecorded_gc_sweeping_samples = 0;
 }
 
 static void
@@ -544,7 +621,13 @@ static void
 stackprof_signal_handler(int sig, siginfo_t *sinfo, void *ucontext)
 {
     _stackprof.overall_signals++;
-    if (rb_during_gc()) {
+    if (!_stackprof.ignore_gc && rb_during_gc()) {
+	VALUE mode = rb_gc_latest_gc_info(sym_state);
+	if (mode == sym_marking) {
+	    _stackprof.unrecorded_gc_marking_samples++;
+	} else if (mode == sym_sweeping) {
+	    _stackprof.unrecorded_gc_sweeping_samples++;
+	}
 	_stackprof.unrecorded_gc_samples++;
 	rb_postponed_job_register_one(0, stackprof_gc_job_handler, (void*)0);
     } else {
@@ -583,6 +666,9 @@ frame_mark_i(st_data_t key, st_data_t val, st_data_t arg)
 static void
 stackprof_gc_mark(void *data)
 {
+    if (RTEST(_stackprof.metadata))
+	rb_gc_mark(_stackprof.metadata);
+
     if (RTEST(_stackprof.out))
 	rb_gc_mark(_stackprof.out);
 
@@ -625,6 +711,7 @@ stackprof_atfork_child(void)
 void
 Init_stackprof(void)
 {
+    size_t i;
 #define S(name) sym_##name = ID2SYM(rb_intern(#name));
     S(object);
     S(custom);
@@ -645,10 +732,18 @@ Init_stackprof(void)
     S(raw);
     S(raw_timestamp_deltas);
     S(out);
+    S(metadata);
+    S(ignore_gc);
     S(frames);
     S(aggregate);
+    S(state);
+    S(marking);
+    S(sweeping);
 #undef S
 
+    /* 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);
 
@@ -661,12 +756,14 @@ Init_stackprof(void)
     _stackprof.raw_timestamp_deltas_len = 0;
     _stackprof.raw_timestamp_deltas_capa = 0;
 
-    _stackprof.fake_gc_frame = INT2FIX(0x9C);
     _stackprof.empty_string = rb_str_new_cstr("");
-    _stackprof.fake_gc_frame_name = rb_str_new_cstr("(garbage collection)");
-    rb_global_variable(&_stackprof.fake_gc_frame_name);
     rb_global_variable(&_stackprof.empty_string);
 
+    for (i = 0; i < TOTAL_FAKE_FRAMES; i++) {
+	    _stackprof.fake_frame_names[i] = rb_str_new_cstr(fake_frame_cstrs[i]);
+	    rb_global_variable(&_stackprof.fake_frame_names[i]);
+    }
+
     rb_mStackProf = rb_define_module("StackProf");
     rb_define_singleton_method(rb_mStackProf, "running?", stackprof_running_p, 0);
     rb_define_singleton_method(rb_mStackProf, "run", stackprof_run, -1);