cosmonats 0.6.0 → 0.8.0

data/sig/cosmo/api/stats/busy.rbs

@@ -0,0 +1,31 @@
+module Cosmo
+  module API
+    module Stats
+      class Busy < Registry
+        TTL: ::Integer
+        HEARTBEAT: ::Integer
+        BUCKET: ::String
+
+        @messages: Hash[::Integer, Hash[Symbol, untyped]]
+        @thread: Thread?
+        @worker_id: ::String
+
+        def initialize: () -> void
+
+        def with: [T] (untyped message) { () -> T } -> T
+
+        def add: (untyped message) -> void
+
+        def delete: (untyped message) -> void
+
+        def list: (?page: ::Integer?, ?limit: ::Integer) -> Array[Hash[Symbol, untyped]]
+
+        private
+
+        def heartbeat_loop: () -> void
+
+        def worker_id: () -> ::String
+      end
+    end
+  end
+end

data/sig/cosmo/api/stats/metrics.rbs

@@ -0,0 +1,42 @@
+module Cosmo
+  module API
+    module Stats
+      class Metrics < Counter
+        STREAM_NAME: ::String
+        DESCRIPTION: ::String
+        DAY: Integer
+
+        self.@instance: Metrics
+
+        @lock: Thread::Mutex
+        @buffer: Hash[[::String, ::String], Hash[Symbol, Numeric]]
+
+        def self.instance: () -> Metrics
+
+        def self.stream_config: () -> Hash[Symbol, untyped]
+
+        def initialize: () -> void
+
+        def record: (::String job_class, ?exec_ms: Numeric?, ?wait_ms: Numeric?, ?failed: bool) -> void
+
+        def flush: () -> void
+
+        def summary: (?days: Integer) -> Array[Hash[Symbol, untyped]]
+
+        def daily: (::String job_class, ?days: Integer) -> Array[Hash[Symbol, untyped]]
+
+        private
+
+        def buffer: () -> Hash[[::String, ::String], Hash[Symbol, Numeric]]
+
+        def read: (Integer days) -> Array[[[::String, ::String, Symbol], Integer]]
+
+        def dates: (Integer days) -> Array[::String]
+
+        def row: (Hash[Symbol, Numeric] sums) -> Hash[Symbol, untyped]
+
+        def average: (Numeric total, Numeric count) -> Float?
+      end
+    end
+  end
+end

data/sig/cosmo/api/stats/processes.rbs

@@ -0,0 +1,19 @@
+module Cosmo
+  module API
+    module Stats
+      class Processes < Registry
+        TTL: ::Integer
+        BUCKET: ::String
+        KINDS: Array[::String]
+
+        def self.kind: (Hash[Symbol, untyped] process) -> ::String
+
+        def list: (?page: ::Integer?, ?limit: ::Integer) -> Array[Hash[Symbol, untyped]]
+
+        def register: (::String identity, Hash[Symbol, untyped] info) -> void
+
+        def unregister: (::String identity) -> void
+      end
+    end
+  end
+end

data/sig/cosmo/api/stats/totals.rbs

@@ -0,0 +1,18 @@
+module Cosmo
+  module API
+    module Stats
+      class Totals < Counter
+        STREAM_NAME: ::String
+        DESCRIPTION: ::String
+
+        self.@instance: Totals
+
+        def self.instance: () -> Totals
+
+        def processed: () -> ::Integer
+
+        def failed: () -> ::Integer
+      end
+    end
+  end
+end

data/sig/cosmo/batch/counters.rbs

@@ -0,0 +1,10 @@
+module Cosmo
+  class Batch
+    class Counters < API::Counter
+      STREAM_NAME: ::String
+      DESCRIPTION: ::String
+
+      def self.stream_config: () -> Hash[Symbol, untyped]
+    end
+  end
+end

data/sig/cosmo/batch.rbs

@@ -3,17 +3,16 @@ module Cosmo
     extend Dispatcher
 
     BUCKET: ::String
-    DEFAULT_EXPIRY: ::String
     EVENTS: ::Array[Symbol]
 
-    self.@counter: API::Counter
+    self.@counter: Batch::Counters
     self.@kv: API::KV
 
     def self.current: () -> Batch?
 
     def self.notify: (::String bid, ::String jid, success: bool) -> void
 
-    def self.counter: () -> API::Counter
+    def self.counter: () -> Batch::Counters
 
     def self.kv: () -> API::KV
 
@@ -36,7 +35,7 @@ module Cosmo
 
     private
 
-    def counter: () -> API::Counter
+    def counter: () -> Batch::Counters
 
     def kv: () -> API::KV
 

data/sig/cosmo/cli.rbs

@@ -8,6 +8,10 @@ module Cosmo
 
     def self.banner: () -> ::String
 
+    @argv: Array[::String]?
+
+    attr_reader argv: Array[::String]?
+
     def run: () -> void
 
     private
@@ -16,6 +20,8 @@ module Cosmo
 
     def load_config: (Hash[Symbol, untyped] flags) -> void
 
+    def run_init: () -> void
+
     def boot_application: () -> void
 
     def require_path: (::String? path) -> void

data/sig/cosmo/client.rbs

@@ -1,15 +1,26 @@
 module Cosmo
   class Client
+    JS_TIMEOUT: ::Integer
+    CONNECT_TIMEOUT: ::Integer
+
+    attr_reader name: ::String
+
+    def self.default_name: () -> ::String
+    def self.js_timeout: () -> ::Integer
+    def self.connect_timeout: () -> ::Integer
+    def self.program_name: () -> ::String
+
     self.@instance: Client
     @nc: untyped
     @js: untyped
+    @name: ::String
 
     def self.instance: () -> Client
 
     attr_reader nc: untyped
     attr_reader js: untyped
 
-    def initialize: (?nats_url: ::String) -> void
+    def initialize: (?nats_url: ::String, ?name: ::String) -> void
 
     def publish: (::String subject, ::String payload, **untyped params) -> untyped
 
@@ -43,6 +54,8 @@ module Cosmo
 
     def get_message: (::String | Symbol name, **untyped options) -> NATS::JetStream::API::RawStreamMsg
 
+    def last_messages: (::String stream_name, Array[::String] filters) -> Hash[::String, ::String]
+
     def delete_message: (::String name, ::Integer seq) -> Hash[::String, untyped]
 
     def purge: (::String stream_name, ::String? subject) -> ::Integer?
@@ -55,6 +68,6 @@ module Cosmo
 
     def ephemeral_subscribe: (::String | Array[::String] subject, Hash[Symbol, untyped] config) -> untyped
 
-    def create_kv_with_msg_ttl: (::String name, **untyped opts) -> untyped
+    def create_kv_with_msg_ttl: (::String name, ?replicas: Integer, **untyped opts) -> untyped
   end
 end

data/sig/cosmo/config/settings.rbs

@@ -0,0 +1,31 @@
+module Cosmo
+  class Config < ::Hash[Symbol, untyped]
+    class Scheduled
+      attr_accessor enabled: bool
+
+      def self.new: (enabled: bool) -> Scheduled
+    end
+
+    class Dead
+      attr_accessor enabled: bool
+      attr_accessor max_age: Numeric | ::String
+      attr_accessor max_msgs: Integer
+      attr_accessor max_bytes: Integer
+
+      def self.new: (enabled: bool, max_age: Numeric | ::String, max_msgs: Integer, max_bytes: Integer) -> Dead
+    end
+
+    class Batches
+      attr_accessor expiry: Numeric | ::String
+
+      def self.new: (expiry: Numeric | ::String) -> Batches
+    end
+
+    class Metrics
+      attr_accessor enabled: bool
+      attr_accessor retention: Numeric | ::String
+
+      def self.new: (enabled: bool, retention: Numeric | ::String) -> Metrics
+    end
+  end
+end

data/sig/cosmo/config.rbs

@@ -2,6 +2,8 @@ module Cosmo
   class Config < ::Hash[Symbol, untyped]
     NANO: Integer
     DEFAULT_PATH: ::String
+    DEFAULTS_FILE: ::String
+    SERVICE_STREAMS: Array[Symbol]
 
     self.@instance: Config
     self.@internal: Hash[Symbol, untyped]
@@ -12,8 +14,14 @@ module Cosmo
 
     def self.to_ns: (Numeric seconds) -> ::Integer
 
+    def self.read: (::String path) -> Hash[Symbol, untyped]
+
     def self.parse_file: (::String path) -> Hash[Symbol, untyped]
 
+    def self.build: (Hash[Symbol, untyped] user) -> Hash[Symbol, untyped]
+
+    def self.validate!: (Hash[Symbol, untyped] config) -> void
+
     def self.normalize!: (Hash[Symbol, untyped] config) -> void
 
     def self.deliver_policy: (Symbol | ::String | Time start_position) -> Hash[Symbol, ::String]
@@ -24,15 +32,61 @@ module Cosmo
 
     def self.dig: (*Symbol keys) -> untyped
 
-    def self.to_h: () -> Hash[Symbol, untyped]
+    def self.load: (?::String? path, ?overrides: Hash[Symbol, untyped]?) -> void
+
+    def self.replicas: () -> Integer
+
+    def self.scheduled: () -> Scheduled
+
+    def self.dead: () -> Dead
+
+    def self.batches: () -> Batches
+
+    def self.metrics: () -> Metrics
+
+    def self.server_middleware: () ?{ (Middleware::Chain chain) -> void } -> Middleware::Chain
+
+    def self.client_middleware: () ?{ (Middleware::Chain chain) -> void } -> Middleware::Chain
+
+    def self.error_handlers: () -> Array[untyped]
+
+    @server_middleware: Middleware::Chain
+
+    def load: (?::String? path, ?overrides: Hash[Symbol, untyped]?) -> void
+
+    def server_middleware: () ?{ (Middleware::Chain chain) -> void } -> Middleware::Chain
+
+    @client_middleware: Middleware::Chain
+
+    def client_middleware: () ?{ (Middleware::Chain chain) -> void } -> Middleware::Chain
+
+    @error_handlers: Array[untyped]
+
+    def error_handlers: () -> Array[untyped]
+
+    @replicas: Integer?
+    @scheduled: Scheduled
+    @dead: Dead
+    @batches: Batches
+
+    attr_writer replicas: Integer
+
+    def replicas: () -> Integer
+
+    def scheduled: () -> Scheduled
+
+    def dead: () -> Dead
+
+    def batches: () -> Batches
 
-    def self.set: (*untyped) -> untyped
+    @metrics: Metrics
 
-    def self.load: (?::String? path) -> void
+    def metrics: () -> Metrics
 
+    def logger: () -> untyped
 
-    def set: (*untyped) -> untyped
+    def logger=: (untyped logger) -> void
 
-    def load: (?::String? path) -> void
+    def log_level=: (Symbol | ::String | Integer level) -> void
   end
 end

data/sig/cosmo/engine.rbs

@@ -6,16 +6,45 @@ module Cosmo
     @concurrency: Integer
     @pool: Utils::ThreadPool
     @running: untyped
+    @quiet: untyped
     @processors: Array[Processor]
+    @http_server: HTTPServer?
+    @heartbeat: Heartbeat?
 
     def self.run: (*untyped) -> void
 
+    def self.processors_for: ((::String | Symbol)? type) -> Array[Class]
+
     def self.instance: () -> Engine
 
+    attr_reader concurrency: Integer
+
     def initialize: () -> void
 
     def run: (::String? type, Hash[Symbol, untyped] options) -> void
 
+    def running?: () -> bool
+
+    def state: () -> ::String
+
+    def busy: () -> Integer
+
+    def subscriptions: () -> Hash[Symbol, Array[::String]]
+
     def shutdown: () -> void
+
+    private
+
+    def start_http_server: () -> void
+
+    def handle_shutdown: (Utils::Signal handler) -> Symbol
+
+    def quiet: () -> void
+
+    def unquiet: () -> void
+
+    def drain_and_exit: (Utils::Signal handler) -> void
+
+    def dump_threads: () -> void
   end
 end

data/sig/cosmo/heartbeat.rbs

@@ -0,0 +1,38 @@
+module Cosmo
+  class Heartbeat
+    INTERVAL: ::Integer
+
+    @engine: Engine
+    @options: Hash[Symbol, untyped]
+    @started_at: ::Integer
+    @thread: Thread?
+    @identity: ::String
+    @static_info: Hash[Symbol, untyped]
+
+    def initialize: (Engine engine, ?options: Hash[Symbol, untyped]) -> void
+
+    def start: () -> self
+
+    def stop: () -> void
+
+    def beat: () -> void
+
+    def flush: () -> void
+
+    def identity: () -> ::String
+
+    def info: () -> Hash[Symbol, untyped]
+
+    private
+
+    def static_info: () -> Hash[Symbol, untyped]
+
+    def nats_info: () -> Hash[Symbol, untyped]
+
+    def rtt: (untyped connection) -> ::Float?
+
+    def rss: () -> ::Integer?
+
+    def processes: () -> API::Stats::Processes
+  end
+end

data/sig/cosmo/http_server/handler.rbs

@@ -0,0 +1,17 @@
+module Cosmo
+  class HTTPServer
+    class Handler < ::WEBrick::HTTPServlet::AbstractServlet
+      @app: untyped
+
+      def initialize: (untyped server, untyped app) -> void
+
+      def service: (untyped req, untyped res) -> void
+
+      private
+
+      def env_for: (untyped req) -> Hash[String, untyped]
+
+      def write_headers: (untyped res, Hash[String, untyped] headers) -> void
+    end
+  end
+end

data/sig/cosmo/http_server/health.rbs

@@ -0,0 +1,21 @@
+module Cosmo
+  class HTTPServer
+    class Health
+      PATH: String
+      HEADERS: Hash[String, String]
+
+      @app: untyped
+      @check: ^() -> Hash[Symbol, bool]
+
+      def initialize: (untyped app, ?check: (^() -> Hash[Symbol, bool])?) -> void
+
+      def call: (Hash[String, untyped] env) -> [Integer, Hash[String, String], Array[String]]
+
+      private
+
+      def default_check: () -> Hash[Symbol, bool]
+
+      def nats_connected?: () -> bool
+    end
+  end
+end

data/sig/cosmo/http_server/ping.rbs

@@ -0,0 +1,14 @@
+module Cosmo
+  class HTTPServer
+    class Ping
+      PATH: String
+      HEADERS: Hash[String, String]
+
+      @app: untyped
+
+      def initialize: (untyped app) -> void
+
+      def call: (Hash[String, untyped] env) -> [Integer, Hash[String, String], Array[String]]
+    end
+  end
+end

data/sig/cosmo/http_server.rbs

@@ -0,0 +1,22 @@
+module Cosmo
+  class HTTPServer
+    DEFAULT_HOST: String
+    NOT_FOUND: [Integer, Hash[String, String], Array[String]]
+
+    @app: untyped
+    @host: String
+    @port: Integer
+    @server: untyped
+    @thread: Thread?
+
+    def self.app: () -> untyped
+
+    def initialize: (?untyped app, port: Integer, ?host: String) -> void
+
+    def start: () -> self
+
+    def stop: () -> void
+
+    def port: () -> Integer
+  end
+end

data/sig/cosmo/job/data.rbs

@@ -17,16 +17,18 @@ module Cosmo
 
       def stream: (?target: bool) -> Symbol
 
-      def subject: (?target: bool) -> Array[::String]
+      def subject: () -> ::String
+
+      def headers: () -> Hash[::String, untyped]
 
       def as_json: () -> { jid: ::String, class: ::String, args: Array[untyped], retry: Integer, dead: bool }
 
       def to_json: (*untyped _args) -> ::String?
 
-      def to_args: () -> [::String, ::String, Hash[Symbol, untyped]]
-
       private
 
+      def subject_for: (Symbol | ::String stream) -> ::String
+
       def validate!: () -> void
 
       def retries: () -> Integer

data/sig/cosmo/job/enqueuer.rbs

@@ -0,0 +1,11 @@
+module Cosmo
+  module Job
+    module Enqueuer
+      def self.enqueue: (::String class_name, Array[untyped] args, Hash[Symbol, untyped] options, ?batch: Batch?) -> ::String?
+
+      def self.pipe: (::String class_name, Data data) -> bool
+
+      def self.publish: (Data data, Hash[Symbol, untyped] payload) -> untyped
+    end
+  end
+end

data/sig/cosmo/job/failure.rbs

@@ -0,0 +1,28 @@
+module Cosmo
+  module Job
+    class Failure
+      HEADER_LIMIT: Integer
+      BACKTRACE_LINES: Integer
+      BACKTRACE_SEPARATOR: String
+
+      @exception: Exception
+      @backtrace: ::String?
+
+      def self.headers: (Exception exception) -> Hash[::String, ::String]
+
+      def initialize: (Exception exception) -> void
+
+      def headers: () -> Hash[::String, ::String]
+
+      private
+
+      def name: () -> ::String
+
+      def message: () -> ::String
+
+      def backtrace: () -> ::String
+
+      def single_line: (untyped value) -> ::String
+    end
+  end
+end

data/sig/cosmo/job/processor.rbs

@@ -1,13 +1,27 @@
 module Cosmo
   module Job
     class Processor < ::Cosmo::Processor
+      DISPATCH_HEADERS: ::Array[::String]
+
       @weights: Array[Symbol]?
 
+      def self.validate_options!: (Hash[Symbol, untyped] options) -> void
+
+      def subscriptions: () -> Array[::String]
+
       private
 
       def setup: () -> void
 
+      def log_subscriptions: () -> void
+
+      def scheduled_config: () -> Hash[Symbol, untyped]?
+
+      def consumer_name: (::String | Symbol stream_name) -> ::String
+
       def schedule_loop: () -> void
+      def scheduled_by: (untyped message) -> ::String?
+      def enqueued_at: (untyped message) -> ::Time
 
       def scheduler?: () -> bool
 
@@ -37,13 +51,13 @@ module Cosmo
 
       def drop_message: (untyped message, Hash[Symbol, untyped] data) -> void
 
-      def move_message: (untyped message, ?Hash[Symbol, untyped]? data) -> void
+      def reject_message: (untyped message, Exception error, ?Hash[Symbol, untyped]? data) -> void
 
-      def with_stats: (untyped message) { () -> untyped } -> void
+      def error_context: (untyped message, Hash[Symbol, untyped]? data, ?source: Symbol) -> Hash[Symbol, untyped]
 
-      def acquire_concurrency_slot: (untyped worker_class, untyped message, Hash[Symbol, untyped] data) -> (::String | false)
+      def move_message: (untyped message, ?Hash[Symbol, untyped]? data, ?Exception? exception) -> void
 
-      def perform_job: (untyped job_instance, data: Hash[Symbol, untyped], message: untyped, ?duration: Float?) -> untyped
+      def perform_job: (untyped job_instance, data: Hash[Symbol, untyped], message: untyped) -> untyped
     end
   end
 end

data/sig/cosmo/job/requeue.rbs

@@ -0,0 +1,9 @@
+module Cosmo
+  module Job
+    class Requeue < StandardError
+      attr_reader delay: Numeric
+
+      def initialize: (?Numeric delay) -> void
+    end
+  end
+end

data/sig/cosmo/job/stream_filter.rbs

@@ -0,0 +1,25 @@
+module Cosmo
+  module Job
+    class StreamFilter
+      SCHEDULED: Symbol
+      ENV_NAME: ::String
+
+      @names: Array[::String]
+      @configured: Array[::String]?
+
+      def self.from: (Array[::String]? names) -> StreamFilter
+
+      def initialize: (Array[::String]? names) -> void
+
+      def all?: () -> bool
+
+      def include?: (::String | Symbol stream_name) -> bool
+
+      def validate!: () -> StreamFilter
+
+      private
+
+      def configured: () -> Array[::String]
+    end
+  end
+end

data/sig/cosmo/job.rbs

@@ -31,8 +31,6 @@ module Cosmo
       private
 
       def client: () -> Client
-
-      def publish: (Data data, Batch? batch) -> void
     end
 
     attr_accessor jid: ::String

data/sig/cosmo/logger.rbs

@@ -45,5 +45,11 @@ module Cosmo
     def self.without: (*Symbol) -> nil
 
     def self.instance: () -> untyped
+
+    def self.instance=: (untyped logger) -> void
+
+    def self.level=: (Symbol | ::String | Integer level) -> void
+
+    def self.coerce_level: (Symbol | ::String | Integer level) -> Integer
   end
 end