Add ApplicationWorker and make every worker include it

c5bd57e8 · Douwe Maan · 2d08a15f · c5bd57e8 · c5bd57e8 · c5bd57e8
Commit c5bd57e8 authored Nov 28, 2017 by Douwe Maan
129 changed files
--- a/app/workers/admin_email_worker.rb
+++ b/app/workers/admin_email_worker.rb
 class AdminEmailWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/app/workers/authorized_projects_worker.rb
+++ b/app/workers/authorized_projects_worker.rb
 class AuthorizedProjectsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  # Schedules multiple jobs and waits for them to be completed.
  def self.bulk_perform_and_wait(args_list)

--- a/app/workers/background_migration_worker.rb
+++ b/app/workers/background_migration_worker.rb
 class BackgroundMigrationWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  # Enqueues a number of jobs in bulk.
  #

--- a/app/workers/build_coverage_worker.rb
+++ b/app/workers/build_coverage_worker.rb
 class BuildCoverageWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  def perform(build_id)

--- a/app/workers/build_finished_worker.rb
+++ b/app/workers/build_finished_worker.rb
 class BuildFinishedWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  enqueue_in group: :processing

--- a/app/workers/build_hooks_worker.rb
+++ b/app/workers/build_hooks_worker.rb
 class BuildHooksWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  enqueue_in group: :hooks

--- a/app/workers/build_queue_worker.rb
+++ b/app/workers/build_queue_worker.rb
 class BuildQueueWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  enqueue_in group: :processing

--- a/app/workers/build_success_worker.rb
+++ b/app/workers/build_success_worker.rb
 class BuildSuccessWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  enqueue_in group: :processing

--- a/app/workers/build_trace_sections_worker.rb
+++ b/app/workers/build_trace_sections_worker.rb
 class BuildTraceSectionsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  def perform(build_id)

--- a/app/workers/cluster_install_app_worker.rb
+++ b/app/workers/cluster_install_app_worker.rb
 class ClusterInstallAppWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include ClusterQueue
  include ClusterApplications

--- a/app/workers/cluster_provision_worker.rb
+++ b/app/workers/cluster_provision_worker.rb
 class ClusterProvisionWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include ClusterQueue
  def perform(cluster_id)

--- a/app/workers/cluster_wait_for_app_installation_worker.rb
+++ b/app/workers/cluster_wait_for_app_installation_worker.rb
 class ClusterWaitForAppInstallationWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include ClusterQueue
  include ClusterApplications

--- a/app/workers/concerns/application_worker.rb
+++ b/app/workers/concerns/application_worker.rb
+Sidekiq::Worker.extend ActiveSupport::Concern
+module ApplicationWorker
+  extend ActiveSupport::Concern
+  include Sidekiq::Worker
+  included do
+    sidekiq_options queue: base_queue_name
+  end
+  module ClassMethods
+    def base_queue_name
+      name
+        .sub(/\AGitlab::/, '')
+        .sub(/Worker\z/, '')
+        .underscore
+        .tr('/', '_')
+    end
+    def queue
+      get_sidekiq_options['queue'].to_s
+    end
+  end
+end
--- a/app/workers/concerns/dedicated_sidekiq_queue.rb
+++ b/app/workers/concerns/dedicated_sidekiq_queue.rb
-# Concern that sets the queue of a Sidekiq worker based on the worker's class
-# name/namespace.
-module DedicatedSidekiqQueue
-  extend ActiveSupport::Concern
-  included do
-    sidekiq_options queue: name.sub(/Worker\z/, '').underscore.tr('/', '_')
-  end
-end
--- a/app/workers/concerns/gitlab/github_import/object_importer.rb
+++ b/app/workers/concerns/gitlab/github_import/object_importer.rb
@@ -8,7 +8,7 @@ module Gitlab
      extend ActiveSupport::Concern
      included do
-        include Sidekiq::Worker
+        include ApplicationWorker
        include GithubImport::Queue
        include ReschedulingMethods
        include NotifyUponDeath

--- a/app/workers/create_gpg_signature_worker.rb
+++ b/app/workers/create_gpg_signature_worker.rb
 class CreateGpgSignatureWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(commit_sha, project_id)
    project = Project.find_by(id: project_id)

--- a/app/workers/create_pipeline_worker.rb
+++ b/app/workers/create_pipeline_worker.rb
 class CreatePipelineWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  enqueue_in group: :creation

--- a/app/workers/delete_merged_branches_worker.rb
+++ b/app/workers/delete_merged_branches_worker.rb
 class DeleteMergedBranchesWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(project_id, user_id)
    begin

--- a/app/workers/delete_user_worker.rb
+++ b/app/workers/delete_user_worker.rb
 class DeleteUserWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(current_user_id, delete_user_id, options = {})
    delete_user  = User.find(delete_user_id)

--- a/app/workers/email_receiver_worker.rb
+++ b/app/workers/email_receiver_worker.rb
 class EmailReceiverWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(raw)
    return unless Gitlab::IncomingEmail.enabled?

--- a/app/workers/emails_on_push_worker.rb
+++ b/app/workers/emails_on_push_worker.rb
 class EmailsOnPushWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  attr_reader :email, :skip_premailer

--- a/app/workers/expire_build_artifacts_worker.rb
+++ b/app/workers/expire_build_artifacts_worker.rb
 class ExpireBuildArtifactsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/app/workers/expire_build_instance_artifacts_worker.rb
+++ b/app/workers/expire_build_instance_artifacts_worker.rb
 class ExpireBuildInstanceArtifactsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(build_id)
    build = Ci::Build

--- a/app/workers/expire_job_cache_worker.rb
+++ b/app/workers/expire_job_cache_worker.rb
 class ExpireJobCacheWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  enqueue_in group: :cache

--- a/app/workers/expire_pipeline_cache_worker.rb
+++ b/app/workers/expire_pipeline_cache_worker.rb
 class ExpirePipelineCacheWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  enqueue_in group: :cache

--- a/app/workers/geo/base_scheduler_worker.rb
+++ b/app/workers/geo/base_scheduler_worker.rb
 module Geo
  class BaseSchedulerWorker
-    include Sidekiq::Worker
+    include ApplicationWorker
    include CronjobQueue
    include ExclusiveLeaseGuard

--- a/app/workers/geo/file_download_worker.rb
+++ b/app/workers/geo/file_download_worker.rb
 module Geo
  class FileDownloadWorker
-    include Sidekiq::Worker
+    include ApplicationWorker
-    sidekiq_options queue: :geo_file_download, retry: 3, dead: false
+    sidekiq_options retry: 3, dead: false
    def perform(object_type, object_id)
      Geo::FileDownloadService.new(object_type.to_sym, object_id).execute

--- a/app/workers/geo/file_removal_worker.rb
+++ b/app/workers/geo/file_removal_worker.rb
 module Geo
  class FileRemovalWorker
-    include Sidekiq::Worker
+    include ApplicationWorker
    include Gitlab::Geo::LogHelpers
+    include GeoQueue
-    sidekiq_options queue: :geo
    def perform(file_path)
      remove_file!(file_path)

--- a/app/workers/geo/hashed_storage_attachments_migration_worker.rb
+++ b/app/workers/geo/hashed_storage_attachments_migration_worker.rb
 module Geo
  class HashedStorageAttachmentsMigrationWorker
-    include Sidekiq::Worker
+    include ApplicationWorker
    include GeoQueue
    def perform(project_id, old_attachments_path, new_attachments_path)

--- a/app/workers/geo/hashed_storage_migration_worker.rb
+++ b/app/workers/geo/hashed_storage_migration_worker.rb
 module Geo
  class HashedStorageMigrationWorker
-    include Sidekiq::Worker
+    include ApplicationWorker
    include GeoQueue
    def perform(project_id, old_disk_path, new_disk_path, old_storage_version)

--- a/app/workers/geo/metrics_update_worker.rb
+++ b/app/workers/geo/metrics_update_worker.rb
 module Geo
  class MetricsUpdateWorker
-    include Sidekiq::Worker
+    include ApplicationWorker
    include ExclusiveLeaseGuard
    include CronjobQueue

--- a/app/workers/geo/project_sync_worker.rb
+++ b/app/workers/geo/project_sync_worker.rb
 module Geo
  class ProjectSyncWorker
-    include Sidekiq::Worker
+    include ApplicationWorker
-    sidekiq_options queue: :geo_project_sync, retry: 3, dead: false
+    sidekiq_options retry: 3, dead: false
    sidekiq_retry_in { |count| 30 * count }

--- a/app/workers/geo/prune_event_log_worker.rb
+++ b/app/workers/geo/prune_event_log_worker.rb
 module Geo
  class PruneEventLogWorker
-    include Sidekiq::Worker
+    include ApplicationWorker
    include CronjobQueue
    include ExclusiveLeaseGuard
    include ::Gitlab::Geo::LogHelpers

--- a/app/workers/geo/rename_repository_worker.rb
+++ b/app/workers/geo/rename_repository_worker.rb
 module Geo
  class RenameRepositoryWorker
-    include Sidekiq::Worker
+    include ApplicationWorker
    include GeoQueue
    def perform(project_id, old_disk_path, new_disk_path)

--- a/app/workers/geo/repositories_clean_up_worker.rb
+++ b/app/workers/geo/repositories_clean_up_worker.rb
 module Geo
  class RepositoriesCleanUpWorker
-    include Sidekiq::Worker
+    include ApplicationWorker
    include GeoQueue
    include Gitlab::ShellAdapter
    include ExclusiveLeaseGuard

--- a/app/workers/geo_repository_destroy_worker.rb
+++ b/app/workers/geo_repository_destroy_worker.rb
 class GeoRepositoryDestroyWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include GeoQueue
  include Gitlab::ShellAdapter

--- a/app/workers/git_garbage_collect_worker.rb
+++ b/app/workers/git_garbage_collect_worker.rb
 class GitGarbageCollectWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  include Gitlab::CurrentSettings
  sidekiq_options retry: false

--- a/app/workers/gitlab/github_import/advance_stage_worker.rb
+++ b/app/workers/gitlab/github_import/advance_stage_worker.rb
@@ -7,7 +7,7 @@ module Gitlab
    # been completed this worker will advance the import process to the next
    # stage.
    class AdvanceStageWorker
-      include Sidekiq::Worker
+      include ApplicationWorker
      sidekiq_options queue: 'github_importer_advance_stage', dead: false

--- a/app/workers/gitlab/github_import/refresh_import_jid_worker.rb
+++ b/app/workers/gitlab/github_import/refresh_import_jid_worker.rb
@@ -3,7 +3,7 @@
 module Gitlab
  module GithubImport
    class RefreshImportJidWorker
-      include Sidekiq::Worker
+      include ApplicationWorker
      include GithubImport::Queue
      # The interval to schedule new instances of this job at.

--- a/app/workers/gitlab/github_import/stage/finish_import_worker.rb
+++ b/app/workers/gitlab/github_import/stage/finish_import_worker.rb
@@ -4,7 +4,7 @@ module Gitlab
  module GithubImport
    module Stage
      class FinishImportWorker
-        include Sidekiq::Worker
+        include ApplicationWorker
        include GithubImport::Queue
        include StageMethods

--- a/app/workers/gitlab/github_import/stage/import_base_data_worker.rb
+++ b/app/workers/gitlab/github_import/stage/import_base_data_worker.rb
@@ -4,7 +4,7 @@ module Gitlab
  module GithubImport
    module Stage
      class ImportBaseDataWorker
-        include Sidekiq::Worker
+        include ApplicationWorker
        include GithubImport::Queue
        include StageMethods

--- a/app/workers/gitlab/github_import/stage/import_issues_and_diff_notes_worker.rb
+++ b/app/workers/gitlab/github_import/stage/import_issues_and_diff_notes_worker.rb
@@ -4,7 +4,7 @@ module Gitlab
  module GithubImport
    module Stage
      class ImportIssuesAndDiffNotesWorker
-        include Sidekiq::Worker
+        include ApplicationWorker
        include GithubImport::Queue
        include StageMethods

--- a/app/workers/gitlab/github_import/stage/import_notes_worker.rb
+++ b/app/workers/gitlab/github_import/stage/import_notes_worker.rb
@@ -4,7 +4,7 @@ module Gitlab
  module GithubImport
    module Stage
      class ImportNotesWorker
-        include Sidekiq::Worker
+        include ApplicationWorker
        include GithubImport::Queue
        include StageMethods

--- a/app/workers/gitlab/github_import/stage/import_pull_requests_worker.rb
+++ b/app/workers/gitlab/github_import/stage/import_pull_requests_worker.rb
@@ -4,7 +4,7 @@ module Gitlab
  module GithubImport
    module Stage
      class ImportPullRequestsWorker
-        include Sidekiq::Worker
+        include ApplicationWorker
        include GithubImport::Queue
        include StageMethods

--- a/app/workers/gitlab/github_import/stage/import_repository_worker.rb
+++ b/app/workers/gitlab/github_import/stage/import_repository_worker.rb
@@ -4,7 +4,7 @@ module Gitlab
  module GithubImport
    module Stage
      class ImportRepositoryWorker
-        include Sidekiq::Worker
+        include ApplicationWorker
        include GithubImport::Queue
        include StageMethods

--- a/app/workers/gitlab_shell_worker.rb
+++ b/app/workers/gitlab_shell_worker.rb
 class GitlabShellWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include Gitlab::ShellAdapter
-  include DedicatedSidekiqQueue
  def perform(action, *arg)
    gitlab_shell.__send__(action, *arg) # rubocop:disable GitlabSecurity/PublicSend

--- a/app/workers/gitlab_usage_ping_worker.rb
+++ b/app/workers/gitlab_usage_ping_worker.rb
 class GitlabUsagePingWorker
  LEASE_TIMEOUT = 86400
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/app/workers/group_destroy_worker.rb
+++ b/app/workers/group_destroy_worker.rb
 class GroupDestroyWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  include ExceptionBacktrace
  def perform(group_id, user_id)

--- a/app/workers/import_export_project_cleanup_worker.rb
+++ b/app/workers/import_export_project_cleanup_worker.rb
 class ImportExportProjectCleanupWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/app/workers/invalid_gpg_signature_update_worker.rb
+++ b/app/workers/invalid_gpg_signature_update_worker.rb
 class InvalidGpgSignatureUpdateWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(gpg_key_id)
    gpg_key = GpgKey.find_by(id: gpg_key_id)

--- a/app/workers/irker_worker.rb
+++ b/app/workers/irker_worker.rb
@@ -2,8 +2,7 @@ require 'json'
 require 'socket'
 class IrkerWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(project_id, chans, colors, push_data, settings)
    project = Project.find(project_id)

--- a/app/workers/merge_worker.rb
+++ b/app/workers/merge_worker.rb
 class MergeWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(merge_request_id, current_user_id, params)
    params = params.with_indifferent_access

--- a/app/workers/namespaceless_project_destroy_worker.rb
+++ b/app/workers/namespaceless_project_destroy_worker.rb
@@ -5,8 +5,7 @@
 # The worker will reject doing anything for projects that *do* have a
 # namespace. For those use ProjectDestroyWorker instead.
 class NamespacelessProjectDestroyWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  include ExceptionBacktrace
  def self.bulk_perform_async(args_list)

--- a/app/workers/new_issue_worker.rb
+++ b/app/workers/new_issue_worker.rb
 class NewIssueWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  include NewIssuable
  def perform(issue_id, user_id)

--- a/app/workers/new_merge_request_worker.rb
+++ b/app/workers/new_merge_request_worker.rb
 class NewMergeRequestWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  include NewIssuable
  def perform(merge_request_id, user_id)

--- a/app/workers/new_note_worker.rb
+++ b/app/workers/new_note_worker.rb
 class NewNoteWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  # Keep extra parameter to preserve backwards compatibility with
  # old `NewNoteWorker` jobs (can remove later)

--- a/app/workers/pages_worker.rb
+++ b/app/workers/pages_worker.rb
 class PagesWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  sidekiq_options queue: :pages, retry: false

--- a/app/workers/pipeline_hooks_worker.rb
+++ b/app/workers/pipeline_hooks_worker.rb
 class PipelineHooksWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  enqueue_in group: :hooks

--- a/app/workers/pipeline_metrics_worker.rb
+++ b/app/workers/pipeline_metrics_worker.rb
 class PipelineMetricsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  def perform(pipeline_id)

--- a/app/workers/pipeline_notification_worker.rb
+++ b/app/workers/pipeline_notification_worker.rb
 class PipelineNotificationWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  def perform(pipeline_id, recipients = nil)

--- a/app/workers/pipeline_process_worker.rb
+++ b/app/workers/pipeline_process_worker.rb
 class PipelineProcessWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  enqueue_in group: :processing

--- a/app/workers/pipeline_schedule_worker.rb
+++ b/app/workers/pipeline_schedule_worker.rb
 class PipelineScheduleWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/app/workers/pipeline_success_worker.rb
+++ b/app/workers/pipeline_success_worker.rb
 class PipelineSuccessWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  enqueue_in group: :processing

--- a/app/workers/pipeline_update_worker.rb
+++ b/app/workers/pipeline_update_worker.rb
 class PipelineUpdateWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  enqueue_in group: :processing

--- a/app/workers/post_receive.rb
+++ b/app/workers/post_receive.rb
 class PostReceive
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  prepend EE::PostReceive
  def perform(gl_repository, identifier, changes)

--- a/app/workers/process_commit_worker.rb
+++ b/app/workers/process_commit_worker.rb
@@ -5,8 +5,7 @@
 # Consider using an extra worker if you need to add any extra (and potentially
 # slow) processing of commits.
 class ProcessCommitWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  # project_id - The ID of the project this commit belongs to.
  # user_id - The ID of the user that pushed the commit.

--- a/app/workers/project_cache_worker.rb
+++ b/app/workers/project_cache_worker.rb
 # Worker for updating any project specific caches.
 class ProjectCacheWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  prepend EE::Workers::ProjectCacheWorker
  LEASE_TIMEOUT = 15.minutes.to_i

--- a/app/workers/project_destroy_worker.rb
+++ b/app/workers/project_destroy_worker.rb
 class ProjectDestroyWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  include ExceptionBacktrace
  def perform(project_id, user_id, params)

--- a/app/workers/project_export_worker.rb
+++ b/app/workers/project_export_worker.rb
 class ProjectExportWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  include ExceptionBacktrace
  sidekiq_options retry: 3

--- a/app/workers/project_migrate_hashed_storage_worker.rb
+++ b/app/workers/project_migrate_hashed_storage_worker.rb
 class ProjectMigrateHashedStorageWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  LEASE_TIMEOUT = 30.seconds.to_i

--- a/app/workers/project_service_worker.rb
+++ b/app/workers/project_service_worker.rb
 class ProjectServiceWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  sidekiq_options dead: false

--- a/app/workers/propagate_service_template_worker.rb
+++ b/app/workers/propagate_service_template_worker.rb
 # Worker for updating any project specific caches.
 class PropagateServiceTemplateWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  LEASE_TIMEOUT = 4.hours.to_i

--- a/app/workers/prune_old_events_worker.rb
+++ b/app/workers/prune_old_events_worker.rb
 class PruneOldEventsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/app/workers/reactive_caching_worker.rb
+++ b/app/workers/reactive_caching_worker.rb
 class ReactiveCachingWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(class_name, id, *args)
    klass = begin

--- a/app/workers/remove_expired_group_links_worker.rb
+++ b/app/workers/remove_expired_group_links_worker.rb
 class RemoveExpiredGroupLinksWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/app/workers/remove_expired_members_worker.rb
+++ b/app/workers/remove_expired_members_worker.rb
 class RemoveExpiredMembersWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/app/workers/remove_old_web_hook_logs_worker.rb
+++ b/app/workers/remove_old_web_hook_logs_worker.rb
 class RemoveOldWebHookLogsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  WEB_HOOK_LOG_LIFETIME = 2.days

--- a/app/workers/remove_unreferenced_lfs_objects_worker.rb
+++ b/app/workers/remove_unreferenced_lfs_objects_worker.rb
 class RemoveUnreferencedLfsObjectsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/app/workers/repository_archive_cache_worker.rb
+++ b/app/workers/repository_archive_cache_worker.rb
 class RepositoryArchiveCacheWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/app/workers/repository_check/batch_worker.rb
+++ b/app/workers/repository_check/batch_worker.rb
 module RepositoryCheck
  class BatchWorker
-    include Sidekiq::Worker
+    include ApplicationWorker
    include CronjobQueue
    RUN_TIME = 3600

--- a/app/workers/repository_check/clear_worker.rb
+++ b/app/workers/repository_check/clear_worker.rb
 module RepositoryCheck
  class ClearWorker
-    include Sidekiq::Worker
+    include ApplicationWorker
    include RepositoryCheckQueue
    def perform

--- a/app/workers/repository_check/single_repository_worker.rb
+++ b/app/workers/repository_check/single_repository_worker.rb
 module RepositoryCheck
  class SingleRepositoryWorker
-    include Sidekiq::Worker
+    include ApplicationWorker
    include RepositoryCheckQueue
    def perform(project_id)

--- a/app/workers/repository_fork_worker.rb
+++ b/app/workers/repository_fork_worker.rb
 class RepositoryForkWorker
  ForkError = Class.new(StandardError)
-  include Sidekiq::Worker
+  include ApplicationWorker
  include Gitlab::ShellAdapter
-  include DedicatedSidekiqQueue
  include ProjectStartImport
  sidekiq_options status_expiration: StuckImportJobsWorker::IMPORT_JOBS_EXPIRATION

--- a/app/workers/repository_import_worker.rb
+++ b/app/workers/repository_import_worker.rb
 class RepositoryImportWorker
  ImportError = Class.new(StandardError)
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  include ExceptionBacktrace
  include ProjectStartImport

--- a/app/workers/requests_profiles_worker.rb
+++ b/app/workers/requests_profiles_worker.rb
 class RequestsProfilesWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/app/workers/schedule_update_user_activity_worker.rb
+++ b/app/workers/schedule_update_user_activity_worker.rb
 class ScheduleUpdateUserActivityWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform(batch_size = 500)

--- a/app/workers/stage_update_worker.rb
+++ b/app/workers/stage_update_worker.rb
 class StageUpdateWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include PipelineQueue
  enqueue_in group: :processing

--- a/app/workers/storage_migrator_worker.rb
+++ b/app/workers/storage_migrator_worker.rb
 class StorageMigratorWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  BATCH_SIZE = 100

--- a/app/workers/stuck_ci_jobs_worker.rb
+++ b/app/workers/stuck_ci_jobs_worker.rb
 class StuckCiJobsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  EXCLUSIVE_LEASE_KEY = 'stuck_ci_builds_worker_lease'.freeze

--- a/app/workers/stuck_import_jobs_worker.rb
+++ b/app/workers/stuck_import_jobs_worker.rb
 class StuckImportJobsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  IMPORT_JOBS_EXPIRATION = 15.hours.to_i

--- a/app/workers/stuck_merge_jobs_worker.rb
+++ b/app/workers/stuck_merge_jobs_worker.rb
 class StuckMergeJobsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/app/workers/system_hook_push_worker.rb
+++ b/app/workers/system_hook_push_worker.rb
 class SystemHookPushWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(push_data, hook_id)
    SystemHooksService.new.execute_hooks(push_data, hook_id)

--- a/app/workers/trending_projects_worker.rb
+++ b/app/workers/trending_projects_worker.rb
 class TrendingProjectsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/app/workers/update_merge_requests_worker.rb
+++ b/app/workers/update_merge_requests_worker.rb
 class UpdateMergeRequestsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  LOG_TIME_THRESHOLD = 90 # seconds

--- a/app/workers/update_user_activity_worker.rb
+++ b/app/workers/update_user_activity_worker.rb
 class UpdateUserActivityWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(pairs)
    pairs = cast_data(pairs)

--- a/app/workers/upload_checksum_worker.rb
+++ b/app/workers/upload_checksum_worker.rb
 class UploadChecksumWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(upload_id)
    upload = Upload.find(upload_id)

--- a/app/workers/wait_for_cluster_creation_worker.rb
+++ b/app/workers/wait_for_cluster_creation_worker.rb
 class WaitForClusterCreationWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include ClusterQueue
  def perform(cluster_id)

--- a/app/workers/web_hook_worker.rb
+++ b/app/workers/web_hook_worker.rb
 class WebHookWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  sidekiq_options retry: 4, dead: false

--- a/config/initializers/sidekiq.rb
+++ b/config/initializers/sidekiq.rb
@@ -76,12 +76,14 @@ end
 # The Sidekiq client API always adds the queue to the Sidekiq queue
 # list, but mail_room and gitlab-shell do not. This is only necessary
 # for monitoring.
-queues = Gitlab::SidekiqConfig.queues
 begin
+  queues = Gitlab::SidekiqConfig.worker_queues
  Sidekiq.redis do |conn|
    conn.pipelined do
-      queues.each { |queue| conn.sadd('queues', queue) }
+      queues.each do |queue|
+        conn.sadd('queues', queue)
+      end
    end
  end
 rescue Redis::BaseError, SocketError, Errno::ENOENT, Errno::EADDRNOTAVAIL, Errno::EAFNOSUPPORT, Errno::ECONNRESET, Errno::ECONNREFUSED

--- a/doc/development/sidekiq_style_guide.md
+++ b/doc/development/sidekiq_style_guide.md
@@ -18,8 +18,7 @@ include the `DedicatedSidekiqQueue` concern as follows:
 ```ruby
 class ProcessSomethingWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
 end
 ```

--- a/ee/app/workers/admin_emails_worker.rb
+++ b/ee/app/workers/admin_emails_worker.rb
 class AdminEmailsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(recipient_id, subject, body)
    recipient_list(recipient_id).pluck(:id).uniq.each do |user_id|

--- a/ee/app/workers/clear_shared_runners_minutes_worker.rb
+++ b/ee/app/workers/clear_shared_runners_minutes_worker.rb
 class ClearSharedRunnersMinutesWorker
  LEASE_TIMEOUT = 3600
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/ee/app/workers/elastic_batch_project_indexer_worker.rb
+++ b/ee/app/workers/elastic_batch_project_indexer_worker.rb
 class ElasticBatchProjectIndexerWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include Gitlab::CurrentSettings
  # Batch indexing is a generally a onetime option, so give finer control over
  # queuing and concurrency
-  include DedicatedSidekiqQueue
  # This worker is long-running, but idempotent, so retry many times if
  # necessary

--- a/ee/app/workers/elastic_commit_indexer_worker.rb
+++ b/ee/app/workers/elastic_commit_indexer_worker.rb
 class ElasticCommitIndexerWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  include Gitlab::CurrentSettings
  sidekiq_options retry: 2

--- a/ee/app/workers/elastic_indexer_worker.rb
+++ b/ee/app/workers/elastic_indexer_worker.rb
 class ElasticIndexerWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  include Elasticsearch::Model::Client::ClassMethods
  include Gitlab::CurrentSettings

--- a/ee/app/workers/export_csv_worker.rb
+++ b/ee/app/workers/export_csv_worker.rb
 class ExportCsvWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(current_user_id, project_id, params)
    @current_user = User.find(current_user_id)

--- a/ee/app/workers/historical_data_worker.rb
+++ b/ee/app/workers/historical_data_worker.rb
 class HistoricalDataWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/ee/app/workers/ldap_all_groups_sync_worker.rb
+++ b/ee/app/workers/ldap_all_groups_sync_worker.rb
 class LdapAllGroupsSyncWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/ee/app/workers/ldap_group_sync_worker.rb
+++ b/ee/app/workers/ldap_group_sync_worker.rb
 class LdapGroupSyncWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(group_ids, provider = nil)
    return unless Gitlab::LDAP::Config.group_sync_enabled?

--- a/ee/app/workers/ldap_sync_worker.rb
+++ b/ee/app/workers/ldap_sync_worker.rb
 class LdapSyncWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  def perform

--- a/ee/app/workers/object_storage_upload_worker.rb
+++ b/ee/app/workers/object_storage_upload_worker.rb
 class ObjectStorageUploadWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(uploader_class_name, subject_class_name, file_field, subject_id)
    uploader_class = uploader_class_name.constantize

--- a/ee/app/workers/project_update_repository_storage_worker.rb
+++ b/ee/app/workers/project_update_repository_storage_worker.rb
 class ProjectUpdateRepositoryStorageWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
-  include DedicatedSidekiqQueue
  def perform(project_id, new_repository_storage_key)
    project = Project.find(project_id)

--- a/ee/app/workers/rebase_worker.rb
+++ b/ee/app/workers/rebase_worker.rb
 class RebaseWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  sidekiq_options queue: :merge

--- a/ee/app/workers/repository_update_mirror_worker.rb
+++ b/ee/app/workers/repository_update_mirror_worker.rb
 class RepositoryUpdateMirrorWorker
  UpdateError = Class.new(StandardError)
-  include Sidekiq::Worker
+  include ApplicationWorker
  include Gitlab::ShellAdapter
-  include DedicatedSidekiqQueue
  include ProjectStartImport
  LEASE_KEY = 'repository_update_mirror_worker_start_scheduler'.freeze

--- a/ee/app/workers/repository_update_remote_mirror_worker.rb
+++ b/ee/app/workers/repository_update_remote_mirror_worker.rb
@@ -2,9 +2,8 @@ class RepositoryUpdateRemoteMirrorWorker
  UpdateAlreadyInProgressError = Class.new(StandardError)
  UpdateError = Class.new(StandardError)
-  include Sidekiq::Worker
+  include ApplicationWorker
  include Gitlab::ShellAdapter
-  include DedicatedSidekiqQueue
  sidekiq_options retry: 3, dead: false

--- a/ee/app/workers/update_all_mirrors_worker.rb
+++ b/ee/app/workers/update_all_mirrors_worker.rb
 class UpdateAllMirrorsWorker
-  include Sidekiq::Worker
+  include ApplicationWorker
  include CronjobQueue
  LEASE_TIMEOUT = 5.minutes

--- a/lib/gitlab/sidekiq_cluster/cli.rb
+++ b/lib/gitlab/sidekiq_cluster/cli.rb
@@ -30,18 +30,16 @@ module Gitlab
        option_parser.parse!(argv)
-        parsed_queues = SidekiqCluster.parse_queues(argv)
+        queue_groups = SidekiqCluster.parse_queues(argv)
-        queues =
+        if @negate_queues
-          if @negate_queues
+          all_queues = SidekiqConfig.config_queues(@rails_path)
-            parsed_queues.map { |queues| SidekiqConfig.queues(@rails_path, except: queues) }
+          queue_groups.map! { |queues| all_queues - queues }
-          else
+        end
-            parsed_queues
-          end
-        @logger.info("Starting cluster with #{queues.length} processes")
+        @logger.info("Starting cluster with #{queue_groups.length} processes")
-        @processes = SidekiqCluster.start(queues, @environment, @rails_path)
+        @processes = SidekiqCluster.start(queue_groups, @environment, @rails_path)
        write_pid
        trap_signals

--- a/lib/gitlab/sidekiq_config.rb
+++ b/lib/gitlab/sidekiq_config.rb
@@ -2,13 +2,51 @@ require 'yaml'
 module Gitlab
  module SidekiqConfig
-    def self.queues(rails_path = Rails.root.to_s, except: [])
+    def self.redis_queues
-      queues_file_path = File.join(rails_path, 'config', 'sidekiq_queues.yml')
+      @redis_queues ||= Sidekiq::Queue.all.map(&:name)
+    end
+    # This method is called by `bin/sidekiq-cluster` in EE, which runs outside
+    # of bundler/Rails context, so we cannot use any gem or Rails methods.
+    def self.config_queues(rails_path = Rails.root.to_s)
+      @config_queues ||= begin
+        config = YAML.load_file(File.join(rails_path, 'config', 'sidekiq_queues.yml'))
+        config[:queues].map(&:first)
+      end
+    end
+    def self.cron_workers
+      @cron_workers ||= Settings.cron_jobs.map { |job_name, options| options['job_class'].constantize }
+    end
+    def self.workers
+      @workers ||=
+        find_workers(Rails.root.join('app', 'workers')) +
+        find_workers(Rails.root.join('ee', 'app', 'workers'))
+    end
+    def self.default_queues
+      [ActionMailer::DeliveryJob.queue_name, 'default']
+    end
+    def self.worker_queues
+      @worker_queues ||= (workers.map(&:queue) + default_queues).uniq
+    end
+    def self.find_workers(root)
+      concerns = root.join('concerns').to_s
+      workers = Dir[root.join('**', '*.rb')]
+        .reject { |path| path.start_with?(concerns) }
+      workers.map! do |path|
+        ns = Pathname.new(path).relative_path_from(root).to_s.gsub('.rb', '')
-      @queues_file = {}
+        ns.camelize.constantize
-      @queues_file[queues_file_path] ||= YAML.load_file(queues_file_path)
+      end
-      @queues_file[queues_file_path].fetch(:queues).map { |queue, _| queue } - except
+      # Skip concerns
+      workers.select { |w| w < Sidekiq::Worker }
    end
  end
 end
--- a/spec/lib/gitlab/sidekiq_cluster/cli_spec.rb
+++ b/spec/lib/gitlab/sidekiq_cluster/cli_spec.rb
@@ -22,7 +22,7 @@ describe Gitlab::SidekiqCluster::CLI do
      context 'with --negate flag' do
        it 'starts Sidekiq workers for all queues on sidekiq_queues.yml except the ones on argv' do
-          expect(Gitlab::SidekiqConfig).to receive(:queues).and_return(['baz'])
+          expect(Gitlab::SidekiqConfig).to receive(:config_queues).and_return(['baz'])
          expect(Gitlab::SidekiqCluster).to receive(:start)
                                              .with([['baz']], 'test', Dir.pwd)
                                              .and_return([])

--- a/spec/lib/gitlab/sidekiq_config_spec.rb
+++ b/spec/lib/gitlab/sidekiq_config_spec.rb
 require 'rails_helper'
 describe Gitlab::SidekiqConfig do
-  describe '.queues' do
+  describe '.workers' do
-    let(:queues_file_path) { Rails.root.join('config', 'sidekiq_queues.yml') }
+    it 'includes all workers' do
+      workers = described_class.workers
-    context 'without except argument' do
+      expect(workers).to include(PostReceive)
-      it 'returns all queues defined on config/sidekiq_queues.yml file' do
+      expect(workers).to include(MergeWorker)
-        expected_queues = YAML.load_file(queues_file_path)[:queues].map { |queue, _| queue }
+    end
+    it 'includes EE workers' do
+      workers = described_class.workers
+      expect(workers).to include(RepositoryUpdateMirrorWorker)
+      expect(workers).to include(LdapGroupSyncWorker)
+    end
+  end
+  describe '.worker_queues' do
+    it 'includes all queues' do
+      queues = described_class.worker_queues
-        expect(described_class.queues).to eq(expected_queues)
+      expect(queues).to include('post_receive')
-      end
+      expect(queues).to include('merge')
+      expect(queues).to include('cronjob')
+      expect(queues).to include('mailers')
+      expect(queues).to include('default')
    end
-    context 'with except argument' do
+    it 'includes EE queues' do
-      it 'returns queues on config/sidekiq_queues.yml filtering out excluded ones' do
+      queues = described_class.worker_queues
-        expected_queues =
-          YAML.load_file(queues_file_path)[:queues].map { |queue, _| queue } - ['webhook']
-        expect(described_class.queues(except: ['webhook'])).to eq(expected_queues)
+      expect(queues).to include('repository_update_mirror')
-      end
+      expect(queues).to include('ldap_group_sync')
    end
  end
 end
--- a/spec/workers/concerns/dedicated_sidekiq_queue_spec.rb
+++ b/spec/workers/concerns/dedicated_sidekiq_queue_spec.rb
 require 'spec_helper'
-describe DedicatedSidekiqQueue do
+describe ApplicationWorker do
  let(:worker) do
    Class.new do
      def self.name
-        'Foo::Bar::DummyWorker'
+        'Gitlab::Foo::Bar::DummyWorker'
      end
-      include Sidekiq::Worker
+      include ApplicationWorker
-      include DedicatedSidekiqQueue
    end
  end
-  describe 'queue names' do
+  describe 'Sidekiq options' do
    it 'sets the queue name based on the class name' do
      expect(worker.sidekiq_options['queue']).to eq('foo_bar_dummy')
    end
  end
+  describe '.queue' do
+    it 'returns the queue name' do
+      worker.sidekiq_options queue: :some_queue
+      expect(worker.queue).to eq('some_queue')
+    end
+  end
 end
--- a/spec/workers/concerns/cluster_queue_spec.rb
+++ b/spec/workers/concerns/cluster_queue_spec.rb
@@ -3,7 +3,11 @@ require 'spec_helper'
 describe ClusterQueue do
  let(:worker) do
    Class.new do
-      include Sidekiq::Worker
+      def self.name
+        'DummyWorker'
+      end
+      include ApplicationWorker
      include ClusterQueue
    end
  end

--- a/spec/workers/concerns/cronjob_queue_spec.rb
+++ b/spec/workers/concerns/cronjob_queue_spec.rb
@@ -3,7 +3,11 @@ require 'spec_helper'
 describe CronjobQueue do
  let(:worker) do
    Class.new do
-      include Sidekiq::Worker
+      def self.name
+        'DummyWorker'
+      end
+      include ApplicationWorker
      include CronjobQueue
    end
  end

--- a/spec/workers/concerns/geo_queue_spec.rb
+++ b/spec/workers/concerns/geo_queue_spec.rb
@@ -3,7 +3,11 @@ require 'spec_helper'
 describe GeoQueue do
  let(:worker) do
    Class.new do
-      include Sidekiq::Worker
+      def self.name
+        'DummyWorker'
+      end
+      include ApplicationWorker
      include GeoQueue
    end
  end

--- a/spec/workers/concerns/gitlab/github_import/object_importer_spec.rb
+++ b/spec/workers/concerns/gitlab/github_import/object_importer_spec.rb
@@ -3,6 +3,10 @@ require 'spec_helper'
 describe Gitlab::GithubImport::ObjectImporter do
  let(:worker) do
    Class.new do
+      def self.name
+        'DummyWorker'
+      end
      include(Gitlab::GithubImport::ObjectImporter)
      def counter_name

--- a/spec/workers/concerns/gitlab/github_import/queue_spec.rb
+++ b/spec/workers/concerns/gitlab/github_import/queue_spec.rb
@@ -3,7 +3,11 @@ require 'spec_helper'
 describe Gitlab::GithubImport::Queue do
  it 'sets the Sidekiq options for the worker' do
    worker = Class.new do
-      include Sidekiq::Worker
+      def self.name
+        'DummyWorker'
+      end
+      include ApplicationWorker
      include Gitlab::GithubImport::Queue
    end

--- a/spec/workers/concerns/pipeline_queue_spec.rb
+++ b/spec/workers/concerns/pipeline_queue_spec.rb
@@ -3,7 +3,11 @@ require 'spec_helper'
 describe PipelineQueue do
  let(:worker) do
    Class.new do
-      include Sidekiq::Worker
+      def self.name
+        'DummyWorker'
+      end
+      include ApplicationWorker
      include PipelineQueue
    end
  end

--- a/spec/workers/concerns/repository_check_queue_spec.rb
+++ b/spec/workers/concerns/repository_check_queue_spec.rb
@@ -3,7 +3,11 @@ require 'spec_helper'
 describe RepositoryCheckQueue do
  let(:worker) do
    Class.new do
-      include Sidekiq::Worker
+      def self.name
+        'DummyWorker'
+      end
+      include ApplicationWorker
      include RepositoryCheckQueue
    end
  end

--- a/spec/workers/every_sidekiq_worker_spec.rb
+++ b/spec/workers/every_sidekiq_worker_spec.rb
 require 'spec_helper'
 describe 'Every Sidekiq worker' do
-  let(:workers) do
+  it 'includes ApplicationWorker' do
-    root = Rails.root.join('app', 'workers')
+    expect(Gitlab::SidekiqConfig.workers).to all(include(ApplicationWorker))
-    concerns = root.join('concerns').to_s
-    ee_modules = root.join('ee').to_s
-    workers = Dir[root.join('**', '*.rb')]
-      .reject { |path| path.start_with?(concerns, ee_modules) }
-    workers.map do |path|
-      ns = Pathname.new(path).relative_path_from(root).to_s.gsub('.rb', '')
-      ns.camelize.constantize
-    end
  end
  it 'does not use the default queue' do
-    workers.each do |worker|
+    expect(Gitlab::SidekiqConfig.workers.map(&:queue)).not_to include('default')
-      expect(worker.sidekiq_options['queue'].to_s).not_to eq('default')
-    end
  end
  it 'uses the cronjob queue when the worker runs as a cronjob' do
-    cron_workers = Settings.cron_jobs
+    expect(Gitlab::SidekiqConfig.cron_workers.map(&:queue)).to all(eq('cronjob'))
-      .map { |job_name, options| options['job_class'].constantize }
-      .to_set
-    workers.each do |worker|
-      next unless cron_workers.include?(worker)
-      expect(worker.sidekiq_options['queue'].to_s).to eq('cronjob')
-    end
  end
  it 'defines the queue in the Sidekiq configuration file' do
-    config = YAML.load_file(Rails.root.join('config', 'sidekiq_queues.yml').to_s)
+    config_queue_names = Gitlab::SidekiqConfig.config_queues.to_set
-    queue_names = config[:queues].map { |(queue, _)| queue }.to_set
-    workers.each do |worker|
+    expect(Gitlab::SidekiqConfig.worker_queues).to all(be_in(config_queue_names))
-      expect(queue_names).to include(worker.sidekiq_options['queue'].to_s)
-    end
  end
 end