rack-mini-profiler 0.1 → 0.1.21

data/lib/mini_profiler/profiling_methods.rb

@@ -0,0 +1,108 @@
+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
+
+      def start_step(name)
+        if current
+          parent_timer = current.current_timer
+          current.current_timer = current_timer = current.current_timer.add_child(name)
+          [current_timer,parent_timer]
+        end
+      end
+
+      def finish_step(obj)
+        if obj && current
+          current_timer, parent_timer = obj
+          current_timer.record_time
+          current.current_timer = parent_timer
+        end
+      end
+
+      # perform a profiling step on given block
+      def step(name, opts = nil)
+        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
+        else
+          yield if block_given?
+        end
+      end
+
+      def unprofile_method(klass, method)
+
+        clean = clean_method_name(method)
+
+        with_profiling = ("#{clean}_with_mini_profiler").intern
+        without_profiling = ("#{clean}_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
+        clean = clean_method_name(method)
+
+        with_profiling =  ("#{clean}_with_mini_profiler").intern
+        without_profiling = ("#{clean}_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 
+          if blk
+            name =
+              if respond_to?(:instance_exec)
+                instance_exec(*args, &blk)
+              else
+                # deprecated in Rails 4.x
+                blk.bind(self).call(*args)
+              end
+          end
+
+          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
+
+      private
+
+      def clean_method_name(method)
+        method.to_s.gsub(/[\?\!]/, "")
+      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,45 @@ 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.configuration[:backtrace_remove], '') if Rack::MiniProfiler.configuration[:backtrace_remove]
-            if Rack::MiniProfiler.configuration[:backtrace_filter].nil? or ln =~ Rack::MiniProfiler.configuration[: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_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
         end
 
+        @parent = parent
+        @page = page
+
         super("ExecuteType" => 3, # TODO
               "FormattedCommandString" => query,
               "StackTraceSnippet" => stack_trace, 
-              "StartMilliseconds" => (Time.now.to_f * 1000).to_i - page['Started'],
+              "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/storage/file_store.rb

@@ -39,9 +39,14 @@ module Rack
 
         me = self
         Thread.new do
-          while true do
-            me.cleanup_cache if MiniProfiler.instance
-            sleep(3600)
+          begin 
+            while true do
+              # TODO: a sane retry count before bailing
+              me.cleanup_cache
+              sleep(3600)
+            end
+          rescue
+            # don't crash the thread, we can clean up next time 
           end
         end
       end
@@ -83,10 +88,6 @@ module Rack
         }
       end
       
-
-      private 
-
-
       def cleanup_cache
         files = Dir.entries(@path)
         @timer_struct_lock.synchronize {

data/lib/mini_profiler/storage/memcache_store.rb

@@ -0,0 +1,51 @@
+module Rack
+  class MiniProfiler
+    class MemcacheStore < AbstractStore
+
+      EXPIRE_SECONDS = 60*60*24
+      MAX_RETRIES = 10
+
+      def initialize(client = nil, prefix = "MPMemcacheStore")
+        require 'dalli' unless defined? Dalli
+        @prefix = prefix
+        @client = client || Dalli::Client.new(['localhost:11211'])
+      end
+
+      def save(page_struct)
+        @client.set("#{@prefix}#{page_struct['Id']}", Marshal::dump(page_struct), EXPIRE_SECONDS)
+      end
+
+      def load(id)
+        raw = @client.get("#{@prefix}#{id}")
+        if raw
+          Marshal::load raw
+        end
+      end
+
+      def set_unviewed(user, id)
+        @client.add("#{@prefix}-#{user}-v", [], EXPIRE_SECONDS)
+        MAX_RETRIES.times do
+          break if @client.cas("#{@prefix}-#{user}-v", EXPIRE_SECONDS) do |ids|
+            ids << id unless ids.include?(id)
+            ids
+          end
+        end
+      end
+
+      def set_viewed(user, id)
+        @client.add("#{@prefix}-#{user}-v", [], EXPIRE_SECONDS)
+        MAX_RETRIES.times do
+          break if @client.cas("#{@prefix}-#{user}-v", EXPIRE_SECONDS) do |ids|
+            ids.delete id
+            ids
+          end
+        end
+      end
+
+      def get_unviewed_ids(user)
+        @client.get("#{@prefix}-#{user}-v") || []
+      end
+
+    end
+  end
+end

data/lib/mini_profiler/storage/memory_store.rb

@@ -52,17 +52,12 @@ module Rack
         }
       end
       
-
-      private 
-
-
       def cleanup_cache
         expire_older_than = ((Time.now.to_f - MiniProfiler::MemoryStore::EXPIRE_TIMER_CACHE) * 1000).to_i
         @timer_struct_lock.synchronize {
-          @timer_struct_cache.delete_if { |k, v| v['Root']['StartMilliseconds'] < expire_older_than }
+          @timer_struct_cache.delete_if { |k, v| v['Started'] < expire_older_than }
         }
       end
-    
     end
   end
 end

data/lib/mini_profiler/storage/redis_store.rb

@@ -4,7 +4,8 @@ module Rack
 
       EXPIRE_SECONDS = 60 * 60 * 24
      
-      def initialize(args = {})
+      def initialize(args)
+        args ||= {}
         @prefix = args[:prefix] || 'MPRedisStore'
       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

@@ -1,30 +1,85 @@
+require 'fileutils'
+
 module MiniProfilerRails
+
   class Railtie < ::Rails::Railtie
 
     initializer "rack_mini_profiler.configure_rails_initialization" do |app|
+      c = Rack::MiniProfiler.config
 
-      # By default, only show the MiniProfiler in development mode
-      Rack::MiniProfiler.configuration[:authorize_cb] = lambda {|env| Rails.env.development? }
-      tmp = Rails.root.to_s + "/tmp/miniprofiler"
-      Dir::mkdir(tmp) unless File.exists?(tmp)
-      Rack::MiniProfiler.configuration[:storage_options] = {:path => tmp}
-      Rack::MiniProfiler.configuration[:storage] = Rack::MiniProfiler::FileStore
+      # 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? || Rails.env.production?  
+      }
 
-      # Quiet the SQL stack traces
-      Rack::MiniProfiler.configuration[:backtrace_remove] = Rails.root.to_s + "/"
-      Rack::MiniProfiler.configuration[:backtrace_filter] =  /^\/?(app|config|lib|test)/
+      c.skip_paths ||= []
+
+      if Rails.env.development?
+        c.skip_paths << "/assets/"
+        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"
+      FileUtils.mkdir_p(tmp) unless File.exists?(tmp)
+
+      c.storage_options = {:path => tmp}
+      c.storage = Rack::MiniProfiler::FileStore
+
+      # Quiet the SQL stack traces
+      c.backtrace_remove = Rails.root.to_s + "/"
+      c.backtrace_includes =  [/^\/?(app|config|lib|test)/]
+      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