rack-mini-profiler 0.1.31 → 0.9.3

data/{Ruby/lib → lib}/mini_profiler/profiling_methods.rb

@@ -3,32 +3,30 @@ module Rack
     module ProfilingMethods
 
       def record_sql(query, elapsed_ms)
+        return unless current
         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
+        return unless current
+        parent_timer          = current.current_timer
+        current.current_timer = current_timer = current.current_timer.add_child(name)
+        [current_timer,parent_timer]
       end
 
       def finish_step(obj)
-        if obj && current
-          current_timer, parent_timer = obj
-          current_timer.record_time
-          current.current_timer = parent_timer
-        end
+        return unless obj && current
+        current_timer, parent_timer = obj
+        current_timer.record_time
+        current.current_timer = parent_timer
       end
 
       # perform a profiling step on given block
       def step(name, opts = nil)
         if current
-          parent_timer = current.current_timer
-          result = nil
+          parent_timer          = current.current_timer
+          result                = nil
           current.current_timer = current_timer = current.current_timer.add_child(name)
           begin
             result = yield if block_given?
@@ -65,9 +63,9 @@ module Rack
 
       def profile_method(klass, method, type = :profile, &blk)
         default_name = type==:counter ? method.to_s  : klass.to_s + " " + method.to_s
-        clean = clean_method_name(method)
+        clean        = clean_method_name(method)
 
-        with_profiling =  ("#{clean}_with_mini_profiler").intern
+        with_profiling    = ("#{clean}_with_mini_profiler").intern
         without_profiling = ("#{clean}_without_mini_profiler").intern
 
         if klass.send :method_defined?, with_profiling
@@ -131,8 +129,8 @@ module Rack
       def counter(type, duration_ms=nil)
         result = nil
         if block_given?
-          start = Time.now
-          result = yield
+          start       = Time.now
+          result      = yield
           duration_ms = (Time.now - start).to_f * 1000
         end
         return result if current.nil? || !request_authorized?

data/{Ruby/lib → lib}/mini_profiler/storage/file_store.rb

@@ -2,6 +2,10 @@ module Rack
   class MiniProfiler
     class FileStore < AbstractStore
 
+      # Sub-class thread so we have a named thread (useful for debugging in Thread.list).
+      class CacheCleanupThread < Thread
+      end
+
       class FileCache
         def initialize(path, prefix)
           @path = path
@@ -35,27 +39,45 @@ module Rack
         @expires_in_seconds = args[:expires_in] || EXPIRES_IN_SECONDS
         raise ArgumentError.new :path unless @path
         @timer_struct_cache = FileCache.new(@path, "mp_timers")
-        @timer_struct_lock = Mutex.new
-        @user_view_cache = FileCache.new(@path, "mp_views")
-        @user_view_lock = Mutex.new
+        @timer_struct_lock  = Mutex.new
+        @user_view_cache    = FileCache.new(@path, "mp_views")
+        @user_view_lock     = Mutex.new
 
         me = self
-        Thread.new do
+        t = CacheCleanupThread.new do
+          interval = 10
+          cleanup_cache_cycle = 3600
+          cycle_count = 1
+
           begin
-            while true do
+            until Thread.current[:should_exit] do
               # TODO: a sane retry count before bailing
-              me.cleanup_cache
-              sleep(3600)
+
+              # We don't want to hit the filesystem every 10s to clean up the cache so we need to do a bit of
+              # accounting to avoid sleeping that entire time.  We don't want to sleep for the entire period because
+              # it means the thread will stay live in hot deployment scenarios, keeping a potentially large memory
+              # graph from being garbage collected upon undeploy.
+              if cycle_count * interval >= cleanup_cache_cycle
+                cycle_count = 1
+                me.cleanup_cache
+              end
+
+              sleep(interval)
+              cycle_count += 1
             end
           rescue
             # don't crash the thread, we can clean up next time
           end
         end
+
+        at_exit { t[:should_exit] = true }
+
+        t
       end
 
       def save(page_struct)
         @timer_struct_lock.synchronize {
-          @timer_struct_cache[page_struct['Id']] = page_struct
+          @timer_struct_cache[page_struct[:id]] = page_struct
         }
       end
 

data/{Ruby/lib → lib}/mini_profiler/storage/memcache_store.rb

@@ -3,25 +3,23 @@ module Rack
     class MemcacheStore < AbstractStore
 
       EXPIRES_IN_SECONDS = 60 * 60 * 24
-      MAX_RETRIES = 10
+      MAX_RETRIES        = 10
 
       def initialize(args = nil)
         require 'dalli' unless defined? Dalli
         args ||= {}
-        @prefix = args[:prefix] || "MPMemcacheStore"
-        @client = args[:client] || Dalli::Client.new
+        @prefix             = args[:prefix]     || "MPMemcacheStore"
+        @client             = args[:client]     || Dalli::Client.new
         @expires_in_seconds = args[:expires_in] || EXPIRES_IN_SECONDS
       end
 
       def save(page_struct)
-        @client.set("#{@prefix}#{page_struct['Id']}", Marshal::dump(page_struct), @expires_in_seconds)
+        @client.set("#{@prefix}#{page_struct[:id]}", Marshal::dump(page_struct), @expires_in_seconds)
       end
 
       def load(id)
         raw = @client.get("#{@prefix}#{id}")
-        if raw
-          Marshal::load raw
-        end
+        Marshal::load(raw) if raw
       end
 
       def set_unviewed(user, id)

data/lib/mini_profiler/storage/memory_store.rb

@@ -0,0 +1,115 @@
+module Rack
+  class MiniProfiler
+    class MemoryStore < AbstractStore
+
+      # Sub-class thread so we have a named thread (useful for debugging in Thread.list).
+      class CacheCleanupThread < Thread
+
+        def initialize(interval, cycle, store)
+          super
+          @store       = store
+          @interval    = interval
+          @cycle       = cycle
+          @cycle_count = 1
+        end
+
+        def should_cleanup?
+          @cycle_count * @interval >= @cycle
+        end
+
+
+        # We don't want to hit the filesystem every 10s to clean up the cache so we need to do a bit of
+        # accounting to avoid sleeping that entire time.  We don't want to sleep for the entire period because
+        # it means the thread will stay live in hot deployment scenarios, keeping a potentially large memory
+        # graph from being garbage collected upon undeploy.
+        def sleepy_run
+          cleanup if should_cleanup?
+          sleep(@interval)
+          increment_cycle
+        end
+
+        def cleanup
+          @store.cleanup_cache
+          @cycle_count = 1
+        end
+
+        def cycle_count
+          @cycle_count
+        end
+
+        def increment_cycle
+          @cycle_count += 1
+        end
+      end
+
+      EXPIRES_IN_SECONDS = 60 * 60 * 24
+      CLEANUP_INTERVAL   = 10
+      CLEANUP_CYCLE      = 3600
+
+      def initialize(args = nil)
+        args ||= {}
+        @expires_in_seconds = args.fetch(:expires_in) { EXPIRES_IN_SECONDS }
+        initialize_locks
+        initialize_cleanup_thread(args)
+      end
+
+      def initialize_locks
+        @timer_struct_lock  = Mutex.new
+        @user_view_lock     = Mutex.new
+        @timer_struct_cache = {}
+        @user_view_cache    = {}
+      end
+
+      #FIXME: use weak ref, trouble it may be broken in 1.9 so need to use the 'ref' gem
+      def initialize_cleanup_thread(args={})
+        cleanup_interval = args.fetch(:cleanup_interval) { CLEANUP_INTERVAL }
+        cleanup_cycle    = args.fetch(:cleanup_cycle)    { CLEANUP_CYCLE }
+        t = CacheCleanupThread.new(cleanup_interval, cleanup_cycle, self) do |t|
+          until Thread.current[:should_exit] do
+            self.sleepy_run
+          end
+        end
+        at_exit { t[:should_exit] = true }
+      end
+
+      def save(page_struct)
+        @timer_struct_lock.synchronize {
+          @timer_struct_cache[page_struct[:id]] = page_struct
+        }
+      end
+
+      def load(id)
+        @timer_struct_lock.synchronize {
+          @timer_struct_cache[id]
+        }
+      end
+
+      def set_unviewed(user, id)
+        @user_view_lock.synchronize {
+          @user_view_cache[user] ||= []
+          @user_view_cache[user] << id
+        }
+      end
+
+      def set_viewed(user, id)
+        @user_view_lock.synchronize {
+          @user_view_cache[user] ||= []
+          @user_view_cache[user].delete(id)
+        }
+      end
+
+      def get_unviewed_ids(user)
+        @user_view_lock.synchronize {
+          @user_view_cache[user]
+        }
+      end
+
+      def cleanup_cache
+        expire_older_than = ((Time.now.to_f - @expires_in_seconds) * 1000).to_i
+        @timer_struct_lock.synchronize {
+          @timer_struct_cache.delete_if { |k, v| v[:started] < expire_older_than }
+        }
+      end
+    end
+  end
+end

data/{Ruby/lib → lib}/mini_profiler/storage/redis_store.rb

@@ -5,25 +5,32 @@ module Rack
       EXPIRES_IN_SECONDS = 60 * 60 * 24
 
       def initialize(args = nil)
-        @args = args || {}
-        @prefix = @args.delete(:prefix) || 'MPRedisStore'
-        @redis_connection = @args.delete(:connection)
+        @args               = args || {}
+        @prefix             = @args.delete(:prefix)     || 'MPRedisStore'
+        @redis_connection   = @args.delete(:connection)
         @expires_in_seconds = @args.delete(:expires_in) || EXPIRES_IN_SECONDS
       end
 
       def save(page_struct)
-        redis.setex "#{@prefix}#{page_struct['Id']}", @expires_in_seconds, Marshal::dump(page_struct)
+        redis.setex "#{@prefix}#{page_struct[:id]}", @expires_in_seconds, Marshal::dump(page_struct)
       end
 
       def load(id)
-        raw = redis.get "#{@prefix}#{id}"
-        if raw
-          Marshal::load raw
+        key = "#{@prefix}#{id}"
+        raw = redis.get key
+        begin
+          Marshal::load(raw) if raw
+        rescue
+          # bad format, junk old data
+          redis.del key
+          nil
         end
       end
 
       def set_unviewed(user, id)
-        redis.sadd "#{@prefix}-#{user}-v", id
+        key = "#{@prefix}-#{user}-v"
+        redis.sadd key, id
+        redis.expire key, @expires_in_seconds
       end
 
       def set_viewed(user, id)
@@ -44,9 +51,10 @@ unviewed_ids: #{get_unviewed_ids(user)}
       private
 
       def redis
-        return @redis_connection if @redis_connection
-        require 'redis' unless defined? Redis
-        @redis_connection ||= Redis.new @args
+        @redis_connection ||= begin
+          require 'redis' unless defined? Redis
+          Redis.new(@args)
+        end
       end
 
     end

data/lib/mini_profiler/timer_struct/base.rb

@@ -0,0 +1,33 @@
+module Rack
+  class MiniProfiler
+    module TimerStruct
+      # A base class for timing structures
+      class Base
+
+        def initialize(attrs={})
+          @attributes = attrs
+        end
+
+        def attributes
+          @attributes ||= {}
+        end
+
+        def [](name)
+          attributes[name]
+        end
+
+        def []=(name, val)
+          attributes[name] = val
+          self
+        end
+
+        def to_json(*a)
+          # 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
+    end
+  end
+end

data/lib/mini_profiler/timer_struct/client.rb

@@ -0,0 +1,89 @@
+module Rack
+  class MiniProfiler
+    module TimerStruct
+
+      # This class holds the client timings
+      class Client < TimerStruct::Base
+
+        def self.init_instrumentation
+          %Q{
+            <script type="text/javascript">
+              mPt=function(){var t=[];return{t:t,probe:function(n){t.push({d:new Date(),n:n})}}}()
+            </script>
+          }
+        end
+
+        # used by Railtie to instrument asset_tag for JS / CSS
+        def self.instrument(name, orig)
+          probe = "<script>mPt.probe('#{name}')</script>"
+          wrapped = probe
+          wrapped << orig
+          wrapped << probe
+          wrapped
+        end
+
+
+        def initialize(env={})
+          super
+        end
+
+        def redirect_count
+          self[:redirect_count]
+        end
+
+        def timings
+          self[:timings]
+        end
+
+        def self.init_from_form_data(env, page_struct)
+          timings = []
+          clientTimes, clientPerf, baseTime = nil
+          form = env['rack.request.form_hash']
+
+          clientPerf  = form['clientPerformance']           if form
+          clientTimes = clientPerf['timing']                if clientPerf
+          baseTime    = clientTimes['navigationStart'].to_i if clientTimes
+          return unless clientTimes && baseTime
+
+          probes     = form['clientProbes']
+          translated = {}
+          if probes && !["null", ""].include?(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
+            duration = 0
+            duration = finish - start if finish > start
+            name     = k.sub(/Start$/, "").split(/(?=[A-Z])/).map{|s| s.capitalize}.join(' ')
+            timings.push({"Name" => name, "Start" => start, "Duration" => duration}) if start >= 0
+          end
+
+          clientTimes.keys.find_all{|k| !(k =~ /(End|Start)$/)}.each do |k|
+            timings.push("Name" => k, "Start" => clientTimes[k].to_i - baseTime, "Duration" => -1)
+          end
+
+          TimerStruct::Client.new.tap do |rval|
+            rval[:redirect_count] = env['rack.request.form_hash']['clientPerformance']['navigation']['redirect_count']
+            rval[:timings]        = timings
+          end
+        end
+      end
+    end
+  end
+end