sql_safety_net 1.1.11 → 2.0.0

data/lib/sql_safety_net/middleware.rb

@@ -0,0 +1,41 @@
+require 'rack'
+
+module SqlSafetyNet
+  # Rack middleware for analyzing queries on a request.
+  #
+  # The X-SqlSafetyNet header will be set with summary info about the queries.
+  #
+  # If the request responds with HTML and the request queries are flagged or if the +always_show+
+  # option is set, debugging info will be injected into the page.
+  class Middleware
+    HTML_CONTENT_TYPE = /text\/(x?)html/i.freeze
+    
+    def initialize(app)
+      @app = app
+    end
+    
+    def call(env)
+      QueryAnalysis.capture do |analysis|
+        response = @app.call(env)
+        unless analysis.queries.empty?
+          formatter = Formatter.new(analysis)
+          Rails.logger.debug(formatter.to_s) if ActiveRecord::Base.logger
+          request = Rack::Request.new(env)
+          wrapped_response = Rack::Response.new(response[2], response[0], response[1])
+          wrapped_response["X-SqlSafetyNet"] = formatter.summary
+        
+          if SqlSafetyNet.config.always_show || analysis.flagged?
+            unless request.xhr? || analysis.queries.empty?
+              content_type = wrapped_response.content_type
+              if content_type && content_type.match(HTML_CONTENT_TYPE) && !wrapped_response.redirection?
+                wrapped_response.write(formatter.to_html)
+              end
+            end
+          end
+          response = wrapped_response.finish
+        end
+        response
+      end
+    end
+  end
+end

data/lib/sql_safety_net/query_analysis.rb

@@ -1,69 +1,72 @@
 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
-
+    attr_reader :elapsed_time, :rows, :result_size, :queries
+    
+    class << self
+      # Get the current analysis object in scope.
+      def current
+        Thread.current[:sql_safety_net_request_queries]
+      end
+      
+      # Capture queries in a block for analysis. Within the block the +current+ method
+      # can be called to the the current analysis object.
+      def capture
+        save_val = Thread.current[:sql_safety_net_request_queries]
+        begin
+          queries = new
+          Thread.current[:sql_safety_net_request_queries] = queries
+          yield queries
+        ensure
+          Thread.current[:sql_safety_net_request_queries] = save_val
+        end
+      end
+    end
+    
     def initialize
-      @selects = 0
-      @rows = 0
+      @queries = []
       @elapsed_time = 0.0
-      @flagged_queries = []
-      @non_flagged_queries = []
-      @caching = false
+      @rows = 0
+      @result_size = 0
     end
-
-    # Analyze all queries within a block.
-    def self.analyze
-      Thread.current[:sql_safety_net] = new
-      begin
-        yield
-        return current
-      ensure
-        clear
-      end
+    
+    # Add a QueryInfo object to the analysis.
+    def <<(query_info)
+      @queries << query_info
+      @elapsed_time += query_info.elapsed_time
+      @rows += query_info.rows
+      @result_size += query_info.result_size
     end
-
-    # Get the current analysis object.
-    def self.current
-      Thread.current[:sql_safety_net]
+    
+    def total_queries
+      queries.size
     end
-
-    # Clear all query information from the current analysis.
-    def self.clear
-      Thread.current[:sql_safety_net] = nil
+    
+    def alerted_queries
+      queries.select{|query| query.alerts?}.size
     end
     
-    def caching?
-      @caching
+    def alerts?
+      queries.any?{|query| query.alerts?}
     end
     
-    def flagged?
-      too_many_selects? || too_many_rows? || flagged_queries?
+    def too_many_rows?
+      rows > SqlSafetyNet.config.returned_rows_limit
     end
     
-    def too_many_selects?
-      selects > SqlSafetyNet.config.query_limit
+    def too_many_queries?
+      total_queries > SqlSafetyNet.config.query_limit
     end
-
-    def too_many_rows?
-      rows > SqlSafetyNet.config.return_rows_limit
+    
+    def results_too_big?
+      result_size > SqlSafetyNet.config.result_size_limit
     end
-
-    def flagged_queries?
-      !flagged_queries.empty?
+    
+    def too_much_time?
+      elapsed_time > SqlSafetyNet.config.elapsed_time_limit
     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
+    def flagged?
+      alerts? || too_many_rows? || too_many_queries? || results_too_big? || too_much_time?
     end
   end
 end

data/lib/sql_safety_net/query_info.rb

@@ -0,0 +1,33 @@
+module SqlSafetyNet
+  # Class to store information about queries.
+  class QueryInfo
+    attr_reader :sql, :elapsed_time, :rows, :result_size, :alerts
+    
+    def initialize(sql, options = {})
+      @sql = sql
+      @elapsed_time = options[:elapsed_time] || 0.0
+      @rows = options[:rows] || 0
+      @result_size = options[:result_size] || 0
+      @alerts = options[:alerts] || []
+      @cached = !!options[:cached]
+      analyze!
+    end
+    
+    def cached?
+      @cached
+    end
+    
+    def alerts?
+      !alerts.empty?
+    end
+    
+    private
+    
+    def analyze!
+      config = SqlSafetyNet.config
+      alerts << "query took #{elapsed_time * 1000} ms" if elapsed_time > config.elapsed_time_limit
+      alerts << "query returned #{rows}" if rows > config.returned_rows_limit
+      alerts << "query returned ~#{result_size} bytes" if result_size > config.result_size_limit
+    end
+  end
+end

data/lib/sql_safety_net.rb

@@ -1,27 +1,78 @@
-require 'active_record'
-require 'action_controller'
-
-# Collects and displays debugging information about SQL statements.
+# Root module for the gem.
+#
+# This module provide access to the singleton configuration object as well as hooks
+# for enabling features.
+#
+# Since the analysis code is intended only for development mode
+# it is not enabled by default. You can enable it by calling the enable methods
+# in an config/initializers file:
+#
+#   if Rails.env.development?
+#     SqlSafetyNet.enable_on_cache_store!(ActiveSupport::Cache::Store)
+#     SqlSafetyNet.enable_on_connection_adapter!(ActiveRecord::Base.connection.class)
+#     SqlSafetyNet::ExplainPlan.enable_on_connection_adapter!(ActiveRecord::Base.connection.class, :mysql) # assuming MySQL adapter
+#     Rails.configuration.middleware.use(SqlSafetyNet::Middleware)
+#   end
+#
+# Or you can simply enable the default configuration by calling:
+#
+#   SqlSafetyNet.enable! if Rails.env.development?
 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__)
+  autoload :CacheStore, File.expand_path("../sql_safety_net/cache_store.rb", __FILE__)
+  autoload :Configuration, File.expand_path("../sql_safety_net/configuration.rb", __FILE__)
+  autoload :ConnectionAdapter, File.expand_path("../sql_safety_net/connection_adapter.rb", __FILE__)
+  autoload :ExplainPlan, File.expand_path("../sql_safety_net/explain_plan.rb", __FILE__)
+  autoload :Formatter, File.expand_path("../sql_safety_net/formatter.rb", __FILE__)
+  autoload :Middleware, File.expand_path("../sql_safety_net/middleware.rb", __FILE__)
+  autoload :QueryAnalysis, File.expand_path("../sql_safety_net/query_analysis.rb", __FILE__)
+  autoload :QueryInfo, File.expand_path("../sql_safety_net/query_info.rb", __FILE__)
   
   class << self
-    # Get the configuration for the safety net.
+    # Enable SQL analysis on your Rails app. This method can be called from your development.rb
+    # file. It will enable analysis on the default database connection class and insert
+    # middleware into the Rack stack that will add debugging information to responses.
+    def enable!
+      enable_on_cache_store!(ActiveSupport::Cache::Store)
+      connection_class = ActiveRecord::Base.connection.class
+      enable_on_connection_adapter!(connection_class)
+      if connection_class.name.match(/mysql/i)
+        ExplainPlan.enable_on_connection_adapter!(connection_class, :mysql)
+      elsif connection_class.name.match(/postgres/i)
+        ExplainPlan.enable_on_connection_adapter!(connection_class, :postgresql)
+      end
+      Rails.configuration.middleware.use(Middleware)
+    end
+    
+    # Enable SQL analysis on a connection adapter.
+    def enable_on_connection_adapter!(connection_adapter_class)
+      connection_adapter_class.send(:include, ConnectionAdapter) unless connection_adapter_class.include?(ConnectionAdapter)
+    end
+    
+    # Enable monitoring on fetches from an ActiveSupport::Cache::Store class. This
+    # will allow reporting which queries are in cache blocks in the analysis.
+    def enable_on_cache_store!(cache_store_class)
+      cache_store_class.send(:include, CacheStore) unless cache_store_class.include?(CacheStore)
+    end
+    
+    # Get the configuration. There is only ever one configuration. The values in the
+    # configuration can be changed. If you only need to change them temporarily, see
+    # +override_config+.
     def config
-      @config ||= SqlSafetyNet::Configuration.new
+      @config ||= 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)
+    # Set configuration values within a block. The block given to this method will
+    # be yielded to with a clone of the configuration. Any changes to the configuration
+    # will only persist within the block.
+    def override_config
+      save_val = config
+      begin
+        @config = save_val.dup
+        @config.style = @config.style.dup
+        yield(@config)
+      ensure
+        @config = save_val
       end
-      Rails.configuration.middleware.use(SqlSafetyNet::RackHandler)
     end
   end
 end

data/spec/cache_store_spec.rb

@@ -1,26 +1,17 @@
 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
+  let(:cache){ ActiveSupport::Cache::MemoryStore.new }
   
-  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"
+  it "should determine if code is inside a cache fetch block" do
+    SqlSafetyNet::CacheStore.in_fetch_block?.should == false
+    val = cache.fetch("foo") do
+      SqlSafetyNet::CacheStore.in_fetch_block?.should == true
+      "bar"
     end
-    val.should == "woot"
+    val.should == "bar"
+    SqlSafetyNet::CacheStore.in_fetch_block?.should == false
   end
   
 end

data/spec/configuration_spec.rb

@@ -1,67 +1,72 @@
 require 'spec_helper'
 
 describe SqlSafetyNet::Configuration do
-
-  before :each do
-    @config = SqlSafetyNet::Configuration.new
-  end
   
-  it "should be able to set debug" do
-    @config.debug?.should == false
-    @config.debug = true
-    @config.debug?.should == true
-    @config.debug = false
-    @config.debug?.should == false
-  end
-
-  it "should be able to set header" do
-    @config.header?.should == false
-    @config.header = true
-    @config.header?.should == true
-    @config.header = false
-    @config.header?.should == false
-  end
-
-  it "should be able to set table_scan_limit" do
-    @config.table_scan_limit = 500
-    @config.table_scan_limit.should == 500
-  end
-
-  it "should be able to set temporary_table_limit" do
-    @config.temporary_table_limit = 50
-    @config.temporary_table_limit.should == 50
-  end
-
-  it "should be able to set filesort_limit" do
-    @config.filesort_limit = 600
-    @config.filesort_limit.should == 600
-  end
-
-  it "should be able to set examine_rows_limit" do
-    @config.examine_rows_limit = 1000
-    @config.examine_rows_limit.should == 1000
-  end
-
-  it "should be able to set return_rows_limit" do
-    @config.return_rows_limit = 1000
-    @config.return_rows_limit.should == 1000
-  end
-
-  it "should be able to set query_limit" do
-    @config.query_limit = 20
-    @config.query_limit.should == 20
+  let(:config){ SqlSafetyNet::Configuration.new }
+  
+  describe "standard settings" do
+    it "should have a query_limit with a default of 10" do
+      config.query_limit.should == 10
+      config.query_limit = 100
+      config.query_limit.should == 100
+    end
+  
+    it "should have a returned_rows_limit with a default of 100" do
+      config.returned_rows_limit.should == 100
+      config.returned_rows_limit = 200
+      config.returned_rows_limit.should == 200
+    end
+  
+    it "should have a result_size_limit with a default of 16K" do
+      config.result_size_limit.should == 16 * 1024
+      config.result_size_limit = 10000
+      config.result_size_limit.should == 10000
+    end
+  
+    it "should have a elapsed_time_limit with a default of 300ms" do
+      config.elapsed_time_limit.should == 0.3
+      config.elapsed_time_limit = 1
+      config.elapsed_time_limit.should == 1
+    end
   end
-
-  it "should be able to set time_limit" do
-    @config.time_limit = 200
-    @config.time_limit.should == 200
+  
+  describe "query plan limits" do
+    it "should have a table_scan_limit with a default of 100 rows" do
+      config.table_scan_limit.should == 100
+      config.table_scan_limit = 200
+      config.table_scan_limit.should == 200
+    end
+  
+    it "should have a temporary_table_limit with a default of 100 rows" do
+      config.temporary_table_limit.should == 100
+      config.temporary_table_limit = 200
+      config.temporary_table_limit.should == 200
+    end
+  
+    it "should have a filesort_limit with a default of 100 rows" do
+      config.filesort_limit.should == 100
+      config.filesort_limit = 200
+      config.filesort_limit.should == 200
+    end
+  
+    it "should have an examined_rows_limit with a default of 5000 rows" do
+      config.examined_rows_limit.should == 5000
+      config.examined_rows_limit = 10000
+      config.examined_rows_limit.should == 10000
+    end
   end
 
-  it "should be able to set always_show" do
-    @config.always_show = true
-    @config.always_show?.should == true
-    @config.always_show = nil
-    @config.always_show?.should == false
+  describe "debugging information" do
+    it "should have a flag to always_show debugging info" do
+      config.always_show.should == false
+      config.always_show = true
+      config.always_show.should == true
+    end
+  
+    it "should have css style" do
+      config.style.should == {}
+      config.style = {"top" => "5px", "right" => "5px"}
+      config.style.should == {"top" => "5px", "right" => "5px"}
+    end
   end
-
 end