rack-mini-profiler 0.9.2 → 0.9.3

data/lib/mini_profiler/storage/file_store.rb

@@ -39,9 +39,9 @@ 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
         t = CacheCleanupThread.new do
@@ -77,7 +77,7 @@ module Rack
 
       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/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

@@ -4,48 +4,77 @@ module Rack
 
       # 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[:expires_in] || EXPIRES_IN_SECONDS
-        @timer_struct_lock = Mutex.new
-        @timer_struct_cache = {}
-        @user_view_lock = Mutex.new
-        @user_view_cache = {}
+        @expires_in_seconds = args.fetch(:expires_in) { EXPIRES_IN_SECONDS }
+        initialize_locks
+        initialize_cleanup_thread(args)
+      end
 
-        # TODO: fix it to use weak ref, trouble is may be broken in 1.9 so need to use the 'ref' gem
-        me = self
-        t = CacheCleanupThread.new do
-          interval = 10
-          cleanup_cache_cycle = 3600
-          cycle_count = 1
+      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
-            # 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
+            self.sleepy_run
           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
 
@@ -78,7 +107,7 @@ module Rack
       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 }
+          @timer_struct_cache.delete_if { |k, v| v[:started] < expire_older_than }
         }
       end
     end

data/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

data/lib/mini_profiler/timer_struct/custom.rb

@@ -0,0 +1,22 @@
+module Rack
+  class MiniProfiler
+    module TimerStruct
+      # Timing system for a custom timers such as cache, redis, RPC, external API
+      # calls, etc.
+      class Custom < TimerStruct::Base
+        def initialize(type, duration_ms, page, parent)
+          @parent      = parent
+          @page        = page
+          @type        = type
+          start_millis = ((Time.now.to_f * 1000).to_i - page[:started]) - duration_ms
+          super(
+            :type                  => type,
+            :start_milliseconds    => start_millis,
+            :duration_milliseconds => duration_ms,
+            :parent_timing_id      => nil
+          )
+        end
+      end
+    end
+  end
+end

data/lib/mini_profiler/timer_struct/page.rb

@@ -0,0 +1,62 @@
+module Rack
+  class MiniProfiler
+    module TimerStruct
+
+      # TimerStruct::Page
+      #   Root: TimerStruct::Request
+      #     :has_many TimerStruct::Request children
+      #     :has_many TimerStruct::Sql children
+      #     :has_many TimerStruct::Custom children
+      class Page < TimerStruct::Base
+        def initialize(env)
+          timer_id     = MiniProfiler.generate_id
+          page_name    = env['PATH_INFO']
+          started_at   = (Time.now.to_f * 1000).to_i
+          machine_name = env['SERVER_NAME']
+          super(
+            :id                                      => timer_id,
+            :name                                    => page_name,
+            :started                                 => started_at,
+            :machine_name                            => machine_name,
+            :level                                   => 0,
+            :user                                    => "unknown user",
+            :has_user_viewed                         => false,
+            :client_timings                          => nil,
+            :duration_milliseconds                   => 0,
+            :has_trivial_timings                     => true,
+            :has_all_trivial_timings                 => false,
+            :trivial_duration_threshold_milliseconds => 2,
+            :head                                    => nil,
+            :duration_milliseconds_in_sql            => 0,
+            :has_sql_timings                         => true,
+            :has_duplicate_sql_timings               => false,
+            :executed_readers                        => 0,
+            :executed_scalars                        => 0,
+            :executed_non_queries                    => 0,
+            :custom_timing_names                     => [],
+            :custom_timing_stats                     => {}
+          )
+          name = "#{env['REQUEST_METHOD']} http://#{env['SERVER_NAME']}:#{env['SERVER_PORT']}#{env['SCRIPT_NAME']}#{env['PATH_INFO']}"
+          self[:root] = TimerStruct::Request.createRoot(name, self)
+        end
+
+        def duration_ms
+          @attributes[:root][:duration_milliseconds]
+        end
+
+        def root
+          @attributes[:root]
+        end
+
+        def to_json(*a)
+          attribs = @attributes.merge(
+            :started               => '/Date(%d)/' % @attributes[:started],
+            :duration_milliseconds => @attributes[:root][:duration_milliseconds],
+            :custom_timing_names   => @attributes[:custom_timing_stats].keys.sort
+          )
+          ::JSON.generate(attribs, :max_nesting => 100)
+        end
+      end
+    end
+  end
+end

data/lib/mini_profiler/timer_struct/request.rb

@@ -0,0 +1,126 @@
+module Rack
+  class MiniProfiler
+    module TimerStruct
+      class Request < TimerStruct::Base
+
+        def self.createRoot(name, page)
+          TimerStruct::Request.new(name, page, nil).tap do |timer|
+            timer[:is_root] = true
+          end
+        end
+
+        attr_accessor :children_duration
+
+        def initialize(name, page, parent)
+          start_millis = (Time.now.to_f * 1000).to_i - page[:started]
+          depth        = parent ? parent.depth + 1 : 0
+          super(
+            :id                                      => MiniProfiler.generate_id,
+            :name                                    => name,
+            :duration_milliseconds                   => 0,
+            :duration_without_children_milliseconds  => 0,
+            :start_milliseconds                      => start_millis,
+            :parent_timing_id                        => nil,
+            :children                                => [],
+            :has_children                            => false,
+            :key_values                              => nil,
+            :has_sql_timings                         => false,
+            :has_duplicate_sql_timings               => false,
+            :trivial_duration_threshold_milliseconds => 2,
+            :sql_timings                             => [],
+            :sql_timings_duration_milliseconds       => 0,
+            :is_trivial                              => false,
+            :is_root                                 => false,
+            :depth                                   => depth,
+            :executed_readers                        => 0,
+            :executed_scalars                        => 0,
+            :executed_non_queries                    => 0,
+            :custom_timing_stats                     => {},
+            :custom_timings                          => {}
+          )
+          @children_duration = 0
+          @start             = Time.now
+          @parent            = parent
+          @page              = page
+        end
+
+        def duration_ms
+          self[:duration_milliseconds]
+        end
+
+        def start_ms
+          self[:start_milliseconds]
+        end
+
+        def start
+          @start
+        end
+
+        def depth
+          self[:depth]
+        end
+
+        def children
+          self[:children]
+        end
+
+        def custom_timings
+          self[:custom_timings]
+        end
+
+        def sql_timings
+          self[:sql_timings]
+        end
+
+        def add_child(name)
+          TimerStruct::Request.new(name, @page, self).tap do |timer|
+            self[:children].push(timer)
+            self[:has_children]      = true
+            timer[:parent_timing_id] = self[:id]
+            timer[:depth]            = self[:depth] + 1
+          end
+        end
+
+        def add_sql(query, elapsed_ms, page, skip_backtrace = false, full_backtrace = false)
+          TimerStruct::Sql.new(query, elapsed_ms, page, self , skip_backtrace, full_backtrace).tap do |timer|
+            self[:sql_timings].push(timer)
+            timer[:parent_timing_id] = self[:id]
+            self[:has_sql_timings]   = true
+            self[:sql_timings_duration_milliseconds] += elapsed_ms
+            page[:duration_milliseconds_in_sql]      += elapsed_ms
+          end
+        end
+
+        def add_custom(type, elapsed_ms, page)
+          TimerStruct::Custom.new(type, elapsed_ms, page, self).tap do |timer|
+            timer[:parent_timing_id] = self[:id]
+
+            self[:custom_timings][type] ||= []
+            self[:custom_timings][type].push(timer)
+
+            self[:custom_timing_stats][type] ||= {:count => 0, :duration => 0.0}
+            self[:custom_timing_stats][type][:count]    += 1
+            self[:custom_timing_stats][type][:duration] += elapsed_ms
+
+            page[:custom_timing_stats][type] ||= {:count => 0, :duration => 0.0}
+            page[:custom_timing_stats][type][:count]    += 1
+            page[:custom_timing_stats][type][:duration] += elapsed_ms
+          end
+        end
+
+        def record_time(milliseconds = nil)
+          milliseconds ||= (Time.now - @start) * 1000
+          self[:duration_milliseconds]                  = milliseconds
+          self[:is_trivial]                             = true if milliseconds < self[:trivial_duration_threshold_milliseconds]
+          self[:duration_without_children_milliseconds] = milliseconds - @children_duration
+
+          if @parent
+            @parent.children_duration += milliseconds
+          end
+
+        end
+
+      end
+    end
+  end
+end