sql_safety_net 1.1.11

data/spec/configuration_spec.rb

@@ -0,0 +1,67 @@
+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
+  end
+
+  it "should be able to set time_limit" do
+    @config.time_limit = 200
+    @config.time_limit.should == 200
+  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
+  end
+
+end

data/spec/connection_adapter_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe SqlSafetyNet::ConnectionAdapter do
+  
+  class SqlSafetyNet::TestConnectionAdapter < ActiveRecord::ConnectionAdapters::AbstractAdapter
+    class Model
+      attr_accessor :id, :name
+      def initialize (attrs)
+        @id = attrs["id"]
+        @name = attrs["name"]
+      end
+    end
+    
+    def columns (table_name, name = nil)
+      select_rows("GET columns")
+      ["id", "name"]
+    end
+    
+    def select_rows (sql, name = nil, binds = [])
+      return [{"id" => 1, "name" => "foo"}, {"id" => 2, "name" => "bar"}]
+    end
+    
+    protected
+    
+    def analyze_query (sql, name, *args)
+      if sql.match(/table scan/i)
+        {:flags => ["table scan"]}
+      end
+    end
+    
+    def select (sql, name = nil, binds = [])
+      select_rows(sql, name).collect do |row|
+        Model.new(row)
+      end
+    end
+    
+    SqlSafetyNet.config.enable_on(self)
+  end
+  
+  before(:each) do
+    SqlSafetyNet.config.debug = true
+    SqlSafetyNet::QueryAnalysis.clear
+  end
+  
+  after(:each) do
+    SqlSafetyNet::QueryAnalysis.clear
+  end
+  
+  let(:connection){ SqlSafetyNet::TestConnectionAdapter.new(:connection) }
+
+  it "should not analyze the SQL select in the columns method" do
+    connection.should_receive(:columns_without_sql_safety_net).with("table", "columns").and_return(["col1", "col2"])
+    analysis = SqlSafetyNet::QueryAnalysis.analyze do
+      connection.columns("table", "columns").should == ["col1", "col2"]
+    end
+    analysis.selects.should == 0
+  end
+
+  it "should not analyze the SQL select in the active? method" do
+    connection.should_receive(:active_without_sql_safety_net?).and_return(true)
+    analysis = SqlSafetyNet::QueryAnalysis.analyze do
+      connection.active?.should == true
+    end
+    analysis.selects.should == 0
+  end
+  
+  it "should determine if a SQL statement is a select statement" do
+    connection.select_statement?("SELECT * FROM TABLE").should == true
+    connection.select_statement?(" \n SELECT * FROM TABLE").should == true
+    connection.select_statement?("Select * From Table").should == true
+    connection.select_statement?("select * from table").should == true
+    connection.select_statement?("EXECUTE SELECT * FROM TABLE").should == false
+  end
+  
+  [:select, :select_rows].each do |select_method|
+    context select_method do
+      it "should proxy the select method to the underlying adapter" do
+        connection.should_receive("#{select_method}_without_sql_safety_net").with('Select sql', 'name').and_return([:row1, :row2])
+        connection.send(select_method, 'Select sql', 'name').should == [:row1, :row2]
+      end
+    
+      it "should count selects" do
+        analysis = SqlSafetyNet::QueryAnalysis.analyze do
+          connection.send(select_method, 'Select * from table')
+          connection.send(select_method, 'Select * from table where whatever')
+        end
+        analysis.selects.should == 2
+      end
+    
+      it "should count rows returned" do
+        analysis = SqlSafetyNet::QueryAnalysis.analyze do
+          connection.send(select_method, 'Select * from table')
+          connection.send(select_method, 'Select * from table where whatever')
+        end
+        analysis.rows.should == 4
+      end
+  
+      it "should analyze select statements and keep track of bad queries" do
+        analysis = SqlSafetyNet::QueryAnalysis.analyze do
+          connection.send(select_method, 'Select * from table doing table scan')
+        end
+        analysis.non_flagged_queries.size.should == 0
+        analysis.flagged_queries.size.should == 1
+        analysis.flagged_queries.first[:sql].should == 'Select * from table doing table scan'
+        analysis.flagged_queries.first[:rows].should == 2
+        analysis.flagged_queries.first[:flags].should == ['table scan']
+      end
+
+      it "should analyze select statements and keep track of good queries" do
+        analysis = SqlSafetyNet::QueryAnalysis.analyze do
+          connection.send(select_method, 'Select * from table')
+        end
+        analysis.flagged_queries.size.should == 0
+        analysis.non_flagged_queries.size.should == 1
+        analysis.non_flagged_queries.first[:sql].should == 'Select * from table'
+        analysis.non_flagged_queries.first[:rows].should == 2
+      end
+      
+      it "should flag queries that exceed the configured time limit" do
+        now = Time.now
+        analysis = SqlSafetyNet::QueryAnalysis.analyze do
+          Time.stub(:now).and_return(now, now + 100)
+          connection.send(select_method, 'Select * from table')
+        end
+        analysis.flagged_queries.size.should == 1
+        analysis.non_flagged_queries.size.should == 0
+        analysis.flagged_queries.first[:flags].should == ["query time exceeded #{SqlSafetyNet.config.time_limit} ms"]
+      end
+
+      it "should not analyze queries if debug mode disabled" do
+        SqlSafetyNet.config.debug = false
+        analysis = SqlSafetyNet::QueryAnalysis.analyze do
+          connection.send(select_method, 'SELECT * from table with table scan')
+        end
+        analysis.selects.should == 1
+        analysis.rows.should == 2
+        analysis.flagged_queries.size.should == 0
+        analysis.non_flagged_queries.size.should == 0
+      end
+    end
+  end
+
+end

data/spec/example_database.yml

@@ -0,0 +1,14 @@
+# Copy this file to database.yml to run the test with connection settings for you environment.
+# You must create the database in both mysql and postgres.
+
+mysql:
+  adapter: mysql
+  username: root
+  password: ""
+  database: sql_safety_net_test
+
+postgresql:
+  adapter: postgresql
+  username: postgres
+  password: postgres
+  database: sql_safety_net_test

data/spec/mysql_connection_adapter_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe SqlSafetyNet::ConnectionAdapter::MysqlAdapter do
+  
+  before(:each) do
+    @connection = SqlSafetyNet::MysqlTestModel.connection
+  end
+
+  it "should use query plan analysis to flag queries" do
+    query_plan = [{'type' => 'ALL', 'rows' => 200}]
+    @connection.should_receive(:select_without_sql_safety_net).with('EXPLAIN Select sql', 'EXPLAIN', []).and_return(query_plan)
+    @connection.should_receive(:analyze_query_plan).with(query_plan).and_return(["bad query"])
+    @connection.analyze_query('Select sql', 'name', []).should == {:query_plan => query_plan, :flags => ["bad query"]}
+  end
+
+  it "should only analyze query plans for select statements" do
+    @connection.should_not_receive(:select_without_sql_safety_net)
+    @connection.should_not_receive(:analyze_query_plan)
+    @connection.analyze_query('Execute sql', 'name', []).should == nil
+  end
+
+  it "should translate query plans into flags" do
+    @connection.send(:analyze_query_plan, [{'type' => 'ALL', 'rows' => 500}]).should == ["table scan", "no index used", "no indexes possible"]
+    @connection.send(:analyze_query_plan, [{'Extra' => 'using temporary table; using filesort', 'rows' => 200, 'key' => 'index', 'possible_keys' => 'index'}]).should == ["uses temporary table for 200 rows", "uses filesort for 200 rows"]
+    @connection.send(:analyze_query_plan, [{'select_type' => 'dependent subquery', 'rows' => 20, 'key' => 'index', 'possible_keys' => 'index'}]).should == ["dependent subquery"]
+    @connection.send(:analyze_query_plan, [{'select_type' => 'uncacheable subquery', 'rows' => 20, 'key' => 'index', 'possible_keys' => 'index'}]).should == ["uncacheable subquery"]
+    @connection.send(:analyze_query_plan, [{'rows' => 20000, 'key' => 'index', 'possible_keys' => 'index'}]).should == ["examines 20000 rows"]
+    @connection.send(:analyze_query_plan, [{'select_type' => 'SIMPLE', 'rows' => 1, 'key' => 'index', 'possible_keys' => 'index'}]).should == []
+  end
+  
+end
+

data/spec/postgres_connection_adapter_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe SqlSafetyNet::ConnectionAdapter::PostgreSQLAdapter do
+
+  before(:each) do
+    @connection = SqlSafetyNet::PostgresqlTestModel.connection
+  end
+
+  it "should use query plan analysis to flag queries" do
+    query_plan = [{"QUERY PLAN"=>"Limit  (cost=0.00..0.06 rows=1 width=335)"}, {"QUERY PLAN"=>"  ->  Seq Scan on records  (cost=0.00..12.20 rows=220 width=335)"}]
+    @connection.should_receive(:select_without_sql_safety_net).with('EXPLAIN Select sql', 'EXPLAIN', []).and_return(query_plan)
+    @connection.should_receive(:analyze_query_plan).with(query_plan).and_return(["bad query"])
+    @connection.analyze_query('Select sql', 'name', []).should == {:query_plan => query_plan, :flags => ["bad query"]}
+  end
+
+  it "should only analyze query plans for select statements" do
+    @connection.should_not_receive(:select_without_sql_safety_net)
+    @connection.should_not_receive(:analyze_query_plan)
+    @connection.analyze_query('Execute sql', 'name', []).should == nil
+  end
+  
+  it "should not flag a small table scan" do
+    query_plan = [{"QUERY PLAN"=>"Seq Scan on records  (cost=0.00..12.20 rows=10 width=335)"}]
+    @connection.send(:analyze_query_plan, query_plan).should == []
+  end
+  
+  it "should flag a table scan" do
+    query_plan = [{"QUERY PLAN"=>"Seq Scan on records  (cost=0.00..12.20 rows=1000000 width=335)"}]
+    @connection.send(:analyze_query_plan, query_plan).should == ["table scan"]
+  end
+  
+  it "should flag too many rows returned" do
+    query_plan = [{"QUERY PLAN"=>"Index Scan using records_pkey on records  (cost=0.00..8.27 rows=1000000 width=336)"}]
+    @connection.send(:analyze_query_plan, query_plan).should == ["examines 1000000 rows"]
+  end
+    
+  it "should apply a limit to the rows returned" do
+    query_plan = [{"QUERY PLAN"=>"Limit  (cost=0.00..0.06 rows=1 width=335)"}, {"QUERY PLAN"=>"  ->  Seq Scan on records  (cost=0.00..12.20 rows=1000000 width=335)"}]
+    @connection.send(:analyze_query_plan, query_plan).should == []
+  end
+  
+end
+

data/spec/query_analysis_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe SqlSafetyNet::QueryAnalysis do
+  
+  let(:analysis){ SqlSafetyNet::QueryAnalysis.new }
+  
+  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
+  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
+  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
+  end
+  
+  it "should determine if the rows selected is flagged" do
+    analysis.rows = 1000000
+    analysis.should be_flagged
+    analysis.too_many_rows?.should == true
+  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
+  end
+  
+  it "should set the analysis object within a block" do
+    SqlSafetyNet::QueryAnalysis.analyze do
+      SqlSafetyNet::QueryAnalysis.current.should be_a(SqlSafetyNet::QueryAnalysis)
+    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"
+      end
+      val.should == "woot"
+    end
+    query = analysis.non_flagged_queries.first
+    query[:cached].should == true
+  end
+end

data/spec/rack_handler_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+describe SqlSafetyNet::RackHandler do
+
+  class SqlSafetyNet::TestApp
+    attr_accessor :response, :block
+    
+    def initialize
+      @response = Rack::Response.new
+    end
+    
+    def call (env)
+      @block.call(env) if @block
+      @response["Content-Type"] = env["response_content_type"] if env["response_content_type"]
+      @response.finish
+    end
+  end
+  
+  before(:each) do
+    SqlSafetyNet.config.debug = true
+    SqlSafetyNet::QueryAnalysis.clear
+  end
+  
+  let(:logger) do
+    logger = Object.new
+    def logger.warn (message)
+      # noop
+    end
+    logger
+  end
+  
+  let(:app){ SqlSafetyNet::TestApp.new }
+  
+  let(:handler){ SqlSafetyNet::RackHandler.new(app, logger) }
+  
+  let(:env) do
+    {
+      "rack.url_scheme" => "http",
+      "PATH_INFO" => "/test",
+      "SERVER_PORT" => 80,
+      "HTTP_HOST" => "example.com",
+      "REQUEST_METHOD" => "GET"
+    }
+  end
+
+  it "should append the bad queries to the HTML when debug is enabled and always_show is false" do
+    SqlSafetyNet.config.always_show = false
+    
+    app.block = lambda do |env|
+      SqlSafetyNet::QueryAnalysis.current.flagged_queries << {:sql => 'sql', :query_plan => 'bad plan', :flags => ['bad query'], :rows => 4, :elapsed_time => 0.1}
+    end
+    app.response.write("Monkeys are neat.")
+    
+    r = handler.call(env)
+    response = Rack::Response.new(r[2], r[0], r[1])
+    
+    response.body.join("").should include('<div id="sql_safety_net_warning"')
+    response.body.join("").should include("Monkeys are neat.")
+    response["X-SqlSafetyNet"].should == "selects=0; rows=0; elapsed_time=0; flagged_queries=1"
+  end
+
+  it "should not append the bad queries to the HTML when there are none and always_show is false" do
+    SqlSafetyNet.config.always_show = false
+    
+    app.response.write("Monkeys are neat.")
+       
+    r = handler.call(env)
+    response = Rack::Response.new(r[2], r[0], r[1])
+    
+    response.body.join("").should == "Monkeys are neat."
+    response["X-SqlSafetyNet"].should == "selects=0; rows=0; elapsed_time=0; flagged_queries=0"
+  end
+  
+  it "should append the queries to the HTML when there are none and always_show is true" do
+    SqlSafetyNet.config.always_show = true
+    
+    app.response.write("Monkeys are neat.")
+    
+    r = handler.call(env)
+    response = Rack::Response.new(r[2], r[0], r[1])
+    
+    response.body.join("").should include('<div id="sql_safety_net_warning"')
+    response.body.join("").should include("Monkeys are neat.")
+    response["X-SqlSafetyNet"].should == "selects=0; rows=0; elapsed_time=0; flagged_queries=0"
+  end
+  
+  it "should append the bad queries to XML when debug is enabled" do
+    SqlSafetyNet.config.always_show = false
+    
+    app.block = lambda do |env|
+      SqlSafetyNet::QueryAnalysis.current.flagged_queries << {:sql => 'sql', :query_plan => 'bad plan', :flags => ['bad query'], :rows => 4, :elapsed_time => 0.1}
+    end
+    app.response.write("<woot>Monkeys are neat.</woot>")
+    
+    r = handler.call(env.merge("response_content_type" => "application/xml"))
+    response = Rack::Response.new(r[2], r[0], r[1])
+    
+    response.body.join("").should_not include('<div id="sql_safety_net_warning"')
+    response.body.join("").should include("<!-- SqlSafetyNet")
+    response.body.join("").should include("<woot>Monkeys are neat.</woot>")
+    Hash.from_xml(response.body.join('')).should == {"woot" => "Monkeys are neat."}
+    response["X-SqlSafetyNet"].should == "selects=0; rows=0; elapsed_time=0; flagged_queries=1"
+  end
+  
+  it "should not append the bad queries to the HTML or add a response header if debug is not enabled" do
+    SqlSafetyNet.config.debug = false
+
+    app.block = lambda do |env|
+      SqlSafetyNet::QueryAnalysis.current.flagged_queries << {:sql => 'sql', :query_plan => 'bad plan', :flags => ['bad query'], :rows => 4, :elapsed_time => 0.1}
+    end
+    app.response.write("Monkeys are neat.")
+    
+    r = handler.call(env)
+    response = Rack::Response.new(r[2], r[0], r[1])
+    
+    response.body.join("").should == "Monkeys are neat."
+    response["X-SqlSafetyNet"].should == nil
+  end
+  
+  it "should not append the bad queries to the HTML if not text/html" do
+    app.block = lambda do |env|
+      SqlSafetyNet::QueryAnalysis.current.flagged_queries << {:sql => 'sql', :query_plan => 'bad plan', :flags => ['bad query'], :rows => 4, :elapsed_time => 0.1}
+    end
+    app.response.write("Monkeys are neat.")
+    app.response["Content-Type"] = "text/plain"
+    
+    r = handler.call(env)
+    response = Rack::Response.new(r[2], r[0], r[1])
+    
+    response.body.join("").should == "Monkeys are neat."
+    response["X-SqlSafetyNet"].should == "selects=0; rows=0; elapsed_time=0; flagged_queries=1"
+  end
+  
+  it "should not append the bad queries to the HTML if Ajax request" do
+    app.block = lambda do |env|
+      SqlSafetyNet::QueryAnalysis.current.flagged_queries << {:sql => 'sql', :query_plan => 'bad plan', :flags => ['bad query'], :rows => 4, :elapsed_time => 0.1}
+    end
+    app.response.write("Monkeys are neat.")
+    app.response["Content-Type"] = "text/plain"
+    
+    r = handler.call(env.merge("HTTP_X_REQUESTED_WITH" => "XMLHttpRequest"))
+    response = Rack::Response.new(r[2], r[0], r[1])
+    
+    response.body.join("").should == "Monkeys are neat."
+    response["X-SqlSafetyNet"].should == "selects=0; rows=0; elapsed_time=0; flagged_queries=1"
+  end
+  
+  it "should log too many selects even if debug is not enabled" do
+    SqlSafetyNet.config.debug = false
+    app.block = lambda do |env|
+      SqlSafetyNet::QueryAnalysis.current.selects = 1000
+    end
+    logger.should_receive(:warn).with("Excess database usage: request generated 1000 queries and returned 0 rows [GET http://example.com/test]")
+    r = handler.call(env)
+  end
+  
+  it "should log too many rows even if debug is not enabled" do
+    SqlSafetyNet.config.debug = false
+    SqlSafetyNet.config.header = false
+    app.block = lambda do |env|
+      SqlSafetyNet::QueryAnalysis.current.rows = 10000
+    end
+    app.response.write("Monkeys are neat.")
+    
+    logger.should_receive(:warn).with("Excess database usage: request generated 0 queries and returned 10000 rows [GET http://example.com/test]")
+    r = handler.call(env)
+    response = Rack::Response.new(r[2], r[0], r[1])
+    
+    response.body.join("").should == "Monkeys are neat."
+    response["X-SqlSafetyNet"].should == nil
+  end
+  
+  it "should log too many rows even if debug is not enabled" do
+    SqlSafetyNet.config.debug = false
+    SqlSafetyNet.config.header = true
+    app.block = lambda do |env|
+      SqlSafetyNet::QueryAnalysis.current.rows = 10
+    end
+    app.response.write("Monkeys are neat.")
+    r = handler.call(env)
+    response = Rack::Response.new(r[2], r[0], r[1])
+    
+    response.body.join("").should == "Monkeys are neat."
+    response["X-SqlSafetyNet"].should == "selects=0; rows=10; elapsed_time=0; flagged_queries=0"
+  end
+  
+  it "should not log warnings if there are none" do
+    SqlSafetyNet.config.debug = false
+    logger.should_not_receive(:warn)
+    r = handler.call(env)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,56 @@
+require 'rubygems'
+
+active_record_version = ENV['ACTIVE_RECORD_VERSION'] || ">=2.2.2"
+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'
+
+begin
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter "/spec/"
+  end
+rescue LoadError
+  # simplecov not installed
+end
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'sql_safety_net'))
+
+module SqlSafetyNet
+  class TestModel < ActiveRecord::Base
+    def self.create_tables
+      connection.create_table(table_name) do |t|
+        t.string :name
+      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)
+end
+
+ActiveSupport::Cache::Store.send(:include, SqlSafetyNet::CacheStore)