sql_safety_net 1.1.11 → 2.0.0

data/spec/query_analysis_spec.rb

@@ -3,69 +3,111 @@ require 'spec_helper'
 describe SqlSafetyNet::QueryAnalysis do
   
   let(:analysis){ SqlSafetyNet::QueryAnalysis.new }
+  let(:query_info){ SqlSafetyNet::QueryInfo.new("SELECT * FROM *", :elapsed_time => 0.1, :rows => 2, :result_size => 500) }
   
-  it "should add a flagged query" do
-    analysis.add_query("sql", "test", 10, 0.01, :query_plan => "this sucks", :flags => ["write better sql"])
-    analysis.non_flagged_queries.should be_empty
-    query = analysis.flagged_queries.first
-    query[:sql].should == "sql"
-    query[:name].should == "test"
-    query[:rows].should == 10
-    query[:elapsed_time].should == 0.01
-    query[:query_plan].should == "this sucks"
-    query[:flags].should == ["write better sql"]
-    query[:cached].should == false
+  it "should instantiate a query analysis inside a block" do
+    SqlSafetyNet::QueryAnalysis.current.should == nil
+    result = SqlSafetyNet::QueryAnalysis.capture do |analysis_1|
+      analysis_1.should be_a(SqlSafetyNet::QueryAnalysis)
+      SqlSafetyNet::QueryAnalysis.capture do |analysis_2|
+        analysis_2.should be_a(SqlSafetyNet::QueryAnalysis)
+        "hello"
+      end
+    end
+    SqlSafetyNet::QueryAnalysis.current.should == nil
+    result.should == "hello"
   end
   
-  it "should add a non-flagged query" do
-    analysis.add_query("sql", "test", 10, 0.01, nil)
-    analysis.flagged_queries.should be_empty
-    query = analysis.non_flagged_queries.first
-    query[:sql].should == "sql"
-    query[:name].should == "test"
-    query[:rows].should == 10
-    query[:elapsed_time].should == 0.01
-    query[:cached].should == false
+  it "should track the number of queries" do
+    analysis.queries.should == []
+    analysis.total_queries.should == 0
+    analysis << query_info
+    analysis.queries.should == [query_info]
+    analysis.total_queries.should == 1
+    analysis << query_info
+    analysis.queries.should == [query_info, query_info]
+    analysis.total_queries.should == 2
   end
   
-  it "should determine if any query is flagged" do
-    analysis.add_query("sql", "test", 10, 0.01, :query_plan => "this sucks", :flags => ["write better sql"])
-    analysis.add_query("sql", "test", 10, 0.01, nil)
-    analysis.should be_flagged
-    analysis.flagged_queries?.should == true
+  it "should track the elasped time of all queries" do
+    analysis.elapsed_time.should == 0.0
+    analysis << query_info
+    analysis.elapsed_time.should == 0.1
+    analysis << query_info
+    analysis.elapsed_time.should == 0.2
   end
   
-  it "should determine if the rows selected is flagged" do
-    analysis.rows = 1000000
-    analysis.should be_flagged
-    analysis.too_many_rows?.should == true
+  it "should track the rows of all queries" do
+    analysis.rows.should == 0
+    analysis << query_info
+    analysis.rows.should == 2
+    analysis << query_info
+    analysis.rows.should == 4
   end
   
-  it "should determine if the number of selects is flagged" do
-    analysis.selects = 100000
-    analysis.should be_flagged
-    analysis.too_many_selects?.should == true
+  it "should track the result size of all queries" do
+    analysis.result_size.should == 0
+    analysis << query_info
+    analysis.result_size.should == 500
+    analysis << query_info
+    analysis.result_size.should == 1000
   end
   
-  it "should set the analysis object within a block" do
-    SqlSafetyNet::QueryAnalysis.analyze do
-      SqlSafetyNet::QueryAnalysis.current.should be_a(SqlSafetyNet::QueryAnalysis)
+  describe "flags" do
+    it "should determine the number of queries that have alerts" do
+      analysis.alerted_queries.should == 0
+      analysis << query_info
+      analysis.alerted_queries.should == 0
+      analysis << SqlSafetyNet::QueryInfo.new("SELECT *", :alerts => ["boom"])
+      analysis.alerted_queries.should == 1
     end
-    SqlSafetyNet::QueryAnalysis.current.should == nil
-  end
-  
-  it "should determine if a query is happening in a cache block" do
-    cache = ActiveSupport::Cache::MemoryStore.new
-    analysis = nil
-    SqlSafetyNet::QueryAnalysis.analyze do
-      val = cache.fetch("key") do
-        analysis = SqlSafetyNet::QueryAnalysis.current
-        analysis.add_query("sql", "test", 10, 0.01, nil)
-        "woot"
+    
+    it "should determine if any queries have alerts" do
+      analysis.alerts?.should == false
+      analysis << query_info
+      analysis.alerts?.should == false
+      analysis << SqlSafetyNet::QueryInfo.new("SELECT *", :alerts => ["boom"])
+      analysis.alerts?.should == true
+    end
+    
+    it "should determine if too many queries have been made" do
+      SqlSafetyNet.override_config do |config|
+        config.query_limit = 1
+        analysis << query_info
+        analysis.too_many_queries?.should == false
+        analysis << query_info
+        analysis.too_many_queries?.should == true
+      end
+    end
+    
+    it "should determine if too many rows have been returned" do
+      SqlSafetyNet.override_config do |config|
+        config.returned_rows_limit = 3
+        analysis << query_info
+        analysis.too_many_rows?.should == false
+        analysis << query_info
+        analysis.too_many_rows?.should == true
+      end
+    end
+    
+    it "should determine if the results are too big" do
+      SqlSafetyNet.override_config do |config|
+        config.result_size_limit = 600
+        analysis << query_info
+        analysis.results_too_big?.should == false
+        analysis << query_info
+        analysis.results_too_big?.should == true
+      end
+    end
+    
+    it "should determine if the queries take too much time" do
+      SqlSafetyNet.override_config do |config|
+        config.elapsed_time_limit = 0.15
+        analysis << query_info
+        analysis.too_much_time?.should == false
+        analysis << query_info
+        analysis.too_much_time?.should == true
       end
-      val.should == "woot"
     end
-    query = analysis.non_flagged_queries.first
-    query[:cached].should == true
   end
 end

data/spec/query_info_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe SqlSafetyNet::QueryInfo do
+  
+  describe "constructor" do
+    it "should keep the sql passed in to the constructor" do
+      query_info = SqlSafetyNet::QueryInfo.new("SELECT * FROM *")
+      query_info.sql.should == "SELECT * FROM *"
+    end
+    
+    it "should keep the elapsed time passed in :elapsed_time option" do
+      query_info = SqlSafetyNet::QueryInfo.new("SELECT * FROM *", :elapsed_time => 0.1)
+      query_info.elapsed_time.should == 0.1
+    end
+    
+    it "should keep the rows passed in :rows option" do
+      query_info = SqlSafetyNet::QueryInfo.new("SELECT * FROM *", :rows => 10)
+      query_info.rows.should == 10
+    end
+    
+    it "should keep the result_size passed in :result_size option" do
+      query_info = SqlSafetyNet::QueryInfo.new("SELECT * FROM *", :result_size => 100)
+      query_info.result_size.should == 100
+    end
+    
+    it "should keep the cached value passed in :cached option" do
+      query_info = SqlSafetyNet::QueryInfo.new("SELECT * FROM *", :cached => true)
+      query_info.cached?.should == true
+    end
+  end
+  
+  describe "alerts" do
+    it "should not have any alerts by default" do
+      query_info = SqlSafetyNet::QueryInfo.new("SELECT * FROM *")
+      query_info.alerts.should == []
+    end
+    
+    it "should indicate if it has any alerts" do
+      query_info = SqlSafetyNet::QueryInfo.new("SELECT * FROM *")
+      query_info.alerts?.should == false
+      query_info.alerts << "problem"
+      query_info.alerts?.should == true
+    end
+  end
+  
+end

data/spec/spec_helper.rb

@@ -1,15 +1,12 @@
 require 'rubygems'
 
-active_record_version = ENV['ACTIVE_RECORD_VERSION'] || ">=2.2.2"
+active_record_version = ENV['ACTIVE_RECORD_VERSION'] || ">=3.2.0"
 gem 'rails', active_record_version
 gem 'activerecord', active_record_version
 gem 'activesupport', active_record_version
 require 'active_support/all'
 require 'active_record'
-puts "Testing against #{ActiveRecord::VERSION::STRING}"
-
-require 'mysql'
-require 'pg'
+puts "Testing against activerecord #{ActiveRecord::VERSION::STRING}"
 
 begin
   require 'simplecov'
@@ -24,33 +21,17 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'sql_saf
 
 module SqlSafetyNet
   class TestModel < ActiveRecord::Base
-    def self.create_tables
+    def self.create_table
       connection.create_table(table_name) do |t|
         t.string :name
+        t.integer :value
       end unless table_exists?
     end
-
-    def self.drop_tables
-      connection.drop_table(table_name)
-    end
-  
-    def self.database_config
-      database_yml = File.expand_path(File.join(File.dirname(__FILE__), 'database.yml'))
-      raise "You must create a database.yml file in the spec directory (see example_database.yml)" unless File.exist?(database_yml)
-      YAML.load_file(database_yml)
-    end
-  end
-  
-  class MysqlTestModel < TestModel
-    establish_connection(database_config['mysql'])
-  end
-  
-  class PostgresqlTestModel < TestModel
-    establish_connection(database_config['postgresql'])
   end
   
-  SqlSafetyNet.config.enable_on(SqlSafetyNet::MysqlTestModel.connection.class)
-  SqlSafetyNet.config.enable_on(SqlSafetyNet::PostgresqlTestModel.connection.class)
+  TestModel.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+  TestModel.create_table
 end
 
 ActiveSupport::Cache::Store.send(:include, SqlSafetyNet::CacheStore)
+SqlSafetyNet.enable_on_connection_adapter!(SqlSafetyNet::TestModel.connection.class)

data/spec/sql_safety_net_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe SqlSafetyNet do
+  
+  it "should have a singleton config" do
+    config = SqlSafetyNet.config
+    config.should be_a(SqlSafetyNet::Configuration)
+    config.object_id.should == SqlSafetyNet.config.object_id
+  end
+  
+  it "should be able to override the config in a block" do
+    original_config = SqlSafetyNet.config
+    original_style = original_config.style.dup
+    SqlSafetyNet.override_config do |config|
+      config.object_id.should_not == original_config.object_id
+      config.style = {"top" => "5px"}
+    end
+    original_config.style.should == original_style
+  end
+  
+end

metadata

@@ -1,102 +1,111 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: sql_safety_net
-version: !ruby/object:Gem::Version
-  version: 1.1.11
+version: !ruby/object:Gem::Version 
+  hash: 15
   prerelease: 
+  segments: 
+  - 2
+  - 0
+  - 0
+  version: 2.0.0
 platform: ruby
-authors:
+authors: 
 - Brian Durand
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-06 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
+
+date: 2012-06-14 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
   name: activesupport
-  requirement: &70157641410240 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
   type: :runtime
-  prerelease: false
-  version_requirements: *70157641410240
-- !ruby/object:Gem::Dependency
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
   name: activerecord
-  requirement: &70157641409720 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 2.2.2
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
   type: :runtime
-  prerelease: false
-  version_requirements: *70157641409720
-- !ruby/object:Gem::Dependency
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
   name: actionpack
-  requirement: &70157641409100 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
   type: :runtime
-  prerelease: false
-  version_requirements: *70157641409100
-- !ruby/object:Gem::Dependency
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
   name: rspec
-  requirement: &70157641408520 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 2.0.0
-  type: :development
-  prerelease: false
-  version_requirements: *70157641408520
-- !ruby/object:Gem::Dependency
-  name: mysql
-  requirement: &70157641408000 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
   prerelease: false
-  version_requirements: *70157641408000
-- !ruby/object:Gem::Dependency
-  name: pg
-  requirement: &70157641407460 !ruby/object:Gem::Requirement
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
   type: :development
-  prerelease: false
-  version_requirements: *70157641407460
-- !ruby/object:Gem::Dependency
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
   name: sqlite3-ruby
-  requirement: &70157641406900 !ruby/object:Gem::Requirement
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
   type: :development
-  prerelease: false
-  version_requirements: *70157641406900
+  version_requirements: *id005
 description: Debug SQL statements in ActiveRecord by displaying warnings on bad queries.
-email:
+email: 
 - mdobrota@tribune.com
 - ddpr@tribune.com
 executables: []
+
 extensions: []
-extra_rdoc_files:
+
+extra_rdoc_files: 
 - README.rdoc
-files:
+files: 
 - License.txt
 - README.rdoc
 - Rakefile
@@ -104,45 +113,59 @@ files:
 - lib/sql_safety_net/cache_store.rb
 - lib/sql_safety_net/configuration.rb
 - lib/sql_safety_net/connection_adapter.rb
-- lib/sql_safety_net/connection_adapter/mysql_adapter.rb
-- lib/sql_safety_net/connection_adapter/postgresql_adapter.rb
+- lib/sql_safety_net/explain_plan.rb
+- lib/sql_safety_net/explain_plan/mysql.rb
+- lib/sql_safety_net/explain_plan/postgresql.rb
+- lib/sql_safety_net/formatter.rb
+- lib/sql_safety_net/middleware.rb
 - lib/sql_safety_net/query_analysis.rb
-- lib/sql_safety_net/rack_handler.rb
+- lib/sql_safety_net/query_info.rb
 - spec/cache_store_spec.rb
 - spec/configuration_spec.rb
 - spec/connection_adapter_spec.rb
-- spec/example_database.yml
-- spec/mysql_connection_adapter_spec.rb
-- spec/postgres_connection_adapter_spec.rb
+- spec/explain_plan/mysql_spec.rb
+- spec/explain_plan/postgresql_spec.rb
+- spec/formatter_spec.rb
+- spec/middleware_spec.rb
 - spec/query_analysis_spec.rb
-- spec/rack_handler_spec.rb
+- spec/query_info_spec.rb
 - spec/spec_helper.rb
+- spec/sql_safety_net_spec.rb
 homepage: 
 licenses: []
+
 post_install_message: 
-rdoc_options:
+rdoc_options: 
 - --line-numbers
 - --inline-source
 - --main
 - README.rdoc
-require_paths:
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
 rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Debug SQL statements in ActiveRecord
 test_files: []
+

data/lib/sql_safety_net/connection_adapter/mysql_adapter.rb

@@ -1,43 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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