rack-bug-rails-3 0.3.0

data/.gitignore

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

data/History.txt

@@ -0,0 +1,46 @@
+== HEAD
+
+  * New features
+
+    * Can use LoggerPanel on ruby stdlib Logger in non-rails app (Tim Connor)
+
+  * Bug fixes
+  
+    * Fix profile, explain and select in the queries tab, fixes issue #22 (ebertech)
+    
+  * Minor fixes
+  
+    * Explicitly require 'digest/sha1' (Jérémy Lecour)
+    * Eliminate unreachable code in params signature validation (Tim Connor)
+
+  * Compatibilty
+
+    * Make Redis panel compatible with latest redis-rb gem, without breaking older redis-rb versions (Luke Melia)
+    * Fix issues with Ruby 1.9.2 and with mysql2 (George Ogota)
+  
+  * Other
+  
+    * Refactoring and code cleanup (Tim Connor)
+    * Testing cleanup - better isolation of Rails vs. non-Rails in tests (Tim Connor)
+  
+== 0.3.0 / 2010-05-28
+
+  * New features
+
+    * Log panel includes log level and timestamp (Tim Connor)
+    * Sphinx panel (George Chatzigeorgiou)
+    * Backtraces for Redis panel (Luke Melia & Joey Aghion)
+
+  * Minor fixes
+
+    * Don't "enable" rack bug if you hit cancel on the bookmarklet prompt (Mischa Fierer)
+
+  * Compatibilty
+
+    * backtrace filtering now supports more than just Rails (Alex Chaffee)
+    * compatibility with current rack-test (Luke Melia & Joey Aghion)
+    * update Sinatra sample app (Tim Conner)
+
+== 0.2.1
+
+  * The beginning of recorded history

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.md

@@ -0,0 +1,118 @@
+Rack::Bug [![Code Climate](https://codeclimate.com/badge.png)](https://codeclimate.com/github/brynary/rack-bug)
+=========
+
+* Repository: [http://github.com/brynary/rack-bug](http://github.com/brynary/rack-bug)
+
+Description
+-----------
+
+Rack::Bug adds a diagnostics toolbar to Rack apps. When enabled, it injects a floating div
+allowing exploration of logging, database queries, template rendering times, etc.
+
+Features
+--------
+
+* Password-based security
+* IP-based security
+* Rack::Bug instrumentation/reporting is broken up into panels.
+    * Panels in default configuration:
+        * Rails Info
+        * Timer
+        * Request Variables
+        * SQL
+        * Active Record
+        * Cache
+        * Templates
+        * Log
+        * Memory
+    * Other bundled panels:
+        * Redis
+        * Sphinx
+    * The API for adding your own panels is simple and powerful
+
+Rails quick start
+---------------------------
+
+    script/plugin install git://github.com/brynary/rack-bug.git
+
+In config/environments/development.rb, add:
+
+    config.middleware.use "Rack::Bug",
+      :secret_key => "someverylongandveryhardtoguesspreferablyrandomstring"
+
+Add the bookmarklet to your browser:
+
+    open http://RAILS_APP/__rack_bug__/bookmarklet.html
+
+Using with non-Rails Rack apps
+------------------------------
+
+Just 'use Rack::Bug' as any other middleware.  See the SampleApp in the spec/fixtures folder for an example Sinatra app.
+
+If you wish to use the logger panel define the LOGGER constant that is a ruby Logger or ActiveSupport::BufferedLogger
+
+Configuring custom panels
+-------------------------
+
+Specify the set of panels you want, in the order you want them to appear:
+
+    require "rack/bug"
+
+    ActionController::Dispatcher.middleware.use Rack::Bug,
+      :secret_key => "someverylongandveryhardtoguesspreferablyrandomstring",
+      :panel_classes => [
+        Rack::Bug::TimerPanel,
+        Rack::Bug::RequestVariablesPanel,
+        Rack::Bug::RedisPanel,
+        Rack::Bug::TemplatesPanel,
+        Rack::Bug::LogPanel,
+        Rack::Bug::MemoryPanel
+      ]
+
+
+Running Rack::Bug in staging or production
+------------------------------------------
+
+We have have found that Rack::Bug is fast enough to run in production for specific troubleshooting efforts.
+
+### Configuration ####
+
+Add the middleware configuration to an initializer or the appropriate environment files, taking the rest of this section into consideration.
+
+### Security ####
+
+Restrict access to particular IP addresses:
+
+    require "ipaddr"
+
+    ActionController::Dispatcher.middleware.use "Rack::Bug"
+      :secret_key => "someverylongandveryhardtoguesspreferablyrandomstring",
+      :ip_masks   => [IPAddr.new("2.2.2.2/0")]
+
+Restrict access using a password:
+
+    ActionController::Dispatcher.middleware.use "Rack::Bug",
+      :secret_key => "someverylongandveryhardtoguesspreferablyrandomstring",
+      :password   => "yourpassword"
+
+
+Authors
+-------
+
+- Maintained by [Bryan Helmkamp](mailto:bryan@brynary.com)
+- Contributions from Luke Melia, Joey Aghion, Tim Connor, and more
+
+Thanks
+------
+Inspiration for Rack::Bug is primarily from the Django debug toolbar. Additional ideas from Rails footnotes, Rack's ShowException middleware, Oink, and Rack::Cache
+
+Thanks to Weplay.com for supporting the development of Rack::Bug
+
+Development
+-----------
+For development, you'll need to install the following gems: rspec, rack-test, webrat, sinatra
+
+License
+-------
+
+See MIT-LICENSE.txt in this directory.

data/Rakefile

@@ -0,0 +1,23 @@
+require "rubygems"
+require "spec/rake/spectask"
+
+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
+
+desc 'Removes trailing whitespace'
+task :whitespace do
+  sh %{find . -name '*.rb' -exec sed -i '' 's/ *$//g' {} \\;}
+end

data/Thorfile

@@ -0,0 +1,113 @@
+module GemHelpers
+
+  def generate_gemspec
+    $LOAD_PATH.unshift(File.expand_path(File.join(File.dirname(__FILE__), "lib")))
+    require "rack/bug"
+
+    Gem::Specification.new do |s|
+      s.name      = "rack-bug"
+      s.version   = Rack::Bug::VERSION
+      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.rubyforge_project = "rack-bug"
+
+      require "git"
+      repo = Git.open(".")
+
+      s.files      = normalize_files(repo.ls_files.keys - repo.lib.ignored_files)
+      s.test_files = normalize_files(Dir['spec/**/*.rb'] - repo.lib.ignored_files)
+
+      s.has_rdoc = true
+      s.extra_rdoc_files = %w[README.md MIT-LICENSE.txt]
+
+      s.add_dependency "rack", ">= 1.0"
+      s.add_development_dependency "webrat"
+      s.add_development_dependency "rspec"
+      s.add_development_dependency "sinatra"
+      s.add_development_dependency "git"
+    end
+  end
+
+  def normalize_files(array)
+    # only keep files, no directories, and sort
+    array.select do |path|
+      File.file?(path)
+    end.sort
+  end
+
+  # Adds extra space when outputting an array. This helps create better version
+  # control diffs, because otherwise it is all on the same line.
+  def prettyify_array(gemspec_ruby, array_name)
+    gemspec_ruby.gsub(/s\.#{array_name.to_s} = \[.+?\]/) do |match|
+      leadin, files = match[0..-2].split("[")
+      leadin + "[\n    #{files.split(",").join(",\n   ")}\n  ]"
+    end
+  end
+
+  def read_gemspec
+    @read_gemspec ||= eval(File.read("rack-bug.gemspec"))
+  end
+
+  def sh(command)
+    puts command
+    system command
+  end
+end
+
+class Default < Thor
+  include GemHelpers
+
+  desc "gemspec", "Regenerate rack-bug.gemspec"
+  def gemspec
+    File.open("rack-bug.gemspec", "w") do |file|
+      gemspec_ruby = generate_gemspec.to_ruby
+      gemspec_ruby = prettyify_array(gemspec_ruby, :files)
+      gemspec_ruby = prettyify_array(gemspec_ruby, :test_files)
+      gemspec_ruby = prettyify_array(gemspec_ruby, :extra_rdoc_files)
+
+      file.write gemspec_ruby
+    end
+
+    puts "Wrote gemspec to rack-bug.gemspec"
+    read_gemspec.validate
+  end
+
+  desc "build", "Build a rack-bug gem"
+  def build
+    sh "gem build rack-bug.gemspec"
+    FileUtils.mkdir_p "pkg"
+    FileUtils.mv read_gemspec.file_name, "pkg"
+  end
+
+  desc "install", "Install the latest built gem"
+  def install
+    sh "gem install --local pkg/#{read_gemspec.file_name}"
+  end
+
+  desc "release", "Release the current branch to GitHub and Gemcutter"
+  def release
+    gemspec
+    build
+    Release.new.tag
+    Release.new.gem
+  end
+end
+
+class Release < Thor
+  include GemHelpers
+
+  desc "tag", "Tag the gem on the origin server"
+  def tag
+    release_tag = "v#{read_gemspec.version}"
+    sh "git tag -a #{release_tag} -m 'Tagging #{release_tag}'"
+    sh "git push origin #{release_tag}"
+  end
+
+  desc "gem", "Push the gem to Gemcutter"
+  def gem
+    sh "gem push pkg/#{read_gemspec.file_name}"
+  end
+end

data/lib/rack/bug/autoloading.rb

@@ -0,0 +1,25 @@
+class Rack::Bug
+  autoload :FilteredBacktrace,      "rack/bug/filtered_backtrace"
+  autoload :Options,                "rack/bug/options"
+  autoload :Panel,                  "rack/bug/panel"
+  autoload :PanelApp,               "rack/bug/panel_app"
+  autoload :ParamsSignature,        "rack/bug/params_signature"
+  autoload :RackStaticBugAvoider,   "rack/bug/rack_static_bug_avoider"
+  autoload :RedirectInterceptor,    "rack/bug/redirect_interceptor"
+  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 :MongoPanel,             "rack/bug/panels/mongo_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"
+  autoload :SphinxPanel,            "rack/bug/panels/sphinx_panel"
+end

data/lib/rack/bug/filtered_backtrace.rb

@@ -0,0 +1,38 @@
+module Rack
+  class Bug
+    module FilteredBacktrace
+
+      def backtrace
+        @backtrace
+      end
+
+      def has_backtrace?
+        filtered_backtrace.any?
+      end
+
+      def filtered_backtrace
+        @filtered_backtrace ||= @backtrace.map{|l| l.to_s.strip }.select do |line|
+          root_for_backtrace_filtering.nil? ||
+          (line.index(root_for_backtrace_filtering.to_s) == 0) && !(line.index(root_for_backtrace_filtering("vendor").to_s) == 0)
+        end
+      end
+
+      def root_for_backtrace_filtering(sub_path = nil)
+        if defined?(Rails) && Rails.respond_to?(:root)
+          (sub_path ? Rails.root.join(sub_path) : Rails.root).to_s
+        else
+          root = if defined?(RAILS_ROOT)
+            RAILS_ROOT
+          elsif defined?(ROOT)
+            ROOT
+          elsif defined?(Sinatra::Application)
+            Sinatra::Application.root
+          else
+            nil
+          end
+          sub_path ? ::File.join(root, sub_path) : root
+        end.to_s
+      end
+    end
+  end
+end

data/lib/rack/bug/options.rb

@@ -0,0 +1,89 @@
+class 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
+  class 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
+  class 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/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/active_record_panel.rb

@@ -0,0 +1,45 @@
+require "rack/bug/panels/active_record_panel/activerecord_extensions"
+
+module Rack
+  class 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