rack-mini-profiler 0.1.23 → 0.1.28

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: dd8393bb0afbc59162f9ece7f63b47218f742127
+  data.tar.gz: 4f29c3a0407eb08c0b5146eea018919dc6620db8
+SHA512:
+  metadata.gz: 0276de7ece6f3f8a70a4ce085ddb36a209385b1e3892c147057d6629922b4ea90e33177fc1093c72c08bf2de156585cff6b95576733c1cc906cf7cd4cd16000f
+  data.tar.gz: f9accaad19036dde64fdacb1c86ddd15892d97e778ce079bd579bdbe78df508b41716fecc17e0b3176887002caef63f6cc9f37c6384f12ecc233bb170a384863

data/Ruby/CHANGELOG

@@ -1,77 +1,77 @@
-28-June-2012 - Sam  
- 
+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 
+  * 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 
+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
+  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 
+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
+  * 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
 
-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 
-  
+30-July-2012 - Sam
+
   * Made compliant with ancient versions of Rack (including Rack used by Rails2)
-  * Fixed broken share link 
+  * Fixed broken share link
   * Fixed crashes on startup (in MemoryStore and FileStore)
   * Version 0.1.8
-  * Unicode fix 
+  * 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 
+  * yajl compatability contributed by Sven Riedel
 
-10-August-2012 - Sam 
+10-August-2012 - Sam
 
-  * Added basic prepared statement profiling for postgres 
+  * Added basic prepared statement profiling for postgres
 
-20-August-2012 - Sam 
-  
-  * 1.12.pre 
+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 
+  * 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 
+  * 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 
+4-September-2012 - Sam
 
   * 1.15.pre
-  * fixed annoying bug where client settings were not sticking 
+  * 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 
+5-September-2012 - Sam
 
   * 1.16
   * fixed long standing problem specs (issue with memory store)
@@ -83,25 +83,65 @@
   * 1.17
   * pp=sample was bust unless stacktrace was installed
 
-10-September-2012 - Sam 
+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 
+  * 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-2010
+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
+
+26-June-2013
+  * 1.27
+  * Disable global ajax handlers on MP requests @JP
+  * Add Rack::MiniProfiler.config.backtrace_threshold_ms
+  * jQuery 2.0 support
+
+18-July-2013
+  * 1.28
+	* diagnostics in abstract storage was raising not implemented killing
+	?pp=env and others
+  * SOLR xml unescaped by mistake
+
+
+

data/Ruby/README.md

@@ -79,6 +79,22 @@ RedisStore/MemcacheStore work in multi process and multi machine environments (R
 
 Additionally you may implement an AbstractStore for your own provider. 
 
+## 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
 
 ```
@@ -95,8 +111,14 @@ You can set configuration options using the configuration accessor on Rack::Mini
 ```
 # Have Mini Profiler show up on the right
 Rack::MiniProfiler.config.position = 'right'
+# Have Mini Profiler start in hidden mode - display with short cut (defaulted to 'Alt+P')
+Rack::MiniProfiler.config.start_hidden = true
+# Don't collect backtraces on SQL queries that take less than 5 ms to execute
+# (necessary on Rubies earlier than 2.0)
+Rack::MiniProfiler.config.backtrace_threshold_ms = 5
 ```
 
+
 In a Rails app, this can be done conveniently in an initializer such as config/initializers/mini_profiler.rb.
 
 ## Rails 2.X support
@@ -129,6 +151,10 @@ if JSON.const_defined?(:Pure)
 end
 ```
 
+## Notes
+
+- Be sure to require rack_mini_profiler last in your Gemfile, when it is required it will monkey patch pg and mysql gems to insert instrumentation. If included to early no SQL will show up.
+
 ## Available Options
 
 * 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.
@@ -136,8 +162,11 @@ end
 * 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.
 * 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
+* backtrace_threshold_ms (default zero) - Minimum SQL query elapsed time before a backtrace is recorded. Backtrace recording can take a couple of milliseconds on rubies earlier than 2.0, impacting performance for very small queries.
 
 ## 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,351 @@
+<!DOCTYPE html>
+<html>
+<head>
+<script src="//cdnjs.cloudflare.com/ajax/libs/jquery/1.9.1/jquery.min.js"></script>
+<script src="//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, exclusive){
+  var info = " (" + samples + 
+    " sample" + (samples == 1 ? "" : "s") + " - " + 
+    ((samples / maxX) * 100).toFixed(2) + "%) ";
+  if (exclusive) {
+    info += " (" + exclusive + 
+      " exclusive - " +
+    ((exclusive / maxX) * 100).toFixed(2) + "%) ";
+  }
+  return info;
+}
+
+var mouseover =  function(d) {
+  var i = info[d.frame];
+  $('.info').text( d.frame + " " + samplePercent(i.samples.length, d.topFrame ? d.topFrame.exclusiveCount : 0));
+  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 = {} 
+var topFrames = {}
+var lastFrame = {frame: 'd52e04d-df28-41ed-a215-b6ec840a8ea5', x: -1}
+
+$.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);
+  }
+  // This assumes the traversal is in order
+  if (lastFrame.x != this.x) {
+    var topFrame = topFrames[lastFrame.frame]
+    if (!topFrame) {
+      topFrames[lastFrame.frame] = topFrame = {exclusiveCount: 0}
+    }
+    topFrame.exclusiveCount += 1;
+    lastFrame.topFrame = topFrame;
+  }
+  lastFrame = this;
+  
+});
+
+var topFrame = topFrames[lastFrame.frame]
+if (!topFrame) {
+  topFrames[lastFrame.frame] = topFrame = {exclusiveCount: 0}
+}
+topFrame.exclusiveCount += 1;
+lastFrame.topFrame = topFrame;
+
+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>
+