miniprofiler 0.1.7.1

data/lib/mini_profiler/storage/file_store.rb

@@ -0,0 +1,108 @@
+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
+          while true do
+            me.cleanup_cache if MiniProfiler.instance
+            sleep(3600)
+          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
+      
+
+      private 
+
+
+      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

data/lib/mini_profiler/storage/memory_store.rb

@@ -0,0 +1,68 @@
+module Rack
+  class MiniProfiler
+    class MemoryStore < AbstractStore
+
+      EXPIRE_TIMER_CACHE = 3600 * 24
+     
+      def initialize(args)
+        @timer_struct_lock = Mutex.new
+        @timer_struct_cache = {}
+        @user_view_lock = Mutex.new
+        @user_view_cache = {}
+
+        # TODO: fix it to use weak ref, trouble is may be broken in 1.9 so need to use the 'ref' gem
+        me = self
+        Thread.new do
+          while true do
+            me.cleanup_cache
+            sleep(3600)
+          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 {
+          @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
+      
+
+      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 }
+        }
+      end
+    
+    end
+  end
+end

data/lib/mini_profiler/storage/redis_store.rb

@@ -0,0 +1,44 @@
+module Rack
+  class MiniProfiler
+    class RedisStore < AbstractStore
+
+      EXPIRE_SECONDS = 60 * 60 * 24
+     
+      def initialize(args)
+        args ||= {}
+        @prefix = args[:prefix] || 'MPRedisStore'
+      end
+
+      def save(page_struct)
+        redis.setex "#{@prefix}#{page_struct['Id']}", EXPIRE_SECONDS, Marshal::dump(page_struct) 
+      end
+
+      def load(id)
+        raw = redis.get "#{@prefix}#{id}"
+        if raw
+          Marshal::load raw
+        end
+      end
+
+      def set_unviewed(user, id)
+        redis.sadd "#{@prefix}-#{user}-v", id
+      end
+
+      def set_viewed(user, id)
+        redis.srem "#{@prefix}-#{user}-v", id
+      end
+
+      def get_unviewed_ids(user)
+        redis.smembers "#{@prefix}-#{user}-v"
+      end
+
+      private 
+
+      def redis
+        require 'redis' unless defined? Redis
+        Redis.new 
+      end
+
+    end
+  end
+end

data/lib/mini_profiler/timer_struct.rb

@@ -0,0 +1,31 @@
+module Rack
+  class MiniProfiler
+
+    # A base class for timing structures
+    class TimerStruct
+
+      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)
+        ::JSON.generate(@attributes, a[0])
+      end
+
+    end
+
+  end
+end

data/lib/mini_profiler_rails/railtie.rb

@@ -0,0 +1,84 @@
+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, in production allow profiling if post_authorize_cb is set
+      c.pre_authorize_cb = lambda { |env|
+        Rails.env.development? || Rails.env.production?  
+      }
+
+      if Rails.env.development?
+        c.skip_paths ||= []
+        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_filter =  /^\/?(app|config|lib|test)/
+      c.skip_schema_queries =  Rails.env != 'production'
+
+      # Install the Middleware
+      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

@@ -0,0 +1,185 @@
+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
+
+
+
+# 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.record_sql(message, duration)
+				log_duration_original(duration, message)
+			end
+		end
+	end
+end
+
+
+## based off https://github.com/newrelic/rpm/blob/master/lib/new_relic/agent/instrumentation/active_record.rb
+## 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
+
+        def log_with_miniprofiler(*args, &block)
+          current = ::Rack::MiniProfiler.current
+          return log_without_miniprofiler(*args, &block) unless current
+
+          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)
+          Rack::MiniProfiler.record_sql(sql, elapsed_time)
+          rval
+        end
+      end
+    end
+
+    def self.insert_instrumentation 
+      ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+        include ::Rack::MiniProfiler::ActiveRecordInstrumentation
+      end
+    end
+
+    if defined?(::Rails) && !SqlPatches.patched?
+      insert_instrumentation
+    end
+  end
+end

data/lib/rack-mini-profiler.rb

@@ -0,0 +1,6 @@
+require File.expand_path('mini_profiler/profiler', File.dirname(__FILE__) )
+require File.expand_path('patches/sql_patches', File.dirname(__FILE__) )
+
+if defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3
+  require File.expand_path('mini_profiler_rails/railtie', File.dirname(__FILE__) )
+end

data/rack-mini-profiler.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |s|
+  s.name = "miniprofiler"
+  s.version = "0.1.7.1"
+  s.summary = "Profiles loading speed for rack applications."
+  s.authors = ["Aleks Totic","Sam Saffron", "Robin Ward"]
+  s.description = "Page loading speed displayed on every page. Optimize while you develop, performance is a feature."
+  s.email = "sam.saffron@gmail.com"
+  s.homepage = "http://miniprofiler.com"
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.extra_rdoc_files = [
+    "README.md",
+    "CHANGELOG"
+  ]
+  s.add_runtime_dependency 'rack', '>= 1.1.3'
+  if RUBY_VERSION < "1.9"
+    s.add_runtime_dependency 'json', '>= 1.6'
+  end
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rack-test'
+  s.add_development_dependency 'activerecord', '~> 3.0'
+end

data/spec/components/body_add_proxy_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'mini_profiler/body_add_proxy'
+
+describe Rack::MiniProfiler::BodyAddProxy do
+
+  context 'body as an array' do
+
+    before do
+      @proxy = Rack::MiniProfiler::BodyAddProxy.new(%w(a b c), 'd')
+    end
+
+    it 'contains the appended value' do
+      @proxy.should expand_each_to %w(a b c d)
+    end
+
+    it 'has a correct value in to_str' do
+      @proxy.to_str.should == "abcd"
+    end
+
+    describe 'delegation' do
+      it 'delegates respond to <<' do
+        @proxy.respond_to?('<<').should be_true
+      end
+
+      it 'delegates respond to first' do
+        @proxy.respond_to?(:first).should be_true
+      end    
+
+      it 'delegates method_missing' do
+        @proxy.first.should == 'a'
+      end
+    end
+
+  end
+
+  context 'body as a custom object' do
+
+    # A class and a super class to help us test appending to a custom object, such as 
+    # Rails' ActionDispatch::Response
+    class Band
+      def style
+        'rock'
+      end
+    end    
+    
+    class Beatles < Band
+      def each
+        yield 'john'
+        yield 'paul'
+        yield 'george'
+      end
+
+      def fake_method; nil; end
+
+      def method_missing(*args, &block)
+        'yoko'
+      end
+    end
+
+    before do
+      @proxy = Rack::MiniProfiler::BodyAddProxy.new(Beatles.new, 'ringo')
+    end
+
+    it 'contains the appended value' do
+      @proxy.should expand_each_to %w(john paul george ringo)
+    end
+
+    it 'has a correct value in to_str' do
+      @proxy.to_str.should == "johnpaulgeorgeringo"
+    end    
+
+    describe 'delegation' do
+      it 'delegates respond to fake_method' do
+        @proxy.respond_to?(:fake_method).should be_true
+      end
+
+      it 'delegates respond to a super class' do
+        @proxy.respond_to?(:style).should be_true
+      end      
+
+      it 'delegates method_missing' do
+        @proxy.doesnt_exist.should == 'yoko'
+      end
+
+    end
+
+  end
+
+
+end