cosmonats 0.7.0 → 0.9.0

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

@@ -0,0 +1,158 @@
+(function () {
+  'use strict';
+
+  var root = document.documentElement;
+  var systemDark = window.matchMedia('(prefers-color-scheme: dark)');
+  var flashTimer;
+  var BACKOFF_LIMIT = 60000;
+
+  if (window.htmx) htmx.config.timeout = 20000;
+
+  function isPoller(el) {
+    return !!(el && el.dataset && el.dataset.poll !== undefined);
+  }
+
+  function pollDelay(el) {
+    var base = (parseFloat(el.dataset.poll) || 5) * 1000;
+    return Math.min(base * Math.pow(2, el.cosmoFailures || 0), Math.max(base, BACKOFF_LIMIT));
+  }
+
+  function poll(el) {
+    if (!el.isConnected) return;
+    if (document.hidden) {
+      el.cosmoHeld = true;
+      return;
+    }
+    htmx.trigger(el, 'cosmo:poll');
+  }
+
+  function schedule(el) {
+    clearTimeout(el.cosmoTimer);
+    if (el.isConnected) el.cosmoTimer = setTimeout(function () { poll(el); }, pollDelay(el));
+  }
+
+  function markOnline(online) {
+    document.body.classList.toggle('offline', !online);
+    var label = document.querySelector('.live-label');
+    if (label) label.textContent = online ? 'live' : 'offline';
+  }
+
+  function settled(el, failed) {
+    if (!el.cosmoPolling) return;
+    el.cosmoPolling = false;
+    el.cosmoFailures = failed ? (el.cosmoFailures || 0) + 1 : 0;
+    markOnline(!failed);
+    schedule(el);
+  }
+
+  document.addEventListener('htmx:beforeRequest', function (event) {
+    if (isPoller(event.detail.elt)) event.detail.elt.cosmoPolling = true;
+  });
+
+  document.addEventListener('htmx:afterRequest', function (event) {
+    if (isPoller(event.detail.elt)) settled(event.detail.elt, !event.detail.successful);
+  });
+
+  ['htmx:sendError', 'htmx:timeout'].forEach(function (name) {
+    document.addEventListener(name, function (event) {
+      if (isPoller(event.detail.elt)) settled(event.detail.elt, true);
+    });
+  });
+
+  document.addEventListener('visibilitychange', function () {
+    if (document.hidden) return;
+    document.querySelectorAll('[data-poll]').forEach(function (el) {
+      if (!el.cosmoHeld) return;
+      el.cosmoHeld = false;
+      poll(el);
+    });
+  });
+
+  if (window.htmx) {
+    htmx.onLoad(function (content) {
+      var pollers = Array.prototype.slice.call(content.querySelectorAll('[data-poll]'));
+      if (isPoller(content)) pollers.push(content);
+      pollers.forEach(function (el) {
+        if (!/\bload\b/.test(el.getAttribute('hx-trigger') || '')) schedule(el);
+      });
+    });
+  }
+
+  function store(key, value) {
+    try { localStorage.setItem(key, value); } catch (e) {}
+  }
+
+  function applyTheme(mode) {
+    root.dataset.themeMode = mode;
+    root.dataset.theme = mode === 'auto' ? (systemDark.matches ? 'dark' : 'light') : mode;
+    document.querySelectorAll('[data-theme-set]').forEach(function (button) {
+      var on = button.dataset.themeSet === mode;
+      button.classList.toggle('on', on);
+      button.setAttribute('aria-pressed', on);
+    });
+  }
+
+  systemDark.addEventListener('change', function () {
+    if (root.dataset.themeMode === 'auto') applyTheme('auto');
+  });
+
+  var actions = {
+    theme: function (el) {
+      store('cosmo-theme', el.dataset.themeSet);
+      applyTheme(el.dataset.themeSet);
+    },
+    'open-menu': function () { document.body.classList.add('menu-open'); },
+    'close-menu': function () { document.body.classList.remove('menu-open'); }
+  };
+
+  function tick() {
+    var clock = document.getElementById('clock');
+    if (clock) clock.textContent = ' · ' + new Date().toLocaleTimeString('en-GB');
+  }
+
+  function hideFlash() {
+    var flash = document.getElementById('flash');
+    if (!flash || !flash.textContent.trim()) return;
+    clearTimeout(flashTimer);
+    flashTimer = setTimeout(function () { flash.textContent = ''; }, 2400);
+  }
+
+  document.addEventListener('click', function (event) {
+    var el = event.target.closest('[data-action]');
+    if (el && actions[el.dataset.action]) actions[el.dataset.action](el);
+  });
+
+  document.addEventListener('keydown', function (event) {
+    if (event.key === 'Escape') document.body.classList.remove('menu-open');
+  });
+
+  window.addEventListener('resize', function () {
+    if (window.innerWidth > 900) document.body.classList.remove('menu-open');
+  });
+
+  document.addEventListener('htmx:beforeSwap', function (event) {
+    event.detail.target.cosmoScroll = Array.prototype.map.call(
+      event.detail.target.querySelectorAll('.scroll'), function (el) { return el.scrollLeft; }
+    );
+  });
+
+  document.addEventListener('htmx:afterSettle', function (event) {
+    var saved = event.detail.target.cosmoScroll;
+    if (saved) {
+      event.detail.target.querySelectorAll('.scroll').forEach(function (el, i) { el.scrollLeft = saved[i] || 0; });
+    }
+    hideFlash();
+  });
+
+  document.addEventListener('DOMContentLoaded', function () {
+    var reload = document.querySelector('[data-reload]');
+    if (reload) {
+      markOnline(false);
+      setTimeout(function () { location.reload(); }, (parseFloat(reload.dataset.reload) || 10) * 1000);
+    }
+
+    applyTheme(root.dataset.themeMode || 'auto');
+    tick();
+    setInterval(tick, 1000);
+  });
+})();

data/lib/cosmo/web/assets/fonts/OFL.txt

@@ -0,0 +1,92 @@
+Copyright (c) 2023 Vercel, in collaboration with basement.studio
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION AND CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

data/lib/cosmo/web/assets/logo.svg

@@ -0,0 +1,10 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <line x1="66" y1="20" x2="76" y2="6" stroke="#0b0f1e" stroke-width="7" stroke-linecap="round"/>
+  <line x1="66" y1="20" x2="76" y2="6" stroke="#ECEAE2" stroke-width="3" stroke-linecap="round"/>
+  <circle cx="77" cy="6" r="5.5" fill="#ff8a3d" stroke="#0b0f1e" stroke-width="3"/>
+  <rect x="24" y="76" width="52" height="18" rx="7" fill="#e2524a" stroke="#0b0f1e" stroke-width="4"/>
+  <circle cx="50" cy="48" r="36" fill="#f4f1e8" stroke="#0b0f1e" stroke-width="4.5"/>
+  <rect x="25" y="32" width="50" height="34" rx="16" fill="#7fe3ff" stroke="#0b0f1e" stroke-width="4.5"/>
+  <path d="M33 47 Q34 39 43 38" stroke="#ffffff" stroke-width="4.5" fill="none" stroke-linecap="round"/>
+  <circle cx="64" cy="57" r="2.6" fill="#ffffff"/>
+</svg>

data/lib/cosmo/web/cache.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Cosmo
+  class Web
+    # A short-lived, process-wide cache of the web UI's refresh responses: requests for the same data, from several
+    # open tabs, wait for a single fetch and share its result for TTL seconds, so viewers don't multiply NATS reads.
+    class Cache
+      # Seconds a response is shared. Override with COSMO_WEB_CACHE_TTL; 0 turns the cache off.
+      TTL = 2
+      LIMIT = 256
+
+      def self.instance
+        @instance ||= new
+      end
+
+      def initialize(ttl: ENV.fetch("COSMO_WEB_CACHE_TTL", TTL).to_f)
+        @ttl = ttl
+        @lock = Mutex.new
+        @entries = {}
+        @gates = {}
+      end
+
+      # @param key [Object]
+      # @yieldreturn [Object] the value, computed only when no fresh copy is cached
+      # @return [Object]
+      def fetch(key)
+        return yield unless @ttl.positive?
+
+        gate(key).synchronize do
+          entry = read(key)
+          next entry.first if entry
+
+          yield.tap { |value| write(key, value) }
+        end
+      end
+
+      # Forgets every cached value, so the next request reads fresh data.
+      #
+      # @return [void]
+      def clear
+        @lock.synchronize { @entries.clear }
+      end
+
+      private
+
+      def gate(key)
+        @lock.synchronize { @gates[key] ||= Mutex.new }
+      end
+
+      def read(key)
+        @lock.synchronize do
+          entry = @entries[key]
+          entry if entry && entry.last > clock
+        end
+      end
+
+      def write(key, value)
+        @lock.synchronize do
+          prune if @entries.size >= LIMIT
+          @entries[key] = [value, clock + @ttl]
+        end
+      end
+
+      def prune
+        now = clock
+        @entries.delete_if { |_, (_, expires)| expires <= now }
+        @gates.delete_if { |key, _| !@entries.key?(key) }
+      end
+
+      def clock
+        ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/cosmo/web/chart.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Cosmo
+  class Web
+    # Geometry for the Metrics tab's chart: a bar per day for the number of runs on the left axis and a line for the
+    # average execution time on the right one, drawn into a viewBox the page stretches to its width, axes and hover
+    # targets laid out in percent.
+    class Chart
+      WIDTH = 1000
+      HEIGHT = 220
+      PLOT = 214
+      TICKS = 3
+      LABELS = 6
+      BAR = 28
+
+      # @param series [Array<Hash>] +{ date:, count:, failed:, exec_ms:, wait_ms: }+ per day, oldest first
+      def initialize(series)
+        @series = series
+        @count_top = top(series.map { _1[:count] }.max.to_i)
+        @exec_top = top(series.filter_map { _1[:exec_ms] }.max.to_f)
+      end
+
+      # @return [Boolean]
+      def empty?
+        @series.all? { _1[:count].zero? }
+      end
+
+      # @return [String] the path of the run bars, one per day with runs
+      def bars # rubocop:disable Metrics/AbcSize
+        width = (slot * 0.6).clamp(2, BAR).round(1)
+        @series.each_with_index.filter_map do |day, index|
+          next if day[:count].zero?
+
+          height = scale(day[:count], @count_top).round(1)
+          "M#{(center(index) - (width / 2)).round(1)} #{HEIGHT} v#{-height} h#{width} v#{height} Z"
+        end.join(" ")
+      end
+
+      # @return [String] the path of the execution time line, broken over days without a successful run
+      def line
+        drawing = false
+        @series.each_with_index.filter_map do |day, index|
+          unless day[:exec_ms]
+            drawing = false
+            next
+          end
+
+          command = drawing ? "L" : "M"
+          drawing = true
+          "#{command}#{center(index).round(1)} #{exec_y(day[:exec_ms])}"
+        end.join(" ")
+      end
+
+      # @return [String] the path of the horizontal grid lines
+      def grid
+        (0..TICKS).map { "M0 #{(HEIGHT - (PLOT * _1 / TICKS.to_f)).round(1)} H#{WIDTH}" }.join(" ")
+      end
+
+      # @return [Array<Hash>] +{ count:, exec_ms: }+ per grid line, top down
+      def ticks
+        TICKS.downto(0).map do |step|
+          { count: (@count_top * step / TICKS.to_f).round, exec_ms: (@exec_top * step / TICKS.to_f).round }
+        end
+      end
+
+      # @return [Array<Hash>] +{ left:, text: }+ x axis labels in percent, thinned out to at most LABELS
+      def labels
+        every = (@series.size / LABELS.to_f).ceil.clamp(1, nil)
+        @series.each_with_index.filter_map do |day, index|
+          { left: percent(center(index)), text: label(day[:date]) } if (index % every).zero?
+        end
+      end
+
+      # @return [Array<Hash>] per day the hover column +left+/+width+, its +center+, the execution time dot +dot+
+      #   (nil without one) and the bar top +top+, in percent, with the day's numbers
+      def points # rubocop:disable Metrics/AbcSize
+        @series.each_with_index.map do |day, index|
+          bar_top = HEIGHT - scale(day[:count], @count_top)
+          day.merge(left: percent(slot * index), width: percent(slot), center: percent(center(index)),
+                    dot: day[:exec_ms] && percent(exec_y(day[:exec_ms]), HEIGHT), top: percent(bar_top, HEIGHT),
+                    label: label(day[:date]))
+        end
+      end
+
+      private
+
+      def slot
+        WIDTH / [@series.size, 1].max.to_f
+      end
+
+      def center(index)
+        slot * (index + 0.5)
+      end
+
+      def exec_y(value)
+        (HEIGHT - scale(value, @exec_top)).round(1)
+      end
+
+      def scale(value, top)
+        top.zero? ? 0 : PLOT * value / top.to_f
+      end
+
+      def percent(value, total = WIDTH)
+        (value / total.to_f * 100).round(2)
+      end
+
+      # The smallest "nice" axis maximum (1, 2 or 5 times a power of ten per tick) at or above +max+.
+      def top(max)
+        return TICKS if max.zero?
+
+        raw = max / TICKS.to_f
+        magnitude = 10**Math.log10(raw).floor
+        step = [1, 2, 5, 10].map { _1 * magnitude }.find { _1 >= raw }
+        step * TICKS
+      end
+
+      def label(date)
+        "#{date[4, 2]}/#{date[6, 2]}"
+      end
+    end
+  end
+end

data/lib/cosmo/web/circuit.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Cosmo
+  class Web
+    # Keeps the web UI from tying up server threads on an unreachable NATS: it is open, and requests answer at once
+    # without touching NATS, while the client is disconnected or for OPEN_FOR seconds after a request failed on a
+    # NATS timeout or connection error. The first request after that tries NATS again.
+    class Circuit
+      OPEN_FOR = 10
+      ERRORS = [NATS::IO::Timeout, NATS::IO::ConnectError, NATS::IO::ConnectionClosedError,
+                NATS::IO::StaleConnectionError].freeze
+
+      def self.instance
+        @instance ||= new
+      end
+
+      def initialize
+        @lock = Mutex.new
+        @tripped_at = nil
+      end
+
+      # @return [Boolean] whether requests should skip NATS
+      def open?
+        return true if tripped?
+        return false if connected?
+
+        trip!
+        true
+      end
+
+      # Opens the circuit for OPEN_FOR seconds.
+      #
+      # @return [void]
+      def trip!
+        @lock.synchronize { @tripped_at = clock }
+      end
+
+      private
+
+      def tripped?
+        @lock.synchronize { @tripped_at && clock - @tripped_at < OPEN_FOR }
+      end
+
+      def connected?
+        Client.instance.nc.connected?
+      rescue StandardError
+        false
+      end
+
+      def clock
+        ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      end
+    end
+  end
+end

data/lib/cosmo/web/context.rb

@@ -12,10 +12,6 @@ module Cosmo
         locals.each { |k, v| instance_variable_set("@#{k}", v) }
       end
 
-      def binding # rubocop:disable Lint/UselessMethodDefinition
-        super
-      end
-
       def content_for(name)
         @content_for[name]
       end

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

@@ -37,6 +37,22 @@ module Cosmo
         def hx_request?
           @request.get_header("HTTP_HX_REQUEST") == "true"
         end
+
+        # 503 while NATS is unreachable: a bare body for an htmx request, which leaves the page as it is and backs
+        # off, or a page that reloads itself.
+        def unavailable
+          headers = { "content-type" => "text/html; charset=utf-8", "retry-after" => Circuit::OPEN_FOR.to_s }
+          return respond_with(503, headers:, body: "NATS is unreachable") if hx_request?
+
+          content_for :title, "Unavailable"
+          content_for :subtitle, "The web UI can't reach NATS."
+          respond_with 503, headers:, body: render("shared/unavailable", { retry: Circuit::OPEN_FOR }, layout: true)
+        end
+
+        # An out-of-band swap of the page header's flash message, appended to an htmx response.
+        def flash(message)
+          %(<div id="flash" class="flash" hx-swap-oob="true">#{Rack::Utils.escape_html(message)}</div>)
+        end
       end
     end
   end

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

@@ -8,6 +8,7 @@ module Cosmo
       class Batches < Application
         def index
           content_for :title, "Batches"
+          content_for :subtitle, "Grouped jobs with a callback when the last one lands."
           ok render("batches/index", layout: true)
         end
 

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

@@ -7,27 +7,36 @@ module Cosmo
     module Controllers
       class Crons < Application
         def index
+          return not_found unless Config.scheduled.enabled
+
           content_for :title, "Crons"
+          content_for :subtitle, "Schedules parked in NATS. NATS keeps the time."
           ok render("crons/index", layout: true)
         end
 
         def _table
+          return not_found unless Config.scheduled.enabled
+
           ok render("crons/_table", { schedules: cron.all })
         end
 
         # Dispatch the job immediately, bypassing the schedule timer.
         # Expects params["subject"] = the schedule subject stored in NATS.
         def run_now
+          return not_found unless Config.scheduled.enabled
+
           subject = Rack::Utils.unescape(params["subject"].to_s)
           cron.run_now!(subject)
-          ok
+          ok flash("#{label(subject)} enqueued now")
         end
 
         # Purge the schedule from NATS so it stops firing.
         def delete
+          return not_found unless Config.scheduled.enabled
+
           subject = Rack::Utils.unescape(params["subject"].to_s)
           cron.delete!(subject)
-          _table
+          ok render("crons/_table", { schedules: cron.all }) + flash("#{label(subject)} deleted")
         end
 
         private
@@ -35,6 +44,12 @@ module Cosmo
         def cron
           @cron ||= API::Cron.instance
         end
+
+        # "cosmo.cron.default.report_job.monthly" → "monthly", "cosmo.cron.default.report_job" → "report_job"
+        def label(subject)
+          parts = subject.split(".")
+          parts.size > 4 ? parts.drop(4).join(".") : parts.last
+        end
       end
     end
   end