cosmonats 0.1.4 → 0.3.0

data/lib/cosmo/api/stream.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "cosmo/api/job"
+
+module Cosmo
+  module API
+    class Stream
+      LIMIT = 20
+
+      include Enumerable
+
+      def self.all
+        client.list_streams.map { new(_1.dig("config", "name")) }
+      end
+
+      def self.jobs
+        client.list_streams.select { _1.dig("config", "metadata", "_cosmo.type") == "jobs" }
+                           .reject { %w[scheduled dead].include?(_1.dig("config", "name")) }
+                           .map { new(_1.dig("config", "name")) }
+      end
+
+      def self.client
+        @client ||= Client.instance
+      end
+
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      def info
+        info = client.stream_info(name)
+        { state: info.state, config: info.config }
+      end
+
+      def total
+        info[:state].messages.to_i
+      rescue StandardError
+        0
+      end
+      alias size total
+
+      def retries
+        client.list_consumers(name).sum { _1["num_redelivered"].to_i }
+      end
+
+      def each
+        return if total.zero?
+
+        state = info[:state]
+        current = @offset || state.first_seq.to_i
+        last = state.last_seq.to_i
+
+        loop do
+          break if current > last
+
+          job = message(current)
+          break unless job
+
+          yield job
+          current += 1
+        end
+      end
+
+      def offset(value)
+        @offset = value.to_i
+        self
+      end
+
+      def messages(page: nil, limit: nil)
+        jobs = []
+        limit = (limit || LIMIT).to_i
+        state = info[:state]
+        start = state.first_seq.to_i
+        start += (page.to_i - 1) * limit if page
+
+        offset(start).each do |message|
+          jobs << message
+          break if jobs.size >= limit
+        end
+
+        jobs
+      end
+
+      def message(seq)
+        Job.new(name, client.get_message(name, seq: seq, direct: true))
+      rescue NATS::JetStream::Error::NotFound
+        # nop, acked/nacked
+      end
+
+      def retry(seq)
+        job = message(seq)
+        return unless job
+
+        client.publish(job.x_subject, job.message.data)
+        delete(seq)
+      end
+
+      def delete(seq)
+        client.delete_message(name, seq)
+      end
+
+      def pause!
+        client.pause_stream(name)
+      end
+
+      def unpause!
+        client.unpause_stream(name)
+      end
+
+      def paused?
+        client.stream_paused?(name)
+      end
+
+      private
+
+      def client
+        self.class.client
+      end
+    end
+  end
+end

data/lib/cosmo/api.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "cosmo/api/stream"
+require "cosmo/api/counter"
+require "cosmo/api/kv"
+require "cosmo/api/stats"
+
+module Cosmo
+  module API
+  end
+end

data/lib/cosmo/cli.rb

@@ -102,13 +102,16 @@ module Cosmo
           load_config(flags)
           boot_application
 
-          Config[:streams].each do |name, config|
-            Client.instance.stream_info(name)
-          rescue NATS::JetStream::Error::NotFound
-            Client.instance.create_stream(name, config)
+          Config[:setup]&.each_value do |configs|
+            configs.each do |name, config|
+              Client.instance.stream_info(name)
+            rescue NATS::JetStream::Error::NotFound
+              meta = { metadata: { "_cosmo.type" => "jobs" } }
+              Client.instance.create_stream(name, config.merge(meta))
+            end
           end
 
-          puts "Cosmo streams were created/updated"
+          puts "Cosmo streams were created successfully"
           exit(0)
         end
 

data/lib/cosmo/client.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "nats/client"
+require "cosmo/utils/overrides"
 
 module Cosmo
   class Client
@@ -37,16 +38,70 @@ module Cosmo
       js.delete_stream(name, params)
     end
 
+    def update_stream(name, config)
+      js.update_stream(name: name, **config)
+    end
+
     def list_streams
       response = nc.request("$JS.API.STREAM.LIST", "")
       data = Utils::Json.parse(response.data, symbolize_names: false)
       return [] if data.nil? || data["streams"].nil?
 
-      data["streams"].filter_map { _1.dig("config", "name") }
+      data["streams"]
+    end
+
+    def pause_stream(name)
+      config = stream_info(name).config.to_h
+      config[:metadata] ||= {}
+      config[:metadata][:"_cosmo.paused"] = "true"
+      update_stream(name, config)
+    end
+
+    def unpause_stream(name)
+      config = stream_info(name).config.to_h
+      config[:metadata] ||= {}
+      config[:metadata].delete(:"_cosmo.paused")
+      update_stream(name, config)
+    end
+
+    def stream_paused?(name)
+      stream_info(name).config.metadata&.[](:"_cosmo.paused") == "true"
+    rescue NATS::IO::Timeout
+      false
+    end
+
+    def list_consumers(stream_name)
+      response = nc.request("$JS.API.CONSUMER.LIST.#{stream_name}", "")
+      data = Utils::Json.parse(response.data, default: {}, symbolize_names: false)
+      Array(data["consumers"])
+    end
+
+    def consumer_info(stream_name, consumer_name)
+      js.consumer_info(stream_name, consumer_name)
+    end
+
+    def get_message(name, **options)
+      js.get_msg(name, **options)
+    end
+
+    def delete_message(name, seq)
+      response = nc.request("$JS.API.STREAM.MSG.DELETE.#{name}", JSON.dump({ seq: seq }))
+      Utils::Json.parse(response.data, symbolize_names: false)
+    end
+
+    def purge(stream_name, subject)
+      payload = subject ? Utils::Json.dump({ filter: subject }) : ""
+      response = @nc.request("$JS.API.STREAM.PURGE.#{stream_name}", payload)
+      result = Utils::Json.parse(response.data, default: {}, symbolize_names: false)
+      raise NATS::JetStream::Error, result.dig("error", "description") if result["error"]
+
+      result["purged"] # number of messages purged
     end
 
-    def get_message(name, seq)
-      js.get_msg(name, seq: seq)
+    def kv(name, **options)
+      js.key_value(name)
+    rescue NATS::KeyValue::BucketNotFoundError
+      js.create_key_value({ bucket: name }.merge(options))
     end
 
     def close

data/lib/cosmo/config.rb

@@ -4,7 +4,7 @@ require "yaml"
 require "forwardable"
 
 module Cosmo
-  class Config
+  class Config < ::Hash
     NANO = 1_000_000_000
     DEFAULT_PATH = "config/cosmo.yml"
 
@@ -18,7 +18,7 @@ module Cosmo
       YAML.load_file(path, aliases: true).tap { normalize!(_1) }
     end
 
-    def self.normalize!(config) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    def self.normalize!(config) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       Utils::Hash.symbolize_keys!(config)
 
       config[:consumers]&.each_key do |name|
@@ -30,11 +30,13 @@ module Cosmo
         end
       end
 
-      config[:streams]&.each_key do |name|
-        c = config[:streams][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[:subjects] = c[:subjects].map { |s| format(s, name: name) } if c[:subjects]
+      config[:setup]&.each_key do |type|
+        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[:subjects] = c[:subjects].map { |s| format(s, name: name) } if c[:subjects]
+        end
       end
     end
 
@@ -57,45 +59,18 @@ module Cosmo
       @instance ||= new
     end
 
-    def self.system
-      @system ||= {}
-    end
-
-    def initialize
-      @config = nil
-      @system = {}
-      @defaults = self.class.parse_file(File.expand_path("defaults.yml", __dir__))
-    end
-
-    def [](key)
-      dig(key)
-    end
-
-    def fetch(key, default = nil)
-      return @config.fetch(key, default) if @config && Utils::Hash.keys?(@config, key)
-
-      @defaults.fetch(key, default)
-    end
-
-    def dig(*keys)
-      return @config&.dig(*keys) if @config && Utils::Hash.keys?(@config, *keys)
-
-      @defaults.dig(*keys)
-    end
-
-    def to_h
-      Utils::Hash.merge(@defaults, @config)
+    def self.internal
+      @internal ||= {}
     end
 
     def set(...)
-      @config ||= {}
-      Utils::Hash.set(@config, ...)
+      Utils::Hash.set(self, ...)
     end
 
     def load(path = nil)
       return unless path
 
-      @config = self.class.parse_file(path)
+      replace(self.class.parse_file(path))
     end
   end
 end

data/lib/cosmo/engine.rb

@@ -25,7 +25,7 @@ module Cosmo
 
     def run(type, options)
       handler = Utils::Signal.trap(:INT, :TERM)
-      Logger.info "Starting processing, hit Ctrl-C to stop"
+      Logger.info "Starting processing, hit Ctrl-C to stop [concurrency=#{@concurrency}]"
 
       processor_classes = type && PROCESSORS.key?(type.to_sym) ? [PROCESSORS[type.to_sym]] : PROCESSORS.values
       @processors = processor_classes.map { _1.run(@pool, @running, options) }

data/lib/cosmo/job/processor.rb

@@ -3,63 +3,27 @@
 module Cosmo
   module Job
     class Processor < ::Cosmo::Processor
-      def initialize(pool, running, options)
-        super
-        @weights = []
-      end
-
       private
 
-      def run_loop
-        Thread.new { work_loop }
-        Thread.new { schedule_loop }
-      end
-
       def setup
         jobs_config = Config.dig(:consumers, :jobs)
         jobs_config&.each do |stream_name, config|
-          consumer_name = "consumer-#{stream_name}"
-          subject = config.delete(:subject)
-          priority = config.delete(:priority)
-          @weights += ([stream_name] * priority.to_i) if priority
-          subscription = client.subscribe(subject, consumer_name, config)
-          @consumers << [subscription, stream_name]
-        end
-      end
+          next if stream_name == :scheduled # scheduled jobs are handled in schedule_loop
 
-      def work_loop # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/AbcSize
-        shutdown = false
-
-        while running?
-          break if shutdown
-
-          @weights.shuffle.each do |stream_name|
-            break unless running?
-
-            begin
-              timeout = ENV.fetch("COSMO_JOBS_FETCH_TIMEOUT", 0.1).to_f
-              @pool.post do
-                subscription = @consumers.find { |(_, sn)| sn == stream_name }&.first
-                messages = fetch(subscription, batch_size: 1, timeout:)
-                process(messages) if messages&.any?
-              end
-            rescue Concurrent::RejectedExecutionError
-              shutdown = true
-              break # pool doesn't accept new jobs, we are shutting down
-            end
-
-            break unless running?
-          end
+          @consumers << subscribe(stream_name, config)
         end
       end
 
       def schedule_loop # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/AbcSize
+        config = Config.dig(:consumers, :jobs, :scheduled)
+        return unless config
+
+        subscription, = subscribe(:scheduled, config)
         while running?
           break unless running?
 
           now = Time.now.to_i
           timeout = ENV.fetch("COSMO_JOBS_SCHEDULER_FETCH_TIMEOUT", 5).to_f
-          subscription = @consumers.find { |(_, sn)| sn == :scheduled }&.first
           messages = fetch(subscription, batch_size: 100, timeout:)
           messages&.each do |message|
             headers = message.header.except("X-Stream", "X-Subject", "X-Execute-At", "Nats-Expected-Stream")
@@ -80,22 +44,24 @@ module Cosmo
         end
       end
 
-      def process(messages) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+      def process(messages, _) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
         message = messages.first
         Logger.debug "received messages #{messages.inspect}"
         data = Utils::Json.parse(message.data)
         unless data
-          Logger.debug ArgumentError.new("malformed payload")
+          Logger.error ArgumentError.new("malformed payload")
+          move_message(message)
           return
         end
 
         worker_class = Utils::String.safe_constantize(data[:class])
         unless worker_class
-          Logger.debug ArgumentError.new("#{data[:class]} class not found")
+          Logger.error ArgumentError.new("#{data[:class]} class not found")
+          move_message(message, data)
           return
         end
 
-        begin
+        with_stats(message) do
           sw = stopwatch
           Logger.with(jid: data[:jid])
           Logger.info "start"
@@ -104,10 +70,12 @@ module Cosmo
           instance.perform(*data[:args])
           message.ack
           Logger.with(elapsed: sw.elapsed_seconds) { Logger.info "done" }
+          true
         rescue StandardError => e
           Logger.debug e
           Logger.with(elapsed: sw.elapsed_seconds) { Logger.info "fail" }
-          handle_failure(message, data)
+          dropped = handle_failure(message, data)
+          false if dropped
         rescue Exception # rubocop:disable Lint/RescueException
           Logger.with(elapsed: sw.elapsed_seconds) { Logger.info "fail" }
           raise
@@ -117,24 +85,65 @@ module Cosmo
         Logger.debug "processed message #{message.inspect}"
       end
 
-      def handle_failure(message, data) # rubocop:disable Metrics/AbcSize
+      def handle_failure(message, data) # 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 based on max_deliver with exponential backoff
+          # 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) * 1_000_000_000
           message.nak(delay: delay_ns)
-          return
+          return false
         end
 
-        if data[:dead]
-          Client.instance.publish("jobs.dead.#{Utils::String.underscore(data[:class])}", message.data)
-          message.ack
-          Logger.debug "job moved #{data[:jid]} to DLQ"
-        else
-          message.term
-          Logger.debug "job dropped #{data[:jid]}"
+        data[:dead] ? move_message(message, data) : drop_message(message, data)
+        true
+      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))
+        [subscription, config, nil]
+      end
+
+      def drop_message(message, data)
+        message.term
+        Logger.debug "job dropped #{data[:jid]}"
+      end
+
+      def move_message(message, data = nil)
+        klass = data ? Utils::String.underscore(data[:class]) : "default"
+        headers = { "X-Stream" => message.metadata.stream, "X-Subject" => message.subject }
+        Client.instance.publish("jobs.dead.#{klass}", message.data, header: headers)
+        message.ack
+        Logger.debug "job moved #{data&.dig(:jid)} to DLQ"
+      end
+
+      def scheduler?
+        true
+      end
+
+      def consumers
+        @weights ||= @consumers.filter_map { |(_, c, _)| [c[:stream]] * [c[:priority].to_i, 1].max }.flatten
+        @weights.shuffle.map { |s| @consumers.find { |(_, c, _)| c[:stream] == s } }
+      end
+
+      def fetch_subjects(config)
+        config[:subject]
+      end
+
+      def fetch_timeout(_config)
+        ENV.fetch("COSMO_JOBS_FETCH_TIMEOUT", 0.1).to_f
+      end
+
+      def with_stats(message, &block)
+        API::Busy.instance.with(message) do
+          API::Counter.instance.with(&block)
         end
       end
     end

data/lib/cosmo/job.rb

@@ -54,7 +54,7 @@ module Cosmo
       end
     end
 
-    attr_reader :jid
+    attr_accessor :jid
 
     def perform(...)
       raise NotImplementedError, "#{self.class}#perform must be implemented"

data/lib/cosmo/logger.rb

@@ -60,7 +60,14 @@ module Cosmo
     end
 
     def self.instance
-      @instance ||= ::Logger.new($stdout).tap { _1.formatter = SimpleFormatter.new }
+      @instance ||= ::Logger.new($stdout).tap do |logger|
+        logger.formatter = SimpleFormatter.new
+        logger.level = ::Logger::Severity.coerce(ENV.fetch("COSMO_LOG_LEVEL", "info"))
+      end
+    end
+
+    def self.instance=(logger)
+      @instance = logger
     end
   end
 end