rack-mini-profiler 0.1.21 → 0.1.26

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

@@ -2,17 +2,19 @@ module Rack
   class MiniProfiler
     class MemcacheStore < AbstractStore
 
-      EXPIRE_SECONDS = 60*60*24
+      EXPIRES_IN_SECONDS = 60 * 60 * 24
       MAX_RETRIES = 10
 
-      def initialize(client = nil, prefix = "MPMemcacheStore")
+      def initialize(args = nil)
         require 'dalli' unless defined? Dalli
-        @prefix = prefix
-        @client = client || Dalli::Client.new(['localhost:11211'])
+        args ||= {}
+        @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), EXPIRE_SECONDS)
+        @client.set("#{@prefix}#{page_struct['Id']}", Marshal::dump(page_struct), @expires_in_seconds)
       end
 
       def load(id)
@@ -23,9 +25,9 @@ module Rack
       end
 
       def set_unviewed(user, id)
-        @client.add("#{@prefix}-#{user}-v", [], EXPIRE_SECONDS)
+        @client.add("#{@prefix}-#{user}-v", [], @expires_in_seconds)
         MAX_RETRIES.times do
-          break if @client.cas("#{@prefix}-#{user}-v", EXPIRE_SECONDS) do |ids|
+          break if @client.cas("#{@prefix}-#{user}-v", @expires_in_seconds) do |ids|
             ids << id unless ids.include?(id)
             ids
           end
@@ -33,9 +35,9 @@ module Rack
       end
 
       def set_viewed(user, id)
-        @client.add("#{@prefix}-#{user}-v", [], EXPIRE_SECONDS)
+        @client.add("#{@prefix}-#{user}-v", [], @expires_in_seconds)
         MAX_RETRIES.times do
-          break if @client.cas("#{@prefix}-#{user}-v", EXPIRE_SECONDS) do |ids|
+          break if @client.cas("#{@prefix}-#{user}-v", @expires_in_seconds) do |ids|
             ids.delete id
             ids
           end

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

@@ -1,63 +1,65 @@
-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
-      
-      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['Started'] < expire_older_than }
-        }
-      end
-    end
-  end
-end
+module Rack
+  class MiniProfiler
+    class MemoryStore < AbstractStore
+
+      EXPIRES_IN_SECONDS = 60 * 60 * 24
+
+      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 = {}
+
+        # 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
+
+      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/mini_profiler/storage/redis_store.rb

@@ -0,0 +1,54 @@
+module Rack
+  class MiniProfiler
+    class RedisStore < AbstractStore
+
+      EXPIRES_IN_SECONDS = 60 * 60 * 24
+     
+      def initialize(args = nil)
+        @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) 
+      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
+
+      def diagnostics(user)
+"Redis prefix: #{@prefix}
+Redis location: #{redis.client.host}:#{redis.client.port} db: #{redis.client.db}
+unviewed_ids: #{get_unviewed_ids(user)}
+"
+      end
+
+      private 
+
+      def redis
+        return @redis_connection if @redis_connection
+        require 'redis' unless defined? Redis
+        @redis_connection ||= Redis.new @args
+      end
+
+    end
+  end
+end

data/Ruby/lib/mini_profiler/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class MiniProfiler
+    VERSION = 'e777c6e0fdfb9a725e857c8ca3eab18f'.freeze
+  end
+end

data/Ruby/lib/mini_profiler_rails/railtie.rb

@@ -0,0 +1,89 @@
+require 'fileutils'
+
+module Rack::MiniProfilerRails
+
+  # call direct if needed to do a defer init
+  def self.initialize!(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.test?
+    }
+
+    c.skip_paths ||= []
+
+    if Rails.env.development?
+      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_includes =  [/^\/?(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
+
+  class Railtie < ::Rails::Railtie
+
+    initializer "rack_mini_profiler.configure_rails_initialization" do |app|
+      Rack::MiniProfilerRails.initialize!(app)
+    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/Ruby/lib/patches/net_patches.rb

@@ -0,0 +1,14 @@
+if (defined?(Net) && defined?(Net::HTTP))
+
+  Net::HTTP.class_eval do
+    def request_with_mini_profiler(*args, &block)
+      request = args[0]
+      Rack::MiniProfiler.step("Net::HTTP #{request.method} #{request.path}") do
+        request_without_mini_profiler(*args, &block)
+      end
+    end
+    alias request_without_mini_profiler request
+    alias request request_with_mini_profiler
+  end
+
+end

data/{lib → Ruby/lib}/patches/sql_patches.rb

@@ -8,32 +8,32 @@ class SqlPatches
     @patched = val
   end
 
-	def self.class_exists?(name)
-		eval(name + ".class").to_s.eql?('Class')
-	rescue NameError
-		false
-	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
+    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) 
+      result = each_without_profiling(*args,&blk)
       elapsed_time = ((Time.now - start).to_f * 1000).round(1)
 
-      @miniprofiler_sql_id.report_reader_duration(elapsed_time) 
+      @miniprofiler_sql_id.report_reader_duration(elapsed_time)
       result
     end
   end
@@ -42,7 +42,7 @@ if SqlPatches.class_exists? "Mysql2::Client"
     alias_method :query_without_profiling, :query
     def query(*args,&blk)
       current = ::Rack::MiniProfiler.current
-      return query_without_profiling(*args,&blk) unless current
+      return query_without_profiling(*args,&blk) unless current && current.measure
 
       start = Time.now
       result = query_without_profiling(*args,&blk)
@@ -53,14 +53,14 @@ if SqlPatches.class_exists? "Mysql2::Client"
 
     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 
+# 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
@@ -69,10 +69,10 @@ if SqlPatches.class_exists? "PG::Result"
       return values_without_profiling(*args, &blk) unless @miniprofiler_sql_id
 
       start = Time.now
-      result = values_without_profiling(*args,&blk) 
+      result = values_without_profiling(*args,&blk)
       elapsed_time = ((Time.now - start).to_f * 1000).round(1)
 
-      @miniprofiler_sql_id.report_reader_duration(elapsed_time) 
+      @miniprofiler_sql_id.report_reader_duration(elapsed_time)
       result
     end
 
@@ -80,10 +80,10 @@ if SqlPatches.class_exists? "PG::Result"
       return each_without_profiling(*args, &blk) unless @miniprofiler_sql_id
 
       start = Time.now
-      result = each_without_profiling(*args,&blk) 
+      result = each_without_profiling(*args,&blk)
       elapsed_time = ((Time.now - start).to_f * 1000).round(1)
 
-      @miniprofiler_sql_id.report_reader_duration(elapsed_time) 
+      @miniprofiler_sql_id.report_reader_duration(elapsed_time)
       result
     end
   end
@@ -96,23 +96,23 @@ if SqlPatches.class_exists? "PG::Result"
     alias_method :prepare_without_profiling, :prepare
 
     def prepare(*args,&blk)
-      # we have no choice but to do this here, 
-      # if we do the check for profiling first, our cache may miss critical stuff  
-      
+      # we have no choice but to do this here,
+      # if we do the check for profiling first, our cache may miss critical stuff
+
       @prepare_map ||= {}
       @prepare_map[args[0]] = args[1]
       # dont leak more than 10k ever
       @prepare_map = {} if @prepare_map.length > 1000
 
       current = ::Rack::MiniProfiler.current
-      return prepare_without_profiling(*args,&blk) unless current
+      return prepare_without_profiling(*args,&blk) unless current && current.measure
 
-      prepare_without_profiling(*args,&blk) 
+      prepare_without_profiling(*args,&blk)
     end
 
     def exec(*args,&blk)
       current = ::Rack::MiniProfiler.current
-      return exec_without_profiling(*args,&blk) unless current
+      return exec_without_profiling(*args,&blk) unless current && current.measure
 
       start = Time.now
       result = exec_without_profiling(*args,&blk)
@@ -124,7 +124,7 @@ if SqlPatches.class_exists? "PG::Result"
 
     def exec_prepared(*args,&blk)
       current = ::Rack::MiniProfiler.current
-      return exec_prepared_without_profiling(*args,&blk) unless current
+      return exec_prepared_without_profiling(*args,&blk) unless current && current.measure
 
       start = Time.now
       result = exec_prepared_without_profiling(*args,&blk)
@@ -135,10 +135,10 @@ if SqlPatches.class_exists? "PG::Result"
 
       result
     end
-    
+
     def send_query_prepared(*args,&blk)
       current = ::Rack::MiniProfiler.current
-      return send_query_prepared_without_profiling(*args,&blk) unless current
+      return send_query_prepared_without_profiling(*args,&blk) unless current && current.measure
 
       start = Time.now
       result = send_query_prepared_without_profiling(*args,&blk)
@@ -149,10 +149,10 @@ if SqlPatches.class_exists? "PG::Result"
 
       result
     end
-    
+
     def async_exec(*args,&blk)
       current = ::Rack::MiniProfiler.current
-      return exec_without_profiling(*args,&blk) unless current
+      return exec_without_profiling(*args,&blk) unless current && current.measure
 
       start = Time.now
       result = exec_without_profiling(*args,&blk)
@@ -161,34 +161,75 @@ if SqlPatches.class_exists? "PG::Result"
 
       result
     end
-    
+
     alias_method :query, :exec
   end
-    
+
   SqlPatches.patched = true
 end
 
 
+# Mongoid 3 patches
+if SqlPatches.class_exists?("Moped::Node")
+  class Moped::Node
+    alias_method :process_without_profiling, :process
+    def process(*args,&blk)
+      current = ::Rack::MiniProfiler.current
+      return process_without_profiling(*args,&blk) unless current && current.measure
+
+      start = Time.now
+      result = process_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].log_inspect, elapsed_time))
+
+      result
+    end
+  end
+end
+
+if SqlPatches.class_exists?("RSolr::Connection") && RSolr::VERSION[0] != "0" #  requires at least v1.0.0
+  class RSolr::Connection
+    alias_method :execute_without_profiling, :execute
+    def execute_with_profiling(client, request_context)
+      current = ::Rack::MiniProfiler.current
+      return execute_without_profiling(client, request_context) unless current && current.measure
+
+      start = Time.now
+      result = execute_without_profiling(client, request_context)
+      elapsed_time = ((Time.now - start).to_f * 1000).round(1)
+
+      data = "#{request_context[:method].upcase} #{request_context[:uri]}"
+      if request_context[:method] == :post and request_context[:data]
+        data << "\n#{Rack::Utils.unescape(request_context[:data])}"
+      end
+      result.instance_variable_set("@miniprofiler_sql_id", ::Rack::MiniProfiler.record_sql(data, elapsed_time))
+
+      result
+    end
+    alias_method :execute, :execute_with_profiling
+  end
+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
+  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')
+if SqlPatches.module_exists?('ActiveRecord') && !SqlPatches.patched?
   module Rack
-    class MiniProfiler  
+    class MiniProfiler
       module ActiveRecordInstrumentation
         def self.included(instrumented_class)
           instrumented_class.class_eval do
@@ -202,12 +243,12 @@ if SqlPatches.module_exists?('ActiveRecord')
 
         def log_with_miniprofiler(*args, &block)
           current = ::Rack::MiniProfiler.current
-          return log_without_miniprofiler(*args, &block) unless current
+          return log_without_miniprofiler(*args, &block) unless current && current.measure
 
           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/
 
@@ -218,7 +259,7 @@ if SqlPatches.module_exists?('ActiveRecord')
       end
     end
 
-    def self.insert_instrumentation 
+    def self.insert_instrumentation
       ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
         include ::Rack::MiniProfiler::ActiveRecordInstrumentation
       end