sql_safety_net 1.1.11 → 2.0.0

data/README.rdoc

@@ -1,19 +1,40 @@
-= SQL Safety Net
+= SqlSafetyNet
 
-This gem provides hooks into ActiveRecord to analyze SQL queries. It can be very useful in keeping an eye on tuning your code before it becomes a problem. ActiveRecord can make it very easy to send excessive load to the database.
+ActiveRecord makes it very easy and seamless to access data from a database. A downside of this is you often don't realize what kind of load you are putting on the database either by the number or the type of queries generated because "it just works." This can lead to performance problems in production because databases are notoriously hard and expensive to scale.
 
-With this gem enabled, HTML pages which have bad queries or too many queries on them will have a debug div added to the HTML with information about the queries. If you see this in development mode, you should investigate and come up with ways to reduce the load.
+This gem exposes debugging information about SQL queries generated by ActiveRecord in a Rails application. It is intended to be used in development mode to allow developers to see what queries are being generated so issues can be caught before code goes to production.
 
-== Example
+It works by injecting code into the connection adapter to count and analyze SELECT queries. It does not collect any information on INSERT, UPDATE, or DELETE queries. The analysis is exposed by a Rack middleware handler in a variety of ways.
 
-Add this code to an initializer:
+== Features
 
-  SqlSafetyNet.init_rails
+SqlSafetyNet will track data about each query in your request and analyze them individually and as a group.
 
-You can pass a block to this method which will yield a configuration object you can use to set threshold parameters on. See SqlSafetyNet::Configuration for all options. For example:
+* Rows returned by each query
+* Estimated number of bytes returned by each query
+* Time taken to execute each query
+* Total number of queries
+* Total number or rows returned for all queries
+* Total estimated bytes returned for all queries
+* Total time taken to execute all queries
+* Query plan analysis for each query (if supported)
 
-  SqlSafetyNet.init_rails do |config|
-    config.query_limit = 20
-  end
+== Debugging Output
 
-If you need finer control over how the gem is set up, or you are using it in a non-Rails environment, you can initialize it manually. You will need to call <tt>SqlSafetyNet::Configuration.enable_on</tt> with the ActiveRecord connection object and you will need to add SqlSafetyNet::RackHandler to the Rack middleware stack.
+A summary of the queries will be added to all responses in the X-SqlSafetyNet header. This will include the number of queries, the number of rows returned, the approximate amount of data returned from the database, and the elapsed time to make the queries.
+
+When issues are found with queries in a request, this information will be logged.
+
+If the response is an HTML document and the request was not from Ajax, a debug info window will be inserted into the document if there were any queries flagged as problematic. This is the most effective way to insure that the analysis is always visible to the developers. The box can also be expanded to details about each query. The debug box will always be displayed if the request queries are flagged with issues. There is also a configuration setting to always show the debug box. The box will be green if there are no issues, red if there are issues, or orange if there are issues but the queries that generate them are cached in Rails.cache.
+
+== Configuration
+
+There are variety of configuration options where you can specify the thresholds which you'd consider excess database usage. See SqlSafetyNet::Config for details.
+
+== Query Plan Analysis
+
+If you are using MySQL or PostgreSQL, then each query will also get the query plan from the database and analyze it for problems like table scans on large tables.
+
+The query analysis for PostgreSQL is much less detailed than MySQL because the MySQL plans are much more straightforward to understand programatically. Reading PostgreSQL query plans is more of an art. In addition, take the PostgreSQL warnings with a grain of salt. It only looks for large table scans or large number of rows examined in a query. However, PostgreSQL will only estimate these numbers on a simple EXPLAIN plan and sometimes it gets the number very wrong on small tables. For the query plan may estimate the query will do a table scan on 300 rows even though the table only has 10 rows in it.
+
+For details on enabling query plan analysis see SqlSafteyNet::ExplainPlan.

data/Rakefile

@@ -27,12 +27,10 @@ begin
     gem.has_rdoc = true
     gem.rdoc_options << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc'
     gem.extra_rdoc_files = ["README.rdoc"]
-    gem.add_dependency('activesupport')
-    gem.add_dependency('activerecord', '>= 2.2.2')
-    gem.add_dependency('actionpack')
+    gem.add_dependency('activesupport', '>= 3.0.0')
+    gem.add_dependency('activerecord', '>= 3.0.0')
+    gem.add_dependency('actionpack', '>= 3.0.0')
     gem.add_development_dependency('rspec', '>= 2.0.0')
-    gem.add_development_dependency('mysql')
-    gem.add_development_dependency('pg')
     gem.add_development_dependency('sqlite3-ruby')
   end
   Jeweler::RubygemsDotOrgTasks.new

data/lib/sql_safety_net/cache_store.rb

@@ -1,18 +1,28 @@
 module SqlSafetyNet
-  # Hook into ActiveSupport::Cache to set a caching flag on the QueryAnalysis whenever +fetch+ is called with a block.
+  # This module provides a hook into ActiveSupport::Cache::Store caches to keep
+  # track of when a query happens inside a cache fetch block. This will be reported
+  # in the analysis.
   module CacheStore
-    def self.included(base)
-      base.alias_method_chain(:fetch, :sql_safety_net)
+    extend ActiveSupport::Concern
+    
+    included do
+      alias_method_chain :fetch, :sql_safety_net
     end
     
     def fetch_with_sql_safety_net(*args, &block)
-      analysis = QueryAnalysis.current
-      saved_val = analysis.caching? if analysis
+      save_val = Thread.current[:sql_safety_net_in_cache_store_fetch_block]
       begin
-        analysis.caching = true if analysis
+        Thread.current[:sql_safety_net_in_cache_store_fetch_block] = true
         fetch_without_sql_safety_net(*args, &block)
       ensure
-        analysis.caching = saved_val if analysis
+        Thread.current[:sql_safety_net_in_cache_store_fetch_block] = save_val
+      end
+    end
+    
+    class << self
+      # Return +true+ if called from within a +fetch+ block.
+      def in_fetch_block?
+        !!Thread.current[:sql_safety_net_in_cache_store_fetch_block]
       end
     end
   end

data/lib/sql_safety_net/configuration.rb

@@ -1,57 +1,46 @@
 module SqlSafetyNet
-  # Configuration for SqlSafetyNet. The various limit attributes are used for adapters that can do query analysis. Queries
-  # will be flagged if their query plan exceeds a limit.
+  # This class provides configuration options for SQL analysis.
+  #
+  # These options specify when a warning will be triggered based on the totals from all queries
+  # in a single request:
+  #
+  # * query_limit - the total number of queries (default to 10)
+  # * returned_rows_limit - the total number of rows returned (defaults to 100)
+  # * result_size_limit - the number of bytes returned by all queries (defaults to 16K)
+  # * elapsed_time_limit - the number of seconds taken for all queries (defaults to 0.3)
+  #
+  # These options specify when a warning will be triggered on a single query. These options are only
+  # available when using MySQL:
+  #
+  # * table_scan_limit - the number of rows in a table scan that will trigger a warning (defaults to 100)
+  # * temporary_table_limit - the number of temporary table rows that will trigger a warning (defaults to 100)
+  # * filesort_limit - the number of rows in a filesort operation that will trigger a warning (defaults to 100)
+  # * examined_rows_limit - the number of rows examined in a query that will trigger a warning (defaults to 5000)
+  #
+  # These options specify details about embedding debugging info in HTML pages
+  #
+  # * always_show - set to true to always show debugging info; otherwise only shown if the request is flagged (defaults to false)
+  # * style - set to a hash of CSS styles used to style the debugging info; defaults to appearing in the upper right corner
   class Configuration
-    attr_accessor :table_scan_limit, :temporary_table_limit, :filesort_limit, :return_rows_limit, :examine_rows_limit, :query_limit, :time_limit, :position
+    attr_accessor :query_limit, :returned_rows_limit, :result_size_limit, :elapsed_time_limit
+    attr_accessor :table_scan_limit, :temporary_table_limit, :filesort_limit, :examined_rows_limit
+    attr_accessor :always_show, :style
     
     def initialize
-      @debug = false
-      @header = false
+      @query_limit = 10
+      @returned_rows_limit = 100
+      @result_size_limit = 16 * 1024
+      @elapsed_time_limit = 0.3
+      
       @table_scan_limit = 100
       @temporary_table_limit = 100
       @filesort_limit = 100
-      @return_rows_limit = 100
-      @examine_rows_limit = 5000
-      @query_limit = 10
+      @examined_rows_limit = 5000
+      
       @always_show = false
-      @position = "top:5px; right: 5px;"
-      @time_limit = 300
-    end
-    
-    # Enable SqlSafetyNet on a connection. Unless this method is called, the code will not be mixed into the database
-    # adapter. This should normally be called only in the development environment.
-    def enable_on(connection_class)
-      connection_class = connection_class.constantize unless connection_class.is_a?(Class)
-      connection_class_name = connection_class.name.split('::').last
-      include_class = ConnectionAdapter.const_get(connection_class_name) if ConnectionAdapter.const_defined?(connection_class_name)
-      connection_class.send(:include, ConnectionAdapter) unless connection_class.include?(ConnectionAdapter)
-      connection_class.send(:include, include_class) if include_class && !connection_class.include?(include_class)
-    end
-    
-    def debug=(val)
-      @debug = !!val
-    end
-
-    def debug?
-      @debug
-    end
-    
-    def header=(val)
-      @header = !!val
-    end
-
-    def header?
-      @header
-    end
-    
-    # Set a flag to always show information about queries on rendered HTML pages. If this is not set to true, the debug
-    # information will only be shown if the queries on the page exceed one of the limits.
-    def always_show=(val)
-      @always_show = !!val
-    end
-    
-    def always_show?
-      @always_show
+      @style = {}
+      
+      yield(self) if block_given?
     end
   end
 end

data/lib/sql_safety_net/connection_adapter.rb

@@ -1,103 +1,72 @@
 module SqlSafetyNet
-  # Logic to be mixed into connection adapters allowing them to analyze queries.
+  # This module needs to be included with the specific ActiveRecord::ConnectionAdapter class
+  # to collect data about all SELECT queries.
   module ConnectionAdapter
-    autoload :MysqlAdapter, File.expand_path('../connection_adapter/mysql_adapter', __FILE__)
-    autoload :PostgreSQLAdapter, File.expand_path('../connection_adapter/postgresql_adapter', __FILE__)
-    
-    SELECT_STATEMENT = /^\s*SELECT\b/i
-    
-    def self.included(base)
-      base.alias_method_chain :select, :sql_safety_net
-      base.alias_method_chain :select_rows, :sql_safety_net
-      base.alias_method_chain :columns, :sql_safety_net
-      base.alias_method_chain :active?, :sql_safety_net
-    end
-    
-    def active_with_sql_safety_net?
-      active = disable_sql_safety_net{active_without_sql_safety_net?}
-      if @logger && !active
-        @logger.warn("#{adapter_name} connection not active")
-      end
-      active
-    end
+    extend ActiveSupport::Concern
 
-    def columns_with_sql_safety_net(table_name, name = nil)
-      disable_sql_safety_net do
-        columns_without_sql_safety_net(table_name, name)
-      end
+    SELECT_SQL_PATTERN = /\A\s*SELECT\b/im.freeze
+    IGNORED_PAYLOADS = %w(SCHEMA EXPLAIN CACHE).freeze
+    
+    included do
+      alias_method_chain :select_rows, :sql_safety_net
+      alias_method_chain :select, :sql_safety_net
     end
     
     def select_rows_with_sql_safety_net(sql, name = nil, *args)
-      analyze_sql_safety_net_query(sql, name, *args) do
+      analyze_query(sql, name, []) do
         select_rows_without_sql_safety_net(sql, name, *args)
       end
     end
     
-    # Disable query analysis within a block.
-    def disable_sql_safety_net
-      save_disabled = Thread.current[:sql_safety_net_disable]
-      begin
-        Thread.current[:sql_safety_net_disable] = true
-        yield
-      ensure
-        Thread.current[:sql_safety_net_disable] = save_disabled
-      end
-    end
-    
-    def analyze_query(sql, *args)
-      # No op; other modules may redefine to analyze query plans
-    end
-    
-    def select_statement?(sql)
-      !!sql.match(SELECT_STATEMENT)
-    end
-    
     protected
-
+    
     def select_with_sql_safety_net(sql, name = nil, *args)
-      analyze_sql_safety_net_query(sql, name, *args) do
+      binds = args.first || []
+      analyze_query(sql, name, binds) do
         select_without_sql_safety_net(sql, name, *args)
       end
     end
     
-    private
     
-    def analyze_sql_safety_net_query(sql, name, *args)
-      if Thread.current[:sql_safety_net_disable]
-        yield
-      else
-        t = Time.now.to_f
-        query_results = nil
-        disable_sql_safety_net do
-          query_results = yield
+    def analyze_query(sql, name, binds)
+      queries = QueryAnalysis.current
+      if queries && sql.match(SELECT_SQL_PATTERN) && !IGNORED_PAYLOADS.include?(name)
+        start_time = Time.now
+        results = yield
+        elapsed_time = Time.now - start_time
+        
+        expanded_sql = sql
+        unless binds.empty?
+          sql = "#{sql} #{binds.collect{|col, val| [col.name, val]}.inspect}"
         end
-        elapsed_time = Time.now.to_f - t
-      
-        unless Thread.current[:sql_safety_net_disable]
-          query_info = Thread.current[:sql_safety_net_query_info]
-          if query_info
-            query_info.count += 1
-            query_info.selects += query_results.size
-          end
-          analysis = QueryAnalysis.current
-          if analysis
-            analysis.selects += 1
-            analysis.rows += query_results.size
-            analysis.elapsed_time += elapsed_time
-            if SqlSafetyNet.config.debug?
-              flagged = (@logger ? @logger.silence{analyze_query(sql, name, *args)} : analyze_query(sql, name, *args))
-              if elapsed_time * 1000 >= SqlSafetyNet.config.time_limit
-                flagged ||= {}
-                flagged[:flags] ||= []
-                flagged[:flags] << "query time exceeded #{SqlSafetyNet.config.time_limit} ms"
-              end
-              analysis.add_query(sql, name, query_results.size, elapsed_time, flagged)
-            end
-          end
+        rows = results.size
+        result_size = 0
+        results.each do |row|
+          values = row.is_a?(Hash) ? row.values : row
+          values.each{|val| result_size += val.to_s.size if val}
         end
-
-        query_results
+        cached = CacheStore.in_fetch_block?
+        sql_str = nil
+        if method(:to_sql).arity == 1
+          sql_str = (sql.is_a?(String) ? sql : to_sql(sql))
+        else
+          sql_str = to_sql(sql, binds)
+        end
+        query_info = QueryInfo.new(sql_str, :elapsed_time => elapsed_time, :rows => rows, :result_size => result_size, :cached => cached)
+        queries << query_info
+        
+        # If connection includes a query plan analyzer then alert on issues in the query plan.
+        if respond_to?(:sql_safety_net_analyze_query_plan)
+          query_info.alerts.concat(sql_safety_net_analyze_query_plan(sql, binds))
+        end
+        
+        query_info.alerts.each{|alert| ActiveRecord::Base.logger.debug(alert)} if ActiveRecord::Base.logger
+        
+        results
+      else
+        yield
       end
     end
+    
   end
 end

data/lib/sql_safety_net/explain_plan/mysql.rb

@@ -0,0 +1,33 @@
+module SqlSafetyNet
+  module ExplainPlan
+    # Include this module in your MySQL connection class to analyze the query plan generated by MySQL.
+    module Mysql
+      def sql_safety_net_analyze_query_plan(sql, binds)
+        alerts = []
+        config = SqlSafetyNet.config
+        explain_results = select("EXPLAIN #{sql}", "EXPLAIN", binds)
+        
+        explain_results.each do |row|
+          select_type = (row['select_type'] || '').downcase
+          type = (row['type'] || '').downcase
+          rows = row['rows'].to_i
+          extra = (row['Extra'] || '').downcase
+          key = row['key']
+          possible_keys = row['possible_keys']
+
+          alerts << "table scan on #{rows} rows" if (type.include?('all') && rows > config.table_scan_limit)
+          alerts << "no index used" if (key.blank? && rows > config.table_scan_limit)
+          alerts << "no index possible" if (possible_keys.blank? && rows > config.table_scan_limit)
+          alerts << "dependent subquery" if select_type.include?('dependent')
+          alerts << "uncacheable subquery" if select_type.include?('uncacheable')
+          alerts << "full scan on null key" if extra.include?('full scan on null key')
+          alerts << "uses temporary table for #{rows} rows" if extra.include?('using temporary') && rows > config.temporary_table_limit
+          alerts << "uses filesort for #{rows} rows" if extra.include?('filesort') && rows > config.filesort_limit
+          alerts << "examined #{rows} rows" if rows > config.examined_rows_limit
+        end
+        
+        alerts
+      end
+    end
+  end
+end

data/lib/sql_safety_net/explain_plan/postgresql.rb

@@ -0,0 +1,30 @@
+module SqlSafetyNet
+  module ExplainPlan
+    # Include this module in your PostgreSQL connection class to analyze the query plan. It will just
+    # look for excess row counts in the number of rows examined or scanned. The row counts provided by
+    # PostgreSQL are just estimates, so take any alerts with a grain of salt.
+    module Postgresql
+      def sql_safety_net_analyze_query_plan(sql, binds)
+        alerts = []
+        config = SqlSafetyNet.config
+        explain_results = select("EXPLAIN #{sql}", "EXPLAIN", binds)
+        query_plan = explain_results.collect{|r| r.values.first}
+        limit = nil
+        
+        query_plan.each do |row|
+          row_count = row.match(/\brows=(\d+)/) ? $~[1].to_i : 0
+          row_count = [limit, row_count].min if limit
+          if row =~ /^(\s|(->))*Limit\s/
+            limit = row_count
+          elsif row =~ /^(\s|(->))*Seq Scan/
+            alerts << "table scan on ~#{row_count} rows" if row_count > config.table_scan_limit
+          elsif row_count > config.examined_rows_limit
+            alerts << "examined ~#{row_count} rows"
+          end
+        end
+        
+        alerts
+      end
+    end
+  end
+end

data/lib/sql_safety_net/explain_plan.rb

@@ -0,0 +1,24 @@
+module SqlSafetyNet
+  # Query plan analysis is supported out of the box for MySQL and PostgreSQL.
+  #
+  # If you wish to implement it for another database, you'll need to create a module that defines
+  # the +sql_safety_net_analyze_query_plan+ method and takes arguments for the sql to execute and
+  # an array of bind values.
+  module ExplainPlan
+    autoload :Mysql, File.expand_path("../explain_plan/mysql.rb", __FILE__)
+    autoload :Postgresql, File.expand_path("../explain_plan/postgresql.rb", __FILE__)
+    
+    class << self
+      # Enable query plan analysize on a connection adapter class. The explain_plan_analyzer argument
+      # can either be <tt>:mysql</tt>, <tt>:postgresql</tt> or a module that defines a
+      # <tt>sql_safety_net_analyze_query_plan(sql, binds)</tt> method.
+      def enable_on_connection_adapter!(connection_adapter_class, explain_plan_analyzer)
+        if explain_plan_analyzer.is_a?(Symbol)
+          class_name = explain_plan_analyzer.to_s.camelize
+          explain_plan_analyzer = ExplainPlan.const_get(class_name)
+        end
+        connection_adapter_class.send(:include, explain_plan_analyzer) unless connection_adapter_class.include?(explain_plan_analyzer)
+      end
+    end
+  end
+end

data/lib/sql_safety_net/formatter.rb

@@ -0,0 +1,178 @@
+require 'rack'
+
+module SqlSafetyNet
+  # Formatter to output information from a query analysis in various formats.
+  class Formatter
+    attr_reader :analysis
+    
+    def initialize(analysis)
+      @analysis = analysis
+    end
+    
+    def to_html
+      uncached_analysis = QueryAnalysis.new
+      cached_analysis = QueryAnalysis.new
+      analysis.queries.each{ |query| query.cached? ? cached_analysis << query : uncached_analysis << query }
+      
+      ok_color = "#060"
+      warn_color = "#900"
+      cache_warn_color = "#A80"
+      theme_color = ok_color
+      theme_color = cache_warn_color if uncached_analysis.flagged?
+      theme_color = warn_color if analysis.flagged?
+      close_js = "document.getElementById('_sql_safety_net_').style.display = 'none'"
+      toggle_queries_js = "document.getElementById('_sql_safety_net_queries_').style.display = (document.getElementById('_sql_safety_net_queries_').style.display == 'block' ? 'none' : 'block')"
+      
+      tag(:div, :id => "_sql_safety_net_", :style => div_style(SqlSafetyNet.config.style)) do
+        tag(:div, :style => "padding:4px; background-color:#{theme_color}; font-weight:bold; color:#FFF;") do
+          tag(:div) do
+            tag(:a, :href => "javascript:void(#{close_js})", :style => "float:right; display:block; text-decoration:none") do
+              tag(:span, "&times;", :style => "color:#FFF; text-decoration:none; font-weight:bold;")
+            end
+            tag(:a, :href => "javascript:void(#{toggle_queries_js})", :style => "text-decoration:none;") do
+              tag(:span, "#{analysis.flagged? ? 'SQL WARNING' : 'SQL INFO'} &raquo;", :style => "color:#FFF; text-decoration:none; font-weight:bold;")
+            end
+          end
+          tag(:div, summary, :style => "font-weight:normal;")
+        end
+        
+        tag(:div, :id => "_sql_safety_net_queries_", :style => "display:none; border:1px solid #{theme_color}; background-color:#FFF; color:#000; overflow:auto; max-height:500px;") do
+          tag(:div, :style => "padding-left:4px; padding-right:4px;") do
+            if cached_analysis.total_queries > 0
+              tag(:div, :style => "margin-top:5px; margin-bottom:5px;") do
+                tag(:div, "Uncached", :style => "font-weight:bold;")
+                tag(:div, Formatter.new(uncached_analysis).summary)
+              end
+              
+              tag(:div, :style => "margin-top:5px; margin-bottom:5px; color:#066;") do
+                tag(:div, "Cached", :style => "font-weight:bold;")
+                tag(:div, Formatter.new(cached_analysis).summary)
+              end
+            end
+          
+            warning_style = "color:#{warn_color}; margin-top:5px; margin-bottom:5px;"
+            tag(:div, "WARNING: #{analysis.total_queries} queries", :style => warning_style) if analysis.too_many_queries?
+            tag(:div, "WARNING: #{analysis.rows} rows returned", :style => warning_style) if analysis.too_many_rows?
+            tag(:div, "WARNING: #{sprintf('%0.1f', analysis.result_size / 1024.0)}K returned", :style => warning_style) if analysis.results_too_big?
+            tag(:div, "WARNING: queries took #{(analysis.elapsed_time * 1000).round} ms", :style => warning_style) if analysis.too_much_time?
+            tag(:div, "WARNING: alerts on #{analysis.alerted_queries} queries", :style => warning_style) if analysis.alerts?
+          end
+          
+          analysis.queries.each do |query|
+            color = ok_color
+            if query.alerts?
+              color = (query.cached? ? cache_warn_color : warn_color)
+            end
+            tag(:div, :style => "color:#{color}; border-top:1px solid #CCC; padding:8px 4px;#{' background-color:#DEE;' if query.cached?}") do
+              tag(:div, "CACHED", :style => "color:#066;") if query.cached?
+              query_info = "#{query.rows} row#{'s' if query.rows != 1} returned (#{sprintf('%0.1f', query.result_size / 1024.0)}K) in #{(query.elapsed_time * 1000).round} ms"
+              tag(:div, query_info, :style => "margin-bottom:5px;")
+              if query.alerts?
+                tag(:div, :style => "margin-bottom:5px;") do
+                  query.alerts.each do |alert|
+                    tag(:div, alert, :style => "margin-bottom:2px;")
+                  end
+                end
+              end
+              tag(:div, query.sql, :style => "color:#666")
+            end
+          end
+        end
+      end
+    end
+    
+    def to_s
+      uncached_analysis = QueryAnalysis.new
+      cached_analysis = QueryAnalysis.new
+      analysis.queries.each{ |query| query.cached? ? cached_analysis << query : uncached_analysis << query }
+      lines = []
+      lines << "#{analysis.flagged? ? 'SQL WARNING' : 'SQL INFO'}: #{summary}"
+      if cached_analysis.total_queries > 0
+        lines << "UNCACHED: #{Formatter.new(uncached_analysis).summary}"
+        lines << "CACHED: #{Formatter.new(cached_analysis).summary}"
+      end
+      lines << "WARNING: #{analysis.total_queries} queries" if analysis.too_many_queries?
+      lines << "WARNING: #{analysis.rows} rows returned" if analysis.too_many_rows?
+      lines << "WARNING: #{analysis.result_size}K returned" if analysis.results_too_big?
+      lines << "WARNING: queries took #{(analysis.elapsed_time * 1000).round} ms" if analysis.too_much_time?
+      lines << "WARNING: alerts on #{analysis.alerted_queries} queries" if analysis.alerts?
+      analysis.queries.each do |query|
+        lines << "-----------------"
+        lines << "CACHED" if query.cached?
+        lines << "#{query.rows} row#{'s' if query.rows != 1} returned (#{sprintf('%0.1f', query.result_size / 1024.0)}K) in #{(query.elapsed_time * 1000).round} ms"
+        lines.concat(query.alerts)
+        lines << "#{query.sql}"
+      end
+      lines.join("\n")
+    end
+    
+    def summary
+      queries = analysis.total_queries
+      rows = analysis.rows
+      kilobytes = analysis.result_size / 1024.0
+      "#{queries} #{queries == 1 ? 'query' : 'queries'}, #{analysis.rows} row#{rows == 1 ? '' : 's'}, #{sprintf("%0.1f", kilobytes)}K, #{(analysis.elapsed_time * 1000).round}ms"
+    end
+    
+    # Turn a hash of styles into a proper CSS style attribute. The style will use specified defaults
+    # to make the div appear in the top, right corner of the page at 160px wide.
+    def div_style(style)
+      default_style = {
+        "font-family" => "sans-serif",
+        "font-size" => "10px",
+        "font-weight" => "normal",
+        "position" => "fixed",
+        "z-index" => "999999",
+        "text-align" => "left",
+        "line-height" => "100%",
+        "width" => "200px"
+      }
+      
+      style = default_style.merge(style)
+      style.delete_if{|key, value| value.blank? }
+      
+      # Ensure a default positioning
+      if %w(fixed static absolute).include?(style["position"])
+        style["top"] = "5px" if style["top"].blank? && style["bottom"].blank?
+        style["right"] = "5px" if style["right"].blank? && style["left"].blank?
+      end
+      
+      css_style = ""
+      style.each do |name, value|
+        css_style << "#{name}:#{value};"
+      end
+      css_style
+    end
+    
+    private
+    
+    # Helper to generate an HTML tag.
+    def tag(name, *args)
+      attributes = args.extract_options!
+      body = args.first
+      
+      @buffer ||= []
+      output = ""
+      @buffer.push(output)
+      output << "<#{name}"
+      if attributes
+        attributes.each do |key, value|
+          output << " #{key}=\"#{Rack::Utils.escape_html(value)}\""
+        end
+      end
+      if block_given? || body
+        output << ">"
+        if block_given?
+          yield
+        else
+          output << body if body
+        end
+        output << "</#{name}>"
+      else
+        output << "/>"
+      end
+      @buffer.pop
+      @buffer.last << output unless @buffer.empty?
+      output
+    end
+  end
+end