cosmonats 0.8.0 → 0.9.0

data/lib/cosmo/web.rb

@@ -3,12 +3,16 @@
 require "rack"
 require "json"
 require "erb"
+require "zlib"
+require "cosmo/web/cache"
+require "cosmo/web/circuit"
 require "cosmo/web/context"
 require "cosmo/web/renderer"
 require "cosmo/web/controllers/application"
+require "cosmo/web/controllers/overview"
 require "cosmo/web/controllers/jobs"
+require "cosmo/web/controllers/processes"
 require "cosmo/web/controllers/streams"
-require "cosmo/web/controllers/actions"
 require "cosmo/web/controllers/crons"
 require "cosmo/web/controllers/batches"
 require "cosmo/web/controllers/metrics"
@@ -17,57 +21,84 @@ module Cosmo
   class Web
     include Renderer
 
+    FONT_HEADERS = { "cache-control" => "public, max-age=31536000, immutable" }.freeze
+
     def self.call(env)
       new.call(env)
     end
 
-    def call(env) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+    # Serves the UI. An htmx refresh is shared through Cache with concurrent and recent identical ones; any other
+    # method than GET changes something, so it empties the cache. While Circuit is open, anything but an asset
+    # answers 503 at once instead of waiting on NATS.
+    def call(env) # rubocop:disable Metrics/AbcSize
       @request = Rack::Request.new(env)
+      return route if @request.path_info.start_with?("/assets/", "/favicon.ico")
+      return guarded.tap { Cache.instance.clear } unless @request.get?
+      return guarded unless @request.get_header("HTTP_HX_REQUEST") == "true"
+
+      status, headers, body = Cache.instance.fetch(@request.fullpath) { guarded }
+      [status, headers.dup, body.dup]
+    rescue *Circuit::ERRORS
+      Circuit.instance.trip!
+      unavailable
+    end
+
+    private
+
+    def route # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
       path     = @request.path_info
       method   = @request.request_method
 
       response = case [method.downcase.to_sym, path]
-                 in [:get,    "/"]                      then redirect_to("/jobs")
-                 in [:get,    "/jobs"]                  then [Controllers::Jobs,    :index]
-                 in [:get,    "/jobs/scheduled"]        then [Controllers::Jobs,    :scheduled]
-                 in [:get,    "/jobs/dead"]             then [Controllers::Jobs,    :dead]
-                 in [:get,    "/jobs/busy"]             then [Controllers::Jobs,    :busy]
-                 in [:get,    "/jobs/enqueued"]         then [Controllers::Jobs,    :enqueued]
-                 in [:patch,  %r{/jobs/retry/\d+}]      then [Controllers::Jobs,    :retry]
-                 in [:delete, %r{/jobs/delete/\d+}]     then [Controllers::Jobs,    :delete]
-                 in [:delete, %r{/jobs/enqueued/\d+}]   then [Controllers::Jobs,    :delete_enqueued]
-                 in [:get,    "/jobs/_stats"]           then [Controllers::Jobs,    :_stats]
-                 in [:get,    "/jobs/_scheduled"]       then [Controllers::Jobs,    :_scheduled]
-                 in [:get,    "/jobs/_dead"]            then [Controllers::Jobs,    :_dead]
-                 in [:get,    "/jobs/_busy"]            then [Controllers::Jobs,    :_busy]
-                 in [:get,    "/jobs/_processes"]       then [Controllers::Jobs,    :_processes]
-                 in [:get,    "/jobs/_enqueued"]        then [Controllers::Jobs,    :_enqueued]
-                 in [:get,    "/streams"]               then [Controllers::Streams, :index]
-                 in [:get,    "/streams/info"]          then [Controllers::Streams, :info]
-                 in [:get,    "/streams/_table"]        then [Controllers::Streams, :_table]
-                 in [:get,    "/streams/_info"]         then [Controllers::Streams, :_info]
-                 in [:patch,  "/streams/pause"]         then [Controllers::Streams, :pause]
-                 in [:patch,  "/streams/unpause"]       then [Controllers::Streams, :unpause]
-                 in [:get,    "/crons"]                 then [Controllers::Crons,   :index]
-                 in [:get,    "/crons/_table"]          then [Controllers::Crons,   :_table]
-                 in [:delete, "/crons/delete"]          then [Controllers::Crons,   :delete]
-                 in [:post,   "/crons/run"]             then [Controllers::Crons,   :run_now]
-                 in [:get,    "/metrics"]               then [Controllers::Metrics, :index]
-                 in [:get,    "/metrics/_panel"]        then [Controllers::Metrics, :_panel]
-                 in [:get,    "/batches"]               then [Controllers::Batches, :index]
-                 in [:get,    "/batches/_table"]        then [Controllers::Batches, :_table]
-                 in [:get,    "/actions"]               then [Controllers::Actions, :index]
+                 in [:get,    "/" | ""]                 then [Controllers::Overview,  :index]
+                 in [:get,    "/_kpis"]                 then [Controllers::Overview,  :_kpis]
+                 in [:get,    "/_throughput"]           then [Controllers::Overview,  :_throughput]
+                 in [:get,    "/_workers"]              then [Controllers::Overview,  :_workers]
+                 in [:get,    "/_running"]              then [Controllers::Overview,  :_running]
+                 in [:get,    "/_badges"]               then [Controllers::Overview,  :_badges]
+                 in [:get,    "/jobs"]                  then [Controllers::Jobs,      :index]
+                 in [:get,    "/jobs/busy"]             then [Controllers::Jobs,      :busy]
+                 in [:get,    "/jobs/enqueued"]         then [Controllers::Jobs,      :enqueued]
+                 in [:get,    "/jobs/scheduled"]        then [Controllers::Jobs,      :scheduled]
+                 in [:get,    "/jobs/dead"]             then [Controllers::Jobs,      :dead]
+                 in [:get,    "/jobs/_queues"]          then [Controllers::Jobs,      :_queues]
+                 in [:patch,  %r{/jobs/retry/\d+}]      then [Controllers::Jobs,      :retry]
+                 in [:delete, %r{/jobs/delete/\d+}]     then [Controllers::Jobs,      :delete]
+                 in [:delete, %r{/jobs/enqueued/\d+}]   then [Controllers::Jobs,      :delete_enqueued]
+                 in [:get,    "/processes"]             then [Controllers::Processes, :index]
+                 in [:get,    "/streams"]               then [Controllers::Streams,   :index]
+                 in [:get,    "/streams/info"]          then [Controllers::Streams,   :info]
+                 in [:patch,  "/streams/pause"]         then [Controllers::Streams,   :pause]
+                 in [:patch,  "/streams/unpause"]       then [Controllers::Streams,   :unpause]
+                 in [:get,    "/crons"]                 then [Controllers::Crons,     :index]
+                 in [:get,    "/crons/_table"]          then [Controllers::Crons,     :_table]
+                 in [:delete, "/crons/delete"]          then [Controllers::Crons,     :delete]
+                 in [:post,   "/crons/run"]             then [Controllers::Crons,     :run_now]
+                 in [:get,    "/metrics"]               then [Controllers::Metrics,   :index]
+                 in [:get,    "/metrics/_panel"]        then [Controllers::Metrics,   :_panel]
+                 in [:get,    "/batches"]               then [Controllers::Batches,   :index]
+                 in [:get,    "/batches/_table"]        then [Controllers::Batches,   :_table]
                  in [:get,    "/assets/htmx.min.js.gz"] then serve("htmx.2.0.8.min.js.gz",
                                                                    "application/javascript",
                                                                    { "content-encoding" => "gzip" })
-                 in [:get, "/assets/app.css"]         then serve("app.css", "text/css")
-                 in [:get, "/favicon.ico"]            then no_content
+                 in [:get, "/assets/app.css"]              then serve("app.css", "text/css")
+                 in [:get, "/assets/app.js"]               then serve("app.js", "application/javascript")
+                 in [:get, "/assets/logo.svg"]             then serve("logo.svg", "image/svg+xml")
+                 in [:get, "/assets/fonts/geist.woff2"]    then serve("fonts/geist.woff2", "font/woff2", FONT_HEADERS)
+                 in [:get, "/assets/fonts/geist-mono.woff2"] then serve("fonts/geist-mono.woff2", "font/woff2", FONT_HEADERS)
+                 in [:get, "/favicon.ico"] then redirect_to("/assets/logo.svg", 301)
                  else not_found
                  end
       handler(response)
     end
 
-    private
+    def guarded
+      Circuit.instance.open? ? unavailable : route
+    end
+
+    def unavailable
+      Controllers::Application.new(@request).unavailable
+    end
 
     def handler(response)
       if response[0].is_a?(Class)

data/sig/cosmo/api/cron/entry.rbs

@@ -19,7 +19,8 @@ module Cosmo
         def schedule_subject: () -> ::String
         def target_subject: () -> ::String
         def dispatch_subject: () -> ::String
-        def schedule_headers: () -> Hash[::String, ::String]
+        def schedule: () -> Hash[Symbol, ::String]
+        def headers: () -> Hash[::String, ::String]
         def job_name: () -> ::String
         def job_payload: () -> ::String
         def as_json: () -> Hash[Symbol, untyped]

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

@@ -20,6 +20,8 @@ module Cosmo
 
         def list: (?page: ::Integer?, ?limit: ::Integer) -> Array[Hash[Symbol, untyped]]
 
+        def by_stream: () -> Hash[::String, ::Integer]
+
         private
 
         def heartbeat_loop: () -> void

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

@@ -23,7 +23,7 @@ module Cosmo
 
         def summary: (?days: Integer) -> Array[Hash[Symbol, untyped]]
 
-        def daily: (::String job_class, ?days: Integer) -> Array[Hash[Symbol, untyped]]
+        def daily: (?::String? job_class, ?days: Integer) -> Array[Hash[Symbol, untyped]]
 
         private
 

data/sig/cosmo/api/stats.rbs

@@ -16,6 +16,10 @@ module Cosmo
       def self.scheduled: () -> ::Integer
 
       def self.dead: () -> ::Integer
+
+      def self.queues: () -> Array[Hash[Symbol, untyped]]
+
+      def self.queue: (Stream stream, ?Hash[::String, ::Integer] busy) -> Hash[Symbol, untyped]
     end
   end
 end

data/sig/cosmo/api/stream.rbs

@@ -26,6 +26,8 @@ module Cosmo
 
       def retries: () -> ::Integer
 
+      def consumers: () -> Array[Hash[::String, untyped]]
+
       def each: () { (Job) -> void } -> void
 
       def messages: (?page: ::Integer?, ?limit: ::Integer?) -> Array[Job]

data/sig/cosmo/client.rbs

@@ -2,6 +2,7 @@ module Cosmo
   class Client
     JS_TIMEOUT: ::Integer
     CONNECT_TIMEOUT: ::Integer
+    MAX_RECONNECT_ATTEMPTS: ::Integer
 
     attr_reader name: ::String
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cosmonats
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Dmitry Vorotilin
@@ -43,20 +43,20 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '2.7'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '2.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '2.7'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '2.8'
 description: Lightweight background and stream processing for Ruby
 email:
 - d.vorotilin@gmail.com
@@ -131,54 +131,67 @@ files:
 - lib/cosmo/utils/duration.rb
 - lib/cosmo/utils/hash.rb
 - lib/cosmo/utils/json.rb
-- lib/cosmo/utils/overrides.rb
 - lib/cosmo/utils/signal.rb
 - lib/cosmo/utils/stopwatch.rb
 - lib/cosmo/utils/string.rb
 - lib/cosmo/utils/thread_pool.rb
 - lib/cosmo/utils/ttl_cache.rb
-- lib/cosmo/utils/warnings.rb
 - lib/cosmo/version.rb
 - lib/cosmo/web.rb
 - lib/cosmo/web/assets/app.css
+- lib/cosmo/web/assets/app.js
+- lib/cosmo/web/assets/fonts/OFL.txt
+- lib/cosmo/web/assets/fonts/geist-mono.woff2
+- lib/cosmo/web/assets/fonts/geist.woff2
 - lib/cosmo/web/assets/htmx.2.0.8.min.js.gz
+- lib/cosmo/web/assets/logo.svg
+- lib/cosmo/web/cache.rb
 - lib/cosmo/web/chart.rb
+- lib/cosmo/web/circuit.rb
 - lib/cosmo/web/context.rb
-- lib/cosmo/web/controllers/actions.rb
 - lib/cosmo/web/controllers/application.rb
 - lib/cosmo/web/controllers/batches.rb
 - lib/cosmo/web/controllers/crons.rb
 - lib/cosmo/web/controllers/jobs.rb
 - lib/cosmo/web/controllers/metrics.rb
+- lib/cosmo/web/controllers/overview.rb
+- lib/cosmo/web/controllers/processes.rb
 - lib/cosmo/web/controllers/streams.rb
 - lib/cosmo/web/helpers/application.rb
 - lib/cosmo/web/renderer.rb
-- lib/cosmo/web/views/actions/index.erb
+- lib/cosmo/web/throughput.rb
 - lib/cosmo/web/views/batches/_table.erb
 - lib/cosmo/web/views/batches/index.erb
 - lib/cosmo/web/views/crons/_table.erb
 - lib/cosmo/web/views/crons/index.erb
+- lib/cosmo/web/views/jobs/_args.erb
 - lib/cosmo/web/views/jobs/_busy.erb
 - lib/cosmo/web/views/jobs/_dead.erb
 - lib/cosmo/web/views/jobs/_enqueued.erb
-- lib/cosmo/web/views/jobs/_processes.erb
+- lib/cosmo/web/views/jobs/_panel.erb
+- lib/cosmo/web/views/jobs/_queue_row.erb
+- lib/cosmo/web/views/jobs/_queues.erb
 - lib/cosmo/web/views/jobs/_scheduled.erb
-- lib/cosmo/web/views/jobs/_stats.erb
-- lib/cosmo/web/views/jobs/_tabs.erb
-- lib/cosmo/web/views/jobs/busy.erb
-- lib/cosmo/web/views/jobs/dead.erb
-- lib/cosmo/web/views/jobs/enqueued.erb
 - lib/cosmo/web/views/jobs/index.erb
-- lib/cosmo/web/views/jobs/scheduled.erb
 - lib/cosmo/web/views/layout.erb
 - lib/cosmo/web/views/metrics/_chart.erb
 - lib/cosmo/web/views/metrics/_panel.erb
 - lib/cosmo/web/views/metrics/_table.erb
 - lib/cosmo/web/views/metrics/index.erb
+- lib/cosmo/web/views/overview/_badges.erb
+- lib/cosmo/web/views/overview/_kpis.erb
+- lib/cosmo/web/views/overview/_running.erb
+- lib/cosmo/web/views/overview/_throughput.erb
+- lib/cosmo/web/views/overview/_workers.erb
+- lib/cosmo/web/views/overview/index.erb
+- lib/cosmo/web/views/processes/_table.erb
+- lib/cosmo/web/views/processes/index.erb
+- lib/cosmo/web/views/shared/_pager.erb
+- lib/cosmo/web/views/shared/unavailable.erb
 - lib/cosmo/web/views/streams/_info.erb
+- lib/cosmo/web/views/streams/_list.erb
 - lib/cosmo/web/views/streams/_pause_banner.erb
-- lib/cosmo/web/views/streams/_stream_row.erb
-- lib/cosmo/web/views/streams/_table.erb
+- lib/cosmo/web/views/streams/_stream.erb
 - lib/cosmo/web/views/streams/index.erb
 - lib/cosmo/web/views/streams/info.erb
 - lib/cosmonats.rb

data/lib/cosmo/utils/overrides.rb

@@ -1,206 +0,0 @@
-# frozen_string_literal: true
-
-Cosmo::Utils::Warnings.silence do
-  unless NATS::JetStream::API::StreamConfig.members.include?(:allow_msg_schedules)
-    members = NATS::JetStream::API::StreamConfig.members + %i[allow_msg_counter allow_msg_schedules]
-    NATS::JetStream::API::StreamConfig = Struct.new(*members, keyword_init: true) do
-      def initialize(opts = {})
-        rem = opts.keys - members
-        opts.delete_if { |k| rem.include?(k) }
-        super
-      end
-    end
-  end
-
-  unless NATS::JetStream::PubAck.members.include?(:val)
-    members = NATS::JetStream::PubAck.members + [:val]
-    NATS::JetStream::PubAck = Struct.new(*members, keyword_init: true)
-  end
-end
-
-# Upstream bug in nats-pure 2.5.0 and 2.6.0 (https://github.com/nats-io/nats-pure.rb):
-# NATS::JetStream::PullSubscription#fetch only assigns its `start_time` local in the
-# `batch > 1` branch, but the final "did we time out" check outside the case statement
-# reads it unconditionally. For `batch == 1` (what Cosmo::Processor always uses),
-# `start_time` is nil there -- normally masked because the `batch == 1` branch has its
-# own timeout check (using a properly-set `t`) that raises first.
-#
-# It only surfaces once two threads call #fetch concurrently on the *same* subscription:
-# @pending_queue/wait_for_msgs_cond are shared per-subscription state, and #dispatch's
-# `wait_for_msgs_cond.signal` wakes exactly one arbitrary waiter -- not necessarily the
-# one whose own request produced that wakeup. A thread woken by someone else's signal
-# finds nothing left in the (already-drained) queue, so it skips its own inner timeout
-# check and falls into the buggy tail check, raising `TypeError: nil can't be coerced
-# into Float` instead of the intended timeout/empty result. Reproduced deterministically
-# with N threads fetching in a loop against the same PullSubscription.
-#
-# Second, separate upstream bug in the same method: the post-wait timeout check below
-# (`raise ... if MonotonicTime.since(t) > timeout`) fires unconditionally, unlike every
-# other timeout check in this method (all guarded with `msgs.empty? &&`). If the unsynchronized
-# pop just above it succeeded in grabbing a real, already-delivered message -- which can happen
-# even after `timeout` has technically elapsed, since #dispatch's signal and this thread actually
-# resuming are two different moments -- that message is already gone from @pending_queue with
-# nowhere else to go, yet gets discarded here and a plain NATS::Timeout raised instead. Callers
-# (including Cosmo::Processor#fetch) treat NATS::Timeout as "no messages", so the message is lost
-# silently: never processed, never acked, and not redelivered until the consumer's ack_wait expires.
-# Reproduces reliably with several threads fetching (batch: 1) concurrently against the same
-# subscription, e.g. Cosmo::Job::Processor's thread pool.
-#
-# Vendored copy of nats-pure's PullSubscription#fetch, kept as close to
-# upstream as possible (two one-line fixes, see comments above), so it's easy to diff against the
-# next nats-pure release and drop once fixed there. Fixed on nats-pure main by the fetch rewrite
-# (#181), recognized by its private #take_pending, in which case this copy is not loaded.
-return if NATS::JetStream.const_get(:PullSubscription).private_method_defined?(:take_pending)
-
-# rubocop:disable all
-module NATS
-  class JetStream
-    module PullSubscription
-      def fetch(batch = 1, params = {})
-        raise ::NATS::JetStream::Error.new("nats: invalid batch size") if batch < 1
-
-        t = MonotonicTime.now
-        start_time = t # fixes the upstream bug -- see comment above
-        timeout = params[:timeout] ||= 5
-        expires = (timeout * 1_000_000_000) - 100_000
-        next_req = { batch: batch }
-
-        msgs = []
-        case
-        when batch == 1
-          synchronize do
-            unless @pending_queue.empty?
-              msg = @pending_queue.pop
-              @pending_size -= msg.data.size
-              if JS.is_status_msg(msg)
-                case msg.header["Status"]
-                when JS::Status::NoMsgs then nil
-                when JS::Status::RequestTimeout then nil # Skip
-                else raise JS.from_msg(msg)
-                end
-              else
-                msgs << msg
-              end
-            end
-          end
-
-          next_req[:expires] = expires
-          if msgs.empty?
-            @nc.publish(@jsi.nms, JS.next_req_to_json(next_req), @subject)
-            synchronize { wait_for_msgs_cond.wait(timeout) }
-
-            unless @pending_queue.empty?
-              msg = @pending_queue.pop
-              @pending_size -= msg.data.size
-              msgs << msg
-            end
-
-            raise ::NATS::Timeout.new("nats: fetch timeout") if msgs.empty? && (MonotonicTime.since(t) > timeout)
-
-            if JS.is_status_msg(msgs.first)
-              msg = msgs.first
-              case msg.header[JS::Header::Status]
-              when JS::Status::RequestTimeout then raise NATS::Timeout.new("nats: fetch request timeout")
-              else raise JS.from_msg(msgs.first)
-              end
-            end
-          end
-        when batch > 1
-          synchronize do
-            if batch <= @pending_queue.size
-              batch.times do
-                msg = @pending_queue.pop
-                @pending_size -= msg.data.size
-                if JS.is_status_msg(msg)
-                  case msg.header[JS::Header::Status]
-                  when JS::Status::NoMsgs, JS::Status::RequestTimeout then next
-                  else raise JS.from_msg(msg)
-                  end
-                else
-                  msgs << msg
-                end
-              end
-              return msgs
-            end
-          end
-
-          next_req[:no_wait] = true
-          @nc.publish(@jsi.nms, JS.next_req_to_json(next_req), @subject)
-
-          start_time = MonotonicTime.now
-          msg = nil
-
-          synchronize do
-            wait_for_msgs_cond.wait(timeout)
-            unless @pending_queue.empty?
-              msg = @pending_queue.pop
-              @pending_size -= msg.data.size
-            end
-          end
-
-          if !msg.nil? && JS.is_status_msg(msg)
-            case msg.header[JS::Header::Status]
-            when JS::Status::NoMsgs
-              next_req[:expires] = expires
-              next_req.delete(:no_wait)
-              @nc.publish(@jsi.nms, JS.next_req_to_json(next_req), @subject)
-            when JS::Status::RequestTimeout
-              raise NATS::Timeout.new("nats: fetch request timeout")
-            else
-              raise JS.from_msg(msg)
-            end
-          else
-            msgs << msg unless msg.nil?
-          end
-
-          duration = MonotonicTime.since(start_time)
-          raise NATS::Timeout.new("nats: fetch timeout") if msgs.empty? && (duration > timeout)
-
-          needed = batch - msgs.count
-          while (needed > 0) && (MonotonicTime.since(start_time) < timeout)
-            duration = MonotonicTime.since(start_time)
-
-            synchronize do
-              if @pending_queue.empty?
-                deadline = timeout - duration
-                wait_for_msgs_cond.wait(deadline) if deadline > 0
-
-                duration = MonotonicTime.since(start_time)
-                if msgs.empty? && @pending_queue.empty? && (duration > timeout)
-                  raise NATS::Timeout.new("nats: fetch timeout")
-                end
-              end
-
-              unless @pending_queue.empty?
-                msg = @pending_queue.pop
-                @pending_size -= msg.data.size
-
-                if JS.is_status_msg(msg)
-                  case msg.header[JS::Header::Status]
-                  when JS::Status::NoMsgs, JS::Status::RequestTimeout
-                    duration = MonotonicTime.since(start_time)
-                    if duration > timeout
-                      raise NATS::Timeout.new("nats: fetch timeout") if msgs.empty?
-
-                      return msgs
-                    end
-                  else
-                    raise JS.from_msg(msg)
-                  end
-                else
-                  msgs << msg
-                  needed -= 1
-                end
-              end
-            end
-          end
-        end
-
-        raise ::NATS::Timeout.new("nats: fetch timeout") if msgs.empty? && (MonotonicTime.since(start_time) > timeout)
-
-        msgs
-      end
-    end
-  end
-end
-# rubocop:enable all

data/lib/cosmo/utils/warnings.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module Cosmo
-  module Utils
-    module Warnings
-      module_function
-
-      def silence
-        verbose = $VERBOSE
-        $VERBOSE = nil
-        yield
-      ensure
-        $VERBOSE = verbose
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "cosmo/web/controllers/application"
-
-module Cosmo
-  class Web
-    module Controllers
-      class Actions < Application
-        def index
-          content_for :title, "Actions"
-          ok render("actions/index", layout: true)
-        end
-      end
-    end
-  end
-end

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

@@ -1,7 +0,0 @@
-<section>
-  <header></header>
-
-  <div>
-    <div class="alert alert-info">Coming soon, stay tuned</div>
-  </div>
-</section>