rack-mini-profiler 0.1.20 → 0.1.25

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

@@ -0,0 +1,53 @@
+module Rack
+  class MiniProfiler
+    class MemcacheStore < AbstractStore
+
+      EXPIRES_IN_SECONDS = 60 * 60 * 24
+      MAX_RETRIES = 10
+
+      def initialize(args = nil)
+        require 'dalli' unless defined? Dalli
+        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), @expires_in_seconds)
+      end
+
+      def load(id)
+        raw = @client.get("#{@prefix}#{id}")
+        if raw
+          Marshal::load raw
+        end
+      end
+
+      def set_unviewed(user, id)
+        @client.add("#{@prefix}-#{user}-v", [], @expires_in_seconds)
+        MAX_RETRIES.times do
+          break if @client.cas("#{@prefix}-#{user}-v", @expires_in_seconds) do |ids|
+            ids << id unless ids.include?(id)
+            ids
+          end
+        end
+      end
+
+      def set_viewed(user, id)
+        @client.add("#{@prefix}-#{user}-v", [], @expires_in_seconds)
+        MAX_RETRIES.times do
+          break if @client.cas("#{@prefix}-#{user}-v", @expires_in_seconds) do |ids|
+            ids.delete id
+            ids
+          end
+        end
+      end
+
+      def get_unviewed_ids(user)
+        @client.get("#{@prefix}-#{user}-v") || []
+      end
+
+    end
+  end
+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/{lib → Ruby/lib}/mini_profiler_rails/railtie.rb

@@ -9,11 +9,12 @@ module MiniProfilerRails
 
       # 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?  
+        !Rails.env.test?
       }
 
+      c.skip_paths ||= []
+
       if Rails.env.development?
-        c.skip_paths ||= []
         c.skip_paths << "/assets/"
         c.skip_schema_queries = true
       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