rack-bug 0.2.1

data/.gitignore

@@ -0,0 +1,3 @@
+coverage
+pkg
+TODO

data/MIT-LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Bryan Helmkamp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,29 @@
+Usage:
+
+ script/plugin install git://github.com/brynary/rack-bug.git 
+
+ # config/environments/development.rb
+ config.middleware.use "Rack::Bug"
+
+ # add bookmarklet to browser
+ open http://RAILS_APP/__rack_bug__/bookmarklet.html
+
+Notes:
+
+ To use rack-bug with hoptoad, you need to stub hoptoad from trying to serialize the environment variables
+ that rack-bug uses like so:
+ 
+ HoptoadNotifier.configure do |config|
+   config.environment_filters << 'rack-bug.*'
+ end
+ 
+ 
+Thanks to:
+
+  Django debug toolbar
+  Rails footnotes
+  Rack's ShowException middleware
+  Oink
+  Rack::Cache
+  
+  

data/Rakefile

@@ -0,0 +1,36 @@
+require "rubygems"
+require "spec/rake/spectask"
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/lib'
+require "rack/bug"
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name      = "rack-bug"
+    s.author    = "Bryan Helmkamp"
+    s.email     = "bryan" + "@" + "brynary.com"
+    s.homepage  = "http://github.com/brynary/rack-bug"
+    s.summary   = "Debugging toolbar for Rack applications implemented as middleware"
+    # s.description  = "TODO"
+    s.extra_rdoc_files = %w(README.rdoc MIT-LICENSE.txt)
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+end
+
+desc "Run all specs in spec directory with RCov"
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  t.spec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+  t.rcov = true
+  t.rcov_opts = lambda do
+    IO.readlines(File.dirname(__FILE__) + "/spec/rcov.opts").map {|l| l.chomp.split " "}.flatten
+  end
+end
+
+desc "Run the specs"
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.2.1

data/lib/rack/bug.rb

@@ -0,0 +1,43 @@
+require "rack"
+
+module Rack::Bug
+  autoload :Options,                "rack/bug/options"
+  autoload :Panel,                  "rack/bug/panel"
+  autoload :PanelApp,               "rack/bug/panel_app"
+  autoload :ParamsSignature,        "rack/bug/params_signature"
+  autoload :Render,                 "rack/bug/render"
+  autoload :Toolbar,                "rack/bug/toolbar"
+
+  # Panels
+  autoload :ActiveRecordPanel,      "rack/bug/panels/active_record_panel"
+  autoload :CachePanel,             "rack/bug/panels/cache_panel"
+  autoload :LogPanel,               "rack/bug/panels/log_panel"
+  autoload :MemoryPanel,            "rack/bug/panels/memory_panel"
+  autoload :RailsInfoPanel,         "rack/bug/panels/rails_info_panel"
+  autoload :RedisPanel,             "rack/bug/panels/redis_panel"
+  autoload :RequestVariablesPanel,  "rack/bug/panels/request_variables_panel"
+  autoload :SQLPanel,               "rack/bug/panels/sql_panel"
+  autoload :TemplatesPanel,         "rack/bug/panels/templates_panel"
+  autoload :TimerPanel,             "rack/bug/panels/timer_panel"
+
+  VERSION = File.read(File.join(File.dirname(__FILE__), "..", "..", "VERSION")).strip
+
+  class SecurityError < StandardError
+  end
+
+  def self.enable
+    Thread.current["rack-bug.enabled"] = true
+  end
+
+  def self.disable
+    Thread.current["rack-bug.enabled"] = false
+  end
+
+  def self.enabled?
+    Thread.current["rack-bug.enabled"] == true
+  end
+
+  def self.new(*args, &block)
+    Toolbar.new(*args, &block)
+  end
+end

data/lib/rack/bug/options.rb

@@ -0,0 +1,89 @@
+module Rack::Bug
+
+  module Options
+    class << self
+      private
+      def option_accessor(key)
+        define_method(key) { || read_option(key) }
+        define_method("#{key}=") { |value| write_option(key, value) }
+        define_method("#{key}?") { || !! read_option(key) }
+      end
+    end
+    
+    option_accessor :secret_key
+    option_accessor :ip_masks
+    option_accessor :password
+    option_accessor :panel_classes
+    option_accessor :intercept_redirects
+
+    # The underlying options Hash. During initialization (or outside of a
+    # request), this is a default values Hash. During a request, this is the
+    # Rack environment Hash. The default values Hash is merged in underneath
+    # the Rack environment before each request is processed.
+    def options
+      @env || @default_options
+    end
+
+    # Set multiple options.
+    def options=(hash={})
+      hash.each { |key,value| write_option(key, value) }
+    end
+
+    # Set an option. When +option+ is a Symbol, it is set in the Rack
+    # Environment as "rack-cache.option". When +option+ is a String, it
+    # exactly as specified. The +option+ argument may also be a Hash in
+    # which case each key/value pair is merged into the environment as if
+    # the #set method were called on each.
+    def set(option, value=self, &block)
+      if block_given?
+        write_option option, block
+      elsif value == self
+        self.options = option.to_hash
+      else
+        write_option option, value
+      end
+    end
+
+  private
+  
+    def read_option(key)
+      options[option_name(key)]
+    end
+
+    def write_option(key, value)
+      options[option_name(key)] = value
+    end
+
+    def option_name(key)
+      case key
+      when Symbol ; "rack-bug.#{key}"
+      when String ; key
+      else raise ArgumentError
+      end
+    end
+    
+    def initialize_options(options={})
+      @default_options = {
+        'rack-bug.ip_masks' => [IPAddr.new("127.0.0.1")],
+        'rack-bug.password' => nil,
+        'rack-bug.verbose'  => nil,
+        'rack-bug.secret_key' => nil,
+        'rack-bug.intercept_redirects' => false,
+        'rack-bug.panels' => [],
+        'rack-bug.panel_classes' => [
+          RailsInfoPanel,
+          TimerPanel,
+          RequestVariablesPanel,
+          SQLPanel,
+          ActiveRecordPanel,
+          CachePanel,
+          TemplatesPanel,
+          LogPanel,
+          MemoryPanel
+        ]
+      }
+      self.options = options
+    end
+    
+  end
+end

data/lib/rack/bug/panel.rb

@@ -0,0 +1,50 @@
+require "erb"
+
+module Rack
+  module Bug
+    
+    # Panels are also Rack middleware
+    class Panel
+      include Render
+      include ERB::Util
+      
+      attr_reader :request
+      
+      def initialize(app)
+        if panel_app
+          @app = Rack::Cascade.new([panel_app, app])
+        else
+          @app = app
+        end
+      end
+      
+      def call(env)
+        before(env)
+        status, headers, body = @app.call(env)
+        @request = Request.new(env)
+        after(env, status, headers, body)
+        env["rack-bug.panels"] << self
+        return [status, headers, body]
+      end
+      
+      def panel_app
+        nil
+      end
+      
+      def has_content?
+        true
+      end
+      
+      def before(env)
+      end
+      
+      def after(env, status, headers, body)
+      end
+      
+      def render(template)
+      end
+      
+    end
+    
+  end
+end

data/lib/rack/bug/panel_app.rb

@@ -0,0 +1,33 @@
+module Rack
+  module Bug
+    
+    class PanelApp
+      include Rack::Bug::Render
+      
+      attr_reader :request
+      
+      def call(env)
+        @request = Rack::Request.new(env)
+        dispatch
+      end
+      
+      def render_template(*args)
+        Rack::Response.new([super]).to_a
+      end
+      
+      def params
+        @request.GET
+      end
+
+      def not_found
+        [404, {}, []]
+      end
+
+      def validate_params
+        ParamsSignature.new(request).validate!
+      end
+      
+    end
+    
+  end
+end

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

@@ -0,0 +1,45 @@
+require "rack/bug/panels/active_record_panel/activerecord_extensions"
+
+module Rack
+  module Bug
+    
+    class ActiveRecordPanel < Panel
+      
+      def self.record(class_name)
+        return unless Rack::Bug.enabled?
+        records[class_name] += 1
+      end
+      
+      def self.reset
+        Thread.current["rack.bug.active_records"] = Hash.new { 0 }
+      end
+      
+      def self.records
+        Thread.current["rack.bug.active_records"] ||= Hash.new { 0 }
+      end
+      
+      def self.total
+        records.inject(0) do |memo, (key, value)|
+          memo + value
+        end
+      end
+      
+      def name
+        "active_record"
+      end
+      
+      def heading
+        "#{self.class.total} AR Objects"
+      end
+      
+      def content
+        records = self.class.records.to_a.sort_by { |key, value| value }.reverse
+        result = render_template "panels/active_record", :records => records
+        self.class.reset
+        result
+      end
+      
+    end
+    
+  end
+end

data/lib/rack/bug/panels/active_record_panel/activerecord_extensions.rb

@@ -0,0 +1,18 @@
+if defined?(ActiveRecord)
+  ActiveRecord::Base.class_eval do
+
+    if instance_methods.include?("after_initialize")
+      def after_initialize_with_rack_bug
+        Rack::Bug::ActiveRecordPanel.record(self.class.base_class.name)
+        after_initialize_without_rack_bug
+      end
+    
+      alias_method_chain :after_initialize, :rack_bug
+    else
+      def after_initialize
+        Rack::Bug::ActiveRecordPanel.record(self.class.base_class.name)
+      end
+    end
+    
+  end
+end

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

@@ -0,0 +1,50 @@
+require "rack/bug/panels/cache_panel/memcache_extension"
+
+module Rack
+  module 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/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