activejob-unique 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 061e508b94c278bf8ccd34aa73f19461625922aec84783d6337968342ef7a8db
+  data.tar.gz: 135d045c623b181d2bb86bd2234b72f25c84f7c4549829e4d40d0908fd4dd838
+SHA512:
+  metadata.gz: 14b1956520105caeef38dcb7e5c4b5f51dbc197d575f3f839d6d9d5a7ca2502cda85ebeacf56b7dff206589566bc1680fa20707d7437a74c95509706e4ce253b
+  data.tar.gz: a821c7491fd5f0768863d0ed475ea72f81ee318ce19ac5999765c6bde3f156bda1e78baeda5390e0fb0dc73d14f9453b20bc10365f9a5c0352f4452a2dcf9b1e

data/CHANGELOG.md

@@ -0,0 +1,128 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [Unreleased](https://github.com/nordinvestments/activejob-uniqueness/compare/v0.5.0...HEAD)
+
+## [0.5.0](https://github.com/nordinvestments/activejob-uniqueness/compare/v0.4.0...v0.5.0) - 2026-01-12
+
+### Changed
+- Fork published as `activejob-unique` gem by [@nordinvestments](https://github.com/nordinvestments)
+- Updated gem metadata to point to fork repository
+
+---
+
+*Versions below are from the original [veeqo/activejob-uniqueness](https://github.com/veeqo/activejob-uniqueness) repository.*
+
+## [0.4.0](https://github.com/veeqo/activejob-uniqueness/compare/v0.3.2...v0.4.0) - 2024-12-07
+
+### Added
+
+- [#86](https://github.com/veeqo/activejob-uniqueness/pull/86) Add Rails 8.0 rc1 support by[@sharshenov](https://github.com/sharshenov)
+- [#78](https://github.com/veeqo/activejob-uniqueness/pull/78) Add on_redis_connection_error config to adjust to new redlock behaviour by[@nduitz](https://github.com/nduitz)
+
+### Changed
+- [#82](https://github.com/veeqo/activejob-uniqueness/pull/82) Optimize bulk unlocking [@sharshenov](https://github.com/sharshenov)
+
+## [0.3.2](https://github.com/veeqo/activejob-uniqueness/compare/v0.3.1...v0.3.2) - 2024-08-16
+
+### Added
+- [#80](https://github.com/veeqo/activejob-uniqueness/pull/80) Add rails 7.2 support by [@viralpraxis](https://github.com/viralpraxis)
+
+### Changed
+- [#74](https://github.com/veeqo/activejob-uniqueness/pull/74) Fix log subscriber by [@shahidkhaliq](https://github.com/shahidkhaliq)
+
+## [0.3.1](https://github.com/veeqo/activejob-uniqueness/compare/v0.3.0...v0.3.1) - 2023-10-30
+
+### Fixed
+
+- [#67](https://github.com/veeqo/activejob-uniqueness/pull/67) Random redis errors on delete_lock by [@laurafeier](https://github.com/laurafeier)
+
+## [0.3.0](https://github.com/veeqo/activejob-uniqueness/compare/v0.2.5...v0.3.0) - 2023-10-20
+
+### Added
+- [#66](https://github.com/veeqo/activejob-uniqueness/pull/66) Activejob 7.1 support by [@laurafeier](https://github.com/laurafeier)
+
+### Changed
+- [#57](https://github.com/veeqo/activejob-uniqueness/pull/57) Upgrade to Redlock 2 & use redis-client by [@bmulholland](https://github.com/bmulholland)
+
+### Removed
+- Support fo Redlock v1 is removed. Switching to `RedisClient` is [a breaking change of Redlock v2](https://github.com/leandromoreira/redlock-rb/blob/main/CHANGELOG.md#200---2023-02-09).
+
+## [0.2.5](https://github.com/veeqo/activejob-uniqueness/compare/v0.2.4...v0.2.5) - 2023-02-01
+
+### Added
+- [#45](https://github.com/veeqo/activejob-uniqueness/pull/45) Add Dependabot for GitHub Actions by [@petergoldstein](https://github.com/petergoldstein)
+- [#51](https://github.com/veeqo/activejob-uniqueness/pull/51) Add support for Sidekiq 7 by [@dwightwatson](https://github.com/dwightwatson)
+- [#52](https://github.com/veeqo/activejob-uniqueness/pull/52) Add Ruby 3.2.0 to the CI matrix by [@petergoldstein](https://github.com/petergoldstein)
+
+### Changed
+- [#46](https://github.com/veeqo/activejob-uniqueness/pull/46) Fix a method name typo in CHANGELOG by [@y-yagi](https://github.com/y-yagi)
+
+## [0.2.4](https://github.com/veeqo/activejob-uniqueness/compare/v0.2.3...v0.2.4) - 2022-06-22
+
+### Added
+- [#43](https://github.com/veeqo/activejob-uniqueness/pull/43) Run rubocop on Github Actions
+- [#44](https://github.com/veeqo/activejob-uniqueness/pull/44) Add ActiveJob::Uniqueness.reset_manager! method to reset lock manager by [@akostadinov](https://github.com/akostadinov)
+
+### Changed
+- [#42](https://github.com/veeqo/activejob-uniqueness/pull/42) Actualize rubies and gems for tests
+
+## [0.2.3](https://github.com/veeqo/activejob-uniqueness/compare/v0.2.2...v0.2.3) - 2022-02-28
+
+### Added
+- [#36](https://github.com/veeqo/activejob-uniqueness/pull/36) Support ActiveJob/Rails 7.0
+- [#37](https://github.com/veeqo/activejob-uniqueness/pull/37) Add Ruby 3.1 to CI by [@petergoldstein](https://github.com/petergoldstein)
+
+## [0.2.2](https://github.com/veeqo/activejob-uniqueness/compare/v0.2.1...v0.2.2) - 2021-10-22
+
+### Added
+- [#32](https://github.com/veeqo/activejob-uniqueness/pull/32) Add ability to set a custom runtime lock key for `:until_and_while_executing` strategy
+
+## [0.2.1](https://github.com/veeqo/activejob-uniqueness/compare/v0.2.0...v0.2.1) - 2021-08-24
+
+### Added
+- [#30](https://github.com/veeqo/activejob-uniqueness/pull/30) Add Sidekiq::JobRecord support (reported by [@dwightwatson](https://github.com/dwightwatson))
+
+## [0.2.0](https://github.com/veeqo/activejob-uniqueness/compare/v0.1.4...v0.2.0) - 2021-05-09
+
+### Added
+- [#22](https://github.com/veeqo/activejob-uniqueness/pull/22) Test with ruby 3.0.1
+
+### Changed
+- [#20](https://github.com/veeqo/activejob-uniqueness/pull/20) **Breaking** Sidekiq patch is not applied automatically anymore
+- [#21](https://github.com/veeqo/activejob-uniqueness/pull/21) Migrate from Travis to Github Actions
+- [#24](https://github.com/veeqo/activejob-uniqueness/pull/24) The default value for `retry_count` of redlock is now 0
+- Require ruby 2.5+
+
+## [0.1.4](https://github.com/veeqo/activejob-uniqueness/compare/v0.1.3...v0.1.4) - 2020-09-22
+
+### Fixed
+- [#11](https://github.com/veeqo/activejob-uniqueness/pull/11) Fix deprecation warnings for ruby 2.7 by [@DanAndreasson](https://github.com/DanAndreasson)
+- [#13](https://github.com/veeqo/activejob-uniqueness/pull/13) Fix deprecation warnings for ruby 2.7
+
+## [0.1.3](https://github.com/veeqo/activejob-uniqueness/compare/v0.1.2...v0.1.3) - 2020-08-17
+
+### Fixed
+- [#7](https://github.com/veeqo/activejob-uniqueness/pull/7) Fix deprecation warnings for ruby 2.7 by [@tonobo](https://github.com/tonobo)
+
+### Changed
+- [#8](https://github.com/veeqo/activejob-uniqueness/pull/8) Use appraisal gem to control gem versions of tests matrix
+- [#9](https://github.com/veeqo/activejob-uniqueness/pull/9) Refactor of Sidekiq API patch. Fixes [#6](https://github.com/veeqo/activejob-uniqueness/issues/6) Rails boot error for version 0.1.2
+- [#10](https://github.com/veeqo/activejob-uniqueness/pull/10) Refactor changelog to comply with Keep a Changelog
+
+## [0.1.2](https://github.com/veeqo/activejob-uniqueness/compare/v0.1.1...v0.1.2) - 2020-07-30
+
+### Added
+-  [#5](https://github.com/veeqo/activejob-uniqueness/pull/5) Release lock for Sidekiq adapter by [@vbyno](https://github.com/vbyno)
+
+## [0.1.1](https://github.com/veeqo/activejob-uniqueness/compare/v0.1.0...v0.1.1) - 2020-07-23
+
+### Fixed
+- [#4](https://github.com/veeqo/activejob-uniqueness/pull/4) Fix `NoMethodError` on `Rails.application.eager_load!` in Rails initializer
+
+## [0.1.0](https://github.com/veeqo/activejob-uniqueness/releases/tag/v0.1.0) - 2020-07-05
+
+### Added
+- Job uniqueness for ActiveJob

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Rustam Sharshenov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,266 @@
+# Job uniqueness for ActiveJob
+
+> **Maintained fork of [veeqo/activejob-uniqueness](https://github.com/veeqo/activejob-uniqueness)**
+>
+> This gem is published as `activejob-unique` on RubyGems. The API is fully compatible with the original gem — just update your Gemfile.
+
+[![Build Status](https://github.com/nordinvestments/activejob-uniqueness/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/nordinvestments/activejob-uniqueness/actions/workflows/main.yml) [![Gem Version](https://badge.fury.io/rb/activejob-unique.svg)](https://badge.fury.io/rb/activejob-unique)
+
+## Requirements
+
+| Dependency | Version |
+|------------|---------|
+| Ruby | >= 3.1 |
+| Rails (ActiveJob) | >= 7.1, < 7.3 |
+| Redis | >= 2.8 |
+
+> **Note:** This fork targets modern Ruby and Rails versions. For older Ruby (2.5-3.0) or Rails (4.2-7.0) support, use the [original gem](https://github.com/veeqo/activejob-uniqueness).
+
+## Overview
+
+The gem allows to protect job uniqueness with next strategies:
+
+| Strategy | The job is locked | The job is unlocked |
+|-|-|-|
+| `until_executing` | when **pushed** to the queue | when **processing starts** |
+| `until_executed` | when **pushed** to the queue | when the job is **processed successfully** |
+| `until_expired` | when **pushed** to the queue | when the lock is **expired** |
+| `until_and_while_executing` | when **pushed** to the queue | when **processing starts**<br>a runtime lock is acquired to **prevent simultaneous jobs**<br>*has extra options: `runtime_lock_ttl`, `on_runtime_conflict`* |
+| `while_executing` | when **processing starts** | when the job is **processed**<br>with any result including an error |
+
+Inspired by [SidekiqUniqueJobs](https://github.com/mhenrixon/sidekiq-unique-jobs), uses [Redlock](https://github.com/leandromoreira/redlock-rb) under the hood.
+
+<p align="center">
+  <a href="https://www.veeqo.com/" title="Sponsored by Veeqo">
+    <img src="https://static.veeqo.com/assets/sponsored_by_veeqo.png" width="360" />
+  </a>
+</p>
+
+## Installation
+
+Add the `activejob-unique` gem to your Gemfile.
+
+```ruby
+gem 'activejob-unique'
+```
+
+If you want jobs unlocking for Sidekiq Web UI, require the patch explicitly. [**Queues cleanup becomes slower!**](#sidekiq-api-support)
+```ruby
+gem 'activejob-unique', require: 'active_job/uniqueness/sidekiq_patch'
+```
+
+And run `bundle install` command.
+
+### Migrating from `activejob-uniqueness`
+
+If you're switching from the original gem, simply replace in your Gemfile:
+
+```ruby
+# Before
+gem 'activejob-uniqueness'
+
+# After
+gem 'activejob-unique'
+```
+
+No code changes required — the `ActiveJob::Uniqueness` module namespace is unchanged.
+
+## Configuration
+
+ActiveJob::Uniqueness is ready to work without any configuration. It will use `REDIS_URL` to connect to Redis instance.
+To override the defaults, create an initializer `config/initializers/active_job_uniqueness.rb` using the following command:
+
+```sh
+rails generate active_job:uniqueness:install
+```
+
+This gem relies on `redlock` for it's Redis connection, that means **it will not inherit global configuration of `Sidekiq`**. To configure the connection, you can use `config.redlock_servers`, for example to disable SSL verification for Redis/Key-Value cloud providers:
+
+```ruby
+ActiveJob::Uniqueness.configure do |config|
+  config.redlock_servers = [
+    RedisClient.new(
+      url: ENV['REDIS_URL'],
+      ssl_params: { verify_mode: OpenSSL::SSL::VERIFY_NONE }
+    )
+  ]
+end
+```
+
+## Usage
+
+
+### Make the job to be unique
+
+```ruby
+class MyJob < ActiveJob::Base
+  # new jobs with the same args will raise error until existing one is executed
+  unique :until_executed
+
+  def perform(args)
+    # work
+  end
+end
+```
+
+### Tune uniqueness settings per job
+
+```ruby
+class MyJob < ActiveJob::Base
+  # new jobs with the same args will be logged within 3 hours or until existing one is being executing
+  unique :until_executing, lock_ttl: 3.hours, on_conflict: :log
+
+  def perform(args)
+    # work
+  end
+end
+```
+
+You can set defaults globally with [the configuration](#configuration)
+
+### Control lock conflicts
+
+```ruby
+class MyJob < ActiveJob::Base
+  # Proc gets the job instance including its arguments
+  unique :until_executing, on_conflict: ->(job) { job.logger.info "Oops: #{job.arguments}" }
+
+  def perform(args)
+    # work
+  end
+end
+```
+
+### Control redis connection errors
+
+```ruby
+class MyJob < ActiveJob::Base
+  # Proc gets the job instance including its arguments, and as keyword arguments the resource(lock key) `resource` and the original error `error`
+  unique :until_executing, on_redis_connection_error: ->(job, resource: _, error: _) { job.logger.info "Oops: #{job.arguments}" }
+
+  def perform(args)
+    # work
+  end
+end
+```
+
+### Control lock key arguments
+
+```ruby
+class MyJob < ActiveJob::Base
+  unique :until_executed
+
+  def perform(foo, bar, baz)
+    # work
+  end
+
+  def lock_key_arguments
+    arguments.first(2) # baz is ignored
+  end
+end
+```
+
+### Control the lock key
+
+```ruby
+class MyJob < ActiveJob::Base
+  unique :until_executed
+
+  def perform(foo, bar, baz)
+    # work
+  end
+
+  def lock_key
+    'qux' # completely custom lock key
+  end
+
+  def runtime_lock_key
+    'quux' # completely custom runtime lock key for :until_and_while_executing
+  end
+end
+```
+
+### Unlock jobs manually
+
+The selected strategy automatically unlocks jobs, but in some cases (e.g. the queue is purged) it is handy to unlock jobs manually.
+
+```ruby
+# Remove the lock for particular arguments:
+MyJob.unlock!(foo: 'bar')
+# or
+ActiveJob::Uniqueness.unlock!(job_class_name: 'MyJob', arguments: [{foo: 'bar'}])
+
+# Remove all locks of MyJob
+MyJob.unlock!
+# or
+ActiveJob::Uniqueness.unlock!(job_class_name: 'MyJob')
+
+# Remove all locks
+ActiveJob::Uniqueness.unlock!
+```
+
+## Test mode
+
+Most probably you don't want jobs to be locked in tests. Add this line to your test suite (`rails_helper.rb`):
+
+```ruby
+ActiveJob::Uniqueness.test_mode!
+```
+
+## Logging
+
+ActiveJob::Uniqueness instruments `ActiveSupport::Notifications` with next events:
+* `lock.active_job_uniqueness`
+* `runtime_lock.active_job_uniqueness`
+* `unlock.active_job_uniqueness`
+* `runtime_unlock.active_job_uniqueness`
+* `conflict.active_job_uniqueness`
+* `runtime_conflict.active_job_uniqueness`
+
+And then writes to `ActiveJob::Base.logger`.
+
+**ActiveJob prior to version `6.1` will always log `Enqueued MyJob (Job ID) ...` even if the callback chain is halted. [Details](https://github.com/rails/rails/pull/37830)**
+
+## Testing
+
+Run redis server (in separate console):
+```
+docker run --rm -p 6379:6379 redis
+```
+
+Run tests with:
+
+```sh
+bundle
+rake
+```
+
+## Sidekiq API support
+
+ActiveJob::Uniqueness supports Sidekiq API to unset job locks on queues cleanup (e.g. via Sidekiq Web UI). Starting Sidekiq 5.1 job death also triggers locks cleanup.
+Take into account that **[big queues cleanup becomes much slower](https://github.com/nordinvestments/activejob-uniqueness/issues/16)** because each job is being unlocked individually. In order to activate Sidekiq API patch require it explicitly in your Gemfile:
+
+```ruby
+gem 'activejob-unique', require: 'active_job/uniqueness/sidekiq_patch'
+```
+
+## Why this fork?
+
+The [original gem](https://github.com/veeqo/activejob-uniqueness) by Veeqo is excellent, but maintenance has slowed. This fork aims to:
+
+- Keep up with new Rails and Ruby versions
+- Merge useful PRs from the community
+- Provide timely security updates
+- Maintain backwards compatibility
+
+We're grateful to the original authors and contributors. This fork preserves the MIT license and full attribution.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nordinvestments/activejob-uniqueness.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+Originally created by [Veeqo](https://www.veeqo.com). Maintained by [Nord Investments](https://github.com/nordinvestments).

data/lib/active_job/uniqueness/active_job_patch.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    # Provides ability to make ActiveJob job unique.
+    #
+    # For example:
+    #
+    # class FooJob < ActiveJob::Base
+    #   queue_as :foo
+    #
+    #   unique :until_executed, lock_ttl: 3.hours
+    #
+    #   def perform(params)
+    #     #...
+    #   end
+    # end
+    #
+    module ActiveJobPatch
+      extend ActiveSupport::Concern
+
+      class_methods do
+        # Enables the uniqueness strategy for the job
+        # Params:
+        # +strategy+:: the uniqueness strategy.
+        # +options+:: uniqueness strategy options. For example: lock_ttl.
+        def unique(strategy, options = {})
+          validate_on_conflict_action!(options[:on_conflict])
+          validate_on_conflict_action!(options[:on_runtime_conflict])
+          validate_on_redis_connection_error!(options[:on_redis_connection_error])
+
+          self.lock_strategy_class = ActiveJob::Uniqueness::Strategies.lookup(strategy)
+          self.lock_options = options
+        end
+
+        # Unlocks all jobs of the job class if no arguments given
+        # Unlocks particular job if job arguments given
+        def unlock!(*arguments)
+          ActiveJob::Uniqueness.unlock!(job_class_name: name, arguments: arguments)
+        end
+
+        private
+
+        delegate :validate_on_conflict_action!,
+                 :validate_on_redis_connection_error!,
+                 to: :'ActiveJob::Uniqueness.config'
+      end
+
+      included do
+        class_attribute :lock_strategy_class, instance_writer: false
+        class_attribute :lock_options, instance_writer: false
+
+        before_enqueue { |job| job.lock_strategy.before_enqueue if job.lock_strategy_class }
+        before_perform { |job| job.lock_strategy.before_perform if job.lock_strategy_class }
+        after_perform  { |job| job.lock_strategy.after_perform if job.lock_strategy_class }
+        around_enqueue { |job, block| job.lock_strategy_class ? job.lock_strategy.around_enqueue(block) : block.call }
+        around_perform { |job, block| job.lock_strategy_class ? job.lock_strategy.around_perform(block) : block.call }
+      end
+
+      def lock_strategy
+        @lock_strategy ||= lock_strategy_class.new(job: self)
+      end
+
+      # Override in your job class if you want to customize arguments set for a digest.
+      def lock_key_arguments
+        arguments
+      end
+
+      # Override lock_key method in your job class if you want to build completely custom lock key.
+      delegate :lock_key, :runtime_lock_key, to: :lock_key_generator
+
+      def lock_key_generator
+        @lock_key_generator ||= ActiveJob::Uniqueness::LockKey.new job_class_name: self.class.name,
+                                                                   arguments: lock_key_arguments
+      end
+    end
+
+    ActiveSupport.on_load(:active_job) do
+      ActiveJob::Base.include ActiveJob::Uniqueness::ActiveJobPatch
+    end
+  end
+end

data/lib/active_job/uniqueness/configuration.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    # Use /config/initializer/activejob_uniqueness.rb to configure ActiveJob::Uniqueness
+    #
+    # ActiveJob::Uniqueness.configure do |c|
+    #   c.lock_ttl = 3.hours
+    # end
+    #
+    class Configuration
+      class_attribute :lock_ttl, default: 86_400 # 1.day
+      class_attribute :lock_prefix, default: 'activejob_uniqueness'
+      class_attribute :_on_conflict, default: :raise
+      class_attribute :_on_redis_connection_error, default: :raise
+      class_attribute :redlock_servers, default: [ENV.fetch('REDIS_URL', 'redis://localhost:6379')]
+      class_attribute :redlock_options, default: { retry_count: 0 }
+      class_attribute :lock_strategies, default: {}
+      class_attribute :digest_method
+
+      def on_conflict
+        _on_conflict
+      end
+
+      def on_conflict=(action)
+        validate_on_conflict_action!(action)
+
+        self._on_conflict = action
+      end
+
+      def on_redis_connection_error
+        _on_redis_connection_error
+      end
+
+      def on_redis_connection_error=(action)
+        validate_on_redis_connection_error!(action)
+
+        self._on_redis_connection_error = action
+      end
+
+      def validate_on_conflict_action!(action)
+        return if action.nil? || %i[log raise].include?(action) || action.respond_to?(:call)
+
+        raise ActiveJob::Uniqueness::InvalidOnConflictAction, "Unexpected '#{action}' action on conflict"
+      end
+
+      def validate_on_redis_connection_error!(action)
+        return if action.nil? || action == :raise || action.respond_to?(:call)
+
+        raise ActiveJob::Uniqueness::InvalidOnConflictAction, "Unexpected '#{action}' action on_redis_connection_error"
+      end
+    end
+  end
+end
+
+# Set default digest_method after class is defined
+ActiveJob::Uniqueness::Configuration.digest_method = begin
+  require 'openssl'
+  OpenSSL::Digest::MD5
+end

data/lib/active_job/uniqueness/errors.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Uniqueness
+    class Error < ::RuntimeError; end
+
+    # Raised when unknown strategy is referenced in the job class
+    #
+    # class MyJob < ActiveJob::Base
+    #   unique :invalid_strategy # exception raised
+    # end
+    #
+    class StrategyNotFound < Error; end
+
+    # Raised on attempt to enqueue a not unique job with :raise on_conflict.
+    # Also raised when the runtime lock is taken by some other job.
+    #
+    # class MyJob < ActiveJob::Base
+    #   unique :until_expired, on_conflict: :raise
+    # end
+    #
+    # MyJob.perform_later(1)
+    # MyJob.perform_later(1) # exception raised
+    #
+    class JobNotUnique < Error; end
+
+    # Raised when unsupported on_conflict action is used
+    #
+    # class MyJob < ActiveJob::Base
+    #   unique :until_expired, on_conflict: :die # exception raised
+    # end
+    #
+    class InvalidOnConflictAction < Error; end
+  end
+end

data/lib/active_job/uniqueness/lock_key.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'active_job/arguments'
+
+module ActiveJob
+  module Uniqueness
+    class LockKey
+      FALLBACK_ARGUMENTS_STRING = 'no_arguments'
+
+      delegate :lock_prefix, :digest_method, to: :'ActiveJob::Uniqueness.config'
+
+      attr_reader :job_class_name, :arguments
+
+      def initialize(job_class_name: nil, arguments: nil)
+        if arguments.present? && job_class_name.blank?
+          raise ArgumentError, 'job_class_name is required if arguments given'
+        end
+
+        @job_class_name = job_class_name
+        @arguments = arguments || []
+      end
+
+      def lock_key
+        [
+          lock_prefix,
+          normalized_job_class_name,
+          arguments_key_part
+        ].join(':')
+      end
+
+      # used only by :until_and_while_executing strategy
+      def runtime_lock_key
+        [
+          lock_key,
+          'runtime'
+        ].join(':')
+      end
+
+      def wildcard_key
+        [
+          lock_prefix,
+          normalized_job_class_name,
+          arguments.any? ? "#{arguments_key_part}*" : '*'
+        ].compact.join(':')
+      end
+
+      private
+
+      def arguments_key_part
+        arguments.any? ? arguments_digest : FALLBACK_ARGUMENTS_STRING
+      end
+
+      # ActiveJob::Arguments is used to reflect the way ActiveJob serializes arguments in order to
+      # serialize ActiveRecord models with GlobalID uuids instead of as_json which could give undesired artifacts
+      def serialized_arguments
+        ActiveSupport::JSON.encode(ActiveJob::Arguments.serialize(arguments))
+      end
+
+      def arguments_digest
+        digest_method.hexdigest(serialized_arguments)
+      end
+
+      def normalized_job_class_name
+        job_class_name&.underscore
+      end
+    end
+  end
+end