stackflame 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1b3079b183df5c34aa2346423f760c4f46447cd7
+  data.tar.gz: fd0ff8bde7e03b081eb2436c7465928a5b39e084
+SHA512:
+  metadata.gz: cc074f970f4423ce0d9cbc1f59832836e70b4c51b4740c8abb7c99d010f4eb0b52bd192fb772bcd33780a89ab530ec8cd58c915b5ae96a2c8e1c6b65ee2d95f7
+  data.tar.gz: b85c35082cb6ef953ca518d2033199ddb12979e82b63d81d5e0ebdbbbf51abe3e9050d14dac08f635c68cee2b5d4233ebaf8a847c7e434d93647c7177a4eb05f

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+*.sqlite3
+mkmf.log

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Takashi Kokubun
+
+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,28 @@
+# Stackflame
+
+Stackflame provides a simple API to deal with Flamegraph of [stackprof](https://github.com/tmm1/stackprof).
+
+## Installation
+
+```bash
+$ gem install stackflame
+```
+
+## Usage
+
+```ruby
+require "stackflame"
+
+Stackflame.profile do
+  # some code to profile
+  100.times { User.create }
+end
+```
+
+If you use OSX, flamegraph will be opened with your default browser.
+
+![](http://i.gyazo.com/47871c2de985298c61d0fcca041a34d0.png)
+
+## License
+
+MIT License

data/Rakefile

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

data/example/ar_profile.rb

@@ -0,0 +1,23 @@
+require "active_record"
+require "yaml"
+require "stackflame"
+
+Stackflame.profile do
+  ActiveRecord::Base.configurations["profile"] = {
+    adapter: "sqlite3",
+    database: "test.sqlite3",
+    pool: 5,
+    timeout: 5000,
+  }
+  ActiveRecord::Base.establish_connection :profile
+
+  ActiveRecord::Schema.define do
+    create_table :users, force: true do |t|
+      t.column :created_at, :datetime
+      t.column :updated_at, :datetime
+    end
+  end
+
+  class User < ActiveRecord::Base; end
+  100.times { User.create }
+end

data/lib/stackflame/version.rb

@@ -0,0 +1,3 @@
+class Stackflame
+  VERSION = "0.0.1"
+end

data/lib/stackflame.rb

@@ -0,0 +1,43 @@
+require "stackflame/version"
+require "stackprof"
+
+class Stackflame
+  def self.profile(mode: :cpu, &block)
+    stackflame = self.new
+    stackflame.run(mode, &block)
+    stackflame.open_flamegraph
+  end
+
+  def run(mode, &block)
+    result = StackProf.run(mode: mode, raw: true, &block)
+
+    File.open(temp_js_path, 'w') do |f|
+      StackProf::Report.new(result).print_flamegraph(f)
+    end
+  end
+
+  def open_flamegraph
+    if system("which osascript > /dev/null")
+      # NOTE: `open` can't open path with query string
+      `osascript -e 'open location "#{flamegraph_path}"'`
+    else
+      puts "This OS is not supported. Please open: #{flamegraph_path}"
+    end
+  end
+
+  private
+
+  def flamegraph_path
+    viewer_path = File.expand_path('../../vendor/viewer.html', __FILE__)
+    "file://#{viewer_path}?data=#{temp_js_path}"
+  end
+
+  def temp_js_path
+    return @js_path if @js_path
+
+    temp = `mktemp /tmp/stackflame-XXXXXXXX`.strip
+    @js_path = "#{temp}.js"
+    `mv #{temp} #{@js_path}`
+    @js_path
+  end
+end

data/stackflame.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'stackflame/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "stackflame"
+  spec.version       = Stackflame::VERSION
+  spec.authors       = ["Takashi Kokubun"]
+  spec.email         = ["takashikkbn@gmail.com"]
+  spec.summary       = %q{Stackflame provides a simple API to deal with Flamegraph of stackprof.}
+  spec.description   = %q{Stackflame provides a simple API to deal with Flamegraph of stackprof.}
+  spec.homepage      = "https://github.com/k0kubun/stackflame"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "stackprof", "~> 0.2.7"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "activerecord", "~> 4.1"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "pry"
+end

data/vendor/flamegraph.js

@@ -0,0 +1,357 @@
+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/');
+    } else {
+      return split[split.length-1].split('/')[0]
+    }
+
+    split = split[Math.max(split.length-2,0)].split('/');
+    return split[split.length-1].split(':')[0];
+  }
+  else
+  {
+    return split[split.length -1].split('/')[0].split('-', 2)[0];
+  }
+}
+
+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 + ")";
+}
+
+// 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);
+}
+
+// http://stackoverflow.com/questions/1960473/unique-values-in-an-array
+var getUnique = function(orig) {
+    var o = {}, a = []
+    for (var i = 0; i < orig.length; i++) o[orig[i]] = 1
+    for (var e in o) a.push(e)
+    return a
+}
+
+function flamegraph(data) {
+  var maxX = 0;
+  var maxY = 0;
+  var minY = 10000;
+  $.each(data, function(){
+     maxX = Math.max(maxX, this.x + this.width);
+     maxY = Math.max(maxY, this.y);
+     minY = Math.min(minY, this.y);
+  });
+
+  // normalize Y
+  if (minY > 0) {
+    $.each(data, function(){
+      this.y -= minY
+    })
+    maxY -= minY
+    minY = 0
+  }
+
+  var margin = {top: 10, right: 10, bottom: 10, left: 10}
+  var width = $(window).width() - 200 - margin.left - margin.right;
+  var height = $(window).height() * 0.70 - margin.top - margin.bottom;
+  var height2 = $(window).height() * 0.30 - 60 - margin.top - margin.bottom;
+
+  $('.flamegraph').width(width + margin.left + margin.right).height(height + margin.top + margin.bottom);
+  $('.zoom').width(width + margin.left + margin.right).height(height2 + margin.top + margin.bottom);
+
+  var xScale = d3.scale.linear()
+    .domain([0, maxX])
+    .range([0, width]);
+
+  var xScale2 = d3.scale.linear()
+    .domain([0, maxX])
+    .range([0, width])
+
+  var yScale = d3.scale.linear()
+      .domain([0, maxY])
+      .range([0,height]);
+
+  var yScale2 = d3.scale.linear()
+      .domain([0, maxY])
+      .range([0,height2]);
+
+  var zoomXRatio = 1
+  var zoomed = function() {
+    svg.attr("transform", "translate(" + d3.event.translate + ")" + " scale(" + (zoomXRatio*d3.event.scale) + "," + d3.event.scale + ")");
+
+    var x = xScale.domain(), y = yScale.domain()
+    brush.extent([ [x[0]/zoomXRatio, y[0]], [x[1]/zoomXRatio, y[1]] ])
+    if (x[1] == maxX && y[1] == maxY)
+      brush.clear()
+    svg2.select('g.brush').call(brush)
+  }
+
+  var zoom = d3.behavior.zoom().x(xScale).y(yScale).scaleExtent([1, 14]).on('zoom', zoomed)
+
+  var svg2 = d3.select('.zoom').append('svg').attr('width', '100%').attr('height', '100%').append('svg:g')
+                      .attr("transform", "translate(" + margin.left + "," + margin.top + ")")
+                      .append('g').attr('class', 'graph')
+
+  var svg = d3.select(".flamegraph")
+                      .append("svg")
+                      .attr("width", "100%")
+                      .attr("height", "100%")
+                      .attr("pointer-events", "all")
+                      .append('svg:g')
+                      .attr("transform", "translate(" + margin.left + "," + margin.top + ")")
+                      .call(zoom)
+                      .append('svg:g').attr('class', 'graph');
+
+  // 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 samplePercentRaw = function(samples, exclusive) {
+    var ret = [samples, ((samples / maxX) * 100).toFixed(2)]
+    if (exclusive)
+      ret = ret.concat([exclusive, ((exclusive / maxX) * 100).toFixed(2)])
+    return ret;
+  }
+
+  var samplePercent = function(samples, exclusive) {
+    var info = samplePercentRaw(samples, exclusive)
+    var samplesPct = info[1], exclusivePct = info[3]
+    var ret = " (" + samples + " sample" + (samples == 1 ? "" : "s") + " - " + samplesPct + "%) ";
+    if (exclusive)
+      ret += " (" + exclusive + " exclusive - " + exclusivePct + "%) ";
+    return ret;
+  }
+
+  var info = {};
+
+  var mouseover =  function(d) {
+    var i = info[d.frame_id];
+    var shortFile = d.file.replace(/^.+\/(gems|app|lib|config|jobs)/, '$1')
+    var data = samplePercentRaw(i.samples.length, d.topFrame ? d.topFrame.exclusiveCount : 0)
+
+    $('.info')
+      .css('background-color', i.color)
+      .find('.frame').text(d.frame).end()
+      .find('.file').text(shortFile).end()
+      .find('.samples').text(data[0] + ' samples ('+data[1]+'%)').end()
+      .find('.exclusive').text('')
+
+    if (data[3])
+      $('.info .exclusive').text(data[2] + ' exclusive ('+data[3]+'%)')
+
+    d3.selectAll(i.nodes)
+       .attr('opacity',0.5);
+  };
+
+  var mouseout = function(d) {
+    var i = info[d.frame_id];
+    $('.info').css('background-color', 'none').find('.frame, .file, .samples, .exclusive').text('')
+
+    d3.selectAll(i.nodes)
+       .attr('opacity',1);
+  };
+
+  // assign some colors, analyze samples per gem
+  var gemStats = {}
+  var topFrames = {}
+  var lastFrame = {frame: 'd52e04d-df28-41ed-a215-b6ec840a8ea5', x: -1}
+
+  $.each(data, function(){
+    var gem = guessGem(this.file);
+    var stat = gemStats[gem];
+    this.gemName = gem
+
+    if(!stat) {
+      gemStats[gem] = stat = {name: gem, samples: [], frames: [], nodes:[]};
+    }
+
+    stat.frames.push(this.frame_id);
+    for(var j=0; j < this.width; j++){
+      stat.samples.push(this.x + j);
+    }
+    // This assumes the traversal is in order
+    if (lastFrame.x != this.x) {
+      var topFrame = topFrames[lastFrame.frame_id]
+      if (!topFrame) {
+        topFrames[lastFrame.frame_id] = topFrame = {exclusiveCount: 0}
+      }
+      topFrame.exclusiveCount += 1;
+      lastFrame.topFrame = topFrame;
+    }
+    lastFrame = this;
+
+  });
+
+  var topFrame = topFrames[lastFrame.frame_id]
+  if (!topFrame) {
+    topFrames[lastFrame.frame_id] = topFrame = {exclusiveCount: 0}
+  }
+  topFrame.exclusiveCount += 1;
+  lastFrame.topFrame = topFrame;
+
+  var totalGems = 0;
+  $.each(gemStats, function(k,stat){
+    totalGems++;
+    stat.samples = getUnique(stat.samples);
+  });
+
+  var gemsSorted = $.map(gemStats, function(v, k){ return v })
+  gemsSorted.sort(function(a, b){ return b.samples.length - a.samples.length })
+
+  var currentIndex = 0;
+  $.each(gemsSorted, function(k,stat){
+    stat.color = rainbow(totalGems, currentIndex);
+    currentIndex += 1;
+
+    for(var x=0; x < stat.frames.length; x++) {
+      info[stat.frames[x]] = {nodes: [], samples: [], color: stat.color};
+    }
+  });
+
+  function drawData(svg, data, xScale, yScale, mini) {
+  svg.selectAll("g.flames")
+    .data(data)
+    .enter()
+      .append("g")
+      .attr('class', 'flames')
+      .each(function(d){
+        gemStats[d.gemName].nodes.push(this)
+
+        var r = d3.select(this)
+        .append("rect")
+        .attr("x",function(d) { return xScale(d.x); })
+        .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_id];
+          if(!i) {
+            info[d.frame_id] = i = {nodes: [], samples: [], color: color()};
+          }
+          i.nodes.push(this);
+          if (!mini)
+            for(var j=0; j < d.width; j++){
+              i.samples.push(d.x + j);
+            }
+          return i.color;
+        })
+
+        if (!mini)
+          r
+          .on("mouseover", mouseover)
+          .on("mouseout", mouseout);
+
+        if (!mini)
+          d3.select(this)
+            .append('foreignObject')
+            .classed('label-body', true)
+            .attr("x",function(d) { return xScale(d.x); })
+            .attr("y",function(d) { return yScale(maxY - d.y);})
+            .attr("width", function(d){return xScale(d.width);})
+            .attr("height", yScale(1))
+            .attr("line-height", yScale(1))
+            .attr("font-size", yScale(0.42) + 'px')
+            .attr('pointer-events', 'none')
+            .append('xhtml:span')
+            .style("height", yScale(1))
+            .classed('label', true)
+            .text(function(d){ return d.frame })
+      });
+  }
+
+  drawData(svg, data, xScale, yScale, 0)
+  drawData(svg2, data, xScale2, yScale2, 1)
+
+  var brushed = function(){
+    if (brush.empty()) {
+      svg.attr('transform', '')
+      zoomXRatio = 1
+      zoom.scale(1).translate([0,0])
+      svg.selectAll('.label-body')
+         .attr('transform', 'scale(1,1)')
+         .attr("x",function(d) { return xScale(d.x)*zoomXRatio; })
+         .attr("width", function(d){return xScale(d.width)*zoomXRatio;})
+    } else {
+      var e = brush.extent()
+      var x = [e[0][0],e[1][0]], y = [e[0][1],e[1][1]]
+
+      xScale.domain([0, maxX])
+      yScale.domain([0, maxY])
+
+      var w = width, h = height2
+      var dx = xScale2(1.0*x[1]-x[0]), dy = yScale2(1.0*y[1]-y[0])
+      var sx = w/dx, sy = h/dy
+      var trlx = -xScale(x[0])*sx, trly = -yScale(y[0])*sy
+      var transform = "translate(" + trlx + ',' + trly + ")" + " scale(" + sx + ',' + sy + ")"
+
+      zoomXRatio = sx/sy
+
+      svg.selectAll('.label-body')
+         .attr("x",function(d) { return xScale(d.x)*zoomXRatio; })
+         .attr("width", function(d){return xScale(d.width)*zoomXRatio;})
+         .attr('transform', function(d){
+           var x = xScale(d.x)
+           return "scale("+(1.0/zoomXRatio)+",1)"
+         })
+
+      svg.attr("transform", transform)
+      zoom.translate([trlx, trly]).scale(sy)
+    }
+  }
+
+  var brush = d3.svg.brush()
+      .x(xScale2)
+      .y(yScale2)
+      .on("brush", brushed);
+
+  svg2.append("g")
+        .attr("class", "brush")
+        .call(brush)
+
+  // Samples may overlap on the same line
+  for (var r in info) {
+    if (info[r].samples) {
+      info[r].samples = getUnique(info[r].samples);
+    }
+  };
+
+  // render the legend
+  $.each(gemsSorted, function(k,gem){
+    var data = samplePercentRaw(gem.samples.length)
+    var node = $("<div class='"+gem.name+"'></div>")
+      .css("background-color", gem.color)
+      .html("<span style='float: right'>" + data[0] + 'x<br>' + data[1] + '%' + '</span>' + '<div class="name">'+gem.name+'<br>&nbsp;</div>');
+
+    node.on('mouseenter mouseleave', function(e){
+      d3.selectAll(gemStats[gem.name].nodes).classed('highlighted', e.type == 'mouseenter')
+    })
+
+    $('.legend').append(node);
+  });
+}

data/vendor/viewer.html

@@ -0,0 +1,85 @@
+<html>
+<head>
+<title>flamegraph</title>
+<style>
+  body {
+    margin: 0;
+    padding: 0;
+    font-family: Monaco, "Liberation Mono", Courier, monospace;
+    font-size: 10pt;
+  }
+  .info {
+    display: block;
+    height: 40px;
+    margin: 3px 6px;
+    margin-right: 206px;
+    padding: 3px 6px;
+    line-height: 18px;
+  }
+  .legend {
+    display: block;
+    float: right;
+    width: 195px;
+    max-height: 100%;
+    overflow-y: scroll;
+  }
+  .legend > div {
+    padding: 6px;
+    clear: right;
+  }
+  .legend > div span {
+    opacity: 0.75;
+    display: block;
+    text-align: right;
+  }
+  .legend > div .name {
+    max-width: 70%;
+    word-wrap: break-word;
+  }
+  .legend:hover + .flamegraph .flames:not(.highlighted) {
+    opacity: 0.25;
+  }
+  .legend:hover ~ .zoom .flames:not(.highlighted) {
+    opacity: 0.25;
+  }
+  .brush .extent {
+    stroke: #999;
+    fill-opacity: .125;
+    shape-rendering: crispEdges;
+  }
+  .label {
+    white-space: nowrap;
+    display: inline-flex;
+    align-items: center;
+    vertical-align: middle;
+    padding-left: 1px;
+  }
+</style>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
+<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/3.0.8/d3.min.js"></script>
+<script src="flamegraph.js"></script>
+</head>
+<body>
+  <div class="legend"></div>
+  <div class="flamegraph"></div>
+  <div class="info">
+    <div style="float: right; text-align: right">
+      <div class="samples"></div>
+      <div class="exclusive"></div>
+    </div>
+    <div class="frame"></div>
+    <div class="file"></div>
+  </div>
+  <div class="zoom"></div>
+  <script type="text/javascript">
+    var queryDict = {}
+    location.search.substr(1).split("&").forEach(function(item) {queryDict[item.split("=")[0]] = decodeURIComponent(item.split("=")[1])})
+
+    if (queryDict.data) {
+      s = document.createElement('script')
+      s.setAttribute('src', queryDict.data)
+      document.body.appendChild(s)
+    }
+  </script>
+</body>
+</html>

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: stackflame
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Takashi Kokubun
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: stackprof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.7
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: Stackflame provides a simple API to deal with Flamegraph of stackprof.
+email:
+- takashikkbn@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- example/ar_profile.rb
+- lib/stackflame.rb
+- lib/stackflame/version.rb
+- stackflame.gemspec
+- vendor/flamegraph.js
+- vendor/viewer.html
+homepage: https://github.com/k0kubun/stackflame
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Stackflame provides a simple API to deal with Flamegraph of stackprof.
+test_files: []