lrd_rack_bug 0.3.0.2

data/lib/rack/bug/panels/cache_panel/memcache_extension.rb

@@ -0,0 +1,129 @@
+if defined?(Memcached)
+  Memcached.class_eval do
+
+    def set_with_rack_bug(key, value, timeout=0, marshal=true)
+      Rack::Bug::CachePanel.record(:set, key) do
+        set_without_rack_bug(key, value, timeout, marshal)
+      end
+    end
+
+    def add_with_rack_bug(key, value, timeout=0, marshal=true)
+      Rack::Bug::CachePanel.record(:add, key) do
+        add_without_rack_bug(key, value, timeout, marshal)
+      end
+    end
+
+    def increment_with_rack_bug(key, offset=1)
+      Rack::Bug::CachePanel.record(:incr, key) do
+        increment_without_rack_bug(key, offset)
+      end
+    end
+
+    def decrement_with_rack_bug(key, offset=1)
+      Rack::Bug::CachePanel.record(:decr, key) do
+        decrement_without_rack_bug(key, offset)
+      end
+    end
+
+    def replace_with_rack_bug(key, value, timeout=0, marshal=true)
+      Rack::Bug::CachePanel.record(:replace, key) do
+        replace_without_rack_bug(key, value, timeout, marshal)
+      end
+    end
+
+    def append_with_rack_bug(key, value)
+      Rack::Bug::CachePanel.record(:append, key) do
+        append_without_rack_bug(key, value)
+      end
+    end
+
+    def prepend_with_rack_bug(key, value)
+      Rack::Bug::CachePanel.record(:prepend, key) do
+        prepend_without_rack_bug(key, value)
+      end
+    end
+
+    def delete_with_rack_bug(key)
+      Rack::Bug::CachePanel.record(:delete, key) do
+        delete_without_rack_bug(key)
+      end
+    end
+
+    def get_with_rack_bug(keys, marshal=true)
+      if keys.is_a? Array
+        Rack::Bug::CachePanel.record(:get_multi, *keys) do
+          get_without_rack_bug(keys, marshal)
+        end
+      else
+        Rack::Bug::CachePanel.record(:get, keys) do
+          get_without_rack_bug(keys, marshal)
+        end
+      end
+    end
+
+    alias_method_chain :decrement,  :rack_bug
+    alias_method_chain :get,        :rack_bug
+    alias_method_chain :increment,  :rack_bug
+    alias_method_chain :set,        :rack_bug
+    alias_method_chain :add,        :rack_bug
+    alias_method_chain :replace,    :rack_bug
+    alias_method_chain :delete,     :rack_bug
+    alias_method_chain :prepend,    :rack_bug
+    alias_method_chain :append,     :rack_bug
+  end
+end
+
+if defined?(MemCache)
+  MemCache.class_eval do
+
+    def decr_with_rack_bug(key, amount = 1)
+      Rack::Bug::CachePanel.record(:decr, key) do
+        decr_without_rack_bug(key, amount)
+      end
+    end
+
+    def get_with_rack_bug(key, raw = false)
+      Rack::Bug::CachePanel.record(:get, key) do
+        get_without_rack_bug(key, raw)
+      end
+    end
+
+    def get_multi_with_rack_bug(*keys)
+      Rack::Bug::CachePanel.record(:get_multi, *keys) do
+        get_multi_without_rack_bug(*keys)
+      end
+    end
+
+    def incr_with_rack_bug(key, amount = 1)
+      Rack::Bug::CachePanel.record(:incr, key) do
+        incr_without_rack_bug(key, amount)
+      end
+    end
+
+    def set_with_rack_bug(key, value, expiry = 0, raw = false)
+      Rack::Bug::CachePanel.record(:set, key) do
+        set_without_rack_bug(key, value, expiry, raw)
+      end
+    end
+
+    def add_with_rack_bug(key, value, expiry = 0, raw = false)
+      Rack::Bug::CachePanel.record(:add, key) do
+        add_without_rack_bug(key, value, expiry, raw)
+      end
+    end
+
+    def delete_with_rack_bug(key, expiry = 0)
+      Rack::Bug::CachePanel.record(:delete, key) do
+        delete_without_rack_bug(key, expiry)
+      end
+    end
+
+    alias_method_chain :decr,       :rack_bug
+    alias_method_chain :get,        :rack_bug
+    alias_method_chain :get_multi,  :rack_bug
+    alias_method_chain :incr,       :rack_bug
+    alias_method_chain :set,        :rack_bug
+    alias_method_chain :add,        :rack_bug
+    alias_method_chain :delete,     :rack_bug
+  end
+end

data/lib/rack/bug/panels/cache_panel/panel_app.rb

@@ -0,0 +1,48 @@
+module Rack
+  class Bug
+    class CachePanel
+
+      class PanelApp < ::Rack::Bug::PanelApp
+
+        def dispatch
+          case request.path_info
+          when "/__rack_bug__/view_cache"         then view_cache
+          when "/__rack_bug__/delete_cache"       then delete_cache
+          when "/__rack_bug__/delete_cache_list"  then delete_cache_list
+          else not_found
+          end
+        end
+
+        def ok
+          Rack::Response.new(["OK"]).to_a
+        end
+
+        def view_cache
+          validate_params
+          render_template "panels/view_cache", :key => params["key"], :value => Rails.cache.read(params["key"])
+        end
+
+        def delete_cache
+          validate_params
+          raise "Rails not found... can't delete key" unless defined?(Rails)
+          Rails.cache.delete(params["key"])
+          ok
+        end
+
+        def delete_cache_list
+          validate_params
+          raise "Rails not found... can't delete key" unless defined?(Rails)
+
+          params.each do |key, value|
+            next unless key =~ /^keys_/
+            Rails.cache.delete(value)
+          end
+
+          ok
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rack/bug/panels/cache_panel/stats.rb

@@ -0,0 +1,97 @@
+module Rack
+  class Bug
+    class CachePanel
+
+      class Stats
+        class Query
+          attr_reader :method, :time, :hit, :keys
+
+          def initialize(method, time, hit, keys)
+            @method = method
+            @time = time
+            @hit = hit
+            @keys = keys
+          end
+
+          def display_time
+            "%.2fms" % time
+          end
+
+          def display_keys
+            if keys.size == 1
+              keys.first
+            else
+              keys.join(", ")
+            end
+          end
+        end
+
+        attr_reader :calls
+        attr_reader :keys
+        attr_reader :queries
+
+        def initialize
+          @queries = []
+          @misses =
+          @calls = 0
+          @time = 0.0
+          @keys = []
+        end
+
+        def record_call(method, time, hit, *keys)
+          @queries << Query.new(method, time, hit, keys)
+          @calls += 1
+          @time += time
+          @keys += keys
+        end
+
+        def display_time
+          "%.2fms" % time
+        end
+
+        def time
+          @queries.inject(0) do |memo, query|
+            memo + query.time
+          end
+        end
+
+        def gets
+          count_queries(:get)
+        end
+
+        def sets
+          count_queries(:set)
+        end
+
+        def deletes
+          count_queries(:delete)
+        end
+
+        def get_multis
+          count_queries(:get_multi)
+        end
+
+        def hits
+          @queries.select { |q| [:get, :get_multi].include?(q.method) && q.hit }.size
+        end
+
+        def misses
+          @queries.select { |q| [:get, :get_multi].include?(q.method) && !q.hit }.size
+        end
+
+        def count_queries(method)
+          @queries.select { |q| q.method == method }.size
+        end
+
+        def queries_to_param
+          params = {}
+          @queries.each_with_index do |query, index|
+            params["keys_#{index}"] = query.keys.first
+          end
+          params
+        end
+      end
+
+    end
+  end
+end

data/lib/rack/bug/panels/cache_panel.rb

@@ -0,0 +1,51 @@
+require "rack/bug/panels/cache_panel/memcache_extension"
+require "rack/bug/panels/cache_panel/dalli_extension"
+
+module Rack
+  class Bug
+
+    class CachePanel < Panel
+      autoload :PanelApp, "rack/bug/panels/cache_panel/panel_app"
+      autoload :Stats,    "rack/bug/panels/cache_panel/stats"
+
+      def self.record(method, *keys, &block)
+        return block.call unless Rack::Bug.enabled?
+
+        start_time = Time.now
+        result = block.call
+        total_time = Time.now - start_time
+        hit = result.nil? ? false : true
+        stats.record_call(method, total_time * 1_000, hit, *keys)
+        return result
+      end
+
+      def self.reset
+        Thread.current["rack.bug.cache"] = Stats.new
+      end
+
+      def self.stats
+        Thread.current["rack.bug.cache"] ||= Stats.new
+      end
+
+      def panel_app
+        PanelApp.new
+      end
+
+      def name
+        "cache"
+      end
+
+      def heading
+        "Cache: %.2fms (#{self.class.stats.queries.size} calls)" % self.class.stats.time
+      end
+
+      def content
+        result = render_template "panels/cache", :stats => self.class.stats
+        self.class.reset
+        return result
+      end
+
+    end
+
+  end
+end

data/lib/rack/bug/panels/log_panel/logger_extension.rb

@@ -0,0 +1,24 @@
+module Rack::Bug::LoggerExtension
+  def self.included(target)
+    target.send :alias_method, :add_without_rack_bug, :add
+    target.send :alias_method, :add, :add_with_rack_bug
+  end
+  
+  def add_with_rack_bug(*args, &block)
+    logger_return = add_without_rack_bug(*args, &block)
+    logged_message = logger_return
+    logged_message = args[1] || args[2] unless logged_message.is_a?(String)
+    Rack::Bug::LogPanel.record(logged_message, args[0])
+    return logger_return
+  end
+end
+
+if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+  logger = Rails.logger
+elsif defined?(LOGGER)
+  logger = LOGGER
+end
+
+if logger
+  logger.class.send :include, Rack::Bug::LoggerExtension
+end

data/lib/rack/bug/panels/log_panel.rb

@@ -0,0 +1,56 @@
+require "rack/bug/panels/log_panel/logger_extension"
+
+module Rack
+  class Bug
+
+    class LogPanel < Panel
+      class LogEntry
+        attr_reader :level, :time, :message
+        LEVELS = ['DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL']
+
+        def initialize(level, time, message)
+          @level = LEVELS[level]
+          @time = time
+          @message = message
+        end
+
+        def cleaned_message
+          @message.to_s.gsub(/\e\[[;\d]+m/, "")
+        end
+      end
+
+      def self.record(message, log_level)
+        return unless Rack::Bug.enabled?
+        return unless message
+        Thread.current["rack.bug.logs.start"] ||= Time.now
+        timestamp = ((Time.now - Thread.current["rack.bug.logs.start"]) * 1000).to_i
+        logs << LogEntry.new(log_level, timestamp, message)
+      end
+
+      def self.reset
+        Thread.current["rack.bug.logs"] = []
+        Thread.current["rack.bug.logs.start"] = nil
+      end
+
+      def self.logs
+        Thread.current["rack.bug.logs"] ||= []
+      end
+
+      def name
+        "log"
+      end
+
+      def heading
+        "Log"
+      end
+
+      def content
+        result = render_template "panels/log", :logs => self.class.logs
+        self.class.reset
+        return result
+      end
+
+    end
+
+  end
+end

data/lib/rack/bug/panels/memory_panel.rb

@@ -0,0 +1,27 @@
+#
+module Rack
+  class Bug
+
+    class MemoryPanel < Panel
+
+      def before(env)
+        @original_memory = `ps -o rss= -p #{$$}`.to_i
+      end
+
+      def after(env, status, headers, body)
+        @total_memory = `ps -o rss= -p #{$$}`.to_i
+        @memory_increase = @total_memory - @original_memory
+      end
+
+      def heading
+        "#{@memory_increase} KB &#916;, #{@total_memory} KB total"
+      end
+
+      def has_content?
+        false
+      end
+
+    end
+
+  end
+end

data/lib/rack/bug/panels/mongo_panel/mongo_extension.rb

@@ -0,0 +1,27 @@
+require 'mongo'
+
+if defined?(Mongo)
+  Mongo::Connection.class_eval do
+
+    def send_message_with_rack_bug(operation, message, log_message=nil)
+      Rack::Bug::MongoPanel.record(log_message || message) do
+        send_message_without_rack_bug(operation, message, log_message)
+      end
+    end
+    alias_method_chain :send_message, :rack_bug
+
+    def send_message_with_safe_check_with_rack_bug(operation, message, db_name, log_message=nil, last_error_params=false)
+      Rack::Bug::MongoPanel.record(log_message || message) do
+        send_message_with_safe_check_without_rack_bug(operation, message, db_name, log_message, last_error_params)
+      end
+    end
+    alias_method_chain :send_message_with_safe_check, :rack_bug
+
+    def receive_message_with_rack_bug(operation, message, log_message=nil, socket=nil)
+      Rack::Bug::MongoPanel.record(log_message || "A logger must be configured to catch receive message commands") do
+        receive_message_without_rack_bug(operation, message, log_message, socket)
+      end
+    end
+    alias_method_chain :receive_message, :rack_bug
+  end
+end

data/lib/rack/bug/panels/mongo_panel/stats.rb

@@ -0,0 +1,48 @@
+module Rack
+  class Bug
+    class MongoPanel
+      
+      class Stats
+        class Query
+          attr_reader :time
+          attr_reader :command
+          
+          def initialize(time, command)
+            @time = time
+            @command = command
+          end
+          
+          def display_time
+            "%.2fms" % time
+          end
+        end
+        
+        attr_reader :calls
+        attr_reader :queries
+        
+        def initialize
+          @queries = []
+          @calls = 0
+          @time = 0.0
+        end
+        
+        def record_call(time, command)
+          @queries << Query.new(time, command)
+          @calls += 1
+          @time += time
+        end
+        
+        def display_time
+          "%.2fms" % time
+        end
+        
+        def time
+          @queries.inject(0) do |memo, query|
+            memo + query.time
+          end
+        end
+      end
+      
+    end
+  end
+end

data/lib/rack/bug/panels/mongo_panel.rb

@@ -0,0 +1,44 @@
+module Rack
+  class Bug
+
+    class MongoPanel < Panel
+      require "rack/bug/panels/mongo_panel/mongo_extension"
+
+      autoload :Stats, "rack/bug/panels/mongo_panel/stats"
+
+      def self.record(command, &block)
+        return block.call unless Rack::Bug.enabled?
+
+        start_time = Time.now
+        result = block.call
+        total_time = Time.now - start_time
+        stats.record_call(total_time * 1_000, command)
+        return result
+      end
+
+      def self.reset
+        Thread.current["rack.bug.mongo"] = Stats.new
+      end
+
+      def self.stats
+        Thread.current["rack.bug.mongo"] ||= Stats.new
+      end
+
+      def name
+        "mongo"
+      end
+
+      def heading
+        "Mongo: %.2fms (#{self.class.stats.queries.size} calls)" % self.class.stats.time
+      end
+
+      def content
+        result = render_template "panels/mongo", :stats => self.class.stats
+        self.class.reset
+        return result
+      end
+
+    end
+
+  end
+end

data/lib/rack/bug/panels/rails_info_panel.rb

@@ -0,0 +1,23 @@
+module Rack
+  class Bug
+
+    class RailsInfoPanel < Panel
+
+      def name
+        "rails_info"
+      end
+
+      def heading
+        return unless (defined?(Rails) && defined?(Rails::Info))
+        "Rails #{Rails.version}"
+      end
+
+      def content
+        return unless (defined?(Rails) && defined?(Rails::Info))
+        render_template "panels/rails_info"
+      end
+
+    end
+
+  end
+end

data/lib/rack/bug/panels/redis_panel/redis_extension.rb

@@ -0,0 +1,28 @@
+require 'redis'
+
+if defined?(Redis)
+  Redis.class_eval do
+    if Redis.methods.include?('call_command') # older versions of redis-rb
+      def call_command_with_rack_bug(*argv)
+        Rack::Bug::RedisPanel.record(argv, Kernel.caller) do
+          call_command_without_rack_bug(*argv)
+        end
+      end
+
+      alias_method_chain :call_command, :rack_bug
+
+    elsif defined?(Redis::Client) # newer versions of redis-rb
+
+      Redis::Client.class_eval do
+        def call_with_rack_bug(*argv)
+          Rack::Bug::RedisPanel.record(argv, Kernel.caller) do
+            call_without_rack_bug(*argv)
+          end
+        end
+
+        alias_method_chain :call, :rack_bug
+
+      end
+    end
+  end
+end

data/lib/rack/bug/panels/redis_panel/stats.rb

@@ -0,0 +1,52 @@
+module Rack
+  class Bug
+    class RedisPanel
+
+      class Stats
+        class Query
+          include Rack::Bug::FilteredBacktrace
+
+          attr_reader :time
+          attr_reader :command
+
+          def initialize(time, command_args, backtrace)
+            @time = time
+            @command = command_args.inspect
+            @backtrace = backtrace
+          end
+
+          def display_time
+            "%.2fms" % time
+          end
+        end
+
+        attr_reader :calls
+        attr_reader :queries
+
+        def initialize
+          @queries = []
+          @calls = 0
+          @time = 0.0
+        end
+
+        def record_call(time, command_args, backtrace)
+          @queries << Query.new(time, command_args, backtrace)
+          @calls += 1
+          @time += time
+        end
+
+        def display_time
+          "%.2fms" % time
+        end
+
+        def time
+          @queries.inject(0) do |memo, query|
+            memo + query.time
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/rack/bug/panels/redis_panel.rb

@@ -0,0 +1,44 @@
+module Rack
+  class Bug
+
+    class RedisPanel < Panel
+      require "rack/bug/panels/redis_panel/redis_extension"
+
+      autoload :Stats, "rack/bug/panels/redis_panel/stats"
+
+      def self.record(redis_command_args, backtrace, &block)
+        return block.call unless Rack::Bug.enabled?
+
+        start_time = Time.now
+        result = block.call
+        total_time = Time.now - start_time
+        stats.record_call(total_time * 1_000, redis_command_args, backtrace)
+        return result
+      end
+
+      def self.reset
+        Thread.current["rack.bug.redis"] = Stats.new
+      end
+
+      def self.stats
+        Thread.current["rack.bug.redis"] ||= Stats.new
+      end
+
+      def name
+        "redis"
+      end
+
+      def heading
+        "Redis: %.2fms (#{self.class.stats.queries.size} calls)" % self.class.stats.time
+      end
+
+      def content
+        result = render_template "panels/redis", :stats => self.class.stats
+        self.class.reset
+        return result
+      end
+
+    end
+
+  end
+end