rack-mini-profiler 0.1.2 → 0.1.7

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)
-        timer = SqlTimerStruct.new(query, elapsed_ms, page, skip_backtrace)
+      def add_sql(query, elapsed_ms, page, skip_backtrace = false, full_backtrace = false)
+        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)
+      def initialize(query, duration_ms, page, parent, skip_backtrace = false, full_backtrace = false)
 
         stack_trace = nil 
         unless skip_backtrace 
@@ -13,24 +13,35 @@ module Rack
           stack_trace = ""
            # 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
-            if Rack::MiniProfiler.config.backtrace_filter.nil? or ln =~ Rack::MiniProfiler.config.backtrace_filter
+            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
               stack_trace << ln << "\n" 
             end
           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|
@@ -6,8 +7,7 @@ module MiniProfilerRails
 
       # By default, only show the MiniProfiler in development mode, in production allow profiling if post_authorize_cb is set
       c.pre_authorize_cb = lambda { |env|
-        Rails.env.development? ||  
-        (Rack::MiniProfiler.config.post_authorize_cb && Rack::MiniProfiler.has_profiling_cookie?(env))
+        Rails.env.development? || Rails.env.production?  
       }
 
       if Rails.env.development?
@@ -16,6 +16,10 @@ module MiniProfilerRails
         c.skip_schema_queries = true
       end
 
+      if Rails.env.production? 
+        c.authorization_mode = :whitelist
+      end
+
       # The file store is just so much less flaky
       tmp = Rails.root.to_s + "/tmp/miniprofiler"
       Dir::mkdir(tmp) unless File.exists?(tmp)
@@ -29,14 +33,50 @@ module MiniProfilerRails
       c.skip_schema_queries =  Rails.env != 'production'
 
       # Install the Middleware
-      app.middleware.insert_before 'Rack::Lock', 'Rack::MiniProfiler'
+      app.middleware.insert(0, Rack::MiniProfiler)
 
       # Attach to various Rails methods
       ::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
+
   end
 end

data/lib/patches/sql_patches.rb

@@ -1,17 +1,136 @@
-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
 		false
 	end
+	
+  def self.module_exists?(name)
+		eval(name + ".class").to_s.eql?('Module')
+	rescue NameError
+		false
+	end
+end
+
+# 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
 
-if SqlPatches.class_exists? "Sequel::Database" then
+
+
+# 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,46 +139,47 @@ end
 
 
 ## based off https://github.com/newrelic/rpm/blob/master/lib/new_relic/agent/instrumentation/active_record.rb
-module Rack
-  class MiniProfiler  
-    module ActiveRecordInstrumentation
-      def self.included(instrumented_class)
-        instrumented_class.class_eval do
-          unless instrumented_class.method_defined?(:log_without_miniprofiler)
-            alias_method :log_without_miniprofiler, :log
-            alias_method :log, :log_with_miniprofiler
-            protected :log
+## fallback for alls sorts of weird dbs
+if SqlPatches.module_exists?('ActiveRecord')
+  module Rack
+    class MiniProfiler  
+      module ActiveRecordInstrumentation
+        def self.included(instrumented_class)
+          instrumented_class.class_eval do
+            unless instrumented_class.method_defined?(:log_without_miniprofiler)
+              alias_method :log_without_miniprofiler, :log
+              alias_method :log, :log_with_miniprofiler
+              protected :log
+            end
           end
         end
-      end
-
-      def log_with_miniprofiler(*args, &block)
-        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
+        def log_with_miniprofiler(*args, &block)
+          current = ::Rack::MiniProfiler.current
+          return log_without_miniprofiler(*args, &block) unless current
 
-        # Don't log schema queries if the option is set
-        return rval if instance.config.skip_schema_queries and name =~ /SCHEMA/
+          sql, name, binds = args
+          t0 = Time.now
+          rval = log_without_miniprofiler(*args, &block)
+          
+          # Don't log schema queries if the option is set
+          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)
-        rval
+          elapsed_time = ((Time.now - t0).to_f * 1000).round(1)
+          Rack::MiniProfiler.record_sql(sql, elapsed_time)
+          rval
+        end
       end
     end
-  end
 
-  def self.insert_instrumentation 
-    ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
-      include ::Rack::MiniProfiler::ActiveRecordInstrumentation
+    def self.insert_instrumentation 
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+        include ::Rack::MiniProfiler::ActiveRecordInstrumentation
+      end
     end
-  end
 
-  if defined?(::Rails)
-    insert_instrumentation
+    if defined?(::Rails) && !SqlPatches.patched?
+      insert_instrumentation
+    end
   end
 end
-