job_contracts 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ccfdc1005a713277b03897aaf58f87db30e04d9697e92f462c8712eeb4faf8d
-  data.tar.gz: 3f3a4d679a61701c986cd858ca259b1208a2f3d82bd94681b96e884252fb4403
+  metadata.gz: 3409ea614e4698241974af1291cac6b6e2fc0cf75c45af5d7d5ea61cde545998
+  data.tar.gz: 7a59f4f8408f9d0c7963578b411bc5425da56e7138cb35e7cd0ee938f342dc58
 SHA512:
-  metadata.gz: 41d343fa07382f35997fe9a6a75410fcfaf8f599b42cf9421349ae4084ed49c5b5467579b83fd326992c27bf4d3ec64bbb38882ee370e297d8688dcd571131c4
-  data.tar.gz: 95336d3dd5464cbb7731ce25c946f5502a7cbc2158a7ea73ef727726b9226e7d660a735351bc5260f783cf6e3ab1a6bc93adeac7c15464a81288863cd70896f9
+  metadata.gz: 6e3329c2fb4ff9a4a898c44453504259b211389f8f2d57a6a6ba1a0722da414ad843030e8c1991e79ba28dfe71abedad9ef016f130ba469a5dc37c23c441572a
+  data.tar.gz: 40be8734e8791531b7b03fde19f89697a10744ec0f77e688a091090df9a998bffd8aa3d70c95bd1e31aba024f10338a4aa7fdea712cef9f8eeaefb4beb2fbc45

data/README.md

@@ -1,12 +1,265 @@
+[![Lines of Code](http://img.shields.io/badge/lines_of_code-240-brightgreen.svg?style=flat)](http://blog.codinghorror.com/the-best-code-is-no-code-at-all/)
+[![Code Quality](https://app.codacy.com/project/badge/Grade/f604d4bc6db0474c802ef51182732488)](https://www.codacy.com/gh/hopsoft/job_contracts/dashboard?utm_source=github.com&utm_medium=referral&utm_content=hopsoft/job_contracts&utm_campaign=Badge_Grade)
+![tests](https://github.com/hopsoft/job_contracts/actions/workflows/test.yml/badge.svg)
+
 # Job Contracts
 
-## Enforceable contracts for background jobs
+## Test-like assurances for jobs
+
+Have you ever wanted to prevent a background job from writing to the database or perhaps ensure that it completes within a fixed amount of time?
+
+Contracts allow you to easily enforce guarantees like this.
+
+<!-- Tocer[start]: Auto-generated, don't remove. -->
+
+## Table of Contents
+
+  - [Why use Contracts?](#why-use-contracts)
+  - [Quick Start](#quick-start)
+  - [Contracts](#contracts)
+    - [Breach of Contract](#breach-of-contract)
+    - [Anatomy of a Contract](#anatomy-of-a-contract)
+    - [Defining a Contract](#defining-a-contract)
+    - [Using a Contract](#using-a-contract)
+  - [Worker Formation/Topology](#worker-formationtopology)
+  - [Advanced Usage](#advanced-usage)
+  - [Sidekiq](#sidekiq)
+  - [Todo](#todo)
+  - [License](#license)
+  - [Sponsors](#sponsors)
+
+<!-- Tocer[finish]: Auto-generated, don't remove. -->
+
+## Why use Contracts?
+
+- Organize your code for better reuse, consistency, and maintainability
+- Refine your telemetry and instrumentation efforts
+- Improve job performance via enforced *(SLAs/SLOs/SLIs)*
+- Monitor and manage job queue backpressure
+- Improve your worker formation/topology to support high throughput
+
+## Quick Start
+
+Imagine you want to ensure a specific job completes within 5 seconds of being enqueued.
+
+```ruby
+class ImportantJob < ApplicationJob
+  include JobContracts::Contractable
+
+  queue_as :default
+
+  add_contract JobContracts::DurationContract.new(max: 5.seconds)
+
+  def perform
+    # logic...
+  end
+
+  # default callback that's invoked if the contract is breached
+  def contract_breached!(contract)
+    # handle breach...
+  end
+end
+```
+
+*How to handle a [__breach of contract__](#breach-of-contract).*
+
+## Contracts
+
+A contract is an agreement that a job should fulfill.
+Failing to satisfy the contract is considered a __breach of contract__.
+
+Contracts help you track `actual` results and compare them to `expected` outcomes.
+For example, this project has a default set of contracts that verify the following:
+
+- That a job will [execute within a set amount of time](https://github.com/hopsoft/job_contracts/blob/main/lib/job_contracts/contracts/duration_contract.rb)
+- That a job is only [performed on a specific queue](https://github.com/hopsoft/job_contracts/blob/main/lib/job_contracts/contracts/queue_name_contract.rb)
+- That a job [does not write to the database](https://github.com/hopsoft/job_contracts/blob/main/lib/job_contracts/contracts/read_only_contract.rb)
+
+### Breach of Contract
+
+A __breach of contract__ is similar to a test failure; however, the breach can be handled in many different ways.
+
+- Log and instrument the breach and continue
+- Halt processing of the job and all other contracts and raise an exception
+- Move the job to a queue where the contract will not be enforced
+- etc...
+
+*Mix and match any combination of these options to support your requirements.*
+
+### Anatomy of a Contract
+
+Contracts support the following constructor arguments.
+
+- __`trigger`__ `[Symbol] (:before, *:after)` - when contract enforcement takes place, *before or after perform*
+- __`halt`__ `[Boolean] (true, *false)` - indicates whether or not to stop processing when the contract is breached
+- __`queues`__ `[Array<String,Symbol>]` - a list of queue names where this contract will be enforced _(defaults to the configured queue, or `*` if the queue has not beeen configured)_
+- __`expected`__ `[Hash]` - a dictionary of contract expectations
+
+### Defining a Contract
+
+Here's a contrived but simple example that ensures the first argument to perform fits within a specific range of values.
+
+```ruby
+# app/contracts/argument_contract.rb
+class ArgumentContract < JobContracts::Contract
+  def initialize(range:)
+    # enforced on all queues
+    super queues: ["*"], expected: {range: range}
+  end
+
+  def enforce!(contractable)
+    actual[:argument] = contractable.arguments.first
+    self.satisfied = expected[:range].cover?(actual[:argument])
+    super
+  end
+end
+```
+
+### Using a Contract
+
+Here's how to use the `ArgumentContract` in a job.
+
+```ruby
+# app/jobs/argument_example_job.rb
+class ArgumentExampleJob < ApplicationJob
+  include JobContracts::Contractable
+
+  queue_as :default
+  add_contract ArgumentContract.new(range: (1..10))
 
-## Todos
+  def perform(arg)
+    # logic...
+  end
 
-- [ ] Add documentation
-- [ ] Add automated tests
+  # default callback that's invoked if the contract is breached
+  def contract_breached!(contract)
+    # handle breach...
+  end
+end
+```
+
+This job will help ensure that the argument passed to perform is between 1 and 10.
+*It's up to you to determine how to handle a breach of contract.*
+
+## Worker Formation/Topology
+
+Thoughtful Rails applications often use specialized worker formations.
+
+A simple formation might be to use two sets of workers.
+One set dedicated to fast low-latency jobs with plenty of dedicated compute resources *(CPUs, processes, threads, etc...)*,
+with another set dedicated to slower jobs that uses fewer compute resources.
+
+<img width="593" alt="Untitled 2 2022-04-29 15-06-13" src="https://user-images.githubusercontent.com/32920/166069103-e316dcc7-e601-43d0-90df-ad0eda20409b.png">
+
+Say we determine that fast low-latency jobs should __not__ write to the database.
+
+We can use a [`ReadOnlyContract`](https://github.com/hopsoft/job_contracts/blob/main/lib/job_contracts/contracts/read_only_contract.rb)
+to enforce this decision. If the contract is breached, we can notify our apm/monitoring service and re-enqueue the job to a slower queue *(worker set)* where database writes are permitted.
+This will ensure that our fast low-latency queue doesn't get clogged with slow-running jobs.
+
+Here's an example job implementation that accomplishes this.
+
+```ruby
+class FastJob < ApplicationJob
+  include JobContracts::Contractable
+
+  # Configure the queue before adding contracts
+  # It will be used as the default enforcement queue for contracts
+  queue_as :critical
+
+  # Only enforces on the critical queue
+  # This allows us to halt job execution and reenqueue the job to a different queue
+  # where the contract will not be enforced
+  #
+  # NOTE: the arg `queues: [:critical]` is default behavior in this example
+  #       we're setting it explicitly here for illustration purposes
+  add_contract JobContracts::ReadOnlyContract.new(queues: [:critical])
+
+  def perform
+    # logic that shouldn't write to the database,
+    # but might accidentally due to complex or opaque internals
+  end
+
+  def contract_breached!(contract)
+    # log and notify apm/monitoring service
+
+    # re-enqueue to a different queue
+    # where the database write will be permitted
+    # i.e. where the contract will not be enforced
+    enqueue queue: :default
+  end
+end
+```
+
+*Worker formations can be designed in countless ways to handle incredibly sophisticated requirements and operational constraints.
+The only real limitation is your creativity.*
+
+## Advanced Usage
+
+It's possible to override the default callback method that handles contract breaches.
+
+```ruby
+class ImportantJob < ApplicationJob
+  include JobContracts::Contractable
+
+  queue_as :default
+
+  on_contract_breach :take_action
+  add_contract JobContracts::DurationContract.new(max: 5.seconds)
+
+  def perform
+    # logic...
+  end
+
+  def take_action(contract)
+    # handle breach...
+  end
+end
+```
+
+```ruby
+class ImportantJob < ApplicationJob
+  include JobContracts::Contractable
+
+  queue_as :default
+
+  on_contract_breach -> (contract) {
+    # take action...
+  }
+
+  add_contract JobContracts::DurationContract.new(max: 5.seconds)
+
+  def perform
+    # logic...
+  end
+end
+```
+
+## Sidekiq
+
+Sidekiq jobs/workers are supported.
+Unfortunately this support comes with a performance penalty *(i.e. additional latency)* because executing
+Sidekiq jobs don't have access to their own metadata. To get around this, we wait to find job metadata in the active
+[`WorkSet`](https://github.com/hopsoft/job_contracts/blob/main/lib/job_contracts/concerns/sidekiq_contractable.rb#L23-L25)
+which is only updated [every 5 seconds](https://github.com/mperham/sidekiq/wiki/API#workers).
+
+## Todo
+
+- [ ] Sidekiq tests
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open-source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Sponsors
+
+This project is sponsored by [Orbit.love](https://orbit.love/?utm_source=github&utm_medium=repo&utm_campaign=hopsoft&utm_content=job_contracts) *(mission control for your community)*.
+
+<a href="https://orbit.love/?utm_source=github&utm_medium=repo&utm_campaign=hopsoft&utm_content=job_contracts">
+  <img height="50" src="https://user-images.githubusercontent.com/32920/166343064-55f92cdb-c81b-4f85-80a8-167bfda73c85.png"></img>
+</a>
+
+---
+
+This effort was partly inspired by a presentation at [Sin City Ruby](https://www.sincityruby.com/) from our friends on the platform team at [Gusto](https://gusto.com/).
+Their presentation validated some of my prior solutions aimed at accomplishing similar goals and motivated me to extract that work into a GEM.

data/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "bundler/setup"
 
 require "bundler/gem_tasks"

data/lib/job_contracts/concerns/contractable.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "monitor"
+
 module JobContracts
   # Universal mixin for jobs/workers
   module Contractable
@@ -5,33 +9,43 @@ module JobContracts
 
     module Prepends
       extend ActiveSupport::Concern
+      include MonitorMixin
 
       def perform(*args)
-        should_perform = true
-        self.class.contracts_to_enforce_before_perform.each do |contract|
-          contract.enforce! self
-          should_perform = false if contract.breached? && contract.halt?
+        # fetch sidekiq job/worker metadata on main thread
+        try :sidekiq_job_metadata
+
+        halted = false
+        contracts.select(&:before?).each do |contract|
+          contract.enforce! self unless halted
+          halted = true if contract.breached? && contract.halt?
         end
-        super if should_perform
-        self.class.contracts_to_enforce_after_perform.each do |contract|
-          contract.enforce! self
+        super unless halted
+      ensure
+        # enforce after contracts in a separate thread to ensure that any perform related behavior
+        # defined in ContractablePrepends will finish executing before we invoke contract.enforce!
+        Thread.new do
+          sleep 0
+          synchronize do
+            contracts.select(&:after?).each do |contract|
+              contract.enforce! self unless halted
+            end
+          end
         end
       end
     end
 
     module ClassMethods
-      attr_reader :after_contract_breach_callback
-
-      def contracts_to_enforce_before_perform
-        @contracts_to_enforce_before_perform ||= Set.new
+      def contracts
+        @contracts ||= Set.new
       end
 
-      def contracts_to_enforce_after_perform
-        @contracts_to_enforce_after_perform ||= Set.new
+      def on_contract_breach(value = nil, &block)
+        @on_contract_breach_callback = value || block
       end
 
-      def after_contract_breach(value = nil, &block)
-        @after_contract_breach_callback = value || block
+      def on_contract_breach_callback
+        @on_contract_breach_callback ||= :contract_breached!
       end
 
       def add_contract(contract)
@@ -45,21 +59,27 @@ module JobContracts
 
         prepend JobContracts::Contractable::Prepends
 
-        if contract.trigger == :before
-          contracts_to_enforce_before_perform << contract
-        else
-          contracts_to_enforce_after_perform << contract
-        end
+        contract.queues << queue_name.to_s if contract.queues.blank? && queue_name.present?
+        contract.queues << "*" if contract.queues.blank?
+        contracts << contract
       end
     end
 
-    def after_contract_breach(contract)
-      method = self.class.after_contract_breach_callback
-      case method
-      when Proc then method.call(contract)
-      when String, Symbol then send(method, contract)
-      else raise NotImplementedError
-      end
+    delegate :contracts, to: "self.class"
+
+    def breached_contracts
+      @breached_contracts ||= Set.new
+    end
+
+    # Default callback
+    def contract_breached!
+      # noop / override in job subclasses
+    end
+
+    def on_contract_breach(contract)
+      breached_contracts << contract
+      method = self.class.on_contract_breach_callback
+      method.is_a?(Proc) ? method.call(contract) : send(method.to_s, contract)
     end
   end
 end

data/lib/job_contracts/concerns/sidekiq_contractable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "contractable"
 
 module JobContracts
@@ -6,41 +8,54 @@ module JobContracts
     extend ActiveSupport::Concern
     include Contractable
 
-    class MetadataNotFoundError < StandardError; end
+    class SidekiqJobMetadataNotFoundError < StandardError; end
 
-    def metadata
-      hit = nil
-      begin
-        attempts ||= 1
-        hit = Sidekiq::WorkSet.new.find do |_pid, _tid, work|
-          work.dig("payload", "jid") == jid
-        end
-        raise MetadataNotFoundError if hit.blank?
-      rescue MetadataNotFoundError
-        # The WorkSet only updates every 5 seconds
-        # SEE: https://github.com/mperham/sidekiq/wiki/API#workers
-        # Re-attempt up to 10 times with a simple backoff strategy (up to 5.5 seconds)
-        # TODO: Is there a faster and more reliable way to fetch the job's metadata after perform has begun?
-        #       May need to query Redis directly if the data is still in there at this point
-        attempts += 1
-        if attempts <= 10
-          sleep 0.1 * attempts
-          retry
-        end
+    module ClassMethods
+      def queue_name
+        sidekiq_options_hash["queue"]
       end
+    end
+
+    def sidekiq_job_metadata
+      @sidekiq_job_metadata ||= begin
+        hit = nil
+        begin
+          attempts ||= 1
+          hit = Sidekiq::Workers.new.find do |_process_id, _thread_id, work|
+            work.dig("payload", "jid") == jid
+          end
+          raise SidekiqJobMetadataNotFoundError if hit.blank?
+        rescue SidekiqJobMetadataNotFoundError
+          # The WorkSet only updates every 5 seconds
+          # SEE: https://github.com/mperham/sidekiq/wiki/API#workers
+          # Re-attempt up to 10 times with a simple backoff strategy (up to 5.5 seconds)
+          # TODO: Is there a faster and more reliable way to fetch the job's metadata after perform has begun?
+          #       May need to query Redis directly if the data is still in there at this point
+          attempts += 1
+          if attempts <= 10
+            sleep 0.1 * attempts
+            retry
+          end
+        end
 
-      hit&.last || {}
+        hit&.last || {}
+      end
     end
 
     # Matches the ActiveJob API
     def queue_name
-      metadata["queue"]
+      sidekiq_job_metadata["queue"]
     end
 
     # Matches the ActiveJob API
     def enqueued_at
-      seconds = metadata.dig("payload", "enqueued_at")
+      seconds = sidekiq_job_metadata.dig("payload", "enqueued_at")
       (seconds ? Time.at(seconds) : nil)&.iso8601.to_s
     end
+
+    # Matches the ActiveJob API
+    def arguments
+      sidekiq_job_metadata.dig("payload", "args") || []
+    end
   end
 end

data/lib/job_contracts/contracts/contract.rb

@@ -1,29 +1,38 @@
+# frozen_string_literal: true
+
 require "observer"
 
 module JobContracts
   class Contract
     include Observable
 
-    attr_reader :trigger
+    attr_reader :trigger, :queues
 
-    def initialize(trigger: :after, halt: false, **kwargs)
+    def initialize(trigger: :after, halt: false, queues: [], expected: {})
       @trigger = trigger.to_sym
       @halt = halt
-      expect.merge! kwargs
+      @queues = Set.new(queues.map(&:to_s))
+      self.expected.merge! expected
     end
 
-    def expect
-      @expect ||= HashWithIndifferentAccess.new
+    def expected
+      @expected ||= HashWithIndifferentAccess.new
     end
 
     def actual
       @actual ||= HashWithIndifferentAccess.new
     end
 
+    def should_enforce?(contractable)
+      return true if queues.include?("*")
+      queues.include? contractable.queue_name.to_s
+    end
+
     # Method to be implemented by subclasses
     # NOTE: subclasses should update `actual`, set `satisfied`, and call `super`
     def enforce!(contractable)
-      add_observer contractable, :after_contract_breach
+      return unless should_enforce?(contractable)
+      add_observer contractable, :on_contract_breach
       changed if breached?
       notify_observers self
     ensure
@@ -42,6 +51,25 @@ module JobContracts
       !!@halt
     end
 
+    def before?
+      trigger == :before
+    end
+
+    def after?
+      trigger == :after
+    end
+
+    def to_h
+      HashWithIndifferentAccess.new(
+        name: self.class.name,
+        trigger: trigger,
+        halt: halt?,
+        queues: queues.to_a,
+        expected: expected,
+        actual: actual
+      )
+    end
+
     protected
 
     attr_accessor :satisfied

data/lib/job_contracts/contracts/duration_contract.rb

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 require_relative "contract"
 
 module JobContracts
   class DurationContract < Contract
-    def initialize(duration:)
-      super
+    def initialize(max:, queues: ["*"])
+      super queues: queues, expected: {max: max}
     end
 
     def enforce!(contractable)
       actual[:duration] = (Time.current - Time.parse(contractable.enqueued_at)).seconds
-      self.satisfied = actual[:duration] < expect[:duration].seconds
+      self.satisfied = actual[:duration] < expected[:max].seconds
       super
     end
   end

data/lib/job_contracts/contracts/queue_name_contract.rb

@@ -1,15 +1,21 @@
+# frozen_string_literal: true
+
 require_relative "contract"
 
 module JobContracts
   class QueueNameContract < Contract
     def initialize(queue_name:)
-      super trigger: :before, halt: true, queue_name: queue_name
+      super(
+        trigger: :before,
+        halt: true,
+        queues: ["*"],
+        expected: {queue_name: queue_name.to_s}
+      )
     end
 
     def enforce!(contractable)
-      queue_name = contractable.queue_name
-      actual[:queue_name] = queue_name
-      self.satisfied = queue_name.to_s == expect[:queue_name].to_s
+      actual[:queue_name] = contractable.queue_name.to_s
+      self.satisfied = contractable.queue_name.to_s == expected[:queue_name]
       super
     end
   end

data/lib/job_contracts/contracts/read_only_contract.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "contract"
 
 module JobContracts
@@ -6,7 +8,12 @@ module JobContracts
       extend ActiveSupport::Concern
 
       def perform(*args)
-        ActiveRecord::Base.while_preventing_writes do
+        contract = contracts.find { |c| c.is_a?(ReadOnlyContract) }
+        if contract.should_enforce?(self)
+          ActiveRecord::Base.while_preventing_writes do
+            super
+          end
+        else
           super
         end
       rescue ActiveRecord::ReadOnlyError => error
@@ -21,11 +28,8 @@ module JobContracts
       end
     end
 
-    # def initialize
-    # super trigger: :before
-    # end
-
     def enforce!(contractable)
+      self.satisfied = true
       if contractable.read_only_error.present?
         actual[:error] = contractable.read_only_error.message
         self.satisfied = false

data/lib/job_contracts/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobContracts
   class Railtie < ::Rails::Railtie
   end

data/lib/job_contracts/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module JobContracts
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/job_contracts.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "job_contracts/version"
 require "job_contracts/railtie"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: job_contracts
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Nathan Hopkins
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-22 00:00:00.000000000 Z
+date: 2022-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -52,7 +52,63 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.10.0
-description: Enforceable contracts for background jobs
+- !ruby/object:Gem::Dependency
+  name: magic_frozen_string_literal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-doc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tocer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Enforceable contracts for jobs
 email:
 - natehop@gmail.com
 executables: []
@@ -93,8 +149,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
-summary: Enforceable contracts for background jobs
+summary: Enforceable contracts for jobs
 test_files: []