zeridion-flare 0.2.0

data/lib/zeridion_flare/worker/runner.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+module Zeridion
+  module Flare
+    module Worker
+      # The poll loop. Runs register-once → poll → dispatch → ack, and bounds
+      # the poll `capacity` to true free slots clamped 1–50. Owns no threads of
+      # its own beyond the per-job heartbeat pumps it starts; the bounded job
+      # threads live in the Pool. Mirrors the reference SDK's poll-loop service.
+      class Runner
+        CAPACITY_MIN = 1
+        CAPACITY_MAX = 50
+
+        # @param worker_id [String]
+        # @param config [Configuration]
+        # @param registry [Registry]
+        # @param executor [Executor]
+        # @param pool [Pool]
+        # @param poll_client [Object] strict client; worker owns it (long read-timeout, no poll-timeout retry)
+        # @param heartbeat_client [Object] strict client for heartbeats
+        # @param ack_client [Object] strict client for acks (<= 1 retry)
+        # @param register_client [Object] strict client for register
+        # @param stop_token [CancellationToken] flips on host shutdown / #stop
+        # @param logger [Logger, nil]
+        def initialize(worker_id:, config:, registry:, executor:, pool:,
+                       poll_client:, heartbeat_client:, ack_client:, register_client:,
+                       stop_token:, logger: nil)
+          @worker_id = worker_id
+          @config = config
+          @registry = registry
+          @executor = executor
+          @pool = pool
+          @poll_client = poll_client
+          @heartbeat_client = heartbeat_client
+          @ack_client = ack_client
+          @register_client = register_client
+          @stop = stop_token
+          @logger = logger
+        end
+
+        # Run the loop on the CURRENT thread until the stop token trips. The
+        # caller (Worker) decides whether that is the main thread or a spawned
+        # poll thread.
+        def run
+          if @registry.empty?
+            @logger&.warn("worker_starting no job types discovered — worker will not poll")
+            return
+          end
+
+          queues = poll_queues
+          job_types = @registry.job_types
+
+          @logger&.info(
+            "worker_starting worker_id=#{@worker_id} job_type_count=#{job_types.length} " \
+            "queues=#{queues.join(',')}",
+          )
+
+          register(queues, job_types)
+          poll_loop(queues, job_types)
+        end
+
+        private
+
+        def poll_queues
+          @config.explicit_queues? ? @config.queues : @registry.queues
+        end
+
+        def register(queues, job_types)
+          body = {
+            "worker_id" => @worker_id,
+            "queues" => queues,
+            "job_types" => job_types,
+          }
+          hostname = @config.hostname || Identity.default_hostname
+          body["hostname"] = hostname unless hostname.to_s.empty?
+          body["sdk_version"] = ::Zeridion::Flare::VERSION
+
+          schedules = @registry.recurring_schedules.map(&:to_wire)
+          # OMIT recurring_schedules entirely when empty (never send []).
+          body["recurring_schedules"] = schedules unless schedules.empty?
+
+          # Best-effort: a strict client raises, the worker swallows (D4).
+          # Timeout::Error is included because Net::ReadTimeout < Timeout::Error
+          # (NOT IOError/SystemCallError) — a cold-start register read-timeout
+          # must not escape and kill the poll thread before polling begins.
+          begin
+            @register_client.register_worker(body)
+            @logger&.info("worker_registered worker_id=#{@worker_id}")
+          rescue ::Zeridion::Flare::FlareError, IOError, SystemCallError, Timeout::Error => e
+            @logger&.warn("registration_failed worker_id=#{@worker_id} error=#{e.class}: #{e.message}")
+          end
+        end
+
+        def poll_loop(queues, job_types)
+          until @stop.cancelled?
+            capacity = current_capacity
+            if capacity.nil?
+              # Saturated: no free slots. Idle the poll interval and re-check.
+              @stop.wait(@config.poll_interval_s)
+              next
+            end
+
+            jobs = poll_once(queues, job_types, capacity)
+            next if jobs.nil? # an error / rate-limit already slept
+
+            if jobs.empty?
+              @stop.wait(@config.poll_interval_s)
+              next
+            end
+
+            @logger&.debug("polled_jobs count=#{jobs.length}")
+            dispatch(jobs)
+          end
+
+          @logger&.info("worker_stopped worker_id=#{@worker_id}")
+        end
+
+        # @return [Integer, nil] the clamped capacity to poll with, or nil when
+        #   the pool is fully saturated (poll should be skipped this cycle).
+        def current_capacity
+          free = @pool.free_slots
+          return nil if free <= 0
+
+          free.clamp(CAPACITY_MIN, CAPACITY_MAX)
+        end
+
+        # @return [Array<Hash>, nil] polled jobs, or nil if the cycle slept due
+        #   to an error / rate-limit (caller should `next`).
+        def poll_once(queues, job_types, capacity)
+          body = {
+            "worker_id" => @worker_id,
+            "queues" => queues,
+            "capacity" => capacity,
+            "job_types" => job_types,
+          }
+          response = @poll_client.poll_workers(body)
+          jobs = response.is_a?(Hash) ? response["jobs"] : nil
+          jobs.is_a?(Array) ? jobs : []
+        rescue ::Zeridion::Flare::RateLimitError => e
+          sleep_for_rate_limit(e)
+          nil
+        rescue ::Zeridion::Flare::AuthError => e
+          # 401 is fatal-fast on poll: stop spinning (rotation = restart).
+          @logger&.error("poll_failed_auth worker_id=#{@worker_id} error=#{e.message} — stopping poll")
+          @stop.cancel!
+          nil
+        rescue StandardError => e
+          # Transient / network / 5xx / a long-poll read timeout: log and retry
+          # next cycle (the next poll IS the retry — no poll-timeout retry).
+          @logger&.error("poll_failed error=#{e.class}: #{e.message} retry_after=#{@config.poll_interval_s}s")
+          @stop.wait(@config.poll_interval_s)
+          nil
+        end
+
+        def dispatch(jobs)
+          jobs.each do |item|
+            break if @stop.cancelled?
+            # Reserve a slot; stop if we somehow lost the race (shouldn't, since
+            # capacity gated the poll, but the server may over-return).
+            break unless @pool.try_acquire
+
+            @pool.submit { process_job(item) }
+          end
+        end
+
+        # The full per-job lifecycle: heartbeat pump (immediate beat) → execute
+        # → stop pump → ack. Runs on a pool thread.
+        def process_job(item)
+          job_id = item["id"]
+          start_monotonic = monotonic_now
+
+          cancellation = CancellationToken.new
+          # If the host is already shutting down, wire shutdown → this job's
+          # cancellation so a freshly-claimed job unwinds cooperatively.
+          cancellation.cancel! if @stop.cancelled?
+
+          progress_slot = ProgressSlot.new
+          context = build_context(item, cancellation, progress_slot)
+
+          @logger&.info(
+            "job_executing job_id=#{job_id} job_type=#{item['job_type']} " \
+            "attempt=#{item['attempt']} max_attempts=#{item['max_attempts']}",
+          )
+
+          hb_stop = CancellationToken.new
+          pump = Heartbeat.new(
+            client: @heartbeat_client,
+            worker_id: @worker_id,
+            job_id: job_id,
+            timeout_seconds: job_timeout(item),
+            progress_slot: progress_slot,
+            cancellation: cancellation,
+            stop: hb_stop,
+            heartbeat_min_ms: @config.heartbeat_min_ms,
+            logger: @logger,
+          ).start
+
+          # Local per-job timeout watchdog: trips the cooperative token (D6 — no
+          # thread-kill). A non-yielding handler can't be force-stopped; this
+          # bounds well-behaved handlers and lets the rest land on the reaper.
+          watchdog = start_timeout_watchdog(item, cancellation)
+
+          outcome =
+            begin
+              @executor.execute(item, context)
+            ensure
+              watchdog&.cancel!
+              pump.stop_and_join(timeout: @config.rpc_timeout_s + 1)
+            end
+
+          duration_ms = ((monotonic_now - start_monotonic) * 1000).round
+          log_outcome(job_id, outcome, duration_ms)
+          ack(job_id, outcome, duration_ms)
+        rescue StandardError => e
+          @logger&.error("job_unexpected_error job_id=#{item['id']} error=#{e.class}: #{e.message}")
+          ack(item["id"], Executor::Outcome.new(succeeded: false,
+                                                error: { "type" => e.class.name, "message" => e.message }), 0)
+        end
+
+        def build_context(item, cancellation, progress_slot)
+          JobContext.new(
+            job_id: item["id"],
+            job_type: item["job_type"],
+            attempt: item["attempt"],
+            max_attempts: item["max_attempts"],
+            enqueued_at: JobContext.parse_timestamp(item["enqueued_at"]),
+            logger: @logger,
+            cancellation: cancellation,
+            progress_slot: progress_slot,
+          )
+        end
+
+        def job_timeout(item)
+          t = item["timeout_seconds"].to_i
+          t.positive? ? t : @config.default_timeout_s
+        end
+
+        # Spawn a watchdog thread that trips the cooperative cancellation token
+        # once the job's timeout elapses (unless cancelled first). Returns a
+        # CancellationToken used to cancel the watchdog when the job finishes.
+        def start_timeout_watchdog(item, cancellation)
+          timeout = job_timeout(item)
+          stop_watch = CancellationToken.new
+          Thread.new do
+            # Wake on either the timeout OR the job finishing (stop_watch).
+            woke_to_stop = stop_watch.wait(timeout)
+            cancellation.cancel! unless woke_to_stop
+          end
+          stop_watch
+        end
+
+        def log_outcome(job_id, outcome, duration_ms)
+          if outcome.succeeded?
+            @logger&.info("job_succeeded job_id=#{job_id} duration_ms=#{duration_ms}")
+          else
+            @logger&.warn("job_failed job_id=#{job_id} error_message=#{outcome.error&.fetch('message', 'unknown')}")
+          end
+        end
+
+        # Ack the terminal outcome. Status is "succeeded"/"failed" only (D1 — a
+        # cancelled/timed-out job acks "failed", never "cancelled"). At most one
+        # retry (D5): rely on the server's at-least-once delivery rather than
+        # amplifying with client backoff.
+        def ack(job_id, outcome, duration_ms)
+          status = outcome.succeeded? ? "succeeded" : "failed"
+          body = {
+            "job_id" => job_id,
+            "worker_id" => @worker_id,
+            "status" => status,
+            "duration_ms" => duration_ms,
+          }
+          body["error"] = outcome.error if !outcome.succeeded? && outcome.error && !outcome.error.empty?
+
+          attempts = 0
+          begin
+            @ack_client.ack_worker(body)
+          rescue ::Zeridion::Flare::FlareError, IOError, SystemCallError, Timeout::Error => e
+            attempts += 1
+            if attempts <= 1
+              retry
+            end
+            @logger&.error("ack_failed job_id=#{job_id} status=#{status} error=#{e.class}: #{e.message}")
+          end
+        end
+
+        # On 429: sleep = Retry-After (delta) if present, else
+        # max(0, X-RateLimit-Reset(epoch) − now), clamped to the poll read
+        # timeout. Keep heartbeating in-flight jobs (their pumps run on their own
+        # threads/clients, untouched by a poll back-off).
+        def sleep_for_rate_limit(error)
+          seconds = error.retry_after
+          # RateLimitError#retry_after carries X-RateLimit-Reset (an epoch). If
+          # it looks like an absolute epoch (large), convert to a delta.
+          delay =
+            if seconds.nil?
+              @config.poll_interval_s
+            elsif seconds > 1_000_000_000 # epoch seconds, not a delta
+              [seconds - Time.now.to_i, 0].max
+            else
+              [seconds, 0].max
+            end
+          delay = delay.clamp(0, @config.poll_read_timeout_s)
+          @logger&.warn("poll_rate_limited sleep_s=#{delay}")
+          @stop.wait(delay)
+        end
+
+        def monotonic_now
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+      end
+    end
+  end
+end

data/lib/zeridion_flare/worker/worker.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module Zeridion
+  module Flare
+    module Worker
+      # The background-worker runtime — the Ruby analog of the reference SDK's
+      # hosted worker service. One bootstrap object:
+      #
+      #   require "zeridion_flare/worker"
+      #
+      #   class SendWelcomeEmail
+      #     include Zeridion::Flare::Job
+      #     flare_options queue: "email", max_attempts: 5, timeout: 120
+      #     def perform(payload, ctx) = Mailer.welcome(payload["email"]).deliver_now
+      #   end
+      #
+      #   worker = Zeridion::Flare::Worker.new(concurrency: 5)
+      #   worker.run   # blocks; SIGTERM/SIGINT → graceful drain
+      #
+      # Lifecycle:
+      #   #start — spawn the poll loop on a background thread, return immediately.
+      #   #run   — #start, install SIGTERM/SIGINT handlers, then block until a
+      #            signal arrives, then #stop. (Signals are wired ONLY inside #run.)
+      #   #stop  — idempotent; stop polling and drain in-flight jobs on the
+      #            CURRENT thread within the shutdown grace, then join everything.
+      #
+      # The worker OWNS its HTTP clients (decision D5): a poll client with a read
+      # timeout > 30 s and no poll-timeout retry, a single-shot heartbeat client,
+      # an ack client with at most one retry, and a register client. All four
+      # reuse the existing Client transport — the worker does NOT reinvent HTTP.
+      class Worker
+        # @param api_key [String, nil] falls back to FLARE_API_KEY.
+        # @param base_url [String, nil] default https://api.zeridion.com.
+        # @param registry [Registry, nil] explicit registry; default = every
+        #   class that included Zeridion::Flare::Job / RecurringJob so far.
+        # @param transport [Object, nil] HTTP transport (for tests / DI); passed
+        #   through to every Client the worker builds.
+        # @param max_response_bytes [Integer] body cap forwarded to each Client.
+        # @param config_options see Configuration#initialize (queues:,
+        #   concurrency:, poll_interval_s:, default_timeout_s:,
+        #   default_max_attempts:, shutdown_grace_s:, poll_read_timeout_s:,
+        #   rpc_timeout_s:, hostname:, logger:, heartbeat_min_ms:).
+        def initialize(api_key: nil, base_url: nil, registry: nil, transport: nil,
+                       max_response_bytes: 10 * 1024 * 1024, **config_options)
+          @config = Configuration.new(**config_options)
+          @registry = registry || Registry.from_declared
+          @worker_id = Identity.generate(hostname: @config.hostname)
+          @logger = @config.logger
+          @stop = CancellationToken.new
+          @lifecycle_mutex = Mutex.new
+          @started = false
+          @stopped = false
+          @poll_thread = nil
+          @run_latch = CancellationToken.new
+
+          base_url ||= ::Zeridion::Flare::Client::DEFAULT_BASE_URL
+          @poll_client = build_poll_client(api_key, base_url, transport, max_response_bytes)
+          @heartbeat_client = build_rpc_client(api_key, base_url, transport, max_response_bytes, max_retries: 0)
+          @ack_client = build_rpc_client(api_key, base_url, transport, max_response_bytes, max_retries: 1)
+          @register_client = build_rpc_client(api_key, base_url, transport, max_response_bytes, max_retries: 0)
+
+          @pool = Pool.new(concurrency: @config.concurrency)
+          @executor = Executor.new(registry: @registry, logger: @logger)
+          @runner = build_runner
+        end
+
+        # @return [String] this worker's id (wrk_{host}_{pid}_{rand}).
+        attr_reader :worker_id
+
+        # @return [Configuration]
+        attr_reader :config
+
+        # Start the pool + poll loop on a background thread. Non-blocking.
+        # Idempotent. Returns self.
+        def start
+          @lifecycle_mutex.synchronize do
+            return self if @started
+
+            @started = true
+            @pool.start
+            @poll_thread = Thread.new do
+              if Thread.current.respond_to?(:name=)
+                Thread.current.name = "flare-poll"
+              end
+              @runner.run
+            end
+          end
+          self
+        end
+
+        # Start, install SIGTERM/SIGINT handlers, and block until a stop signal
+        # (or another thread calls #stop). On wake, drain and return. Must run on
+        # the main thread (Signal.trap is process-global).
+        def run
+          start
+          install_signal_handlers
+          # Block the calling thread until stop is requested.
+          @run_latch.wait(Float::INFINITY)
+          stop
+        ensure
+          uninstall_signal_handlers
+        end
+
+        # Idempotent graceful shutdown: stop polling, then drain in-flight jobs
+        # on the CURRENT thread within shutdown_grace_s, then join the poll
+        # thread + pool. Safe to call from a signal context or another thread.
+        def stop
+          @lifecycle_mutex.synchronize do
+            return if @stopped
+
+            @stopped = true
+          end
+
+          # 1. Flip the stop token → poll loop stops claiming new jobs and
+          #    cooperatively cancels freshly-claimed ones.
+          @stop.cancel!
+          # 2. Wake #run if it is blocking.
+          @run_latch.cancel!
+          # 3. Let the poll loop notice and exit.
+          @poll_thread&.join(@config.poll_read_timeout_s + 5)
+          # 4. Drain in-flight jobs (each acks itself) within the grace window.
+          @logger&.info("shutdown_waiting in_flight=#{@pool.in_flight}") if @pool.in_flight.positive?
+          all_done = @pool.shutdown(timeout: @config.shutdown_grace_s)
+          @logger&.warn("shutdown_grace_exceeded — some jobs still running") unless all_done
+          nil
+        end
+
+        # @return [Boolean] true once #stop has completed (test convenience).
+        def stopped?
+          @lifecycle_mutex.synchronize { @stopped }
+        end
+
+        private
+
+        def build_runner
+          Runner.new(
+            worker_id: @worker_id,
+            config: @config,
+            registry: @registry,
+            executor: @executor,
+            pool: @pool,
+            poll_client: @poll_client,
+            heartbeat_client: @heartbeat_client,
+            ack_client: @ack_client,
+            register_client: @register_client,
+            stop_token: @stop,
+            logger: @logger,
+          )
+        end
+
+        # Poll client: long read timeout (> 30 s long-poll), retries disabled so
+        # a long-poll read timeout is never retried inside the client (the next
+        # loop poll is the retry).
+        def build_poll_client(api_key, base_url, transport, max_response_bytes)
+          ::Zeridion::Flare::Client.new(
+            api_key: api_key,
+            base_url: base_url,
+            max_retries: 0,
+            timeout_seconds: @config.poll_read_timeout_s,
+            max_response_bytes: max_response_bytes,
+            transport: transport,
+          )
+        end
+
+        # Heartbeat / ack / register client: short read timeout, retry budget per
+        # caller (heartbeat 0, ack 1, register 0).
+        def build_rpc_client(api_key, base_url, transport, max_response_bytes, max_retries:)
+          ::Zeridion::Flare::Client.new(
+            api_key: api_key,
+            base_url: base_url,
+            max_retries: max_retries,
+            timeout_seconds: @config.rpc_timeout_s,
+            max_response_bytes: max_response_bytes,
+            transport: transport,
+          )
+        end
+
+        def install_signal_handlers
+          @previous_handlers = {}
+          %w[TERM INT].each do |sig|
+            @previous_handlers[sig] = Signal.trap(sig) do
+              # A trap handler MUST NOT acquire a Mutex (Ruby raises
+              # "can't be called from trap context" — both CancellationTokens use
+              # one internally). Hand the actual wake to a fresh thread, which
+              # runs OUTSIDE the trap context and may safely lock. The real drain
+              # then runs on the main thread once #run unblocks.
+              Thread.new do
+                @stop.cancel!
+                @run_latch.cancel!
+              end
+            end
+          rescue ArgumentError
+            # Signal not supported on this platform — skip it.
+            nil
+          end
+        end
+
+        def uninstall_signal_handlers
+          return unless @previous_handlers
+
+          @previous_handlers.each do |sig, handler|
+            Signal.trap(sig, handler) if handler
+          rescue ArgumentError
+            nil
+          end
+          @previous_handlers = nil
+        end
+      end
+    end
+  end
+end

data/lib/zeridion_flare/worker.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Opt-in background-worker runtime for the Zeridion Flare Ruby SDK.
+#
+#   require "zeridion_flare/worker"
+#
+# This pulls in the full worker surface on top of the thin client:
+#
+#   * Zeridion::Flare::Job              — mixin + `flare_options` macro for payload jobs
+#   * Zeridion::Flare::RecurringJob     — mixin for payloadless cron jobs
+#   * Zeridion::Flare::Worker           — the runtime (register → poll → dispatch →
+#                                         heartbeat → ack → drain)
+#   * Zeridion::Flare::Worker::Configuration
+#   * Zeridion::Flare::JobContext       — per-execution context (cancellation, progress)
+#
+# The runtime is opt-in by import so thin-client bundles stay lean. It reads the
+# single client version constant and reuses the existing HTTP transport for
+# auth / retry / body-cap — it does NOT reinvent HTTP.
+#
+# Requires Ruby 3.2+ (uses Data.define).
+
+require_relative "../zeridion_flare"
+
+require_relative "worker/errors"
+require_relative "worker/recurring_schedule"
+require_relative "worker/progress_slot"
+require_relative "worker/cancellation_token"
+require_relative "worker/job_context"
+require_relative "worker/job"
+require_relative "worker/recurring_job"
+require_relative "worker/registry"
+require_relative "worker/job_definition"
+require_relative "worker/identity"
+require_relative "worker/configuration"
+require_relative "worker/executor"
+require_relative "worker/heartbeat"
+require_relative "worker/pool"
+require_relative "worker/runner"
+require_relative "worker/worker"

data/lib/zeridion_flare.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "zeridion_flare/version"
+require_relative "zeridion_flare/errors"
+require_relative "zeridion_flare/webhook"
+require_relative "zeridion_flare/client"
+
+# Top-level convenience: the module name is `Zeridion::Flare`. Most consumers
+# will write `client = Zeridion::Flare::Client.new(api_key: "...")` or alias
+# the module as needed.
+module Zeridion
+  module Flare
+  end
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: zeridion-flare
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Zeridion
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-07-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.20'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.20'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+description: Synchronous Ruby client for the Zeridion Flare API (background jobs,
+  recurring schedules, workers, webhook verification) plus an opt-in background-worker
+  runtime (require "zeridion_flare/worker") that polls, dispatches to your job classes,
+  heartbeats with progress, honors server cancellation, and drains gracefully on shutdown.
+  Zero runtime dependencies — uses Ruby stdlib Net::HTTP only.
+email:
+- support@zeridion.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/zeridion_flare.rb
+- lib/zeridion_flare/client.rb
+- lib/zeridion_flare/errors.rb
+- lib/zeridion_flare/version.rb
+- lib/zeridion_flare/webhook.rb
+- lib/zeridion_flare/worker.rb
+- lib/zeridion_flare/worker/cancellation_token.rb
+- lib/zeridion_flare/worker/configuration.rb
+- lib/zeridion_flare/worker/errors.rb
+- lib/zeridion_flare/worker/executor.rb
+- lib/zeridion_flare/worker/heartbeat.rb
+- lib/zeridion_flare/worker/identity.rb
+- lib/zeridion_flare/worker/job.rb
+- lib/zeridion_flare/worker/job_context.rb
+- lib/zeridion_flare/worker/job_definition.rb
+- lib/zeridion_flare/worker/pool.rb
+- lib/zeridion_flare/worker/progress_slot.rb
+- lib/zeridion_flare/worker/recurring_job.rb
+- lib/zeridion_flare/worker/recurring_schedule.rb
+- lib/zeridion_flare/worker/registry.rb
+- lib/zeridion_flare/worker/runner.rb
+- lib/zeridion_flare/worker/worker.rb
+homepage: https://docs.zeridion.com/flare
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://docs.zeridion.com/flare
+  source_code_uri: https://github.com/zeridion/zeridion
+  documentation_uri: https://docs.zeridion.com/flare
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Official Ruby SDK for Zeridion Flare — managed background jobs + worker runtime.
+test_files: []