redis_cron_scheduler 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aae119ff9453e9fef9436fb80e01e49592375abb0855dedc239c9064b8e6a496
+  data.tar.gz: e8fbe149a0bc027a715bdcb0505e03964100cf1f4e0e9bc09ae099381b97caf5
+SHA512:
+  metadata.gz: 0eadc71066e408e327179f38cae367fb88a1c33658f2ce431defc20368746da66872eb4f3d593f3f25ee1d7aa700ed9569f9c76471f642ccf5a8aaa5470ba53f
+  data.tar.gz: e14379fe3db00a100e60c4347a0efe2a7e80365c8421f8f610c129ec1c7d72647bd20d4fcabcd50cc72cf262c8f72d3ebeea750a4f6329b3b9b7ed538a613ba0

data/README.md

@@ -0,0 +1,32 @@
+## Web Dashboard
+
+Acesse o dashboard em: `http://localhost:3000/redis_cron`
+
+### Necessáio:
+export REDIS_NAMESPACE="myapp::"
+export REDIS_WORKER_COUNT=1
+export REDIS_CRON_AUTO_START=true
+
+## Necessário incluir no environment o cache_store
+
+  config.cache_store = :redis_cache_store, {
+    url: "rediss://#{ENV['elasticache_valkey_username']}:#{ENV['elasticache_valkey_password']}@#{ENV['REDIS_SERVER']}:6379/0",
+    ssl_params: { verify_mode: OpenSSL::SSL::VERIFY_NONE },
+    namespace: ENV['REDIS_NAMESPACE']
+  }
+
+# incluir no config/routes.rb
+
+  scope "/redis_cron", module: "redis_cron_scheduler/web", as: "redis_cron_scheduler_web" do
+    root to: "redis_jobs#index"
+    resources :redis_jobs, only: [:index]
+  end
+
+### Features do Dashboard:
+- 📊 Estatísticas em tempo real
+- 👀 Visualização de todas as filas
+- ⏰ Jobs agendados
+- 🔄 Jobs em retry
+- 💀 Dead jobs
+- 🏃 Jobs em execução
+- ⚡ Ações: retry, delete, retry all, delete all

data/config/scheduled_jobs.json

@@ -0,0 +1,12 @@
+{
+  "jobs": [
+    {
+      "name": "example_job",
+      "job_class": "ExampleJob",
+      "cron_expression": "0 * * * *",
+      "arguments": [],
+      "queue": "default",
+      "description": "Example job running hourly"
+    }
+  ]
+}

data/lib/redis_cron_scheduler/cron_scheduler.rb

@@ -0,0 +1,347 @@
+# lib/redis_cron_scheduler/cron_scheduler.rb
+module RedisCronScheduler
+  class CronScheduler
+    # ... (todo o código do CronScheduler aqui)
+    # Apenas mude as constantes para configuração:
+    CONFIG_FILE = File.expand_path("config/scheduled_jobs.json", Dir.pwd)
+
+    REDIS_NAMESPACE      = (ENV['REDIS_NAMESPACE'] || "queue:").freeze
+    LOCK_KEY = "#{REDIS_NAMESPACE}cron_scheduler:lock"
+    POLL_INTERVAL = 45.seconds
+    LOCK_TIMEOUT = 30.seconds 
+    CONFIG_CHECK_INTERVAL = 300.seconds
+
+    class << self
+        def start
+            new.run
+        end
+
+        def shutdown
+            @running = false
+            Rails.logger.info "[CronScheduler] Desligamento solicitado..."
+        end
+
+        def running?
+            @running == true
+        end
+    end
+
+    def initialize
+        @running = Concurrent::AtomicBoolean.new(true)  # Use AtomicBoolean
+        @scheduled_jobs = {}
+        @last_config_check = Time.now
+
+        Rails.logger.info "[CronScheduler] Timezone configurado: #{Time.zone.name}"
+        Rails.logger.info "[CronScheduler] Hora atual: #{Time.current.strftime('%H:%M:%S %Z')}"
+
+        setup_signal_handlers
+        load_and_schedule_jobs
+    end
+
+    def run
+        Rails.logger.info "[CronScheduler] Iniciando agendador..."
+        iteration = 0
+        
+        while @running.true?
+        iteration += 1
+        Rails.logger.debug "[CronScheduler] Iteração ##{iteration} - #{Time.now.strftime('%H:%M:%S')}"
+        
+        begin
+            # Usar lock distribuído para evitar execução duplicada
+            with_redis_lock do
+            check_config_changes
+            execute_due_jobs
+            end
+            
+            sleep_gracefully(POLL_INTERVAL)
+        rescue => e
+            Rails.logger.error "[CronScheduler] Erro no loop principal: #{e.message}"
+            sleep_gracefully(5)
+        end
+        end
+    end
+
+
+    def shutdown
+        @running.make_false  # ⬅️ Use make_false para AtomicBoolean
+        Rails.logger.info "[CronScheduler] Desligando..."
+    end
+
+    private
+
+    def sleep_gracefully(seconds)
+        # ⬇️ Dormir o tempo total, mas verificar @running periodicamente ⬇️
+        end_time = Time.now + seconds
+        while Time.now < end_time && @running
+        sleep [1, end_time - Time.now].min  # Verificar a cada 1 segundo
+        end
+    end
+
+    def with_redis_lock(&block)
+        with_redis do |conn|
+        lock_acquired = conn.set(LOCK_KEY, Process.pid, nx: true, ex: LOCK_TIMEOUT)
+        if lock_acquired
+            begin
+            Rails.logger.debug "[CronScheduler] 🔒 Lock adquirido"
+            yield
+            ensure
+            conn.del(LOCK_KEY) if conn.get(LOCK_KEY) == Process.pid.to_s
+            Rails.logger.debug "[CronScheduler] 🔓 Lock liberado"
+            end
+        else
+            # ⬇️ NÃO BLOQUEIE - apenas log e continue ⬇️
+            current_pid = conn.get(LOCK_KEY)
+            Rails.logger.debug "[CronScheduler] ⏩ Lock ocupado (PID: #{current_pid}), pulando execução"
+        end
+        end
+    end
+
+    def check_config_changes
+        return unless Time.now - @last_config_check >= CONFIG_CHECK_INTERVAL
+
+        load_and_schedule_jobs
+        @last_config_check = Time.now
+    end
+
+    def load_and_schedule_jobs
+        config = load_config
+        current_jobs = config[:jobs] || []
+        
+        Rails.logger.info "[CronScheduler] 📋 Jobs encontrados no config: #{current_jobs.map { |j| j[:name] }.join(', ')}"
+        Rails.logger.debug "[CronScheduler] Config completo: #{config.inspect}"  # ⬅️ DEBUG
+        
+        # Identificar mudanças de forma mais eficiente
+        detect_and_apply_changes(current_jobs)
+        
+        # Executar jobs que estão no horário (já dentro do lock)
+        execute_due_jobs
+    end
+
+
+
+    def load_config
+        return { jobs: [] } unless File.exist?(CONFIG_FILE)
+        
+        begin
+        file_content = File.read(CONFIG_FILE)
+        config = JSON.parse(file_content, symbolize_names: true)
+        
+        # ⬇️ CORREÇÃO: Garanta que sempre retorne um hash com :jobs ⬇️
+        if config.is_a?(Hash) && config.has_key?(:jobs)
+            config
+        elsif config.is_a?(Array)
+            { jobs: config }  # Se for array, converta para hash
+        else
+            Rails.logger.error "[CronScheduler] Formato inválido no config: #{config.class}"
+            { jobs: [] }
+        end
+        
+        rescue JSON::ParserError => e
+        Rails.logger.error "Erro ao parsear #{CONFIG_FILE}: #{e.message}"
+        { jobs: [] }
+        rescue => e
+        Rails.logger.error "Erro ao carregar config: #{e.message}"
+        { jobs: [] }
+        end
+    end
+
+    def detect_and_apply_changes(current_jobs)
+        current_names = current_jobs.map { |j| j[:name].to_s }
+        existing_names = @scheduled_jobs.keys
+        
+        Rails.logger.info "[CronScheduler] 🔄 Comparando: atuais=#{current_names}, existentes=#{existing_names}"
+        
+        # Remover jobs que não existem mais
+        (existing_names - current_names).each { |job_name| unschedule_job(job_name) }
+        
+        # Adicionar/atualizar jobs
+        current_jobs.each do |job|
+        job_name = job[:name].to_s
+        if !@scheduled_jobs[job_name] || job_changed?(@scheduled_jobs[job_name][:config], job)
+            Rails.logger.info "[CronScheduler] ➕ Agendando/atualizando: #{job_name}"
+            schedule_job(job)
+        else
+            Rails.logger.debug "[CronScheduler] ⏩ Job unchanged: #{job_name}"
+        end
+        end
+    end
+
+    def job_changed?(old_job, new_job)
+        old_job[:cron_expression] != new_job[:cron_expression] ||
+        old_job[:job_class] != new_job[:job_class] ||
+        old_job[:arguments] != new_job[:arguments] ||
+        old_job[:queue] != new_job[:queue]
+    end
+
+    def execute_due_jobs
+        now = Time.current  # ⬅️ Use Time.current
+        Rails.logger.debug "[CronScheduler] Verificando jobs às #{now.strftime('%H:%M:%S %Z')}"
+        
+        jobs_executados = 0
+        @scheduled_jobs.each do |job_name, job_info|
+        next unless job_info[:next_execution] && job_info[:next_execution] <= now
+
+        Rails.logger.info "[CronScheduler] ⏰ EXECUTANDO: #{job_name} (agendado para #{job_info[:next_execution].strftime('%H:%M:%S %Z')})"
+        
+        begin
+            enqueue_job_for_execution(job_info[:config])
+            jobs_executados += 1
+            
+            # Reagendar para próxima execução
+            next_time = calculate_next_execution(job_info[:cron_expression])
+            @scheduled_jobs[job_name][:next_execution] = next_time
+            @scheduled_jobs[job_name][:last_execution] = now
+            
+            Rails.logger.info "[CronScheduler] ✅ #{job_name} executado. Próximo: #{next_time.strftime('%H:%M:%S %Z')}"
+        rescue => e
+            Rails.logger.error "[CronScheduler] ❌ Erro ao executar #{job_name}: #{e.message}"
+        end
+        end
+        
+        Rails.logger.debug "[CronScheduler] #{jobs_executados} jobs executados nesta verificação"
+    end
+
+    def calculate_next_execution(cron_expression)
+        fugit_cron = Fugit::Cron.parse(cron_expression)
+        
+        unless fugit_cron
+        Rails.logger.error "[CronScheduler] Expressão cron inválida: #{cron_expression}"
+        return Time.current + 24.hours
+        end
+        
+        # ⬇️ USE Time.current (que respeita config.time_zone) ⬇️
+        next_time = fugit_cron.next_time(Time.current)
+        Rails.logger.debug "[CronScheduler] Fugit: '#{cron_expression}' -> #{next_time} (timezone: #{Time.zone.name})"
+        next_time
+        
+    rescue => e
+        Rails.logger.error "[CronScheduler] Erro no cron expression '#{cron_expression}': #{e.message}"
+        Time.current + 24.hours
+    end
+
+
+    # app/services/cron_scheduler.rb
+    private
+
+    def enqueue_job_for_execution(job_config)
+        # ⬇️ ESTRUTURA COMPATÍVEL COM REDIS QUEUE WORKER ⬇️
+        job_data = {
+        job_class: job_config[:job_class],
+        arguments: job_config[:arguments] || [],
+        queue: job_config[:queue] || "default",
+        job_id: "cron_#{job_config[:name]}_#{Time.now.to_i}_#{SecureRandom.hex(4)}",
+        
+        # ⬇️ METADADOS ESPECÍFICOS PARA JOBS CRON ⬇️
+        cron_expression: job_config[:cron_expression],
+        cron_uuid: SecureRandom.uuid,
+        cron_name: job_config[:name],
+        scheduled_at: Time.now.iso8601,
+        retry_count: 0,
+        enqueued_at: Time.now.iso8601
+        }
+        
+        queue_name = job_config[:queue] || "default"
+        
+        # ⬇️ CORREÇÃO: Use a chave correta para o RedisQueueWorker ⬇️
+        redis_key = "#{REDIS_NAMESPACE}queue:#{queue_name}"  # SEM "queue:" extra!
+        
+        # ⬇️ ENFILEIRAR NO REDIS ⬇️
+        with_redis do |conn|
+        conn.rpush(redis_key, job_data.to_json)
+        Rails.logger.info "[CronScheduler] Job #{job_config[:name]} enfileirado na chave: #{redis_key}"
+        end
+        
+    rescue => e
+        Rails.logger.error "[CronScheduler] Erro ao enfileirar #{job_config[:name]}: #{e.message}"
+    end
+
+
+    def schedule_job(job_config)
+        job_name = job_config[:name].to_s
+        cron_expression = job_config[:cron_expression]
+        
+        begin
+        next_time = calculate_next_execution(cron_expression)
+        @scheduled_jobs[job_name] = {
+            config: job_config,
+            cron_expression: cron_expression,
+            next_execution: next_time,
+            last_execution: nil
+        }
+        
+        Rails.logger.info "[CronScheduler] 📅 Agendado #{job_name} para #{next_time.strftime('%H:%M:%S')} (cron: #{cron_expression})"
+        rescue => e
+        Rails.logger.error "[CronScheduler] Erro ao agendar #{job_name}: #{e.message}"
+        end
+    end
+
+    def unschedule_job(job_name)
+        @scheduled_jobs.delete(job_name)
+        Rails.logger.info "[CronScheduler] Removido agendamento para #{job_name}"
+    end
+
+    def load_config
+        return { jobs: [] } unless File.exist?(CONFIG_FILE)
+        
+        begin
+        file_content = File.read(CONFIG_FILE)
+        JSON.parse(file_content, symbolize_names: true) || { jobs: [] }
+        rescue JSON::ParserError => e
+        Rails.logger.error "Erro ao parsear #{CONFIG_FILE}: #{e.message}"
+        { jobs: [] }
+        rescue => e
+        Rails.logger.error "Erro ao carregar config: #{e.message}"
+        { jobs: [] }
+        end
+    end
+
+    def with_redis
+        Rails.cache.redis.with { |conn| yield conn }
+    rescue Redis::BaseConnectionError => e
+        Rails.logger.error "Redis connection error: #{e.message}"
+        raise
+    end
+
+    def setup_signal_handlers
+        # ⬇️ Use $stdout.puts em vez de Rails.logger dentro do trap ⬇️
+        Signal.trap("TERM") do
+        $stdout.puts "[CronScheduler] Sinal TERM recebido, iniciando shutdown..."
+        @running.make_false  # ⬅️ Use make_false
+        end
+        
+        Signal.trap("INT") do
+        $stdout.puts "[CronScheduler] Sinal INT recebido, iniciando shutdown..." 
+        @running.make_false  # ⬅️ Use make_false
+        end
+    end
+
+    # Remover métodos de classe antigos não utilizados
+    class << self
+        undef_method :scheduled_key, :cron_jobs_registry_key, :schedule_all_jobs, 
+                    :clear_existing_config_jobs if method_defined?(:schedule_all_jobs)
+    end    
+
+
+
+
+
+    # Adicione métodos de classe para configuração
+    class << self
+      def config_file=(path)
+        @config_file = path
+      end
+      
+      def config_file
+        @config_file || CONFIG_FILE
+      end
+      
+      def redis_namespace=(namespace)
+        @redis_namespace = namespace
+      end
+      
+      def redis_namespace
+        @redis_namespace || REDIS_NAMESPACE
+      end
+    end
+  end
+end

data/lib/redis_cron_scheduler/railtie.rb

@@ -0,0 +1,25 @@
+require 'rails'
+require 'redis_cron_scheduler/web/engine'  # <-- garante que a engine existe
+
+module RedisCronScheduler
+  class Railtie < Rails::Railtie
+    initializer "redis_cron_scheduler.setup" do |app|
+      app.config.after_initialize do
+        if ENV['REDIS_CRON_AUTO_START'] != 'false'
+          RedisCronScheduler.start_scheduler
+          RedisCronScheduler.start_workers
+        end
+      end
+    end
+
+#    initializer "redis_cron_scheduler.routes" do |app|
+#      app.routes.append do
+#        mount RedisCronScheduler::Web::Engine => '/redis_cron'
+#      end
+#    end
+
+    rake_tasks do
+      load File.expand_path('../tasks/redis_cron_scheduler.rake', __FILE__)
+    end
+  end
+end

data/lib/redis_cron_scheduler/redis_queue_worker.rb

@@ -0,0 +1,544 @@
+# lib/redis_cron_scheduler/redis_queue_worker.rb
+module RedisCronScheduler
+  class RedisQueueWorker
+    # --- Configuráveis via ENV ---
+    POLL_INTERVAL        = (ENV['REDIS_POLL_INTERVAL'] || 10).to_f            # segundos quando fila vazia
+    RUNNING_TTL          = (ENV['REDIS_RUNNING_TTL'] || 15).to_i            # lease por job (segundos)
+    LEASE_RENEW_INTERVAL = (ENV['REDIS_LEASE_RENEW_INTERVAL'] || 5).to_i    # frequência de renovação do lease
+    CLEANUP_INTERVAL     = (ENV['REDIS_CLEANUP_INTERVAL'] || 300).to_i       # varredura de cleanup (segundos)
+    MAX_JOBS_PER_CYCLE   = (ENV['REDIS_MAX_JOBS_PER_CYCLE'] || 100).to_i
+    SHUTDOWN_TIMEOUT     = (ENV['REDIS_SHUTDOWN_TIMEOUT'] || 30).to_i        # tempo para aguardar jobs terminarem no shutdown (s)
+    REDIS_NAMESPACE      = (ENV['REDIS_NAMESPACE'] || "queue:").freeze
+
+    # filas + peso (peso influencia chance de ser escolhida)
+    QUEUE_WEIGHTS = {
+        "critical" => 3,
+        "mailers"  => 2,
+        "default"  => 1
+    }.freeze
+
+    RETRY_INTERVALS = [5, 15, 30, 60, 300].freeze
+
+    # --- Lua scripts (mantêm atomicidade de movimentos) ---
+    LUA_MOVE_SCHEDULED = <<~LUA
+        local scheduled_key = KEYS[1]
+        local queue_key = KEYS[2]
+        local now = tonumber(ARGV[1])
+        local jobs = redis.call('ZRANGEBYSCORE', scheduled_key, 0, now)
+        for i, job in ipairs(jobs) do
+        redis.call('RPUSH', queue_key, job)
+        redis.call('ZREM', scheduled_key, job)
+        end
+        return #jobs
+    LUA
+
+    LUA_MOVE_RETRY = <<~LUA
+        local retry_key = KEYS[1]
+        local queue_key = KEYS[2]
+        local now = tonumber(ARGV[1])
+        local jobs = redis.call('ZRANGEBYSCORE', retry_key, 0, now)
+        for i, job in ipairs(jobs) do
+        redis.call('RPUSH', queue_key, job)
+        redis.call('ZREM', retry_key, job)
+        end
+        return #jobs
+    LUA
+
+    # LMOVE atômico (fila -> running). Lease é gerenciado depois no Ruby.
+    LUA_POP_JOB = <<~LUA
+        local queue_key = KEYS[1]
+        local running_key = KEYS[2]
+        return redis.call('LMOVE', queue_key, running_key, 'RIGHT', 'LEFT')
+    LUA
+
+    # --- Inicialização ---
+    def self.start
+        new.run
+    end
+
+    def initialize
+        @worker_id = "#{Socket.gethostname}:#{Process.pid}:#{Thread.current.object_id}"
+        @running = Concurrent::AtomicBoolean.new(true)
+        @shutdown_immediate = Concurrent::AtomicBoolean.new(false)
+
+        # estrutura para acompanhar leases que este worker criou
+        @leases_mutex = Mutex.new
+        @active_leases = {} # lease_key => expiration_time (apenas para inspeção rápida)
+
+        # preparar array ponderado para seleção de fila
+        @weighted_queues = build_weighted_queue_array(QUEUE_WEIGHTS)
+
+        # controle de limpeza periódico
+        @last_cleanup = Time.at(0)
+    end
+
+    # --- Loop principal ---
+    def run
+        Rails.logger.info "[RedisQueueWorker] Iniciando worker #{@worker_id}..."
+        setup_signal_handlers
+
+        # start lease renewer thread
+        @renewer_thread = Thread.new { lease_renewer_loop }
+        @last_config_check = Time.now
+
+        # carregar scripts em cada conexão não estritamente necessário, usamos EVAL direto
+        while @running.true?
+        begin
+            # cleanup periódico de stuck jobs
+            if Time.now - @last_cleanup >= CLEANUP_INTERVAL
+            cleanup_stuck_jobs
+            @last_cleanup = Time.now
+            end
+
+            # mover scheduled/retry prontos
+            move_scheduled_to_queue
+            move_retry_to_queue
+
+
+            processed = process_up_to_limit(MAX_JOBS_PER_CYCLE)
+
+            # polling inteligente: só dorme quando não processou nada
+            if processed == 0 && !@shutdown_immediate.true?
+            sleep POLL_INTERVAL
+            end
+        rescue => e
+            Rails.logger.error "[RedisQueueWorker] Erro no loop principal: #{e.class} - #{e.message}"
+            Rails.logger.error e.backtrace.join("\n")
+            sleep 1
+        end
+        end
+
+        # se shutdown normal (graceful) aguardar jobs em andamento
+        if !@shutdown_immediate.true?
+        wait_for_active_jobs_or_timeout(SHUTDOWN_TIMEOUT)
+        end
+
+        # finalizar renewer
+        @renewer_thread&.kill
+        Rails.logger.info "[RedisQueueWorker] Worker #{@worker_id} finalizado."
+    end
+
+    def shutdown(immediate: false)
+        @shutdown_immediate.make_true if immediate
+        @running.make_false
+        Rails.logger.info "[RedisQueueWorker] Shutdown solicitado (immediate: #{immediate})"
+    end
+
+    private
+
+    # --------------- Redis helpers (usa connection pool do Rails)
+    def with_redis
+        Rails.cache.redis.with do |conn|
+        yield conn
+        end
+    end
+
+    def queue_key(queue);   "#{REDIS_NAMESPACE}queue:#{queue}"; end
+    def running_key(queue); "#{REDIS_NAMESPACE}running:#{queue}:#{@worker_id}"; end
+    def lease_key(queue, job_id); "#{REDIS_NAMESPACE}running_lease:#{queue}:#{job_id}"; end
+    def retry_key(queue);   "#{REDIS_NAMESPACE}retry:#{queue}"; end
+    def dead_key(queue);    "#{REDIS_NAMESPACE}dead:#{queue}"; end
+    def scheduled_key(queue); "#{REDIS_NAMESPACE}schedule:#{queue}"; end
+
+    # --------------- Weighted queue array
+    def build_weighted_queue_array(weights_hash)
+        arr = []
+        weights_hash.each do |q, w|
+        next if w.to_i <= 0
+        w.times { arr << q.to_s }
+        end
+        arr.freeze
+    end
+
+    # Escolhe uma fila aleatoriamente ponderada
+    def pick_weighted_queue
+        @weighted_queues.sample
+    end
+
+    # --------------- Move scheduled -> queue
+    def move_scheduled_to_queue
+        with_redis do |conn|
+        now = Time.now.to_f
+        QUEUE_WEIGHTS.keys.each do |queue|
+            begin
+            moved = conn.eval(LUA_MOVE_SCHEDULED, [scheduled_key(queue), queue_key(queue)], [now])
+            Rails.logger.debug "[RedisQueueWorker] moved #{moved} scheduled -> #{queue}" if moved.to_i > 0
+            rescue => e
+            Rails.logger.error "[RedisQueueWorker] Erro move_scheduled_to_queue #{queue}: #{e.message}"
+            end
+        end
+        end
+    end
+
+    # --------------- Move retry -> queue
+    def move_retry_to_queue
+        with_redis do |conn|
+        now = Time.now.to_f
+        QUEUE_WEIGHTS.keys.each do |queue|
+            begin
+            moved = conn.eval(LUA_MOVE_RETRY, [retry_key(queue), queue_key(queue)], [now])
+            Rails.logger.debug "[RedisQueueWorker] moved #{moved} retry -> #{queue}" if moved.to_i > 0
+            rescue => e
+            Rails.logger.error "[RedisQueueWorker] Erro move_retry_to_queue #{queue}: #{e.message}"
+            end
+        end
+        end
+    end
+
+    # --------------- Processamento: até N jobs por ciclo (evita starvation)
+    def process_up_to_limit(limit)
+        processed = 0
+        limit.times do
+        break unless @running.true?
+        found = process_one_job_from_any_queue
+        break if found == 0
+        processed += found
+        end
+        processed
+    end
+
+    # Tenta pop atômico (LMOVE) de acordo com prioridade ponderada.
+    # Retorna 1 se processou um job, 0 caso contrário.
+    def process_one_job_from_any_queue
+        # Try several times picking weighted queues; this balances priorities but still probes other queues.
+        trials = @weighted_queues.size
+        trials.times do
+        queue = pick_weighted_queue
+        with_redis do |conn|
+            begin
+            job_json = conn.eval(LUA_POP_JOB, [queue_key(queue), running_key(queue)], [])
+            rescue => e
+            Rails.logger.error "[RedisQueueWorker] Erro LMOVE em #{queue}: #{e.message}"
+            next
+            end
+
+            next unless job_json
+
+            # processou
+            process_single_job(job_json, queue, conn)
+            return 1
+        end
+        end
+
+        # se nenhum dos picks retornou job, realizar uma verificação direta nas filas (fallback)
+        QUEUE_WEIGHTS.keys.each do |queue|
+        with_redis do |conn|
+            job_json = begin
+            conn.eval(LUA_POP_JOB, [queue_key(queue), running_key(queue)], [])
+            rescue => e
+            Rails.logger.error "[RedisQueueWorker] Erro LMOVE fallback em #{queue}: #{e.message}"
+            nil
+            end
+            next unless job_json
+            process_single_job(job_json, queue, conn)
+            return 1
+        end
+        end
+
+        0
+    end
+
+    # --- Processa job que já está no running (job_json já movido atômicamente)
+    def process_single_job(job_json, queue, conn)
+        job_data = parse_job_json(job_json)
+        unless job_data
+        # job corrompido: joga no dead para análise
+        Rails.logger.error "[RedisQueueWorker] Job inválido detectado na fila running: #{job_json.inspect}"
+        conn.zadd(dead_key(queue), Time.now.to_f, job_json)
+        # remove da running list onde foi colocado
+        conn.lrem(running_key(queue), 0, job_json)
+        return
+        end
+
+        job_id = job_data[:job_id] || Digest::SHA1.hexdigest(job_json)
+        lease_k = lease_key(queue, job_id)
+
+        # criar lease e registrar localmente
+        conn.setex(lease_k, RUNNING_TTL, job_json)
+        register_lease_local(lease_k, Time.now + RUNNING_TTL)
+
+        begin
+        run_job(job_json, queue, conn)
+        # sucesso: remove da running da lista (a LMOVE já colocou o job lá)
+        conn.lrem(running_key(queue), 0, job_json)
+        rescue => e
+        Rails.logger.error "[RedisQueueWorker] Erro inesperado ao processar job #{job_id}: #{e.class} - #{e.message}"
+        # run_job já faz retry/dead quando apropriado
+        ensure
+        # remover lease local e redis (caso ainda exista)
+        unregister_lease_local(lease_k)
+        conn.del(lease_k) rescue nil
+        end
+    end
+
+    def run_job(job_json, queue, conn)
+        job_data = parse_job_json(job_json)
+        return unless job_data
+
+        klass_name  = job_data[:job_class]
+        args        = job_data[:arguments] || []
+        retry_count = job_data[:retry_count] || 0
+        job_id      = job_data[:job_id] || Digest::SHA1.hexdigest(job_json)
+
+        klass = klass_name.to_s.safe_constantize
+        unless klass
+        Rails.logger.error "[RedisQueueWorker] Classe inválida para job #{job_id}: #{klass_name.inspect}"
+        conn.zadd(dead_key(queue), Time.now.to_f, job_json)
+        return
+        end
+
+        Rails.logger.info "[RedisQueueWorker] Executando #{klass_name} (#{job_id}) fila=#{queue} retry=#{retry_count}"
+        
+        begin
+        klass.new.perform(*args)
+        Rails.logger.info "[RedisQueueWorker] Job concluído #{job_id} (#{klass_name})"
+        
+        true
+        rescue => e
+        Rails.logger.error "[RedisQueueWorker] Falha no job #{job_id} (#{klass_name}): #{e.class} - #{e.message}"
+        
+        false
+        end
+    end
+
+    # ⬇️ NOVO MÉTODO: Tratamento especial para falhas de jobs cron ⬇️
+    def handle_cron_job_failure(job_data, job_json, queue, conn, error, retry_count)
+        max_retries = RETRY_INTERVALS.size
+        
+        if retry_count < max_retries
+        # ⬇️ Tentar novamente (retry normal) ⬇️
+        delay = RETRY_INTERVALS[retry_count]
+        retry_job = job_data.merge(
+            retry_count: retry_count + 1,
+            last_error: "#{error.class}: #{error.message}",
+            failed_at: Time.now.iso8601
+        ).to_json
+
+        conn.zadd(retry_key(queue), Time.now.to_f + delay, retry_job)
+        Rails.logger.info "[RedisQueueWorker] Job cron #{job_data[:cron_name]} reenfileirado para retry em #{delay}s"
+        else
+        # ⬇️ MÁXIMO DE RETRIES ATINGIDO - REAGENDAR MESMO ASSIM ⬇️
+        Rails.logger.error "[RedisQueueWorker] Job cron #{job_data[:cron_name]} excedeu retries, mas será reagendado (cron)"
+        
+        # Registrar no dead para análise, mas SEMPRE reagendar
+        conn.zadd(dead_key(queue), Time.now.to_f, job_json)
+        
+        # ⬇️ REAGENDAR PARA PRÓXIMA OCORRÊNCIA ⬇️
+        reschedule_cron_job(job_data, queue, conn)
+        end
+    end
+
+    # ⬇️ MÉTODO EXISTENTE PARA JOBS REGULARES (não cron) ⬇️
+    def handle_regular_job_failure(job_data, job_json, queue, conn, error, retry_count)
+        max_retries = RETRY_INTERVALS.size
+        
+        if retry_count < max_retries
+        delay = RETRY_INTERVALS[retry_count]
+        retry_job = job_data.merge(
+            retry_count: retry_count + 1,
+            last_error: "#{error.class}: #{error.message}",
+            failed_at: Time.now.iso8601
+        ).to_json
+
+        conn.zadd(retry_key(queue), Time.now.to_f + delay, retry_job)
+        Rails.logger.info "[RedisQueueWorker] Job #{job_data[:job_id]} reenfileirado para retry em #{delay}s"
+        else
+        # ⬇️ JOBS REGULARES VÃO PARA DEAD (comportamento normal) ⬇️
+        conn.zadd(dead_key(queue), Time.now.to_f, job_json)
+        Rails.logger.error "[RedisQueueWorker] Job #{job_data[:job_id]} movido para dead (excedeu retries)"
+        end
+    end
+
+    # ⬇️ MÉTODO DE REAGENDAMENTO (já existente) ⬇️
+    def reschedule_cron_job(job_data, queue, conn)
+        cron_expression = job_data[:cron_expression]
+        cron_uuid = job_data[:cron_uuid]
+        
+        next_time = CronParser.next_occurrence(cron_expression, Time.current + 1.minute)
+        
+        new_job_data = job_data.merge(
+        job_id: "cron_#{cron_uuid}_#{next_time.to_i}",
+        scheduled_at: next_time.iso8601,
+        retry_count: 0,  # ⬅️ Resetar retry count para próxima execução
+        last_error: nil,
+        failed_at: nil
+        )
+
+        conn.zadd(
+        scheduled_key(queue), 
+        next_time.to_f, 
+        new_job_data.to_json
+        )
+        
+        Rails.logger.info "[RedisQueueWorker] Job cron #{job_data[:cron_name]} reagendado para #{next_time}"
+    end
+
+    # --- Lease renewer (único thread por worker) ---
+    def lease_renewer_loop
+        loop do
+        break unless @running.true?
+        begin
+            lease_keys = nil
+            @leases_mutex.synchronize { lease_keys = @active_leases.keys.dup }
+            unless lease_keys.empty?
+            with_redis do |conn|
+                lease_keys.each do |lk|
+                # renova apenas se ainda existir no redis (proteção adicional)
+                if conn.exists?(lk)
+                    conn.expire(lk, RUNNING_TTL)
+                    # atualizar nossa expiração local (apenas estimativa)
+                    @leases_mutex.synchronize { @active_leases[lk] = Time.now + RUNNING_TTL }
+                else
+                    # remove local se não existir
+                    @leases_mutex.synchronize { @active_leases.delete(lk) }
+                end
+                end
+            end
+            end
+        rescue => e
+            Rails.logger.error "[RedisQueueWorker] Erro no lease_renewer: #{e.class} - #{e.message}"
+        ensure
+            sleep LEASE_RENEW_INTERVAL
+        end
+        end
+    end
+
+    # Registra lease_local thread-safe
+    def register_lease_local(lease_key, expiry_time)
+        @leases_mutex.synchronize { @active_leases[lease_key] = expiry_time }
+    end
+
+    def unregister_lease_local(lease_key)
+        @leases_mutex.synchronize { @active_leases.delete(lease_key) }
+    end
+
+    # --- Cleanup: reencaminha jobs em running sem lease ---
+    def cleanup_stuck_jobs
+        Rails.logger.info "[RedisQueueWorker] Iniciando cleanup_stuck_jobs..."
+        with_redis do |conn|
+        QUEUE_WEIGHTS.keys.each do |queue|
+            cursor = "0"
+            loop do
+            cursor, keys = conn.scan(cursor, match: "#{REDIS_NAMESPACE}running:#{queue}:*", count: 200)
+            keys.each do |running_k|
+                begin
+                jobs = conn.lrange(running_k, 0, -1)
+                next if jobs.nil? || jobs.empty?
+                jobs.each do |job_json|
+                    jd = parse_job_json(job_json) rescue nil
+                    next unless jd
+                    job_id = jd[:job_id] || Digest::SHA1.hexdigest(job_json)
+                    lease_k = lease_key(queue, job_id)
+                    unless conn.exists?(lease_k)
+                    Rails.logger.warn "[RedisQueueWorker] Cleanup: re-enfileirando job stuck #{job_id} (from #{running_k})"
+                    conn.rpush(queue_key(queue), job_json)
+                    conn.lrem(running_k, 0, job_json)
+                    end
+                end
+                # remove lista running vazia
+                conn.del(running_k) if conn.llen(running_k).to_i == 0
+                rescue => e
+                Rails.logger.error "[RedisQueueWorker] Erro no cleanup para #{running_k}: #{e.message}"
+                end
+            end
+            break if cursor == "0"
+            end
+        end
+        end
+    end
+
+    # --- Utilitários e fallback ---
+    def parse_job_json(json)
+        data = JSON.parse(json, symbolize_names: true)
+        
+        # ⬇️ COMPATIBILIDADE COM CRON_SCHEDULER ⬇️
+        # Se não tiver os campos cron, mas tiver job_class, é um job regular
+        if data[:job_class] && !data[:cron_expression]
+        data.merge(
+            cron_expression: nil,
+            cron_uuid: nil,
+            cron_name: "regular_job"
+        )
+        else
+        data
+        end
+    rescue JSON::ParserError => e
+        Rails.logger.error "[RedisQueueWorker] JSON inválido: #{json.inspect}"
+        nil
+    end
+
+
+
+
+    def wait_for_active_jobs_or_timeout(timeout_seconds)
+        start = Time.now
+        loop do
+        break if @active_leases.empty?
+        break if Time.now - start >= timeout_seconds
+        Rails.logger.info "[RedisQueueWorker] aguardando #{@active_leases.size} jobs finalizarem antes do shutdown..."
+        sleep 1
+        end
+
+        if @active_leases.any?
+        Rails.logger.warn "[RedisQueueWorker] Timeout ao aguardar jobs; reencaminhando leases restantes..."
+        # re-enfileira qualquer job que ainda esteja no running sem aguardar conclusão
+        with_redis do |conn|
+            @leases_mutex.synchronize do
+            @active_leases.keys.each do |lk|
+                # tentamos extrair queue e job_id do lease key (formato conhecido)
+                if lk =~ /\Arunning_lease:(.+?):(.+)\z/
+                q = $1
+                jid = $2
+                # job body guard (se existir, já está no lease value)
+                job_json = conn.get(lk) rescue nil
+                if job_json
+                    conn.rpush(queue_key(q), job_json) rescue nil
+                end
+                conn.del(lk) rescue nil
+                else
+                # nome fora do padrão: apenas delete para evitar ostentação
+                conn.del(lk) rescue nil
+                end
+                @active_leases.delete(lk)
+            end
+            end
+        end
+        end
+    end
+
+    def setup_signal_handlers
+        # ⬇️ Use $stdout.puts em vez de Rails.logger ⬇️
+        Signal.trap("TERM") do
+        $stdout.puts "[RedisQueueWorker] Sinal TERM recebido, iniciando shutdown..."
+        shutdown(immediate: true)
+        end
+        
+        Signal.trap("INT") do
+        $stdout.puts "[RedisQueueWorker] Sinal INT recebido, iniciando shutdown..."
+        shutdown(immediate: true)
+        end
+    end
+
+    
+
+
+    # Métodos de classe para configuração
+    class << self
+      def start_workers
+        worker_count = (ENV['REDIS_WORKER_COUNT'] || [3, Concurrent.processor_count].min).to_i
+        
+        worker_count.times do |i|
+          Thread.new do
+            begin
+              new.run
+            rescue => e
+              Rails.logger.error "[RedisQueueWorker] Worker #{i} crashed: #{e.message}"
+              sleep 5
+              retry
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/redis_cron_scheduler/version.rb

@@ -0,0 +1,4 @@
+# lib/redis_cron_scheduler/version.rb
+module RedisCronScheduler
+  VERSION = "0.0.1"
+end

data/lib/redis_cron_scheduler/web/controllers/redis_cron_scheduler/web/redis_jobs_controller.rb

@@ -0,0 +1,55 @@
+# lib/redis_cron_scheduler/web/controllers/redis_jobs_controller.rb
+module RedisCronScheduler
+  module Web
+    class RedisJobsController < ActionController::Base
+
+            def index
+                respond_to do |format|
+                    format.html do
+                        @queues_info = fetch_queues_info
+                    end
+                    format.json do
+                        render json: fetch_queues_info
+                    end
+                end
+            end
+
+            private
+
+            def fetch_queues_info
+                redis_namespace = ENV['REDIS_NAMESPACE']
+                queues_info = {}
+                queues = %w[default mailers critical]
+
+                Rails.cache.redis.with do |conn|
+                    queues.each do |queue|
+                        queue_key     = "#{redis_namespace}queue:#{queue}"
+                        scheduled_key = "#{redis_namespace}schedule:#{queue}"
+                        retry_key     = "#{redis_namespace}retry:#{queue}"
+                        running_key   = "#{redis_namespace}running:#{queue}"
+                        dead_key      = "#{redis_namespace}dead:#{queue}"
+
+                        pending_count   = conn.llen(queue_key) || 0
+                        scheduled_count = conn.zcard(scheduled_key) || 0
+                        retry_count     = conn.zcard(retry_key) || 0
+                        dead_count     = conn.zcard(dead_key) || 0
+
+                        # Contar keys de running (prefixo usado no worker)
+                        running_keys = conn.keys("#{running_key}:*") || []
+                        running_count = running_keys.size
+
+                        queues_info[queue] = {
+                        pending: pending_count,
+                        scheduled: scheduled_count,
+                        retry: retry_count,
+                        running: running_count,
+                        dead: dead_count
+
+                        }
+                    end
+                end
+                queues_info
+            end
+        end
+    end
+end

data/lib/redis_cron_scheduler/web/engine.rb

@@ -0,0 +1,23 @@
+# lib/redis_cron_scheduler/web/engine.rb
+require "rails/engine"
+
+module RedisCronScheduler
+  module Web
+    class Engine < ::Rails::Engine
+      isolate_namespace RedisCronScheduler::Web
+
+      # garante que o Rails enxergue controllers e views dentro do engine
+      paths["app/controllers"] << "lib/redis_cron_scheduler/web/controllers"
+      paths["app/views"]       << "lib/redis_cron_scheduler/web/views"
+      # 👇 carrega as rotas internas do engine
+
+      initializer "redis_cron_scheduler.web.load_routes" do
+        config.paths["config/routes.rb"] = File.expand_path("routes.rb", __dir__)
+      end     
+
+    end
+  end
+end
+
+# 👇 este require é essencial para as rotas do engine serem carregadas
+#require_relative "routes"

data/lib/redis_cron_scheduler/web/routes.rb

@@ -0,0 +1,6 @@
+# lib/redis_cron_scheduler/web/routes.rb
+RedisCronScheduler::Web::Engine.routes.draw do
+  get "/" => "redis_jobs#index"
+  resources :redis_jobs, only: [:index]
+end
+

data/lib/redis_cron_scheduler/web/views/redis_cron_scheduler/web/redis_jobs/index.html.erb

@@ -0,0 +1,61 @@
+<!-- lib/redis_cron_scheduler/web/views/redis_jobs/index.html.erb -->
+<h1 class="mb-4">Painel Redis Jobs</h1>
+
+<table class="table table-striped table-bordered">
+  <thead class="table-dark">
+    <tr>
+      <th>Fila</th>
+      <th>Pending</th>
+      <th>Scheduled</th>
+      <th>Retry</th>
+      <th>Running</th>
+      <th>Morto</th>
+    </tr>
+  </thead>
+  <tbody id="queues-table-body">
+    <% @queues_info.each do |queue, info| %>
+      <tr>
+        <td><%= queue %></td>
+        <td class="pending"><%= info[:pending] %></td>
+        <td class="scheduled"><%= info[:scheduled] %></td>
+        <td class="retry"><%= info[:retry] %></td>
+        <td class="running"><%= info[:running] %></td>
+        <td class="dead"><%= info[:dead] %></td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>
+
+<script>
+function fetchQueueData() {
+  fetch("/redis_cron/redis_jobs.json")
+    .then(res => res.json())
+    .then(data => {
+      const tbody = document.getElementById('queues-table-body');
+      tbody.innerHTML = '';
+      for (const [queue, info] of Object.entries(data)) {
+        const tr = document.createElement('tr');
+        tr.innerHTML = `
+          <td>${queue}</td>
+          <td class="pending">${info.pending}</td>
+          <td class="scheduled">${info.scheduled}</td>
+          <td class="retry">${info.retry}</td>
+          <td class="running">${info.running}</td>
+          <td class="dead">${info.dead}</td>
+        `;
+        tbody.appendChild(tr);
+      }
+    })
+    .catch(err => console.error("Erro ao atualizar painel:", err));
+}
+
+// Atualiza a cada 5 segundos
+setInterval(fetchQueueData, 5000);
+</script>
+
+<style>
+.pending { color: blue; font-weight: bold; }
+.scheduled { color: orange; font-weight: bold; }
+.retry { color: red; font-weight: bold; }
+.running { color: green; font-weight: bold; }
+</style>

data/lib/redis_cron_scheduler.rb

@@ -0,0 +1,35 @@
+# lib/redis_cron_scheduler.rb
+require "concurrent"
+require "fugit"
+require "redis"
+require "json"
+require "rails"
+
+# Carregue ActiveSupport para ter .seconds mesmo sem Rails completo
+require "active_support"
+require "active_support/core_ext/numeric/time"
+require "active_support/core_ext/time/calculations"
+
+require_relative "redis_cron_scheduler/version"
+require_relative "redis_cron_scheduler/cron_scheduler"
+require_relative "redis_cron_scheduler/redis_queue_worker"
+require_relative "redis_cron_scheduler/railtie" if defined?(Rails)
+
+module RedisCronScheduler
+  class Error < StandardError; end
+  
+  def self.start_scheduler
+    Thread.new do
+      CronScheduler.start
+    end
+  end
+
+  def self.start_workers
+    RedisQueueWorker.start_workers
+  end
+
+  # Método para configurar manualmente sem Rails
+  def self.configure
+    yield self if block_given?
+  end
+end

data/lib/tasks/redis_cron_scheduler.rake

@@ -0,0 +1,20 @@
+# lib/tasks/redis_cron_scheduler.rake
+namespace :redis_cron do
+  desc "Start the cron scheduler"
+  task :start_scheduler => :environment do
+    RedisCronScheduler.start_scheduler
+    puts "Cron scheduler started"
+  end
+
+  desc "Start the queue workers"
+  task :start_workers => :environment do
+    RedisCronScheduler.start_workers
+    puts "Queue workers started"
+  end
+
+  desc "Start both scheduler and workers"
+  task :start_all => :environment do
+    Rake::Task['redis_cron:start_scheduler'].invoke
+    Rake::Task['redis_cron:start_workers'].invoke
+  end
+end

data/lib/web.rb

@@ -0,0 +1,9 @@
+require 'rails/engine'
+
+module RedisCronScheduler
+  module Web
+    class Engine < ::Rails::Engine
+      isolate_namespace RedisCronScheduler::Web
+    end
+  end
+end

metadata

@@ -0,0 +1,159 @@
+--- !ruby/object:Gem::Specification
+name: redis_cron_scheduler
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Guy Novaes
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2025-09-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.0.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 8.0.2
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 8.0.2.1
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+- !ruby/object:Gem::Dependency
+  name: fugit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.11.0
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.4.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.4.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.15.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.15.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 13.3.0
+description: A distributed cron scheduler and background job worker using Redis with
+  web dashboard
+email:
+- guynovaes@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- config/scheduled_jobs.json
+- lib/redis_cron_scheduler.rb
+- lib/redis_cron_scheduler/cron_scheduler.rb
+- lib/redis_cron_scheduler/railtie.rb
+- lib/redis_cron_scheduler/redis_queue_worker.rb
+- lib/redis_cron_scheduler/version.rb
+- lib/redis_cron_scheduler/web/controllers/redis_cron_scheduler/web/redis_jobs_controller.rb
+- lib/redis_cron_scheduler/web/engine.rb
+- lib/redis_cron_scheduler/web/routes.rb
+- lib/redis_cron_scheduler/web/views/redis_cron_scheduler/web/redis_jobs/index.html.erb
+- lib/tasks/redis_cron_scheduler.rake
+- lib/web.rb
+homepage: https://github.com/guynovaes/redis_cron_scheduler
+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.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.20
+signing_key:
+specification_version: 4
+summary: Redis-based cron scheduler and queue worker
+test_files: []