schked 1.4.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a45abd806085b8336543dfff30a298b8f1148e0ee0642cd4896b8e6f5a721c3
-  data.tar.gz: b2d6030f651c9a86e573038c88a30f26efbd6bc840ff212aab9baa5cbb3b4fab
+  metadata.gz: de7c669767af942f29f4c3414334cc7e996d8d41c3e9375ef2a249cc7ccc3b22
+  data.tar.gz: a55cb9f96f1eb18d43452ad0e61ec1d722c51d316f4e6b6604d7627b82aaaa2c
 SHA512:
-  metadata.gz: 8a13bb8431aaf97845d49c92e8410dc65d8a3308cb34ce129ce060c3dea5673fbc254c3bdcb461a1e4049020d71dbd16894fd0fe25be1fd53faab491b0077f36
-  data.tar.gz: 18289f5de7000436ebfc4249b3b2de3781dcf61873c94442d93584f3e362652bcef7ede7ba4e08355692f3a4d479cd149579ca19b3c99360c632787defdf23e9
+  metadata.gz: 5691b00d0cd7b9575e82a743b45c7e0210593f34648a2bf1d98f7b387538805a9acea000f63724f6a31b81ce6b21a7825919b975023de04e46285eb009788ea8
+  data.tar.gz: 9184dd5c9190dff9f43c3534487fb4d38b6355fdd93b66d61b859f30dfc9c95d4d469d1298bb2f7f314a824ae577943835cfc530d5ff4dd3646e239a6f75b1ff

data/README.md

@@ -30,9 +30,9 @@ gem install schked
 
 ## Supported Ruby and Rails versions
 
-Schked requires **Ruby 2.7+**.
+Schked requires **Ruby 3.0+**.
 
-The test matrix covers Ruby **2.7, 3.0, 3.1, 3.2, 3.3, 3.4, and 4.0**. Rails integration tests run on every Ruby; Rails 8 is only included on Ruby **3.2+**.
+The test matrix covers Ruby **3.0, 3.1, 3.2, 3.3, 3.4, and 4.0**. Rails integration tests run on every Ruby; Rails 8 is only included on Ruby **3.2+**.
 
 ## Usage
 
@@ -80,7 +80,11 @@ bundle exec schked show
 
 ### Duplicate scheduling
 
-When you deploy your schedule to production, you want to start new instance before you shut down the current. And you don't want simultaneous working of both. To achieve a seamless transition, Schked is using Redis for locks.
+Schked ships two coordination strategies for multi-instance deployments. Choose one via `Schked.config.job_run_store`:
+
+#### Single-active-instance (default)
+
+When you deploy your schedule to production, you want to start new instance before you shut down the current. And you don't want simultaneous working of both. To achieve a seamless transition, Schked uses Redis for a global lock.
 
 You can configure Redis client as the following:
 
@@ -88,6 +92,67 @@ You can configure Redis client as the following:
 Schked.config.redis = {url: ENV.fetch("REDIS_URL") }
 ```
 
+This is the default — one instance runs all jobs; standby instances hold the global Redis lock and stay idle. This strategy will continue to be supported because it is the simplest and most predictable for many setups.
+
+#### Per-job deduplication
+
+When you want every scheduler instance to do useful work (and not require a global leader), opt into the per-job deduplication mode. Each recurring job claims its schedule interval atomically; only one instance wins each interval, so each job still runs exactly once across the cluster.
+
+Pick a coordination store:
+
+```ruby
+# Redis-backed (default Redis client from Schked.config.redis):
+Schked.config.job_run_store = :redis
+
+# Database-backed (no Redis required). The ActiveRecord or Sequel
+# connection pool is auto-detected; override via:
+Schked.config.job_run_store = :database
+Schked.config.database_connection = conn   # optional: Sequel::Database, ActiveRecord pool, or AR connection (PostgreSQL, Mysql2, or Trilogy)
+
+# Custom store responding to #claim(job_name, window_start) and #cleanup(older_than):
+Schked.config.job_run_store = my_store
+```
+
+The database backend runs entirely through the ActiveRecord/Sequel connection pool: claims and the internal cleanup sweep check connections out per operation, so they are thread-safe and survive database restarts and failovers. MySQL 8.0+ is required for the MySQL DDL.
+
+Additional tuning:
+
+```ruby
+Schked.config.max_skew = 60  # max expected clock skew between instances (seconds)
+```
+
+Schedule behavior in deduplication mode:
+
+- `every` jobs are aligned to an absolute time grid so all instances share the same phase. The first firing is the next grid point relative to now — not relative to process start.
+- `cron` jobs already align to absolute time natively and need no change.
+- `at` / `in` (one-time) jobs are deduplicated too — the claim is kept for the store's retention period (the Redis TTL / the database sweep window).
+- `interval` jobs **are not supported** and raise `Schked::ScheduleDSL::IntervalNotSupportedError` when scheduled in this mode. Their phase depends on job duration and cannot be grid-aligned. Use `every` or `cron` instead.
+
+##### Durability of the coordination store
+
+Choosing between `:redis` and `:database` is also choosing how strong the exactly-once guarantee is:
+
+- **`:database`** — claims are durable rows guarded by a UNIQUE constraint. They survive database restarts and failovers, and nothing removes them before the internal cleanup sweep (which keeps rows for 24 hours). Prefer this backend when a duplicate run is unacceptable.
+- **`:redis`** — claims are keys with a TTL of `max(10 × max_skew, 1 hour)`, so the guarantee is only as strong as the Redis instance's durability:
+  - **Eviction policy** must be `noeviction` (or the instance must never reach `maxmemory`). Claim keys have a TTL, so both `allkeys-*` and `volatile-*` policies can evict them under memory pressure — the evicted window may then be claimed and executed by another instance.
+  - **Persistence**: a Redis restart without AOF/RDB loses in-flight claims. If it happens inside the contention window (the `max_skew`-wide interval during which instances race to claim the same slot), the job may run twice. Enable AOF, or use `:database` if you cannot accept that risk.
+
+Failure semantics (both backends):
+
+- The claim is taken **before** the job runs, so the semantics are *at-most-once per window*: if the winning instance crashes mid-run, that window's execution is lost and Schked does not retry it.
+- The coordination store is a hard dependency: when it is unreachable, the claim fails and the firing is skipped (fail-closed) rather than risking a duplicate.
+
+##### Database store migration
+
+Run the migration generator to print the `schked_job_runs` DDL:
+
+```sh
+bundle exec schked generate-migration               # Postgres
+bundle exec schked generate-migration --flavor=mysql
+```
+
+Copy the SQL into your application's migration and run it. The gem does not write migration files or run DDL on its own — it stays framework-agnostic.
+
 ### Callbacks
 
 Also, you can define callbacks for errors handling:
@@ -124,6 +189,54 @@ config/initializers/schked.rb
 Schked.config.logger = Logger.new(Rails.root.join("log", "schked.log"))
 ```
 
+### Liveness probe
+
+Schked can expose a small HTTP endpoint for Kubernetes liveness probes. It is **disabled by default** to keep the existing behavior unchanged.
+
+Configure it in Ruby:
+
+```ruby
+Schked.config.liveness_probe = {
+  enabled: true,
+  bind: "0.0.0.0",
+  port: 8080,
+  path: "/healthz",
+  heartbeat_interval: 5,
+  heartbeat_threshold: 15
+}
+```
+
+Or via CLI flags:
+
+```sh
+bundle exec schked start --liveness-probe --liveness-bind 0.0.0.0 --liveness-port 8080 --liveness-path /healthz
+```
+
+In Rails, set it through the application config:
+
+```ruby
+# config/application.rb or config/environments/*.rb
+config.schked.liveness_probe = {
+  enabled: true,
+  bind: "0.0.0.0",
+  port: 8080,
+  path: "/healthz",
+  heartbeat_interval: 5,
+  heartbeat_threshold: 15
+}
+```
+
+The endpoint returns `200 OK` while the scheduler is responsive and `503 Service Unavailable` when the heartbeat is stale or during shutdown. The scheduler updates the heartbeat every `heartbeat_interval` seconds (default `5`); if it is not updated within `heartbeat_threshold` seconds (default `15`), the endpoint reports unhealthy. Use it in Kubernetes like this:
+
+```yaml
+livenessProbe:
+  httpGet:
+    path: /healthz
+    port: 8080
+  initialDelaySeconds: 10
+  periodSeconds: 10
+```
+
 ### Monitoring
 
 [Yabeda::Schked](https://github.com/yabeda-rb/yabeda-schked) - built-in metrics for monitoring Schked recurring jobs out of the box! Part of the [yabeda](https://github.com/yabeda-rb/yabeda) suite.

data/lib/schked/adapters/active_record.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Schked
+  # Adapter for ActiveRecord connection pools (PostgreSQL, Mysql2,
+  # Trilogy). Implements the +Schked::JobRunStore+ contract.
+  #
+  # The adapter wraps a connection *pool*, not a single connection: every
+  # operation checks a connection out via +with_connection+ and returns it
+  # afterwards. The lease guarantees exclusive use of the checked-out
+  # connection, so claims (scheduler thread) and the cleanup sweep (work
+  # threads) can safely share the pool, and the pool transparently
+  # replaces dead connections after a database restart or failover.
+  class Adapters
+    class ActiveRecord
+      include JobRunStore
+
+      SUPPORTED_ADAPTERS = %w[PostgreSQL Mysql2 Trilogy].freeze
+
+      attr_reader :adapter_name
+      attr_reader :logger
+
+      def initialize(pool, logger: Logger.new($stdout))
+        # Accept either a ConnectionPool or a concrete adapter connection
+        # (+ActiveRecord::Base.connection+) and normalize to the pool.
+        @pool = pool.respond_to?(:with_connection) ? pool : pool.pool
+        @logger = logger
+        validate_adapter!
+      end
+
+      def claim(job_name, window_start)
+        validate!(job_name, window_start)
+
+        ts = window_start.is_a?(Time) ? window_start.to_i : Integer(window_start)
+        run_at = Time.now.to_f
+        claimer = SecureRandom.uuid
+
+        @pool.with_connection do |connection|
+          if postgres?
+            postgres_claim(connection, job_name, ts, run_at, claimer)
+          else
+            mysql_claim(connection, job_name, ts, run_at, claimer)
+          end
+        end
+      rescue ArgumentError
+        raise
+      rescue => e
+        logger.error("Failed to claim AR job run with error: #{e.message}")
+        raise
+      end
+
+      def cleanup(older_than)
+        cutoff = older_than.is_a?(Time) ? older_than.to_i : Integer(older_than)
+        @pool.with_connection do |connection|
+          connection.execute("DELETE FROM #{TABLE} WHERE window_start < #{connection.quote(cutoff)}")
+        end
+        nil
+      rescue => e
+        logger.error("Failed to clean up AR job runs with error: #{e.message}")
+        raise
+      end
+
+      private
+
+      TABLE = "schked_job_runs"
+
+      def validate_adapter!
+        name = @pool.with_connection do |connection|
+          connection.respond_to?(:adapter_name) ? connection.adapter_name.to_s : ""
+        end
+        unless SUPPORTED_ADAPTERS.any? { |supported| supported.casecmp?(name) }
+          raise ArgumentError,
+            "Schked::Adapters::ActiveRecord supports #{SUPPORTED_ADAPTERS.join(", ")} " \
+            "connections only, got: #{name.inspect}"
+        end
+
+        # Cached: claim/cleanup dispatch on the dialect without extra
+        # adapter_name round-trips on every firing.
+        @adapter_name = name
+      end
+
+      def postgres?
+        adapter_name.include?("Postgre") || adapter_name.include?("Postgres")
+      end
+
+      # Postgres can decide atomically in a single statement: INSERT ...
+      # ON CONFLICT DO NOTHING RETURNING yields a row only for the winner.
+      def postgres_claim(connection, job_name, ts, run_at, claimer)
+        sql = "INSERT INTO #{TABLE} (job_name, window_start, run_at, claimer) " \
+          "VALUES (#{connection.quote(job_name)}, #{connection.quote(ts)}, " \
+          "#{connection.quote(run_at)}, #{connection.quote(claimer)}) " \
+          "ON CONFLICT (job_name, window_start) DO NOTHING RETURNING id"
+        Integer(connection.exec_query(sql, "Schked CLAIM").length).positive?
+      end
+
+      # Rails' mysql2 and trilogy adapters both connect with the
+      # CLIENT_FOUND_ROWS capability set unconditionally (see
+      # mysql2_adapter.rb / trilogy_adapter.rb), so affected_rows cannot
+      # distinguish a fresh insert from a matched duplicate. Instead every
+      # claimer writes a unique token and reads it back: the
+      # UNIQUE (job_name, window_start) constraint guarantees exactly one
+      # row survives, so only the claimer whose token is stored in that
+      # row won the window.
+      def mysql_claim(connection, job_name, ts, run_at, claimer)
+        insert = "INSERT IGNORE INTO #{TABLE} (job_name, window_start, run_at, claimer) " \
+          "VALUES (#{connection.quote(job_name)}, #{connection.quote(ts)}, " \
+          "#{connection.quote(run_at)}, #{connection.quote(claimer)})"
+        connection.execute(insert)
+
+        select = "SELECT claimer FROM #{TABLE} " \
+          "WHERE job_name = #{connection.quote(job_name)} AND window_start = #{connection.quote(ts)}"
+        row = connection.exec_query(select, "Schked CLAIM").first
+        !row.nil? && row["claimer"] == claimer
+      end
+
+      def validate!(job_name, window_start)
+        raise ArgumentError, "job_name must be a non-empty String" if job_name.to_s.empty?
+        raise ArgumentError, "window_start must not be nil" if window_start.nil?
+      end
+    end
+  end
+end

data/lib/schked/adapters/sequel.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module Schked
+  # Adapter for Sequel (Postgres or MySQL via +Sequel::Database+).
+  # Implements the +Schked::JobRunStore+ contract. Both operations go
+  # through Sequel's thread-safe connection pool, so claims (scheduler
+  # thread) and the cleanup sweep (work threads) can overlap freely.
+  class Adapters
+    class Sequel
+      include JobRunStore
+
+      SUPPORTED_DATABASE_TYPES = %w[postgres mysql].freeze
+
+      attr_reader :logger
+
+      def initialize(database, logger: Logger.new($stdout))
+        @database = database
+        @logger = logger
+        type = database.database_type.to_s
+        unless SUPPORTED_DATABASE_TYPES.include?(type)
+          raise ArgumentError,
+            "Schked::Adapters::Sequel supports Postgres and MySQL databases only, got: #{type.inspect}"
+        end
+      end
+
+      def claim(job_name, window_start)
+        validate!(job_name, window_start)
+
+        ts = window_start.is_a?(Time) ? window_start.to_i : Integer(window_start)
+        run_at = Time.now.to_f
+        claimer = SecureRandom.uuid
+
+        if postgres?
+          # Sequel's +insert_conflict+ is a PostgreSQL-only dataset method;
+          # it returns the new PK on success and +nil+ on conflict, so the
+          # winner is decided atomically in a single statement.
+          id = dataset
+            .insert_conflict(target: UNIQUE_COLUMNS)
+            .insert(job_name: job_name, window_start: ts, run_at: run_at, claimer: claimer)
+          !id.nil?
+        else
+          mysql_claim(job_name, ts, run_at, claimer)
+        end
+      rescue ArgumentError
+        raise
+      rescue => e
+        logger.error("Failed to claim sequel job run with error: #{e.message}")
+        raise
+      end
+
+      def cleanup(older_than)
+        cutoff = older_than.is_a?(Time) ? older_than.to_i : Integer(older_than)
+        dataset.where { window_start < cutoff }.delete
+        nil
+      rescue => e
+        logger.error("Failed to clean up sequel job runs with error: #{e.message}")
+        raise
+      end
+
+      def adapter_name
+        @database.adapter_scheme.to_s
+      end
+
+      private
+
+      TABLE = :schked_job_runs
+      UNIQUE_COLUMNS = %i[job_name window_start].freeze
+
+      def postgres?
+        @database.database_type == :postgres
+      end
+
+      # MySQL has no +RETURNING+, and affected-rows semantics depend on the
+      # CLIENT_FOUND_ROWS connection flag, so the winner cannot be derived
+      # from the insert alone. Instead every claimer writes a unique token
+      # and reads it back: the UNIQUE (job_name, window_start) constraint
+      # guarantees exactly one row survives, so only the claimer whose
+      # token is stored in that row won the window. +insert_ignore+ is a
+      # MySQL dataset method (+INSERT IGNORE+).
+      def mysql_claim(job_name, ts, run_at, claimer)
+        sql = dataset
+          .insert_ignore
+          .insert_sql(job_name: job_name, window_start: ts, run_at: run_at, claimer: claimer)
+
+        @database.synchronize do |conn|
+          conn.query(sql)
+        end
+
+        row = @database[TABLE]
+          .where(job_name: job_name, window_start: ts)
+          .select(:claimer)
+          .first
+        !row.nil? && row[:claimer] == claimer
+      end
+
+      def dataset
+        @database[TABLE]
+      end
+
+      def validate!(job_name, window_start)
+        raise ArgumentError, "job_name must be a non-empty String" if job_name.to_s.empty?
+        raise ArgumentError, "window_start must not be nil" if window_start.nil?
+      end
+    end
+  end
+end

data/lib/schked/callbacks.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Schked
+  # Installs rufus-scheduler callbacks that translate rufus events into
+  # schked semantics: per-job deduplication claims via the configured
+  # +JobRunStore+, logging, and user-registered +Schked.config+ callbacks
+  # (+:before_start+, +:after_finish+, +:on_error+, +:around_job+).
+  #
+  # Extracted from +Schked::Worker+ so the worker stays focused on
+  # lifecycle and the callback wiring remains independently testable.
+  class Callbacks
+    # Marker prefix for schked's own internal jobs (cleanup, liveness
+    # heartbeat). These are exempt from dedup claims.
+    INTERNAL_JOB_PREFIX = "Schked::Worker#"
+
+    def initialize(config:, job_run_store: nil)
+      @config = config
+      @job_run_store = job_run_store
+    end
+
+    def install(scheduler)
+      cfg = @config
+      store = @job_run_store
+      internal = method(:internal_job?)
+      # Unlabeled jobs are skipped on every firing; logging the guidance at
+      # error level for each firing would spam operators (an `every 10s`
+      # job yields 8_640 messages per day). Remember which labels were
+      # already reported and downgrade repeat notices to debug.
+      missing_as_reported = {}
+
+      scheduler.define_singleton_method(:extract_job_name) do |job|
+        if job
+          job.opts[:as] || job.job_id
+        else
+          "unknown"
+        end
+      end
+
+      scheduler.define_singleton_method(:on_error) do |job, error|
+        cfg.logger.fatal("Task #{extract_job_name(job)} failed with error: #{error.message}")
+        cfg.logger.error(error.backtrace.join("\n")) if error.backtrace
+
+        cfg.fire_callback(:on_error, job, error)
+      end
+
+      scheduler.define_singleton_method(:on_pre_trigger) do |job, time|
+        job_name = extract_job_name(job).to_s
+
+        if store && internal.call(job_name)
+          # Internal schked jobs (cleanup sweep, liveness heartbeat) skip
+          # the dedup claim entirely so they always run on every instance.
+        elsif store
+          unless job.opts[:as]
+            # Without an explicit +as:+, the dedup key falls back to
+            # +job.job_id+, which encodes the Ruby +object_id+ of the
+            # +Rufus::Scheduler::Job+ and is unique per process. Claiming
+            # with that key would silently duplicate every run across the
+            # cluster. Refuse to claim; the operator must add +as:+ to
+            # their schedule for dedup to be correct.
+            if missing_as_reported.key?(job_name)
+              cfg.logger.debug("Skipping task #{job_name}: still no `as:` label (already reported).")
+            else
+              cfg.logger.error(
+                "Task #{job_name} has no `as:` label and cannot be deduplicated " \
+                "(each process generates a unique job_id). Add `as: \"my_job\"` to " \
+                "the schedule entry. Skipping this firing."
+              )
+              missing_as_reported[job_name] = true
+            end
+            next false
+          end
+
+          window_start = job.previous_time || job.scheduled_at
+          begin
+            claimed = store.claim(job_name, window_start)
+          rescue => e
+            # Fail closed, but say what actually happened: the task did not
+            # fail — the coordination store is unavailable, and firing is
+            # skipped to avoid a duplicate run.
+            cfg.logger.fatal("Skipped task #{job_name}: job run store unavailable: #{e.class} #{e.message}")
+            cfg.fire_callback(:on_error, job, e)
+            next false
+          end
+          unless claimed
+            cfg.logger.info("Skipped task: #{job_name} (already claimed for window_start=#{window_start.to_i})")
+            next false
+          end
+        end
+
+        cfg.logger.info("Started task: #{extract_job_name(job)}")
+        cfg.fire_callback(:before_start, job, time)
+      end
+
+      scheduler.define_singleton_method(:around_trigger) do |job, &block|
+        cfg.fire_around_callback(:around_job, job, &block)
+      end
+
+      scheduler.define_singleton_method(:on_post_trigger) do |job, time|
+        cfg.logger.info("Finished task: #{extract_job_name(job)}")
+
+        cfg.fire_callback(:after_finish, job, time)
+      end
+
+      scheduler
+    end
+
+    def internal_job?(job_name)
+      job_name.start_with?(INTERNAL_JOB_PREFIX)
+    end
+  end
+end

data/lib/schked/cli.rb

@@ -15,7 +15,7 @@ module Schked
           .shellsplit
       end
 
-      super(argv)
+      super
     end
 
     def self.exit_on_failure?
@@ -26,8 +26,13 @@ module Schked
 
     desc "start", "Start scheduler"
     option :require, type: :array
+    option :liveness_probe, type: :boolean, default: nil, desc: "Enable or disable the liveness probe"
+    option :liveness_bind, type: :string, desc: "Address the liveness probe binds to"
+    option :liveness_port, type: :numeric, desc: "Port the liveness probe listens on"
+    option :liveness_path, type: :string, desc: "HTTP path for the liveness probe"
     def start
       load_requires
+      apply_liveness_probe_options
 
       Schked.worker.wait
     end
@@ -42,6 +47,12 @@ module Schked
       puts "====="
     end
 
+    desc "generate-migration", "Print DDL SQL for the schked_job_runs table to stdout"
+    option :flavor, type: :string, default: "postgres", desc: "DDL flavor (postgres or mysql)"
+    def generate_migration(flavor = nil)
+      puts MigrationGenerator.sql(flavor || options[:flavor])
+    end
+
     private
 
     def load_requires
@@ -50,5 +61,15 @@ module Schked
       # We have to load Schked at here, because of Rails and our railtie.
       require "schked"
     end
+
+    def apply_liveness_probe_options
+      overrides = {}
+      overrides[:enabled] = options[:liveness_probe] unless options[:liveness_probe].nil?
+      overrides[:bind] = options[:liveness_bind] if options[:liveness_bind]
+      overrides[:port] = options[:liveness_port] if options[:liveness_port]
+      overrides[:path] = options[:liveness_path] if options[:liveness_path]
+
+      Schked.config.liveness_probe = Schked.config.liveness_probe.to_h.merge(overrides) if overrides.any?
+    end
   end
 end

data/lib/schked/config.rb

@@ -4,10 +4,23 @@ require "logger"
 
 module Schked
   class Config
+    VALID_JOB_RUN_STORES = %i[redis database].freeze
+
     attr_writer :logger,
       :do_not_load_root_schedule,
       :redis,
-      :standalone
+      :standalone,
+      :job_run_store,
+      :max_skew,
+      :database_connection
+
+    def liveness_probe
+      @liveness_probe ||= LivenessProbeConfig.new
+    end
+
+    def liveness_probe=(value)
+      @liveness_probe = value.is_a?(LivenessProbeConfig) ? value : LivenessProbeConfig.new(value)
+    end
 
     def paths
       @paths ||= []
@@ -73,8 +86,59 @@ module Schked
       !!@standalone
     end
 
+    attr_reader :job_run_store
+
+    def max_skew
+      @max_skew ||= 60
+    end
+
+    attr_reader :database_connection
+
+    def dedup_enabled?
+      !@job_run_store.nil?
+    end
+
+    # Validates all configuration options. Called by the worker during
+    # initialization so the worker can remain agnostic about which options
+    # exist and which combinations are legal.
+    def validate!
+      validate_job_run_store!
+      validate_max_skew!
+    end
+
     private
 
+    def validate_max_skew!
+      return if @max_skew.nil?
+
+      begin
+        skew = Integer(@max_skew)
+      rescue ArgumentError, TypeError
+        raise ArgumentError,
+          "Schked `max_skew` must be a positive number of seconds, got: #{@max_skew.inspect}"
+      end
+
+      return if skew.positive?
+
+      raise ArgumentError,
+        "Schked `max_skew` must be a positive number of seconds, got: #{@max_skew.inspect}"
+    end
+
+    def validate_job_run_store!
+      return if @job_run_store.nil?
+
+      message = "Schked `job_run_store` must be one of #{VALID_JOB_RUN_STORES.inspect}, " \
+        "a Symbol, or an object responding to #claim and #cleanup; got: #{@job_run_store.inspect}"
+
+      valid = if @job_run_store.is_a?(Symbol)
+        VALID_JOB_RUN_STORES.include?(@job_run_store)
+      else
+        @job_run_store.respond_to?(:claim) && @job_run_store.respond_to?(:cleanup)
+      end
+
+      raise ArgumentError, message unless valid
+    end
+
     def callbacks
       @callbacks ||= Hash.new { |hsh, key| hsh[key] = [] }
     end