sql_safety_net 1.1.11

data/README.rdoc

@@ -0,0 +1,19 @@
+= SQL Safety Net
+
+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.
+
+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.
+
+== Example
+
+Add this code to an initializer:
+
+  SqlSafetyNet.init_rails
+
+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:
+
+  SqlSafetyNet.init_rails do |config|
+    config.query_limit = 20
+  end
+
+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.

data/Rakefile

@@ -0,0 +1,40 @@
+require 'rubygems'
+require 'rake'
+
+desc 'Default: run unit tests'
+task :default => :test
+
+begin
+  require 'rspec'
+  require 'rspec/core/rake_task'
+  desc 'Run the unit tests'
+  RSpec::Core::RakeTask.new(:test)
+rescue LoadError
+  task :test do
+    raise "You must have rspec 2.0 installed to run the tests"
+  end
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "sql_safety_net"
+    gem.summary = %Q{Debug SQL statements in ActiveRecord}
+    gem.description = %Q{Debug SQL statements in ActiveRecord by displaying warnings on bad queries.}
+    gem.authors = ["Brian Durand"]
+    gem.email = ["mdobrota@tribune.com", "ddpr@tribune.com"]
+    gem.files = FileList["lib/**/*", "spec/**/*", "README.rdoc", "Rakefile", "License.txt"].to_a
+    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_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
+rescue LoadError
+end

data/lib/sql_safety_net/cache_store.rb

@@ -0,0 +1,19 @@
+module SqlSafetyNet
+  # Hook into ActiveSupport::Cache to set a caching flag on the QueryAnalysis whenever +fetch+ is called with a block.
+  module CacheStore
+    def self.included(base)
+      base.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
+      begin
+        analysis.caching = true if analysis
+        fetch_without_sql_safety_net(*args, &block)
+      ensure
+        analysis.caching = saved_val if analysis
+      end
+    end
+  end
+end

data/lib/sql_safety_net/configuration.rb

@@ -0,0 +1,57 @@
+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.
+  class Configuration
+    attr_accessor :table_scan_limit, :temporary_table_limit, :filesort_limit, :return_rows_limit, :examine_rows_limit, :query_limit, :time_limit, :position
+    
+    def initialize
+      @debug = false
+      @header = false
+      @table_scan_limit = 100
+      @temporary_table_limit = 100
+      @filesort_limit = 100
+      @return_rows_limit = 100
+      @examine_rows_limit = 5000
+      @query_limit = 10
+      @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
+    end
+  end
+end

data/lib/sql_safety_net/connection_adapter/mysql_adapter.rb

@@ -0,0 +1,43 @@
+module SqlSafetyNet
+  module ConnectionAdapter
+    # Logic for analyzing MySQL query plans.
+    module MysqlAdapter
+      def analyze_query(sql, name, *args)
+        if select_statement?(sql)
+          query_plan = select_without_sql_safety_net("EXPLAIN #{sql}", "EXPLAIN", *args)
+          query_plan_flags = analyze_query_plan(query_plan)
+          unless query_plan_flags.empty?
+            @logger.debug("Flagged query plan #{name} (#{query_plan_flags.join(', ')}): #{query_plan.inspect}") if @logger
+            return {:query_plan => query_plan, :flags => query_plan_flags}
+          end
+        end
+      end
+
+      private
+    
+      def analyze_query_plan(query_plan)
+        flagged = []
+        query_plan.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']
+
+          flagged << 'table scan' if (type.include?('all') and rows > SqlSafetyNet.config.table_scan_limit)
+          flagged << 'fulltext search' if type.include?('fulltext')
+          flagged << 'no index used' if (key.blank? and rows > SqlSafetyNet.config.table_scan_limit)
+          flagged << 'no indexes possible' if (possible_keys.blank? and rows > SqlSafetyNet.config.table_scan_limit)
+          flagged << 'dependent subquery' if select_type.include?('dependent')
+          flagged << 'uncacheable subquery' if select_type.include?('uncacheable')
+          flagged << 'full scan on null key' if extra.include?('full scan on null key')
+          flagged << "uses temporary table for #{rows} rows" if extra.include?('using temporary') and rows > SqlSafetyNet.config.temporary_table_limit
+          flagged << "uses filesort for #{rows} rows" if extra.include?('filesort') and rows > SqlSafetyNet.config.filesort_limit
+          flagged << "examines #{rows} rows" if rows > SqlSafetyNet.config.examine_rows_limit
+        end
+        return flagged
+      end
+    end
+  end
+end

data/lib/sql_safety_net/connection_adapter/postgresql_adapter.rb

@@ -0,0 +1,48 @@
+module SqlSafetyNet
+  module ConnectionAdapter
+    # Logic for analyzing a query plan from PostgreSQL. These plans are not terribly useful and sometimes
+    # the statistics are off, so take them with a grain of salt.
+    module PostgreSQLAdapter
+      def analyze_query(sql, name, *args)
+        if select_statement?(sql)
+          query_plan = select_without_sql_safety_net("EXPLAIN #{sql}", "EXPLAIN", *args)
+          query_plan_flags = analyze_query_plan(query_plan)
+          unless query_plan_flags.empty?
+            @logger.debug("Flagged query plan #{name} (#{query_plan_flags.join(', ')}): #{query_plan.inspect}") if @logger
+            return {:query_plan => query_plan, :flags => query_plan_flags}
+          end
+        end
+      end
+
+      private
+      
+      def analyze_query_plan(query_plan)
+        query_plan = query_plan.collect{|r| r.values.first}
+        flagged = []
+        limit = nil
+        query_plan.each do |row|
+          row_count = query_plan_rows_value(row)
+          row_count = [limit, row_count].min if limit
+          if row =~ /^(\s|(->))*Limit\s/
+            limit = row_count
+          elsif row =~ /^(\s|(->))*Seq Scan/
+            flagged << 'table scan' if row_count > SqlSafetyNet.config.table_scan_limit
+          elsif row_count > SqlSafetyNet.config.examine_rows_limit
+            flagged << "examines #{row_count} rows"
+          end
+        end
+        return flagged
+      end
+    
+      private
+    
+      def query_plan_rows_value(plan_row)
+        if plan_row.match(/\brows=(\d+)/)
+          return $~[1].to_i
+        else
+          return 0
+        end
+      end
+    end
+  end
+end

data/lib/sql_safety_net/connection_adapter.rb

@@ -0,0 +1,103 @@
+module SqlSafetyNet
+  # Logic to be mixed into connection adapters allowing them to analyze 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
+
+    def columns_with_sql_safety_net(table_name, name = nil)
+      disable_sql_safety_net do
+        columns_without_sql_safety_net(table_name, name)
+      end
+    end
+    
+    def select_rows_with_sql_safety_net(sql, name = nil, *args)
+      analyze_sql_safety_net_query(sql, name, *args) 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
+        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
+        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
+        end
+
+        query_results
+      end
+    end
+  end
+end

data/lib/sql_safety_net/query_analysis.rb

@@ -0,0 +1,69 @@
+module SqlSafetyNet
+  # Analysis container for the sql queries in a context.
+  class QueryAnalysis
+    attr_accessor :selects, :rows, :elapsed_time
+    attr_reader :flagged_queries, :non_flagged_queries
+    attr_writer :caching
+
+    def initialize
+      @selects = 0
+      @rows = 0
+      @elapsed_time = 0.0
+      @flagged_queries = []
+      @non_flagged_queries = []
+      @caching = false
+    end
+
+    # Analyze all queries within a block.
+    def self.analyze
+      Thread.current[:sql_safety_net] = new
+      begin
+        yield
+        return current
+      ensure
+        clear
+      end
+    end
+
+    # Get the current analysis object.
+    def self.current
+      Thread.current[:sql_safety_net]
+    end
+
+    # Clear all query information from the current analysis.
+    def self.clear
+      Thread.current[:sql_safety_net] = nil
+    end
+    
+    def caching?
+      @caching
+    end
+    
+    def flagged?
+      too_many_selects? || too_many_rows? || flagged_queries?
+    end
+    
+    def too_many_selects?
+      selects > SqlSafetyNet.config.query_limit
+    end
+
+    def too_many_rows?
+      rows > SqlSafetyNet.config.return_rows_limit
+    end
+
+    def flagged_queries?
+      !flagged_queries.empty?
+    end
+    
+    def add_query(sql, name, rows, elapsed_time, flagged)
+      info = {:sql => sql, :name => name, :rows => rows, :elapsed_time => elapsed_time, :cached => caching?}
+      if flagged.blank?
+        non_flagged_queries << info
+      else
+        info[:query_plan] = flagged[:query_plan]
+        info[:flags] = flagged[:flags]
+        flagged_queries << info
+      end
+    end
+  end
+end

data/lib/sql_safety_net/rack_handler.rb

@@ -0,0 +1,196 @@
+require 'rack'
+
+module SqlSafetyNet
+  # This Rack handler must be added to the middleware stack in order for query analysis to be output.
+  # If the configuration option for debug is set to true, it will add response headers indicating information
+  # about the queries executed in the course of the request.
+  class RackHandler
+    
+    X_SQL_SAFETY_NET_HEADER = "X-SqlSafetyNet".freeze
+    HTML_CONTENT_TYPE_PATTERN = /text\/(x?)html/i
+    XML_CONTENT_TYPE_PATTERN = /application\/xml/i
+    
+    def initialize(app, logger = Rails.logger)
+      @app = app
+      @logger = logger
+    end
+    
+    def call(env)
+      response = nil
+      analysis = QueryAnalysis.analyze do
+        response = @app.call(env)
+      end
+      
+      if @logger && (analysis.too_many_selects? || analysis.too_many_rows?)
+        request = Rack::Request.new(env)
+        @logger.warn("Excess database usage: request generated #{analysis.selects} queries and returned #{analysis.rows} rows [#{request.request_method} #{request.url}]")
+      end
+      
+      # Add a response header that contains a summary of the debug info
+      if SqlSafetyNet.config.header? || SqlSafetyNet.config.debug?
+        headers = response[1]
+        headers[X_SQL_SAFETY_NET_HEADER] = "selects=#{analysis.selects}; rows=#{analysis.rows}; elapsed_time=#{(analysis.elapsed_time * 1000).round}; flagged_queries=#{analysis.flagged_queries.size}" if headers
+      end
+      
+      if SqlSafetyNet.config.debug?
+        wrapped_response = Rack::Response.new(response[2], response[0], response[1])
+        if analysis.flagged? || SqlSafetyNet.config.always_show?
+          request = Rack::Request.new(env)
+          # Ignore Ajax calls
+          unless request.xhr?
+            # Only if content type is text/html
+            type = wrapped_response.content_type
+            if type.nil? || type.to_s.match(HTML_CONTENT_TYPE_PATTERN)
+              wrapped_response.write(flagged_sql_html(analysis))
+            elsif type.to_s.match(XML_CONTENT_TYPE_PATTERN)
+              wrapped_response.write(xml_comment(flagged_sql_text(analysis)))
+            end
+          end
+        end
+        response = wrapped_response.finish
+      end
+      
+      response
+    end
+
+    def flagged_sql_html(analysis)
+      flagged_html = ''
+      cached_selects = 0
+      cached_rows = 0
+      cached_elapsed_time = 0.0
+      
+      if analysis.flagged_queries?
+        flagged_html << '<div style="color:#C00;">'
+        flagged_html << "<div style=\"font-weight:bold; margin-bottom:10px;\">#{analysis.flagged_queries.size == 1 ? 'This query has' : "These #{analysis.flagged_queries.size} queries have"} flagged query plans:</div>"
+        analysis.flagged_queries.each do |query|
+          if query[:cached]
+            cached_selects += 1
+            cached_rows += query[:rows]
+            cached_elapsed_time += query[:elapsed_time]
+          end
+          flagged_html << '<div style="margin-bottom:10px;">'
+          flagged_html << "<div style=\"font-weight:bold; margin-bottom: 5px;\">#{query[:rows]} rows returned, #{(query[:elapsed_time] * 1000).round} ms#{ " <span style='color:teal;'>(CACHED)</span>" if query[:cached]}</div>"
+          flagged_html << "<div style=\"font-weight:bold; margin-bottom: 5px;\">#{query[:flags].join(', ')}</div>"
+          flagged_html << "<div style=\"margin-bottom: 5px;\">#{Rack::Utils.escape_html(query[:sql])}</div>"
+          flagged_html << "<div style=\"margin-bottom: 5px;\">Query Plan: #{Rack::Utils.escape_html(query[:query_plan].inspect)}</div>" if query[:query_plan]
+          flagged_html << '</div>'
+        end
+        flagged_html << '</div>'
+      end
+      
+      if analysis.too_many_selects? || analysis.too_many_rows? || SqlSafetyNet.config.always_show?
+        flagged_html << "<div style=\"font-weight:bold; margin-bottom:10px;\">#{analysis.non_flagged_queries.size == 1 ? 'This query' : "These #{analysis.non_flagged_queries.size} queries"} did not have flagged query plans:</div>"
+        analysis.non_flagged_queries.each do |query|
+          if query[:cached]
+            cached_selects += 1
+            cached_rows += query[:rows]
+            cached_elapsed_time += query[:elapsed_time]
+          end
+          flagged_html << '<div style="margin-bottom:10px;">'
+          flagged_html << "<div style=\"font-weight:bold; margin-bottom: 5px;\">#{query[:rows]} rows returned, #{(query[:elapsed_time] * 1000).round} ms#{ " <span style='color:teal;'>(CACHED)</span>" if query[:cached]}</div>"
+          flagged_html << "<div style=\"margin-bottom: 5px;\">#{Rack::Utils.escape_html(query[:sql])}</div>"
+          flagged_html << '</div>'
+        end
+      end
+
+      color_scheme = '#060'
+      if analysis.flagged_queries?
+        color_scheme = '#C00' 
+      elsif analysis.flagged?
+        color_scheme = '#C60'
+      end
+      label = (analysis.flagged?) ? 'SQL WARNING' : 'SQL INFO'
+      
+      cache_html = nil
+      if cached_selects > 0
+        cache_html = <<-EOS
+          <div style="margin-bottom:10px; font-weight:bold;">
+            Some of the queries will be cached.
+            <div style="color:#C00;">
+              Uncached: #{analysis.selects - cached_selects} selects, #{analysis.rows - cached_rows} rows, #{((analysis.elapsed_time - cached_elapsed_time) * 1000).round} ms
+            </div> 
+            <div style="color:teal;">
+              Cached: #{cached_selects} selects, #{cached_rows} rows, #{(cached_elapsed_time * 1000).round} ms
+            </div> 
+          </div>
+        EOS
+      end
+      
+      <<-EOS
+        <div id="sql_safety_net_warning" style="font-family:sans-serif; font-size:10px; position:fixed; z-index:999999999; text-align:left; #{SqlSafetyNet.config.position}">
+          <div style="background-color:#{color_scheme}; color:#FFF; padding:4px; width:160px; float:right;">
+            <a href="javascript:void(document.getElementById('sql_safety_net_warning').style.display = 'none')" style="text-decoration:none; float:right; display:block; font-size:9px;"><span style="color:#FFF; text-decoration:none; font-weight:bold;">&times;</span></a>
+            <a href="javascript:void(document.getElementById('sql_safety_net_flagged_queries').style.display = (document.getElementById('sql_safety_net_flagged_queries').style.display == 'block' ? 'none' : 'block'))" style="text-decoration:none;">
+              <span style="color:#FFF; text-decoration:none; font-weight:bold;">#{label} &raquo;</span>
+            </a>
+            <div>#{analysis.selects} selects, #{analysis.rows} rows, #{(analysis.elapsed_time * 1000).round} ms</div>
+          </div>
+          <div id="sql_safety_net_flagged_queries" style="clear:right; display:none; width:500px; padding:2px; border:1px solid #{color_scheme}; background-color:#FFF; color:#000; overflow:auto; max-height:500px;">
+            <div style="margin-bottom:10px; font-weight:bold;">
+              There are #{analysis.selects} queries on this page that return #{analysis.rows} rows and took #{(analysis.elapsed_time * 1000).round} ms to execute.
+            </div>
+            #{cache_html}
+            #{flagged_html}
+          </div>
+        </div>
+      EOS
+    end
+
+    def flagged_sql_text(analysis)
+      flagged_text = ''
+      cached_selects = 0
+      cached_rows = 0
+      cached_elapsed_time = 0.0
+      
+      if analysis.flagged_queries?
+        flagged_text << "#{analysis.flagged_queries.size == 1 ? 'This query has' : "These #{analysis.flagged_queries.size} queries have"} flagged query plans:\n\n"
+        analysis.flagged_queries.each do |query|
+          if query[:cached]
+            cached_selects += 1
+            cached_rows += query[:rows]
+            cached_elapsed_time += query[:elapsed_time]
+          end
+          flagged_text << "#{query[:rows]} rows returned, #{(query[:elapsed_time] * 1000).round} ms#{ " (CACHED)" if query[:cached]}\n"
+          flagged_text << "#{query[:flags].join(', ')}\n\n"
+          flagged_text << "#{query[:sql]}\n\n"
+          flagged_text << "Query Plan: #{Rack::Utils.escape_html(query[:query_plan].inspect)}\n" if query[:query_plan]
+          flagged_text << "\n"
+        end
+        flagged_text << "\n"
+      end
+      
+      if analysis.too_many_selects? || analysis.too_many_rows? || SqlSafetyNet.config.always_show?
+        flagged_text << "#{analysis.non_flagged_queries.size == 1 ? 'This query' : "These #{analysis.non_flagged_queries.size} queries"} did not have flagged query plans:\n\n"
+        analysis.non_flagged_queries.each do |query|
+          if query[:cached]
+            cached_selects += 1
+            cached_rows += query[:rows]
+            cached_elapsed_time += query[:elapsed_time]
+          end
+          flagged_text << "#{query[:rows]} rows returned, #{(query[:elapsed_time] * 1000).round} ms#{ " (CACHED)" if query[:cached]}\n\n"
+          flagged_text << "#{query[:sql]}\n\n"
+          flagged_text << "\n"
+        end
+      end
+
+      label = (analysis.flagged?) ? 'SQL WARNING' : 'SQL INFO'
+      
+      cache_text = ""
+      if cached_selects > 0
+        cache_text << "Some of the queries will be cached.\n\n"
+        cache_text << "Uncached: #{analysis.selects - cached_selects} selects, #{analysis.rows - cached_rows} rows, #{((analysis.elapsed_time - cached_elapsed_time) * 1000).round} ms\n"
+        cache_text << "Cached: #{cached_selects} selects, #{cached_rows} rows, #{(cached_elapsed_time * 1000).round} ms\n\n"
+      end
+      
+      text = "SqlSafetyNet\n\n"
+      text << "There are #{analysis.selects} queries on this page that return #{analysis.rows} rows and took #{(analysis.elapsed_time * 1000).round} ms to execute.\n\n"
+      text << cache_text
+      text << flagged_text
+      text
+    end
+    
+    def xml_comment(text)
+      "<!-- #{text.gsub('-->', '\\-\\->')} -->"
+    end
+  end
+end

data/lib/sql_safety_net.rb

@@ -0,0 +1,27 @@
+require 'active_record'
+require 'action_controller'
+
+# Collects and displays debugging information about SQL statements.
+module SqlSafetyNet
+  autoload :CacheStore, File.expand_path('../sql_safety_net/cache_store', __FILE__)
+  autoload :Configuration, File.expand_path('../sql_safety_net/configuration', __FILE__)
+  autoload :ConnectionAdapter, File.expand_path('../sql_safety_net/connection_adapter', __FILE__)
+  autoload :QueryAnalysis, File.expand_path('../sql_safety_net/query_analysis', __FILE__)
+  autoload :RackHandler, File.expand_path('../sql_safety_net/rack_handler', __FILE__)
+  
+  class << self
+    # Get the configuration for the safety net.
+    def config
+      @config ||= SqlSafetyNet::Configuration.new
+    end
+    
+    def init_rails
+      SqlSafetyNet.config.enable_on(ActiveRecord::Base.connection.class)
+      if Rails.env == "development"
+        SqlSafetyNet.config.debug = true
+        ActiveSupport::Cache::Store.send(:include, CacheStore)
+      end
+      Rails.configuration.middleware.use(SqlSafetyNet::RackHandler)
+    end
+  end
+end

data/spec/cache_store_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe SqlSafetyNet::CacheStore do
+  let(:cache){ ActiveSupport::Cache::MemoryStore.new }
+  
+  it "should set the caching flag on the current query analysis when fetching with a block" do
+    SqlSafetyNet::QueryAnalysis.analyze do
+      SqlSafetyNet::QueryAnalysis.current.caching?.should == false
+      val = cache.fetch("key") do
+        SqlSafetyNet::QueryAnalysis.current.caching?.should == true
+        "woot"
+      end
+      val.should == "woot"
+    end
+  end
+  
+  it "should fetch properly even when there is not current query analysis" do
+    SqlSafetyNet::QueryAnalysis.current.should == nil
+    val = cache.fetch("key") do
+      SqlSafetyNet::QueryAnalysis.current.should == nil
+      "woot"
+    end
+    val.should == "woot"
+  end
+  
+end