rack-mini-profiler 0.1

data/lib/mini_profiler/request_timer_struct.rb

@@ -0,0 +1,65 @@
+require 'mini_profiler/timer_struct'
+
+module Rack
+  class MiniProfiler
+
+    class RequestTimerStruct < TimerStruct
+      
+      def self.createRoot(name, page)
+        rt = RequestTimerStruct.new(name, page)
+        rt["IsRoot"]= true
+        rt
+      end
+
+      attr_reader :children_duration
+
+      def initialize(name, page)
+        super("Id" => MiniProfiler.generate_id,
+              "Name" => name,
+              "DurationMilliseconds" => 0,
+              "DurationWithoutChildrenMilliseconds"=> 0,
+              "StartMilliseconds" => (Time.now.to_f * 1000).to_i - page['Started'],
+              "ParentTimingId" => nil,
+              "Children" => [],
+              "HasChildren"=> false,
+              "KeyValues" => nil,
+              "HasSqlTimings"=> false,
+              "HasDuplicateSqlTimings"=> false,
+              "TrivialDurationThresholdMilliseconds" => 2,
+              "SqlTimings" => [],
+              "SqlTimingsDurationMilliseconds"=> 0,
+              "IsTrivial"=> false,
+              "IsRoot"=> false,
+              "Depth"=> 0,
+              "ExecutedReaders"=> 0,
+              "ExecutedScalars"=> 0,
+              "ExecutedNonQueries"=> 0)
+        @children_duration = 0
+      end
+
+      def add_child(request_timer)
+        self['Children'].push(request_timer)
+        self['HasChildren'] = true
+        request_timer['ParentTimingId'] = self['Id']
+        request_timer['Depth'] = self['Depth'] + 1
+        @children_duration += request_timer['DurationMilliseconds']
+      end
+
+      def add_sql(query, elapsed_ms, page, skip_backtrace = false)
+        timer = SqlTimerStruct.new(query, elapsed_ms, page, skip_backtrace)
+        timer['ParentTimingId'] = self['Id']
+        self['SqlTimings'].push(timer)
+        self['HasSqlTimings'] = true
+        self['SqlTimingsDurationMilliseconds'] += elapsed_ms
+        page['DurationMillisecondsInSql'] += elapsed_ms        
+      end
+
+      def record_time(milliseconds)
+        self['DurationMilliseconds'] = milliseconds
+        self['IsTrivial'] = true if milliseconds < self["TrivialDurationThresholdMilliseconds"]
+        self['DurationWithoutChildrenMilliseconds'] = milliseconds - @children_duration
+      end     
+    end
+  end
+  
+end

data/lib/mini_profiler/sql_timer_struct.rb

@@ -0,0 +1,37 @@
+require 'mini_profiler/timer_struct'
+
+module Rack
+  class MiniProfiler
+
+    # Timing system for a SQL query
+    class SqlTimerStruct < TimerStruct
+      def initialize(query, duration_ms, page, skip_backtrace = false)
+
+        stack_trace = nil 
+        unless skip_backtrace 
+          # Allow us to filter the stack trace
+          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]
+              stack_trace << ln << "\n" 
+            end
+          end
+        end
+
+        super("ExecuteType" => 3, # TODO
+              "FormattedCommandString" => query,
+              "StackTraceSnippet" => stack_trace, 
+              "StartMilliseconds" => (Time.now.to_f * 1000).to_i - page['Started'],
+              "DurationMilliseconds" => duration_ms,
+              "FirstFetchDurationMilliseconds" => 0,
+              "Parameters" => nil,
+              "ParentTimingId" => nil,
+              "IsDuplicate" => false)
+      end
+
+    end
+
+  end
+end

data/lib/mini_profiler/storage/abstract_store.rb

@@ -0,0 +1,27 @@
+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

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,43 @@
+module Rack
+  class MiniProfiler
+    class RedisStore < AbstractStore
+
+      EXPIRE_SECONDS = 60 * 60 * 24
+     
+      def initialize(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,30 @@
+module MiniProfilerRails
+  class Railtie < ::Rails::Railtie
+
+    initializer "rack_mini_profiler.configure_rails_initialization" do |app|
+
+      # 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
+
+      # Quiet the SQL stack traces
+      Rack::MiniProfiler.configuration[:backtrace_remove] = Rails.root.to_s + "/"
+      Rack::MiniProfiler.configuration[:backtrace_filter] =  /^\/?(app|config|lib|test)/
+
+      # The file store is just so much less flaky
+
+      # Install the Middleware
+      app.middleware.insert_before 'Rack::Lock', '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
+
+  end
+end

data/lib/patches/sql_patches.rb

@@ -0,0 +1,72 @@
+module SqlPatches
+	def self.class_exists?(name)
+		eval(name + ".class").to_s.eql?('Class')
+	rescue NameError
+		false
+	end
+end
+
+if SqlPatches.class_exists? "Sequel::Database" then
+	module Sequel
+		class Database
+			alias_method :log_duration_original, :log_duration
+			def log_duration(duration, message)
+				::Rack::MiniProfiler.instance.record_sql(message, duration) if ::Rack::MiniProfiler.instance
+				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
+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)
+        sql, name, binds = args
+        t0 = Time.now
+        rval = log_without_miniprofiler(*args, &block)
+
+        # Get our MP Instance
+        instance = ::Rack::MiniProfiler.instance
+        return rval unless instance
+
+        # Don't log schema queries if the option is set
+        return rval if instance.options[:skip_schema_queries] and name =~ /SCHEMA/
+
+        elapsed_time = ((Time.now - t0).to_f * 1000).round(1)
+        instance.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)
+    if ::Rails::VERSION::MAJOR.to_i == 3
+    # in theory this is the right thing to do for rails 3 ... but it seems to work anyway
+    #Rails.configuration.after_initialize do
+        insert_instrumentation
+    #end
+    else
+      insert_instrumentation
+    end
+  end
+end
+