lrd_rack_bug 0.3.0.2

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

@@ -0,0 +1,52 @@
+module Rack
+  class Bug
+
+    class RequestVariablesPanel < Panel
+
+      def name
+        "request_variables"
+      end
+
+      def before(env)
+        @env = env
+      end
+
+      def heading
+        "Rack Env"
+      end
+
+      def content
+        sections = {}
+        sections["GET"] = sort(@request.GET) if @request.GET.any?
+        sections["POST"] = sort(@request.GET) if @request.POST.any?
+        sections["Session"] = sort(@request.env["rack.session"]) if @request.env["rack.session"] && @request.env["rack.session"].any?
+        sections["Cookies"] = sort(@request.env["rack.request.cookie_hash"]) if @request.env["rack.request.cookie_hash"] && @request.env["rack.request.cookie_hash"].any?
+        server, rack = split_and_filter_env(@env)
+        sections["SERVER VARIABLES"] = sort(server)
+        sections["Rack ENV"] = sort(rack)
+        render_template "panels/request_variables", :sections => sections
+      end
+
+    private
+      def sort(hash)
+        hash.sort_by { |k, v| k.to_s }
+      end
+
+      def split_and_filter_env(env)
+        server, rack = {}, {}
+        env.each do |k,v|
+          if k.index("rack.") == 0
+            rack[k] = v
+          elsif k.index("rack-bug.") == 0
+            #don't output the rack-bug variables - especially secret_key
+          else
+            server[k] = v
+          end
+        end
+        return server, rack
+      end
+
+    end
+
+  end
+end

data/lib/rack/bug/panels/sphinx_panel/sphinx_extension.rb

@@ -0,0 +1,25 @@
+require 'riddle'
+
+if defined?(Riddle)
+  Riddle::Client.class_eval do
+    def request_with_rack_bug(command, messages)
+      Rack::Bug::SphinxPanel.record(command, messages) do
+        request_without_rack_bug(command, messages)
+      end
+    end
+
+    alias_method_chain :request, :rack_bug
+  end
+end
+
+if defined?(Sphinx::Client)
+  Sphinx::Client.class_eval do
+    def PerformRequest_with_rack_bug(command, request, additional = nil)
+      Rack::Bug::SphinxPanel.record(command, request) do
+        PerformRequest_without_rack_bug(command, request, additional)
+      end
+    end
+
+    alias_method_chain :PerformRequest, :rack_bug
+  end
+end

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

@@ -0,0 +1,96 @@
+module Rack
+  class Bug
+    class SphinxPanel
+
+      class Stats
+        class Query
+          attr_reader :time
+          attr_reader :command
+
+          def initialize(time, *command_args)
+            @time = time
+            if command_args.flatten.first == :search
+              @command = "search: " + decode_message(command_args.first.flatten.last).collect{|k,v| "#{k} => #{v}"}.join(", ")
+            else
+              @command = command_args.flatten.first.to_s + ": No more info is available for this Sphinx request type"
+            end
+          end
+
+          def display_time
+            "%.2fms" % time
+          end
+
+          def decode_message(m)
+            @m = m.clone
+            params = ActiveSupport::OrderedHash.new
+
+            params[:offset] = consume_int
+            params[:limit] = consume_int
+            params[:match_mode] = consume_int
+            params[:rank_mode] = consume_int
+            params[:sort_mode] = consume_int
+            params[:sort_by] = consume_string
+            params[:query] = consume_string
+            wl = consume_int
+            weights = []
+            wl.times do weights << consume_int end
+            params[:weights] = weights
+
+            params[:index] = consume_string
+
+            consume_string
+
+            params[:id_range] = [consume_64int, consume_64int]
+            params
+          end
+
+          def consume_int
+            i = @m.unpack("N").first
+            @m = @m.slice(4, @m.length - 4)
+            i
+          end
+
+          def consume_64int
+            i = @m.unpack("NN").first
+            @m = @m.slice(8, @m.length - 8)
+            i
+          end
+
+          def consume_string
+            len = consume_int
+            s = @m.slice(0, len)
+            @m = @m.slice(len, @m.length - len)
+            s
+          end
+        end
+
+        attr_reader :calls
+        attr_reader :queries
+
+        def initialize
+          @queries = []
+          @calls = 0
+          @time = 0.0
+        end
+
+        def record_call(time, *command_args)
+
+          @queries << Query.new(time, command_args)
+          @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/sphinx_panel.rb

@@ -0,0 +1,44 @@
+module Rack
+  class Bug
+
+    class SphinxPanel < Panel
+      require "rack/bug/panels/sphinx_panel/sphinx_extension"
+
+      autoload :Stats, "rack/bug/panels/sphinx_panel/stats"
+
+      def self.record(*sphinx_command_args, &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, sphinx_command_args)
+        return result
+      end
+
+      def self.reset
+        Thread.current["rack.bug.sphinx"] = Stats.new
+      end
+
+      def self.stats
+        Thread.current["rack.bug.sphinx"] ||= Stats.new
+      end
+
+      def name
+        "sphinx"
+      end
+
+      def heading
+        "Sphinx: %.2fms (#{self.class.stats.queries.size} calls)" % self.class.stats.time
+      end
+
+      def content
+        result = render_template "panels/sphinx", :stats => self.class.stats
+        self.class.reset
+        return result
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,37 @@
+module Rack
+  class Bug
+    class SQLPanel
+
+      class PanelApp < ::Rack::Bug::PanelApp
+
+        def dispatch
+          case request.path_info
+          when "/__rack_bug__/explain_sql" then explain_sql
+          when "/__rack_bug__/profile_sql" then profile_sql
+          when "/__rack_bug__/execute_sql" then execute_sql
+          else not_found
+          end
+        end
+
+        def explain_sql
+          validate_params
+          query = Query.new(params["query"], params["time"].to_f)
+          render_template "panels/explain_sql", :result => query.explain, :query => query.sql, :time => query.time
+        end
+
+        def profile_sql
+          validate_params
+          query = Query.new(params["query"], params["time"].to_f)
+          render_template "panels/profile_sql", :result => query.profile, :query => query.sql, :time => query.time
+        end
+
+        def execute_sql
+          validate_params
+          query = Query.new(params["query"], params["time"].to_f)
+          render_template "panels/execute_sql", :result => query.execute, :query => query.sql, :time => query.time
+        end
+
+      end
+    end
+  end
+end

data/lib/rack/bug/panels/sql_panel/query.rb

@@ -0,0 +1,63 @@
+module Rack
+  class Bug
+    class SQLPanel
+
+      class Query
+        include Rack::Bug::FilteredBacktrace
+
+        attr_reader :sql
+        attr_reader :time
+
+        def initialize(sql, time, backtrace = [])
+          @sql = sql
+          @time = time
+          @backtrace = backtrace
+        end
+
+        def human_time
+          "%.2fms" % (@time * 1_000)
+        end
+
+        def inspectable?
+          sql.strip =~ /^SELECT /i
+        end
+
+        def with_profiling
+          self.class.execute("SET PROFILING=1")
+          result = yield
+          self.class.execute("SET PROFILING=0")
+          return result
+        end
+
+        def explain
+          self.class.execute "EXPLAIN #{@sql}"
+        end
+
+        def profile
+          with_profiling do
+            execute
+            self.class.execute <<-SQL
+              SELECT *
+                FROM information_schema.profiling
+               WHERE query_id = (SELECT query_id FROM information_schema.profiling ORDER BY query_id DESC LIMIT 1)
+            SQL
+          end
+        end
+
+        def execute
+          self.class.execute(@sql)
+        end
+
+        def valid_hash?(secret_key, possible_hash)
+          hash = Digest::SHA1.hexdigest [secret_key, @sql].join(":")
+          possible_hash == hash
+        end
+
+        def self.execute(sql)
+          ActiveRecord::Base.connection.execute(sql)
+        end
+      end
+
+    end
+  end
+end

data/lib/rack/bug/panels/sql_panel/sql_extension.rb

@@ -0,0 +1,22 @@
+if defined?(ActiveRecord) && defined?(ActiveRecord::ConnectionAdapters)
+
+  if defined?(ActiveSupport::Notifications)
+    require 'active_record/base'
+    ActiveSupport::Notifications.subscribe(/sql.active_record/) do |*args|
+      event = ActiveSupport::Notifications::Event.new(*args)
+      Rack::Bug::SQLPanel.record_event(event.payload[:sql], event.duration) # TODO: is there any way to get a backtrace out of here?
+    end
+  else
+  
+    ActiveRecord::ConnectionAdapters::AbstractAdapter.class_eval do
+      def log_with_rack_bug(sql, name, &block)
+        Rack::Bug::SQLPanel.record(sql, Kernel.caller) do
+          log_without_rack_bug(sql, name, &block)
+        end
+      end
+
+      alias_method_chain :log, :rack_bug
+    end
+    
+  end
+end

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

@@ -0,0 +1,60 @@
+require "digest"
+
+module Rack
+  class Bug
+
+    class SQLPanel < Panel
+      require "rack/bug/panels/sql_panel/sql_extension"
+
+      autoload :PanelApp, "rack/bug/panels/sql_panel/panel_app"
+      autoload :Query,    "rack/bug/panels/sql_panel/query"
+
+      def panel_app
+        PanelApp.new
+      end
+
+      def self.record(sql, backtrace = [], &block)
+        return block.call unless Rack::Bug.enabled?
+
+        start_time = Time.now
+        result = block.call
+        queries << Query.new(sql, Time.now - start_time, backtrace)
+
+        return result
+      end
+      
+      def self.record_event(sql, duration, backtrace = [])
+        return unless Rack::Bug.enabled?
+        queries << Query.new(sql, duration, backtrace)
+      end
+
+      def self.reset
+        Thread.current["rack.test.queries"] = []
+      end
+
+      def self.queries
+        Thread.current["rack.test.queries"] ||= []
+      end
+
+      def self.total_time
+        (queries.inject(0) { |memo, query| memo + query.time}) * 1_000
+      end
+
+      def name
+        "sql"
+      end
+
+      def heading
+        "#{self.class.queries.size} Queries (%.2fms)" % self.class.total_time
+      end
+
+      def content
+        result = render_template "panels/sql", :queries => self.class.queries
+        self.class.reset
+        return result
+      end
+
+    end
+
+  end
+end

data/lib/rack/bug/panels/templates_panel/actionview_extension.rb

@@ -0,0 +1,21 @@
+if defined?(ActionView) && defined?(ActionView::Template)
+  if defined?(ActiveSupport::Notifications)
+
+    ActiveSupport::Notifications.subscribe /^render.*\.action_view/ do |*args|
+      event = ActiveSupport::Notifications::Event.new(*args)
+      Rack::Bug::TemplatesPanel.record_event(event)
+    end
+
+  else
+    ActionView::Template.class_eval do
+
+      def render_template_with_rack_bug(*args, &block)
+        Rack::Bug::TemplatesPanel.record(path_without_format_and_extension) do
+          render_template_without_rack_bug(*args, &block)
+        end
+      end
+
+      alias_method_chain :render_template, :rack_bug
+    end
+  end
+end

data/lib/rack/bug/panels/templates_panel/rendering.rb

@@ -0,0 +1,77 @@
+module Rack
+  class Bug
+    class TemplatesPanel
+
+      class Rendering
+        attr_accessor :name
+        attr_accessor :start_time
+        alias_method :time, :start_time
+        attr_accessor :end_time
+        attr_accessor :parent
+        attr_reader :children
+
+        def initialize(name, start_time = nil, end_time = nil)
+          @name = name
+          @start_time = start_time || Time.now
+          @end_time = end_time
+          @children = []
+        end
+
+        def add(rendering)
+          @children << rendering
+          rendering.parent = self
+        end
+
+        def delete(rendering)
+          @children.delete(rendering)
+        end
+        
+        def duration
+          if @end_time
+            @end_time - @start_time
+          else
+            child_duration
+          end
+        end
+
+        def exclusive_duration
+          duration - child_duration
+        end
+
+        def child_duration
+          children.inject(0.0) { |memo, c| memo + c.duration }
+        end
+
+        def duration_summary
+          if children.any?
+            "%.2fms, %.2f exclusive" % [duration * 1_000, exclusive_duration * 1_000]
+          else
+            "%.2fms" % (duration * 1_000)
+          end
+        end
+        def html
+          <<-HTML
+            <li>
+              <p>#{name} (#{duration_summary})</p>
+
+              #{children_html}
+            </li>
+          HTML
+        end
+
+        def children_html
+          return "" unless children.any?
+
+          <<-HTML
+            <ul>#{joined_children_html}</ul>
+          HTML
+        end
+
+        def joined_children_html
+          children.map { |c| c.html }.join
+        end
+      end
+
+    end
+  end
+end

data/lib/rack/bug/panels/templates_panel/trace.rb

@@ -0,0 +1,44 @@
+module Rack
+  class Bug
+    class TemplatesPanel
+
+      class Trace
+
+        def start(template_name)
+          rendering = Rendering.new(template_name)
+          rendering.start_time = Time.now
+          @current.add(rendering)
+          @current = rendering
+        end
+        
+        def add(template_name, start_time, end_time, event)
+          current = Rendering.new(template_name, start_time, end_time)
+          root_rendering.children.each do |child|
+            next unless event.parent_of?(child)
+            root_rendering.delete(child)
+            current.add(child)
+          end
+          root_rendering.add(current)
+        end
+
+        def finished(template_name)
+          @current.end_time = Time.now
+          @current = @current.parent
+        end
+
+        def initialize
+          @current = root_rendering
+        end
+
+        def total_time
+          root_rendering.duration
+        end
+
+        def root_rendering
+          @root_rendering ||= Rendering.new("root")
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+module Rack
+  class Bug
+
+    class TemplatesPanel < Panel
+      require "rack/bug/panels/templates_panel/actionview_extension"
+
+      autoload :Trace,      "rack/bug/panels/templates_panel/trace"
+      autoload :Rendering,  "rack/bug/panels/templates_panel/rendering"
+
+      def self.record(template, &block)
+        return block.call unless Rack::Bug.enabled?
+
+        template_trace.start(template)
+        result = block.call
+        template_trace.finished(template)
+        return result
+      end
+
+      def self.record_event(event)
+        return unless Rack::Bug.enabled?
+
+        template_description = "#{event.name}: #{event.payload[:virtual_path] || event.payload[:identifier]}"
+        template_trace.add(template_description, event.time, event.end, event)
+      end
+
+      def self.reset
+        Thread.current["rack.bug.template_trace"] = Trace.new
+      end
+
+      def self.template_trace
+        Thread.current["rack.bug.template_trace"] ||= Trace.new
+      end
+
+      def name
+        "templates"
+      end
+
+      def heading
+        "Templates: %.2fms" % (self.class.template_trace.total_time * 1_000)
+      end
+
+      def content
+        result = render_template "panels/templates", :root_rendering => self.class.template_trace.root_rendering
+        self.class.reset
+        return result
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,40 @@
+require "benchmark"
+
+module Rack
+  class Bug
+
+    class TimerPanel < Panel
+
+      def name
+        "timer"
+      end
+
+      def call(env)
+        status, headers, body = nil
+        @times = Benchmark.measure do
+          status, headers, body = @app.call(env)
+        end
+
+        @measurements = [
+          ["User CPU time",   "%.2fms" % (@times.utime * 1_000)],
+          ["System CPU time", "%.2fms" % (@times.stime * 1_000)],
+          ["Total CPU time",  "%.2fms" % (@times.total * 1_000)],
+          ["Elapsed time",    "%.2fms" % (@times.real  * 1_000)]
+        ]
+
+        env["rack-bug.panels"] << self
+        return [status, headers, body]
+      end
+
+      def heading
+        "%.2fms" % (@times.real * 1_000)
+      end
+
+      def content
+        render_template "panels/timer", :measurements => @measurements
+      end
+
+    end
+
+  end
+end

data/lib/rack/bug/params_signature.rb

@@ -0,0 +1,63 @@
+require "digest"
+
+module Rack
+  class Bug
+
+    class ParamsSignature
+      extend ERB::Util
+
+      def self.sign(request, hash)
+        parts = []
+
+        hash.keys.sort.each do |key|
+          parts << "#{key}=#{u(hash[key])}"
+        end
+
+        signature = new(request).signature(hash)
+        parts << "hash=#{u(signature)}"
+
+        parts.join("&amp;")
+      end
+
+      attr_reader :request
+
+      def initialize(request)
+        @request = request
+      end
+
+      def secret_key
+        @request.env['rack-bug.secret_key']
+      end
+
+      def secret_key_blank?
+        secret_key.nil? || secret_key == ""
+      end
+
+      def validate!
+        if secret_key_blank?
+          raise SecurityError.new("Missing secret key")
+        elsif request.params["hash"] != signature(request.params)
+          raise SecurityError.new("Invalid query hash.")
+        end
+      end
+
+      def signature(params)
+        Digest::SHA1.hexdigest(signature_base(params))
+      end
+
+      def signature_base(params)
+        signature = []
+        signature << secret_key
+
+        params.keys.sort.each do |key|
+          next if key == "hash"
+          signature << params[key].to_s
+        end
+
+        signature.join(":")
+      end
+
+    end
+
+  end
+end