cosmonats 0.4.2 → 0.5.0

data/lib/cosmo/cli.rb

@@ -16,6 +16,8 @@ module Cosmo
 
     def run
       flags, command, options = parse
+      return run_setup(flags) if flags[:setup]
+
       load_config(flags)
       puts self.class.banner
       boot_application
@@ -53,6 +55,34 @@ module Cosmo
       Config.set(:timeout, flags[:timeout]) if flags[:timeout]
     end
 
+    def run_setup(flags)
+      load_config(flags)
+      boot_application
+
+      Config[:setup]&.each do |type, configs|
+        next if type == :cron
+
+        first_line = true
+        configs.each do |name, config|
+          meta = { metadata: { "_cosmo.type" => "jobs" } } if type == :jobs
+          Client.instance.setup_stream(name.to_s, config.merge(Hash(meta)))
+          first_line ? print("Stream is ready: #{name}") : print(", #{name}")
+          first_line = false
+        end
+      end
+
+      puts
+      schedules = Config.dig(:setup, :cron)&.reduce(0) do |sum, (name, entry)|
+        class_name = entry.delete(:class)
+        API::Cron.instance.upsert!(**entry, name: name, class_name: class_name)
+        sum + 1
+      end.to_i
+
+      puts "Cron sync complete: #{schedules} schedule(s) registered" unless schedules.zero?
+      puts "Cosmo streams#{" and cron schedules" unless schedules.zero?} set up successfully."
+      exit(0)
+    end
+
     def boot_application
       boot_path = File.expand_path("config/boot.rb")
       require boot_path if File.exist?(boot_path)
@@ -104,31 +134,7 @@ module Cosmo
         end
 
         o.on "-S", "--setup", "Create/update streams and sync cron schedules, then exit" do
-          load_config(flags)
-          boot_application
-
-          Config[:setup]&.each do |type, configs|
-            next if type == :cron
-
-            first_line = true
-            configs.each do |name, config|
-              meta = { metadata: { "_cosmo.type" => "jobs" } } if type == :jobs
-              Client.instance.setup_stream(name.to_s, config.merge(Hash(meta)))
-              first_line ? print("Stream is ready: #{name}") : print(", #{name}")
-              first_line = false
-            end
-          end
-
-          puts
-          schedules = Config.dig(:setup, :cron)&.reduce(0) do |sum, (name, entry)|
-            class_name = entry.delete(:class)
-            API::Cron.instance.upsert!(**entry, name: name, class_name: class_name)
-            sum + 1
-          end.to_i
-
-          puts "Cron sync complete: #{schedules} schedule(s) registered" unless schedules.zero?
-          puts "Cosmo streams#{" and cron schedules" unless schedules.zero?} set up successfully."
-          exit(0)
+          flags[:setup] = true
         end
 
         o.on_tail "-v", "--version", "Print version" do

data/lib/cosmo/config.rb

@@ -14,6 +14,10 @@ module Cosmo
       delegate %i[[] fetch dig to_h set load] => :instance
     end
 
+    def self.to_ns(seconds)
+      (seconds.to_f * NANO).to_i
+    end
+
     def self.parse_file(path)
       YAML.load_file(path, aliases: true).tap { normalize!(_1) }
     end
@@ -21,10 +25,14 @@ module Cosmo
     def self.normalize!(config) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       Utils::Hash.symbolize_keys!(config)
 
+      config[:timeout] = Utils::Duration.parse(config[:timeout]) if config[:timeout]
+      config[:batch_expiry] = Utils::Duration.parse(config[:batch_expiry]) if config[:batch_expiry]
+
       config[:consumers]&.each_key do |name|
         config[:consumers][name].each do |stream_name, c|
           next unless c
 
+          c[:ack_wait] = Utils::Duration.parse(c[:ack_wait]) if c[:ack_wait]
           c[:subject] = format(c[:subject], { name: stream_name }) if c[:subject]
           c[:subjects] = c[:subjects].map { |s| format(s, name: stream_name) } if c[:subjects]
         end
@@ -35,8 +43,8 @@ module Cosmo
 
         config[:setup][type]&.each_key do |name|
           c = config[:setup][type][name]
-          c[:max_age] = c[:max_age].to_i * NANO if c[:max_age]
-          c[:duplicate_window] = c[:duplicate_window].to_i * NANO if c[:duplicate_window]
+          c[:max_age] = to_ns(Utils::Duration.parse(c[:max_age])) if c[:max_age]
+          c[:duplicate_window] = to_ns(Utils::Duration.parse(c[:duplicate_window])) if c[:duplicate_window]
           c[:subjects] = c[:subjects].map { |s| format(s, name: name) } if c[:subjects]
 
           next unless type == :jobs # Every jobs stream supports NATS 2.14 message scheduling.

data/lib/cosmo/job/data.rb

@@ -7,6 +7,10 @@ module Cosmo
     class Data
       DEFAULTS = { stream: :default, retry: 3, dead: true, limit: nil }.freeze
 
+      def self.default_retry
+        Config[:max_retries] || DEFAULTS[:retry]
+      end
+
       attr_reader :jid
 
       def initialize(class_name, args, options = nil)
@@ -22,6 +26,10 @@ module Cosmo
         @jid = SecureRandom.hex(12)
       end
 
+      def batch_id
+        @options[:batch_id]
+      end
+
       def stream(target: false)
         return @options[:stream] if target
 
@@ -33,13 +41,8 @@ module Cosmo
       end
 
       def as_json
-        {
-          jid: jid,
-          class: @class_name,
-          args: @args,
-          retry: retries,
-          dead: dead
-        }
+        json = { jid: jid, class: @class_name, args: @args, retry: retries, dead: dead }
+        batch_id ? json.merge(batch_id: batch_id) : json
       end
 
       def to_json(*_args)
@@ -63,7 +66,10 @@ module Cosmo
       end
 
       def retries
-        @options[:retry].nil? ? DEFAULTS[:retry] : @options[:retry]
+        return self.class.default_retry if @options[:retry].nil?
+        return 0 if @options[:retry] == false
+
+        @options[:retry]
       end
 
       def dead

data/lib/cosmo/job/processor.rb

@@ -42,9 +42,14 @@ module Cosmo
               client.publish(subject, message.data, headers: headers)
               message.ack
             else
-              delay_ns = (execute_at - now) * 1_000_000_000
-              message.nak(delay: delay_ns)
+              message.nak(delay: Config.to_ns(execute_at - now))
             end
+          rescue StandardError => e
+            # A transient failure here (e.g. a JetStream publish timeout) must not be allowed
+            # to escape #each and kill this thread — schedule_loop only runs once per processor,
+            # so an unhandled exception would silently stop all future scheduled-job dispatch.
+            Logger.error e
+            message.nak rescue nil
           end
 
           break unless running?
@@ -65,6 +70,7 @@ module Cosmo
         unless worker_class
           Logger.error ArgumentError.new("#{data[:class]} class not found")
           move_message(message, data)
+          notify_batch(data, success: false)
           return
         end
 
@@ -80,20 +86,21 @@ module Cosmo
           Logger.with(jid: data[:jid])
           Logger.info "start"
 
-          instance = worker_class.new.tap { |w| w.jid = data[:jid] }
+          instance = build_worker(worker_class, data, message)
           perform_job(instance, data: data, message: message, duration: duration)
 
           message.ack
+          notify_batch(data, success: true)
           Logger.with(elapsed: sw.elapsed_seconds) { Logger.info "done" }
           true
-        rescue Timeout::Error
+        rescue Timeout::Error => e
           Logger.with(elapsed: sw.elapsed_seconds) { Logger.info "fail[timeout]" }
-          dropped = handle_failure(message, data)
+          dropped = handle_failure(worker_class, message, data, e)
           false if dropped
         rescue StandardError => e
           Logger.debug e
           Logger.with(elapsed: sw.elapsed_seconds) { Logger.info "fail[error]" }
-          dropped = handle_failure(message, data)
+          dropped = handle_failure(worker_class, message, data, e)
           false if dropped
         rescue Exception # rubocop:disable Lint/RescueException
           Logger.with(elapsed: sw.elapsed_seconds) { Logger.info "fail[exception]" }
@@ -105,6 +112,16 @@ module Cosmo
         Logger.debug "processed message #{message.inspect}"
       end
 
+      def build_worker(worker_class, data, message)
+        worker_class.new.tap do |worker|
+          worker.jid = data[:jid]
+          worker.enqueued_at = message.metadata.timestamp
+          worker.attempt = message.metadata.num_delivered
+          worker.scheduled_by = message.header&.dig("Nats-Scheduler")
+          worker.batch_id = data[:batch_id]
+        end
+      end
+
       # Tries to acquire a concurrency slot for the job.
       # Returns the slot key (String) on success, or false if all slots are
       # taken (a message is NAK'd with a delay of +retry_in+ before returning
@@ -115,7 +132,7 @@ module Cosmo
         slot = Limit.instance.acquire(key, jid: data[:jid], limit: options[:limit], duration: options[:duration])
         return slot if slot
 
-        message.nak(delay: options[:retry_in] * Config::NANO)
+        message.nak(delay: Config.to_ns(options[:retry_in]))
         Logger.debug "concurrency limit reached for #{data[:class]}, re-queueing back #{data[:jid]}"
         false
       rescue NATS::Error => e
@@ -126,29 +143,72 @@ module Cosmo
         false
       end
 
-      def handle_failure(message, data) # rubocop:disable Naming/PredicateMethod
+      def handle_failure(worker_class, message, data, exception) # rubocop:disable Naming/PredicateMethod
         current_attempt = message.metadata.num_delivered
-        max_retries = data[:retry].to_i + 1
-
-        if current_attempt < max_retries
-          # NATS will auto-retry with delay (exponential backoff based on current attempt).
-          # When max_deliver is reached, NATS stops redelivering the message and marks it as "max deliveries exceeded".
-          # The message is effectively abandoned by NATS — it stays in the stream (consuming a slot) but will never be delivered again to that consumer.
-          delay_ns = ((current_attempt**4) + 15) * Config::NANO
-          message.nak(delay: delay_ns)
+        desired_retries = data[:retry].to_i + 1
+        capped_at = deliver_cap(message.metadata.stream, desired_retries)
+
+        if current_attempt < (capped_at || desired_retries)
+          nak_message(worker_class, message, data, current_attempt, exception)
           return false
         end
 
+        warn_capped(message, data, capped_at) if capped_at
         data[:dead] ? move_message(message, data) : drop_message(message, data)
+        notify_batch(data, success: false)
         true
       end
 
+      def notify_batch(data, success:)
+        return unless data[:batch_id]
+
+        Batch.notify(data[:batch_id], data[:jid], success: success)
+      end
+
+      # The message is NAK'd with an explicit delay (default backoff, or the job class's own +retry_in+ handler).
+      def nak_message(worker_class, message, data, current_attempt, exception)
+        message.nak(delay: Config.to_ns(retry_delay(worker_class, data, current_attempt, exception)))
+      end
+
+      def warn_capped(message, data, capped_at)
+        consumer_name = consumer_entry(message.metadata.stream)&.dig(1, :consumer)
+        Logger.warn "#{data[:class]} configured retry: #{data[:retry]} exceeds max_deliver: #{capped_at} " \
+                    "on #{consumer_name}; giving up early to avoid a stranded message"
+      end
+
+      # Returns the consumer's configured +max_deliver+ when it's lower than the job's own configured
+      # retry count (so we should give up a bit early instead of NAK'ing into a redelivery that'll never
+      # come), or +nil+ when the job's own retry count is already the binding constraint.
+      def deliver_cap(stream_name, desired_retries)
+        max_deliver = consumer_entry(stream_name)&.dig(1, :max_deliver).to_i
+        max_deliver if max_deliver.positive? && max_deliver < desired_retries
+      end
+
+      def consumer_entry(stream_name)
+        @consumers.find { |(_, config, _)| config[:stream].to_s == stream_name.to_s }
+      end
+
+      def retry_delay(worker_class, data, current_attempt, exception)
+        handler = worker_class.retry_in(data)
+        return default_retry_delay(current_attempt) unless handler
+
+        delay = handler.call(current_attempt, exception)
+        delay.is_a?(Numeric) && delay.positive? ? delay : default_retry_delay(current_attempt)
+      rescue StandardError => e
+        Logger.error e
+        default_retry_delay(current_attempt)
+      end
+
+      def default_retry_delay(current_attempt)
+        (current_attempt**4) + 15
+      end
+
       def subscribe(stream_name, config)
         config = config.dup
         config[:batch_size] = 1
         config[:stream] = stream_name
-        consumer_name = "consumer-#{stream_name}"
-        subscription = client.subscribe(config[:subject], consumer_name, config.except(:subject, :priority, :stream, :batch_size))
+        config[:consumer] = "consumer-#{stream_name}"
+        subscription = client.subscribe(config[:subject], config[:consumer], config.except(:subject, :priority, :stream, :batch_size, :consumer))
         [subscription, config, nil]
       end
 

data/lib/cosmo/job.rb

@@ -11,32 +11,48 @@ module Cosmo
     end
 
     module ClassMethods
-      # @option config [Symbol]  :stream  NATS stream to publish to (default: :default)
-      # @option config [Integer] :retry   max delivery attempts before giving up (default: 3)
-      # @option config [Boolean] :dead    move to dead-letter stream after retries exhausted (default: true)
-      # @option config [Hash]    :limit   execution limits:
+      # @option config [Symbol] :stream NATS stream to publish to (default: :default)
+      # @option config [Integer, Boolean] :retry max delivery attempts before giving up (default: +max_retries+
+      #   from cosmo.yml, or 3 if unset). +false+ is treated as 0 (no retries). Should stay comfortably under
+      #   the assigned stream's consumer +max_deliver+ (a coarse, shared safety ceiling, not a per-job budget) --
+      #   a job whose +retry:+ exceeds it is capped and dead-lettered a delivery early, with a warning logged.
+      # @option config [Boolean] :dead move to dead-letter stream after retries exhausted (default: true)
+      # @option config [Hash] :limit execution limits:
       #
       #   limit: { duration: 30 }
       #   limit: { duration: 30, concurrency: 3 }
       #   limit: { duration: 30, concurrency: { to: 3, key: ->(id) { id } } }
       #   limit: { duration: 30, concurrency: 3, retry_in: 5 }
       #
-      # @option config [Integer] :"limit[:duration]"    hard execution timeout in seconds. The job thread is
+      # @option config [Integer] :"limit[:duration]" hard execution timeout in seconds. The job thread is
       #   killed after this many seconds and counts as a failed attempt (retried with exponential backoff,
       #   moved to DLQ after retries exhausted).
-      # @option config [Integer, Hash] :"limit[:concurrency]"  caps how many instances run at once across all
+      # @option config [Integer, Hash] :"limit[:concurrency]" caps how many instances run at once across all
       #   workers. Jobs that cannot acquire a slot are NAK'd (see +retry_in+) so they are not re-delivered until
       #   the slot is likely free. Requires +duration+.
       #   Pass an Integer for a class-wide cap, or <tt>{ to: N, key: ->(args) {} }</tt> to scope per key.
-      # @option config [Integer] :"limit[:retry_in]"    seconds to wait before NATS redelivers a job that was
+      # @option config [Integer] :"limit[:retry_in]" seconds to wait before NATS redelivers a job that was
       #   NAK'd for lack of a concurrency slot (default: half of +duration+). Counts against the same delivery
       #   counter as any other retry -- a job stuck behind the concurrency limit for enough consecutive
       #   attempts is dropped/DLQ'd exactly like one that keeps failing outright.
+      # @option config [Proc] :retry_in <tt>->(count, exception) { }</tt> returns a number of seconds to
+      #   wait before redelivering a *failed* job. +count+ is a 1-based delivery attempt that just failed.
+      #   Falls back to the default backoff (<tt>attempt**4 + 15</tt> seconds) if not set or the proc returns
+      #   a non-numeric/non-positive value, or if it raises.
+      #
+      #   Caveat when combined with +limit[:concurrency]+: when there's no free slot to run in, the message is
+      #   put back on the stream using the +limit[:retry_in]+ delay described above, and that counts as an
+      #   attempt too -- the same +count+ goes up whether the job was turned away for lack of a free slot (via
+      #   +limit[:retry_in]+) or actually ran and failed. So a job that gets turned away twice for lack of a
+      #   slot, then finally runs and fails, calls this handler with +count == 3+, not 1. Don't read +count+ as
+      #   "how many times perform has actually run and failed" when concurrency limits are in play.
       def options(**config)
         if config[:limit] && config.dig(:limit, :concurrency) && !config.dig(:limit, :duration).to_i.positive?
           raise ArgumentError, "limit: duration is required when concurrency is set"
         end
 
+        raise ArgumentError, "retry_in must be callable, e.g. ->(count, exception) { ... }" if config[:retry_in] && !config[:retry_in].respond_to?(:call)
+
         default_options.merge!(config)
       end
       alias cosmo_options options
@@ -45,6 +61,13 @@ module Cosmo
         !!concurrency_options
       end
 
+      # Returns the +retry_in+ Proc/lambda (taking +(count, exception)+) configured for this job class, or
+      # +nil+ when unset. Overridable by wrapper job classes (e.g. the ActiveJob executor) that need to
+      # resolve it from something other than +self+.
+      def retry_in(_data = nil)
+        default_options[:retry_in]
+      end
+
       # Returns a normalized concurrency config hash, or +nil+ when not configured.
       # Always contains +:limit+, +:key+, +:duration+, and +:retry_in+.
       def concurrency_options
@@ -71,6 +94,8 @@ module Cosmo
       end
 
       def perform(*args, async: true, **options)
+        batch = Batch.current if async
+        options[:batch_id] = batch.bid if batch
         data = Data.new(name, args, default_options.merge(options))
         unless async
           payload = Utils::Json.parse(data.to_args[1])
@@ -80,7 +105,19 @@ module Cosmo
           return
         end
 
+        publish(data, batch)
+      end
+
+      # The batch is reserved a pending slot before we know the publish will
+      # succeed (must happen in that order -- see Batch#jobs). Roll it back
+      # if it never actually made it onto the stream, so the batch doesn't
+      # hang waiting for a completion that will never arrive.
+      def publish(data, batch)
+        batch&.register_job!
         Publisher.publish_job(data)
+      rescue StandardError
+        batch&.rollback_job!
+        raise
       end
 
       def perform_async(*args)
@@ -100,7 +137,7 @@ module Cosmo
       end
 
       def default_options
-        @default_options ||= (superclass.respond_to?(:default_options) ? superclass.default_options : Data::DEFAULTS).dup
+        @default_options ||= (superclass.respond_to?(:default_options) ? superclass.default_options : Data::DEFAULTS.merge(retry: Data.default_retry)).dup
       end
 
       private
@@ -110,7 +147,7 @@ module Cosmo
       end
     end
 
-    attr_accessor :jid
+    attr_accessor :jid, :batch_id, :enqueued_at, :attempt, :scheduled_by
 
     def perform(...)
       raise NotImplementedError, "#{self.class}#perform must be implemented"

data/lib/cosmo/processor.rb

@@ -2,9 +2,9 @@
 
 module Cosmo
   class Processor
-    STREAM_PAUSED_RECHECK_TTL = 5.0 # Seconds a stream's paused state is cached before re-checking (override via COSMO_STREAM_PAUSED_RECHECK_TTL)
-    STREAMS_PAUSED_IDLE_SLEEP = 1.0 # Seconds to sleep when every stream is paused, preventing a tight CPU spin (override via COSMO_STREAMS_PAUSED_IDLE_SLEEP)
-    STREAM_EMPTY_BACKOFF_MAX = 5.0  # Max seconds to sleep between empty fetches (override via COSMO_STREAM_EMPTY_BACKOFF_MAX)
+    STREAM_PAUSED_RECHECK_TTL = "5s" # How long a stream's paused state is cached before re-checking (override via COSMO_STREAM_PAUSED_RECHECK_TTL)
+    STREAMS_PAUSED_IDLE_SLEEP = "1s" # How long to sleep when every stream is paused, preventing a tight CPU spin (override via COSMO_STREAMS_PAUSED_IDLE_SLEEP)
+    STREAM_EMPTY_BACKOFF_MAX = "5s"  # Max sleep between empty fetches (override via COSMO_STREAM_EMPTY_BACKOFF_MAX)
 
     def self.run(...)
       new(...).tap(&:run)
@@ -58,8 +58,8 @@ module Cosmo
           break unless running?
 
           stream_name = config[:stream].to_s
-          ttl = ENV.fetch("COSMO_STREAM_PAUSED_RECHECK_TTL", STREAM_PAUSED_RECHECK_TTL).to_f
-          if @cache.fetch(stream_name, ttl:) { API::Stream.new(stream_name).paused? }
+          ttl = Utils::Duration.parse(ENV.fetch("COSMO_STREAM_PAUSED_RECHECK_TTL", STREAM_PAUSED_RECHECK_TTL))
+          if @cache.fetch("#{stream_name}:paused", ttl:) { API::Stream.new(stream_name).paused? }
             Logger.debug "stream #{stream_name} is paused, skipping fetch"
             next
           end
@@ -86,7 +86,7 @@ module Cosmo
                 consumer_state.delete(stream_name)
                 process(messages, processor)
               else
-                max_backoff = ENV.fetch("COSMO_STREAM_EMPTY_BACKOFF_MAX", STREAM_EMPTY_BACKOFF_MAX).to_f
+                max_backoff = Utils::Duration.parse(ENV.fetch("COSMO_STREAM_EMPTY_BACKOFF_MAX", STREAM_EMPTY_BACKOFF_MAX))
                 consumer_state.compute(stream_name) do |current|
                   count = (current&.first || 0) + 1
                   backoff = [timeout * (2**(count - 1)), max_backoff].min
@@ -103,7 +103,7 @@ module Cosmo
         break unless running?
 
         if all_paused
-          period = ENV.fetch("COSMO_STREAMS_PAUSED_IDLE_SLEEP", STREAMS_PAUSED_IDLE_SLEEP).to_f
+          period = Utils::Duration.parse(ENV.fetch("COSMO_STREAMS_PAUSED_IDLE_SLEEP", STREAMS_PAUSED_IDLE_SLEEP))
           Logger.debug "all streams paused, sleep=#{period}"
           sleep(period)
         elsif all_empty

data/lib/cosmo/utils/duration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Cosmo
+  module Utils
+    # Parses human-friendly duration strings ("20s", "1h", "7d") into seconds, so
+    # config values don't have to be spelled out as bare, uncommented integers.
+    # Numbers pass through unchanged, since existing config already uses plain seconds.
+    module Duration
+      UNITS = {
+        "s" => 1,
+        "m" => 60,
+        "h" => 3600,
+        "d" => 86_400,
+        "w" => 604_800,
+        "mo" => 2_592_000, # 30 days
+        "y" => 31_536_000
+      }.freeze
+
+      module_function
+
+      def parse(value)
+        return value if value.is_a?(Numeric)
+
+        str = value.to_s
+        match = str.match(/\A(\d+)(mo|[smhdwy])\z/)
+        return match[1].to_i * UNITS[match[2]] if match
+        return str.to_f if str.match?(/\A\d+(\.\d+)?\z/)
+
+        raise ArgumentError, "invalid duration: #{value}"
+      end
+    end
+  end
+end

data/lib/cosmo/utils.rb

@@ -5,6 +5,7 @@ require "cosmo/utils/json"
 require "cosmo/utils/string"
 require "cosmo/utils/signal"
 require "cosmo/utils/warnings"
+require "cosmo/utils/duration"
 require "cosmo/utils/stopwatch"
 require "cosmo/utils/thread_pool"
 require "cosmo/utils/ttl_cache"

data/lib/cosmo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Cosmo
-  VERSION = "0.4.2"
+  VERSION = "0.5.0"
 end

data/lib/cosmo/web/assets/app.css

@@ -180,6 +180,14 @@ button:hover, .btn:hover {
   background: oklch(from var(--color-warning) l c h / 20%);
   color: oklch(from var(--color-warning) calc(l - 0.15) c h);
 }
+.badge-danger {
+  background: oklch(from var(--color-danger) l c h / 15%);
+  color: var(--color-danger);
+}
+.badge-info {
+  background: oklch(from var(--color-info) l c h / 15%);
+  color: var(--color-info);
+}
 
 /* ── Alerts ────────────────────────────────────────────────────────────── */
 .alert {
@@ -507,7 +515,7 @@ details summary {
   font-size: var(--font-size-small);
   user-select: none;
 }
-details summary code { display: inline; }
+details summary code { display: inline; user-select: text; }
 details[open] summary { margin-bottom: var(--space); }
 details code { display: block; max-width: 400px; white-space: pre-wrap; }
 

data/lib/cosmo/web/controllers/batches.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "cosmo/web/controllers/application"
+
+module Cosmo
+  class Web
+    module Controllers
+      class Batches < Application
+        def index
+          content_for :title, "Batches"
+          ok render("batches/index", layout: true)
+        end
+
+        def _table
+          limit = (params["limit"] || API::Batch::LIMIT).to_i
+          ok render("batches/_table", { batches: API::Batch.all(limit:) })
+        end
+      end
+    end
+  end
+end

data/lib/cosmo/web/controllers/jobs.rb

@@ -76,10 +76,13 @@ module Cosmo
           stream_name, stream_names = streams
           limit = (params["limit"] || API::Stream::LIMIT).to_i
           page = [params["page"].to_i, 1].max
-          stream = API::Stream.new(stream_name)
-          total = stream.total
-          jobs = stream.messages(page:, limit:)
-          total_pages = (total.to_f / limit).ceil
+
+          unless stream_name.to_s.empty?
+            stream = API::Stream.new(stream_name)
+            total = stream.total
+            jobs = stream.messages(page:, limit:)
+            total_pages = (total.to_f / limit).ceil
+          end
 
           ok render("jobs/_enqueued", { jobs:, total:, stream_name:, stream_names:, page:, limit:, total_pages: })
         end

data/lib/cosmo/web/views/batches/_table.erb

@@ -0,0 +1,47 @@
+<% if @batches.empty? -%>
+  <div class="alert alert-success">No batches tracked.</div>
+<% else -%>
+  <div class="table-container">
+    <table>
+      <thead>
+        <tr>
+          <th>Batch</th>
+          <th>Parent</th>
+          <th>Status</th>
+          <th>Total</th>
+          <th>Succeeded</th>
+          <th>Failed</th>
+          <th>Created</th>
+        </tr>
+      </thead>
+      <tbody>
+        <% @batches.each do |b| -%>
+          <% stats = b.stats -%>
+          <tr>
+            <td><code><%= h(b.bid) %></code></td>
+            <td>
+              <% if b.parent_id -%>
+                <code><%= h(b.parent_id) %></code>
+              <% else -%>
+                <span class="text-muted">&mdash;</span>
+              <% end -%>
+            </td>
+            <td>
+              <% if !b.ready? -%>
+                <span class="badge badge-info">Open</span>
+              <% elsif stats[:failed].to_i.positive? -%>
+                <span class="badge badge-danger">Complete</span>
+              <% else -%>
+                <span class="badge badge-success">Success</span>
+              <% end -%>
+            </td>
+            <td><%= format_numbers(stats[:total]) %></td>
+            <td><%= format_numbers(stats[:succeeded]) %></td>
+            <td><%= format_numbers(stats[:failed]) %></td>
+            <td><%= format_timestamp(b.created_at) %></td>
+          </tr>
+        <% end -%>
+      </tbody>
+    </table>
+  </div>
+<% end -%>

data/lib/cosmo/web/views/batches/index.erb

@@ -0,0 +1,10 @@
+<section>
+  <header><%= render('jobs/_tabs') %></header>
+
+  <div id="batches-table"
+       hx-get="<%= url_for('/batches/_table') %>"
+       hx-trigger="load, every 5s"
+       hx-swap="innerHTML">
+    <div class="alert alert-info">Loading batches&hellip;</div>
+  </div>
+</section>