stackprofiler 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec396ab3126b59c0e52b0b0e35abe6a67bfbc39c
-  data.tar.gz: 035f170274d6bfe42cc4ca507a53069658fe1592
+  metadata.gz: 53d49ea799e330d848bf167e2f5fbec763e136cc
+  data.tar.gz: 572be41c382be167f0b61bdca9aad96d44d55c30
 SHA512:
-  metadata.gz: a3f64d23fd792ae533c17df0b31a21ae6125d1df0b1c7d1f4c890e5609b66bf03280031d370c5613c385d27a0459b6456844b6416531ac365cb63351ace2a999
-  data.tar.gz: 4e303ce9b29293ea6340bffbc0a0a22950251a47a5f9c765d39757f0441a7c9cc74c55d0d1b850d2bb0577ed4dbe66eb685393ffdf997be20a1b64932e93a617
+  metadata.gz: 1ef14a9045d59fdfe64b6d5ad0e0a7e0d33cf641e2b01f2cf4557ba921b042156d752b0ce8e9e0b08140c320ab2e4ad58bf76f39a599bd57ff4fe1d867ffc848
+  data.tar.gz: c3ef5a43a3707f168b3026d6bd44763733824df9b533d0879c8f8daa04fbe512a52962f7d1793d7bcbb52fe5bf7889a21a40f680a7a560ce51a31d5cc3ded425

data/Guardfile

@@ -0,0 +1,3 @@
+guard 'puma', port: 9292 do
+  watch(/.+/)
+end

data/README.md

@@ -19,6 +19,7 @@ for a job application! Please keep that in mind when you find all the
 rough edges :)
 
 ![Screenshot](http://i.imgur.com/8UJV9Oo.png)
+![Screenshot](http://i.imgur.com/CsZMXLu.png)
 
 ## Installation
 
@@ -36,7 +37,7 @@ Or install it yourself as:
 
     $ gem install stackprofiler
 
-## Usage
+## Middleware
 
 Using Stackprofiler at this stage is pretty simple on account of there
 not yet being much flexibility in the way of configuration. This will be
@@ -57,7 +58,7 @@ visible results, e.g. XHR.
 Once you have profiled a request or two, you can head over to Stackprofiler's
 GUI. This is located on the same port as your website, albeit at the
 path `/__stackprofiler`. If your server is running on port 5000 in development,
-the link might be [`http://localhost:5000/__stackprofiler`]([http://localhost:5000/__stackprofiler]).
+the link might be [`http://localhost:5000/__stackprofiler`](http://localhost:5000/__stackprofiler).
 
 You should now see a page that looks like the screenshot above. Click on any
 line in the stack trace to see the code for that method annotated with the
@@ -65,6 +66,44 @@ performance characteristics for each line. I would document those here but
 they are going to change in the next few dev hours, so I'll come back to that
 later.
 
+### Data collection configuration
+
+Stackprofiler's operation can be configured by passing in parameters to the
+middleware specified above. While the defaults should suit most applications,
+changing them is easy enough:
+
+```ruby
+config.middleware.use Stackprofiler::Middleware {
+  predicate: /profile=true/, # regex form for urls to be profiled
+  predicate: proc {|env| true }, # callable form for greater flexibility than regex
+  stackprof: { # options to be passed directly through to stackprof, e.g.:
+    interval: 1000 # sample every n micro-seconds
+  }
+}
+```
+
+## Ad hoc
+
+Sometimes you want to test some code that isn't part of a Rack app - or is
+just cumbersome to run outside of an IRB console. You can test this code
+directly using code very similar to the `stackprof` interface. It works like
+this:
+
+Run `$ stackprofiler` from the command line. This will start a Stackprofiler
+server that will listen for incoming profile runs and display them on
+[`http://localhost:9292/__stackprofiler`](http://localhost:9292/__stackprofiler).
+Next, in an IRB console (or, even better, [Pry][3]!)
+
+```ruby
+require 'stackprofiler'
+
+Stackprofiler.profile do
+  SomeSlowTaskThatNeedsInvestigation.run
+end
+```
+
+Now visit the above URL and a visual breakdown of the code flow will be visible.
+
 ## Contributing
 
 1. Fork it ( https://github.com/glassechidna/stackprofiler/fork )
@@ -79,3 +118,4 @@ So much. First todo: write a todo list.
 
 [1]: https://github.com/tmm1/stackprof
 [2]: https://github.com/ruby-prof/ruby-prof
+[3]: https://github.com/pry/pry

data/bin/stackprofiler

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'stackprofiler'
+
+app = Rack::URLMap.new '/__stackprofiler' => Stackprofiler::WebUI.new
+Rack::Server.start app: app, Port: 9292

data/config.ru

@@ -0,0 +1,5 @@
+require 'stackprofiler'
+
+run Rack::URLMap.new '/__stackprofiler' => Stackprofiler::WebUI.new(file: '/Users/aidan/dev/better-data/yy.json')
+# run Rack::URLMap.new '/__stackprofiler' => Stackprofiler::WebUI.new
+

data/lib/stackprofiler/data_collector.rb

@@ -1,14 +1,27 @@
 module Stackprofiler
   class DataCollector
-    def initialize(app, options = {})
+    def initialize(app, options)
       @app = app
+
+      pred = options[:predicate] || /profile=true/
+      if pred.respond_to? :call
+        @predicate = pred
+      else
+        regex = Regexp.new pred
+
+        @predicate = proc do |env|
+          req = Rack::Request.new env
+          req.fullpath =~ regex
+        end
+      end
+
+      @stackprof_opts = {mode: :wall, interval: 1000, raw: true}.merge(options[:stackprof] || {})
     end
 
     def call(env)
-      puts env['PATH_INFO']
-      if env['QUERY_STRING'] =~ /profile=true/
+      if @predicate.call(env)
         out = nil
-        profile = StackProf.run(mode: :wall, interval: 1000, raw: true) { out = @app.call env }
+        profile = StackProf.run(@stackprof_opts) { out = @app.call env }
 
         req = Rack::Request.new env
         run = Run.new req.fullpath, profile, Time.now

data/lib/stackprofiler/filters/build_tree.rb

@@ -0,0 +1,49 @@
+module Stackprofiler
+  module Filter
+    class BuildTree
+      def initialize(options={})
+        @options = options
+      end
+
+      def filter run, frames
+        stacks = run.stacks
+
+        root_addr = stacks[0][0].to_s
+        root = Tree::TreeNode.new root_addr, {addrs: [root_addr]}
+
+        stacks.each do |stack|
+          prev = root
+          iterate stack do |addr|
+            addr = addr.to_s
+            node = prev[addr]
+            if node.nil?
+              hash = {count: 0, addrs: [addr]}
+              node = Tree::TreeNode.new(addr, hash)
+              prev << node
+            end
+            node.content[:count] +=1
+            prev = node
+          end
+        end
+
+        if inverted?
+          root.children.each {|n| n.content[:open] = false }
+        end
+
+        root
+      end
+
+      def inverted?
+        @options[:invert]
+      end
+
+      def iterate stack, &blk
+        if inverted?
+          stack.reverse_each &blk
+        else
+          stack.each &blk
+        end
+      end
+    end
+  end
+end

data/lib/stackprofiler/filters/compress_tree.rb

@@ -1,21 +1,18 @@
 module Stackprofiler
   module Filter
     class CompressTree
-      def filter root, frames
-        depths = Hash.new {|h, k| h[k] = [] }
-        root.each {|n| depths[n.node_depth].push n }
-        depths.delete 0
+      def initialize(options={})
+
+      end
 
-        depths.keys.sort.reverse.each do |depth|
-          nodes = depths[depth]
-          nodes.each do |node|
-            if node.out_degree == 1
-              hash = node.content.dup
-              hash[:addrs] = hash[:addrs] + node.first_child.content[:addrs]
-              repl = Tree::TreeNode.new(node.name, hash)
-              node.first_child.children.each {|n| repl << n }
-              node.replace_with repl
-            end
+      def filter root, frames
+        root.reverse_depth_first do |node|
+          if node.out_degree == 1
+            hash = node.content
+            hash[:addrs] += node.first_child.content[:addrs]
+            repl = Tree::TreeNode.new(node.name, hash)
+            node.first_child.children.each {|n| repl << n }
+            node.replace_with repl
           end
         end
         root

data/lib/stackprofiler/filters/frame_regex_removal.rb

@@ -0,0 +1,22 @@
+module Stackprofiler
+  module Filter
+    class FrameRegexRemoval
+      include RemoveFramesHelper
+
+      def initialize(options={})
+        @options = options
+      end
+
+      def regexes
+        ary = @options[:regexes] || []
+        @regexes ||= ary.reject(&:blank?).map {|r| /#{r}/ }.compact
+      end
+
+      def filter root, frames
+        remove_frames root, frames do |node, frame|
+          regexes.any? {|r| frame[:name] =~ r }
+        end
+      end
+    end
+  end
+end

data/lib/stackprofiler/filters/gem_removal.rb

@@ -0,0 +1,16 @@
+module Stackprofiler
+  module Filter
+    class GemRemoval
+      include RemoveFramesHelper
+
+      def initialize(options={})
+      end
+
+      def filter root, frames
+        remove_frames root, frames do |node, frame|
+          Gem.path.any? {|p| frame[:file].include?(p) }
+        end
+      end
+    end
+  end
+end

data/lib/stackprofiler/filters/js_tree.rb

@@ -1,6 +1,10 @@
 module Stackprofiler
   module Filter
     class JsTree
+      def initialize(options={})
+
+      end
+
       def filter root, frames
         addrs = root.content[:addrs]
         name = addrs.first.to_i
@@ -13,9 +17,15 @@ module Stackprofiler
         end
         text = escaped.join("<br> ↳ ")
 
-        children = root.children.map { |n| filter(n, frames) }
-        open = frame[:total_samples] > 100
-        {text: text, children: children, state: {opened: open}, icon: false, data: {addrs: addrs}}
+        sorted_children = root.children.sort_by do |child|
+          addr = child.content[:addrs].first.to_i
+          frame = frames[addr]
+          frame[:samples]
+        end.reverse
+
+        children = sorted_children.map { |n| filter(n, frames) }
+        open = root.content.has_key?(:open) ? root.content[:open] : frame[:total_samples] > 100
+        {text: text, state: {opened: open}, children: children, icon: false, data: {addrs: addrs}}
       end
     end
 

data/lib/stackprofiler/filters/quick_method_removal.rb

@@ -0,0 +1,18 @@
+module Stackprofiler
+  module Filter
+    class QuickMethodRemoval
+      include RemoveFramesHelper
+      attr_accessor :limit
+
+      def initialize(options={})
+        self.limit = options[:limit].try(:to_i) || 0
+      end
+
+      def filter root, frames
+        remove_frames root, frames do |node, frame|
+          frame[:total_samples] < limit
+        end
+      end
+    end
+  end
+end

data/lib/stackprofiler/filters/rebase_stack.rb

@@ -0,0 +1,25 @@
+module Stackprofiler
+  module Filter
+    class RebaseStack
+      attr_accessor :top_names
+
+      def initialize(options={})
+        self.top_names = options[:name].presence || RebaseStack.default
+      end
+
+      def filter root, frames
+        root.find do |node|
+          addr = node.content[:addrs].first.to_i
+          top_names.include? frames[addr][:name]
+          # frames[addr][:name] == top_names
+        end || root
+      end
+
+      class << self
+        def default
+          ['Stackprofiler::DataCollector#call', 'block in Stackprofiler#profile']
+        end
+      end
+    end
+  end
+end

data/lib/stackprofiler/middleware.rb

@@ -6,7 +6,7 @@ module Stackprofiler
         run WebUI
       end
 
-      @app = Rack::URLMap.new({'/__stackprofiler' => mid, '/' => DataCollector.new(app)})
+      @app = Rack::URLMap.new({'/__stackprofiler' => mid, '/' => DataCollector.new(app, options)})
       @options = options
     end
 

data/lib/stackprofiler/run_data_source.rb

@@ -29,6 +29,24 @@ module Stackprofiler
     def duration
       profile[:samples] * profile[:interval] / 1e6
     end
+
+    def gem_breakdown
+      bottom_frames = stacks.map &:last
+      paths = bottom_frames.map {|addr| profile[:frames][addr][:file] }
+
+      gems = paths.map do |p|
+        case p
+          when %r{gems/(\D\w+)}
+            $1
+          when %r{#{RbConfig::CONFIG['rubylibdir']}}
+            'stdlib'
+          else
+            '(app)'
+        end
+      end
+
+      gems.group_by {|g| g }.map {|k, v| [k, v.count] }.sort_by(&:last).reverse.to_h
+    end
   end
 
   class RunDataSource

data/lib/stackprofiler/utils.rb

@@ -0,0 +1,50 @@
+module Tree
+  class TreeNode
+    def reverse_depth_first &blk
+      depths = Hash.new {|h, k| h[k] = [] }
+      root.each {|n| depths[n.node_depth].push n }
+      depths.delete 0
+      keys = depths.keys.sort.reverse
+
+      keys.each do |depth|
+        nodes = depths[depth]
+        nodes.each &blk
+      end
+    end
+  end
+end
+
+module Stackprofiler
+  def profile
+    # todo: pass through options perhaps?
+    profile = StackProf.run(mode: :wall, raw: true) { yield }
+    # todo: remove terrible hard-coded url
+    url = URI::parse 'http://localhost:9292/__stackprofiler/receive'
+    headers = {'Content-Type' => 'application/json'}
+    req = Net::HTTP::Post.new(url.to_s, headers)
+    req.body = Oj.dump profile
+    response = Net::HTTP.new(url.host, url.port).start {|http| http.request(req) }
+  end
+  module_function :profile
+
+  module Filter
+    module RemoveFramesHelper
+      def remove_frames root, frames
+        root.reverse_depth_first do |node|
+          frame = frames[node.name.to_i]
+
+          if yield node, frame
+            parent = node.parent
+            node.remove_from_parent!
+
+            node.children.each do |n|
+              n.remove_from_parent!
+              parent << n if parent[n.name].nil? # todo: have a think about if/why this "if" is necessary
+            end
+          end
+        end
+        root
+      end
+    end
+  end
+end

data/lib/stackprofiler/version.rb

@@ -1,3 +1,3 @@
 module Stackprofiler
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/lib/stackprofiler/web_ui/public/js/stackprofiler.js

@@ -0,0 +1,103 @@
+$(function() {
+    $('#foo').split({
+        orientation: 'horizontal',
+        limit: 10,
+        position: '40%'
+    });
+
+    var $filteredFrames = $('#filtered_frames');
+    $filteredFrames.tokenfield();
+
+    var $tree = $('#jstree_demo');
+
+    $('#rebase_stack_enabled').change(function(e) {
+        var enabled = $(e.target).is(':checked');
+        $('#rebase_stack').prop('disabled', !enabled);
+    });
+
+    $('#rebase_stack').autocomplete({
+        source: "/__stackprofiler/frame_names?run_id=" + $tree.data('runId'),
+        minLength: 2
+    });
+
+    var getParams = function()
+    {
+        var params = {
+            run_id: $tree.data('runId'),
+            filters: {}
+        };
+
+        params.filters.filtered_frames = {regexes: $filteredFrames.val().split(', ')};
+        params.filters.quick_method_removal = {limit: $('form#options input[name="quick_method_removal"]').val()};
+
+        if ($('#rebase_stack_enabled').is(':checked')) params.filters.rebase_stack = {name: $('#rebase_stack').val() };
+        if ($('form#options input[name="invert"]').is(':checked')) params.filters.build_tree = {invert: true};
+        if ($('form#options input[name="remove_gems"]').is(':checked')) params.filters.remove_gems = {};
+        if ($('form#options input[name="compress_tree"]').is(':checked')) params.filters.compress_tree = {};
+
+        return params;
+    };
+
+    var getNodes = function(node, cb) {
+        $.post("/__stackprofiler/json", JSON.stringify(getParams()), function(data, status, xhr) {
+            cb.call(this, data);
+        });
+    };
+
+    $tree.jstree({
+        core: {
+            data: getNodes
+        }
+    });
+
+    $tree.on("changed.jstree", function (e, data) {
+        if (!data.node) return;
+
+        var addrs = data.node.data.addrs;
+        var url = "/__stackprofiler/code/" + addrs[0] + "?run_id=" + $tree.data('runId');
+        $("#source-display").load(url);
+    });
+
+    $('button#save-options').click(function() {
+        $tree.jstree().refresh();
+    });
+
+    $.getJSON('/__stackprofiler/gem_breakdown?run_id=' + $tree.data('runId'), function(data, status, xhr) {
+        var threshold = 0.1;
+
+        var sum = _.reduce(data, function(memo, count, gem) {
+            return memo + count;
+        }, 0);
+
+        var reduced = _(data).reduce(function(memo, count, gem) {
+            var key = count/sum > threshold ? gem : '(other)';
+            var accum = memo[key] || 0;
+            memo[key] = accum + count;
+            return memo;
+        }, {});
+
+        var f = function(count, gem) {
+            return {label: gem, value: count};
+        };
+
+        var ary = _.map(data, f);
+        var graph_data = _.map(reduced, f);
+
+        var colors = d3.scale.category10().range();
+
+        var rows = _(ary).zip(colors).first(ary.length).map(function(item) {
+            var gem = item[0];
+            var percent = (gem.value / sum * 100).toFixed(1);
+            var has_color = gem.value/sum > threshold;
+            var style = has_color ? 'background-color: ' + item[1] + ';' : '';
+            return $('<tr><td><div class="color-box" style="' + style + '"></div>' + gem.label + '</td><td>' + gem.value + '</td><td>' + percent + '%</td></tr>');
+        }).value();
+        
+        $('#gem-pie').epoch({
+            type: 'pie',
+            data: graph_data
+        });
+
+        $('#gem-table').append(rows);
+    });
+});