Skip to content

Business intelligence made simple

Improved caching code

Andrew Kane358ad55bb3d0
diff --git a/app/controllers/blazer/queries_controller.rb b/app/controllers/blazer/queries_controller.rb
index ece7f6a3..910aa86f 100644
--- a/app/controllers/blazer/queries_controller.rb
+++ b/app/controllers/blazer/queries_controller.rb
@@ -141,7 +141,7 @@ module Blazer
end
if @result
- @data_source.delete_results(@run_id) if @run_id
+ @data_source.delete_results(@run_id) if @run_id && Blazer.async
@columns = @result.columns
@rows = @result.rows
diff --git a/lib/blazer.rb b/lib/blazer.rb
index 547ae44d..3d09c619 100644
--- a/lib/blazer.rb
+++ b/lib/blazer.rb
@@ -12,6 +12,7 @@ require "yaml"
require_relative "blazer/version"
require_relative "blazer/data_source"
require_relative "blazer/result"
+require_relative "blazer/result_cache"
require_relative "blazer/run_statement"
require_relative "blazer/statement"
diff --git a/lib/blazer/data_source.rb b/lib/blazer/data_source.rb
index 899cf935..6832ee77 100644
--- a/lib/blazer/data_source.rb
+++ b/lib/blazer/data_source.rb
@@ -72,19 +72,16 @@ module Blazer
@local_time_suffix ||= Array(settings["local_time_suffix"])
end
- def read_cache(cache_key)
- value = Blazer.cache.read(cache_key)
- if value
- Blazer::Result.new(self, *Blazer::Result.load(value), nil)
- end
+ def result_cache
+ @result_cache ||= Blazer::ResultCache.new(self)
end
def run_results(run_id)
- read_cache(run_cache_key(run_id))
+ result_cache.read_run(run_id)
end
def delete_results(run_id)
- Blazer.cache.delete(run_cache_key(run_id))
+ result_cache.delete_run(run_id)
end
def sub_variables(statement, vars)
@@ -106,7 +103,7 @@ module Blazer
if options[:refresh_cache]
clear_cache(statement) # for checks
else
- result = read_cache(statement_cache_key(statement))
+ result = result_cache.read_statement(statement)
end
end
@@ -135,19 +132,7 @@ module Blazer
end
def clear_cache(statement)
- Blazer.cache.delete(statement_cache_key(statement))
- end
-
- def cache_key(key)
- (["blazer", "v5"] + key).join("/")
- end
-
- def statement_cache_key(statement)
- cache_key(["statement", id, Digest::SHA256.hexdigest(statement.bind_statement.to_s.gsub("\r\n", "\n") + statement.bind_values.to_json)])
- end
-
- def run_cache_key(run_id)
- cache_key(["run", run_id])
+ result_cache.delete_statement(statement)
end
def quote(value)
@@ -240,25 +225,29 @@ module Blazer
end
duration = Blazer.monotonic_time - start_time
- cache_data = nil
cache = !error && (cache_mode == "all" || (cache_mode == "slow" && duration >= cache_slow_threshold))
- if cache || run_id
- cache_data = Blazer::Result.dump([columns, rows, error, cache ? Time.now : nil]) rescue nil
- end
- if cache && cache_data && adapter_instance.cachable?(statement.bind_statement)
- Blazer.cache.write(statement_cache_key(statement), cache_data, expires_in: cache_expires_in.to_f * 60)
+ result = Blazer::Result.new(self, columns, rows, error, cache ? Time.now : nil, cache)
+
+ if cache && adapter_instance.cachable?(statement.bind_statement)
+ begin
+ result_cache.write_statement(statement, result, expires_in: cache_expires_in.to_f * 60)
+ rescue
+ result.just_cached = false
+ end
end
if run_id
- unless cache_data
- error = "Error storing the results of this query :("
- cache_data = Blazer::Result.dump([[], [], error, nil])
+ begin
+ result_cache.write_run(run_id, result)
+ rescue
+ result = Blazer::Result.new(self, [], [], "Error storing the results of this query :(", nil, false)
+ result_cache.write_run(run_id, result)
end
- Blazer.cache.write(run_cache_key(run_id), cache_data, expires_in: 30.seconds)
end
- Blazer::Result.new(self, columns, rows, error, nil, cache && !cache_data.nil?)
+ result.cached_at = nil
+ result
end
# TODO check for adapter with same name, default to sql
diff --git a/lib/blazer/result.rb b/lib/blazer/result.rb
index 65bdcf1c..bd38b713 100644
--- a/lib/blazer/result.rb
+++ b/lib/blazer/result.rb
@@ -1,6 +1,7 @@
module Blazer
class Result
- attr_reader :data_source, :columns, :rows, :error, :cached_at, :just_cached, :forecast_error
+ attr_reader :data_source, :columns, :rows, :error, :forecast_error
+ attr_accessor :cached_at, :just_cached
def initialize(data_source, columns, rows, error, cached_at, just_cached)
@data_source = data_source
@@ -198,13 +199,5 @@ module Blazer
raise "Unknown anomaly detector"
end
end
-
- def self.load(*args)
- Marshal.load(*args)
- end
-
- def self.dump(*args)
- Marshal.dump(*args)
- end
end
end
diff --git a/lib/blazer/result_cache.rb b/lib/blazer/result_cache.rb
new file mode 100644
index 00000000..e7197cfc
--- /dev/null
+++ b/lib/blazer/result_cache.rb
@@ -0,0 +1,67 @@
+module Blazer
+ class ResultCache
+ def initialize(data_source)
+ @data_source = data_source
+ end
+
+ def write_run(run_id, result)
+ write(run_cache_key(run_id), result, expires_in: 30.seconds)
+ end
+
+ def read_run(run_id)
+ read(run_cache_key(run_id))
+ end
+
+ def delete_run(run_id)
+ delete(run_cache_key(run_id))
+ end
+
+ def write_statement(statement, result, expires_in:)
+ write(statement_cache_key(statement), result, expires_in: expires_in)
+ end
+
+ def read_statement(statement)
+ read(statement_cache_key(statement))
+ end
+
+ def delete_statement(statement)
+ delete(statement_cache_key(statement))
+ end
+
+ private
+
+ def write(key, result, expires_in:)
+ raise ArgumentError, "expected Blazer::Result" unless result.is_a?(Blazer::Result)
+ value = [result.columns, result.rows, result.error, result.cached_at]
+ cache.write(key, value, expires_in: expires_in)
+ end
+
+ def read(key)
+ value = cache.read(key)
+ if value
+ columns, rows, error, cached_at = value
+ Blazer::Result.new(@data_source, columns, rows, error, cached_at, false)
+ end
+ end
+
+ def delete(key)
+ cache.delete(key)
+ end
+
+ def cache_key(key)
+ (["blazer", "v5", @data_source.id] + key).join("/")
+ end
+
+ def statement_cache_key(statement)
+ cache_key(["statement", Digest::SHA256.hexdigest(statement.bind_statement.to_s.gsub("\r\n", "\n") + statement.bind_values.to_json)])
+ end
+
+ def run_cache_key(run_id)
+ cache_key(["run", run_id])
+ end
+
+ def cache
+ Blazer.cache
+ end
+ end
+end
diff --git a/lib/blazer/run_statement.rb b/lib/blazer/run_statement.rb
index f6d45aba..35a3a432 100644
--- a/lib/blazer/run_statement.rb
+++ b/lib/blazer/run_statement.rb
@@ -32,7 +32,7 @@ module Blazer
audit.save! if audit.changed?
end
- if query && !result.timed_out? && !query.variables.any?
+ if query && !result.timed_out? && !result.cached_at && !query.variables.any?
query.checks.each do |check|
check.update_state(result)
end
diff --git a/lib/blazer/run_statement_job.rb b/lib/blazer/run_statement_job.rb
index a4206293..1e15d50a 100644
--- a/lib/blazer/run_statement_job.rb
+++ b/lib/blazer/run_statement_job.rb
@@ -11,8 +11,8 @@ module Blazer
Blazer::RunStatement.new.perform(statement, options)
end
rescue Exception => e
- Blazer::Result.new(data_source, [], [], "Unknown error", nil, false)
- Blazer.cache.write(data_source.run_cache_key(options[:run_id]), Blazer::Result.dump([[], [], "Unknown error", nil]), expires_in: 30.seconds)
+ result = Blazer::Result.new(data_source, [], [], "Unknown error", nil, false)
+ data_source.result_cache.write_run(options[:run_id], result)
raise e
end
end