flamegraph 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d5843c5d2ae0e8009e59a7b2ae1be5866801f7f2
+  data.tar.gz: 2c8783c5494d36e030917705e56469f22bb7ad33
+SHA512:
+  metadata.gz: 5eb5c07f7b53389bad117144637dced3282e0db7d8b16fec95b293e3f7d30ea53fe3908fa27cf27fa487099c19745d858ac51fb0a53a60577063cc9ba25e1ccf
+  data.tar.gz: 23c5aff03a944b3658dd7ec3beba84c9e5ce3439d1012a5e26c68e796b30800276e38143e07e7bc47e1f0201f8c54602e68f2991858cce45728fba708ff35346

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.swp
+demo/graph.html

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in flamegraph.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Sam Saffron
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Flamegraph
+
+Flamegraph support for arbitrary Ruby apps
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'flamegraph'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install flamegraph
+
+## Usage
+
+Note: Only supported on Ruby 2.0. Gathering stack traces is too slow on earlier versions of Ruby or JRuby
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/demo/demo.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift File.expand_path '../lib'
+require File.expand_path('../../lib/flamegraph', __FILE__)
+
+def ack(m, n)
+  if (m == 0)
+    n + 1
+  elsif (n == 0)
+    ack(m - 1, 1)
+  else
+    ack(m - 1, ack(m, n - 1))
+  end
+end
+
+graph = Flamegraph.generate do
+  ack(3,7)
+end
+
+Flamegraph.generate("graph.html") do
+  ack(3,7)
+end
+

data/flamegraph.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'flamegraph/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "flamegraph"
+  spec.version       = Flamegraph::VERSION
+  spec.authors       = ["Sam Saffron"]
+  spec.email         = ["sam.saffron@gmail.com"]
+  spec.description   = %q{Flamegraph support for arbitrary ruby apps}
+  spec.summary       = %q{Flamegraph support for arbitrary ruby apps}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+end

data/lib/flamegraph.rb

@@ -0,0 +1,23 @@
+require "json"
+require "flamegraph/version"
+require "flamegraph/sampler"
+require "flamegraph/renderer"
+
+module Flamegraph
+  def self.generate(filename=nil)
+    sampler = Flamegraph::Sampler.new
+    sampler.start
+    yield
+    results = sampler.finish
+
+    renderer = Flamegraph::Renderer.new(results)
+    result = renderer.graph_html
+
+    if filename
+      File.open(filename,"w") do |f|
+        f.write(result)
+      end
+    end
+    result
+  end
+end

data/lib/flamegraph/flamegraph.html

@@ -0,0 +1,325 @@
+<!DOCTYPE html>
+<html>
+<head>
+<script src="http://code.jquery.com/jquery-1.9.1.min.js"></script>
+<script src="http://cdnjs.cloudflare.com/ajax/libs/d3/3.0.8/d3.min.js"></script>
+<meta charset=utf-8 />
+<title>Flame Graph of Page</title>
+<style>
+  .info {height: 40px;}
+  .legend div {
+    display: block;
+    float: left;
+    width: 150px;
+    margin: 0 8px 8px;
+    padding: 4px;
+    height: 50px;
+  }
+</style>
+</head>
+<body>
+  <div class="graph"></div>
+  <div class="info"></div>
+  <div class="legend"></div>
+
+  <script>
+
+var data = /*DATA*/;
+var maxX = 0;
+var maxY = 0;
+
+debounce = function(func, wait, trickle) {
+  var timeout;
+
+  timeout = null;
+  return function() {
+    var args, context, currentWait, later;
+    context = this;
+    args = arguments;
+    later = function() {
+      timeout = null;
+      return func.apply(context, args);
+    };
+
+    if (timeout && trickle) {
+      // already queued, let it through
+      return;
+    }
+
+    if (typeof wait === "function") {
+      currentWait = wait();
+    } else {
+      currentWait = wait;
+    }
+
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+
+    timeout = setTimeout(later, currentWait);
+    return timeout;
+  };
+};
+
+
+var guessGem = function(frame)
+{
+  var split = frame.split('/gems/');
+  if(split.length == 1) {
+    split = frame.split('/app/');
+    if(split.length == 1) {
+      split = frame.split('/lib/');
+    }
+
+    split = split[Math.max(split.length-2,0)].split('/');
+    return split[split.length-1];
+  }
+  else
+  {
+    return split[split.length -1].split('/')[0];
+  }
+}
+
+var guessMethod = function(frame) {
+  var split = frame.split('`');
+  if(split.length == 2) {
+    return split[1].split("'")[0];
+  }
+  return '?';
+}
+
+var guessFile = function(frame) {
+  var split = frame.split(".rb:");
+  if(split.length == 2) {
+    split = split[0].split('/');
+    return split[split.length - 1];
+  }
+  return "";
+}
+
+$.each(data, function(){
+   maxX = Math.max(maxX, this.x + this.width);
+   maxY = Math.max(maxY, this.y);
+   this.shortName = /* guessGem(this.frame) + " " + guessFile(this.frame) + " "  */ guessMethod(this.frame);
+});
+
+var width = $(window).width();
+var height = $(window).height() / 1.2;
+
+$('.graph').width(width).height(height);
+
+var xScale = d3.scale.linear()
+	.domain([0, maxX])
+    .range([0, width]);
+
+var yScale = d3.scale.linear()
+    .domain([0, maxY])
+    .range([0,height]);
+
+var realHeight = 0;
+var debouncedHeightCheck = debounce(function(){
+  if (realHeight > 15) {
+    svg.selectAll('text').attr('display','show');
+  } else {
+    svg.selectAll('text').attr('display','none');
+  }
+}, 200);
+
+function zoom()
+{
+  svg.attr("transform", "translate(" + d3.event.translate + ")" + " scale(" + d3.event.scale + ")");
+
+  realHeight = yScale(1) * d3.event.scale;
+  debouncedHeightCheck();
+}
+
+var svg = d3.select(".graph")
+                    .append("svg")
+                    .attr("width", "100%")
+                    .attr("height", "100%")
+                    .attr("pointer-events", "all")
+                    .append('svg:g')
+                    .call(d3.behavior.zoom().on("zoom", zoom))
+                    .append('svg:g');
+
+
+// so zoom works everywhere
+svg.append("rect")
+    .attr("x",function(d) { return xScale(0); })
+    .attr("y",function(d) { return yScale(0);})
+    .attr("width", function(d){return xScale(maxX);})
+    .attr("height", yScale(maxY))
+    .attr("fill", "white");
+
+var color = function() {
+  var r = parseInt(205 + Math.random() * 50);
+  var g = parseInt(Math.random() * 230);
+  var b = parseInt(Math.random() * 55);
+  return "rgb(" + r + "," + g + "," + b + ")";
+}
+var info = {};
+
+// http://stackoverflow.com/questions/1960473/unique-values-in-an-array
+Array.prototype.getUnique = function() {
+    var o = {}, a = []
+    for (var i = 0; i < this.length; i++) o[this[i]] = 1
+    for (var e in o) a.push(e)
+    return a
+}
+
+var samplePercent = function(samples){
+  return "(" + samples +
+    " sample" + (samples == 1 ? "" : "s") + " - " +
+    ((samples / maxX) * 100).toFixed(2) + "%)";
+}
+
+var mouseover =  function(d) {
+  var i = info[d.frame];
+  $('.info').text( d.frame + " " + samplePercent(i.samples.length));
+  d3.selectAll(i.nodes)
+     .attr('opacity',0.5);
+};
+
+var mouseout = function(d) {
+  var i = info[d.frame];
+  $('.info').text("");
+  d3.selectAll(i.nodes)
+     .attr('opacity',1);
+};
+
+// http://stackoverflow.com/a/7419630
+var rainbow = function(numOfSteps, step) {
+    // This function generates vibrant, "evenly spaced" colours (i.e. no clustering). This is ideal for creating easily distiguishable vibrant markers in Google Maps and other apps.
+    // Adam Cole, 2011-Sept-14
+    // HSV to RBG adapted from: http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript
+    var r, g, b;
+    var h = step / numOfSteps;
+    var i = ~~(h * 6);
+    var f = h * 6 - i;
+    var q = 1 - f;
+    switch(i % 6){
+        case 0: r = 1, g = f, b = 0; break;
+        case 1: r = q, g = 1, b = 0; break;
+        case 2: r = 0, g = 1, b = f; break;
+        case 3: r = 0, g = q, b = 1; break;
+        case 4: r = f, g = 0, b = 1; break;
+        case 5: r = 1, g = 0, b = q; break;
+    }
+    var c = "#" + ("00" + (~ ~(r * 255)).toString(16)).slice(-2) + ("00" + (~ ~(g * 255)).toString(16)).slice(-2) + ("00" + (~ ~(b * 255)).toString(16)).slice(-2);
+    return (c);
+}
+
+// assign some colors, analyze samples per gem
+var gemStats = {}
+
+$.each(data, function(){
+
+  var gem = guessGem(this.frame);
+  var stat = gemStats[gem];
+
+  if(!stat) {
+    gemStats[gem] = stat = {samples: [], frames: []};
+  }
+
+  stat.frames.push(this.frame);
+  for(var j=0; j < this.width; j++){
+    stat.samples.push(this.x + j);
+  }
+});
+
+var totalGems = 0;
+$.each(gemStats, function(){totalGems++;});
+
+
+var currentIndex = 0;
+$.each(gemStats, function(k,stat){
+
+  stat.color = rainbow(totalGems, currentIndex);
+  stat.samples = stat.samples.getUnique();
+
+  for(var x=0; x < stat.frames.length; x++) {
+    info[stat.frames[x]] = {nodes: [], samples: [], color: stat.color};
+  }
+
+  currentIndex += 1;
+});
+
+
+// see: http://bl.ocks.org/mundhradevang/1387786
+function fontSize(d,i) {
+  var size = yScale(1) / 3;
+  // var words = d.shortName.split(' ');
+  var word = d.shortName; // words[0];
+  var width = xScale(d.width+100);
+  var height = yScale(1);
+  var length = 0;
+  d3.select(this).style("font-size", size + "px").text(word);
+  while(((this.getBBox().width >= width) || (this.getBBox().height >= height)) && (size > 12))
+   {
+    size -= 0.1;
+    d3.select(this).style("font-size", size + "px");
+   }
+
+   d3.select(this).attr("dy", size);
+}
+
+svg.selectAll("g")
+	.data(data)
+	.enter()
+    .append("g")
+    .each(function(){
+      d3.select(this)
+      .append("rect")
+      .attr("x",function(d) { return xScale(d.x-1); })
+      .attr("y",function(d) { return yScale(maxY - d.y);})
+      .attr("width", function(d){return xScale(d.width);})
+      .attr("height", yScale(1))
+      .attr("fill", function(d){
+        var i = info[d.frame];
+        if(!i) {
+          info[d.frame] = i = {nodes: [], samples: [], color: color()};
+        }
+        i.nodes.push(this);
+        for(var j=0; j < d.width; j++){
+          i.samples.push(d.x + j);
+        }
+        return i.color;
+      })
+      .on("mouseover", mouseover)
+      .on("mouseout", mouseout);
+
+      d3.select(this)
+        .append("text")
+        .attr("x",function(d) { return xScale(d.x - 0.98); })
+        .attr("y",function(d) { return yScale(maxY - d.y);})
+        .on("mouseover", mouseover)
+        .on("mouseout", mouseout)
+        .each(fontSize)
+        .attr("display", "none");
+
+    });
+
+
+// Samples may overlap on the same line
+for (var r in info) {
+  if (info[r].samples) {
+    info[r].samples = info[r].samples.getUnique();
+  }
+};
+
+
+// render the legend
+$.each(gemStats, function(k,v){
+  var node = $("<div></div>")
+    .css("background-color", v.color)
+    .text(k + " " + samplePercent(v.samples.length)) ;
+  $('.legend').append(node);
+});
+
+
+
+  </script>
+</body>
+</html>
+
+

data/lib/flamegraph/renderer.rb

@@ -0,0 +1,61 @@
+# inspired by https://github.com/brendangregg/FlameGraph
+
+class Flamegraph::Renderer
+  def initialize(stacks)
+    @stacks = stacks
+  end
+
+  def graph_html
+    body = IO.read(::File.expand_path('flamegraph.html', ::File.dirname(__FILE__)))
+    body.sub!("/*DATA*/", ::JSON.generate(graph_data));
+    body
+  end
+
+  def graph_data
+    height = 0
+
+    table = []
+    prev = []
+
+    # a 2d array makes collapsing easy
+    @stacks.each_with_index do |stack, pos|
+      col = []
+
+      stack.reverse.map{|r| r.to_s}.each_with_index do |frame, i|
+
+        if !prev[i].nil?
+          last_col = prev[i]
+          if last_col[0] == frame
+            last_col[1] += 1
+            col << nil
+            next
+          end
+        end
+
+        prev[i] = [frame, 1]
+        col << prev[i]
+      end
+      prev = prev[0..col.length-1].to_a
+      table << col
+    end
+
+    data = []
+
+    # a 1d array makes rendering easy
+    table.each_with_index do |col, col_num|
+      col.each_with_index do |row, row_num|
+        next unless row && row.length == 2
+        data << {
+          :x => col_num + 1,
+          :y => row_num + 1,
+          :width => row[1],
+          :frame => row[0]
+        }
+      end
+    end
+
+    data
+  end
+
+end
+

data/lib/flamegraph/sampler.rb

@@ -0,0 +1,32 @@
+class Flamegraph::Sampler
+
+  def initialize
+    @backtraces = []
+    @done_samplint = false
+  end
+
+  def start
+    @backtraces = []
+    @done_samplint = false
+
+    t = Thread.current
+    @thread = Thread.new do
+      begin
+        while !@done_sampling
+          @backtraces << t.backtrace_locations
+
+          # On my machine using Ruby 2.0 this give me excellent fidelity of stack trace per 1.2ms
+          #   with this fidelity analysis becomes very powerful
+          sleep 0.0005
+        end
+      end
+    end
+  end
+
+  def finish
+    @done_sampling = true
+    @thread.join
+    @backtraces
+  end
+
+end

data/lib/flamegraph/version.rb

@@ -0,0 +1,3 @@
+module Flamegraph
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: flamegraph
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sam Saffron
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Flamegraph support for arbitrary ruby apps
+email:
+- sam.saffron@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- demo/demo.rb
+- flamegraph.gemspec
+- lib/flamegraph.rb
+- lib/flamegraph/flamegraph.html
+- lib/flamegraph/renderer.rb
+- lib/flamegraph/sampler.rb
+- lib/flamegraph/version.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Flamegraph support for arbitrary ruby apps
+test_files: []