cache_sweeper 0.1.1 → 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,360 +0,0 @@
1
- require 'request_store'
2
- require 'set'
3
-
4
- module CacheSweeper
5
- module Loader
6
- SWEEPER_PATH = 'app/sweepers'.freeze
7
-
8
- class << self
9
- # Configuration resolution methods
10
- def resolve_trigger(rule, sweeper)
11
- rule[:trigger] || sweeper.trigger || CacheSweeper.trigger
12
- end
13
-
14
- def resolve_mode(rule, sweeper)
15
- rule[:mode] || sweeper.mode || CacheSweeper.mode
16
- end
17
-
18
- def resolve_queue(rule, sweeper)
19
- rule[:queue] || sweeper.queue || CacheSweeper.queue
20
- end
21
-
22
- def resolve_sidekiq_options(rule, sweeper)
23
- # Merge options in order of precedence: rule > sweeper > global
24
- options = CacheSweeper.sidekiq_options.dup
25
- options.merge!(sweeper.sidekiq_options) if sweeper.sidekiq_options
26
- options.merge!(rule[:sidekiq_options]) if rule[:sidekiq_options]
27
-
28
- # Add queue to options if specified
29
- queue = resolve_queue(rule, sweeper)
30
- options[:queue] = queue if queue && queue != :default
31
-
32
- options
33
- end
34
- end
35
-
36
- def self.collect_pending_key(key, sweeper = nil, mode = :request)
37
- if mode == :request
38
- RequestStore.store["cache_sweeper_pending_keys_#{sweeper&.name || 'global'}"] ||= Set.new
39
- RequestStore.store["cache_sweeper_pending_keys_#{sweeper&.name || 'global'}"] << key
40
- elsif mode == :job
41
- RequestStore.store["cache_sweeper_job_keys_#{sweeper&.name || 'global'}"] ||= Set.new
42
- RequestStore.store["cache_sweeper_job_keys_#{sweeper&.name || 'global'}"] << key
43
- end
44
- end
45
-
46
- def self.flush_pending_keys(sweeper: nil)
47
- start_time = Time.current
48
- sweeper_name = sweeper&.name || 'global'
49
-
50
- CacheSweeper::Logger.log_cache_operations("Flushing pending keys for sweeper: #{sweeper_name}", :debug, {
51
- sweeper: sweeper_name
52
- })
53
-
54
- # Flush request-level keys
55
- request_key = "cache_sweeper_pending_keys_#{sweeper_name}"
56
- keys = RequestStore.store[request_key]
57
- if keys&.any?
58
- deleted_count = CacheSweeper.delete_cache_keys(keys, {
59
- sweeper: sweeper_name,
60
- mode: :inline,
61
- trigger: :request
62
- })
63
- failed_count = keys.length - deleted_count
64
-
65
- CacheSweeper::Logger.log_cache_operations("Flushed request-level keys", :info, {
66
- sweeper: sweeper_name,
67
- deleted_count: deleted_count,
68
- failed_count: failed_count,
69
- total_keys: keys.length
70
- })
71
-
72
- RequestStore.store[request_key] = Set.new
73
- end
74
-
75
- # Flush job-level keys
76
- job_key = "cache_sweeper_job_keys_#{sweeper_name}"
77
- job_keys = RequestStore.store[job_key]
78
- if job_keys&.any?
79
- begin
80
- CacheSweeper::AsyncWorker.perform_async(job_keys.to_a, :request)
81
- CacheSweeper::Logger.log_cache_operations("Scheduled async job for pending keys", :info, {
82
- sweeper: sweeper_name,
83
- keys_count: job_keys.length,
84
- keys: job_keys.to_a
85
- })
86
- rescue => e
87
- CacheSweeper::Logger.log_error(e, {
88
- sweeper: sweeper_name,
89
- keys: job_keys.to_a,
90
- error_type: 'async_job_schedule_error'
91
- })
92
- end
93
- RequestStore.store[job_key] = Set.new
94
- end
95
-
96
- duration = (Time.current - start_time) * 1000
97
- CacheSweeper::Logger.log_performance("flush_pending_keys", duration, {
98
- sweeper: sweeper_name,
99
- request_keys_flushed: keys&.length || 0,
100
- job_keys_scheduled: job_keys&.length || 0
101
- })
102
- end
103
-
104
- def self.load_sweepers!
105
- Dir[Rails.root.join(SWEEPER_PATH, '**', '*_sweeper.rb')].each { |file| require_dependency file }
106
- end
107
-
108
- def self.hook_sweepers!
109
- start_time = Time.current
110
- CacheSweeper::Logger.log_initialization("Starting model attachment process")
111
-
112
- sweeper_count = 0
113
- rule_count = 0
114
- error_count = 0
115
- CacheSweeper::Base.descendants.each do |sweeper|
116
- sweeper_count += 1
117
- CacheSweeper::Logger.log_initialization("Processing sweeper: #{sweeper.name}", { sweeper: sweeper.name, rule_count: sweeper.cache_sweeper_rules.length })
118
-
119
- sweeper.cache_sweeper_rules.each do |rule|
120
- rule_count += 1
121
- association = rule[:association]
122
- attributes = rule[:attributes]
123
- condition = rule[:condition]
124
- keys = rule[:keys]
125
-
126
- begin
127
- if association.nil?
128
- model_name = sweeper.name.sub('Sweeper', '')
129
- model = model_name.constantize
130
- CacheSweeper::Logger.log_initialization("Attaching direct model callback: #{model_name}", {
131
- sweeper: sweeper.name,
132
- model: model_name,
133
- attributes: attributes,
134
- callback: rule[:callback] || :after_commit,
135
- events: rule[:on] || [:create, :update, :destroy]
136
- })
137
- attach_callbacks(model, sweeper, attributes, condition, keys, rule)
138
- else
139
- parent_model_name = sweeper.name.sub('Sweeper', '')
140
- parent_model = parent_model_name.constantize
141
- assoc_reflection = parent_model.reflect_on_association(association)
142
-
143
- unless assoc_reflection
144
- CacheSweeper::Logger.warn("Association not found: #{parent_model_name}##{association}", {
145
- sweeper: sweeper.name,
146
- parent_model: parent_model_name,
147
- association: association
148
- })
149
- next
150
- end
151
-
152
- assoc_model = assoc_reflection.klass
153
- CacheSweeper::Logger.log_initialization("Attaching association callback: #{parent_model_name}##{association} -> #{assoc_model.name}", {
154
- sweeper: sweeper.name,
155
- parent_model: parent_model_name,
156
- association: association,
157
- assoc_model: assoc_model.name,
158
- attributes: attributes,
159
- callback: rule[:callback] || :after_commit,
160
- events: rule[:on] || [:create, :update, :destroy]
161
- })
162
- attach_callbacks(assoc_model, sweeper, attributes, condition, keys, rule, parent_model, association)
163
- end
164
- rescue NameError => e
165
- error_count += 1
166
- CacheSweeper::Logger.log_error(e, {
167
- sweeper: sweeper.name,
168
- association: association,
169
- error_type: 'model_not_found'
170
- })
171
- # Model doesn't exist yet, skip for now
172
- next
173
- rescue => e
174
- error_count += 1
175
- CacheSweeper::Logger.log_error(e, {
176
- sweeper: sweeper.name,
177
- association: association,
178
- error_type: 'attachment_error'
179
- })
180
- next
181
- end
182
- end
183
- end
184
-
185
- duration = (Time.current - start_time) * 1000
186
- CacheSweeper::Logger.log_initialization("Model attachment completed", {
187
- sweeper_count: sweeper_count,
188
- rule_count: rule_count,
189
- error_count: error_count,
190
- duration_ms: duration.round(3)
191
- })
192
- end
193
-
194
- def self.attach_callbacks(model, sweeper, attributes, condition, keys, rule, parent_model = nil, association = nil)
195
- callback = lambda do |record|
196
- start_time = Time.current
197
- sweeper_instance = sweeper.new
198
-
199
- # Log rule execution start
200
- CacheSweeper::Logger.log_rule_execution(rule, record, 'started', {
201
- event: record.previous_changes.keys.any? ? 'update' : (record.persisted? ? 'create' : 'destroy'),
202
- changed_attributes: record.saved_changes.keys
203
- })
204
-
205
- begin
206
- # Check attribute changes
207
- if attributes
208
- changed = (record.saved_changes.keys.map(&:to_sym) & attributes.map(&:to_sym)).any?
209
- CacheSweeper::Logger.log_rule_execution(rule, record, "attribute_check: #{changed}", {
210
- watched_attributes: attributes,
211
- changed_attributes: record.saved_changes.keys,
212
- relevant_changes: record.saved_changes.keys.map(&:to_sym) & attributes.map(&:to_sym)
213
- })
214
- next unless changed
215
- end
216
-
217
- # Check condition
218
- if condition
219
- condition_result = sweeper_instance.call_condition(condition, record)
220
- CacheSweeper::Logger.log_rule_execution(rule, record, "condition_check: #{condition_result}", {
221
- condition: condition.class.name,
222
- condition_result: condition_result
223
- })
224
- next unless condition_result
225
- end
226
-
227
- # Generate cache keys
228
- cache_keys = if keys.is_a?(Proc)
229
- begin
230
- generated_keys = keys.call(record)
231
- CacheSweeper::Logger.log_rule_execution(rule, record, "keys_generated", {
232
- keys_count: Array(generated_keys).length,
233
- keys: Array(generated_keys)
234
- })
235
- generated_keys
236
- rescue => e
237
- CacheSweeper::Logger.log_error(e, {
238
- sweeper: sweeper.name,
239
- record_class: record.class.name,
240
- record_id: record.id,
241
- error_type: 'key_generation_error'
242
- })
243
- next
244
- end
245
- else
246
- Array(keys)
247
- end
248
-
249
- # Execute cache invalidation
250
- if parent_model && association
251
- # For association rules, we need to find the parent records
252
- # that have this record in their association
253
- parents = parent_model.joins(association).where(association => { id: record.id })
254
- CacheSweeper::Logger.log_rule_execution(rule, record, "association_processing", {
255
- parent_count: parents.count,
256
- association: association
257
- })
258
- Array(parents).each do |parent|
259
- CacheSweeper::Loader.invalidate_cache(cache_keys, record, rule)
260
- end
261
- else
262
- CacheSweeper::Loader.invalidate_cache(cache_keys, record, rule)
263
- end
264
-
265
- # Log successful completion
266
- duration = (Time.current - start_time) * 1000
267
- CacheSweeper::Logger.log_rule_execution(rule, record, "completed", {
268
- duration_ms: duration.round(3),
269
- cache_keys_processed: Array(cache_keys).length
270
- })
271
-
272
- rescue => e
273
- duration = (Time.current - start_time) * 1000
274
- CacheSweeper::Logger.log_error(e, {
275
- sweeper: sweeper.name,
276
- record_class: record.class.name,
277
- record_id: record.id,
278
- duration_ms: duration.round(3),
279
- error_type: 'rule_execution_error'
280
- })
281
- end
282
- end
283
-
284
- callback_type = rule[:callback] || :after_commit
285
- events = rule[:on] || [:create, :update, :destroy]
286
- model.send(callback_type, callback, on: events)
287
- end
288
-
289
- def self.invalidate_cache(keys, *args, rule)
290
- start_time = Time.current
291
- sweeper = rule[:sweeper_class]
292
- trigger = resolve_trigger(rule, sweeper)
293
- mode = resolve_mode(rule, sweeper)
294
- sidekiq_opts = resolve_sidekiq_options(rule, sweeper)
295
-
296
- CacheSweeper::Logger.debug("Cache invalidation started", {
297
- sweeper: sweeper&.name,
298
- trigger: trigger,
299
- mode: mode,
300
- keys_count: Array(keys).length
301
- })
302
-
303
- begin
304
- if trigger == :request && !in_console?
305
- RequestStore.store[:cache_sweeper_request_pending] ||= []
306
- RequestStore.store[:cache_sweeper_request_pending] << { keys: keys, mode: mode, sidekiq_options: sidekiq_opts }
307
- CacheSweeper::Logger.log_cache_operations("Batched for request: #{Array(keys).inspect} (mode: #{mode})", :info, {
308
- keys: Array(keys),
309
- mode: mode,
310
- batch_size: RequestStore.store[:cache_sweeper_request_pending].length
311
- })
312
- else
313
- if mode == :async
314
- CacheSweeper::AsyncWorker.set(sidekiq_opts).perform_async(keys, trigger)
315
- CacheSweeper::Logger.log_cache_operations("Scheduled async job for: #{Array(keys).inspect}", :info, {
316
- keys: Array(keys),
317
- sidekiq_options: sidekiq_opts
318
- })
319
- else
320
-
321
- deleted_count = CacheSweeper.delete_cache_keys(keys, {
322
- sweeper: sweeper&.name,
323
- mode: :inline,
324
- trigger: :instant
325
- })
326
- failed_count = Array(keys).length - deleted_count
327
-
328
- CacheSweeper::Logger.log_cache_operations("Instant deletion completed", :info, {
329
- deleted_count: deleted_count,
330
- failed_count: failed_count,
331
- total_keys: Array(keys).length
332
- })
333
- end
334
- end
335
-
336
- duration = (Time.current - start_time) * 1000
337
- CacheSweeper::Logger.log_performance("cache_invalidation", duration, {
338
- trigger: trigger,
339
- mode: mode,
340
- keys_count: Array(keys).length
341
- })
342
-
343
- rescue => e
344
- duration = (Time.current - start_time) * 1000
345
- CacheSweeper::Logger.log_error(e, {
346
- sweeper: sweeper&.name,
347
- trigger: trigger,
348
- mode: mode,
349
- keys: Array(keys),
350
- duration_ms: duration.round(3),
351
- error_type: 'cache_invalidation_error'
352
- })
353
- end
354
- end
355
-
356
- def self.in_console?
357
- defined?(Rails::Console) || Rails.const_defined?('Console')
358
- end
359
- end
360
- end
@@ -1,104 +0,0 @@
1
- # lib/cache_sweeper/logger.rb
2
- module CacheSweeper
3
- class Logger
4
- class << self
5
- def log(level, message, context = {})
6
- return unless should_log?(level)
7
-
8
- formatted_message = format_message(message, level, context)
9
- CacheSweeper.logger.send(level, formatted_message)
10
- end
11
-
12
- def debug(message, context = {})
13
- log(:debug, message, context)
14
- end
15
-
16
- def info(message, context = {})
17
- log(:info, message, context)
18
- end
19
-
20
- def warn(message, context = {})
21
- log(:warn, message, context)
22
- end
23
-
24
- def error(message, context = {})
25
- log(:error, message, context)
26
- end
27
-
28
- def log_initialization(message, context = {})
29
- info("Initialization: #{message}", context)
30
- end
31
-
32
- def log_rule_execution(rule, record, result, context = {})
33
- sweeper_name = rule[:sweeper_class]&.name || 'Unknown'
34
- model_name = record.class.name
35
- record_id = record.respond_to?(:id) ? record.id : 'unknown'
36
-
37
- message = "Rule execution: #{sweeper_name} -> #{model_name}##{record_id}"
38
- context.merge!({
39
- sweeper: sweeper_name,
40
- model: model_name,
41
- record_id: record_id,
42
- association: rule[:association],
43
- attributes: rule[:attributes],
44
- condition_result: result,
45
- batching_mode: rule[:batching_mode],
46
- async: rule[:async]
47
- })
48
-
49
- debug(message, context)
50
- end
51
-
52
- def log_performance(operation, duration, context = {})
53
- message = "Performance: #{operation} took #{duration.round(3)}ms"
54
- context.merge!({
55
- operation: operation,
56
- duration_ms: duration.round(3)
57
- })
58
-
59
- debug(message, context)
60
- end
61
-
62
- def log_error(error, context = {})
63
- message = "Error: #{error.class.name}: #{error.message}"
64
- context.merge!({
65
- error_class: error.class.name,
66
- error_message: error.message,
67
- backtrace: error.backtrace&.first(5)
68
- })
69
-
70
- error(message, context)
71
- end
72
-
73
- def log_cache_operations(message, level = :info, context = {})
74
- log(level, message, context)
75
- end
76
-
77
- def log_async_jobs(message, level = :info, context = {})
78
- log(level, message, context)
79
- end
80
-
81
- def log_middleware(message, level = :info, context = {})
82
- log(level, message, context)
83
- end
84
-
85
- private
86
-
87
- def should_log?(level)
88
- return false unless CacheSweeper.logger
89
-
90
- level_priority = { debug: 0, info: 1, warn: 2, error: 3 }
91
- current_level_priority = level_priority[CacheSweeper.log_level] || 1
92
- requested_level_priority = level_priority[level] || 1
93
-
94
- requested_level_priority >= current_level_priority
95
- end
96
-
97
- def format_message(message, level, context)
98
- timestamp = Time.current.strftime("%Y-%m-%d %H:%M:%S.%3N")
99
- context_str = context.any? ? " #{context.inspect}" : ""
100
- "[CacheSweeper] [#{timestamp}] [#{level.to_s.upcase}] #{message}#{context_str}"
101
- end
102
- end
103
- end
104
- end
@@ -1,4 +0,0 @@
1
- require 'rake'
2
-
3
- namespace :cache_sweeper do
4
- end