Add latest changes from gitlab-org/gitlab@15-2-stable-eev15.2.0-rc42

35 files changed, 422 insertions, 220 deletions

diff --git a/app/workers/all_queues.yml b/app/workers/all_queues.yml
index ab75abff9ba..966a1202db2 100644
--- a/app/workers/all_queues.yml
+++ b/app/workers/all_queues.yml
@@ -219,6 +219,15 @@
   :weight: 1
   :idempotent: false
   :tags: []
+- :name: cronjob:ci_runners_reconcile_existing_runner_versions_cron
+  :worker_name: Ci::Runners::ReconcileExistingRunnerVersionsCronWorker
+  :feature_category: :runner_fleet
+  :has_external_dependencies: false
+  :urgency: :low
+  :resource_boundary: :unknown
+  :weight: 1
+  :idempotent: true
+  :tags: []
 - :name: cronjob:ci_schedule_delete_objects_cron
   :worker_name: Ci::ScheduleDeleteObjectsCronWorker
   :feature_category: :continuous_integration
@@ -948,15 +957,6 @@
   :weight: 1
   :idempotent: false
   :tags: []
-- :name: gcp_cluster:clusters_applications_activate_service
-  :worker_name: Clusters::Applications::ActivateServiceWorker
-  :feature_category: :kubernetes_management
-  :has_external_dependencies: false
-  :urgency: :low
-  :resource_boundary: :unknown
-  :weight: 1
-  :idempotent: false
-  :tags: []
 - :name: gcp_cluster:clusters_applications_deactivate_integration
   :worker_name: Clusters::Applications::DeactivateIntegrationWorker
   :feature_category: :kubernetes_management
@@ -966,15 +966,6 @@
   :weight: 1
   :idempotent: false
   :tags: []
-- :name: gcp_cluster:clusters_applications_deactivate_service
-  :worker_name: Clusters::Applications::DeactivateServiceWorker
-  :feature_category: :kubernetes_management
-  :has_external_dependencies: false
-  :urgency: :low
-  :resource_boundary: :unknown
-  :weight: 1
-  :idempotent: false
-  :tags: []
 - :name: gcp_cluster:clusters_applications_uninstall
   :worker_name: Clusters::Applications::UninstallWorker
   :feature_category: :kubernetes_management
@@ -1038,6 +1029,15 @@
   :weight: 1
   :idempotent: false
   :tags: []
+- :name: github_importer:github_import_import_issue_event
+  :worker_name: Gitlab::GithubImport::ImportIssueEventWorker
+  :feature_category: :importers
+  :has_external_dependencies: true
+  :urgency: :low
+  :resource_boundary: :unknown
+  :weight: 1
+  :idempotent: false
+  :tags: []
 - :name: github_importer:github_import_import_lfs_object
   :worker_name: Gitlab::GithubImport::ImportLfsObjectWorker
   :feature_category: :importers
@@ -1110,6 +1110,15 @@
   :weight: 1
   :idempotent: false
   :tags: []
+- :name: github_importer:github_import_stage_import_issue_events
+  :worker_name: Gitlab::GithubImport::Stage::ImportIssueEventsWorker
+  :feature_category: :importers
+  :has_external_dependencies: false
+  :urgency: :low
+  :resource_boundary: :unknown
+  :weight: 1
+  :idempotent: false
+  :tags: []
 - :name: github_importer:github_import_stage_import_issues_and_diff_notes
   :worker_name: Gitlab::GithubImport::Stage::ImportIssuesAndDiffNotesWorker
   :feature_category: :importers
@@ -1452,6 +1461,15 @@
   :weight: 1
   :idempotent: false
   :tags: []
+- :name: package_cleanup:packages_cleanup_execute_policy
+  :worker_name: Packages::Cleanup::ExecutePolicyWorker
+  :feature_category: :package_registry
+  :has_external_dependencies: false
+  :urgency: :low
+  :resource_boundary: :unknown
+  :weight: 1
+  :idempotent: true
+  :tags: []
 - :name: package_cleanup:packages_cleanup_package_file
   :worker_name: Packages::CleanupPackageFileWorker
   :feature_category: :package_registry
@@ -2344,6 +2362,15 @@
   :weight: 2
   :idempotent: false
   :tags: []
+- :name: google_cloud_create_cloudsql_instance
+  :worker_name: GoogleCloud::CreateCloudsqlInstanceWorker
+  :feature_category: :not_owned
+  :has_external_dependencies: false
+  :urgency: :low
+  :resource_boundary: :unknown
+  :weight: 1
+  :idempotent: true
+  :tags: []
 - :name: group_destroy
   :worker_name: GroupDestroyWorker
   :feature_category: :subgroups
@@ -2389,6 +2416,15 @@
   :weight: 2
   :idempotent: true
   :tags: []
+- :name: incident_management_close_incident
+  :worker_name: IncidentManagement::CloseIncidentWorker
+  :feature_category: :incident_management
+  :has_external_dependencies: true
+  :urgency: :low
+  :resource_boundary: :unknown
+  :weight: 1
+  :idempotent: true
+  :tags: []
 - :name: integrations_create_external_cross_reference
   :worker_name: Integrations::CreateExternalCrossReferenceWorker
   :feature_category: :integrations
@@ -2425,15 +2461,6 @@
   :weight: 2
   :idempotent: false
   :tags: []
-- :name: irker
-  :worker_name: IrkerWorker
-  :feature_category: :integrations
-  :has_external_dependencies: false
-  :urgency: :low
-  :resource_boundary: :unknown
-  :weight: 1
-  :idempotent: false
-  :tags: []
 - :name: issuable_export_csv
   :worker_name: IssuableExportCsvWorker
   :feature_category: :team_planning
@@ -2704,14 +2731,14 @@
   :weight: 1
   :idempotent: false
   :tags: []
-- :name: pages_transfer
-  :worker_name: PagesTransferWorker
+- :name: pages_invalidate_domain_cache
+  :worker_name: Pages::InvalidateDomainCacheWorker
   :feature_category: :pages
   :has_external_dependencies: false
   :urgency: :low
   :resource_boundary: :unknown
   :weight: 1
-  :idempotent: false
+  :idempotent: true
   :tags: []
 - :name: phabricator_import_import_tasks
   :worker_name: Gitlab::PhabricatorImport::ImportTasksWorker
@@ -2767,15 +2794,6 @@
   :weight: 1
   :idempotent: false
   :tags: []
-- :name: project_service
-  :worker_name: ProjectServiceWorker
-  :feature_category: :integrations
-  :has_external_dependencies: true
-  :urgency: :low
-  :resource_boundary: :unknown
-  :weight: 1
-  :idempotent: false
-  :tags: []
 - :name: projects_after_import
   :worker_name: Projects::AfterImportWorker
   :feature_category: :importers
@@ -3092,15 +3110,6 @@
   :weight: 1
   :idempotent: false
   :tags: []
-- :name: web_hooks_destroy
-  :worker_name: WebHooks::DestroyWorker
-  :feature_category: :integrations
-  :has_external_dependencies: false
-  :urgency: :high
-  :resource_boundary: :unknown
-  :weight: 1
-  :idempotent: true
-  :tags: []
 - :name: web_hooks_log_destroy
   :worker_name: WebHooks::LogDestroyWorker
   :feature_category: :integrations
diff --git a/app/workers/authorized_projects_worker.rb b/app/workers/authorized_projects_worker.rb
index afe14369d43..4312ba41367 100644
--- a/app/workers/authorized_projects_worker.rb
+++ b/app/workers/authorized_projects_worker.rb
@@ -14,17 +14,6 @@ class AuthorizedProjectsWorker
   idempotent!
   loggable_arguments 1 # For the job waiter key
 
-  # This is a workaround for a Ruby 2.3.7 bug. rspec-mocks cannot restore the
-  # visibility of prepended modules. See https://github.com/rspec/rspec-mocks/issues/1231
-  # for more details.
-  if Rails.env.test?
-    def self.bulk_perform_and_wait(args_list, timeout: 10)
-    end
-
-    def self.bulk_perform_inline(args_list)
-    end
-  end
-
   def perform(user_id)
     user = User.find_by_id(user_id)
 
diff --git a/app/workers/build_hooks_worker.rb b/app/workers/build_hooks_worker.rb
index 78244e0941e..5c08344bfe3 100644
--- a/app/workers/build_hooks_worker.rb
+++ b/app/workers/build_hooks_worker.rb
@@ -18,4 +18,16 @@ class BuildHooksWorker # rubocop:disable Scalability/IdempotentWorker
       .try(:execute_hooks)
   end
   # rubocop: enable CodeReuse/ActiveRecord
+
+  def self.perform_async(build)
+    Gitlab::AppLogger.info(
+      message: "Enqueuing hooks for Build #{build.id}: #{build.status}",
+      class: self.name,
+      build_id: build.id,
+      pipeline_id: build.pipeline_id,
+      project_id: build.project_id,
+      build_status: build.status)
+
+    super(build.id)
+  end
 end
diff --git a/app/workers/bulk_imports/pipeline_worker.rb b/app/workers/bulk_imports/pipeline_worker.rb
index 9c95e25e2e8..e171ec1e194 100644
--- a/app/workers/bulk_imports/pipeline_worker.rb
+++ b/app/workers/bulk_imports/pipeline_worker.rb
@@ -53,12 +53,8 @@ module BulkImports
       pipeline_tracker.update!(status_event: 'start', jid: jid)
       pipeline_tracker.pipeline_class.new(context).run
       pipeline_tracker.finish!
-    rescue BulkImports::NetworkError => e
-      if e.retriable?(pipeline_tracker)
-        retry_tracker(e)
-      else
-        fail_tracker(e)
-      end
+    rescue BulkImports::RetryPipelineError => e
+      retry_tracker(e)
     rescue StandardError => e
       fail_tracker(e)
     end
diff --git a/app/workers/ci/archive_trace_worker.rb b/app/workers/ci/archive_trace_worker.rb
index 47d77c15b4a..edbaf0536a2 100644
--- a/app/workers/ci/archive_trace_worker.rb
+++ b/app/workers/ci/archive_trace_worker.rb
@@ -4,17 +4,13 @@ module Ci
   class ArchiveTraceWorker # rubocop:disable Scalability/IdempotentWorker
     include ApplicationWorker
 
-    data_consistency :sticky, feature_flag: :sticky_ci_archive_trace_worker
+    data_consistency :sticky
 
     sidekiq_options retry: 3
     include PipelineBackgroundQueue
 
     def perform(job_id)
-      archivable_jobs = Ci::Build.without_archived_trace
-
-      if Feature.enabled?(:sticky_ci_archive_trace_worker)
-        archivable_jobs = archivable_jobs.eager_load_for_archiving_trace
-      end
+      archivable_jobs = Ci::Build.without_archived_trace.eager_load_for_archiving_trace
 
       archivable_jobs.find_by_id(job_id).try do |job|
         Ci::ArchiveTraceService.new.execute(job, worker_name: self.class.name)
diff --git a/app/workers/ci/build_finished_worker.rb b/app/workers/ci/build_finished_worker.rb
index 2d7f3a67004..25c7637a79f 100644
--- a/app/workers/ci/build_finished_worker.rb
+++ b/app/workers/ci/build_finished_worker.rb
@@ -37,9 +37,10 @@ module Ci
       Ci::BuildReportResultService.new.execute(build)
 
       # We execute these async as these are independent operations.
-      BuildHooksWorker.perform_async(build.id)
+      BuildHooksWorker.perform_async(build)
       ChatNotificationWorker.perform_async(build.id) if build.pipeline.chat?
       build.track_deployment_usage
+      build.track_verify_usage
 
       if build.failed? && !build.auto_retry_expected?
         ::Ci::MergeRequests::AddTodoWhenBuildFailsWorker.perform_async(build.id)
@@ -57,15 +58,7 @@ module Ci
       # See https://gitlab.com/gitlab-org/gitlab/-/issues/267112 for more
       # details.
       #
-      archive_trace_worker_class(build).perform_in(ARCHIVE_TRACES_IN, build.id)
-    end
-
-    def archive_trace_worker_class(build)
-      if Feature.enabled?(:ci_build_finished_worker_namespace_changed, build.project)
-        Ci::ArchiveTraceWorker
-      else
-        ::ArchiveTraceWorker
-      end
+      Ci::ArchiveTraceWorker.perform_in(ARCHIVE_TRACES_IN, build.id)
     end
   end
 end
diff --git a/app/workers/ci/pipeline_artifacts/coverage_report_worker.rb b/app/workers/ci/pipeline_artifacts/coverage_report_worker.rb
index 8ee518e3ae6..127eb3b6f44 100644
--- a/app/workers/ci/pipeline_artifacts/coverage_report_worker.rb
+++ b/app/workers/ci/pipeline_artifacts/coverage_report_worker.rb
@@ -15,8 +15,14 @@ module Ci
       idempotent!
 
       def perform(pipeline_id)
-        Ci::Pipeline.find_by_id(pipeline_id).try do |pipeline|
-          Ci::PipelineArtifacts::CoverageReportService.new(pipeline).execute
+        pipeline = Ci::Pipeline.find_by_id(pipeline_id)
+
+        return unless pipeline
+
+        pipeline.root_ancestor.try do |root_ancestor_pipeline|
+          next unless root_ancestor_pipeline.self_and_descendants_complete?
+
+          Ci::PipelineArtifacts::CoverageReportService.new(root_ancestor_pipeline).execute
         end
       end
     end
diff --git a/app/workers/ci/runners/reconcile_existing_runner_versions_cron_worker.rb b/app/workers/ci/runners/reconcile_existing_runner_versions_cron_worker.rb
new file mode 100644
index 00000000000..035b2563e56
--- /dev/null
+++ b/app/workers/ci/runners/reconcile_existing_runner_versions_cron_worker.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Ci
+  module Runners
+    class ReconcileExistingRunnerVersionsCronWorker
+      include ApplicationWorker
+
+      # This worker does not schedule other workers that require context.
+      include CronjobQueue # rubocop:disable Scalability/CronWorkerContext
+
+      data_consistency :sticky
+      feature_category :runner_fleet
+      urgency :low
+
+      idempotent!
+
+      def perform
+        result = ::Ci::Runners::ReconcileExistingRunnerVersionsService.new.execute
+        result.each { |key, value| log_extra_metadata_on_done(key, value) }
+      end
+    end
+  end
+end
diff --git a/app/workers/clusters/applications/activate_service_worker.rb b/app/workers/clusters/applications/activate_service_worker.rb
deleted file mode 100644
index abc84bcd093..00000000000
--- a/app/workers/clusters/applications/activate_service_worker.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-# This worker was renamed in 15.1, we can delete it in 15.2.
-# See: https://gitlab.com/gitlab-org/gitlab/-/issues/364112
-#
-# rubocop:disable Scalability/IdempotentWorker
-module Clusters
-  module Applications
-    class ActivateServiceWorker < ActivateIntegrationWorker
-    end
-  end
-end
diff --git a/app/workers/clusters/applications/deactivate_service_worker.rb b/app/workers/clusters/applications/deactivate_service_worker.rb
deleted file mode 100644
index 88219b8b17e..00000000000
--- a/app/workers/clusters/applications/deactivate_service_worker.rb
+++ /dev/null
@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-# This worker was renamed in 15.1, we can delete it in 15.2.
-# See: https://gitlab.com/gitlab-org/gitlab/-/issues/364112
-#
-# rubocop:disable Scalability/IdempotentWorker
-module Clusters
-  module Applications
-    class DeactivateServiceWorker < DeactivateIntegrationWorker
-    end
-  end
-end
diff --git a/app/workers/concerns/gitlab/github_import/object_importer.rb b/app/workers/concerns/gitlab/github_import/object_importer.rb
index e1f404b250d..c2cd50d8c21 100644
--- a/app/workers/concerns/gitlab/github_import/object_importer.rb
+++ b/app/workers/concerns/gitlab/github_import/object_importer.rb
@@ -23,6 +23,12 @@ module Gitlab
       # client - An instance of `Gitlab::GithubImport::Client`
       # hash - A Hash containing the details of the object to import.
       def import(project, client, hash)
+        if project.import_state&.canceled?
+          info(project.id, message: 'project import canceled')
+
+          return
+        end
+
         object = representation_class.from_json_hash(hash)
 
         # To better express in the logs what object is being imported.
diff --git a/app/workers/concerns/gitlab/github_import/stage_methods.rb b/app/workers/concerns/gitlab/github_import/stage_methods.rb
index 225716f6bf3..b12c2311ea8 100644
--- a/app/workers/concerns/gitlab/github_import/stage_methods.rb
+++ b/app/workers/concerns/gitlab/github_import/stage_methods.rb
@@ -9,6 +9,12 @@ module Gitlab
 
         return unless (project = find_project(project_id))
 
+        if project.import_state&.canceled?
+          info(project_id, message: 'project import canceled')
+
+          return
+        end
+
         client = GithubImport.new_client_for(project)
 
         try_import(client, project)
diff --git a/app/workers/concerns/packages/cleanup_artifact_worker.rb b/app/workers/concerns/packages/cleanup_artifact_worker.rb
index a01d7e8abba..7e647ddd229 100644
--- a/app/workers/concerns/packages/cleanup_artifact_worker.rb
+++ b/app/workers/concerns/packages/cleanup_artifact_worker.rb
@@ -9,14 +9,21 @@ module Packages
     def perform_work
       return unless artifact
 
-      artifact.transaction do
-        log_metadata(artifact)
+      begin
+        artifact.transaction do
+          log_metadata(artifact)
 
-        artifact.destroy!
-      rescue StandardError
+          artifact.destroy!
+        end
+      rescue StandardError => exception
         unless artifact&.destroyed?
           artifact&.update_column(:status, :error)
         end
+
+        Gitlab::ErrorTracking.log_exception(
+          exception,
+          class: self.class.name
+        )
       end
 
       after_destroy
diff --git a/app/workers/concerns/waitable_worker.rb b/app/workers/concerns/waitable_worker.rb
index f8b945b8892..336d60d46ac 100644
--- a/app/workers/concerns/waitable_worker.rb
+++ b/app/workers/concerns/waitable_worker.rb
@@ -5,25 +5,13 @@ module WaitableWorker
 
   class_methods do
     # Schedules multiple jobs and waits for them to be completed.
-    def bulk_perform_and_wait(args_list, timeout: 10)
+    def bulk_perform_and_wait(args_list)
       # Short-circuit: it's more efficient to do small numbers of jobs inline
-      return bulk_perform_inline(args_list) if args_list.size <= 3
-
-      # Don't wait if there's too many jobs to be waited for. Not including the
-      # waiter allows them to be deduplicated and it skips waiting for jobs that
-      # are not likely to finish within the timeout. This assumes we can process
-      # 10 jobs per second:
-      # https://gitlab.com/gitlab-com/gl-infra/scalability/-/issues/205
-      return bulk_perform_async(args_list) if args_list.length >= 10 * timeout
-
-      waiter = Gitlab::JobWaiter.new(args_list.size, worker_label: self.to_s)
-
-      # Point all the bulk jobs at the same JobWaiter. Converts, [[1], [2], [3]]
-      # into [[1, "key"], [2, "key"], [3, "key"]]
-      waiting_args_list = args_list.map { |args| [*args, waiter.key] }
-      bulk_perform_async(waiting_args_list)
+      if args_list.size == 1
+        return bulk_perform_inline(args_list)
+      end
 
-      waiter.wait(timeout)
+      bulk_perform_async(args_list)
     end
 
     # Performs multiple jobs directly. Failed jobs will be put into sidekiq so
diff --git a/app/workers/container_registry/migration/enqueuer_worker.rb b/app/workers/container_registry/migration/enqueuer_worker.rb
index f3c8dfa63ad..1dd29eff86e 100644
--- a/app/workers/container_registry/migration/enqueuer_worker.rb
+++ b/app/workers/container_registry/migration/enqueuer_worker.rb
@@ -125,17 +125,18 @@ module ContainerRegistry
 
       def next_repository
         strong_memoize(:next_repository) do
-          # Using .limit(2)[0] instead of take here. Using a LIMIT 1 caused the query planner to
-          # use an inefficient sequential scan instead of picking an index. LIMIT 2 works around
+          # Using .limit(25)[0] instead of take here. Using a LIMIT 1 and 2 caused the query planner to
+          # use an inefficient sequential scan instead of picking an index. LIMIT 25 works around
           # this issue.
-          # See https://gitlab.com/gitlab-org/gitlab/-/merge_requests/87733 for details.
-          ContainerRepository.ready_for_import.limit(2)[0] # rubocop:disable CodeReuse/ActiveRecord
+          # See https://gitlab.com/gitlab-org/gitlab/-/merge_requests/87733 and
+          # https://gitlab.com/gitlab-org/gitlab/-/merge_requests/90735 for details.
+          ContainerRepository.ready_for_import.limit(25)[0] # rubocop:disable CodeReuse/ActiveRecord
         end
       end
 
       def next_aborted_repository
         strong_memoize(:next_aborted_repository) do
-          ContainerRepository.with_migration_state('import_aborted').limit(2)[0] # rubocop:disable CodeReuse/ActiveRecord
+          ContainerRepository.with_migration_state('import_aborted').limit(25)[0] # rubocop:disable CodeReuse/ActiveRecord
         end
       end
 
diff --git a/app/workers/deployments/hooks_worker.rb b/app/workers/deployments/hooks_worker.rb
index 608601b4eb9..62e75638c7d 100644
--- a/app/workers/deployments/hooks_worker.rb
+++ b/app/workers/deployments/hooks_worker.rb
@@ -16,7 +16,7 @@ module Deployments
         log_extra_metadata_on_done(:deployment_project_id, deploy.project.id)
         log_extra_metadata_on_done(:deployment_id, params[:deployment_id])
 
-        deploy.execute_hooks(params[:status_changed_at].to_time)
+        deploy.execute_hooks(params[:status], params[:status_changed_at].to_time)
       end
     end
   end
diff --git a/app/workers/gitlab/github_import/advance_stage_worker.rb b/app/workers/gitlab/github_import/advance_stage_worker.rb
index 06f0ef623c2..70d18d8004c 100644
--- a/app/workers/gitlab/github_import/advance_stage_worker.rb
+++ b/app/workers/gitlab/github_import/advance_stage_worker.rb
@@ -23,6 +23,7 @@ module Gitlab
         pull_requests_merged_by: Stage::ImportPullRequestsMergedByWorker,
         pull_request_reviews: Stage::ImportPullRequestsReviewsWorker,
         issues_and_diff_notes: Stage::ImportIssuesAndDiffNotesWorker,
+        issue_events: Stage::ImportIssueEventsWorker,
         notes: Stage::ImportNotesWorker,
         lfs_objects: Stage::ImportLfsObjectsWorker,
         finish: Stage::FinishImportWorker
diff --git a/app/workers/gitlab/github_import/import_issue_event_worker.rb b/app/workers/gitlab/github_import/import_issue_event_worker.rb
new file mode 100644
index 00000000000..d7071d3ee09
--- /dev/null
+++ b/app/workers/gitlab/github_import/import_issue_event_worker.rb
@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module GithubImport
+    class ImportIssueEventWorker # rubocop:disable Scalability/IdempotentWorker
+      include ObjectImporter
+
+      def representation_class
+        Representation::IssueEvent
+      end
+
+      def importer_class
+        Importer::IssueEventImporter
+      end
+
+      def object_type
+        :issue_event
+      end
+    end
+  end
+end
diff --git a/app/workers/gitlab/github_import/stage/import_issue_events_worker.rb b/app/workers/gitlab/github_import/stage/import_issue_events_worker.rb
new file mode 100644
index 00000000000..8155b910677
--- /dev/null
+++ b/app/workers/gitlab/github_import/stage/import_issue_events_worker.rb
@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Gitlab
+  module GithubImport
+    module Stage
+      class ImportIssueEventsWorker # rubocop:disable Scalability/IdempotentWorker
+        include ApplicationWorker
+
+        data_consistency :always
+
+        sidekiq_options retry: 3
+        include GithubImport::Queue
+        include StageMethods
+
+        # client - An instance of Gitlab::GithubImport::Client.
+        # project - An instance of Project.
+        def import(client, project)
+          importer = ::Gitlab::GithubImport::Importer::SingleEndpointIssueEventsImporter
+          return skip_to_next_stage(project, importer) if feature_disabled?(project)
+
+          start_importer(project, importer, client)
+        end
+
+        private
+
+        def start_importer(project, importer, client)
+          info(project.id, message: "starting importer", importer: importer.name)
+          waiter = importer.new(project, client).execute
+          move_to_next_stage(project, waiter.key => waiter.jobs_remaining)
+        end
+
+        def skip_to_next_stage(project, importer)
+          info(project.id, message: "skipping importer", importer: importer.name)
+          move_to_next_stage(project)
+        end
+
+        def move_to_next_stage(project, waiters = {})
+          AdvanceStageWorker.perform_async(project.id, waiters, :notes)
+        end
+
+        def feature_disabled?(project)
+          Feature.disabled?(:github_importer_issue_events_import, project.group, type: :ops)
+        end
+      end
+    end
+  end
+end
diff --git 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
index 34996b710d4..7922c1113c4 100644
--- 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
@@ -21,7 +21,7 @@ module Gitlab
             hash[waiter.key] = waiter.jobs_remaining
           end
 
-          AdvanceStageWorker.perform_async(project.id, waiters, :notes)
+          AdvanceStageWorker.perform_async(project.id, waiters, :issue_events)
         end
 
         # The importers to run in this stage. Issues can't be imported earlier
diff --git a/app/workers/gitlab_service_ping_worker.rb b/app/workers/gitlab_service_ping_worker.rb
index 0f7b3ba56a5..a974667e5e0 100644
--- a/app/workers/gitlab_service_ping_worker.rb
+++ b/app/workers/gitlab_service_ping_worker.rb
@@ -30,8 +30,6 @@ class GitlabServicePingWorker # rubocop:disable Scalability/IdempotentWorker
   end
 
   def usage_data
-    return unless Feature.enabled?(:prerecord_service_ping_data)
-
     ServicePing::BuildPayload.new.execute.tap do |payload|
       record = {
         recorded_at: payload[:recorded_at],
diff --git a/app/workers/google_cloud/create_cloudsql_instance_worker.rb b/app/workers/google_cloud/create_cloudsql_instance_worker.rb
new file mode 100644
index 00000000000..3c15c59b8d9
--- /dev/null
+++ b/app/workers/google_cloud/create_cloudsql_instance_worker.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module GoogleCloud
+  class CreateCloudsqlInstanceWorker
+    include ApplicationWorker
+
+    data_consistency :always
+    feature_category :not_owned # rubocop:disable Gitlab/AvoidFeatureCategoryNotOwned
+    idempotent!
+
+    def perform(user_id, project_id, options = {})
+      user = User.find(user_id)
+      project = Project.find(project_id)
+
+      google_oauth2_token = options[:google_oauth2_token]
+      gcp_project_id = options[:gcp_project_id]
+      instance_name = options[:instance_name]
+      database_version = options[:database_version]
+      environment_name = options[:environment_name]
+      is_protected = options[:is_protected]
+
+      params = {
+        google_oauth2_token: google_oauth2_token,
+        gcp_project_id: gcp_project_id,
+        instance_name: instance_name,
+        database_version: database_version,
+        environment_name: environment_name,
+        is_protected: is_protected
+      }
+
+      response = GoogleCloud::SetupCloudsqlInstanceService.new(project, user, params).execute
+
+      if response[:status] == :error
+        raise response[:message]
+      end
+    end
+  end
+end
diff --git a/app/workers/incident_management/close_incident_worker.rb b/app/workers/incident_management/close_incident_worker.rb
new file mode 100644
index 00000000000..7d45a6785ea
--- /dev/null
+++ b/app/workers/incident_management/close_incident_worker.rb
@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module IncidentManagement
+  class CloseIncidentWorker
+    include ApplicationWorker
+
+    idempotent!
+    deduplicate :until_executed
+    data_consistency :always
+    feature_category :incident_management
+    urgency :low
+
+    # Issues:CloseService execute webhooks which are treated as external dependencies
+    worker_has_external_dependencies!
+
+    def perform(issue_id)
+      incident = Issue.incident.opened.find_by_id(issue_id)
+
+      return unless incident
+
+      close_incident(incident)
+      add_system_note(incident)
+    end
+
+    private
+
+    def user
+      @user ||= User.alert_bot
+    end
+
+    def close_incident(incident)
+      ::Issues::CloseService
+        .new(project: incident.project, current_user: user)
+        .execute(incident, system_note: false)
+    end
+
+    def add_system_note(incident)
+      return unless incident.reset.closed?
+
+      SystemNoteService.auto_resolve_prometheus_alert(incident, incident.project, user)
+    end
+  end
+end
diff --git a/app/workers/irker_worker.rb b/app/workers/irker_worker.rb
deleted file mode 100644
index a054021e418..00000000000
--- a/app/workers/irker_worker.rb
+++ /dev/null
@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-# This worker was renamed in 15.1, we can delete it in 15.2.
-# See: https://gitlab.com/gitlab-org/gitlab/-/issues/364112
-#
-# rubocop: disable Gitlab/NamespacedClass
-# rubocop:disable Scalability/IdempotentWorker
-class IrkerWorker < Integrations::IrkerWorker
-end
diff --git a/app/workers/loose_foreign_keys/cleanup_worker.rb b/app/workers/loose_foreign_keys/cleanup_worker.rb
index 0d04c503fbf..0a3a834578a 100644
--- a/app/workers/loose_foreign_keys/cleanup_worker.rb
+++ b/app/workers/loose_foreign_keys/cleanup_worker.rb
@@ -34,7 +34,7 @@ module LooseForeignKeys
     # If two DBs are configured (Main, CI): minute 1 -> Main, minute 2 -> CI
     def current_connection_name_and_base_model
       minutes_since_epoch = Time.current.to_i / 60
-      connections_with_name = Gitlab::Database.database_base_models.to_a # this will never be empty
+      connections_with_name = Gitlab::Database.database_base_models_with_gitlab_shared.to_a # this will never be empty
       connections_with_name[minutes_since_epoch % connections_with_name.count]
     end
   end
diff --git a/app/workers/packages/cleanup/execute_policy_worker.rb b/app/workers/packages/cleanup/execute_policy_worker.rb
new file mode 100644
index 00000000000..59f0f0250c8
--- /dev/null
+++ b/app/workers/packages/cleanup/execute_policy_worker.rb
@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Packages
+  module Cleanup
+    class ExecutePolicyWorker
+      include ApplicationWorker
+      include LimitedCapacity::Worker
+      include Gitlab::Utils::StrongMemoize
+
+      data_consistency :always
+      queue_namespace :package_cleanup
+      feature_category :package_registry
+      urgency :low
+      worker_resource_boundary :unknown
+      idempotent!
+
+      COUNTS_KEYS = %i[
+        marked_package_files_total_count
+        unique_package_id_and_file_name_total_count
+      ].freeze
+
+      def perform_work
+        return unless next_policy
+
+        log_extra_metadata_on_done(:project_id, next_policy.project_id)
+        result = ::Packages::Cleanup::ExecutePolicyService.new(next_policy).execute
+
+        if result.success?
+          timeout = !!result.payload[:timeout]
+          counts = result.payload[:counts]
+          log_extra_metadata_on_done(:execution_timeout, timeout)
+          COUNTS_KEYS.each do |count_key|
+            log_extra_metadata_on_done(count_key, counts[count_key])
+          end
+        end
+      end
+
+      def remaining_work_count
+        ::Packages::Cleanup::Policy.runnable
+                                   .limit(max_running_jobs + 1)
+                                   .count
+      end
+
+      def max_running_jobs
+        ::Gitlab::CurrentSettings.package_registry_cleanup_policies_worker_capacity
+      end
+
+      private
+
+      def next_policy
+        strong_memoize(:next_policy) do
+          ::Packages::Cleanup::Policy.transaction do
+            # the #lock call is specific to this worker
+            # rubocop: disable CodeReuse/ActiveRecord
+            policy = ::Packages::Cleanup::Policy.runnable
+                                                .limit(1)
+                                                .lock('FOR UPDATE SKIP LOCKED')
+                                                .first
+            # rubocop: enable CodeReuse/ActiveRecord
+
+            next nil unless policy
+
+            policy.set_next_run_at
+            policy.save!
+
+            policy
+          end
+        end
+      end
+    end
+  end
+end
diff --git a/app/workers/packages/cleanup_package_registry_worker.rb b/app/workers/packages/cleanup_package_registry_worker.rb
index a849e055b64..5f14102b5a1 100644
--- a/app/workers/packages/cleanup_package_registry_worker.rb
+++ b/app/workers/packages/cleanup_package_registry_worker.rb
@@ -12,6 +12,7 @@ module Packages
 
     def perform
       enqueue_package_file_cleanup_job if Packages::PackageFile.pending_destruction.exists?
+      enqueue_cleanup_policy_jobs if Packages::Cleanup::Policy.runnable.exists?
 
       log_counts
     end
@@ -22,6 +23,10 @@ module Packages
       Packages::CleanupPackageFileWorker.perform_with_capacity
     end
 
+    def enqueue_cleanup_policy_jobs
+      Packages::Cleanup::ExecutePolicyWorker.perform_with_capacity
+    end
+
     def log_counts
       use_replica_if_available do
         pending_destruction_package_files_count = Packages::PackageFile.pending_destruction.count
@@ -31,6 +36,9 @@ module Packages
         log_extra_metadata_on_done(:pending_destruction_package_files_count, pending_destruction_package_files_count)
         log_extra_metadata_on_done(:processing_package_files_count, processing_package_files_count)
         log_extra_metadata_on_done(:error_package_files_count, error_package_files_count)
+
+        pending_cleanup_policies_count = Packages::Cleanup::Policy.runnable.count
+        log_extra_metadata_on_done(:pending_cleanup_policies_count, pending_cleanup_policies_count)
       end
     end
 
diff --git a/app/workers/packages/debian/generate_distribution_worker.rb b/app/workers/packages/debian/generate_distribution_worker.rb
index 1eff3ea02dd..822fe5a1517 100644
--- a/app/workers/packages/debian/generate_distribution_worker.rb
+++ b/app/workers/packages/debian/generate_distribution_worker.rb
@@ -4,6 +4,7 @@ module Packages
   module Debian
     class GenerateDistributionWorker
       include ApplicationWorker
+      include ::Packages::FIPS
 
       data_consistency :always
       include Gitlab::Utils::StrongMemoize
@@ -20,6 +21,8 @@ module Packages
       loggable_arguments 0
 
       def perform(container_type, distribution_id)
+        raise DisabledError, 'Debian registry is not FIPS compliant' if Gitlab::FIPS.enabled?
+
         @container_type = container_type
         @distribution_id = distribution_id
 
diff --git a/app/workers/packages/debian/process_changes_worker.rb b/app/workers/packages/debian/process_changes_worker.rb
index 0a716c61203..d477a6f2e1f 100644
--- a/app/workers/packages/debian/process_changes_worker.rb
+++ b/app/workers/packages/debian/process_changes_worker.rb
@@ -4,6 +4,7 @@ module Packages
   module Debian
     class ProcessChangesWorker
       include ApplicationWorker
+      include ::Packages::FIPS
 
       data_consistency :always
       include Gitlab::Utils::StrongMemoize
@@ -15,6 +16,8 @@ module Packages
       feature_category :package_registry
 
       def perform(package_file_id, user_id)
+        raise DisabledError, 'Debian registry is not FIPS compliant' if Gitlab::FIPS.enabled?
+
         @package_file_id = package_file_id
         @user_id = user_id
 
@@ -22,6 +25,8 @@ module Packages
 
         ::Packages::Debian::ProcessChangesService.new(package_file, user).execute
       rescue StandardError => e
+        raise if e.instance_of?(DisabledError)
+
         Gitlab::ErrorTracking.log_exception(e, package_file_id: @package_file_id, user_id: @user_id)
         package_file.destroy!
       end
diff --git a/app/workers/pages/invalidate_domain_cache_worker.rb b/app/workers/pages/invalidate_domain_cache_worker.rb
new file mode 100644
index 00000000000..63b6f5c05b5
--- /dev/null
+++ b/app/workers/pages/invalidate_domain_cache_worker.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pages
+  class InvalidateDomainCacheWorker
+    include Gitlab::EventStore::Subscriber
+
+    idempotent!
+
+    feature_category :pages
+
+    def handle_event(event)
+      if event.data[:project_id]
+        ::Gitlab::Pages::CacheControl
+          .for_project(event.data[:project_id])
+          .clear_cache
+      end
+
+      if event.data[:root_namespace_id]
+        ::Gitlab::Pages::CacheControl
+          .for_namespace(event.data[:root_namespace_id])
+          .clear_cache
+      end
+    end
+  end
+end
diff --git a/app/workers/pages_transfer_worker.rb b/app/workers/pages_transfer_worker.rb
deleted file mode 100644
index 6d3918e7ab6..00000000000
--- a/app/workers/pages_transfer_worker.rb
+++ /dev/null
@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-class PagesTransferWorker # rubocop:disable Scalability/IdempotentWorker
-  include ApplicationWorker
-
-  data_consistency :always
-
-  sidekiq_options retry: 3
-
-  TransferFailedError = Class.new(StandardError)
-
-  feature_category :pages
-  loggable_arguments 0, 1
-
-  def perform(method, args)
-    # noop
-    # This worker is not necessary anymore and will be removed
-    # https://gitlab.com/gitlab-org/gitlab/-/issues/340616
-  end
-end
diff --git a/app/workers/post_receive.rb b/app/workers/post_receive.rb
index 45af15216fc..68a0934e2b7 100644
--- a/app/workers/post_receive.rb
+++ b/app/workers/post_receive.rb
@@ -131,11 +131,24 @@ class PostReceive
     repository_update_hook_data = Gitlab::DataBuilder::Repository.update(project, user, changes, refs)
     SystemHooksService.new.execute_hooks(repository_update_hook_data, :repository_update_hooks)
     Gitlab::UsageDataCounters::SourceCodeCounter.count(:pushes)
+    emit_snowplow_event(project, user)
   end
 
   def log(message)
     Gitlab::GitLogger.error("POST-RECEIVE: #{message}")
   end
+
+  def emit_snowplow_event(project, user)
+    return unless Feature.enabled?(:route_hll_to_snowplow_phase2, project.namespace)
+
+    Gitlab::Tracking.event(
+      'PostReceive',
+      'source_code_pushes',
+      project: project,
+      namespace: project.namespace,
+      user: user
+    )
+  end
 end
 
 PostReceive.prepend_mod_with('PostReceive')
diff --git a/app/workers/project_service_worker.rb b/app/workers/project_service_worker.rb
deleted file mode 100644
index 56ac4bc046a..00000000000
--- a/app/workers/project_service_worker.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-# This worker was renamed in 15.1, we can delete it in 15.2.
-# See: https://gitlab.com/gitlab-org/gitlab/-/issues/364112
-#
-# rubocop: disable Gitlab/NamespacedClass
-# rubocop: disable Scalability/IdempotentWorker
-class ProjectServiceWorker < Integrations::ExecuteWorker
-  data_consistency :always
-  sidekiq_options retry: 3
-  sidekiq_options dead: false
-  feature_category :integrations
-  urgency :low
-
-  worker_has_external_dependencies!
-end
diff --git a/app/workers/projects/refresh_build_artifacts_size_statistics_worker.rb b/app/workers/projects/refresh_build_artifacts_size_statistics_worker.rb
index a91af72cc2c..705bf0534f7 100644
--- a/app/workers/projects/refresh_build_artifacts_size_statistics_worker.rb
+++ b/app/workers/projects/refresh_build_artifacts_size_statistics_worker.rb
@@ -5,10 +5,6 @@ module Projects
     include ApplicationWorker
     include LimitedCapacity::Worker
 
-    MAX_RUNNING_LOW = 2
-    MAX_RUNNING_MEDIUM = 20
-    MAX_RUNNING_HIGH = 50
-
     data_consistency :always
 
     feature_category :build_artifacts
@@ -37,12 +33,8 @@ module Projects
     end
 
     def max_running_jobs
-      if ::Feature.enabled?(:projects_build_artifacts_size_refresh_high)
-        MAX_RUNNING_HIGH
-      elsif ::Feature.enabled?(:projects_build_artifacts_size_refresh_medium)
-        MAX_RUNNING_MEDIUM
-      elsif ::Feature.enabled?(:projects_build_artifacts_size_refresh_low)
-        MAX_RUNNING_LOW
+      if ::Feature.enabled?(:projects_build_artifacts_size_refresh, type: :ops)
+        10
       else
         0
       end
diff --git a/app/workers/web_hooks/destroy_worker.rb b/app/workers/web_hooks/destroy_worker.rb
deleted file mode 100644
index 8f9b194f88a..00000000000
--- a/app/workers/web_hooks/destroy_worker.rb
+++ /dev/null
@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module WebHooks
-  class DestroyWorker
-    include ApplicationWorker
-
-    DestroyError = Class.new(StandardError)
-
-    data_consistency :always
-    sidekiq_options retry: 3
-    feature_category :integrations
-    urgency :high
-
-    idempotent!
-
-    def perform(user_id, web_hook_id)
-      user = User.find_by_id(user_id)
-      hook = WebHook.find_by_id(web_hook_id)
-
-      return unless user && hook
-
-      result = ::WebHooks::DestroyService.new(user).sync_destroy(hook)
-
-      result.track_and_raise_exception(as: DestroyError, web_hook_id: hook.id)
-    end
-  end
-end