sidekiq-assured-jobs 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 213608148534e316bf24588d51b181572130d503b664db631ce2a0bb5be53f1a
-  data.tar.gz: 5e158bcc84da84d90ed15918ba1216ad6eddcf555aa3f9ca923bf840551e57ad
+  metadata.gz: a5ea24f7575f4e5183d9d21a0d3a59f623496e19f13e79a611db1eb286ef87b5
+  data.tar.gz: 5f4a107e730f7f9ae5ae4a7efb51e4789441689395cd08d8f22237b8f73acd83
 SHA512:
-  metadata.gz: e63bf1b133743c43def063eede4e64a94a19d10ab90775f5cf0b36e0cdf9a50dc0597c78e349a4df2c650119b02db9cc8fb165b911ffff4af5cdd7a570df249a
-  data.tar.gz: f41c16f24cf7273f41a76f39c301f4398ed989496355cbe37097ebe7fedf03b798bf623e48c632026d46996caf9e41cf134a19fb6479e914365e026f47df70e3
+  metadata.gz: 2a663a11343df9331de4d3517e3a4d6d154f9b29461d016c322b4d4d96689410d48555005d49d462d90e12bd5fd5de518e23f79dda28493e2dae3ef100ac5870
+  data.tar.gz: 1ed718cfe35480c48feccd574ccd5d721bf70e55d9d9d060a4c8dfb99253ebd6e404f19e1358ea52b03ea00f3e61ded4dd90c1962fb85f1d5c99f86ee1ca5314

data/CHANGELOG.md

@@ -5,6 +5,41 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.0] - 2025-01-03
+
+### Added
+- **🖥️ Web Dashboard**: Complete web interface for monitoring and managing orphaned jobs
+- **📊 Real-time Monitoring**: Live dashboard showing all orphaned jobs with detailed information
+- **🔄 Interactive Actions**: Manual retry and delete operations for individual jobs
+- **🎯 Bulk Operations**: Select and manage multiple orphaned jobs simultaneously
+- **📈 Instance Monitoring**: Visual status tracking of worker instances (alive/dead)
+- **🔍 Job Details View**: Comprehensive job information including arguments, errors, and metadata
+- **⏱️ Auto-refresh**: Dashboard automatically updates every 30 seconds
+- **📱 Responsive Design**: Mobile-friendly interface matching Sidekiq's UI patterns
+
+### Features
+- **Orphaned Jobs Tab**: New tab in Sidekiq web interface at `/orphaned-jobs`
+- **Job Arguments Display**: Arguments column in main table for better job identification
+- **Bulk Selection**: Checkbox interface for selecting multiple jobs
+- **Confirmation Dialogs**: Prevent accidental job deletions
+- **Instance Health Cards**: Visual display of live vs dead worker instances
+- **Job Duration Tracking**: Shows how long jobs have been orphaned
+- **Error Information**: Display job errors and failure details
+- **Demo Script**: Interactive demo at `examples/web_demo.rb`
+
+### Technical
+- **Web Extension**: Seamless integration with `Sidekiq::Web`
+- **Helper Methods**: Time formatting, text truncation, CSRF protection
+- **Data Access Layer**: Efficient Redis queries for orphaned job data
+- **Test Coverage**: Comprehensive test suite for web functionality
+- **Unicode Icons**: Replaced FontAwesome with Unicode symbols for better compatibility
+
+### Documentation
+- **Web Interface Guide**: Complete documentation of dashboard features
+- **Setup Instructions**: Clear integration steps for Rails and standalone apps
+- **Demo Instructions**: How to run the interactive demo
+- **Feature Overview**: Detailed explanation of all web interface capabilities
+
 ## [1.0.0] - 2025-06-20
 
 ### Added

data/README.md

@@ -18,6 +18,7 @@ Sidekiq Assured Jobs ensures that your critical Sidekiq jobs are never lost due
 - **🛡️ Job Assurance**: Guarantees that tracked jobs will complete or be automatically retried
 - **🔄 Automatic Recovery**: Detects and re-enqueues orphaned jobs from crashed workers
 - **⏰ Delayed Recovery**: Configurable additional recovery passes for enhanced reliability
+- **🖥️ Web Dashboard**: Monitor and manage orphaned jobs through Sidekiq's web interface
 - **⚡ Zero Configuration**: Works out of the box with sensible defaults
 - **🏗️ Production Ready**: Designed for high-throughput production environments
 - **🔗 Sidekiq Integration**: Uses Sidekiq's existing Redis connection pool
@@ -146,6 +147,72 @@ end
 
 Your critical jobs are now protected. If a worker crashes while processing a tracked job, another worker will automatically detect and re-enqueue it.
 
+## Web Interface
+
+Sidekiq Assured Jobs includes a web dashboard that integrates seamlessly with Sidekiq's existing web interface. The dashboard allows you to monitor and manage orphaned jobs in real-time.
+
+### Setup
+
+The web interface is automatically available when you mount Sidekiq::Web in your application:
+
+```ruby
+# config/routes.rb (Rails)
+require 'sidekiq/web'
+mount Sidekiq::Web => '/sidekiq'
+```
+
+Or for standalone applications:
+
+```ruby
+# config.ru
+require 'sidekiq/web'
+run Sidekiq::Web
+```
+
+### Features
+
+The **Orphaned Jobs** tab provides:
+
+- **📊 Real-time Dashboard**: View all orphaned jobs with key information
+- **🔍 Job Details**: Detailed view of individual orphaned jobs including arguments and error information
+- **🔄 Manual Recovery**: Retry orphaned jobs individually or in bulk
+- **🗑️ Job Management**: Delete orphaned jobs that are no longer needed
+- **📈 Instance Monitoring**: Track the status of worker instances (alive/dead)
+- **⏱️ Auto-refresh**: Dashboard automatically updates every 30 seconds
+- **🎯 Bulk Operations**: Select multiple jobs for batch retry or delete operations
+
+### Dashboard Information
+
+For each orphaned job, the dashboard displays:
+
+- **Job ID**: Unique identifier for the job
+- **Class**: The worker class name
+- **Queue**: The queue the job was running in
+- **Instance**: The worker instance that was processing the job
+- **Orphaned Time**: When the job became orphaned
+- **Duration**: How long the job has been orphaned
+- **Arguments**: The job's input parameters
+- **Error Information**: Any error details if the job failed
+
+### Actions Available
+
+- **Retry**: Re-enqueue the job for processing
+- **Delete**: Remove the job from tracking (cannot be undone)
+- **Bulk Retry**: Retry multiple selected jobs at once
+- **Bulk Delete**: Delete multiple selected jobs at once
+
+The web interface provides a user-friendly way to monitor your job reliability and take action when needed, complementing the automatic recovery system.
+
+### Demo
+
+To see the web interface in action, run the included demo:
+
+```bash
+ruby examples/web_demo.rb
+```
+
+Then visit `http://localhost:4567/orphaned-jobs` to explore the dashboard with sample orphaned jobs.
+
 ## Configuration
 
 The gem works with zero configuration but provides extensive customization options. See the [Complete Configuration Reference](#complete-configuration-reference) below for all available options.

data/examples/web_demo.rb

@@ -0,0 +1,151 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Demo script showing the Sidekiq Assured Jobs web interface
+# Run this script and visit http://localhost:4567/orphaned-jobs
+
+require 'bundler/setup'
+require 'sidekiq'
+require 'sidekiq/web'
+require_relative '../lib/sidekiq-assured-jobs'
+
+# Configure Redis for demo
+Sidekiq.configure_server do |config|
+  config.redis = { url: 'redis://localhost:6379/15' } # Use test database
+end
+
+Sidekiq.configure_client do |config|
+  config.redis = { url: 'redis://localhost:6379/15' } # Use test database
+end
+
+# Configure AssuredJobs for demo
+Sidekiq::AssuredJobs.configure do |config|
+  config.namespace = "demo_assured_jobs"
+  config.heartbeat_interval = 5
+  config.heartbeat_ttl = 15
+  config.auto_recovery_enabled = false # Disable auto-recovery for demo
+end
+
+# Demo worker class
+class DemoWorker
+  include Sidekiq::Worker
+  include Sidekiq::AssuredJobs::Worker
+
+  def perform(message, delay = 0)
+    puts "Processing: #{message}"
+    sleep(delay) if delay > 0
+    puts "Completed: #{message}"
+  end
+end
+
+# Create some demo orphaned jobs
+def create_demo_orphaned_jobs
+  puts "Creating demo orphaned jobs..."
+  
+  # Simulate orphaned jobs by creating tracking data without live instances
+  dead_instances = ["demo-worker-1", "demo-worker-2", "demo-worker-3"]
+  
+  Sidekiq::AssuredJobs.redis_sync do |conn|
+    dead_instances.each_with_index do |instance_id, i|
+      # Create some orphaned jobs for each dead instance
+      (1..3).each do |job_num|
+        jid = "demo_job_#{instance_id}_#{job_num}"
+        job_data = {
+          "class" => "DemoWorker",
+          "args" => ["Demo job #{job_num} from #{instance_id}", 2],
+          "jid" => jid,
+          "queue" => "default",
+          "created_at" => (Time.now - (i * 300) - (job_num * 60)).to_f,
+          "enqueued_at" => (Time.now - (i * 300) - (job_num * 60)).to_f,
+          "retry_count" => job_num - 1
+        }
+        
+        # Add to tracking
+        job_tracking_key = Sidekiq::AssuredJobs.send(:namespaced_key, "jobs:#{instance_id}")
+        job_data_key = Sidekiq::AssuredJobs.send(:namespaced_key, "job:#{jid}")
+        
+        conn.sadd(job_tracking_key, jid)
+        conn.set(job_data_key, job_data.to_json)
+      end
+    end
+  end
+  
+  puts "Created #{dead_instances.size * 3} demo orphaned jobs"
+end
+
+# Create some live instances for comparison
+def create_demo_live_instances
+  puts "Creating demo live instances..."
+  
+  live_instances = ["live-worker-1", "live-worker-2"]
+  
+  Sidekiq::AssuredJobs.redis_sync do |conn|
+    live_instances.each do |instance_id|
+      key = Sidekiq::AssuredJobs.send(:namespaced_key, "instance:#{instance_id}")
+      conn.setex(key, 60, Time.now.to_f)
+    end
+  end
+  
+  puts "Created #{live_instances.size} demo live instances"
+end
+
+# Clean up demo data
+def cleanup_demo_data
+  puts "Cleaning up demo data..."
+  
+  Sidekiq::AssuredJobs.redis_sync do |conn|
+    keys = conn.keys("#{Sidekiq::AssuredJobs.namespace}:*")
+    conn.del(*keys) if keys.any?
+  end
+  
+  puts "Demo data cleaned up"
+end
+
+# Setup demo data
+puts "Setting up demo environment..."
+cleanup_demo_data
+create_demo_orphaned_jobs
+create_demo_live_instances
+
+puts "\n" + "="*60
+puts "SIDEKIQ ASSURED JOBS WEB DEMO"
+puts "="*60
+puts ""
+puts "Demo server starting at: http://localhost:4567"
+puts ""
+puts "Available endpoints:"
+puts "  • Main dashboard:     http://localhost:4567/"
+puts "  • Orphaned Jobs:      http://localhost:4567/orphaned-jobs"
+puts "  • Job stats (JSON):   http://localhost:4567/orphaned-jobs/stats"
+puts ""
+puts "Demo features:"
+puts "  • View orphaned jobs from 3 'dead' worker instances"
+puts "  • See live vs dead instance status"
+puts "  • Try retrying or deleting orphaned jobs"
+puts "  • Test bulk operations"
+puts "  • View detailed job information"
+puts ""
+puts "Press Ctrl+C to stop the demo and clean up"
+puts "="*60
+puts ""
+
+# Trap interrupt to cleanup
+trap('INT') do
+  puts "\n\nShutting down demo..."
+  cleanup_demo_data
+  puts "Demo data cleaned up. Goodbye!"
+  exit
+end
+
+# Start the web server
+require 'rack'
+
+app = Rack::Builder.new do
+  use Rack::ShowExceptions
+  run Sidekiq::Web
+end
+
+Rack::Handler::WEBrick.run(app, Port: 4567, Host: '0.0.0.0') do |server|
+  puts "Demo server started successfully!"
+  puts "Visit http://localhost:4567/orphaned-jobs to see the dashboard"
+end

data/lib/sidekiq/assured_jobs/version.rb

@@ -2,6 +2,6 @@
 
 module Sidekiq
   module AssuredJobs
-    VERSION = "1.0.0"
+    VERSION = "1.1.0"
   end
 end

data/lib/sidekiq/assured_jobs/web.rb

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+require 'sidekiq/web'
+
+module Sidekiq
+  module AssuredJobs
+    module Web
+      def self.registered(app)
+        # Add helper methods to the app
+        app.helpers do
+          def relative_time(time)
+            return 'Unknown' unless time
+
+            diff = Time.now - time
+            case diff
+            when 0..59
+              "#{diff.to_i} seconds ago"
+            when 60..3599
+              "#{(diff / 60).to_i} minutes ago"
+            when 3600..86399
+              "#{(diff / 3600).to_i} hours ago"
+            else
+              "#{(diff / 86400).to_i} days ago"
+            end
+          end
+
+          def distance_of_time_in_words(seconds)
+            return 'Unknown' unless seconds
+
+            case seconds
+            when 0..59
+              "#{seconds.to_i}s"
+            when 60..3599
+              "#{(seconds / 60).to_i}m"
+            when 3600..86399
+              "#{(seconds / 3600).to_i}h"
+            else
+              "#{(seconds / 86400).to_i}d"
+            end
+          end
+
+          def truncate(text, length)
+            return text unless text
+            text.length > length ? "#{text[0, length]}..." : text
+          end
+
+          def csrf_tag
+            # Sidekiq web uses Rack::Protection, get the token
+            "<input type='hidden' name='authenticity_token' value='#{env['rack.session'][:csrf]}' />"
+          end
+
+          def root_path
+            "#{env['SCRIPT_NAME']}/"
+          end
+        end
+
+        app.get '/orphaned-jobs' do
+          @orphaned_jobs = OrphanedJobsManager.get_orphaned_jobs
+          @instances = OrphanedJobsManager.get_instances_info
+          @total_count = @orphaned_jobs.size
+          erb File.read(File.join(File.dirname(__FILE__), '../../../web/views/orphaned_jobs.erb'))
+        end
+
+        app.get '/orphaned-jobs/:jid' do
+          jid = params[:jid]
+          @job = OrphanedJobsManager.get_orphaned_job(jid)
+          halt 404 unless @job
+          erb File.read(File.join(File.dirname(__FILE__), '../../../web/views/orphaned_job.erb'))
+        end
+
+        app.post '/orphaned-jobs/:jid/retry' do
+          jid = params[:jid]
+          result = OrphanedJobsManager.retry_orphaned_job(jid)
+          if result[:success]
+            redirect to('/orphaned-jobs')
+          else
+            halt 400, result[:error]
+          end
+        end
+
+        app.post '/orphaned-jobs/:jid/delete' do
+          jid = params[:jid]
+          result = OrphanedJobsManager.delete_orphaned_job(jid)
+          if result[:success]
+            redirect to('/orphaned-jobs')
+          else
+            halt 400, result[:error]
+          end
+        end
+
+        app.post '/orphaned-jobs/bulk-action' do
+          action = params[:action]
+          jids = params[:jids] || []
+          
+          case action
+          when 'retry'
+            result = OrphanedJobsManager.bulk_retry_orphaned_jobs(jids)
+          when 'delete'
+            result = OrphanedJobsManager.bulk_delete_orphaned_jobs(jids)
+          else
+            halt 400, "Invalid action: #{action}"
+          end
+
+          if result[:success]
+            redirect to('/orphaned-jobs')
+          else
+            halt 400, result[:error]
+          end
+        end
+
+        app.get '/orphaned-jobs/stats' do
+          content_type :json
+          OrphanedJobsManager.get_stats.to_json
+        end
+      end
+
+      # Manager class for handling orphaned jobs operations
+      class OrphanedJobsManager
+        class << self
+          def get_orphaned_jobs
+            AssuredJobs.get_orphaned_jobs_info
+          end
+
+          def get_orphaned_job(jid)
+            AssuredJobs.get_orphaned_job_by_jid(jid)
+          end
+
+          def retry_orphaned_job(jid)
+            begin
+              job_data = get_orphaned_job(jid)
+              return { success: false, error: "Job not found" } unless job_data
+
+              # Clear unique-jobs lock if present
+              AssuredJobs.clear_unique_jobs_lock(job_data)
+              
+              # Re-enqueue the job
+              Sidekiq::Client.push(job_data)
+              
+              # Clean up tracking data
+              cleanup_job_tracking(jid, job_data['instance_id'])
+              
+              { success: true }
+            rescue => e
+              { success: false, error: e.message }
+            end
+          end
+
+          def delete_orphaned_job(jid)
+            begin
+              job_data = get_orphaned_job(jid)
+              return { success: false, error: "Job not found" } unless job_data
+
+              # Clean up tracking data
+              cleanup_job_tracking(jid, job_data['instance_id'])
+              
+              { success: true }
+            rescue => e
+              { success: false, error: e.message }
+            end
+          end
+
+          def bulk_retry_orphaned_jobs(jids)
+            begin
+              success_count = 0
+              errors = []
+              
+              jids.each do |jid|
+                result = retry_orphaned_job(jid)
+                if result[:success]
+                  success_count += 1
+                else
+                  errors << "#{jid}: #{result[:error]}"
+                end
+              end
+              
+              if errors.empty?
+                { success: true, message: "Successfully retried #{success_count} jobs" }
+              else
+                { success: false, error: "Retried #{success_count} jobs, failed: #{errors.join(', ')}" }
+              end
+            rescue => e
+              { success: false, error: e.message }
+            end
+          end
+
+          def bulk_delete_orphaned_jobs(jids)
+            begin
+              success_count = 0
+              errors = []
+              
+              jids.each do |jid|
+                result = delete_orphaned_job(jid)
+                if result[:success]
+                  success_count += 1
+                else
+                  errors << "#{jid}: #{result[:error]}"
+                end
+              end
+              
+              if errors.empty?
+                { success: true, message: "Successfully deleted #{success_count} jobs" }
+              else
+                { success: false, error: "Deleted #{success_count} jobs, failed: #{errors.join(', ')}" }
+              end
+            rescue => e
+              { success: false, error: e.message }
+            end
+          end
+
+          def get_instances_info
+            AssuredJobs.get_instances_status
+          end
+
+          def get_stats
+            stats = {
+              total_orphaned_jobs: 0,
+              dead_instances: 0,
+              live_instances: 0,
+              oldest_orphaned_job: nil
+            }
+            
+            orphaned_jobs = get_orphaned_jobs
+            instances = get_instances_info
+            
+            stats[:total_orphaned_jobs] = orphaned_jobs.size
+            stats[:dead_instances] = instances.count { |_, info| info[:status] == 'dead' }
+            stats[:live_instances] = instances.count { |_, info| info[:status] == 'alive' }
+            
+            if orphaned_jobs.any?
+              oldest_job = orphaned_jobs.min_by { |job| job['orphaned_at'] || Float::INFINITY }
+              stats[:oldest_orphaned_job] = oldest_job['orphaned_duration'] if oldest_job
+            end
+            
+            stats
+          end
+
+          private
+
+          def cleanup_job_tracking(jid, instance_id)
+            AssuredJobs.redis_sync do |conn|
+              job_tracking_key = AssuredJobs.send(:namespaced_key, "jobs:#{instance_id}")
+              job_data_key = AssuredJobs.send(:namespaced_key, "job:#{jid}")
+
+              conn.multi do |multi|
+                multi.srem(job_tracking_key, jid)
+                multi.del(job_data_key)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+# Register the web extension with Sidekiq::Web
+Sidekiq::Web.register(Sidekiq::AssuredJobs::Web)
+Sidekiq::Web.tabs["Orphaned Jobs"] = "orphaned-jobs"