rack-mini-profiler 0.1.23 → 0.1.28

data/Ruby/lib/mini_profiler/profiling_methods.rb

@@ -1,108 +1,131 @@
-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
+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
+      
+      # Add a custom timing. These are displayed similar to SQL/query time in
+      # columns expanding to the right.
+      #
+      # type        - String counter type. Each distinct type gets its own column.
+      # duration_ms - Duration of the call in ms. Either this or a block must be
+      #               given but not both.
+      #
+      # When a block is given, calculate the duration by yielding to the block
+      # and keeping a record of its run time.
+      #
+      # Returns the result of the block, or nil when no block is given.
+      def counter(type, duration_ms=nil)
+        result = nil
+        if block_given?
+          start = Time.now
+          result = yield
+          duration_ms = (Time.now - start).to_f * 1000
+        end
+        return result if current.nil? || !request_authorized?
+        current.current_timer.add_custom(type, duration_ms, current.page_struct)
+        result
+      end
+
+      private
+
+      def clean_method_name(method)
+        method.to_s.gsub(/[\?\!]/, "")
+      end
+
+    end
+  end
+end

data/Ruby/lib/mini_profiler/sql_timer_struct.rb

@@ -8,7 +8,7 @@ module Rack
       def initialize(query, duration_ms, page, parent, skip_backtrace = false, full_backtrace = false)
 
         stack_trace = nil 
-        unless skip_backtrace 
+        unless skip_backtrace || duration_ms < Rack::MiniProfiler.config.backtrace_threshold_ms
           # Allow us to filter the stack trace
           stack_trace = ""
            # Clean up the stack trace if there are options to do so

data/Ruby/lib/mini_profiler/storage/abstract_store.rb

@@ -1,27 +1,32 @@
-module Rack
-  class MiniProfiler
-    class AbstractStore
-      
-      def save(page_struct)
-        raise NotImplementedError.new("save is not implemented")
-      end
-
-      def load(id)
-        raise NotImplementedError.new("load is not implemented")
-      end
-
-      def set_unviewed(user, id)
-        raise NotImplementedError.new("set_unviewed is not implemented")
-      end
-
-      def set_viewed(user, id)
-        raise NotImplementedError.new("set_viewed is not implemented")
-      end
-
-      def get_unviewed_ids(user)
-        raise NotImplementedError.new("get_unviewed_ids is not implemented")
-      end
-    
-    end
-  end
-end
+module Rack
+  class MiniProfiler
+    class AbstractStore
+
+      def save(page_struct)
+        raise NotImplementedError.new("save is not implemented")
+      end
+
+      def load(id)
+        raise NotImplementedError.new("load is not implemented")
+      end
+
+      def set_unviewed(user, id)
+        raise NotImplementedError.new("set_unviewed is not implemented")
+      end
+
+      def set_viewed(user, id)
+        raise NotImplementedError.new("set_viewed is not implemented")
+      end
+
+      def get_unviewed_ids(user)
+        raise NotImplementedError.new("get_unviewed_ids is not implemented")
+      end
+
+      def diagnostics(user)
+        # this is opt in, no need to explode if not implemented
+        ""
+      end
+
+    end
+  end
+end

data/Ruby/lib/mini_profiler/storage/file_store.rb

@@ -1,109 +1,111 @@
-module Rack
-  class MiniProfiler
-    class FileStore < AbstractStore
-
-      class FileCache
-        def initialize(path, prefix)
-          @path = path
-          @prefix = prefix
-        end
-
-        def [](key)
-          begin 
-            data = ::File.open(path(key),"rb") {|f| f.read}
-            return Marshal.load data
-          rescue => e
-            return nil
-          end
-        end
-
-        def []=(key,val)
-          ::File.open(path(key), "wb+") {|f| f.write Marshal.dump(val)}
-        end
-
-        private
-        def path(key)
-          @path + "/" + @prefix  + "_" + key
-        end
-      end
-
-      EXPIRE_TIMER_CACHE = 3600 * 24
-     
-      def initialize(args)
-        @path = args[:path]
-        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
-
-        me = self
-        Thread.new do
-          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
-
-      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 {
-          current = @user_view_cache[user]
-          current = [] unless Array === current
-          current << id
-          @user_view_cache[user] = current.uniq
-        }
-      end
-
-      def set_viewed(user, id)
-        @user_view_lock.synchronize {
-          @user_view_cache[user] ||= []
-          current = @user_view_cache[user]
-          current = [] unless Array === current
-          current.delete(id)
-          @user_view_cache[user] = current.uniq
-        }
-      end
-
-      def get_unviewed_ids(user)
-        @user_view_lock.synchronize {
-          @user_view_cache[user]
-        }
-      end
-      
-      def cleanup_cache
-        files = Dir.entries(@path)
-        @timer_struct_lock.synchronize {
-          files.each do |f|
-            f = @path + '/' + f
-            File.delete f if f =~ /^mp_timers/ and (Time.now - File.mtime(f)) > EXPIRE_TIMER_CACHE
-          end
-        }
-        @user_view_lock.synchronize {
-          files.each do |f|
-            f = @path + '/' + f
-            File.delete f if f =~ /^mp_views/ and (Time.now - File.mtime(f)) > EXPIRE_TIMER_CACHE
-          end
-        }
-      end
-    
-    end
-  end
-end
+module Rack
+  class MiniProfiler
+    class FileStore < AbstractStore
+
+      class FileCache
+        def initialize(path, prefix)
+          @path = path
+          @prefix = prefix
+        end
+
+        def [](key)
+          begin
+            data = ::File.open(path(key),"rb") {|f| f.read}
+            return Marshal.load data
+          rescue => e
+            return nil
+          end
+        end
+
+        def []=(key,val)
+          ::File.open(path(key), "wb+") {|f| f.write Marshal.dump(val)}
+        end
+
+        private
+        def path(key)
+          @path + "/" + @prefix  + "_" + key
+        end
+      end
+
+      EXPIRES_IN_SECONDS = 60 * 60 * 24
+
+      def initialize(args = nil)
+        args ||= {}
+        @path = args[:path]
+        @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
+
+        me = self
+        Thread.new do
+          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
+
+      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 {
+          current = @user_view_cache[user]
+          current = [] unless Array === current
+          current << id
+          @user_view_cache[user] = current.uniq
+        }
+      end
+
+      def set_viewed(user, id)
+        @user_view_lock.synchronize {
+          @user_view_cache[user] ||= []
+          current = @user_view_cache[user]
+          current = [] unless Array === current
+          current.delete(id)
+          @user_view_cache[user] = current.uniq
+        }
+      end
+
+      def get_unviewed_ids(user)
+        @user_view_lock.synchronize {
+          @user_view_cache[user]
+        }
+      end
+
+      def cleanup_cache
+        files = Dir.entries(@path)
+        @timer_struct_lock.synchronize {
+          files.each do |f|
+            f = @path + '/' + f
+            ::File.delete f if ::File.basename(f) =~ /^mp_timers/ and (Time.now - ::File.mtime(f)) > @expires_in_seconds
+          end
+        }
+        @user_view_lock.synchronize {
+          files.each do |f|
+            f = @path + '/' + f
+            ::File.delete f if ::File.basename(f) =~ /^mp_views/ and (Time.now - ::File.mtime(f)) > @expires_in_seconds
+          end
+        }
+      end
+
+    end
+  end
+end