Add `ApplicationWorker` base class for workers

2024-03-25 11:44:39 -04:00 · 2024-03-25 11:44:39 -04:00 · a0bcfa0f64
parent d9eee9bf9a
commit a0bcfa0f64
86 changed files with 94 additions and 225 deletions
--- a/app/workers/account_deletion_worker.rb
+++ b/app/workers/account_deletion_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class AccountDeletionWorker
-  include Sidekiq::Worker
-
+class AccountDeletionWorker < ApplicationWorker
  sidekiq_options queue: 'pull', lock: :until_executed, lock_ttl: 1.week.to_i

  def perform(account_id, options = {})
--- a/app/workers/account_merging_worker.rb
+++ b/app/workers/account_merging_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class AccountMergingWorker
-  include Sidekiq::Worker
-
+class AccountMergingWorker < ApplicationWorker
  sidekiq_options queue: 'pull'

  def perform(account_id)
--- a/app/workers/account_refresh_worker.rb
+++ b/app/workers/account_refresh_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class AccountRefreshWorker
-  include Sidekiq::Worker
-
+class AccountRefreshWorker < ApplicationWorker
  sidekiq_options queue: 'pull', retry: 3, dead: false, lock: :until_executed, lock_ttl: 1.day.to_i

  def perform(account_id)
--- a/app/workers/activitypub/delivery_worker.rb
+++ b/app/workers/activitypub/delivery_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class ActivityPub::DeliveryWorker
-  include Sidekiq::Worker
+class ActivityPub::DeliveryWorker < ApplicationWorker
  include RoutingHelper
  include JsonLdHelper

--- a/app/workers/activitypub/distribute_poll_update_worker.rb
+++ b/app/workers/activitypub/distribute_poll_update_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class ActivityPub::DistributePollUpdateWorker
-  include Sidekiq::Worker
+class ActivityPub::DistributePollUpdateWorker < ApplicationWorker
  include Payloadable

  sidekiq_options queue: 'push', lock: :until_executed, retry: 0
--- a/app/workers/activitypub/fetch_replies_worker.rb
+++ b/app/workers/activitypub/fetch_replies_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class ActivityPub::FetchRepliesWorker
-  include Sidekiq::Worker
+class ActivityPub::FetchRepliesWorker < ApplicationWorker
  include ExponentialBackoff

  sidekiq_options queue: 'pull', retry: 3
--- a/app/workers/activitypub/followers_synchronization_worker.rb
+++ b/app/workers/activitypub/followers_synchronization_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class ActivityPub::FollowersSynchronizationWorker
-  include Sidekiq::Worker
-
+class ActivityPub::FollowersSynchronizationWorker < ApplicationWorker
  sidekiq_options queue: 'push', lock: :until_executed

  def perform(account_id, url)
--- a/app/workers/activitypub/move_distribution_worker.rb
+++ b/app/workers/activitypub/move_distribution_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class ActivityPub::MoveDistributionWorker
-  include Sidekiq::Worker
+class ActivityPub::MoveDistributionWorker < ApplicationWorker
  include Payloadable

  sidekiq_options queue: 'push'
--- a/app/workers/activitypub/post_upgrade_worker.rb
+++ b/app/workers/activitypub/post_upgrade_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class ActivityPub::PostUpgradeWorker
-  include Sidekiq::Worker
-
+class ActivityPub::PostUpgradeWorker < ApplicationWorker
  sidekiq_options queue: 'pull'

  def perform(domain)
--- a/app/workers/activitypub/processing_worker.rb
+++ b/app/workers/activitypub/processing_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class ActivityPub::ProcessingWorker
-  include Sidekiq::Worker
-
+class ActivityPub::ProcessingWorker < ApplicationWorker
  sidekiq_options queue: 'ingress', backtrace: true, retry: 8

  def perform(actor_id, body, delivered_to_account_id = nil, actor_type = 'Account')
--- a/app/workers/activitypub/raw_distribution_worker.rb
+++ b/app/workers/activitypub/raw_distribution_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class ActivityPub::RawDistributionWorker
-  include Sidekiq::Worker
+class ActivityPub::RawDistributionWorker < ApplicationWorker
  include Payloadable

  sidekiq_options queue: 'push'
--- a/app/workers/activitypub/synchronize_featured_collection_worker.rb
+++ b/app/workers/activitypub/synchronize_featured_collection_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class ActivityPub::SynchronizeFeaturedCollectionWorker
-  include Sidekiq::Worker
-
+class ActivityPub::SynchronizeFeaturedCollectionWorker < ApplicationWorker
  sidekiq_options queue: 'pull', lock: :until_executed, lock_ttl: 1.day.to_i

  def perform(account_id, options = {})
--- a/app/workers/activitypub/synchronize_featured_tags_collection_worker.rb
+++ b/app/workers/activitypub/synchronize_featured_tags_collection_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class ActivityPub::SynchronizeFeaturedTagsCollectionWorker
-  include Sidekiq::Worker
-
+class ActivityPub::SynchronizeFeaturedTagsCollectionWorker < ApplicationWorker
  sidekiq_options queue: 'pull', lock: :until_executed, lock_ttl: 1.day.to_i

  def perform(account_id, url)
--- a/app/workers/add_to_public_statuses_index_worker.rb
+++ b/app/workers/add_to_public_statuses_index_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class AddToPublicStatusesIndexWorker
-  include Sidekiq::Worker
+class AddToPublicStatusesIndexWorker < ApplicationWorker
  include DatabaseHelper

  sidekiq_options queue: 'pull'
--- a/app/workers/admin/account_deletion_worker.rb
+++ b/app/workers/admin/account_deletion_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Admin::AccountDeletionWorker
-  include Sidekiq::Worker
-
+class Admin::AccountDeletionWorker < ApplicationWorker
  sidekiq_options queue: 'pull', lock: :until_executed, lock_ttl: 1.week.to_i

  def perform(account_id)
--- a/app/workers/admin/domain_purge_worker.rb
+++ b/app/workers/admin/domain_purge_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Admin::DomainPurgeWorker
-  include Sidekiq::Worker
-
+class Admin::DomainPurgeWorker < ApplicationWorker
  sidekiq_options queue: 'pull', lock: :until_executed, lock_ttl: 1.week.to_i

  def perform(domain)
--- a/app/workers/admin/suspension_worker.rb
+++ b/app/workers/admin/suspension_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Admin::SuspensionWorker
-  include Sidekiq::Worker
-
+class Admin::SuspensionWorker < ApplicationWorker
  sidekiq_options queue: 'pull'

  def perform(account_id)
--- a/app/workers/admin/unsuspension_worker.rb
+++ b/app/workers/admin/unsuspension_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Admin::UnsuspensionWorker
-  include Sidekiq::Worker
-
+class Admin::UnsuspensionWorker < ApplicationWorker
  sidekiq_options queue: 'pull'

  def perform(account_id)
--- a/app/workers/after_account_domain_block_worker.rb
+++ b/app/workers/after_account_domain_block_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class AfterAccountDomainBlockWorker
-  include Sidekiq::Worker
-
+class AfterAccountDomainBlockWorker < ApplicationWorker
  def perform(account_id, domain)
    AfterBlockDomainFromAccountService.new.call(Account.find(account_id), domain)
  rescue ActiveRecord::RecordNotFound
--- a/app/workers/after_unallow_domain_worker.rb
+++ b/app/workers/after_unallow_domain_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class AfterUnallowDomainWorker
-  include Sidekiq::Worker
-
+class AfterUnallowDomainWorker < ApplicationWorker
  def perform(domain)
    AfterUnallowDomainService.new.call(domain)
  end
--- a/app/workers/application_worker.rb
+++ b/app/workers/application_worker.rb
@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class ApplicationWorker
+  include Sidekiq::Worker
+
+  def perform(*)
+    raise NotImplementedError
+  end
+end
--- a/app/workers/authorize_follow_worker.rb
+++ b/app/workers/authorize_follow_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class AuthorizeFollowWorker
-  include Sidekiq::Worker
-
+class AuthorizeFollowWorker < ApplicationWorker
  def perform(source_account_id, target_account_id)
    source_account = Account.find(source_account_id)
    target_account = Account.find(target_account_id)
--- a/app/workers/backup_worker.rb
+++ b/app/workers/backup_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class BackupWorker
-  include Sidekiq::Worker
-
+class BackupWorker < ApplicationWorker
  sidekiq_options queue: 'pull', backtrace: true, retry: 5, dead: false

  sidekiq_retries_exhausted do |msg|
--- a/app/workers/block_worker.rb
+++ b/app/workers/block_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class BlockWorker
-  include Sidekiq::Worker
-
+class BlockWorker < ApplicationWorker
  def perform(account_id, target_account_id)
    AfterBlockService.new.call(
      Account.find(account_id),
--- a/app/workers/bootstrap_timeline_worker.rb
+++ b/app/workers/bootstrap_timeline_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class BootstrapTimelineWorker
-  include Sidekiq::Worker
-
+class BootstrapTimelineWorker < ApplicationWorker
  def perform(account_id)
    BootstrapTimelineService.new.call(Account.find(account_id))
  end
--- a/app/workers/bulk_import_worker.rb
+++ b/app/workers/bulk_import_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class BulkImportWorker
-  include Sidekiq::Worker
-
+class BulkImportWorker < ApplicationWorker
  sidekiq_options queue: 'pull', retry: false

  def perform(import_id)
--- a/app/workers/cache_buster_worker.rb
+++ b/app/workers/cache_buster_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class CacheBusterWorker
-  include Sidekiq::Worker
+class CacheBusterWorker < ApplicationWorker
  include RoutingHelper

  sidekiq_options queue: 'pull'
--- a/app/workers/delete_mute_worker.rb
+++ b/app/workers/delete_mute_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class DeleteMuteWorker
-  include Sidekiq::Worker
-
+class DeleteMuteWorker < ApplicationWorker
  def perform(mute_id)
    mute = Mute.find_by(id: mute_id)
    UnmuteService.new.call(mute.account, mute.target_account) if mute&.expired?
--- a/app/workers/distribution_worker.rb
+++ b/app/workers/distribution_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class DistributionWorker
-  include Sidekiq::Worker
+class DistributionWorker < ApplicationWorker
  include Redisable
  include Lockable

--- a/app/workers/domain_block_worker.rb
+++ b/app/workers/domain_block_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class DomainBlockWorker
-  include Sidekiq::Worker
-
+class DomainBlockWorker < ApplicationWorker
  def perform(domain_block_id, update = false)
    domain_block = DomainBlock.find_by(id: domain_block_id)
    return true if domain_block.nil?
--- a/app/workers/domain_clear_media_worker.rb
+++ b/app/workers/domain_clear_media_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class DomainClearMediaWorker
-  include Sidekiq::Worker
-
+class DomainClearMediaWorker < ApplicationWorker
  sidekiq_options queue: 'pull'

  def perform(domain_block_id)
--- a/app/workers/feed_insert_worker.rb
+++ b/app/workers/feed_insert_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class FeedInsertWorker
-  include Sidekiq::Worker
+class FeedInsertWorker < ApplicationWorker
  include DatabaseHelper

  def perform(status_id, id, type = 'home', options = {})
--- a/app/workers/fetch_reply_worker.rb
+++ b/app/workers/fetch_reply_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class FetchReplyWorker
-  include Sidekiq::Worker
+class FetchReplyWorker < ApplicationWorker
  include ExponentialBackoff

  sidekiq_options queue: 'pull', retry: 3
--- a/app/workers/generate_annual_report_worker.rb
+++ b/app/workers/generate_annual_report_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class GenerateAnnualReportWorker
-  include Sidekiq::Worker
-
+class GenerateAnnualReportWorker < ApplicationWorker
  def perform(account_id, year)
    AnnualReport.new(Account.find(account_id), year).generate
  rescue ActiveRecord::RecordNotFound, ActiveRecord::RecordNotUnique
--- a/app/workers/import/relationship_worker.rb
+++ b/app/workers/import/relationship_worker.rb
@ -3,9 +3,7 @@
 # NOTE: This is a deprecated worker, only kept to not break ongoing imports
 # on upgrade. See `Import::RowWorker` for its replacement.

-class Import::RelationshipWorker
-  include Sidekiq::Worker
-
+class Import::RelationshipWorker < ApplicationWorker
  sidekiq_options queue: 'pull', retry: 8, dead: false

  def perform(account_id, target_account_uri, relationship, options)
--- a/app/workers/import/row_worker.rb
+++ b/app/workers/import/row_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Import::RowWorker
-  include Sidekiq::Worker
-
+class Import::RowWorker < ApplicationWorker
  sidekiq_options queue: 'pull', retry: 6, dead: false

  sidekiq_retries_exhausted do |msg, _exception|
--- a/app/workers/import_worker.rb
+++ b/app/workers/import_worker.rb
@ -3,9 +3,7 @@
 # NOTE: This is a deprecated worker, only kept to not break ongoing imports
 # on upgrade. See `ImportWorker` for its replacement.

-class ImportWorker
-  include Sidekiq::Worker
-
+class ImportWorker < ApplicationWorker
  sidekiq_options queue: 'pull', retry: false

  def perform(import_id)
--- a/app/workers/link_crawl_worker.rb
+++ b/app/workers/link_crawl_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class LinkCrawlWorker
-  include Sidekiq::Worker
-
+class LinkCrawlWorker < ApplicationWorker
  sidekiq_options queue: 'pull', retry: 0

  def perform(status_id)
--- a/app/workers/local_notification_worker.rb
+++ b/app/workers/local_notification_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class LocalNotificationWorker
-  include Sidekiq::Worker
-
+class LocalNotificationWorker < ApplicationWorker
  def perform(receiver_account_id, activity_id = nil, activity_class_name = nil, type = nil)
    if activity_id.nil? && activity_class_name.nil?
      activity = Mention.find(receiver_account_id)
--- a/app/workers/merge_worker.rb
+++ b/app/workers/merge_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class MergeWorker
-  include Sidekiq::Worker
+class MergeWorker < ApplicationWorker
  include Redisable
  include DatabaseHelper

--- a/app/workers/move_worker.rb
+++ b/app/workers/move_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class MoveWorker
-  include Sidekiq::Worker
-
+class MoveWorker < ApplicationWorker
  def perform(source_account_id, target_account_id)
    @source_account = Account.find(source_account_id)
    @target_account = Account.find(target_account_id)
--- a/app/workers/mute_worker.rb
+++ b/app/workers/mute_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class MuteWorker
-  include Sidekiq::Worker
-
+class MuteWorker < ApplicationWorker
  def perform(account_id, target_account_id)
    FeedManager.instance.clear_from_home(Account.find(account_id), Account.find(target_account_id))
  rescue ActiveRecord::RecordNotFound
--- a/app/workers/poll_expiration_notify_worker.rb
+++ b/app/workers/poll_expiration_notify_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class PollExpirationNotifyWorker
-  include Sidekiq::Worker
-
+class PollExpirationNotifyWorker < ApplicationWorker
  sidekiq_options lock: :until_executing

  def perform(poll_id)
--- a/app/workers/post_process_media_worker.rb
+++ b/app/workers/post_process_media_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class PostProcessMediaWorker
-  include Sidekiq::Worker
-
+class PostProcessMediaWorker < ApplicationWorker
  sidekiq_options retry: 1, dead: false

  sidekiq_retries_exhausted do |msg|
--- a/app/workers/publish_announcement_reaction_worker.rb
+++ b/app/workers/publish_announcement_reaction_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class PublishAnnouncementReactionWorker
-  include Sidekiq::Worker
+class PublishAnnouncementReactionWorker < ApplicationWorker
  include Redisable

  def perform(announcement_id, name)
--- a/app/workers/publish_scheduled_announcement_worker.rb
+++ b/app/workers/publish_scheduled_announcement_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class PublishScheduledAnnouncementWorker
-  include Sidekiq::Worker
+class PublishScheduledAnnouncementWorker < ApplicationWorker
  include Redisable

  def perform(announcement_id)
--- a/app/workers/publish_scheduled_status_worker.rb
+++ b/app/workers/publish_scheduled_status_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class PublishScheduledStatusWorker
-  include Sidekiq::Worker
-
+class PublishScheduledStatusWorker < ApplicationWorker
  sidekiq_options lock: :until_executed, lock_ttl: 1.hour.to_i

  def perform(scheduled_status_id)
--- a/app/workers/push_conversation_worker.rb
+++ b/app/workers/push_conversation_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class PushConversationWorker
-  include Sidekiq::Worker
+class PushConversationWorker < ApplicationWorker
  include Redisable

  def perform(conversation_account_id)
--- a/app/workers/push_encrypted_message_worker.rb
+++ b/app/workers/push_encrypted_message_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class PushEncryptedMessageWorker
-  include Sidekiq::Worker
+class PushEncryptedMessageWorker < ApplicationWorker
  include Redisable

  def perform(encrypted_message_id)
--- a/app/workers/push_update_worker.rb
+++ b/app/workers/push_update_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class PushUpdateWorker
-  include Sidekiq::Worker
+class PushUpdateWorker < ApplicationWorker
  include Redisable

  def perform(account_id, status_id, timeline_id = nil, options = {})
--- a/app/workers/redownload_avatar_worker.rb
+++ b/app/workers/redownload_avatar_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class RedownloadAvatarWorker
-  include Sidekiq::Worker
+class RedownloadAvatarWorker < ApplicationWorker
  include ExponentialBackoff
  include JsonLdHelper

--- a/app/workers/redownload_header_worker.rb
+++ b/app/workers/redownload_header_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class RedownloadHeaderWorker
-  include Sidekiq::Worker
+class RedownloadHeaderWorker < ApplicationWorker
  include ExponentialBackoff
  include JsonLdHelper

--- a/app/workers/redownload_media_worker.rb
+++ b/app/workers/redownload_media_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class RedownloadMediaWorker
-  include Sidekiq::Worker
+class RedownloadMediaWorker < ApplicationWorker
  include ExponentialBackoff
  include JsonLdHelper

--- a/app/workers/refollow_worker.rb
+++ b/app/workers/refollow_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class RefollowWorker
-  include Sidekiq::Worker
-
+class RefollowWorker < ApplicationWorker
  sidekiq_options queue: 'pull', retry: false

  def perform(target_account_id)
--- a/app/workers/regeneration_worker.rb
+++ b/app/workers/regeneration_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class RegenerationWorker
-  include Sidekiq::Worker
+class RegenerationWorker < ApplicationWorker
  include DatabaseHelper

  sidekiq_options lock: :until_executed
--- a/app/workers/remote_account_refresh_worker.rb
+++ b/app/workers/remote_account_refresh_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class RemoteAccountRefreshWorker
-  include Sidekiq::Worker
+class RemoteAccountRefreshWorker < ApplicationWorker
  include ExponentialBackoff
  include JsonLdHelper

--- a/app/workers/removal_worker.rb
+++ b/app/workers/removal_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class RemovalWorker
-  include Sidekiq::Worker
-
+class RemovalWorker < ApplicationWorker
  def perform(status_id, options = {})
    RemoveStatusService.new.call(Status.with_discarded.find(status_id), **options.symbolize_keys)
  rescue ActiveRecord::RecordNotFound
--- a/app/workers/remove_featured_tag_worker.rb
+++ b/app/workers/remove_featured_tag_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class RemoveFeaturedTagWorker
-  include Sidekiq::Worker
-
+class RemoveFeaturedTagWorker < ApplicationWorker
  def perform(account_id, featured_tag_id)
    RemoveFeaturedTagService.new.call(Account.find(account_id), FeaturedTag.find(featured_tag_id))
  rescue ActiveRecord::RecordNotFound
--- a/app/workers/remove_from_public_statuses_index_worker.rb
+++ b/app/workers/remove_from_public_statuses_index_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class RemoveFromPublicStatusesIndexWorker
-  include Sidekiq::Worker
-
+class RemoveFromPublicStatusesIndexWorker < ApplicationWorker
  def perform(account_id)
    account = Account.find(account_id)

--- a/app/workers/resolve_account_worker.rb
+++ b/app/workers/resolve_account_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class ResolveAccountWorker
-  include Sidekiq::Worker
-
+class ResolveAccountWorker < ApplicationWorker
  sidekiq_options queue: 'pull', lock: :until_executed, lock_ttl: 1.day.to_i

  def perform(uri)
--- a/app/workers/scheduler/accounts_statuses_cleanup_scheduler.rb
+++ b/app/workers/scheduler/accounts_statuses_cleanup_scheduler.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::AccountsStatusesCleanupScheduler
-  include Sidekiq::Worker
+class Scheduler::AccountsStatusesCleanupScheduler < ApplicationWorker
  include Redisable

  # This limit is mostly to be nice to the fediverse at large and not
--- a/app/workers/scheduler/auto_close_registrations_scheduler.rb
+++ b/app/workers/scheduler/auto_close_registrations_scheduler.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::AutoCloseRegistrationsScheduler
-  include Sidekiq::Worker
+class Scheduler::AutoCloseRegistrationsScheduler < ApplicationWorker
  include Redisable

  sidekiq_options retry: 0
--- a/app/workers/scheduler/follow_recommendations_scheduler.rb
+++ b/app/workers/scheduler/follow_recommendations_scheduler.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::FollowRecommendationsScheduler
-  include Sidekiq::Worker
-
+class Scheduler::FollowRecommendationsScheduler < ApplicationWorker
  sidekiq_options retry: 0, lock: :until_executed, lock_ttl: 1.day.to_i

  def perform
--- a/app/workers/scheduler/indexing_scheduler.rb
+++ b/app/workers/scheduler/indexing_scheduler.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::IndexingScheduler
-  include Sidekiq::Worker
+class Scheduler::IndexingScheduler < ApplicationWorker
  include Redisable
  include DatabaseHelper

--- a/app/workers/scheduler/instance_refresh_scheduler.rb
+++ b/app/workers/scheduler/instance_refresh_scheduler.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::InstanceRefreshScheduler
-  include Sidekiq::Worker
-
+class Scheduler::InstanceRefreshScheduler < ApplicationWorker
  sidekiq_options retry: 0, lock: :until_executed, lock_ttl: 1.day.to_i

  def perform
--- a/app/workers/scheduler/ip_cleanup_scheduler.rb
+++ b/app/workers/scheduler/ip_cleanup_scheduler.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::IpCleanupScheduler
-  include Sidekiq::Worker
-
+class Scheduler::IpCleanupScheduler < ApplicationWorker
  IP_RETENTION_PERIOD = ENV.fetch('IP_RETENTION_PERIOD', 1.year).to_i.seconds.freeze
  SESSION_RETENTION_PERIOD = ENV.fetch('SESSION_RETENTION_PERIOD', 1.year).to_i.seconds.freeze

--- a/app/workers/scheduler/pghero_scheduler.rb
+++ b/app/workers/scheduler/pghero_scheduler.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::PgheroScheduler
-  include Sidekiq::Worker
-
+class Scheduler::PgheroScheduler < ApplicationWorker
  sidekiq_options retry: 0, lock: :until_executed, lock_ttl: 1.day.to_i

  def perform
--- a/app/workers/scheduler/scheduled_statuses_scheduler.rb
+++ b/app/workers/scheduler/scheduled_statuses_scheduler.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::ScheduledStatusesScheduler
-  include Sidekiq::Worker
-
+class Scheduler::ScheduledStatusesScheduler < ApplicationWorker
  sidekiq_options retry: 0, lock: :until_executed, lock_ttl: 1.hour.to_i

  def perform
--- a/app/workers/scheduler/self_destruct_scheduler.rb
+++ b/app/workers/scheduler/self_destruct_scheduler.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::SelfDestructScheduler
-  include Sidekiq::Worker
+class Scheduler::SelfDestructScheduler < ApplicationWorker
  include SelfDestructHelper

  MAX_ENQUEUED = 10_000
--- a/app/workers/scheduler/software_update_check_scheduler.rb
+++ b/app/workers/scheduler/software_update_check_scheduler.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::SoftwareUpdateCheckScheduler
-  include Sidekiq::Worker
-
+class Scheduler::SoftwareUpdateCheckScheduler < ApplicationWorker
  sidekiq_options retry: 0, lock: :until_executed, lock_ttl: 1.hour.to_i

  def perform
--- a/app/workers/scheduler/suspended_user_cleanup_scheduler.rb
+++ b/app/workers/scheduler/suspended_user_cleanup_scheduler.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::SuspendedUserCleanupScheduler
-  include Sidekiq::Worker
-
+class Scheduler::SuspendedUserCleanupScheduler < ApplicationWorker
  # Each processed deletion request may enqueue an enormous
  # amount of jobs in the `pull` queue, so only enqueue when
  # the queue is empty or close to being so.
--- a/app/workers/scheduler/trends/refresh_scheduler.rb
+++ b/app/workers/scheduler/trends/refresh_scheduler.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::Trends::RefreshScheduler
-  include Sidekiq::Worker
-
+class Scheduler::Trends::RefreshScheduler < ApplicationWorker
  sidekiq_options retry: 0, lock: :until_executed, lock_ttl: 30.minutes.to_i

  def perform
--- a/app/workers/scheduler/trends/review_notifications_scheduler.rb
+++ b/app/workers/scheduler/trends/review_notifications_scheduler.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::Trends::ReviewNotificationsScheduler
-  include Sidekiq::Worker
-
+class Scheduler::Trends::ReviewNotificationsScheduler < ApplicationWorker
  sidekiq_options retry: 0

  def perform
--- a/app/workers/scheduler/user_cleanup_scheduler.rb
+++ b/app/workers/scheduler/user_cleanup_scheduler.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::UserCleanupScheduler
-  include Sidekiq::Worker
-
+class Scheduler::UserCleanupScheduler < ApplicationWorker
  sidekiq_options retry: 0, lock: :until_executed, lock_ttl: 1.day.to_i

  def perform
--- a/app/workers/scheduler/vacuum_scheduler.rb
+++ b/app/workers/scheduler/vacuum_scheduler.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Scheduler::VacuumScheduler
-  include Sidekiq::Worker
-
+class Scheduler::VacuumScheduler < ApplicationWorker
  sidekiq_options retry: 0, lock: :until_executed, lock_ttl: 1.day.to_i

  def perform
--- a/app/workers/tag_unmerge_worker.rb
+++ b/app/workers/tag_unmerge_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class TagUnmergeWorker
-  include Sidekiq::Worker
+class TagUnmergeWorker < ApplicationWorker
  include DatabaseHelper

  sidekiq_options queue: 'pull'
--- a/app/workers/thread_resolve_worker.rb
+++ b/app/workers/thread_resolve_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class ThreadResolveWorker
-  include Sidekiq::Worker
+class ThreadResolveWorker < ApplicationWorker
  include ExponentialBackoff

  sidekiq_options queue: 'pull', retry: 3
--- a/app/workers/trigger_webhook_worker.rb
+++ b/app/workers/trigger_webhook_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class TriggerWebhookWorker
-  include Sidekiq::Worker
-
+class TriggerWebhookWorker < ApplicationWorker
  def perform(event, class_name, id)
    object = class_name.constantize.find(id)
    WebhookService.new.call(event, object)
--- a/app/workers/unfavourite_worker.rb
+++ b/app/workers/unfavourite_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class UnfavouriteWorker
-  include Sidekiq::Worker
-
+class UnfavouriteWorker < ApplicationWorker
  def perform(account_id, status_id)
    UnfavouriteService.new.call(Account.find(account_id), Status.find(status_id))
  rescue ActiveRecord::RecordNotFound
--- a/app/workers/unfilter_notifications_worker.rb
+++ b/app/workers/unfilter_notifications_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class UnfilterNotificationsWorker
-  include Sidekiq::Worker
-
+class UnfilterNotificationsWorker < ApplicationWorker
  def perform(notification_request_id)
    @notification_request = NotificationRequest.find(notification_request_id)

--- a/app/workers/unfollow_follow_worker.rb
+++ b/app/workers/unfollow_follow_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class UnfollowFollowWorker
-  include Sidekiq::Worker
-
+class UnfollowFollowWorker < ApplicationWorker
  sidekiq_options queue: 'pull'

  def perform(follower_account_id, old_target_account_id, new_target_account_id, bypass_locked = false)
--- a/app/workers/unmerge_worker.rb
+++ b/app/workers/unmerge_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class UnmergeWorker
-  include Sidekiq::Worker
+class UnmergeWorker < ApplicationWorker
  include DatabaseHelper

  sidekiq_options queue: 'pull'
--- a/app/workers/unpublish_announcement_worker.rb
+++ b/app/workers/unpublish_announcement_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class UnpublishAnnouncementWorker
-  include Sidekiq::Worker
+class UnpublishAnnouncementWorker < ApplicationWorker
  include Redisable

  def perform(announcement_id)
--- a/app/workers/verify_account_links_worker.rb
+++ b/app/workers/verify_account_links_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class VerifyAccountLinksWorker
-  include Sidekiq::Worker
-
+class VerifyAccountLinksWorker < ApplicationWorker
  sidekiq_options queue: 'default', retry: false, lock: :until_executed, lock_ttl: 1.hour.to_i

  def perform(account_id)
--- a/app/workers/web/push_notification_worker.rb
+++ b/app/workers/web/push_notification_worker.rb
@ -1,8 +1,6 @@
 # frozen_string_literal: true

-class Web::PushNotificationWorker
-  include Sidekiq::Worker
-
+class Web::PushNotificationWorker < ApplicationWorker
  sidekiq_options queue: 'push', retry: 5

  TTL     = 48.hours.to_s
--- a/app/workers/webhooks/delivery_worker.rb
+++ b/app/workers/webhooks/delivery_worker.rb
@ -1,7 +1,6 @@
 # frozen_string_literal: true

-class Webhooks::DeliveryWorker
-  include Sidekiq::Worker
+class Webhooks::DeliveryWorker < ApplicationWorker
  include JsonLdHelper

  sidekiq_options queue: 'push', retry: 16, dead: false