rack-mini-profiler 0.1.21 → 0.1.26

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 943d309dfe7e69d839ea284e6c9d525e61e5411e
+  data.tar.gz: bdf30a92d384c74ab69e5d5c19ca853135100d77
+SHA512:
+  metadata.gz: db02f40f91da2a44a6e0d001d24e5d12946499a1e152a20068e252ff551c57627196648ee3b101fa4d746a0752e431497658c74610b37fb36b8e4e4061c4e71a
+  data.tar.gz: 5ca22681b6b47bdb4b0e1d5929a9199e7b4b8974d144a9d318b737e6c5988929d11aeff8dd06f890f7975093c63c3eeb8c8ebbc799121aca290f713306eb0f03

data/Ruby/CHANGELOG

@@ -0,0 +1,135 @@
+28-June-2012 - Sam
+
+  * Started change log
+  * Corrected profiler so it properly captures POST requests (was supressing non 200s)
+  * Amended Rack.MiniProfiler.config[:user_provider] to use ip addres for identity
+  * Fixed bug where unviewed missing ids never got cleared
+  * Supress all '/assets/' in the rails tie (makes debugging easier)
+  * record_sql was mega buggy
+  * added MemcacheStore
+
+9-July-2012 - Sam
+
+  * Cleaned up mechanism for profiling in production, all you need to do now
+  is call Rack::MiniProfiler.authorize_request to get profiling working in
+  production
+  * Added option to display full backtraces pp=full-backtrace
+  * Cleaned up railties, got rid of the post authorize callback
+  * Version 0.1.3
+
+12-July-2012 - Sam
+
+  * Fixed incorrect profiling steps (was not indenting or measuring start time right
+  * Implemented native PG and MySql2 interceptors, this gives way more accurate times
+  * Refactored context so its a proper class and not a hash
+  * Added some more client probing built in to rails
+  * More tests
+
+18-July-2012 - Sam
+
+  * Added First Paint time for chrome
+  * Bug fix to ensure non Rails installs have mini profiler
+  * Version 0.1.7
+
+30-July-2012 - Sam
+
+  * Made compliant with ancient versions of Rack (including Rack used by Rails2)
+  * Fixed broken share link
+  * Fixed crashes on startup (in MemoryStore and FileStore)
+  * Version 0.1.8
+  * Unicode fix
+  * Version 0.1.9
+
+7-August-2012 - Sam
+
+  * Added option to disable profiler for the current session (pp=disable / pp=enable)
+  * yajl compatability contributed by Sven Riedel
+
+10-August-2012 - Sam
+
+  * Added basic prepared statement profiling for postgres
+
+20-August-2012 - Sam
+
+  * 1.12.pre
+  * Cap X-MiniProfiler-Ids at 10, otherwise the header can get killed
+
+3-September-2012 - Sam
+
+  * 1.13.pre
+  * pg gem prepared statements were not being logged correctly
+  * added setting config.backtrace_ignores = [] - an array of regexes that match on caller lines that get ignored
+  * added setting config.backtrace_includes = [] - an array of regexes that get included in the trace by default
+  * cleaned up the way client settings are stored
+  * made pp=full-backtrace "sticky"
+  * added pp=normal-backtrace to clear the "sticky" state
+  * change "pp=sample" to work with "caller" no need for stack trace gem
+
+4-September-2012 - Sam
+
+  * 1.15.pre
+  * fixed annoying bug where client settings were not sticking
+  * fixed long standing issue with Rack::ConditionalGet stopping MiniProfiler from working properly
+
+5-September-2012 - Sam
+
+  * 1.16
+  * fixed long standing problem specs (issue with memory store)
+  * fixed issue where profiler would be dumped when you got a 404 in production (and any time rails is bypassed)
+  * implemented stacktrace properly
+
+9-September-2012 - Sam
+
+  * 1.17
+  * pp=sample was bust unless stacktrace was installed
+
+10-September-2012 - Sam
+
+  * 1.19
+  * fix compat issue with 1.8.7
+
+12-September-2012 - Sam
+
+  * 1.20
+  * Added pp=profile-gc , it allows you to profile the GC in Ruby 1.9.3
+
+17-September-2012
+  * 1.21
+  * New MemchacedStore
+  * Rails 4 support
+
+17-September-2012
+  * Allow rack-mini-profiler to be sourced from github
+  * Extracted the pp=profile-gc-time out, the object space profiler needs to disable gc
+
+20-September-2012
+  * 1.22
+  * Fix permission issue in the gem
+
+8-April-2013
+  * 1.24
+  * Flame Graph Support see: http://samsaffron.com/archive/2013/03/19/flame-graphs-in-ruby-miniprofiler
+  * Fix file retention leak in file_store
+  * New toggle_shortcut and start_hidden options
+  * Fix for AngularJS support and MooTools
+  * More robust gc profiling
+  * Mongoid support
+  * Fix for html5 implicit body tags
+  * script tag initialized via data-attributes
+  * new - Rack::MiniProfiler.counter counter_name {}
+  * Allow usage of existing jQuery if its already loaded
+  * Fix pp=enable
+  * 1.8.7 support ... grrr
+  * Net:HTTP profiling
+  * pre authorize to run in all non development? and production? modes
+
+8-April-2013
+  * 1.25
+  * Missed flamegraph.html from build
+
+11-April-2013
+  * 1.26
+  * (minor) allow Rack::MiniProfilerRails.initialize!(Rails.application), for post config intialization
+
+
+

data/{README.md → Ruby/README.md}

@@ -15,7 +15,7 @@ All you have to do is include the Gem and you're good to go in development.
 
 rack-mini-profiler is designed with production profiling in mind. To enable that just run `Rack::MiniProfiler.authorize_request` once you know a request is allowed to profile.
 
-For example: 
+Using Rails:
 
 ```ruby
 # A hook in your ApplicationController
@@ -47,23 +47,53 @@ class MyApp < Sinatra::Base
 end
 ```
 
+## Database profiling
+
+Currently supports Mysql2, Postgres, and Mongoid3 (with fallback support to ActiveRecord)
+
 ## Storage
 
-By default, rack-mini-profiler stores its results in a memory store: 
+rack-mini-profiler stores it's results so they can be shared later and aren't lost at the end of the request.
+
+There are 4 storage options: `MemoryStore`, `RedisStore`, `MemcacheStore`, and `FileStore`.
+
+`FileStore` is the default in Rails environments and will write files to `tmp/miniprofiler/*`.  `MemoryStore` is the default otherwise.
+
+To change the default you can create a file in `config/initializers/mini_profiler.rb`
 
 ```ruby 
-# our default
+# set MemoryStore
 Rack::MiniProfiler.config.storage = Rack::MiniProfiler::MemoryStore
-```
 
-There are 2 other available storage engines, `RedisStore`, `MemcacheStore`, and `FileStore`.
+# set RedisStore
+if Rails.env.production?
+  uri = URI.parse(ENV["REDIS_SERVER_URL"])
+  Rack::MiniProfiler.config.storage_options = { :host => uri.host, :port => uri.port, :password => uri.password }
+  Rack::MiniProfiler.config.storage = Rack::MiniProfiler::RedisStore
+end
+```
 
-MemoryStore is stores results in a processes heap - something that does not work well in a multi process environment. 
+MemoryStore stores results in a processes heap - something that does not work well in a multi process environment. 
 FileStore stores results in the file system - something that may not work well in a multi machine environment. 
+RedisStore/MemcacheStore work in multi process and multi machine environments (RedisStore only saves results for up to 24 hours so it won't continue to fill up Redis).
 
 Additionally you may implement an AbstractStore for your own provider. 
 
-Rails hooks up a FileStore for all environments. 
+## User result segregation
+
+MiniProfiler will attempt to keep all user results isolated, out-of-the-box the user provider uses the ip address: 
+
+```ruby
+Rack::MiniProfiler.config.user_provider = Proc.new{|env| Rack::Request.new(env).ip} 
+```
+
+You can override (something that is very important in a multi-machine production setup): 
+
+```ruby
+Rack::MiniProfiler.config.user_provider = Proc.new{ |env| CurrentUser.get(env) } 
+```
+
+The string this function returns should be unique for each user on the system (for anonymous you may need to fall back to ip address)
 
 ## Running the Specs
 
@@ -120,11 +150,12 @@ end
 * pre_authorize_cb - A lambda callback you can set to determine whether or not mini_profiler should be visible on a given request. Default in a Rails environment is only on in development mode. If in a Rack app, the default is always on.
 * position - Can either be 'right' or 'left'. Default is 'left'.
 * skip_schema_queries - Whether or not you want to log the queries about the schema of your tables. Default is 'false', 'true' in rails development.
-* use_existing_jquery - Use the version of jQuery on the page as opposed to the self contained one
 * auto_inject (default true) - when false the miniprofiler script is not injected in the page
 * backtrace_filter - a regex you can use to filter out unwanted lines from the backtraces
+* toggle_shortcut (default Alt+P) - a jquery.hotkeys.js-style keyboard shortcut, used to toggle the mini_profiler's visibility. See http://code.google.com/p/js-hotkeys/ for more info.
+* start_hidden (default false) - Whether or not you want the mini_profiler to be visible when loading a page
 
 ## Special query strings 
 
-If you include the query string `pp=help` at the end of your request you will see the various option you have. You can use these options to extend or contract the amount of diagnostics rack-mini-profiler gathers. 
+If you include the query string `pp=help` at the end of your request you will see the various options available. You can use these options to extend or contract the amount of diagnostics rack-mini-profiler gathers. 
 

data/Ruby/lib/html/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>
+<!-- <script src="http://cdnjs.cloudflare.com/ajax/libs/sugar/1.3.8/sugar.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>
+