cache_sweeper 0.1.0

data/lib/cache_sweeper/logger.rb

@@ -0,0 +1,104 @@
+# lib/cache_sweeper/logger.rb
+module CacheSweeper
+  class Logger
+    class << self
+      def log(level, message, context = {})
+        return unless should_log?(level)
+
+        formatted_message = format_message(message, level, context)
+        CacheSweeper.logger.send(level, formatted_message)
+      end
+
+      def debug(message, context = {})
+        log(:debug, message, context)
+      end
+
+      def info(message, context = {})
+        log(:info, message, context)
+      end
+
+      def warn(message, context = {})
+        log(:warn, message, context)
+      end
+
+      def error(message, context = {})
+        log(:error, message, context)
+      end
+
+      def log_initialization(message, context = {})
+        info("Initialization: #{message}", context)
+      end
+
+      def log_rule_execution(rule, record, result, context = {})
+        sweeper_name = rule[:sweeper_class]&.name || 'Unknown'
+        model_name = record.class.name
+        record_id = record.respond_to?(:id) ? record.id : 'unknown'
+
+        message = "Rule execution: #{sweeper_name} -> #{model_name}##{record_id}"
+        context.merge!({
+          sweeper: sweeper_name,
+          model: model_name,
+          record_id: record_id,
+          association: rule[:association],
+          attributes: rule[:attributes],
+          condition_result: result,
+          batching_mode: rule[:batching_mode],
+          async: rule[:async]
+        })
+
+        debug(message, context)
+      end
+
+      def log_performance(operation, duration, context = {})
+        message = "Performance: #{operation} took #{duration.round(3)}ms"
+        context.merge!({
+          operation: operation,
+          duration_ms: duration.round(3)
+        })
+
+        debug(message, context)
+      end
+
+      def log_error(error, context = {})
+        message = "Error: #{error.class.name}: #{error.message}"
+        context.merge!({
+          error_class: error.class.name,
+          error_message: error.message,
+          backtrace: error.backtrace&.first(5)
+        })
+
+        error(message, context)
+      end
+
+      def log_cache_operations(message, level = :info, context = {})
+        log(level, message, context)
+      end
+
+      def log_async_jobs(message, level = :info, context = {})
+        log(level, message, context)
+      end
+
+      def log_middleware(message, level = :info, context = {})
+        log(level, message, context)
+      end
+
+      private
+
+      def should_log?(level)
+        return false unless CacheSweeper.logger
+
+        level_priority = { debug: 0, info: 1, warn: 2, error: 3 }
+        current_level_priority = level_priority[CacheSweeper.log_level] || 1
+        requested_level_priority = level_priority[level] || 1
+
+        requested_level_priority >= current_level_priority
+      end
+
+      def format_message(message, level, context)
+        timestamp = Time.current.strftime("%Y-%m-%d %H:%M:%S.%3N")
+        context_str = context.any? ? " #{context.inspect}" : ""
+        "[CacheSweeper] [#{timestamp}] [#{level.to_s.upcase}] #{message}#{context_str}"
+      end
+    end
+  end
+end

data/lib/cache_sweeper/railtie.rb

@@ -0,0 +1,13 @@
+module CacheSweeper
+  class Railtie < Rails::Railtie
+    initializer "cache_sweeper.configure_defaults" do
+      CacheSweeper.configure_defaults
+    end
+
+    config.after_initialize do
+      CacheSweeper.validate_configuration!
+      CacheSweeper::Loader.load_sweepers!
+      CacheSweeper::Loader.hook_sweepers!
+    end
+  end
+end

data/lib/cache_sweeper/version.rb

@@ -0,0 +1,3 @@
+module CacheSweeper
+  VERSION = "0.1.0"
+end

data/lib/cache_sweeper.rb

@@ -0,0 +1,108 @@
+require "cache_sweeper/version"
+require "cache_sweeper/dsl"
+require "cache_sweeper/base"
+require "cache_sweeper/logger"
+require "cache_sweeper/loader"
+require "cache_sweeper/async_worker"
+require "cache_sweeper/flush_middleware"
+
+module CacheSweeper
+  class Error < StandardError; end
+
+  DEFAULTS = {
+    log_level: :info,
+    trigger:   :instant,
+    mode:      :inline,
+    queue:     :default,
+    sidekiq_options: {},
+    delete_multi_batch_size: 100
+  }.freeze
+
+  class << self
+    attr_accessor :logger, :log_level, :trigger, :mode, :queue, :sidekiq_options, :delete_multi_batch_size
+
+    def configure
+      yield self
+    end
+
+    def configure_defaults
+      DEFAULTS.each { |k, v| instance_variable_set("@#{k}", v) }
+
+      if defined?(Rails)
+        @log_level =
+          if Rails.env.development?
+            :debug
+          elsif Rails.env.production?
+            :warn
+          else
+            :info
+          end
+      end
+    end
+
+    def log_level=(level)
+      valid_levels = %i[debug info warn error]
+      unless valid_levels.include?(level)
+        raise ArgumentError,
+              "Invalid log level: #{level}. Must be one of: #{valid_levels.join(', ')}"
+      end
+      @log_level = level
+    end
+
+    def attached_sweepers
+      @attached_sweepers ||= []
+    end
+
+    def validate_configuration!
+      validate_async_mode(@mode, "global configuration")
+    end
+
+    def validate_async_mode(mode, context)
+      if mode == :async && !defined?(Sidekiq)
+        warn "CacheSweeper Warning: #{context} has mode set to :async but Sidekiq is not available. " \
+             "Async jobs will be executed synchronously. " \
+             "Add 'gem \"sidekiq\"' to your Gemfile to enable async processing."
+      end
+    end
+
+  def delete_cache_keys(keys, context = {})
+    keys_array = Array(keys)
+    return 0 if keys_array.empty?
+
+    batch_size = @delete_multi_batch_size || 100
+    deleted_count = 0
+    failed_count = 0
+
+    keys_array.each_slice(batch_size) do |batch|
+      begin
+        Rails.cache.delete_multi(batch)
+        deleted_count += batch.length
+        CacheSweeper::Logger.log_cache_operations("Deleted batch of #{batch.length} keys", :debug, context.merge({
+          batch_size: batch.length,
+          keys: batch
+        }))
+      rescue => e
+        failed_count += batch.length
+        CacheSweeper::Logger.log_error(e, context.merge({
+          batch_size: batch.length,
+          keys: batch,
+          error_type: 'delete_multi_error'
+        }))
+      end
+    end
+
+    CacheSweeper::Logger.log_cache_operations("Batch deletion completed", :info, context.merge({
+      total_keys: keys_array.length,
+      deleted_count: deleted_count,
+      failed_count: failed_count,
+      batch_size: batch_size
+    }))
+
+    deleted_count
+  end
+  end
+end
+
+if defined?(Rails)
+  require "cache_sweeper/railtie"
+end

data/lib/tasks/cache_sweeper.rake

@@ -0,0 +1,4 @@
+require 'rake'
+
+namespace :cache_sweeper do
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: cache_sweeper
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rafay Qayyum
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-09-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: request_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '8.0'
+- !ruby/object:Gem::Dependency
+  name: sidekiq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description:
+email: rafayqayyum786@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- lib/cache_sweeper.rb
+- lib/cache_sweeper/async_worker.rb
+- lib/cache_sweeper/base.rb
+- lib/cache_sweeper/dsl.rb
+- lib/cache_sweeper/flush_middleware.rb
+- lib/cache_sweeper/loader.rb
+- lib/cache_sweeper/logger.rb
+- lib/cache_sweeper/railtie.rb
+- lib/cache_sweeper/version.rb
+- lib/tasks/cache_sweeper.rake
+homepage: https://github.com/rafayqayyum/cache_sweeper
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: Flexible, rule-based cache invalidation for Rails with batching, async jobs,
+  and association support.
+test_files: []