stackprof 0.2.12 → 0.2.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 25c29d953e534a2d31065493cbffa762c5f92ee1
-  data.tar.gz: f9533f32cd7d5d648f3b9e16fd9d43469181521a
+SHA256:
+  metadata.gz: 81201dbe84f93b79242ce9987c763b7edaa54b4f66a7005ff83d22a9b4e25cb4
+  data.tar.gz: c80ad82b003cb989c83bc5882f4bcdeb6f6db697729315faf6d4507b7f3888fb
 SHA512:
-  metadata.gz: 69d486b03120ed37b76b16e65825b98e00fa6fbfb3aa3c484870ebead42cdbfed204e1e4e4362e3d5bdadee9c81ccf4169bcdaf109191c8b0fa580f97a8dfc62
-  data.tar.gz: b735b0457b8ee0bbf217d0a891abd81c88ecbfd63a435001d1aaaec9707ac01607e14bea0b82a6c0c6ba827b64b3885d0cbffffdabe0742a3cc51bb402a59fc2
+  metadata.gz: f4fec270902e0b6f21e9d37b8317a2c3614cf4647ad29956b52561bc6c86d7625c4ee3362388c1323c1b74fd2fbb6c99242e75cf0314e20f5be97491e9888122
+  data.tar.gz: 01a18137afc847cba43882fbc7e22483e350490e655e9536f0dc1cb5275a49c222c4613b9a4f39cb0d3265a6e834560fc87cac4fae77324634bc2f68cde0c03a

data/.gitignore

@@ -2,5 +2,4 @@
 /lib/stackprof/stackprof.bundle
 /lib/stackprof/stackprof.so
 *.sw?
-/ext
 /pkg

data/.travis.yml

@@ -1,8 +1,22 @@
-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.1
+    - 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

@@ -1,3 +1,15 @@
-# 0.2.12
+# 0.2.13
 
-* Eliminate one loop over the stack by using `overall_samples` [#98]
+* Remove /ext from .gitignore
+* update gemfile
+* Add ruby 2.5 to CI targets
+* comment some of the inner workings
+* feature: add --json format
+* Add test coverage around the string branch in result writing
+* Flip conditional to use duck typing
+* Allow Pathname objects for Stackprof :out
+* Fix a compilation error and a compilation warning
+* Add `--alphabetical-flamegraph` for population-based instead of timeline
+* Add `--d3-flamegraph` to output html using d3-flame-graph
+* Avoid JSON::NestingError when processing deep stacks
+* Use docker for CI

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/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    stackprof (0.2.11)
+    stackprof (0.2.13)
 
 GEM
   remote: https://rubygems.org/
@@ -24,4 +24,4 @@ DEPENDENCIES
   stackprof!
 
 BUNDLED WITH
-   1.15.4
+   1.16.0

data/README.md

@@ -97,6 +97,14 @@ The `--flamegraph-viewer` command will output the exact shell command you need t
 
 ![](http://i.imgur.com/EwndrgD.png)
 
+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:

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/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+if have_func('rb_postponed_job_register_one') &&
+   have_func('rb_profile_frames') &&
+   have_func('rb_tracepoint_new') &&
+   have_const('RUBY_INTERNAL_EVENT_NEWOBJ')
+  create_makefile('stackprof/stackprof')
+else
+  fail 'missing API: are you using ruby 2.1+?'
+end

data/ext/stackprof/stackprof.c

@@ -0,0 +1,696 @@
+/**********************************************************************
+
+  stackprof.c - Sampling call-stack frame profiler for MRI.
+
+  vim: noexpandtab shiftwidth=4 tabstop=8 softtabstop=4
+
+**********************************************************************/
+
+#include <ruby/ruby.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 <pthread.h>
+
+#define BUF_SIZE 2048
+
+typedef struct {
+    size_t total_samples;
+    size_t caller_samples;
+    size_t seen_at_sample_number;
+    st_table *edges;
+    st_table *lines;
+} frame_data_t;
+
+static struct {
+    int running;
+    int raw;
+    int aggregate;
+
+    VALUE mode;
+    VALUE interval;
+    VALUE out;
+
+    VALUE *raw_samples;
+    size_t raw_samples_len;
+    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;
+
+    size_t overall_signals;
+    size_t overall_samples;
+    size_t during_gc;
+    size_t unrecorded_gc_samples;
+    st_table *frames;
+
+    VALUE fake_gc_frame;
+    VALUE fake_gc_frame_name;
+    VALUE empty_string;
+    VALUE frames_buffer[BUF_SIZE];
+    int lines_buffer[BUF_SIZE];
+} _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_frames, sym_out, sym_aggregate, sym_raw_timestamp_deltas;
+static VALUE sym_gc_samples, objtracer;
+static VALUE gc_hook;
+static VALUE rb_mStackProf;
+
+static void stackprof_newobj_handler(VALUE, void*);
+static void stackprof_signal_handler(int sig, siginfo_t* sinfo, void* ucontext);
+
+static VALUE
+stackprof_start(int argc, VALUE *argv, VALUE self)
+{
+    struct sigaction sa;
+    struct itimerval timer;
+    VALUE opts = Qnil, mode = Qnil, interval = Qnil, out = Qfalse;
+    int raw = 0, aggregate = 1;
+
+    if (_stackprof.running)
+	return Qfalse;
+
+    rb_scan_args(argc, argv, "0:", &opts);
+
+    if (RTEST(opts)) {
+	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_raw)))
+	    raw = 1;
+	if (rb_hash_lookup2(opts, sym_aggregate, Qundef) == Qfalse)
+	    aggregate = 0;
+    }
+    if (!RTEST(mode)) mode = sym_wall;
+
+    if (!_stackprof.frames) {
+	_stackprof.frames = st_init_numtable();
+	_stackprof.overall_signals = 0;
+	_stackprof.overall_samples = 0;
+	_stackprof.during_gc = 0;
+    }
+
+    if (mode == sym_object) {
+	if (!RTEST(interval)) interval = INT2FIX(1);
+
+	objtracer = rb_tracepoint_new(Qnil, RUBY_INTERNAL_EVENT_NEWOBJ, stackprof_newobj_handler, 0);
+	rb_tracepoint_enable(objtracer);
+    } else if (mode == sym_wall || mode == sym_cpu) {
+	if (!RTEST(interval)) interval = INT2FIX(1000);
+
+	sa.sa_sigaction = stackprof_signal_handler;
+	sa.sa_flags = SA_RESTART | SA_SIGINFO;
+	sigemptyset(&sa.sa_mask);
+	sigaction(mode == sym_wall ? SIGALRM : SIGPROF, &sa, NULL);
+
+	timer.it_interval.tv_sec = 0;
+	timer.it_interval.tv_usec = NUM2LONG(interval);
+	timer.it_value = timer.it_interval;
+	setitimer(mode == sym_wall ? ITIMER_REAL : ITIMER_PROF, &timer, 0);
+    } else if (mode == sym_custom) {
+	/* sampled manually */
+	interval = Qnil;
+    } else {
+	rb_raise(rb_eArgError, "unknown profiler mode");
+    }
+
+    _stackprof.running = 1;
+    _stackprof.raw = raw;
+    _stackprof.aggregate = aggregate;
+    _stackprof.mode = mode;
+    _stackprof.interval = interval;
+    _stackprof.out = out;
+
+    if (raw) {
+	gettimeofday(&_stackprof.last_sample_at, NULL);
+    }
+
+    return Qtrue;
+}
+
+static VALUE
+stackprof_stop(VALUE self)
+{
+    struct sigaction sa;
+    struct itimerval timer;
+
+    if (!_stackprof.running)
+	return Qfalse;
+    _stackprof.running = 0;
+
+    if (_stackprof.mode == sym_object) {
+	rb_tracepoint_disable(objtracer);
+    } else 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);
+
+	sa.sa_handler = SIG_IGN;
+	sa.sa_flags = SA_RESTART;
+	sigemptyset(&sa.sa_mask);
+	sigaction(_stackprof.mode == sym_wall ? SIGALRM : SIGPROF, &sa, NULL);
+    } else if (_stackprof.mode == sym_custom) {
+	/* sampled manually */
+    } else {
+	rb_raise(rb_eArgError, "unknown profiler mode");
+    }
+
+    return Qtrue;
+}
+
+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));
+    return ST_CONTINUE;
+}
+
+static int
+frame_lines_i(st_data_t key, st_data_t val, st_data_t arg)
+{
+    VALUE lines = (VALUE)arg;
+
+    size_t weight = (size_t)val;
+    size_t total = weight & (~(size_t)0 << (8*SIZEOF_SIZE_T/2));
+    weight -= total;
+    total = total >> (8*SIZEOF_SIZE_T/2);
+    rb_hash_aset(lines, INT2FIX(key), rb_ary_new3(2, ULONG2NUM(total), ULONG2NUM(weight)));
+    return ST_CONTINUE;
+}
+
+static int
+frame_i(st_data_t key, st_data_t val, st_data_t arg)
+{
+    VALUE frame = (VALUE)key;
+    frame_data_t *frame_data = (frame_data_t *)val;
+    VALUE results = (VALUE)arg;
+    VALUE details = rb_hash_new();
+    VALUE name, file, edges, lines;
+    VALUE line;
+
+    rb_hash_aset(results, rb_obj_id(frame), details);
+
+    if (frame == _stackprof.fake_gc_frame) {
+	name = _stackprof.fake_gc_frame_name;
+	file = _stackprof.empty_string;
+	line = INT2FIX(0);
+    } else {
+	name = rb_profile_frame_full_label(frame);
+
+	file = rb_profile_frame_absolute_path(frame);
+	if (NIL_P(file))
+	    file = rb_profile_frame_path(frame);
+	line = rb_profile_frame_first_lineno(frame);
+    }
+
+    rb_hash_aset(details, sym_name, name);
+    rb_hash_aset(details, sym_file, file);
+    if (line != INT2FIX(0)) {
+	rb_hash_aset(details, sym_line, line);
+    }
+
+    rb_hash_aset(details, sym_total_samples, SIZET2NUM(frame_data->total_samples));
+    rb_hash_aset(details, sym_samples, SIZET2NUM(frame_data->caller_samples));
+
+    if (frame_data->edges) {
+        edges = rb_hash_new();
+        rb_hash_aset(details, sym_edges, edges);
+        st_foreach(frame_data->edges, frame_edges_i, (st_data_t)edges);
+        st_free_table(frame_data->edges);
+        frame_data->edges = NULL;
+    }
+
+    if (frame_data->lines) {
+	lines = rb_hash_new();
+	rb_hash_aset(details, sym_lines, lines);
+	st_foreach(frame_data->lines, frame_lines_i, (st_data_t)lines);
+	st_free_table(frame_data->lines);
+	frame_data->lines = NULL;
+    }
+
+    xfree(frame_data);
+    return ST_DELETE;
+}
+
+static VALUE
+stackprof_results(int argc, VALUE *argv, VALUE self)
+{
+    VALUE results, frames;
+
+    if (!_stackprof.frames || _stackprof.running)
+	return Qnil;
+
+    results = rb_hash_new();
+    rb_hash_aset(results, sym_version, DBL2NUM(1.2));
+    rb_hash_aset(results, sym_mode, _stackprof.mode);
+    rb_hash_aset(results, sym_interval, _stackprof.interval);
+    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));
+
+    frames = rb_hash_new();
+    rb_hash_aset(results, sym_frames, frames);
+    st_foreach(_stackprof.frames, frame_i, (st_data_t)frames);
+
+    st_free_table(_stackprof.frames);
+    _stackprof.frames = NULL;
+
+    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++) {
+	    len = (size_t)_stackprof.raw_samples[n];
+	    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, SIZET2NUM((size_t)_stackprof.raw_samples[n]));
+	}
+
+	free(_stackprof.raw_samples);
+	_stackprof.raw_samples = NULL;
+	_stackprof.raw_samples_len = 0;
+	_stackprof.raw_samples_capa = 0;
+	_stackprof.raw_sample_index = 0;
+
+	rb_hash_aset(results, sym_raw, raw_samples);
+
+	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]));
+	}
+
+	free(_stackprof.raw_timestamp_deltas);
+	_stackprof.raw_timestamp_deltas = NULL;
+	_stackprof.raw_timestamp_deltas_len = 0;
+	_stackprof.raw_timestamp_deltas_capa = 0;
+
+	rb_hash_aset(results, sym_raw_timestamp_deltas, raw_timestamp_deltas);
+
+	_stackprof.raw = 0;
+    }
+
+    if (argc == 1)
+	_stackprof.out = argv[0];
+
+    if (RTEST(_stackprof.out)) {
+	VALUE file;
+	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;
+	return file;
+    } else {
+	return results;
+    }
+}
+
+static VALUE
+stackprof_run(int argc, VALUE *argv, VALUE self)
+{
+    rb_need_block();
+    stackprof_start(argc, argv, self);
+    rb_ensure(rb_yield, Qundef, stackprof_stop, self);
+    return stackprof_results(0, 0, self);
+}
+
+static VALUE
+stackprof_running_p(VALUE self)
+{
+    return _stackprof.running ? Qtrue : Qfalse;
+}
+
+static inline frame_data_t *
+sample_for(VALUE frame)
+{
+    st_data_t key = (st_data_t)frame, val = 0;
+    frame_data_t *frame_data;
+
+    if (st_lookup(_stackprof.frames, key, &val)) {
+        frame_data = (frame_data_t *)val;
+    } else {
+        frame_data = ALLOC_N(frame_data_t, 1);
+        MEMZERO(frame_data, frame_data_t, 1);
+        val = (st_data_t)frame_data;
+        st_insert(_stackprof.frames, key, val);
+    }
+
+    return frame_data;
+}
+
+static int
+numtable_increment_callback(st_data_t *key, st_data_t *value, st_data_t arg, int existing)
+{
+    size_t *weight = (size_t *)value;
+    size_t increment = (size_t)arg;
+
+    if (existing)
+	(*weight) += increment;
+    else
+	*weight = increment;
+
+    return ST_CONTINUE;
+}
+
+void
+st_numtable_increment(st_table *table, st_data_t key, size_t increment)
+{
+    st_update(table, key, numtable_increment_callback, (st_data_t)increment);
+}
+
+void
+stackprof_record_sample_for_stack(int num, int timestamp_delta)
+{
+    int i, n;
+    VALUE prev_frame = Qnil;
+
+    _stackprof.overall_samples++;
+
+    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)
+		    break;
+	    }
+	    if (i == -1) {
+		_stackprof.raw_samples[_stackprof.raw_samples_len-1] += 1;
+		found = 1;
+	    }
+	}
+
+	/* 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--) {
+		VALUE frame = _stackprof.frames_buffer[i];
+		_stackprof.raw_samples[_stackprof.raw_samples_len++] = frame;
+	    }
+	    _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++) {
+	int line = _stackprof.lines_buffer[i];
+	VALUE frame = _stackprof.frames_buffer[i];
+	frame_data_t *frame_data = sample_for(frame);
+
+	if (frame_data->seen_at_sample_number != _stackprof.overall_samples) {
+	    frame_data->total_samples++;
+	}
+	frame_data->seen_at_sample_number = _stackprof.overall_samples;
+
+	if (i == 0) {
+	    frame_data->caller_samples++;
+	} else if (_stackprof.aggregate) {
+	    if (!frame_data->edges)
+		frame_data->edges = st_init_numtable();
+	    st_numtable_increment(frame_data->edges, (st_data_t)prev_frame, 1);
+	}
+
+	if (_stackprof.aggregate && line > 0) {
+	    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);
+	}
+
+	prev_frame = frame;
+    }
+
+    if (_stackprof.raw) {
+	gettimeofday(&_stackprof.last_sample_at, NULL);
+    }
+}
+
+void
+stackprof_record_sample()
+{
+    int 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;
+    }
+    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);
+}
+
+void
+stackprof_record_gc_samples()
+{
+    int delta_to_first_unrecorded_gc_sample = 0;
+    int i;
+    if (_stackprof.raw) {
+	struct timeval t;
+	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) * NUM2LONG(_stackprof.interval);
+	if (delta_to_first_unrecorded_gc_sample < 0) {
+	    delta_to_first_unrecorded_gc_sample = 0;
+	}
+    }
+
+    _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 : NUM2LONG(_stackprof.interval);
+	stackprof_record_sample_for_stack(1, timestamp_delta);
+    }
+    _stackprof.during_gc += _stackprof.unrecorded_gc_samples;
+    _stackprof.unrecorded_gc_samples = 0;
+}
+
+static void
+stackprof_gc_job_handler(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--;
+}
+
+static void
+stackprof_job_handler(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--;
+}
+
+static void
+stackprof_signal_handler(int sig, siginfo_t *sinfo, void *ucontext)
+{
+    _stackprof.overall_signals++;
+    if (rb_during_gc()) {
+	_stackprof.unrecorded_gc_samples++;
+	rb_postponed_job_register_one(0, stackprof_gc_job_handler, (void*)0);
+    } else {
+	rb_postponed_job_register_one(0, stackprof_job_handler, (void*)0);
+    }
+}
+
+static void
+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);
+}
+
+static VALUE
+stackprof_sample(VALUE self)
+{
+    if (!_stackprof.running)
+	return Qfalse;
+
+    _stackprof.overall_signals++;
+    stackprof_job_handler(0);
+    return Qtrue;
+}
+
+static int
+frame_mark_i(st_data_t key, st_data_t val, st_data_t arg)
+{
+    VALUE frame = (VALUE)key;
+    rb_gc_mark(frame);
+    return ST_CONTINUE;
+}
+
+static void
+stackprof_gc_mark(void *data)
+{
+    if (RTEST(_stackprof.out))
+	rb_gc_mark(_stackprof.out);
+
+    if (_stackprof.frames)
+	st_foreach(_stackprof.frames, frame_mark_i, 0);
+}
+
+static void
+stackprof_atfork_prepare(void)
+{
+    struct itimerval timer;
+    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);
+	}
+    }
+}
+
+static void
+stackprof_atfork_parent(void)
+{
+    struct itimerval timer;
+    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);
+	    timer.it_value = timer.it_interval;
+	    setitimer(_stackprof.mode == sym_wall ? ITIMER_REAL : ITIMER_PROF, &timer, 0);
+	}
+    }
+}
+
+static void
+stackprof_atfork_child(void)
+{
+    stackprof_stop(rb_mStackProf);
+}
+
+void
+Init_stackprof(void)
+{
+#define S(name) sym_##name = ID2SYM(rb_intern(#name));
+    S(object);
+    S(custom);
+    S(wall);
+    S(cpu);
+    S(name);
+    S(file);
+    S(line);
+    S(total_samples);
+    S(gc_samples);
+    S(missed_samples);
+    S(samples);
+    S(edges);
+    S(lines);
+    S(version);
+    S(mode);
+    S(interval);
+    S(raw);
+    S(raw_timestamp_deltas);
+    S(out);
+    S(frames);
+    S(aggregate);
+#undef S
+
+    gc_hook = Data_Wrap_Struct(rb_cObject, stackprof_gc_mark, NULL, &_stackprof);
+    rb_global_variable(&gc_hook);
+
+    _stackprof.raw_samples = NULL;
+    _stackprof.raw_samples_len = 0;
+    _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.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);
+
+    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);
+    rb_define_singleton_method(rb_mStackProf, "start", stackprof_start, -1);
+    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);
+
+    pthread_atfork(stackprof_atfork_prepare, stackprof_atfork_parent, stackprof_atfork_child);
+}

data/lib/stackprof.rb

@@ -1,4 +1,8 @@
 require "stackprof/stackprof"
 
+module StackProf
+  VERSION = '0.2.13'
+end
+
 StackProf.autoload :Report, "stackprof/report.rb"
 StackProf.autoload :Middleware, "stackprof/middleware.rb"

data/lib/stackprof/report.rb

@@ -68,6 +68,11 @@ module StackProf
       f.puts Marshal.dump(@data.reject{|k,v| k == :files })
     end
 
+    def print_json(f=STDOUT)
+      require "json"
+      f.puts JSON.generate(@data, max_nesting: false)
+    end
+
     def print_stackcollapse
       raise "profile does not include raw samples (add `raw: true` to collecting StackProf.run)" unless raw = data[:raw]
 
@@ -80,7 +85,15 @@ module StackProf
       end
     end
 
-    def print_flamegraph(f=STDOUT, skip_common=true)
+    def print_timeline_flamegraph(f=STDOUT, skip_common=true)
+      print_flamegraph(f, skip_common, false)
+    end
+
+    def print_alphabetical_flamegraph(f=STDOUT, skip_common=true)
+      print_flamegraph(f, skip_common, true)
+    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 = []
@@ -93,6 +106,8 @@ module StackProf
         max_x += stack.last
       end
 
+      stacks.sort! if alphabetical
+
       f.puts 'flamegraph(['
       max_y.times do |y|
         row_prev = nil
@@ -148,6 +163,216 @@ module StackProf
       f.puts %{{"x":#{x},"y":#{y},"width":#{weight},"frame_id":#{addr},"frame":#{frame[:name].dump},"file":#{frame[:file].dump}}}
     end
 
+    def convert_to_d3_flame_graph_format(name, stacks, depth)
+      weight = 0
+      children = []
+      stacks.chunk do |stack|
+        if depth == stack.length - 1
+          :leaf
+        else
+          stack[depth]
+        end
+      end.each do |val, child_stacks|
+        if val == :leaf
+          child_stacks.each do |stack|
+            weight += stack.last
+          end
+        else
+          frame = frames[val]
+          child_name = "#{ frame[:name] } : #{ frame[:file] }"
+          child_data = convert_to_d3_flame_graph_format(child_name, child_stacks, depth + 1)
+          weight += child_data["value"]
+          children << child_data
+        end
+      end
+
+      {
+        "name" => name,
+        "value" => weight,
+        "children" => children,
+      }
+    end
+
+    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
+
+      # d3-flame-grpah supports only alphabetical flamegraph
+      stacks.sort!
+
+      require "json"
+      json = JSON.generate(convert_to_d3_flame_graph_format("<root>", stacks, 0), max_nesting: false)
+
+      # This html code is almost copied from d3-flame-graph sample code.
+      # (Apache License 2.0)
+      # https://github.com/spiermar/d3-flame-graph/blob/gh-pages/index.html
+
+      f.print <<-END
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+
+    <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css">
+    <link rel="stylesheet" type="text/css" href="https://cdn.jsdelivr.net/gh/spiermar/d3-flame-graph@2.0.3/dist/d3-flamegraph.css">
+
+    <style>
+
+    /* Space out content a bit */
+    body {
+      padding-top: 20px;
+      padding-bottom: 20px;
+    }
+
+    /* Custom page header */
+    .header {
+      padding-bottom: 20px;
+      padding-right: 15px;
+      padding-left: 15px;
+      border-bottom: 1px solid #e5e5e5;
+    }
+
+    /* Make the masthead heading the same height as the navigation */
+    .header h3 {
+      margin-top: 0;
+      margin-bottom: 0;
+      line-height: 40px;
+    }
+
+    /* Customize container */
+    .container {
+      max-width: 990px;
+    }
+
+    address {
+      text-align: right;
+    }
+    </style>
+
+    <title>stackprof (mode: #{ data[:mode] })</title>
+
+    <!-- HTML5 shim and Respond.js for IE8 support of HTML5 elements and media queries -->
+    <!--[if lt IE 9]>
+      <script src="https://oss.maxcdn.com/html5shiv/3.7.2/html5shiv.min.js"></script>
+      <script src="https://oss.maxcdn.com/respond/1.4.2/respond.min.js"></script>
+    <![endif]-->
+  </head>
+  <body>
+    <div class="container">
+      <div class="header clearfix">
+        <nav>
+          <div class="pull-right">
+            <form class="form-inline" id="form">
+              <a class="btn" href="javascript: resetZoom();">Reset zoom</a>
+              <a class="btn" href="javascript: clear();">Clear</a>
+              <div class="form-group">
+                <input type="text" class="form-control" id="term">
+              </div>
+              <a class="btn btn-primary" href="javascript: search();">Search</a>
+            </form>
+          </div>
+        </nav>
+        <h3 class="text-muted">stackprof (mode: #{ data[:mode] })</h3>
+      </div>
+      <div id="chart">
+      </div>
+      <address>
+        powered by <a href="https://github.com/spiermar/d3-flame-graph">d3-flame-graph</a>
+      </address>
+      <hr>
+      <div id="details">
+      </div>
+    </div>
+
+    <!-- D3.js -->
+    <script src="https://d3js.org/d3.v4.min.js" charset="utf-8"></script>
+
+    <!-- d3-tip -->
+    <script type="text/javascript" src=https://cdnjs.cloudflare.com/ajax/libs/d3-tip/0.9.1/d3-tip.min.js></script>
+
+    <!-- d3-flamegraph -->
+    <script type="text/javascript" src="https://cdn.jsdelivr.net/gh/spiermar/d3-flame-graph@2.0.3/dist/d3-flamegraph.min.js"></script>
+
+    <script type="text/javascript">
+    var flameGraph = d3.flamegraph()
+      .width(960)
+      .cellHeight(18)
+      .transitionDuration(750)
+      .minFrameSize(5)
+      .transitionEase(d3.easeCubic)
+      .sort(true)
+      //Example to sort in reverse order
+      //.sort(function(a,b){ return d3.descending(a.name, b.name);})
+      .title("")
+      .onClick(onClick)
+      .differential(false)
+      .selfValue(false);
+
+
+    // Example on how to use custom tooltips using d3-tip.
+    // var tip = d3.tip()
+    //   .direction("s")
+    //   .offset([8, 0])
+    //   .attr('class', 'd3-flame-graph-tip')
+    //   .html(function(d) { return "name: " + d.data.name + ", value: " + d.data.value; });
+
+    // flameGraph.tooltip(tip);
+
+    var details = document.getElementById("details");
+    flameGraph.setDetailsElement(details);
+
+    // Example on how to use custom labels
+    // var label = function(d) {
+    //  return "name: " + d.name + ", value: " + d.value;
+    // }
+    // flameGraph.label(label);
+
+    // Example of how to set fixed chart height
+    // flameGraph.height(540);
+
+    d3.select("#chart")
+        .datum(#{ json })
+        .call(flameGraph);
+
+    document.getElementById("form").addEventListener("submit", function(event){
+      event.preventDefault();
+      search();
+    });
+
+    function search() {
+      var term = document.getElementById("term").value;
+      flameGraph.search(term);
+    }
+
+    function clear() {
+      document.getElementById('term').value = '';
+      flameGraph.clear();
+    }
+
+    function resetZoom() {
+      flameGraph.resetZoom();
+    }
+
+    function onClick(d) {
+      console.info("Clicked on " + d.data.name);
+    }
+    </script>
+  </body>
+</html>
+      END
+    end
+
     def print_graphviz(options = {}, f = STDOUT)
       if filter = options[:filter]
         mark_stack = []

data/stackprof.gemspec

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

data/test/test_stackprof.rb

@@ -2,6 +2,7 @@ $:.unshift File.expand_path('../../lib', __FILE__)
 require 'stackprof'
 require 'minitest/autorun'
 require 'tempfile'
+require 'pathname'
 
 class StackProfTest < MiniTest::Test
   def test_info
@@ -167,6 +168,32 @@ class StackProfTest < MiniTest::Test
     refute_empty profile[:frames]
   end
 
+  def test_out_to_path_string
+    tmpfile = Tempfile.new('stackprof-out')
+    ret = StackProf.run(mode: :custom, out: tmpfile.path) do
+      StackProf.sample
+    end
+
+    refute_equal tmpfile, ret
+    assert_equal tmpfile.path, ret.path
+    tmpfile.rewind
+    profile = Marshal.load(tmpfile.read)
+    refute_empty profile[:frames]
+  end
+
+  def test_pathname_out
+    tmpfile  = Tempfile.new('stackprof-out')
+    pathname = Pathname.new(tmpfile.path)
+    ret = StackProf.run(mode: :custom, out: pathname) do
+      StackProf.sample
+    end
+
+    assert_equal tmpfile.path, ret.path
+    tmpfile.rewind
+    profile = Marshal.load(tmpfile.read)
+    refute_empty profile[:frames]
+  end
+
   def math
     250_000.times do
       2 ** 10

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stackprof
 version: !ruby/object:Gem::Version
-  version: 0.2.12
+  version: 0.2.13
 platform: ruby
 authors:
 - Aman Gupta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-06-29 00:00:00.000000000 Z
+date: 2019-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -66,6 +66,7 @@ files:
 - ".gitignore"
 - ".travis.yml"
 - CHANGELOG.md
+- Dockerfile
 - Gemfile
 - Gemfile.lock
 - LICENSE
@@ -109,8 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 3.1.0.pre1
 signing_key: 
 specification_version: 4
 summary: sampling callstack-profiler for ruby 2.1+