clockwork_web_plus 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eb90588bcdf155500c67ad5950849b3604258ebc8dee6fa1e6d3b6c23a3a1ade
+  data.tar.gz: 04c70b48a91eb02b5ba90310ce8917d6438225adf0914746c88b92747d3483b0
+SHA512:
+  metadata.gz: df81e08fd74e56d6497753d87cfc40373bc080ce639856c6adf1f9927f79682a8dd2118f6bc5493eca6d5e9a1812fd8abe8c2c9b0aab6f0c5db5864c417e26fe
+  data.tar.gz: da9c17ce70d80e6c207ed84869c586b2e8e8ac5d794f850f88b272660726e53b137ea739a6dbba5f7eb145cc120909086f882a920fe72743bc590436d427dde6

data/CHANGELOG.md

@@ -0,0 +1,43 @@
+## 1.0.0 (2025-11-11)
+
+- New: Fuzzy find search across jobs
+- New: "Run now" — run any job immediately from the index page
+- New: View the Ruby implementation of each job
+- New: Highlight overdue jobs at a glance
+- New: Hourly health check callback via `ClockworkWebPlus.on_health_check`, with detailed overdue context
+- New: Redesigned jobs table with a sleeker, modern UI
+
+Note: Versions prior to 1.0.0 (0.x.y) correspond to the original `clockwork_web` project by ankane. See `https://github.com/ankane/clockwork_web`.
+
+## 0.3.1 (2024-09-04)
+
+- Improved CSP support
+
+## 0.3.0 (2024-06-24)
+
+- Dropped support for Clockwork < 3
+- Dropped support for Ruby < 3.1 and Rails < 6.1
+
+## 0.2.0 (2023-02-01)
+
+- Dropped support for Ruby < 2.7 and Rails < 6
+
+## 0.1.2 (2023-02-01)
+
+- Fixed CSRF vulnerability with Rails < 5.2 - [more info](https://github.com/ankane/clockwork_web/issues/4)
+
+## 0.1.1 (2020-03-19)
+
+- Fixed load error
+
+## 0.1.0 (2019-10-28)
+
+- Added `on_job_update` hook
+
+## 0.0.5 (2015-05-13)
+
+- Added `running_threshold` option
+
+## 0.0.4 (2015-03-15)
+
+- Better monitoring for multiple processes

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015-2024 Andrew Kane
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,169 @@
+# Clockwork Web Plus
+
+A fully compatible drop-in enhancement to [ankane/clockwork_web](https://github.com/ankane/clockwork_web), providing a modern web interface for [Clockwork](https://github.com/Rykian/clockwork) with fuzzy search, manual job run, overdue visibility, and hourly health checks.
+
+[![Build Status](https://github.com/chaadow/clockwork_web_plus/actions/workflows/build.yml/badge.svg)](https://github.com/chaadow/clockwork_web_plus/actions/workflows/build.yml)
+
+## Preview
+
+<video src="https://github.com/user-attachments/assets/d145a4d5-834d-4c0d-9f11-397272b2d013" controls muted playsinline loop>
+  Sorry, your browser doesn't support embedded videos. Here’s a <a href="https://github.com/user-attachments/assets/d145a4d5-834d-4c0d-9f11-397272b2d013">direct link</a>.
+</video>
+
+## Features
+
+### Core (from `clockwork_web`)
+
+- see list of jobs
+- monitor jobs ( when they were last run at)
+- Temporarily disable jobs
+
+### New compared to clockwork_web
+
+- fuzzy find search across jobs
+- run any job immediately through the `Run now` button
+- view the Ruby implementation of each job
+- highlight overdue jobs at a glance
+- optional hourly health check callback with custom alerting
+
+## Installation
+
+Add this line to your application’s Gemfile:
+
+```ruby
+gem "clockwork_web_plus"
+```
+
+> [!TIP]
+> Already using `clockwork_web`? Keep your existing `ClockworkWeb::Engine` mount and initializers—no renaming needed. `ClockworkWebPlus` aliases `ClockworkWeb`, so it works out of the box.
+
+And add it to your `config/routes.rb`.
+
+```ruby
+mount ClockworkWebPlus::Engine, at: "clockwork"
+```
+
+> [!IMPORTANT]
+> Secure the dashboard in production. Protect access with Basic Auth, Devise, or your app’s auth layer to avoid exposing job controls and status.
+
+To monitor and disable jobs, hook up Redis in an initializer.
+
+```ruby
+ClockworkWebPlus.redis = Redis.new
+```
+
+#### Basic Authentication
+
+Set the following variables in your environment or an initializer.
+
+```ruby
+ENV["CLOCKWORK_USERNAME"] = "chaadow"
+ENV["CLOCKWORK_PASSWORD"] = "secret"
+```
+
+> [!NOTE]
+> These are example credentials. Use environment-specific secrets and rotate them regularly.
+
+#### Devise
+
+```ruby
+authenticate :user, ->(user) { user.admin? } do
+  mount ClockworkWebPlus::Engine, at: "clockwork"
+end
+```
+
+> [!TIP]
+> Any authentication framework works—wrap the mount with whatever guard your app already uses for admin/ops access.
+
+## Monitoring
+
+```ruby
+ClockworkWebPlus.running?
+ClockworkWebPlus.multiple?
+```
+
+> [!NOTE]
+> `running?` reflects recent heartbeats. `multiple?` indicates multiple active Clockwork processes (based on heartbeat contention).
+
+## Customize
+
+Change clock path
+
+```ruby
+ClockworkWebPlus.clock_path = Rails.root.join("clock") # default
+```
+
+> [!NOTE]
+> The default `clock_path` matches `clockwork_web`. Change it only if your clock file lives elsewhere.
+
+Turn off monitoring
+
+```ruby
+ClockworkWebPlus.monitor = false
+```
+
+> [!CAUTION]
+> Disabling monitoring stops heartbeats and multiple-process detection. The dashboard won’t show “running” status, but other features still work.
+
+### Overdue Jobs & Health Checks
+
+The dashboard highlights overdue jobs based on schedule and last run. You can also configure an hourly health check to alert when jobs are overdue:
+
+```ruby
+ClockworkWebPlus.on_health_check = ->(overdue_jobs:) do
+  # backlog contains array of hashes with details like:
+  # { job:, should_have_run_at:, last_run:, period:, at: { hour:, min: } }
+  if overdue_jobs.any?
+    # send notification to Slack, email, etc.
+  end
+end
+```
+
+> [!NOTE]
+> Overdue detection uses `ClockworkWebPlus.warning_threshold` (default: 300 seconds).  
+> - For `@at` schedules: a job is overdue when the most recent scheduled time has passed by more than `warning_threshold` and the job hasn’t run since that time.  
+> - For periodic jobs (no `@at`): a job is overdue when `now > last_run + period + warning_threshold`.
+>
+> Example:
+> ```ruby
+> # consider jobs overdue 10 minutes after their expected time
+> ClockworkWebPlus.warning_threshold = 600
+> ```
+
+> [!IMPORTANT]
+> With Redis configured, the health check runs at most once per hour across processes. Without Redis, throttling is per-process and approximate.
+
+## History
+
+View the [changelog](CHANGELOG.md)
+
+## Compatibility
+
+This gem is a drop-in replacement for `clockwork_web`. For backward compatibility, the original namespace is aliased:
+
+```ruby
+# Both of these work:
+mount ClockworkWebPlus::Engine, at: "clockwork"
+mount ClockworkWeb::Engine, at: "clockwork"
+```
+
+> [!TIP]
+> Adopting this gem can be as simple as swapping the gem name in your Gemfile. Your existing `ClockworkWeb` mounts and initializers continue to work unchanged.
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/chaadow/clockwork_web_plus/issues)
+- Fix bugs and [submit pull requests](https://github.com/chaadow/clockwork_web_plus/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
+
+To get started with development:
+
+```sh
+git clone https://github.com/chaadow/clockwork_web_plus.git
+cd clockwork_web_plus
+bundle install
+bundle exec rake test
+```

data/app/controllers/clockwork_web/home_controller.rb

@@ -0,0 +1,53 @@
+module ClockworkWeb
+  class HomeController < ActionController::Base
+    layout false
+    helper ClockworkWeb::HomeHelper
+
+    protect_from_forgery with: :exception
+
+    http_basic_authenticate_with name: ENV["CLOCKWORK_USERNAME"], password: ENV["CLOCKWORK_PASSWORD"] if ENV["CLOCKWORK_PASSWORD"]
+
+    def index
+      @last_runs = ClockworkWeb.last_runs
+      @disabled = ClockworkWeb.disabled_jobs
+      @events =
+        Clockwork.manager.instance_variable_get(:@events).sort_by do |e|
+          at = e.instance_variable_get(:@at)
+          enabled = !@disabled.include?(e.job)
+          overdue = enabled && ClockworkWeb.overdue?(e, @last_runs[e.job])
+          [
+            overdue ? 0 : 1, # prioritize overdue first
+            e.instance_variable_get(:@period),
+            (at && at.instance_variable_get(:@hour)) || -1,
+            (at && at.instance_variable_get(:@min)) || -1,
+            e.job.to_s
+          ]
+        end
+
+      @last_heartbeat = ClockworkWeb.last_heartbeat
+    end
+
+    def job
+      job = params[:job]
+      enable = params[:enable] == "true"
+      if enable
+        ClockworkWeb.enable(job)
+      else
+        ClockworkWeb.disable(job)
+      end
+      ClockworkWeb.on_job_update.call(job: job, enable: enable, user: try(ClockworkWeb.user_method)) if ClockworkWeb.on_job_update
+      redirect_to root_path
+    end
+
+    def execute
+      job = params[:job]
+
+      event = Clockwork.manager.events.find { _1.job == params[:job] }
+
+      event.run(Time.now.utc)
+      ClockworkWeb.set_last_run(event.job)
+
+      redirect_to root_path
+    end
+  end
+end

data/app/helpers/clockwork_web/home_helper.rb

@@ -0,0 +1,71 @@
+module ClockworkWeb
+  module HomeHelper
+    def friendly_period(period)
+      if period % 1.day == 0
+        pluralize(period / 1.day, "day")
+      elsif period % 1.hour == 0
+        pluralize(period / 1.hour, "hour")
+      elsif period % 1.minute == 0
+        "#{period / 1.minute} min"
+      else
+        "#{period} sec"
+      end
+    end
+
+    def last_run(time)
+      if time
+        "#{time_ago_in_words(time, include_seconds: true)} ago"
+      end
+    end
+
+    def friendly_time_part(time_part)
+      if time_part
+        time_part.to_s.rjust(2, "0")
+      else
+        "**"
+      end
+    end
+
+    def overdue?(event, last_run)
+      ClockworkWeb.overdue?(event, last_run)
+    end
+
+    def should_have_run_at(event, last_run)
+      ClockworkWeb.should_have_run_at(event, last_run)
+    end
+
+    def friendly_should_have_run(event, last_run)
+      at = should_have_run_at(event, last_run)
+      if at
+        "#{time_ago_in_words(at, include_seconds: true)} ago"
+      end
+    end
+
+    def friendly_extract_source_from_callable(callable, with_affixes: true)
+      iseq = RubyVM::InstructionSequence.of(callable)
+      source =
+        if iseq.script_lines
+          iseq.script_lines.join("\n")
+        elsif File.readable?(iseq.absolute_path)
+          File.read(iseq.absolute_path)
+        end
+      return '-' unless source
+
+      location = iseq.to_a[4][:code_location]
+      return callable unless location
+
+      lines = source.lines[(location[0] - 1)..(location[2] - 1)]
+      lines[-1] = lines[-1].byteslice(...location[3])
+      lines[0] = lines[0].byteslice(location[1]...)
+      source = lines.join.strip
+
+      source.tap do |source|
+        source.delete_prefix!('{')
+        source.delete_suffix!('}')
+
+        source.delete_prefix!('do')
+        source.delete_suffix!('end')
+      end
+    end
+  end
+end

data/app/views/clockwork_web/home/index.html.erb

@@ -0,0 +1,476 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>Clockwork</title>
+
+    <meta charset="utf-8" />
+
+    <%= content_tag :style, nonce: request.content_security_policy_nonce_directives&.include?("style-src") ? content_security_policy_nonce : nil do %>
+      :root {
+        --bg: #f6f7fb;
+        --card-bg: #ffffff;
+        --text: #0f172a;
+        --muted: #64748b;
+        --border: #e5e7eb;
+        --primary: #2563eb;
+        --primary-600: #1d4ed8;
+        --success: #16a34a;
+        --warning-50: #fff7ed;
+        --warning-600: #d97706;
+        --danger-50: #fef2f2;
+        --danger-600: #dc2626;
+        --disabled-50: #f8fafc;
+      }
+
+      html, body {
+        height: 100%;
+      }
+
+      body {
+        font-family: "Helvetica Neue", Arial, Helvetica, sans-serif;
+        margin: 0;
+        padding: 20px;
+        font-size: 14px;
+        line-height: 1.5;
+        color: var(--text);
+        background:
+          radial-gradient(60rem 60rem at 120% -10%, #c7d2fe 0%, transparent 40%),
+          radial-gradient(50rem 50rem at -20% -20%, #bae6fd 0%, transparent 35%),
+          var(--bg);
+      }
+
+      .container {
+        max-width: none;
+        width: 100%;
+        margin: 0;
+      }
+
+      .card {
+        background: var(--card-bg);
+        border: 1px solid var(--border);
+        border-radius: 12px;
+        box-shadow:
+          0 1px 2px rgba(0,0,0,0.04),
+          0 10px 20px rgba(2,6,23,0.04);
+        overflow: hidden;
+      }
+
+      .header {
+        padding: 20px 20px 8px 20px;
+        border-bottom: 1px solid var(--border);
+        background: linear-gradient(180deg, rgba(248,250,252,0.7), rgba(255,255,255,1));
+      }
+
+      .title-row {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        gap: 16px;
+        flex-wrap: wrap;
+      }
+
+      h1 {
+        font-size: 20px;
+        margin: 0;
+        font-weight: 700;
+        letter-spacing: -0.01em;
+      }
+
+      .status {
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+        font-size: 12px;
+        color: var(--muted);
+      }
+
+      .badge {
+        display: inline-flex;
+        align-items: center;
+        gap: 6px;
+        padding: 4px 8px;
+        border-radius: 999px;
+        border: 1px solid var(--border);
+        background: #ffffff;
+        font-weight: 600;
+        font-size: 12px;
+      }
+
+      .badge.success {
+        color: var(--success);
+        border-color: rgba(22,163,74,0.18);
+        background: #f0fdf4;
+      }
+
+      .badge.warn {
+        color: var(--warning-600);
+        border-color: rgba(217,119,6,0.18);
+        background: #fffbeb;
+      }
+
+      .badge.danger {
+        color: var(--danger-600);
+        border-color: rgba(220,38,38,0.18);
+        background: var(--danger-50);
+      }
+
+      .badge.info {
+        color: var(--muted);
+        background: #f8fafc;
+      }
+
+      .toolbar {
+        padding: 12px 20px 16px 20px;
+        display: flex;
+        gap: 12px;
+        align-items: center;
+        flex-wrap: wrap;
+      }
+
+      .search {
+        position: relative;
+        flex: 1 1 320px;
+        max-width: 420px;
+      }
+
+      .search input {
+        width: 100%;
+        padding: 10px 12px 10px 34px;
+        border: 1px solid var(--border);
+        border-radius: 8px;
+        background: #fff;
+        color: var(--text);
+        outline: none;
+        transition: box-shadow .15s ease, border-color .15s ease;
+      }
+
+      .search input:focus {
+        border-color: rgba(37,99,235,0.5);
+        box-shadow: 0 0 0 3px rgba(37,99,235,0.15);
+      }
+
+      .search .icon {
+        position: absolute;
+        top: 50%;
+        left: 10px;
+        transform: translateY(-50%);
+        color: var(--muted);
+        font-size: 14px;
+      }
+
+      .table-wrap {
+        padding: 0 0 8px 0;
+        overflow-x: auto;
+      }
+
+      table {
+        width: 100%;
+        border-collapse: collapse;
+        border-spacing: 0;
+        background: #fff;
+      }
+
+      thead th {
+        text-align: left;
+        font-weight: 700;
+        font-size: 12px;
+        color: var(--muted);
+        letter-spacing: .02em;
+        text-transform: uppercase;
+        background: #f9fafb;
+        border-bottom: 1px solid var(--border);
+        padding: 12px 12px;
+        white-space: nowrap;
+      }
+
+      tbody td {
+        padding: 12px;
+        border-bottom: 1px solid var(--border);
+        vertical-align: top;
+      }
+
+      tbody tr:hover {
+        background: #f8fafc;
+      }
+
+      .row-disabled {
+        background: var(--danger-50);
+      }
+
+      .row-warning {
+        background: var(--warning-50);
+      }
+
+      tbody tr.row-disabled:hover {
+        background: var(--danger-50);
+      }
+
+      tbody tr.row-warning:hover {
+        background: var(--warning-50);
+      }
+
+      .width-15 {
+        width: 15%;
+      }
+
+      details summary {
+        cursor: pointer;
+        color: var(--muted);
+      }
+
+      .button-form {
+        display: inline-flex;
+        align-items: center;
+        margin: 0;
+        vertical-align: middle;
+      }
+
+      .btn {
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        gap: 6px;
+        border: 1px solid var(--border);
+        padding: 8px 12px;
+        line-height: 1.2;
+        border-radius: 8px;
+        background: #fff;
+        color: var(--text);
+        cursor: pointer;
+        font-weight: 600;
+        transition: box-shadow .15s ease, border-color .15s ease, background .15s ease;
+      }
+
+      .btn:hover {
+        background: #f8fafc;
+      }
+
+      .btn:disabled {
+        opacity: .6;
+        cursor: not-allowed;
+      }
+
+      .btn-primary {
+        border-color: rgba(37,99,235,0.3);
+        background: #eff6ff;
+        color: var(--primary-600);
+      }
+
+      .btn-primary:hover {
+        background: #dbeafe;
+      }
+
+      .btn-danger {
+        border-color: rgba(220, 38, 38, 0.25);
+        background: var(--danger-50);
+        color: var(--danger-600);
+      }
+
+      .btn-danger:hover {
+        background: #fee2e2;
+      }
+
+      .meta {
+        color: var(--muted);
+        font-size: 12px;
+      }
+
+      .empty {
+        padding: 16px 20px;
+        color: var(--muted);
+        display: none;
+      }
+
+      td[data-col="actions"] {
+        white-space: nowrap;
+      }
+
+      .button-form + .button-form {
+        margin-left: 8px;
+      }
+    <% end %>
+  </head>
+  <body>
+    <div class="container">
+      <div class="card">
+        <div class="header">
+          <div class="title-row">
+            <h1>Clockwork Jobs</h1>
+            <div class="status">
+              <% if ClockworkWeb.redis %>
+                <% if ClockworkWeb.monitor %>
+                  <% if ClockworkWeb.multiple? %>
+                    <span class="badge warn" title="Multiple processes are updating heartbeat">Multiple processes</span>
+                  <% elsif ClockworkWeb.running? %>
+                    <span class="badge success" title="Heartbeat received recently">Running</span>
+                  <% else %>
+                    <span class="badge" style="color: var(--muted)" title="No recent heartbeat">Stopped</span>
+                    <% if @last_heartbeat %>
+                      <span class="meta">Last heartbeat <%= time_ago_in_words(@last_heartbeat) %> ago</span>
+                    <% end %>
+                  <% end %>
+                <% end %>
+              <% else %>
+                <span class="badge info">Redis not configured • monitoring/actions disabled</span>
+              <% end %>
+            </div>
+          </div>
+        </div>
+
+        <div class="toolbar">
+          <div class="search">
+            <span class="icon">🔎</span>
+            <input id="jobs-search" type="search" placeholder="Search jobs, schedules, or conditions…" aria-label="Filter jobs" autofocus />
+          </div>
+        </div>
+
+        <div class="table-wrap">
+          <table id="jobs-table">
+            <thead>
+              <tr>
+                <th class="width-15">Job</th>
+                <th class="width-15">Schedule</th>
+                <th class="width-15">Implementation</th>
+                <th class="width-15">Last run</th>
+                <th class="width-15">Should have run</th>
+                <th class="width-15">Actions</th>
+              </tr>
+            </thead>
+            <tbody>
+              <% @events.each do |event| %>
+                <% enabled = !@disabled.include?(event.job) %>
+                <% is_overdue = (enabled && overdue?(event, @last_runs[event.job])) %>
+                <tr class="<%= [enabled ? nil : 'row-disabled', is_overdue ? 'row-warning' : nil].compact.join(' ') %>">
+                  <td data-col="job">
+                    <strong><%= event.job %></strong>
+                    <% unless enabled %>
+                      &nbsp;<span class="badge danger" title="Job is disabled">Disabled</span>
+                    <% end %>
+                    <% if is_overdue %>
+                      &nbsp;<span class="badge warn" title="Job is overdue">Overdue</span>
+                    <% end %>
+                  </td>
+                  <td data-col="schedule">
+                    <%= friendly_period(event.instance_variable_get(:@period)) %>
+                    <% at = event.instance_variable_get(:@at) %>
+                    <% if at %>
+                      <span class="meta">at <%= friendly_time_part(at.instance_variable_get(:@hour)) %>:<%= friendly_time_part(at.instance_variable_get(:@min)) %></span>
+                    <% end %>
+                    <% if if_lambda = event.instance_variable_get(:@if) %>
+                      <div class="meta">if: -> <%= friendly_extract_source_from_callable(if_lambda)%></div>
+                    <% end %>
+                  </td>
+                  <td data-col="impl">
+                    <% if block = event.instance_variable_get(:@block) %>
+                      <details>
+                        <summary>View implementation</summary>
+                        {
+                        <%= friendly_extract_source_from_callable(block, with_affixes: false) %>
+                        }
+                      </details>
+                    <% else %>
+                      <span class="meta">-</span>
+                    <% end %>
+                  </td>
+                  <td data-col="last"><%= last_run(@last_runs[event.job]) || content_tag(:span, '-', class: 'meta') %></td>
+                  <td data-col="should">
+                    <% if is_overdue %>
+                      <%= friendly_should_have_run(event, @last_runs[event.job]) %>
+                    <% else %>
+                      <span class="meta">-</span>
+                    <% end %>
+                  </td>
+                  <td data-col="actions">
+                    <%= button_to(enabled ? "Disable" : "Enable",
+                                  home_job_path(job: event.job, enable: !enabled),
+                                  disabled: !ClockworkWeb.redis,
+                                  form_class: 'button-form',
+                                  class: enabled ? 'btn btn-danger' : 'btn') %>
+                    <%= button_to "Run now",
+                                  home_execute_path(job: event.job),
+                                  disabled: !ClockworkWeb.redis,
+                                  form_class: 'button-form',
+                                  class: 'btn btn-primary' %>
+                  </td>
+                </tr>
+              <% end %>
+            </tbody>
+          </table>
+          <div id="no-results" class="empty">No jobs match your search.</div>
+        </div>
+      </div>
+    </div>
+
+    <%= content_tag :script, nonce: request.content_security_policy_nonce_directives&.include?("script-src") ? content_security_policy_nonce : nil do %>
+      document.addEventListener('DOMContentLoaded', function () {
+        var input = document.getElementById('jobs-search');
+        var table = document.getElementById('jobs-table');
+        if (!input || !table) return;
+
+        var tbody = table.tBodies[0];
+        var rows = Array.prototype.slice.call(tbody.rows);
+        var emptyState = document.getElementById('no-results');
+
+        try { input.focus({ preventScroll: true }); } catch (e) { try { input.focus(); } catch (_) {} }
+
+        function normalize(text) {
+          return (text || '').toString().toLowerCase();
+        }
+
+        function stripNonAlnum(text) {
+          return text.replace(/[^a-z0-9]/g, '');
+        }
+
+        // Returns true if all chars of needle appear in order within haystack
+        function fuzzyIncludes(haystack, needle) {
+          if (!needle) return true;
+          var i = 0, j = 0;
+          while (i < haystack.length && j < needle.length) {
+            if (haystack.charCodeAt(i) === needle.charCodeAt(j)) {
+              j++;
+            }
+            i++;
+          }
+          return j === needle.length;
+        }
+
+        function rowMatches(row, query) {
+          if (!query) return true;
+          var text = normalize(row.textContent);
+          // direct substring match across the row
+          if (text.indexOf(query) !== -1) return true;
+
+          // fuzzy match only against the job name to reduce false positives
+          var jobCell = row.querySelector('[data-col="job"]');
+          if (!jobCell) return false;
+          var jobText = normalize(jobCell.textContent);
+
+          var qNorm = stripNonAlnum(query);
+          if (qNorm.length < 3) {
+            // for very short queries, avoid fuzzy to prevent over-matching
+            return jobText.indexOf(query) !== -1;
+          }
+          return fuzzyIncludes(stripNonAlnum(jobText), qNorm);
+        }
+
+        function applyFilter() {
+          var q = normalize(input.value.trim());
+          var visible = 0;
+          rows.forEach(function (row) {
+            if (rowMatches(row, q)) {
+              row.style.display = '';
+              visible += 1;
+            } else {
+              row.style.display = 'none';
+            }
+          });
+          if (emptyState) {
+            emptyState.style.display = visible === 0 ? 'block' : 'none';
+          }
+        }
+
+        input.addEventListener('input', applyFilter);
+      });
+    <% end %>
+  </body>
+</html>

data/config/routes.rb

@@ -0,0 +1,6 @@
+ClockworkWeb::Engine.routes.draw do
+  post "home/job"
+  post "home/execute"
+
+  root to: "home#index"
+end

data/lib/clockwork_web/engine.rb

@@ -0,0 +1,10 @@
+module ClockworkWeb
+  class Engine < ::Rails::Engine
+    isolate_namespace ClockworkWeb
+
+    initializer "clockwork_web" do
+      ClockworkWeb.clock_path ||= Rails.root.join("clock")
+      require ClockworkWeb.clock_path.to_s
+    end
+  end
+end

data/lib/clockwork_web/version.rb

@@ -0,0 +1,3 @@
+module ClockworkWeb
+  VERSION = "1.0.0"
+end

data/lib/clockwork_web.rb

@@ -0,0 +1,297 @@
+# dependencies
+require "clockwork"
+require "safely/core"
+
+# modules
+require_relative "clockwork_web/engine" if defined?(Rails)
+require_relative "clockwork_web/version"
+
+module ClockworkWeb
+  LAST_RUNS_KEY = "clockwork:last_runs"
+  DISABLED_KEY = "clockwork:disabled"
+  HEARTBEAT_KEY = "clockwork:heartbeat"
+  STATUS_KEY = "clockwork:status"
+  HEALTH_CHECK_KEY = "clockwork:health_check"
+
+  class << self
+    attr_accessor :clock_path
+    attr_accessor :redis
+    attr_accessor :monitor
+    attr_accessor :running_threshold
+    attr_accessor :on_job_update
+    attr_accessor :user_method
+    attr_accessor :warning_threshold
+    attr_accessor :on_health_check
+  end
+  self.monitor = true
+  self.running_threshold = 60 # seconds
+  self.user_method = :current_user
+  self.warning_threshold = 300 # seconds, default 5 minutes
+
+  def self.enable(job)
+    if redis
+      redis.srem(DISABLED_KEY, job)
+      true
+    else
+      false
+    end
+  end
+
+  def self.disable(job)
+    if redis
+      redis.sadd(DISABLED_KEY, job)
+      true
+    else
+      false
+    end
+  end
+
+  def self.enabled?(job)
+    if redis
+      !redis.sismember(DISABLED_KEY, job)
+    else
+      true
+    end
+  end
+
+  def self.disabled_jobs
+    if redis
+      Set.new(redis.smembers(DISABLED_KEY))
+    else
+      Set.new
+    end
+  end
+
+  def self.last_runs
+    if redis
+      Hash[redis.hgetall(LAST_RUNS_KEY).map { |job, timestamp| [job, Time.at(timestamp.to_i)] }.sort_by { |job, time| [time, job] }]
+    else
+      {}
+    end
+  end
+
+  def self.set_last_run(job)
+    if redis
+      redis.hset(LAST_RUNS_KEY, job, Time.now.utc.to_i)
+    end
+  end
+
+  def self.last_heartbeat
+    if redis
+      timestamp = redis.get(HEARTBEAT_KEY)
+      if timestamp
+        Time.at(timestamp.to_i)
+      end
+    end
+  end
+
+  def self.heartbeat
+    if redis
+      heartbeat = Time.now.utc.to_i
+      if heartbeat % 10 == 0 # every 10 seconds
+        prev_heartbeat = redis.getset(HEARTBEAT_KEY, heartbeat).to_i
+        if prev_heartbeat >= heartbeat
+          redis.setex(STATUS_KEY, 60, "multiple")
+        end
+      end
+    end
+  end
+
+  def self.running?
+    last_heartbeat && last_heartbeat > Time.now.utc - running_threshold
+  end
+
+  def self.multiple?
+    redis && redis.get(STATUS_KEY) == "multiple"
+  end
+
+  # Runs at most once per hour across processes. When triggered, gathers overdue jobs and
+  # invokes the configured on_health_check callback if any are found.
+  def self.health_check
+    return unless on_health_check
+
+    now = Time.now.utc.to_i
+    proceed = false
+
+    if redis
+      last = redis.get(HEALTH_CHECK_KEY).to_i
+      if last == 0 || (now - last) >= 3600
+        prev = redis.getset(HEALTH_CHECK_KEY, now).to_i
+        proceed = (prev == last) || (now - prev) >= 3600
+      end
+    else
+      @last_health_check ||= 0
+      if (now - @last_health_check) >= 3600
+        @last_health_check = now
+        proceed = true
+      end
+    end
+
+    return unless proceed
+
+    events = Clockwork.manager.events
+    last_runs = ClockworkWeb.last_runs
+    overdue_jobs = ClockworkWeb.overdue_details(events, last_runs)
+    ClockworkWeb.on_health_check.call(overdue_jobs: overdue_jobs) if overdue_jobs.any?
+  end
+
+  # Returns the last time this event should have run before now.
+  # For @at schedules, computes the most recent scheduled time at the declared hour/minute,
+  # respecting common periods (daily, multi-day, hourly). For simple periodic jobs (no @at),
+  # returns last_run + period when that is in the past. Returns nil when it cannot be determined.
+  # Convert a given time to the event timezone if supported; default to UTC.
+  def self.now_in_event_timezone(event, base_now = Time.now.utc)
+    if event.respond_to?(:convert_timezone)
+      event.convert_timezone(base_now)
+    else
+      base_now
+    end
+  end
+
+  def self.should_have_run_at(event, last_run_time, now = Time.now.utc)
+    period = event.instance_variable_get(:@period)
+    return nil unless period
+
+    at = event.instance_variable_get(:@at)
+    if at
+      now_for_event = now_in_event_timezone(event, now)
+      hour = at.instance_variable_get(:@hour) || 0
+      min = at.instance_variable_get(:@min) || 0
+      wday = at.instance_variable_get(:@wday) rescue nil
+
+      # Weekly or multi-week schedules with specific weekday
+      if !wday.nil?
+        step_weeks = (period % 604_800).zero? ? [(period / 604_800).to_i, 1].max : 1
+        days_ago = (now_for_event.wday - wday) % 7
+        day = now_for_event.to_date - days_ago
+        candidate = Time.new(day.year, day.month, day.day, hour, min, 0, now_for_event.utc_offset)
+        candidate -= 604_800 if candidate > now
+        if step_weeks > 1
+          anchor = last_run_time || candidate
+          while (((anchor.to_date - candidate.to_date).to_i / 7) % step_weeks) != 0
+            candidate -= 604_800
+          end
+        end
+        return candidate
+      end
+
+      # Daily or multi-day schedules
+      if (period % 86_400).zero?
+        step_days = [(period / 86_400).to_i, 1].max
+        base_day = now_for_event.to_date
+        # Try the most recent aligned day within one full cycle
+        0.upto(step_days - 1) do |offset|
+          day = base_day - offset
+          candidate = Time.new(day.year, day.month, day.day, hour, min, 0, now_for_event.utc_offset)
+          if candidate <= now_for_event
+            # Alignment: only consider days separated by the step length
+            return candidate if (base_day - day).to_i % step_days == 0
+          end
+        end
+        # Fallback to previous aligned cycle
+        day = base_day - step_days
+        return Time.new(day.year, day.month, day.day, hour, min, 0, now_for_event.utc_offset)
+      end
+
+      # Hourly or multi-hour schedules (e.g., every 2 hours at minute 15)
+      if (period % 3600).zero?
+        step_hours = [(period / 3600).to_i, 1].max
+        aligned_hour = (now_for_event.hour / step_hours) * step_hours
+        candidate = Time.new(now_for_event.year, now_for_event.month, now_for_event.day, aligned_hour, min, 0, now_for_event.utc_offset)
+        candidate -= step_hours * 3600 if candidate > now
+        return candidate
+      end
+
+      # Fallback: treat as daily at the given time
+      candidate = Time.new(now_for_event.year, now_for_event.month, now_for_event.day, hour, min, 0, now_for_event.utc_offset)
+      candidate -= 86_400 if candidate > now_for_event
+      return candidate
+    else
+      # Simple periodic job (no @at) – use last_run anchor
+      return nil unless last_run_time
+      expected = last_run_time + period
+      return expected if expected <= (now || Time.now.utc)
+      return nil
+    end
+  end
+
+  # Determines whether an event is overdue given its schedule and last run.
+  def self.overdue?(event, last_run_time, now = Time.now.utc)
+    period = event.instance_variable_get(:@period) || 0
+    at_time = should_have_run_at(event, last_run_time, now)
+    now_for_event = now_in_event_timezone(event, now)
+
+    # If an if-lambda is present and evaluates false at current event-local time,
+    # do not consider the job overdue.
+    if_lambda = event.instance_variable_get(:@if)
+    if if_lambda
+      begin
+        allowed = if if_lambda.arity == 1
+          if_lambda.call(now_for_event)
+        else
+          if_lambda.call
+        end
+        return false unless allowed
+      rescue StandardError
+        return true
+      end
+    end
+
+    if event.instance_variable_get(:@at)
+      return false unless at_time
+      # Overdue if the scheduled time has passed by more than the threshold and we haven't run since
+      return (now_for_event - at_time) > warning_threshold && (last_run_time.nil? || last_run_time < at_time)
+    else
+      return false unless last_run_time && period.positive?
+      return now_for_event > (last_run_time + period + warning_threshold)
+    end
+  end
+
+  # Collect details about overdue events for alerting or diagnostics.
+  def self.overdue_details(events, last_runs, now = Time.now)
+    events.filter_map do |event|
+      next unless ClockworkWeb.enabled?(event.job)
+      lr = last_runs[event.job]
+      if overdue?(event, lr, now)
+        should_at = should_have_run_at(event, lr, now)
+        {
+          job: event.job,
+          should_have_run_at: should_at,
+          last_run: lr,
+          period: event.instance_variable_get(:@period),
+          at: event.instance_variable_get(:@at) && {
+            hour: event.instance_variable_get(:@at).instance_variable_get(:@hour),
+            min: event.instance_variable_get(:@at).instance_variable_get(:@min)
+          }
+        }
+      end
+    end
+  end
+end
+
+module Clockwork
+  on(:before_tick) do
+    ClockworkWeb.heartbeat if ClockworkWeb.monitor
+    ClockworkWeb.health_check if ClockworkWeb.on_health_check
+    true
+  end
+
+  on(:before_run) do |event, t|
+    run = true
+
+    Safely.safely do
+      run = ClockworkWeb.enabled?(event.job)
+      unless run
+        manager.log "Skipping '#{event}'"
+        event.last = event.convert_timezone(t)
+      end
+    end
+
+    run
+  end
+
+  on(:after_run) do |event, _t|
+    ClockworkWeb.set_last_run(event.job) if ClockworkWeb.enabled?(event.job)
+  end
+
+end

data/lib/clockwork_web_plus/version.rb

@@ -0,0 +1,5 @@
+module ClockworkWebPlus
+  VERSION = "1.0.0"
+end
+
+

data/lib/clockwork_web_plus.rb

@@ -0,0 +1,6 @@
+require "clockwork_web"
+
+# New namespace that aliases the original, for easy drop-in replacement.
+ClockworkWebPlus = ClockworkWeb unless defined?(ClockworkWebPlus)
+
+

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: clockwork_web_plus
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Andrew Kane
+- Chedli Bourguiba
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: clockwork
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: safely_block
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+email:
+- bourguiba.chedli@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- app/controllers/clockwork_web/home_controller.rb
+- app/helpers/clockwork_web/home_helper.rb
+- app/views/clockwork_web/home/index.html.erb
+- config/routes.rb
+- lib/clockwork_web.rb
+- lib/clockwork_web/engine.rb
+- lib/clockwork_web/version.rb
+- lib/clockwork_web_plus.rb
+- lib/clockwork_web_plus/version.rb
+homepage: https://github.com/chedli/clockwork_web_plus
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A modern web interface for Clockwork with search, run-now & health checks
+test_files: []