rack-mini-profiler 0.1.8 → 0.1.13.pre

data/CHANGELOG

@@ -30,3 +30,36 @@
   * 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

data/README.md

@@ -85,11 +85,44 @@ Rack::MiniProfiler.config.position = 'right'
 
 In a Rails app, this can be done conveniently in an initializer such as config/initializers/mini_profiler.rb.
 
+## Rails 2.X support
+
+To get MiniProfiler working with Rails 2.3.X you need to do the initialization manually as well as monkey patch away an incompatibility between activesupport and json_pure.
+
+Add the following code to your environment.rb (or just in a specific environment such as development.rb) for initialization and configuration of MiniProfiler.
+
+```ruby
+# configure and initialize MiniProfiler
+require 'rack-mini-profiler'
+c = ::Rack::MiniProfiler.config
+c.pre_authorize_cb = lambda { |env|
+  Rails.env.development? || Rails.env.production?
+}
+tmp = Rails.root.to_s + "/tmp/miniprofiler"
+FileUtils.mkdir_p(tmp) unless File.exists?(tmp)
+c.storage_options = {:path => tmp}
+c.storage = ::Rack::MiniProfiler::FileStore
+config.middleware.use(::Rack::MiniProfiler)
+::Rack::MiniProfiler.profile_method(ActionController::Base, :process) {|action| "Executing action: #{action}"}
+::Rack::MiniProfiler.profile_method(ActionView::Template, :render) {|x,y| "Rendering: #{@virtual_path}"}
+
+# monkey patch away an activesupport and json_pure incompatability
+# http://pivotallabs.com/users/alex/blog/articles/1332-monkey-patch-of-the-day-activesupport-vs-json-pure-vs-ruby-1-8
+if JSON.const_defined?(:Pure)
+  class JSON::Pure::Generator::State
+    include ActiveSupport::CoreExtensions::Hash::Except
+  end
+end
+```
+
 ## 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.
 * 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
 
 ## Special query strings 
 

data/lib/html/includes.css

@@ -58,7 +58,7 @@
 .profiler-results .profiler-popup .profiler-timings th,.profiler-results .profiler-popup .profiler-timings td{padding-left:6px;padding-right:6px;}
 .profiler-results .profiler-popup .profiler-timings th{font-size:95%;padding-bottom:3px;}
 .profiler-results .profiler-popup .profiler-timings .profiler-label{max-width:275px;}
-.profiler-results .profiler-queries{display:none;z-index:2147483643;position:absolute;overflow-y:auto;overflow-x:hidden;background-color:#fff;}.profiler-results .profiler-queries th{font-size:17px;}
+.profiler-results .profiler-queries{display:none;z-index:2147483643;position:absolute;overflow-y:auto;overflow-x:auto;background-color:#fff;}.profiler-results .profiler-queries th{font-size:17px;}
 .profiler-results.profiler-min .profiler-result{display:none;}
 .profiler-results.profiler-min .profiler-controls span{display:none;}
 .profiler-results.profiler-min .profiler-controls .profiler-min-max{border-right:none;padding:0px;margin:0px;}

data/lib/html/includes.js

@@ -5,7 +5,8 @@ var MiniProfiler = (function ($) {
         container,
         controls,
         fetchedIds = [],
-        fetchingIds = []  // so we never pull down a profiler twice
+        fetchingIds = [], // so we never pull down a profiler twice
+        ajaxStartTime
         ;
 
     var hasLocalStorage = function () {
@@ -73,15 +74,15 @@ var MiniProfiler = (function ($) {
             clientPerformance = null;
             clientProbes = null;
 
-            if (id == options.currentId) {
-
-                if (window.mPt) {
-                    clientProbes = mPt.t;
-                    for (j = 0; j < clientProbes.length; j++) {
-                        clientProbes[j].d = clientProbes[j].d.getTime();
-                    }
-                    mPt.t = [];
+            if (window.mPt) {
+                clientProbes = mPt.results();
+                for (j = 0; j < clientProbes.length; j++) {
+                    clientProbes[j].d = clientProbes[j].d.getTime();
                 }
+                mPt.flush();
+            }
+            
+            if (id == options.currentId) {
 
                 clientPerformance = getClientPerformance();
 
@@ -113,6 +114,9 @@ var MiniProfiler = (function ($) {
 
                     }
                 }
+            } else if (ajaxStartTime != null && clientProbes.length > 0) {
+                clientPerformance = { timing: { navigationStart: ajaxStartTime.getTime() } };
+                ajaxStartTime = null;
             }
 
             if ($.inArray(id, fetchedIds) < 0 && $.inArray(id, fetchingIds) < 0) {
@@ -449,6 +453,9 @@ var MiniProfiler = (function ($) {
             jQuery(document).ajaxComplete(jQueryAjaxComplete);
         }
 
+        if (jQuery(document).ajaxStart)
+            jQuery(document).ajaxStart(function () { ajaxStartTime = new Date(); });
+        
         // fetch results after ASP Ajax calls
         if (typeof (Sys) != 'undefined' && typeof (Sys.WebForms) != 'undefined' && typeof (Sys.WebForms.PageRequestManager) != 'undefined') {
             // Get the instance of PageRequestManager.

data/lib/html/includes.less

@@ -359,7 +359,7 @@
         z-index:@zindex + 3;
         position:absolute;
         overflow-y:auto;
-        overflow-x:hidden;
+        overflow-x:auto;
         background-color:#fff;
 
         th {

data/lib/html/includes.tmpl

@@ -43,7 +43,7 @@
             {{if HasSqlTimings}}
               <td colspan="2" class="profiler-number profiler-percent-in-sql" title="${MiniProfiler.getSqlTimingsCount(Root)} queries spent ${MiniProfiler.formatDuration(DurationMillisecondsInSql)} ms of total request time">
                 ${MiniProfiler.formatDuration(DurationMillisecondsInSql / DurationMilliseconds * 100)}
-                <span class="profiler-unit">% in sql</span>
+                <span class="profiler-unit">% in qry</span>
               </td>
             {{/if}}
             </tr>
@@ -141,7 +141,7 @@
     <td class="profiler-duration {{if HasDuplicateSqlTimings}}profiler-warning{{/if}}" title="{{if HasDuplicateSqlTimings}}duplicate queries detected - {{/if}}${ExecutedReaders} reader, ${ExecutedScalars} scalar, ${ExecutedNonQueries} non-query statements executed">
       <a class="profiler-queries-show">
         {{if HasDuplicateSqlTimings}}<span class="profiler-nuclear">!</span>{{/if}}
-        ${SqlTimings.length} <span class="profiler-unit">sql</span>
+        ${SqlTimings.length} <span class="profiler-unit">qry</span>
       </a>
     </td>
     <td class="profiler-duration" title="aggregate duration of all queries in this step (excludes children)">

data/lib/mini_profiler/client_settings.rb

@@ -0,0 +1,65 @@
+module Rack
+  class MiniProfiler
+    class ClientSettings
+      
+      COOKIE_NAME = "__profilin"
+
+      BACKTRACE_DEFAULT = nil
+      BACKTRACE_FULL = 1 
+      BACKTRACE_NONE = 2
+
+      attr_accessor :disable_profiling
+      attr_accessor :backtrace_level
+
+      
+      def initialize(env)
+        request = ::Rack::Request.new(env)
+        @cookie = request.cookies[COOKIE_NAME] 
+        if @cookie
+          @cookie.split(",").map{|pair| pair.split("=")}.each do |k,v|
+            @orig_disable_profiling = @disable_profiling = (v=='t') if k == "dp"
+            @backtrace_level = v.to_i if k == "bt"
+          end
+        end
+
+        @backtrace_level = nil if !@backtrace_level.nil? && (@backtrace_level == 0 || @backtrace_level > BACKTRACE_NONE) 
+        @orig_backtrace_level = @backtrace_level
+
+      end
+
+      def write!(headers)
+        if @orig_disable_profiling != @disable_profiling || @orig_backtrace_level != @backtrace_level || @cookie.nil?
+          settings = {"p" =>  "t" }
+          settings["dp"] = "t" if @disable_profiling 
+          settings["bt"] = @backtrace_level if @backtrace_level
+          settings_string = settings.map{|k,v| "#{k}=#{v}"}.join(",")
+          Rack::Utils.set_cookie_header!(headers, COOKIE_NAME, :value => settings_string)
+        end
+      end
+
+      def discard_cookie!(headers)
+        Rack::Utils.delete_cookie_header!(headers, COOKIE_NAME)
+      end
+
+      def has_cookie?
+        !@cookie.nil?
+      end
+
+      def disable_profiling? 
+        @disable_profiling
+      end
+
+      def backtrace_full? 
+        @backtrace_level == BACKTRACE_FULL
+      end
+
+      def backtrace_default? 
+        @backtrace_level == BACKTRACE_DEFAULT
+      end
+      
+      def backtrace_none? 
+        @backtrace_level == BACKTRACE_NONE
+      end
+    end
+  end
+end

data/lib/mini_profiler/config.rb

@@ -13,7 +13,7 @@ module Rack
     end
 
     attr_accessor :auto_inject, :base_url_path, :pre_authorize_cb, :position,
-        :backtrace_remove, :backtrace_filter, :skip_schema_queries, 
+        :backtrace_remove, :backtrace_includes, :backtrace_ignores, :skip_schema_queries, 
         :storage, :user_provider, :storage_instance, :storage_options, :skip_paths, :authorization_mode, :use_existing_jquery
       
       def self.default

data/lib/mini_profiler/profiler.rb

@@ -13,6 +13,7 @@ require 'mini_profiler/storage/file_store'
 require 'mini_profiler/config'
 require 'mini_profiler/profiling_methods'
 require 'mini_profiler/context'
+require 'mini_profiler/client_settings'
 
 module Rack
 
@@ -56,20 +57,6 @@ module Rack
         self.current.discard = true if current
       end
 
-      # user has the mini profiler cookie, only used when config.authorization_mode == :whitelist
-      def has_profiling_cookie?(env)
-        env['HTTP_COOKIE'] && env['HTTP_COOKIE'].include?("__profilin=stylin")
-      end
-
-      # remove the mini profiler cookie, only used when config.authorization_mode == :whitelist
-      def remove_profiling_cookie(headers)
-        Rack::Utils.delete_cookie_header!(headers, '__profilin')
-      end
-
-      def set_profiling_cookie(headers)
-        Rack::Utils.set_cookie_header!(headers, '__profilin', 'stylin')
-      end
-
       def create_current(env={}, options={})
         # profiling the request
         self.current = Context.new
@@ -180,54 +167,75 @@ module Rack
 
 
 		def call(env)
+
+      client_settings = ClientSettings.new(env)
+
       status = headers = body = nil
+      query_string = env['QUERY_STRING']
       path = env['PATH_INFO']
 
       skip_it = (@config.pre_authorize_cb && !@config.pre_authorize_cb.call(env)) ||
                 (@config.skip_paths && @config.skip_paths.any?{ |p| path[0,p.length] == p}) ||
-                env["QUERY_STRING"] =~ /pp=skip/ 
+                query_string =~ /pp=skip/ 
       
-      has_profiling_cookie = MiniProfiler.has_profiling_cookie?(env)
+      has_profiling_cookie = client_settings.has_cookie?
     
       if skip_it || (@config.authorization_mode == :whitelist && !has_profiling_cookie)
         status,headers,body = @app.call(env)
         if !skip_it && @config.authorization_mode == :whitelist && !has_profiling_cookie && MiniProfiler.request_authorized? 
-          MiniProfiler.set_profiling_cookie(headers) 
+          client_settings.write!(headers) 
         end
         return [status,headers,body]
       end
 
       # handle all /mini-profiler requests here
-			return serve_html(env) if env['PATH_INFO'].start_with? @config.base_url_path
+			return serve_html(env) if path.start_with? @config.base_url_path
+
+      has_disable_cookie = client_settings.disable_profiling?
+      # manual session disable / enable
+      if query_string =~ /pp=disable/ || has_disable_cookie
+        skip_it = true
+      end
+
+      if query_string =~ /pp=enable/
+        skip_it = false
+      end
+
+      if skip_it
+        status,headers,body = @app.call(env)
+        client_settings.disable_profiling = true
+        client_settings.write!(headers)
+        return [status,headers,body]
+      end
 
       MiniProfiler.create_current(env, @config)
       MiniProfiler.deauthorize_request if @config.authorization_mode == :whitelist
-      if env["QUERY_STRING"] =~ /pp=no-backtrace/
+      if query_string =~ /pp=normal-backtrace/
+        client_settings.backtrace_level = ClientSettings::BACKTRACE_DEFAULT
+      elsif query_string =~ /pp=no-backtrace/
         current.skip_backtrace = true
-      elsif env["QUERY_STRING"] =~ /pp=full-backtrace/
+        client_settings.backtrace_level = ClientSettings::BACKTRACE_NONE
+      elsif query_string =~ /pp=full-backtrace/ || client_settings.backtrace_full?
         current.full_backtrace = true
+        client_settings.backtrace_level = ClientSettings::BACKTRACE_FULL
+      elsif client_settings.backtrace_none?
+        current.skip_backtrace = true
       end
 
       done_sampling = false
       quit_sampler = false
       backtraces = nil
       missing_stacktrace = false
-      if env["QUERY_STRING"] =~ /pp=sample/
+      if query_string =~ /pp=sample/
         backtraces = []
         t = Thread.current
         Thread.new {
           begin
-            require 'stacktrace' rescue nil
-            if !t.respond_to? :stacktrace
-              missing_stacktrace = true
-              quit_sampler = true 
-              return
-            end
             i = 10000 # for sanity never grab more than 10k samples 
             while i > 0
               break if done_sampling
               i -= 1
-              backtraces << t.stacktrace
+              backtraces << t.backtrace
               sleep 0.001
             end
           ensure
@@ -240,6 +248,7 @@ module Rack
       start = Time.now 
       begin 
         status,headers,body = @app.call(env)
+        client_settings.write!(headers)
       ensure
         if backtraces 
           done_sampling = true
@@ -249,21 +258,21 @@ module Rack
 
       skip_it = current.discard
       if (config.authorization_mode == :whitelist && !MiniProfiler.request_authorized?)
-        MiniProfiler.remove_profiling_cookie(headers)
+        client_settings.discard_cookie!(headers)
         skip_it = true
       end
       
       return [status,headers,body] if skip_it
 
       # we must do this here, otherwise current[:discard] is not being properly treated
-      if env["QUERY_STRING"] =~ /pp=env/
+      if query_string =~ /pp=env/
         body.close if body.respond_to? :close
         return dump_env env
       end
 
-      if env["QUERY_STRING"] =~ /pp=help/
+      if query_string =~ /pp=help/
         body.close if body.respond_to? :close
-        return help
+        return help(nil, client_settings)
       end
       
       page_struct = current.page_struct
@@ -271,7 +280,7 @@ module Rack
 
       if backtraces
         body.close if body.respond_to? :close
-        return help(:stacktrace) if missing_stacktrace
+        return help(:stacktrace, client_settings) if missing_stacktrace
         return analyze(backtraces, page_struct)
       end
       
@@ -282,6 +291,8 @@ module Rack
 			
       # inject headers, script
 			if status == 200
+
+        client_settings.write!(headers)
         
         # mini profiler is meddling with stuff, we can not cache cause we will get incorrect data
         # Rack::ETag has already inserted some nonesense in the chain
@@ -311,6 +322,7 @@ module Rack
 				end
 			end
 
+      client_settings.write!(headers)
 			[status, headers, body]
     ensure
       # Make sure this always happens
@@ -318,7 +330,15 @@ module Rack
 		end
 
     def inject(fragment, script)
-      fragment.sub(/<\/body>/i, script + "</body>") 
+      fragment.sub(/<\/body>/i) do 
+        # if for whatever crazy reason we dont get a utf string, 
+        #   just force the encoding, no utf in the mp scripts anyway 
+        if script.respond_to?(:encoding) && script.respond_to?(:force_encoding)
+          (script + "</body>").force_encoding(fragment.encoding)
+        else
+          script + "</body>"
+        end
+      end
     end
 
     def dump_env(env)
@@ -330,21 +350,25 @@ module Rack
       [200, headers, [body]]
     end
 
-    def help(category = nil)
+    def help(category = nil, client_settings)
       headers = {'Content-Type' => 'text/plain'}
       body = "Append the following to your query string:
 
   pp=help : display this screen
   pp=env : display the rack environment
   pp=skip : skip mini profiler for this request
-  pp=no-backtrace : don't collect stack traces from all the SQL executed
-  pp=full-backtrace : enable full backtrace for SQL executed
-  pp=sample : sample stack traces and return a report isolating heavy usage (requires the stacktrace gem)
+  pp=no-backtrace #{"(*) " if client_settings.backtrace_none?}: don't collect stack traces from all the SQL executed (sticky, use pp=normal-backtrace to enable)
+  pp=normal-backtrace #{"(*) " if client_settings.backtrace_default?}: collect stack traces from all the SQL executed and filter normally
+  pp=full-backtrace #{"(*) " if client_settings.backtrace_full?}: enable full backtraces for SQL executed (use pp=normal-backtrace to disable) 
+  pp=sample : sample stack traces and return a report isolating heavy usage (experimental)
+  pp=disable : disable profiling for this session 
+  pp=enable : enable profiling for this session (if previously disabled)
 "
       if (category == :stacktrace)
         body = "pp=stacktrace requires the stacktrace gem - add gem 'stacktrace' to your Gemfile"
       end
     
+      client_settings.write!(headers)
       [200, headers, [body]]
     end
 
@@ -358,13 +382,12 @@ module Rack
         fulldump << "\n\n"
         distinct = {}
         trace.each do |frame|
-          name = "#{frame.klass} #{frame.method}"
-          unless distinct[name]
-            distinct[name] = true
-            seen[name] ||= 0
-            seen[name] += 1
+          unless distinct[frame]
+            distinct[frame] = true
+            seen[frame] ||= 0
+            seen[frame] += 1
           end
-          fulldump << name << "\n"
+          fulldump << frame << "\n"
         end
       end
 
@@ -382,7 +405,8 @@ module Rack
     end
 
     def ids_json(env)
-      ids = [current.page_struct["Id"]] + (@storage.get_unviewed_ids(user(env)) || [])
+      # cap at 10 ids, otherwise there is a chance you can blow the header
+      ids = [current.page_struct["Id"]] + (@storage.get_unviewed_ids(user(env)) || [])[0..8]
       ::JSON.generate(ids.uniq)
     end
 

data/lib/mini_profiler/profiling_methods.rb

@@ -9,7 +9,7 @@ module Rack
 		  end
 
       # perform a profiling step on given block
-      def step(name)
+      def step(name, opts = nil)
         if current
           parent_timer = current.current_timer
           result = nil
@@ -20,7 +20,6 @@ module Rack
             current_timer.record_time
             current.current_timer = parent_timer
           end
-          result
         else
           yield if block_given?
         end

data/lib/mini_profiler/sql_timer_struct.rb

@@ -14,7 +14,17 @@ module Rack
            # Clean up the stack trace if there are options to do so
           Kernel.caller.each do |ln|
             ln.gsub!(Rack::MiniProfiler.config.backtrace_remove, '') if Rack::MiniProfiler.config.backtrace_remove and !full_backtrace
-            if full_backtrace or Rack::MiniProfiler.config.backtrace_filter.nil? or ln =~ Rack::MiniProfiler.config.backtrace_filter
+            if    full_backtrace or 
+                  (
+                    (
+                      Rack::MiniProfiler.config.backtrace_includes.nil? or 
+                      Rack::MiniProfiler.config.backtrace_includes.all?{|regex| ln =~ regex}
+                    ) and
+                    (
+                      Rack::MiniProfiler.config.backtrace_ignores.nil? or 
+                      Rack::MiniProfiler.config.backtrace_ignores.all?{|regex| !(ln =~ regex)}
+                    )
+                  ) 
               stack_trace << ln << "\n" 
             end
           end

data/lib/mini_profiler/storage/memory_store.rb

@@ -58,7 +58,6 @@ module Rack
           @timer_struct_cache.delete_if { |k, v| v['Root']['StartMilliseconds'] < expire_older_than }
         }
       end
-    
     end
   end
 end

data/lib/mini_profiler/timer_struct.rb

@@ -22,7 +22,9 @@ module Rack
       end
 
       def to_json(*a)
-        ::JSON.generate(@attributes, a[0])
+        # this does could take in an option hash, but the only interesting there is max_nesting.
+        #   if this becomes an option we could increase
+        ::JSON.generate( @attributes, :max_nesting => 100 )
       end
 
     end

data/lib/mini_profiler_rails/railtie.rb

@@ -31,7 +31,7 @@ module MiniProfilerRails
 
       # Quiet the SQL stack traces
       c.backtrace_remove = Rails.root.to_s + "/"
-      c.backtrace_filter =  /^\/?(app|config|lib|test)/
+      c.backtrace_includes =  [/^\/?(app|config|lib|test)/]
       c.skip_schema_queries =  Rails.env != 'production'
 
       # Install the Middleware

data/lib/patches/sql_patches.rb

@@ -91,6 +91,24 @@ if SqlPatches.class_exists? "PG::Result"
   class PG::Connection
     alias_method :exec_without_profiling, :exec
     alias_method :async_exec_without_profiling, :async_exec
+    alias_method :exec_prepared_without_profiling, :exec_prepared
+    alias_method :send_query_prepared_without_profiling, :send_query_prepared
+    alias_method :prepare_without_profiling, :prepare
+
+    def prepare(*args,&blk)
+      # we have no choice but to do this here, 
+      # if we do the check for profiling first, our cache may miss critical stuff  
+      
+      @prepare_map ||= {}
+      @prepare_map[args[0]] = args[1]
+      # dont leak more than 10k ever
+      @prepare_map = {} if @prepare_map.length > 1000
+
+      current = ::Rack::MiniProfiler.current
+      return prepare_without_profiling(*args,&blk) unless current
+
+      prepare_without_profiling(*args,&blk) 
+    end
 
     def exec(*args,&blk)
       current = ::Rack::MiniProfiler.current
@@ -104,6 +122,34 @@ if SqlPatches.class_exists? "PG::Result"
       result
     end
 
+    def exec_prepared(*args,&blk)
+      current = ::Rack::MiniProfiler.current
+      return exec_prepared_without_profiling(*args,&blk) unless current
+
+      start = Time.now
+      result = exec_prepared_without_profiling(*args,&blk)
+      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
+      mapped = args[0]
+      mapped = @prepare_map[mapped] || args[0] if @prepare_map
+      result.instance_variable_set("@miniprofiler_sql_id", ::Rack::MiniProfiler.record_sql(mapped, elapsed_time))
+
+      result
+    end
+    
+    def send_query_prepared(*args,&blk)
+      current = ::Rack::MiniProfiler.current
+      return send_query_prepared_without_profiling(*args,&blk) unless current
+
+      start = Time.now
+      result = send_query_prepared_without_profiling(*args,&blk)
+      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
+      mapped = args[0]
+      mapped = @prepare_map[mapped] || args[0] if @prepare_map
+      result.instance_variable_set("@miniprofiler_sql_id", ::Rack::MiniProfiler.record_sql(mapped, elapsed_time))
+
+      result
+    end
+    
     def async_exec(*args,&blk)
       current = ::Rack::MiniProfiler.current
       return exec_without_profiling(*args,&blk) unless current

data/rack-mini-profiler.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
 	s.name = "rack-mini-profiler"
-	s.version = "0.1.8"
+	s.version = "0.1.13.pre"
 	s.summary = "Profiles loading speed for rack applications."
 	s.authors = ["Aleks Totic","Sam Saffron", "Robin Ward"]
 	s.description = "Page loading speed displayed on every page. Optimize while you develop, performance is a feature."

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification
 name: rack-mini-profiler
 version: !ruby/object:Gem::Version
-  version: 0.1.8
-  prerelease: 
+  version: 0.1.13.pre
+  prerelease: 7
 platform: ruby
 authors:
 - Aleks Totic
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-30 00:00:00.000000000 Z
+date: 2012-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -91,6 +91,7 @@ files:
 - lib/mini_profiler/request_timer_struct.rb
 - lib/mini_profiler/timer_struct.rb
 - lib/mini_profiler/page_timer_struct.rb
+- lib/mini_profiler/client_settings.rb
 - lib/mini_profiler/context.rb
 - lib/mini_profiler/config.rb
 - lib/mini_profiler/profiling_methods.rb
@@ -130,16 +131,13 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -902573215
+      hash: -879601329
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
-      segments:
-      - 0
-      hash: -902573215
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24