async-background 0.6.2 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1890dfac1632afedbbb20c367d4d770c3037f6201bb6fac77396f07481df477
-  data.tar.gz: 1b435f70b2fd290bd569c0c081d19ae94250a181367ada7d3b4d157c213fd5b8
+  metadata.gz: a8f8593628f08094cc53b6c69eff34e3a4be9e8c12de5bd72f1447857aab2682
+  data.tar.gz: e9e441eb2b6f775cd52d2704c8a2b24d9ac771a24beb07d33f78d81285d41f1c
 SHA512:
-  metadata.gz: 0e9c2398241b48d0cc8fe66ed0b227cca3c93a5969e7f753c0a8dbb08a41462626d73709ae9eece1a254f8567f4a9044958e96a2658a77ab8f6b11bbdb6a1c14
-  data.tar.gz: 702016f46a3bbaa255735defcc2746baafe66a26400d2ad9525b80d89848970143998a706ceb4644519433cfcd558d9936c0caae4f968e335a2f8b8496afdec1
+  metadata.gz: 194c82e280d24821e756849cc9f3f74db8cbadc424d4984fb3a58d10d21864cbe13b1adfa84aa3bf1bd6b9996d59e1d423d5c865c2d1ec33846679ed2ab936f0
+  data.tar.gz: 518bc2a692d0ade6ea02ff18ebca2a3078e02365ffd77fe9850d8bccc64b7243ea871efeec2913f33fe7ecdaeb8fa6a56067e57f36d5852adf59302cc656416e

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.7.1
+
+### Features
+- **Tunable `Store` options via `StoreOptions`** — three knobs exposed for SQLite tuning, validated at construction time so misconfigurations fail fast at boot:
+  - `mmap` (`true`/`false`, default `true`) — toggle memory-mapped I/O
+  - `synchronous` (`:normal`/`:full`/`:extra`, default `:normal`) — durability vs throughput
+  - `wal_autocheckpoint` (`Integer` in `100..10_000`, default `1_000`) — WAL checkpoint frequency in pages
+
+  Range and enum validation prevent foot-guns (e.g. `wal_autocheckpoint: 100_000` would bloat WAL beyond `journal_size_limit`). See [Get Started → Store tuning](docs/GET_STARTED.md) for trade-offs of each knob
+
+### Breaking changes
+- `Store.new(path:, mmap:)` → `Store.new(path:, options: { mmap: ... })`. Direct `mmap:` keyword argument removed in favor of the unified `options:` hash. Users who construct `Store` manually (e.g. for web-worker enqueue) need to update the call site
+
 ## 0.6.2
 
 ### Features

data/lib/async/background/job.rb

@@ -4,9 +4,48 @@ module Async
   module Background
     module Job
       DEFAULT_TIMEOUT = 120
+      BACKOFFS        = %i[fixed linear exponential].freeze
+      DEFAULT_JITTER_FOR = { fixed: 0.0, linear: 0.0, exponential: 0.5 }.freeze
 
-      Options = Data.define(:timeout) do
-        def initialize(timeout: DEFAULT_TIMEOUT) = super(timeout: Integer(timeout))
+      Options = Data.define(:timeout, :retry, :retry_delay, :backoff, :attempt, :jitter) do
+        def initialize(timeout: DEFAULT_TIMEOUT, retry: 0, retry_delay: nil, backoff: :fixed, attempt: nil, jitter: nil)
+          timeout     = Integer(timeout)
+          retries     = Integer(binding.local_variable_get(:retry) || 0)
+          retry_delay = Float(retry_delay) unless retry_delay.nil?
+          backoff     = backoff.to_sym
+          attempt     = Integer(attempt) unless attempt.nil?
+          jitter      = Float(jitter) unless jitter.nil?
+
+          raise ArgumentError, "timeout must be > 0"                        unless timeout.positive?
+          raise ArgumentError, "retry must be >= 0"                         if     retries.negative?
+          raise ArgumentError, "attempt must be >= 0"                       if     attempt && attempt.negative?
+          raise ArgumentError, "backoff must be one of #{BACKOFFS.inspect}" unless BACKOFFS.include?(backoff)
+          if retries.positive?
+            raise ArgumentError, "retry_delay is required when retry > 0" if retry_delay.nil?
+            raise ArgumentError, "retry_delay must be > 0"                unless retry_delay.positive?
+          end
+          raise ArgumentError, "jitter must be in [0, 1]" if jitter && !(0.0..1.0).cover?(jitter)
+
+          super(timeout:, retry: retries, retry_delay:, backoff:, attempt:, jitter:)
+        end
+
+        def retry?          = self.retry.positive?
+        def attempts_made   = attempt || 0
+        def next_attempt    = attempts_made + 1
+        def with_attempt(n) = with(attempt: Integer(n))
+        def next_retry_delay(for_attempt = next_attempt, rng: Random)
+          raise ArgumentError, "attempt must be > 0" unless for_attempt.positive?
+          raise ArgumentError, "retry_delay must be configured" if retry_delay.nil?
+
+          base = case backoff
+          when :fixed       then retry_delay
+          when :linear      then retry_delay * for_attempt
+          when :exponential then retry_delay * (2**(for_attempt - 1))
+          end
+
+          factor = jitter || DEFAULT_JITTER_FOR[backoff]
+          factor.zero? ? base : base * (1 + rng.rand * factor)
+        end
       end
 
       def self.included(base)
@@ -14,30 +53,20 @@ module Async
       end
 
       module ClassMethods
-        def perform_now(*args)
-          new.perform(*args)
-        end
-
-        def perform_async(*args, options: {})
-          Async::Background::Queue.enqueue(self, *args, options: options)
-        end
+        def perform_now(*args) = new.perform(*args)
 
-        def perform_in(delay, *args, options: {})
-          Async::Background::Queue.enqueue_in(delay, self, *args, options: options)
-        end
-
-        def perform_at(time, *args, options: {})
-          Async::Background::Queue.enqueue_at(time, self, *args, options: options)
-        end
+        def perform_async(*args, options: {})     = Async::Background::Queue.enqueue(self, *args, options: options)
+        def perform_in(delay, *args, options: {}) = Async::Background::Queue.enqueue_in(delay, self, *args, options: options)
+        def perform_at(time, *args, options: {})  = Async::Background::Queue.enqueue_at(time, self, *args, options: options)
 
         def options(**values)
-          @options = Options.new(**values).to_h
+          @options = Options.new(**values).to_h.compact
         end
 
         def resolve_options = @options || {}
       end
 
-      def perform(*args)
+      def perform(*)
         raise NotImplementedError, "#{self.class} must implement #perform"
       end
     end

data/lib/async/background/queue/client.rb

@@ -22,8 +22,7 @@ module Async
         end
 
         def push_in(delay, class_name, args = [], options: {})
-          run_at = realtime_now + delay.to_f
-          push(class_name, args, run_at, options: options)
+          push(class_name, args, realtime_now + delay.to_f, options: options)
         end
 
         def push_at(time, class_name, args = [], options: {})
@@ -37,29 +36,36 @@ module Async
 
         def enqueue(job_class, *args, options: {})
           ensure_configured!
-          merged = build_options(job_class, options)
-          default_client.push(resolve_class_name(job_class), args, nil, options: merged)
+          default_client.push(resolve_class_name(job_class), args, nil, options: build_options(job_class, options))
         end
 
         def enqueue_in(delay, job_class, *args, options: {})
           ensure_configured!
-          merged = build_options(job_class, options)
-          default_client.push_in(delay, resolve_class_name(job_class), args, options: merged)
+          default_client.push_in(delay, resolve_class_name(job_class), args, options: build_options(job_class, options))
         end
 
         def enqueue_at(time, job_class, *args, options: {})
           ensure_configured!
-          merged = build_options(job_class, options)
-          default_client.push_at(time, resolve_class_name(job_class), args, options: merged)
+          default_client.push_at(time, resolve_class_name(job_class), args, options: build_options(job_class, options))
         end
 
         private
 
-        def build_options(job_class, call_site_options)
-          merged = resolve_options(job_class).merge!(call_site_options.compact)
-          return EMPTY_OPTIONS if merged.empty?
+        RETRY_KEYS = %i[retry retry_delay backoff jitter].freeze
+        private_constant :RETRY_KEYS
+
+        def build_options(job_class, call_site)
+          call_site ||= {}
+          merged = resolve_options(job_class).merge(call_site.compact)
+          apply_retry_overrides!(merged, call_site)
+
+          merged.empty? ? EMPTY_OPTIONS : Job::Options.new(**merged).to_h.compact
+        end
+
+        def apply_retry_overrides!(merged, call_site)
+          return unless RETRY_KEYS.any? { |k| call_site.key?(k) && !call_site[k].nil? }
 
-          Job::Options.new(**merged).to_h
+          RETRY_KEYS.each { |k| merged[k] = call_site[k] if call_site.key?(k) }
         end
 
         def ensure_configured!

data/lib/async/background/queue/store.rb

@@ -6,6 +6,49 @@ require_relative '../clock'
 module Async
   module Background
     module Queue
+      SYNCHRONOUS_LEVELS = { normal: 'NORMAL', full: 'FULL', extra: 'EXTRA' }.freeze
+      WAL_AUTOCHECKPOINT_RANGE = 100..10_000
+      DEFAULTS = { mmap: true, synchronous: :normal, wal_autocheckpoint: 1_000 }.freeze
+      MMAP_SIZE = 268_435_456
+
+      StoreOptions = Data.define(:mmap, :synchronous, :wal_autocheckpoint) do
+        def self.build(value = {}) = value.is_a?(self) ? value : new(**DEFAULTS, **value)
+
+        def initialize(mmap:, synchronous:, wal_autocheckpoint:)
+          unless mmap == true || mmap == false
+            raise ArgumentError, "mmap must be true or false, got #{mmap.inspect}"
+          end
+
+          unless SYNCHRONOUS_LEVELS.key?(synchronous)
+            raise ArgumentError,
+              "synchronous must be one of #{SYNCHRONOUS_LEVELS.keys.inspect}, got #{synchronous.inspect}"
+          end
+
+          unless wal_autocheckpoint.is_a?(Integer) && WAL_AUTOCHECKPOINT_RANGE.cover?(wal_autocheckpoint)
+            raise ArgumentError,
+              "wal_autocheckpoint must be an Integer in #{WAL_AUTOCHECKPOINT_RANGE}, " \
+              "got #{wal_autocheckpoint.inspect}"
+          end
+
+          super
+        end
+
+        def synchronous_pragma = SYNCHRONOUS_LEVELS.fetch(synchronous)
+        def mmap_size = mmap ? MMAP_SIZE : 0
+
+        def pragma_sql
+          <<~SQL
+            PRAGMA journal_mode       = WAL;
+            PRAGMA synchronous        = #{synchronous_pragma};
+            PRAGMA mmap_size          = #{mmap_size};
+            PRAGMA cache_size         = -16000;
+            PRAGMA temp_store         = MEMORY;
+            PRAGMA journal_size_limit = 67108864;
+            PRAGMA wal_autocheckpoint = #{wal_autocheckpoint};
+          SQL
+        end
+      end
+
       class Store
         include Clock
 
@@ -25,29 +68,16 @@ module Async
           CREATE INDEX IF NOT EXISTS idx_jobs_pending ON jobs(run_at, id) WHERE status = 'pending';
         SQL
 
-        MMAP_SIZE = 268_435_456
-        PRAGMAS = ->(mmap_size) {
-          <<~SQL
-            PRAGMA journal_mode       = WAL;
-            PRAGMA synchronous        = NORMAL;
-            PRAGMA mmap_size          = #{mmap_size};
-            PRAGMA cache_size         = -16000;
-            PRAGMA temp_store         = MEMORY;
-            PRAGMA busy_timeout       = 5000;
-            PRAGMA journal_size_limit = 67108864;
-          SQL
-        }.freeze
-
         CLEANUP_INTERVAL = 300
         CLEANUP_AGE      = 3600
 
-        attr_reader :path
+        attr_reader :path, :options
 
-        def initialize(path: self.class.default_path, mmap: true)
-          @path = path
-          @mmap = mmap
-          @pragma_sql = PRAGMAS.call(mmap ? MMAP_SIZE : 0).freeze
-          @db   = nil
+        def initialize(path: self.class.default_path, options: {})
+          @path           = path
+          @options        = StoreOptions.build(options)
+          @pragma_sql     = @options.pragma_sql.freeze
+          @db             = nil
           @schema_checked = false
           @last_cleanup_at = nil
         end
@@ -55,8 +85,7 @@ module Async
         def ensure_database!
           require_sqlite3
           db = SQLite3::Database.new(@path)
-          db.execute('PRAGMA busy_timeout = 5000')
-          db.execute_batch(@pragma_sql)
+          configure_database(db)
           db.execute_batch(SCHEMA)
           db.execute("PRAGMA wal_checkpoint(TRUNCATE)")
           db.close
@@ -65,34 +94,22 @@ module Async
 
         def enqueue(class_name, args = [], run_at = nil, options: {})
           ensure_connection
-          run_at ||= realtime_now
-          options_json = options.empty? ? nil : JSON.generate(options)
-          @enqueue_stmt.execute(class_name, JSON.generate(args), options_json, realtime_now, run_at)
+          now = realtime_now
+          @enqueue_stmt.execute(class_name, JSON.generate(args), dump_options(options), now, run_at || now)
           @db.last_insert_row_id
         end
 
         def fetch(worker_id)
           ensure_connection
           now = realtime_now
-          @db.execute("BEGIN IMMEDIATE")
-
-          begin
-            results = @fetch_stmt.execute(worker_id, now, now)
-            row = results.first
-          ensure
-            @fetch_stmt.reset! rescue nil
-          end
 
-          @db.execute("COMMIT")
+          row = transaction { with_stmt(@fetch_stmt) { |s| s.execute(worker_id, now, now).first } }
           return unless row
 
           maybe_cleanup
-          options = row[3] ? JSON.parse(row[3], symbolize_names: true) : {}
-          { id: row[0], class_name: row[1], args: JSON.parse(row[2]), options: options }
-        rescue
-          @db.execute("ROLLBACK") rescue nil
-          raise
+          { id: row[0], class_name: row[1], args: JSON.parse(row[2]), options: load_options(row[3]) }
         end
+
         def complete(job_id)
           ensure_connection
           @complete_stmt.execute(job_id)
@@ -103,6 +120,24 @@ module Async
           @fail_stmt.execute(job_id)
         end
 
+        def retry_or_fail(job_id, fallback_options: nil)
+          ensure_connection
+
+          transaction do
+            stored = with_stmt(@retry_state_stmt) { |s| load_options(s.execute(job_id).first&.first) }
+            policy = stored.empty? ? normalize_options(fallback_options) : Job::Options.new(**stored)
+
+            if policy&.retry? && policy.next_attempt <= policy.retry
+              advanced = policy.with_attempt(policy.next_attempt)
+              @retry_stmt.execute(realtime_now + advanced.next_retry_delay(advanced.attempt), dump_options(advanced.to_h.compact), job_id)
+              :retried
+            else
+              @fail_stmt.execute(job_id)
+              :failed
+            end
+          end
+        end
+
         def recover(worker_id)
           ensure_connection
           @requeue_stmt.execute(worker_id)
@@ -138,8 +173,7 @@ module Async
           require_sqlite3
           finalize_statements
           @db = SQLite3::Database.new(@path)
-          @db.execute('PRAGMA busy_timeout = 5000')
-          @db.execute_batch(@pragma_sql)
+          configure_database(@db)
 
           unless @schema_checked
             @db.execute_batch(SCHEMA)
@@ -151,6 +185,42 @@ module Async
           @last_cleanup_at = monotonic_now
         end
 
+        def configure_database(db)
+          db.execute("PRAGMA busy_timeout = 5000")
+          db.execute_batch(@pragma_sql)
+        end
+
+        def transaction
+          @db.execute("BEGIN IMMEDIATE")
+          result = yield
+          @db.execute("COMMIT")
+          result
+        rescue
+          @db.execute("ROLLBACK") rescue nil
+          raise
+        end
+
+        def with_stmt(stmt)
+          yield stmt
+        ensure
+          stmt.reset! rescue nil
+        end
+
+        def dump_options(options)
+          options.empty? ? nil : JSON.generate(options)
+        end
+
+        def load_options(json)
+          json ? JSON.parse(json, symbolize_names: true) : {}
+        end
+
+        def normalize_options(options)
+          return if options.nil?
+          return options if options.is_a?(Job::Options)
+
+          Job::Options.new(**options)
+        end
+
         def prepare_statements
           @enqueue_stmt = @db.prepare(
             "INSERT INTO jobs (class_name, args, options, created_at, run_at) VALUES (?, ?, ?, ?, ?)"
@@ -168,23 +238,27 @@ module Async
             RETURNING id, class_name, args, options
           SQL
 
-          @complete_stmt = @db.prepare("UPDATE jobs SET status = 'done' WHERE id = ?")
-          @fail_stmt     = @db.prepare("UPDATE jobs SET status = 'failed' WHERE id = ?")
-
+          @complete_stmt    = @db.prepare("UPDATE jobs SET status = 'done',   locked_by = NULL, locked_at = NULL WHERE id = ?")
+          @fail_stmt        = @db.prepare("UPDATE jobs SET status = 'failed', locked_by = NULL, locked_at = NULL WHERE id = ?")
+          @retry_state_stmt = @db.prepare("SELECT options FROM jobs WHERE id = ?")
+          @retry_stmt       = @db.prepare(
+            "UPDATE jobs SET status = 'pending', locked_by = NULL, locked_at = NULL, run_at = ?, options = ? WHERE id = ?"
+          )
           @requeue_stmt = @db.prepare(
             "UPDATE jobs SET status = 'pending', locked_by = NULL, locked_at = NULL " \
             "WHERE status = 'running' AND locked_by = ?"
           )
-
           @cleanup_stmt = @db.prepare("DELETE FROM jobs WHERE status = 'done' AND created_at < ?")
         end
 
         def finalize_statements
-          [@enqueue_stmt, @fetch_stmt, @complete_stmt, @fail_stmt, @requeue_stmt, @cleanup_stmt].each do |s|
-            s&.close rescue next
+          [@enqueue_stmt, @fetch_stmt, @complete_stmt, @fail_stmt,
+           @retry_state_stmt, @retry_stmt, @requeue_stmt, @cleanup_stmt].each do |stmt|
+            stmt&.close rescue next
           end
 
-          @enqueue_stmt = @fetch_stmt = @complete_stmt = @fail_stmt = @requeue_stmt = @cleanup_stmt = nil
+          @enqueue_stmt = @fetch_stmt = @complete_stmt = @fail_stmt = nil
+          @retry_state_stmt = @retry_stmt = @requeue_stmt = @cleanup_stmt = nil
         end
 
         def maybe_cleanup
@@ -193,10 +267,7 @@ module Async
 
           @last_cleanup_at = now
           @cleanup_stmt.execute(realtime_now - CLEANUP_AGE)
-
-          if @db.changes > 100
-            @db.execute("PRAGMA incremental_vacuum")
-          end
+          @db.execute("PRAGMA incremental_vacuum") if @db.changes > 100
         end
       end
     end

data/lib/async/background/runner.rb

@@ -69,18 +69,17 @@ module Async
         @listen_queue = false
         return unless queue_socket_dir
 
-        # Lazy require — only loaded when queue is actually used
+        isolated = ENV.fetch("ISOLATION_FORKS", "").split(",").map(&:to_i)
+        return if isolated.include?(worker_index)
+
         require_relative 'queue/store'
         require_relative 'queue/socket_waker'
         require_relative 'queue/client'
 
-        isolated = ENV.fetch("ISOLATION_FORKS", "").split(",").map(&:to_i)
-        return if isolated.include?(worker_index)
-
         @listen_queue = true
         @queue_store  = Queue::Store.new(
-          path: queue_db_path || Queue::Store.default_path,
-          mmap: queue_mmap
+          path:    queue_db_path || Queue::Store.default_path,
+          options: { mmap: queue_mmap }
         )
 
         socket_path = File.join(queue_socket_dir, "async_bg_worker_#{worker_index}.sock")
@@ -112,40 +111,55 @@ module Async
 
       def run_queue_job(job_task, job)
         class_name = job[:class_name]
-        args       = job[:args]
         klass      = resolve_job_class(class_name)
-        opts       = Job::Options.new(**job[:options])
-        timeout    = opts.timeout
+        options    = parse_job_options(job[:options])
 
         metrics.job_started(nil)
-        t = monotonic_now
-
-        job_task.with_timeout(timeout) { klass.perform_now(*args) }
+        started = monotonic_now
+        job_task.with_timeout(options.timeout) { klass.perform_now(*job[:args]) }
+        duration = monotonic_now - started
 
-        duration = monotonic_now - t
         metrics.job_finished(nil, duration)
         @queue_store.complete(job[:id])
-
-        logger.info('Async::Background') {
-          "queue(#{class_name}): completed in #{duration.round(2)}s"
-        }
+        logger.info('Async::Background') { "queue(#{class_name}): completed in #{duration.round(2)}s" }
+      rescue ConfigError => e
+        metrics.job_failed(nil, e) if options
+        @queue_store.fail(job[:id])
+        logger.error('Async::Background') { "queue(#{class_name}): #{e.class} #{e.message}" }
       rescue ::Async::TimeoutError
         metrics.job_timed_out(nil)
-        @queue_store.fail(job[:id])
-        logger.error('Async::Background') { "queue(#{class_name}): timed out after #{timeout}s" }
+        handle_queue_failure(job, options, "timed out after #{options.timeout}s", backtrace: nil)
       rescue => e
         metrics.job_failed(nil, e)
-        @queue_store.fail(job[:id])
-        logger.error('Async::Background') {
-          "queue(#{class_name}): #{e.class} #{e.message}\n#{e.backtrace.join("\n")}"
-        }
+        handle_queue_failure(job, options, "#{e.class} #{e.message}", backtrace: e.backtrace)
+      end
+
+      def parse_job_options(raw)
+        Job::Options.new(**(raw || {}))
+      rescue ArgumentError, TypeError => e
+        raise ConfigError, "invalid queue options: #{e.message}"
+      end
+
+      def handle_queue_failure(job, options, message, backtrace:)
+        result = @queue_store.retry_or_fail(job[:id], fallback_options: options)
+        class_name = job[:class_name]
+
+        if result == :retried
+          @queue_waker&.signal
+          attempt = options.next_attempt
+          logger.warn('Async::Background') do
+            "queue(#{class_name}): #{message}; retry #{attempt}/#{options.retry}"
+          end
+        else
+          tail = backtrace ? "\n#{backtrace.join("\n")}" : ''
+          logger.error('Async::Background') { "queue(#{class_name}): #{message}#{tail}" }
+        end
       end
 
       def resolve_job_class(class_name)
-        raise ConfigError, "empty class name in queue job" if class_name.nil? || class_name.strip.empty?
+        raise ConfigError, "empty class name in queue job" if class_name.nil? || class_name.to_s.strip.empty?
 
-        names = class_name.split("::")
-        klass = names.reduce(Object) do |mod, name|
+        klass = class_name.split("::").reduce(Object) do |mod, name|
           raise ConfigError, "unknown class: #{class_name}" unless mod.const_defined?(name, false)
           mod.const_get(name, false)
         end
@@ -259,14 +273,12 @@ module Async
         class_name = config&.dig('class').to_s.strip
         raise ConfigError, "[#{name}] missing class" if class_name.empty?
 
-        begin
-          job_class = Object.const_get(class_name)
-        rescue NameError
-          raise ConfigError, "[#{name}] unknown class: #{class_name}"
+        job_class = begin
+          resolve_job_class(class_name)
+        rescue ConfigError => e
+          raise ConfigError, "[#{name}] #{e.message}"
         end
 
-        raise ConfigError, "[#{name}] #{class_name} must include Async::Background::Job" unless job_class.respond_to?(:perform_now)
-
         interval = config['every']&.then { |v|
           int = v.to_i
           raise ConfigError, "[#{name}] 'every' must be > 0" unless int.positive?
@@ -279,12 +291,13 @@ module Async
 
         raise ConfigError, "[#{name}] specify 'every' or 'cron'" unless interval || cron
 
-        {
-          job_class: job_class,
-          interval: interval,
-          cron: cron,
-          timeout: config.fetch('timeout', DEFAULT_TIMEOUT).to_i
-        }
+        timeout = begin
+          Job::Options.new(timeout: config.fetch('timeout', DEFAULT_TIMEOUT)).timeout
+        rescue ArgumentError, TypeError => e
+          raise ConfigError, "[#{name}] #{e.message}"
+        end
+
+        { job_class: job_class, interval: interval, cron: cron, timeout: timeout }
       end
 
       def run_job(job_task, entry)

data/lib/async/background/version.rb

@@ -2,6 +2,6 @@
 
 module Async
   module Background
-    VERSION = '0.6.2'
+    VERSION = '0.7.1'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: async-background
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.1
 platform: ruby
 authors:
 - Roman Hajdarov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-16 00:00:00.000000000 Z
+date: 2026-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async