rack-mini-profiler 0.1.3 → 0.1.4

data/CHANGELOG

@@ -15,3 +15,12 @@
 	* 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
+

data/lib/mini_profiler/client_timer_struct.rb

@@ -6,6 +6,19 @@ module Rack
     # This class holds the client timings
     class ClientTimerStruct < TimerStruct
 
+      def self.init_instrumentation
+        "<script type=\"text/javascript\">mPt=function(){var t=[];return{t:t,probe:function(n){t.push({d:new Date(),n:n})}}}()</script>"
+      end
+      
+      def self.instrument(name,orig)
+        probe = "<script>mPt.probe('#{name}')</script>"
+        wrapped = probe
+        wrapped << orig 
+        wrapped << probe 
+        wrapped
+      end
+
+
       def initialize(env={})
         super
       end
@@ -21,6 +34,26 @@ module Rack
         baseTime = clientTimes['navigationStart'].to_i if clientTimes
         return unless clientTimes && baseTime 
 
+        probes = form['clientProbes']
+        translated = {}
+        if probes 
+          probes.each do |id, val|
+            name = val["n"]
+            translated[name] ||= {} 
+            if translated[name][:start]
+              translated[name][:finish] = val["d"]
+            else 
+              translated[name][:start] = val["d"]
+            end
+          end
+        end
+
+        translated.each do |name, data|
+          h = {"Name" => name, "Start" => data[:start].to_i - baseTime}
+          h["Duration"] = data[:finish].to_i - data[:start].to_i if data[:finish]
+          timings.push(h)
+        end
+
         clientTimes.keys.find_all{|k| k =~ /Start$/ }.each do |k|
           start = clientTimes[k].to_i - baseTime 
           finish = clientTimes[k.sub(/Start$/, "End")].to_i - baseTime

data/lib/mini_profiler/context.rb

@@ -0,0 +1,10 @@
+class Rack::MiniProfiler::Context
+  attr_accessor :inject_js,:current_timer,:page_struct,:skip_backtrace,:full_backtrace,:discard, :mpt_init
+  
+  def initialize(opts = {})
+    opts.each do |k,v|
+      self.instance_variable_set('@' + k, v)
+    end
+  end
+
+end

data/lib/mini_profiler/page_timer_struct.rb

@@ -35,15 +35,19 @@ module Rack
       def duration_ms
         @attributes['Root']['DurationMilliseconds']
       end
+
+      def root
+        @attributes['Root']
+      end
       
       def to_json(*a)
         attribs = @attributes.merge(
           "Started" => '/Date(%d)/' % @attributes['Started'], 
           "DurationMilliseconds" => @attributes['Root']['DurationMilliseconds']
         )        
-        ::JSON.generate(attribs, a[0])
+        ::JSON.generate(attribs, :max_nesting => 100)
       end
     end
     
   end
-end
+end

data/lib/mini_profiler/profiler.rb

@@ -12,41 +12,90 @@ require 'mini_profiler/storage/memory_store'
 require 'mini_profiler/storage/redis_store'
 require 'mini_profiler/storage/file_store'
 require 'mini_profiler/config'
+require 'mini_profiler/profiling_methods'
+require 'mini_profiler/context'
 
 module Rack
 
 	class MiniProfiler
 
-		VERSION = 'rZlycOOTnzxZvxTmFuOEV0dSmu4P5m5bLrCtwJHVXPA='.freeze
-		@@instance = nil
+		VERSION = 'rZlycOOTnzxZvxTmFuOEV0dSmu4P5m5bLrCtwJHVXPA=A'.freeze
 
-		def self.instance
-			@@instance
-		end
+    class << self 
+      
+      include Rack::MiniProfiler::ProfilingMethods
 
-		def self.generate_id
-			rand(36**20).to_s(36)
-		end
+      def generate_id
+        rand(36**20).to_s(36)
+      end
 
-    def self.reset_config
-      @config = Config.default
-    end
+      def reset_config
+        @config = Config.default
+      end
 
-    # So we can change the configuration if we want
-    def self.config
-      @config ||= Config.default
-    end
+      # So we can change the configuration if we want
+      def config
+        @config ||= Config.default
+      end
+
+      def share_template
+        return @share_template unless @share_template.nil?
+        @share_template = ::File.read(::File.expand_path("../html/share.html", ::File.dirname(__FILE__)))
+      end
+      
+      def current
+        Thread.current[:mini_profiler_private]
+      end
+
+      def current=(c)
+        # we use TLS cause we need access to this from sql blocks and code blocks that have no access to env
+        Thread.current[:mini_profiler_private]= c
+      end
+
+      # discard existing results, don't track this request
+      def discard_results
+        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
+        self.current.inject_js = config.auto_inject && (!env['HTTP_X_REQUESTED_WITH'].eql? 'XMLHttpRequest')
+        self.current.page_struct = PageTimerStruct.new(env)
+        self.current.current_timer = current.page_struct['Root']
+      end
+
+      def authorize_request
+        Thread.current[:mp_authorized] = true
+      end
 
-    def self.share_template
-      return @share_template unless @share_template.nil?
-      @share_template = ::File.read(::File.expand_path("../html/share.html", ::File.dirname(__FILE__)))
+      def deauthorize_request
+        Thread.current[:mp_authorized] = nil
+      end
+
+      def request_authorized?
+        Thread.current[:mp_authorized]
+      end
     end
 
 		#
 		# options:
 		# :auto_inject - should script be automatically injected on every html page (not xhr)
 		def initialize(app, config = nil)
-			@@instance = self
       MiniProfiler.config.merge!(config)
       @config = MiniProfiler.config 
 			@app = app
@@ -106,14 +155,6 @@ module Rack
 			f.serving env
 		end
 
-    def self.current
-      Thread.current['profiler.mini.private']
-    end
-
-    def self.current=(c)
-      # we use TLS cause we need access to this from sql blocks and code blocks that have no access to env
- 			Thread.current['profiler.mini.private'] = c
-    end
     
     def current
       MiniProfiler.current
@@ -123,48 +164,11 @@ module Rack
       MiniProfiler.current=c
     end
 
-    # discard existing results, don't track this request
-    def self.discard_results
-      current[:discard] = true if current
-    end
-
-    # user has the mini profiler cookie, only used when config.authorization_mode == :whitelist
-    def self.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 self.remove_profiling_cookie(headers)
-      Rack::Utils.delete_cookie_header!(headers, '__profilin')
-    end
-
-    def self.set_profiling_cookie(headers)
-      Rack::Utils.set_cookie_header!(headers, '__profilin', 'stylin')
-    end
 
     def config
       @config
     end
 
-    def self.create_current(env={}, options={})
-      # profiling the request
-      self.current = {}
-      self.current['inject_js'] = config.auto_inject && (!env['HTTP_X_REQUESTED_WITH'].eql? 'XMLHttpRequest')
-      self.current['page_struct'] = PageTimerStruct.new(env)
-      self.current['current_timer'] = current['page_struct']['Root']
-    end
-
-    def self.authorize_request
-      Thread.current[:mp_authorized] = true
-    end
-
-    def self.deauthorize_request
-      Thread.current[:mp_authorized] = nil
-    end
-
-    def self.request_authorized?
-      Thread.current[:mp_authorized]
-    end
 
 		def call(env)
       status = headers = body = nil
@@ -174,12 +178,12 @@ module Rack
                 (@config.skip_paths && @config.skip_paths.any?{ |p| path[0,p.length] == p}) ||
                 env["QUERY_STRING"] =~ /pp=skip/ 
       
-      has_profiling_cookie = self.class.has_profiling_cookie?(env)
+      has_profiling_cookie = MiniProfiler.has_profiling_cookie?(env)
     
       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? 
-          self.class.set_profiling_cookie(headers) 
+          MiniProfiler.set_profiling_cookie(headers) 
         end
         return [status,headers,body]
       end
@@ -188,34 +192,38 @@ module Rack
 			return serve_html(env) if env['PATH_INFO'].start_with? @config.base_url_path
 
       MiniProfiler.create_current(env, @config)
-
       MiniProfiler.deauthorize_request if @config.authorization_mode == :whitelist
       if env["QUERY_STRING"] =~ /pp=no-backtrace/
-        current['skip-backtrace'] = true
+        current.skip_backtrace = true
       elsif env["QUERY_STRING"] =~ /pp=full-backtrace/
-        current['full-backtrace'] = true
+        current.full_backtrace = true
       end
 
       done_sampling = false
       quit_sampler = false
       backtraces = nil
+      missing_stacktrace = false
       if env["QUERY_STRING"] =~ /pp=sample/
         backtraces = []
         t = Thread.current
         Thread.new {
-          require 'stacktrace'
-          if !t.respond_to? :stacktrace
-            quit_sampler = true 
-            return
+          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
+              sleep 0.001
+            end
+          ensure
+            quit_sampler = true
           end
-          i = 10000 # for sanity never grab more than 10k samples 
-          while i > 0
-            break if done_sampling
-            i -= 1
-            backtraces << t.stacktrace
-            sleep 0.001
-          end
-          quit_sampler = true
         }
       end
 
@@ -230,7 +238,7 @@ module Rack
         end
       end
 
-      skip_it = current[:discard]
+      skip_it = current.discard
       if (config.authorization_mode == :whitelist && !MiniProfiler.request_authorized?)
         MiniProfiler.remove_profiling_cookie(headers)
         skip_it = true
@@ -249,11 +257,12 @@ module Rack
         return help
       end
       
-      page_struct = current['page_struct']
+      page_struct = current.page_struct
 			page_struct['Root'].record_time((Time.now - start) * 1000)
 
       if backtraces
         body.close if body.respond_to? :close
+        return help(:stacktrace) if missing_stacktrace
         return analyze(backtraces, page_struct)
       end
       
@@ -271,7 +280,7 @@ module Rack
         end
 
 				# inject script
-				if current['inject_js'] \
+				if current.inject_js \
 					&& headers.has_key?('Content-Type') \
 					&& !headers['Content-Type'].match(/text\/html/).nil? then
 					body = MiniProfiler::BodyAddProxy.new(body, self.get_profile_script(env))
@@ -298,7 +307,7 @@ module Rack
       [200, headers, [body]]
     end
 
-    def help
+    def help(category = nil)
       headers = {'Content-Type' => 'text/plain'}
       body = "Append the following to your query string:
 
@@ -309,24 +318,48 @@ module Rack
   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)
 "
-      #headers['Content-Length'] = body.length
+      if (category == :stacktrace)
+        body = "pp=stacktrace requires the stacktrace gem - add gem 'stacktrace' to your Gemfile"
+      end
+    
       [200, headers, [body]]
     end
 
     def analyze(traces, page_struct)
       headers = {'Content-Type' => 'text/plain'}
       body = "Collected: #{traces.count} stack traces. Duration(ms): #{page_struct.duration_ms}"
+
+      seen = {}
+      fulldump = ""
       traces.each do |trace| 
-        body << "\n\n"
+        fulldump << "\n\n"
+        distinct = {}
         trace.each do |frame|
-          body << "#{frame.klass} #{frame.method}\n"
+          name = "#{frame.klass} #{frame.method}"
+          unless distinct[name]
+            distinct[name] = true
+            seen[name] ||= 0
+            seen[name] += 1
+          end
+          fulldump << name << "\n"
         end
       end
+
+      body << "\n\nStack Trace Analysis\n"
+      seen.to_a.sort{|x,y| y[1] <=> x[1]}.each do |name, count|
+        if count > traces.count / 10
+          body << "#{name} x #{count}\n"
+        end
+      end
+      
+      body << "\n\n\nRaw traces \n"
+      body << fulldump
+
       [200, headers, [body]]
     end
 
     def ids_json(env)
-      ids = [current['page_struct']["Id"]] + (@storage.get_unviewed_ids(user(env)) || [])
+      ids = [current.page_struct["Id"]] + (@storage.get_unviewed_ids(user(env)) || [])
       ::JSON.generate(ids.uniq)
     end
 
@@ -345,7 +378,7 @@ module Rack
 			showChildren = false
 			maxTracesToShow = 10
 			showControls = false
-			currentId = current['page_struct']["Id"]
+			currentId = current.page_struct["Id"]
 			authorized = true
       useExistingjQuery = false
 			# TODO : cache this snippet 
@@ -357,52 +390,13 @@ module Rack
 			end
 			# replace the '{{' and '}}''
 			script.gsub!(/\{\{/, '{').gsub!(/\}\}/, '}')
-			current['inject_js'] = false
+			current.inject_js = false
 			script
 		end
 
 		# cancels automatic injection of profile script for the current page
 		def cancel_auto_inject(env)
-		  current['inject_js'] = false
-		end
-
-		# perform a profiling step on given block
-		def self.step(name)
-      if current
-        old_timer = current['current_timer']
-        new_step = RequestTimerStruct.new(name, current['page_struct'])
-        current['current_timer'] = new_step
-        new_step['Name'] = name
-        start = Time.now
-        result = yield if block_given?
-        new_step.record_time((Time.now - start)*1000)
-        old_timer.add_child(new_step)
-        current['current_timer'] = old_timer
-        result
-      else
-        yield if block_given?
-      end
-		end
-
-    def self.profile_method(klass, method, &blk)
-      default_name = klass.to_s + " " + method.to_s
-      with_profiling = (method.to_s + "_with_mini_profiler").intern
-      without_profiling = (method.to_s + "_without_mini_profiler").intern
-      
-      klass.send :alias_method, without_profiling, method
-      klass.send :define_method, with_profiling do |*args, &orig|
-        name = default_name 
-        name = blk.bind(self).call(*args) if blk
-        ::Rack::MiniProfiler.step name do 
-          self.send without_profiling, *args, &orig
-        end
-      end
-      klass.send :alias_method, method, with_profiling
-    end
-
-		def record_sql(query, elapsed_ms)
-      c = current
-			c['current_timer'].add_sql(query, elapsed_ms, c['page_struct'], c['skip-backtrace'], c['full-backtrace']) if (c && c['current_timer'])
+		  current.inject_js = false
 		end
 
 	end

data/lib/mini_profiler/profiling_methods.rb

@@ -0,0 +1,73 @@
+module Rack
+  class MiniProfiler
+    module ProfilingMethods 
+     
+		  def record_sql(query, elapsed_ms)
+        c = current
+        return unless c
+			  c.current_timer.add_sql(query, elapsed_ms, c.page_struct, c.skip_backtrace, c.full_backtrace) if (c && c.current_timer)
+		  end
+
+      # perform a profiling step on given block
+      def step(name)
+        if current
+          parent_timer = current.current_timer
+          result = nil
+          current.current_timer = current_timer = current.current_timer.add_child(name) 
+          begin 
+            result = yield if block_given?
+          ensure
+            current_timer.record_time
+            current.current_timer = parent_timer
+          end
+          result
+        else
+          yield if block_given?
+        end
+      end
+
+      def unprofile_method(klass, method)
+        with_profiling = (method.to_s + "_with_mini_profiler").intern
+        without_profiling = (method.to_s + "_without_mini_profiler").intern
+        
+        if klass.send :method_defined?, with_profiling
+          klass.send :alias_method, method, without_profiling
+          klass.send :remove_method, with_profiling
+          klass.send :remove_method, without_profiling
+        end
+      end
+
+      def profile_method(klass, method, &blk)
+        default_name = klass.to_s + " " + method.to_s
+        with_profiling = (method.to_s + "_with_mini_profiler").intern
+        without_profiling = (method.to_s + "_without_mini_profiler").intern
+        
+        if klass.send :method_defined?, with_profiling
+          return # dont double profile
+        end
+          
+        klass.send :alias_method, without_profiling, method
+        klass.send :define_method, with_profiling do |*args, &orig|
+          return self.send without_profiling, *args, &orig unless Rack::MiniProfiler.current
+
+          name = default_name 
+          name = blk.bind(self).call(*args) if blk
+          
+          parent_timer = Rack::MiniProfiler.current.current_timer
+          page_struct = Rack::MiniProfiler.current.page_struct
+          result = nil
+
+          Rack::MiniProfiler.current.current_timer = current_timer = parent_timer.add_child(name) 
+          begin 
+            result = self.send without_profiling, *args, &orig
+          ensure
+            current_timer.record_time
+            Rack::MiniProfiler.current.current_timer = parent_timer
+          end 
+          result 
+        end
+        klass.send :alias_method, method, with_profiling
+      end
+    end
+  end
+end

data/lib/mini_profiler/request_timer_struct.rb

@@ -6,14 +6,14 @@ module Rack
     class RequestTimerStruct < TimerStruct
       
       def self.createRoot(name, page)
-        rt = RequestTimerStruct.new(name, page)
+        rt = RequestTimerStruct.new(name, page, nil)
         rt["IsRoot"]= true
         rt
       end
 
-      attr_reader :children_duration
+      attr_accessor :children_duration
 
-      def initialize(name, page)
+      def initialize(name, page, parent)
         super("Id" => MiniProfiler.generate_id,
               "Name" => name,
               "DurationMilliseconds" => 0,
@@ -30,34 +30,65 @@ module Rack
               "SqlTimingsDurationMilliseconds"=> 0,
               "IsTrivial"=> false,
               "IsRoot"=> false,
-              "Depth"=> 0,
+              "Depth"=> parent ? parent.depth + 1 : 0,
               "ExecutedReaders"=> 0,
               "ExecutedScalars"=> 0,
               "ExecutedNonQueries"=> 0)
         @children_duration = 0
+        @start = Time.now
+        @parent = parent
+        @page = page
       end
 
-      def add_child(request_timer)
+      def duration_ms
+        self['DurationMilliseconds']
+      end
+
+      def start_ms
+        self['StartMilliseconds']
+      end
+
+      def start
+        @start
+      end
+
+      def depth
+        self['Depth']
+      end
+
+      def children
+        self['Children']
+      end
+
+      def add_child(name)
+        request_timer =  RequestTimerStruct.new(name, @page, self)
         self['Children'].push(request_timer)
         self['HasChildren'] = true
         request_timer['ParentTimingId'] = self['Id']
         request_timer['Depth'] = self['Depth'] + 1
-        @children_duration += request_timer['DurationMilliseconds']
+        request_timer
       end
 
       def add_sql(query, elapsed_ms, page, skip_backtrace = false, full_backtrace = false)
-        timer = SqlTimerStruct.new(query, elapsed_ms, page, skip_backtrace, full_backtrace)
+        timer = SqlTimerStruct.new(query, elapsed_ms, page, self , skip_backtrace, full_backtrace)
         timer['ParentTimingId'] = self['Id']
         self['SqlTimings'].push(timer)
         self['HasSqlTimings'] = true
         self['SqlTimingsDurationMilliseconds'] += elapsed_ms
         page['DurationMillisecondsInSql'] += elapsed_ms        
+        timer
       end
 
-      def record_time(milliseconds)
+      def record_time(milliseconds = nil)
+        milliseconds ||= (Time.now - @start) * 1000
         self['DurationMilliseconds'] = milliseconds
         self['IsTrivial'] = true if milliseconds < self["TrivialDurationThresholdMilliseconds"]
         self['DurationWithoutChildrenMilliseconds'] = milliseconds - @children_duration
+        
+        if @parent
+          @parent.children_duration += milliseconds
+        end
+
       end     
     end
   end

data/lib/mini_profiler/sql_timer_struct.rb

@@ -5,7 +5,7 @@ module Rack
 
     # Timing system for a SQL query
     class SqlTimerStruct < TimerStruct
-      def initialize(query, duration_ms, page, skip_backtrace = false, full_backtrace = false)
+      def initialize(query, duration_ms, page, parent, skip_backtrace = false, full_backtrace = false)
 
         stack_trace = nil 
         unless skip_backtrace 
@@ -20,17 +20,28 @@ module Rack
           end
         end
 
+        @parent = parent
+        @page = page
+
         super("ExecuteType" => 3, # TODO
               "FormattedCommandString" => query,
               "StackTraceSnippet" => stack_trace, 
               "StartMilliseconds" => ((Time.now.to_f * 1000).to_i - page['Started']) - duration_ms,
               "DurationMilliseconds" => duration_ms,
-              "FirstFetchDurationMilliseconds" => 0,
+              "FirstFetchDurationMilliseconds" => duration_ms,
               "Parameters" => nil,
               "ParentTimingId" => nil,
               "IsDuplicate" => false)
       end
 
+      def report_reader_duration(elapsed_ms)
+        return if @reported
+        @reported = true
+        self["DurationMilliseconds"] += elapsed_ms
+        @parent["SqlTimingsDurationMilliseconds"] += elapsed_ms
+        @page["DurationMillisecondsInSql"] += elapsed_ms
+      end
+
     end
 
   end

data/lib/mini_profiler_rails/railtie.rb

@@ -1,4 +1,5 @@
 module MiniProfilerRails
+
   class Railtie < ::Rails::Railtie
 
     initializer "rack_mini_profiler.configure_rails_initialization" do |app|
@@ -38,6 +39,42 @@ module MiniProfilerRails
       ::Rack::MiniProfiler.profile_method(ActionController::Base, :process) {|action| "Executing action: #{action}"}
       ::Rack::MiniProfiler.profile_method(ActionView::Template, :render) {|x,y| "Rendering: #{@virtual_path}"}
 
+    end
+
+    # TODO: Implement something better here
+    # config.after_initialize do 
+    #   
+    #   class ::ActionView::Helpers::AssetTagHelper::JavascriptIncludeTag 
+    #     alias_method :asset_tag_orig, :asset_tag
+    #     def asset_tag(source,options)
+    #       current = Rack::MiniProfiler.current 
+    #       return asset_tag_orig(source,options) unless current 
+    #       wrapped = ""
+    #       unless current.mpt_init
+    #         current.mpt_init = true
+    #         wrapped << Rack::MiniProfiler::ClientTimerStruct.init_instrumentation 
+    #       end
+    #       name = source.split('/')[-1]
+    #       wrapped << Rack::MiniProfiler::ClientTimerStruct.instrument(name, asset_tag_orig(source,options)).html_safe
+    #       wrapped
+    #     end
+    #   end
+
+    #   class ::ActionView::Helpers::AssetTagHelper::StylesheetIncludeTag  
+    #     alias_method :asset_tag_orig, :asset_tag
+    #     def asset_tag(source,options)
+    #       current = Rack::MiniProfiler.current 
+    #       return asset_tag_orig(source,options) unless current 
+    #       wrapped = ""
+    #       unless current.mpt_init
+    #         current.mpt_init = true
+    #         wrapped << Rack::MiniProfiler::ClientTimerStruct.init_instrumentation 
+    #       end
+    #       name = source.split('/')[-1]
+    #       wrapped << Rack::MiniProfiler::ClientTimerStruct.instrument(name, asset_tag_orig(source,options)).html_safe
+    #       wrapped
+    #     end
+    #   end
 
     end
 

data/lib/patches/sql_patches.rb

@@ -1,4 +1,13 @@
-module SqlPatches
+class SqlPatches
+
+  def self.patched?
+    @patched
+  end
+
+  def self.patched=(val)
+    @patched = val
+  end
+
 	def self.class_exists?(name)
 		eval(name + ".class").to_s.eql?('Class')
 	rescue NameError
@@ -6,12 +15,116 @@ module SqlPatches
 	end
 end
 
-if SqlPatches.class_exists? "Sequel::Database" then
+# The best kind of instrumentation is in the actual db provider, however we don't want to double instrument
+if SqlPatches.class_exists? "Mysql2::Client"
+  
+  class Mysql2::Result
+    alias_method :each_without_profiling, :each
+    def each(*args, &blk)
+      return each_without_profiling(*args, &blk) unless @miniprofiler_sql_id
+
+      start = Time.now
+      result = each_without_profiling(*args,&blk) 
+      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
+
+      @miniprofiler_sql_id.report_reader_duration(elapsed_time) 
+      result
+    end
+  end
+
+  class Mysql2::Client
+    alias_method :query_without_profiling, :query
+    def query(*args,&blk)
+      current = ::Rack::MiniProfiler.current
+      return query_without_profiling(*args,&blk) unless current
+
+      start = Time.now
+      result = query_without_profiling(*args,&blk)
+      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
+      result.instance_variable_set("@miniprofiler_sql_id", ::Rack::MiniProfiler.record_sql(args[0], elapsed_time))
+
+      result
+
+    end
+  end
+    
+  SqlPatches.patched = true
+end
+
+
+# PG patches, keep in mind exec and async_exec have a exec{|r| } semantics that is yet to be implemented 
+if SqlPatches.class_exists? "PG::Result"
+  
+  class PG::Result
+    alias_method :each_without_profiling, :each
+    alias_method :values_without_profiling, :values
+
+    def values(*args, &blk)
+      return values_without_profiling(*args, &blk) unless @miniprofiler_sql_id
+
+      start = Time.now
+      result = values_without_profiling(*args,&blk) 
+      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
+
+      @miniprofiler_sql_id.report_reader_duration(elapsed_time) 
+      result
+    end
+
+    def each(*args, &blk)
+      return each_without_profiling(*args, &blk) unless @miniprofiler_sql_id
+
+      start = Time.now
+      result = each_without_profiling(*args,&blk) 
+      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
+
+      @miniprofiler_sql_id.report_reader_duration(elapsed_time) 
+      result
+    end
+  end
+
+  class PG::Connection
+    alias_method :exec_without_profiling, :exec
+    alias_method :async_exec_without_profiling, :async_exec
+
+    def exec(*args,&blk)
+      current = ::Rack::MiniProfiler.current
+      return exec_without_profiling(*args,&blk) unless current
+
+      start = Time.now
+      result = exec_without_profiling(*args,&blk)
+      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
+      result.instance_variable_set("@miniprofiler_sql_id", ::Rack::MiniProfiler.record_sql(args[0], elapsed_time))
+
+      result
+    end
+
+    def async_exec(*args,&blk)
+      current = ::Rack::MiniProfiler.current
+      return exec_without_profiling(*args,&blk) unless current
+
+      start = Time.now
+      result = exec_without_profiling(*args,&blk)
+      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
+      result.instance_variable_set("@miniprofiler_sql_id", ::Rack::MiniProfiler.record_sql(args[0], elapsed_time))
+
+      result
+    end
+    
+    alias_method :query, :exec
+  end
+    
+  SqlPatches.patched = true
+end
+
+
+
+# Fallback for sequel
+if SqlPatches.class_exists?("Sequel::Database") && !SqlPatches.patched?
 	module Sequel
 		class Database
 			alias_method :log_duration_original, :log_duration
 			def log_duration(duration, message)
-				::Rack::MiniProfiler.instance.record_sql(message, duration) if ::Rack::MiniProfiler.instance
+				::Rack::MiniProfiler.record_sql(message, duration)
 				log_duration_original(duration, message)
 			end
 		end
@@ -20,6 +133,7 @@ end
 
 
 ## based off https://github.com/newrelic/rpm/blob/master/lib/new_relic/agent/instrumentation/active_record.rb
+## fallback for alls sorts of weird dbs
 module Rack
   class MiniProfiler  
     module ActiveRecordInstrumentation
@@ -34,19 +148,18 @@ module Rack
       end
 
       def log_with_miniprofiler(*args, &block)
+        current = ::Rack::MiniProfiler.current
+        return log_without_miniprofiler(*args, &block) unless current
+
         sql, name, binds = args
         t0 = Time.now
         rval = log_without_miniprofiler(*args, &block)
-
-        # Get our MP Instance
-        instance = ::Rack::MiniProfiler.instance
-        return rval unless instance
-
+        
         # Don't log schema queries if the option is set
-        return rval if instance.config.skip_schema_queries and name =~ /SCHEMA/
+        return rval if Rack::MiniProfiler.config.skip_schema_queries and name =~ /SCHEMA/
 
         elapsed_time = ((Time.now - t0).to_f * 1000).round(1)
-        instance.record_sql(sql, elapsed_time)
+        Rack::MiniProfiler.record_sql(sql, elapsed_time)
         rval
       end
     end
@@ -58,7 +171,7 @@ module Rack
     end
   end
 
-  if defined?(::Rails)
+  if defined?(::Rails) && !SqlPatches.patched?
     insert_instrumentation
   end
 end

data/rack-mini-profiler.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
 	s.name = "rack-mini-profiler"
-	s.version = "0.1.3"
+	s.version = "0.1.4"
 	s.summary = "Profiles loading speed for rack applications."
 	s.authors = ["Aleks Totic","Sam Saffron", "Robin Ward"]
 	s.date = "2012-04-02"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-mini-profiler
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -91,8 +91,10 @@ files:
 - lib/mini_profiler/request_timer_struct.rb
 - lib/mini_profiler/timer_struct.rb
 - lib/mini_profiler/page_timer_struct.rb
+- lib/mini_profiler/context.rb
 - lib/mini_profiler/config.rb
 - lib/mini_profiler/body_add_proxy.rb
+- lib/mini_profiler/profiling_methods.rb
 - lib/mini_profiler/client_timer_struct.rb
 - lib/mini_profiler/profiler.rb
 - lib/mini_profiler/storage/memory_store.rb
@@ -130,7 +132,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 809318397
+      hash: 887503633
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -139,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 809318397
+      hash: 887503633
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.24