capistrano-sidekiq 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41a4b345da5a4f9019cca07d226270be72a796a743b03dc9cfeb0cf13a7c0dc3
-  data.tar.gz: bea4261d462c586ededff2ef99bf0311a463810a334cf73fc128f82041ed3a03
+  metadata.gz: 61bb07339f25aae4a39fa10cb0dad5b696b13d89bb29e2c626d4d930cab246dc
+  data.tar.gz: fca70af00d2a413d6bd84d7ab9f40ff678000f32f6699b5bbb221704ab72eccc
 SHA512:
-  metadata.gz: 0b8e9df1839123c5cef2a3f15fbc7512bfc1d328f9c79ae141f9f48ff87d0d95e60a3a310dc14b47bc9ef4a01de18e73c14000706fd92c09a7d995380c421760
-  data.tar.gz: d31d7765c396d32d987b6f70b5de3e2bf5eeb3a43e7528187bb4c1d862b59235772a171353e9611d4d7bc151e7c8a24fecc5855fa459c1e48187b67a91c084e6
+  metadata.gz: 3e5ebaa925990b9e6896328a3d78e0a187c3f794870ef5ed47fb0828f7a709236817020918aee2cd0cb7601e7b3bc739b36060a686abebd0988ed81f611d7a1e
+  data.tar.gz: 9325d11d20b43003c085dd645e66d9028b30d87ed8c8422bdd01996afdd7fb6b35cc9e34ecf794f410c10d6499e426620f44a1ec1bd3f34ec53e641fcffb082f

data/CHANGELOG.md

@@ -1,11 +1,43 @@
 # Changelog
 
-## [Unreleased](https://github.com/seuros/capistrano-sidekiq/compare/v2.3.0...master)
+## [Unreleased](https://github.com/seuros/capistrano-sidekiq/compare/v3.1.0...master)
+
+## [3.1.0](https://github.com/seuros/capistrano-sidekiq/compare/v3.0.0...v3.1.0) - 2025-06-22
+
+### Fixed
+- Fix undefined method 'as' error by properly calling backend.as (#327)
+- Fix inconsistent systemd variable naming (systemctl_user vs sidekiq_systemctl_user)
+- Fix systemd lingering configuration issues (#311)
+- Fix sidekiq:uninstall to work without sudo for user services (#307)
+- Align configuration pattern with capistrano-puma for consistency
+
+### Added
+- Add sidekiqswarm support for Sidekiq Enterprise
+- Add deployment tracking for Sidekiq 7+ metrics (`sidekiq_mark_deploy`)
+- Add login shell option for systemd (`sidekiq_use_login_shell`)
+- Add configurable sidekiq command (`sidekiq_command`, `sidekiq_command_args`)
+- Add helper tasks for generating multiple config files
+- Add comprehensive documentation for per-server configuration (#312)
+- Add detailed systemd integration guide (#240)
+- Add GitHub Actions CI workflow with Ruby 3.2+ support
+- Add COSS specification compliance
+- Add shared configuration support with other Capistrano service gems
+
+### Changed
+- Update minimum Ruby version to 3.2+ (required by Sidekiq 7)
+- Use consistent sidekiq-prefixed variables for systemd configuration
+- Improve README documentation with shared configuration examples
+- Update CI to test with Ruby 3.2 and 3.3
+- Enhance systemd service template with configurable features
+
+## [3.0.0](https://github.com/seuros/capistrano-sidekiq/compare/v2.3.0...v3.0.0)
 - Rewrite to match capistrano3-puma api
 - Add support for multiple sidekiq configs (processes and queues can be configured with erb)
 - Add support to multiple EnvironmentFile
 - Add support to multiple EnvironmentVariables
 - Default role for sidekiq is now :worker instead of :app
+- Remove monit support
+- Remove deprecated --index argument for Sidekiq 6.0+ compatibility (#234)
 
 ## [2.3.0](https://github.com/seuros/capistrano-sidekiq/tree/2.3.0) (2022-05-17)
 

data/README.md

@@ -1,54 +1,375 @@
-[![Gem Version](https://badge.fury.io/rb/capistrano-sidekiq.svg)](http://badge.fury.io/rb/capistrano-sidekiq)
-
 # Capistrano::Sidekiq
 
-Sidekiq integration for Capistrano
+[![Gem Version](https://badge.fury.io/rb/capistrano-sidekiq.svg)](http://badge.fury.io/rb/capistrano-sidekiq)
+[![COSS Compliant](https://img.shields.io/badge/COSS-compliant-green.svg)](https://github.com/contriboss/coss_spec)
+
+Sidekiq integration for Capistrano - providing systemd service management and deployment coordination for Sidekiq 7+.
 
 ## Installation
 
-    gem 'capistrano-sidekiq', group: :development
+Add to your Gemfile:
+
+```ruby
+gem 'capistrano-sidekiq', group: :development
+```
+
+Then execute:
+
+```bash
+$ bundle install
+```
+
+## Setup
+
+Add to your Capfile:
+
+```ruby
+# Capfile
+require 'capistrano/sidekiq'
+install_plugin Capistrano::Sidekiq  # Default sidekiq tasks
+install_plugin Capistrano::Sidekiq::Systemd  # Systemd integration
+```
+
+## Configuration Options
+
+### Basic Settings
+
+```ruby
+# config/deploy.rb
+set :sidekiq_roles, :worker                  # Default role for Sidekiq processes
+set :sidekiq_default_hooks, true             # Enable default deployment hooks
+set :sidekiq_env, fetch(:rack_env, fetch(:rails_env, fetch(:stage)))  # Environment for Sidekiq processes
+
+# Single config file
+set :sidekiq_config_files, ['sidekiq.yml']   
+
+# Multiple config files for different Sidekiq processes
+set :sidekiq_config_files, ['sidekiq.yml', 'sidekiq-high-priority.yml']
+```
+
+### Shared Configuration with Other Gems
+
+This gem follows the Capistrano convention of sharing common settings across multiple service gems (e.g., capistrano-puma, capistrano-sidekiq). The following settings are shared:
+
+- `:service_unit_user` - Determines if services run as system or user services
+- `:systemctl_bin` - Path to the systemctl binary
+- `:lingering_user` - User for systemd lingering (for user services)
+- `:service_unit_env_files` - Shared environment files
+- `:service_unit_env_vars` - Shared environment variables
+
+Each gem can override these with prefixed versions (e.g., `:sidekiq_systemctl_user`).
+
+### Advanced Configuration
+
+```ruby
+# Shared systemd settings (can be used by multiple Capistrano gems like capistrano-puma)
+set :service_unit_user, :user                # Run as user or system service (:system or :user)
+set :systemctl_bin, '/bin/systemctl'         # Path to systemctl binary
+set :lingering_user, 'deploy'                # User to enable lingering for (defaults to :user)
+
+# Sidekiq-specific overrides (optional - defaults to shared settings above)
+set :sidekiq_systemctl_user, :system         # Override service_unit_user for Sidekiq only
+set :sidekiq_systemctl_bin, '/usr/bin/systemctl'  # Override systemctl_bin for Sidekiq only
+set :sidekiq_service_unit_name, "custom_sidekiq_#{fetch(:stage)}"  # Custom service name
+set :sidekiq_lingering_user, 'sidekiq'       # Override lingering user for Sidekiq only
+
+# Environment configuration
+set :sidekiq_service_unit_env_files, ['/etc/environment']  # Environment files
+set :sidekiq_service_unit_env_vars, [                      # Environment variables
+  'RAILS_ENV=production',
+  'MALLOC_ARENA_MAX=2'
+]
+
+# Logging configuration
+set :sidekiq_log, -> { File.join(shared_path, 'log', 'sidekiq.log') }
+set :sidekiq_error_log, -> { File.join(shared_path, 'log', 'sidekiq.error.log') }
+
+# Command customization
+set :sidekiq_command, 'sidekiq'  # Use 'sidekiq' or 'sidekiqswarm' for Enterprise
+set :sidekiq_command_args, -> { "-e #{fetch(:sidekiq_env)}" }
+
+# Use login shell to load environment (for rbenv, rvm, etc.)
+set :sidekiq_use_login_shell, true
+
+# Sidekiq Enterprise - Swarm configuration
+set :sidekiq_command, 'sidekiqswarm'
+set :sidekiq_swarm_env_vars, [
+  'SIDEKIQ_COUNT=5',           # Number of processes
+  'SIDEKIQ_MAXMEM_MB=768',     # Memory limit per process
+  'SIDEKIQ_PRELOAD_APP=1'      # Preload app for memory efficiency
+]
+# Merge swarm env vars with regular env vars
+set :sidekiq_service_unit_env_vars, -> { 
+  fetch(:sidekiq_service_unit_env_vars, []) + fetch(:sidekiq_swarm_env_vars, [])
+}
+```
+
+### Per-Server Configuration
+
+You can configure Sidekiq differently for specific servers, allowing you to run different Sidekiq processes with different configurations on different servers.
+
+#### Basic Per-Server Setup
+
+```ruby
+# config/deploy/production.rb
+server 'worker1.example.com', 
+  roles: [:worker], 
+  sidekiq_config_files: ['sidekiq_high_priority.yml']
+
+server 'worker2.example.com', 
+  roles: [:worker], 
+  sidekiq_config_files: ['sidekiq_low_priority.yml']
+```
+
+#### Advanced Per-Server Configuration
+
+```ruby
+# Different users and multiple processes per server
+server 'worker1.example.com',
+  roles: [:worker],
+  sidekiq_config_files: ['sidekiq_critical.yml', 'sidekiq_default.yml'],
+  sidekiq_user: 'sidekiq_critical',
+  sidekiq_systemctl_user: :system  # Run as system service on this server
+
+server 'worker2.example.com',
+  roles: [:worker],
+  sidekiq_config_files: ['sidekiq_batch.yml'],
+  sidekiq_user: 'sidekiq_batch',
+  sidekiq_service_unit_env_vars: ['MALLOC_ARENA_MAX=4']  # Server-specific env vars
+```
+
+#### How It Works
+
+1. **Configuration Files**: Each server can have its own set of `sidekiq_config_files`
+2. **Service Creation**: A separate systemd service is created for each config file
+3. **Service Naming**: Services are named as `<app>_sidekiq_<stage>` for the default `sidekiq.yml`, or `<app>_sidekiq_<stage>.<config_name>` for additional configs
+4. **Independent Control**: Each service can be started, stopped, and restarted independently
+
+#### Example Configurations
+
+**config/sidekiq_high_priority.yml:**
+```yaml
+:concurrency: 10
+:queues:
+  - [critical, 2]
+  - [high, 1]
+```
+
+**config/sidekiq_low_priority.yml:**
+```yaml
+:concurrency: 5
+:queues:
+  - [low, 1]
+  - [default, 1]
+```
+
+#### Deployment Commands
+
+When using per-server configurations, Capistrano will:
+- Install the appropriate services on each server during `cap production sidekiq:install`
+- Start only the configured services on each server during `cap production sidekiq:start`
+- Manage each server's services independently
+
+You can also target specific servers:
+```bash
+cap production sidekiq:restart --hosts=worker1.example.com
+```
+
+## Multiple Processes
+
+There are two ways to run multiple Sidekiq processes:
+
+### Option 1: Multiple Config Files (Recommended)
+
+Create separate config files for different workloads:
+
+```yaml
+# config/sidekiq_critical.yml
+:concurrency: 5
+:queues:
+  - [critical, 2]
+
+# config/sidekiq_default.yml  
+:concurrency: 10
+:queues:
+  - [default, 1]
+  - [low, 1]
+```
+
+Configure in deploy.rb:
+```ruby
+set :sidekiq_config_files, ['sidekiq_critical.yml', 'sidekiq_default.yml']
+```
+
+This creates separate services:
+- `myapp_sidekiq_production.sidekiq_critical`
+- `myapp_sidekiq_production.sidekiq_default`
+
+Benefits:
+- Clear purpose for each process
+- Independent scaling and management
+- Different configurations per process
+- Meaningful service names
+
+### Option 2: Sidekiq Enterprise (Sidekiqswarm)
+
+For simple scaling with identical processes:
+
+```ruby
+set :sidekiq_command, 'sidekiqswarm'
+set :sidekiq_service_unit_env_vars, ['SIDEKIQ_COUNT=10']
+```
+
+This runs 10 identical processes with a single service.
+
+### Quick Setup for Multiple Processes
+
+Use the helper task to generate config files:
+
+```bash
+# Generate 5 config files
+bundle exec cap production sidekiq:helpers:generate_configs[5]
+
+# This creates:
+# - config/sidekiq.yml (critical, high queues)
+# - config/sidekiq_1.yml (default, medium queues)
+# - config/sidekiq_2.yml (low, background queues)
+# - config/sidekiq_3.yml (low, background queues)
+# - config/sidekiq_4.yml (low, background queues)
+```
+
+Then add to your deploy.rb:
+```ruby
+set :sidekiq_config_files, ['sidekiq.yml', 'sidekiq_1.yml', 'sidekiq_2.yml', 'sidekiq_3.yml', 'sidekiq_4.yml']
+```
+
+## Available Tasks
+
+```bash
+# View all available tasks
+cap -T sidekiq
 
-And then execute:
+# Common commands
+cap sidekiq:start              # Start Sidekiq
+cap sidekiq:stop               # Stop Sidekiq (graceful shutdown)
+cap sidekiq:restart            # Restart Sidekiq
+cap sidekiq:quiet              # Quiet Sidekiq (stop processing new jobs)
+cap sidekiq:install            # Install Sidekiq systemd service
+cap sidekiq:uninstall          # Remove Sidekiq systemd service
+cap sidekiq:enable             # Enable Sidekiq systemd service
+cap sidekiq:disable            # Disable Sidekiq systemd service
+cap sidekiq:mark_deploy        # Mark deployment in Sidekiq metrics (Sidekiq 7+)
 
-    $ bundle
+# Helper tasks
+cap sidekiq:helpers:generate_configs[3]  # Generate 3 config files
+cap sidekiq:helpers:show_config          # Show current configuration
+```
+
+## Systemd Integration
+
+For detailed information about systemd integration, see [Systemd Integration Guide](docs/SYSTEMD_INTEGRATION.md).
+
+## Deployment Tracking (Sidekiq 7+)
 
+Sidekiq 7 introduced metrics with deployment tracking. Enable it to see deployment markers in your Sidekiq metrics graphs:
+
+### Configuration
 
-## Usage
 ```ruby
-    # Capfile
-    require 'capistrano/sidekiq'
-    install_plugin Capistrano::Sidekiq  # Default sidekiq tasks
-    # Then select your service manager
-    install_plugin Capistrano::Sidekiq::Systemd
+# config/deploy.rb
+
+# Enable deployment marking
+set :sidekiq_mark_deploy, true
+
+# Optional: Custom deploy label (defaults to git commit description)
+set :sidekiq_deploy_label, "v#{fetch(:current_revision)[0..6]} deployed to #{fetch(:stage)}"
 ```
 
-Configurable options - Please ensure you check your version's branch for the available settings - shown here with defaults:
+### How It Works
+
+When enabled, the gem will:
+1. Automatically mark deployments after successful deploys
+2. Show vertical red lines in Sidekiq's metrics graphs
+3. Display the deploy label when hovering over the marker
+
+This helps correlate performance changes with deployments.
+
+## Sidekiq Enterprise (Swarm) Support
+
+This gem supports Sidekiq Enterprise's `sidekiqswarm` command for managing multiple processes with a single service.
+
+### Configuration
 
 ```ruby
-:sidekiq_roles => :worker
-:sidekiq_default_hooks => true
-:sidekiq_env => fetch(:rack_env, fetch(:rails_env, fetch(:stage)))
-# single config
-:sidekiq_config_files, ['sidekiq.yml']
-# multiple configs
-:sidekiq_config_files, ['sidekiq.yml', 'sidekiq-2.yml'] #  you can also set it per server
+# config/deploy.rb
+
+# Use sidekiqswarm instead of sidekiq
+set :sidekiq_command, 'sidekiqswarm'
+
+# Configure swarm-specific environment variables
+set :sidekiq_service_unit_env_vars, [
+  'SIDEKIQ_COUNT=10',          # Number of processes to spawn
+  'SIDEKIQ_MAXMEM_MB=512',     # Memory limit per process
+  'SIDEKIQ_PRELOAD_APP=1',     # Preload Rails app for memory efficiency
+  'RAILS_ENV=production'
+]
+
+# Optional: Configure shutdown timeout for graceful stops
+set :sidekiq_command_args, -> { "-e #{fetch(:sidekiq_env)} -t 30" }
 ```
 
-## Example
+### Benefits of Sidekiqswarm
+
+- **Single Service**: Manage N processes with one systemd service
+- **Memory Efficiency**: Preload app once, fork processes
+- **Auto-restart**: Processes that exceed memory limits are automatically restarted
+- **Simplified Management**: No need for multiple service files
+
+### Per-Server Swarm Configuration
+
+```ruby
+server 'worker1.example.com',
+  roles: [:worker],
+  sidekiq_service_unit_env_vars: ['SIDEKIQ_COUNT=20', 'SIDEKIQ_MAXMEM_MB=1024']
+
+server 'worker2.example.com',
+  roles: [:worker],
+  sidekiq_service_unit_env_vars: ['SIDEKIQ_COUNT=5', 'SIDEKIQ_MAXMEM_MB=512']
+```
+
+## Working with Systemd Logs
+
+View Sidekiq service logs using journalctl:
+
+```bash
+# View last 100 lines of logs
+journalctl -u sidekiq_myapp_production -n 100
+
+# Follow logs in real-time
+journalctl -u sidekiq_myapp_production -f
+```
+
+## Log File Configuration
+
+### Modern Systemd (v240+, e.g., Ubuntu 20.04+)
+
+Log files are configured automatically using the `append:` functionality in the systemd service file.
 
-A sample application is provided to show how to use this gem at https://github.com/seuros/capistrano-example-app
+### Legacy Systemd Systems
 
-## Configuring the log files on systems with less recent Systemd versions
+For systems with older Systemd versions where `append:` is not supported:
 
-The template used by this project assumes a recent version of Systemd (v240+, e.g. Ubuntu 20.04).
+1. Sidekiq messages are sent to syslog by default
+2. Configure system logger to filter Sidekiq messages
 
-On systems with a less recent version, the `append:` functionality is not supported, and the Sidekiq log messages are sent to the syslog.
+## Example Application
 
-It's possible to workaround this limitation by configuring the system logger to filter the Sidekiq messages; see [wiki](/../../wiki/Configuring-append-mode-log-files-via-Syslog-NG).
+A complete example application demonstrating the usage of this gem is available at:
+https://github.com/seuros/capistrano-example-app
 
 ## Contributing
 
-1. Fork it
+1. Fork the repository
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/lib/capistrano/sidekiq/systemd.rb

@@ -1,46 +1,72 @@
 # frozen_string_literal: true
 
 module Capistrano
-  class Sidekiq::Systemd < Capistrano::Plugin
-    include SidekiqCommon
-    def define_tasks
-      eval_rakefile File.expand_path('../tasks/systemd.rake', __dir__)
-    end
-    def set_defaults
-      set_if_empty :systemctl_bin, '/bin/systemctl'
-      set_if_empty :service_unit_user, :user
-      set_if_empty :systemctl_user, fetch(:service_unit_user, :user) == :user
+  class Sidekiq
+    class Systemd < Capistrano::Plugin
+      include SidekiqCommon
+      def define_tasks
+        eval_rakefile File.expand_path('../tasks/systemd.rake', __dir__)
+        eval_rakefile File.expand_path('../tasks/helpers.rake', __dir__)
+      end
 
-      set_if_empty :sidekiq_service_unit_name, -> { "#{fetch(:application)}_sidekiq_#{fetch(:stage)}" }
-      set_if_empty :sidekiq_lingering_user, -> { fetch(:lingering_user, fetch(:user)) }
+      def set_defaults
+        set_if_empty :systemctl_bin, '/bin/systemctl'
+        set_if_empty :service_unit_user, :user
+        set_if_empty :systemctl_user, -> { fetch(:service_unit_user, :user) == :user }
 
-      ## Sidekiq could have a stripped down or more complex version of the environment variables
-      set_if_empty :sidekiq_service_unit_env_files, -> { fetch(:service_unit_env_files, []) }
-      set_if_empty :sidekiq_service_unit_env_vars, -> { fetch(:service_unit_env_vars, []) }
+        set_if_empty :sidekiq_systemctl_bin, -> { fetch(:systemctl_bin) }
+        set_if_empty :sidekiq_service_unit_name, -> { "#{fetch(:application)}_sidekiq_#{fetch(:stage)}" }
 
-      set_if_empty :sidekiq_service_templates_path, fetch(:service_templates_path, 'config/deploy/templates')
-    end
+        set_if_empty :sidekiq_systemctl_user, -> { fetch(:service_unit_user) }
+        set_if_empty :sidekiq_enable_lingering, -> { fetch(:sidekiq_systemctl_user) != :system }
+        set_if_empty :sidekiq_lingering_user, -> { fetch(:lingering_user, fetch(:user)) }
+
+        ## Sidekiq could have a stripped down or more complex version of the environment variables
+        set_if_empty :sidekiq_service_unit_env_files, -> { fetch(:service_unit_env_files, []) }
+        set_if_empty :sidekiq_service_unit_env_vars, -> { fetch(:service_unit_env_vars, []) }
 
-    def systemd_command(*args)
-      command = [fetch(:systemctl_bin)]
+        set_if_empty :sidekiq_service_templates_path, fetch(:service_templates_path, 'config/deploy/templates')
 
-      unless fetch(:service_unit_user) == :system
-        command << "--user"
+        # Allow customization of the sidekiq command
+        set_if_empty :sidekiq_command, 'sidekiq'
+        set_if_empty :sidekiq_command_args, -> { "-e #{fetch(:sidekiq_env)}" }
+
+        # Deployment tracking for Sidekiq 7+ metrics
+        set_if_empty :sidekiq_mark_deploy, false
+        set_if_empty :sidekiq_deploy_label, nil
+
+        # Login shell option for loading environment
+        set_if_empty :sidekiq_use_login_shell, false
       end
 
-      command + args
-    end
+      def fetch_systemd_unit_path
+        if fetch(:sidekiq_systemctl_user) == :system
+          '/etc/systemd/system/'
+        else
+          home_dir = backend.capture :pwd
+          File.join(home_dir, '.config', 'systemd', 'user')
+        end
+      end
+
+      def systemd_command(*args)
+        command = [fetch(:sidekiq_systemctl_bin)]
 
-    def sudo_if_needed(*command)
-      if fetch(:service_unit_user) == :system
-        backend.sudo command.map(&:to_s).join(" ")
-      else
-        backend.execute(*command)
+        command << '--user' unless fetch(:sidekiq_systemctl_user) == :system
+
+        command + args
       end
-    end
 
-    def execute_systemd(*args)
-      sudo_if_needed(*systemd_command(*args))
+      def sudo_if_needed(*command)
+        if fetch(:sidekiq_systemctl_user) == :system
+          backend.sudo command.map(&:to_s).join(' ')
+        else
+          backend.execute(*command)
+        end
+      end
+
+      def execute_systemd(*)
+        sudo_if_needed(*systemd_command(*))
+      end
     end
   end
 end

data/lib/capistrano/sidekiq/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Capistrano
-  SidekiqVERSION = '3.0.0'
+  SIDEKIQ_VERSION = '3.1.0'
 end

data/lib/capistrano/sidekiq.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'capistrano/bundler'
+require 'capistrano/bundler' unless ENV['TEST']
 require 'capistrano/plugin'
 
 module Capistrano
   module SidekiqCommon
-    def compiled_template(config_file = "sidekiq.yml")
+    def compiled_template(config_file = 'sidekiq.yml')
       @config_file = config_file
       local_template_directory = fetch(:sidekiq_service_templates_path)
       search_paths = [
@@ -25,15 +25,15 @@ module Capistrano
     end
 
     def sidekiq_config
-      "--config config/#{@config_file}" if @config_file != "sidekiq.yml"
+      "--config config/#{@config_file}" if @config_file != 'sidekiq.yml'
     end
 
-    def switch_user(role, &block)
+    def switch_user(role, &)
       su_user = sidekiq_user(role)
       if su_user == role.user
         yield
       else
-        as su_user, &block
+        backend.as(su_user, &)
       end
     end
 
@@ -42,13 +42,14 @@ module Capistrano
         fetch(:sidekiq_user)
       else
         properties = role.properties
-        properties.fetch(:sidekiq_user) || # local property for sidekiq only
-          fetch(:sidekiq_user) ||
-          properties.fetch(:run_as) || # global property across multiple capistrano gems
+        properties.fetch(:sidekiq_user, nil) || # local property for sidekiq only
+          fetch(:sidekiq_user, nil) ||
+          properties.fetch(:run_as, nil) || # global property across multiple capistrano gems
           role.user
       end
     end
   end
+
   class Sidekiq < Capistrano::Plugin
     def define_tasks
       eval_rakefile File.expand_path('tasks/sidekiq.rake', __dir__)
@@ -59,7 +60,7 @@ module Capistrano
 
       set_if_empty :sidekiq_env, -> { fetch(:rack_env, fetch(:rails_env, fetch(:rake_env, fetch(:stage)))) }
       set_if_empty :sidekiq_roles, fetch(:sidekiq_role, :worker)
-      set_if_empty :sidekiq_configs, %w[sidekiq]  # sidekiq.yml
+      set_if_empty :sidekiq_configs, %w[sidekiq] # sidekiq.yml
 
       set_if_empty :sidekiq_log, -> { File.join(shared_path, 'log', 'sidekiq.log') }
       set_if_empty :sidekiq_error_log, -> { File.join(shared_path, 'log', 'sidekiq.log') }

data/lib/capistrano/tasks/helpers.rake

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+namespace :sidekiq do
+  namespace :helpers do
+    desc 'Generate multiple Sidekiq config files'
+    task :generate_configs, :count do |_task, args|
+      count = (args[:count] || 3).to_i
+
+      puts "Generating #{count} Sidekiq config files..."
+
+      # Base template
+      base_config = {
+        concurrency: 10,
+        timeout: 25,
+        verbose: false,
+        strict: true
+      }
+
+      # Generate config files
+      count.times do |i|
+        config = base_config.dup
+
+        # Assign queues based on index
+        config[:queues] = case i
+                          when 0
+                            [['critical', 2], ['high', 1]]
+                          when 1
+                            [['default', 1], ['medium', 1]]
+                          else
+                            [['low', 1], ['background', 1]]
+                          end
+
+        filename = i.zero? ? 'sidekiq.yml' : "sidekiq_#{i}.yml"
+        filepath = "config/#{filename}"
+
+        # Generate YAML content
+        content = <<~YAML
+          # Sidekiq configuration file #{i + 1}/#{count}
+          :concurrency: #{config[:concurrency]}
+          :timeout: #{config[:timeout]}
+          :verbose: #{config[:verbose]}
+          :strict: #{config[:strict]}
+
+          :queues:
+        YAML
+
+        config[:queues].each do |queue, priority|
+          content += "  - [#{queue}, #{priority}]\n"
+        end
+
+        puts "  Creating #{filepath}..."
+        File.write(filepath, content)
+      end
+
+      puts "\nAdd to your deploy.rb:"
+      puts "set :sidekiq_config_files, #{count.times.map do |i|
+        i.zero? ? "'sidekiq.yml'" : "'sidekiq_#{i}.yml'"
+      end.join(', ')}"
+    end
+
+    desc 'Show current Sidekiq configuration'
+    task :show_config do
+      on roles(fetch(:sidekiq_roles)) do
+        within current_path do
+          config_files = fetch(:sidekiq_config_files, ['sidekiq.yml'])
+
+          config_files.each do |config_file|
+            puts "\n=== #{config_file} ==="
+            if test("[ -f config/#{config_file} ]")
+              puts capture(:cat, "config/#{config_file}")
+            else
+              puts '  File not found'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/capistrano/tasks/sidekiq.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 namespace :deploy do
   before :starting, :check_sidekiq_hooks do
     invoke 'sidekiq:add_default_hooks' if fetch(:sidekiq_default_hooks)
@@ -8,7 +10,36 @@ namespace :sidekiq do
   task :add_default_hooks do
     after 'deploy:starting', 'sidekiq:quiet' if Rake::Task.task_defined?('sidekiq:quiet')
     after 'deploy:updated', 'sidekiq:stop'
+    after 'deploy:reverted', 'sidekiq:stop'
     after 'deploy:published', 'sidekiq:start'
+    after 'deploy:published', 'sidekiq:mark_deploy' if fetch(:sidekiq_mark_deploy, false)
     after 'deploy:failed', 'sidekiq:restart'
   end
+
+  desc 'Mark deployment in Sidekiq metrics'
+  task :mark_deploy do
+    if fetch(:sidekiq_mark_deploy, false)
+      on roles(fetch(:sidekiq_roles)) do
+        within current_path do
+          # Get deploy label - use custom label or git description
+          deploy_label = fetch(:sidekiq_deploy_label) || begin
+            capture(:git, 'log', '-1', '--format="%h %s"').strip
+          rescue StandardError
+            "#{fetch(:application)} #{fetch(:stage)} deploy"
+          end
+
+          info "Marking deployment in Sidekiq metrics: #{deploy_label}"
+
+          # Create a Ruby script to mark the deployment
+          mark_deploy_script = <<~RUBY
+            require 'sidekiq/deploy'
+            Sidekiq::Deploy.mark!(ARGV[0])
+          RUBY
+
+          # Execute the script with the deploy label
+          execute :bundle, :exec, :ruby, '-e', mark_deploy_script, '--', deploy_label
+        end
+      end
+    end
+  end
 end

data/lib/capistrano/tasks/systemd.rake

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 git_plugin = self
@@ -56,11 +55,11 @@ namespace :sidekiq do
   task :enable do
     on roles(fetch(:sidekiq_roles)) do |role|
       git_plugin.config_files(role).each do |config_file|
-        git_plugin.execute_systemd("enable", git_plugin.sidekiq_service_file_name(config_file))
+        git_plugin.execute_systemd('enable', git_plugin.sidekiq_service_file_name(config_file))
       end
 
-      if fetch(:systemctl_user) && fetch(:sidekiq_lingering_user)
-        execute :loginctl, "enable-linger", fetch(:sidekiq_lingering_user)
+      if fetch(:sidekiq_enable_lingering) && fetch(:sidekiq_lingering_user)
+        execute :loginctl, 'enable-linger', fetch(:sidekiq_lingering_user)
       end
     end
   end
@@ -69,36 +68,36 @@ namespace :sidekiq do
   task :disable do
     on roles(fetch(:sidekiq_roles)) do |role|
       git_plugin.config_files(role).each do |config_file|
-        git_plugin.execute_systemd("disable", git_plugin.sidekiq_service_file_name(config_file))
+        git_plugin.execute_systemd('disable', git_plugin.sidekiq_service_file_name(config_file))
       end
     end
   end
 
   def fetch_systemd_unit_path
     if fetch(:sidekiq_systemctl_user) == :system
-      "/etc/systemd/system/"
+      '/etc/systemd/system/'
     else
       home_dir = backend.capture :pwd
-      File.join(home_dir, ".config", "systemd", "user")
+      File.join(home_dir, '.config', 'systemd', 'user')
     end
   end
 
   def create_systemd_template(role)
     systemd_path = fetch(:service_unit_path, fetch_systemd_unit_path)
-    backend.execute :mkdir, '-p', systemd_path if fetch(:systemctl_user)
+    backend.execute :mkdir, '-p', systemd_path if fetch(:sidekiq_systemctl_user) != :system
 
     config_files(role).each do |config_file|
-        ctemplate = compiled_template(config_file)
-        temp_file_name = File.join('/tmp', "sidekiq.#{config_file}.service")
-        systemd_file_name = File.join(systemd_path, sidekiq_service_file_name(config_file))
-        backend.upload!(StringIO.new(ctemplate), temp_file_name)
-        if fetch(:systemctl_user)
-          warn "Moving #{temp_file_name} to #{systemd_file_name}"
-          backend.execute :mv, temp_file_name, systemd_file_name
-        else
-          warn "Installing #{systemd_file_name} as root"
-          backend.execute :sudo, :mv, temp_file_name, systemd_file_name
-        end
+      ctemplate = compiled_template(config_file)
+      temp_file_name = File.join('/tmp', "sidekiq.#{config_file}.service")
+      systemd_file_name = File.join(systemd_path, sidekiq_service_file_name(config_file))
+      backend.upload!(StringIO.new(ctemplate), temp_file_name)
+      if fetch(:sidekiq_systemctl_user) == :system
+        warn "Installing #{systemd_file_name} as root"
+        backend.execute :sudo, :mv, temp_file_name, systemd_file_name
+      else
+        warn "Moving #{temp_file_name} to #{systemd_file_name}"
+        backend.execute :mv, temp_file_name, systemd_file_name
+      end
     end
   end
 
@@ -107,12 +106,12 @@ namespace :sidekiq do
 
     config_files(role).each do |config_file|
       systemd_file_name = File.join(systemd_path, sidekiq_service_file_name(config_file))
-      if fetch(:systemctl_user)
-        warn "Deleting #{systemd_file_name}"
-        backend.execute :rm, "-f", systemd_file_name
-      else
+      if fetch(:sidekiq_systemctl_user) == :system
         warn "Deleting #{systemd_file_name} as root"
-        backend.execute :sudo, :rm, "-f", systemd_file_name
+        backend.execute :sudo, :rm, '-f', systemd_file_name
+      else
+        warn "Deleting #{systemd_file_name}"
+        backend.execute :rm, '-f', systemd_file_name
       end
     end
   end
@@ -121,21 +120,21 @@ namespace :sidekiq do
     config_files(role).each do |config_file|
       sidekiq_service = sidekiq_service_unit_name(config_file)
       warn "Quieting #{sidekiq_service}"
-      execute_systemd("kill -s TSTP", sidekiq_service)
+      execute_systemd('kill -s TSTP', sidekiq_service)
     end
   end
 
   def sidekiq_service_unit_name(config_file)
-    if config_file != "sidekiq.yml"
-      fetch(:sidekiq_service_unit_name) + "." + config_file.split(".")[0..-2].join(".")
-    else
+    if config_file == 'sidekiq.yml'
       fetch(:sidekiq_service_unit_name)
+    else
+      "#{fetch(:sidekiq_service_unit_name)}.#{config_file.split('.')[0..-2].join('.')}"
     end
   end
 
   def sidekiq_service_file_name(config_file)
     ## Remove the extension
-    config_file = config_file.split('.')[0..-1].join('.')
+    config_file = config_file.split('.').join('.')
 
     "#{sidekiq_service_unit_name(config_file)}.service"
   end

data/lib/capistrano/templates/sidekiq.service.capistrano.erb

@@ -20,7 +20,11 @@ Type=notify
 WatchdogSec=10
 <%="User=#{sidekiq_user}" if fetch(:sidekiq_systemctl_user) == :system %>
 WorkingDirectory=<%= current_path %>
-ExecStart=<%= expanded_bundle_path %> exec sidekiq -e <%= fetch(:sidekiq_env) %> <%= sidekiq_config %>
+<% if fetch(:sidekiq_use_login_shell) %>
+ExecStart=/bin/bash -lc '<%= expanded_bundle_path %> exec <%= fetch(:sidekiq_command) %> <%= fetch(:sidekiq_command_args) %> <%= sidekiq_config %>'
+<% else %>
+ExecStart=<%= expanded_bundle_path %> exec <%= fetch(:sidekiq_command) %> <%= fetch(:sidekiq_command_args) %> <%= sidekiq_config %>
+<% end %>
 
 # Use `systemctl kill -s TSTP <% sidekiq_service_unit_name(@config_file) %>` to quiet the Sidekiq process
 UMask=0002

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: capistrano-sidekiq
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Abdelkader Boudih
 bindir: bin
 cert_chain: []
-date: 2025-01-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: capistrano
@@ -43,14 +43,84 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.6
+        version: '7.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 6.0.6
+        version: '7.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.50'
+- !ruby/object:Gem::Dependency
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.30'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.30'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.6'
 description: Sidekiq integration for Capistrano
 email:
 - terminale@gmail.com
@@ -65,15 +135,15 @@ files:
 - lib/capistrano/sidekiq.rb
 - lib/capistrano/sidekiq/systemd.rb
 - lib/capistrano/sidekiq/version.rb
+- lib/capistrano/tasks/helpers.rake
 - lib/capistrano/tasks/sidekiq.rake
 - lib/capistrano/tasks/systemd.rake
 - lib/capistrano/templates/sidekiq.service.capistrano.erb
-- lib/generators/capistrano/sidekiq/monit/template_generator.rb
-- lib/generators/capistrano/sidekiq/monit/templates/sidekiq_monit.conf.erb
 homepage: https://github.com/seuros/capistrano-sidekiq
 licenses:
 - LGPL-3.0
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message: "\n    Version 3.0.0 is a major release. Please see README.md,
   breaking changes are listed in CHANGELOG.md\n  "
 rdoc_options: []
@@ -83,14 +153,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Sidekiq integration for Capistrano
 test_files: []

data/lib/generators/capistrano/sidekiq/monit/template_generator.rb

@@ -1,24 +0,0 @@
-require 'rails/generators/base'
-
-module Capistrano
-  module Sidekiq
-    module Monit
-      module Generators
-        class TemplateGenerator < Rails::Generators::Base
-
-          namespace "capistrano:sidekiq:monit:template"
-          desc "Create local monitrc.erb, and erb files for monitored processes for customization"
-          source_root File.expand_path('../templates', __FILE__)
-          argument :templates_path, type: :string,
-            default: "config/deploy/templates",
-            banner: "path to templates"
-
-          def copy_template
-            copy_file "sidekiq_monit.conf.erb", "#{templates_path}/sidekiq_monit.erb"
-          end
-
-        end
-      end
-    end
-  end
-end

data/lib/generators/capistrano/sidekiq/monit/templates/sidekiq_monit.conf.erb

@@ -1,8 +0,0 @@
-# Monit configuration for Sidekiq
-# Service name: <%= sidekiq_service_name %>
-#
-check process <%= sidekiq_service_name %>
-  matching 'sidekiq .* <%= fetch(:application) %>'
-  start program = "/bin/su - <%= sidekiq_user(role) %> -c 'cd <%= current_path %> && <%= SSHKit.config.command_map[:bundle] %> exec sidekiq -e <%= fetch(:sidekiq_env) %> <%= sidekiq_config %> <%= sidekiq_concurrency %> <%= sidekiq_require %> <%= sidekiq_queues %> <%= sidekiq_logfile ? ">> #{sidekiq_logfile} 2>&1" : nil %> &'" with timeout <%= fetch(:sidekiq_timeout).to_i + 10 %> seconds
-  stop program = "/bin/su - <%= sidekiq_user(role) %> -c 'ps ax | grep "<%= "sidekiq .* #{fetch(:application)}" %>" | grep -v grep | awk "{print \$1}" | xargs --no-run-if-empty kill'" with timeout <%= fetch(:sidekiq_timeout).to_i + 10  %> seconds
-  group <%= fetch(:sidekiq_monit_group) || fetch(:application) %>-sidekiq