v0.8.3 · MIT · works on every queue driver

The production control center for Laravel queues & jobs

See exactly what ran — with the parameters it ran with, whether it failed, and how long it took. Supervise & auto-scale workers on any driver, watch whole-app performance, and dispatch jobs or run commands by hand — from one self-contained dashboard.

Get started Star on GitHub

bash

$ composer require anousss007/vigilance
$ php artisan vigilance:install
$ php artisan migrate
# open /vigilance — that's it.

PHP 8.2+ · Laravel 12 / 13 · Livewire 3.5+ / 4 · no Filament required

myapp.test/vigilance

V Vigilance

Overviewlast 24 hours · all connections

live

Throughput12,480▲ 8.2%

Failed140.11%

Avg wait0.34s▼ 21%

Workers6/10auto

Throughput processed failed

JobQueueTimeStatus

ProcessPodcastmedia1.82sdone

ChargeInvoicepayments0.41sdone

SyncCrmContactdefault5.30srunning

SendWelcomeMailmail0.12sdone

GenerateReportdefault—failed

One package, the whole picture

Everything you need to run background work in production

Horizon, Telescope and Pulse each cover a slice. Vigilance brings the operationally important parts together — and works no matter which queue driver you use.

Driver-agnostic capture

Full queued → running → done/failed lifecycle for jobs, commands and the scheduler — on database, Redis, SQS, Beanstalkd or sync. One row per run, with parameters.

Worker supervisor

A Horizon-style supervisor that runs & auto-scales worker pools on any driver — balancing, autoscaling, graceful restarts. Chaos-tested across drivers, zero orphans.

Whole-app APM

Pulse-parity telemetry — servers, slow requests/queries/HTTP, cache, exceptions, per-user usage. Captures cheaply and flushes after the response, so zero request latency.

Request & job tracing

Per-request / per-job waterfalls of every query, cache op and outgoing call — with N+1 detection and distributed W3C traceparent propagation across HTTP and the queue boundary. Only slow or failed traces are stored.

Manual control plane

Dispatch allowlisted jobs (with a form reflected from the constructor) and run artisan commands from the dashboard — every action audited. Off by default; secure to enable.

Error tracking & alerts

A fingerprinted Issues inbox over every layer — web, queue, command and browser errors — with stacktraces, context and a breadcrumb trail, plus manual issue merge. Rule-based alerts (with maintenance windows) route to mail / Slack / Discord / Teams / webhooks, persisted as incidents with MTTR.

Front-end & route performance

Per-route throughput, error rate, Apdex and exact p50 / p95 / p99 latency — plus Real User Monitoring of Core Web Vitals (LCP, INP, CLS, FCP, TTFB) from real visitors via a tiny beacon.

SLOs & error budgets

Track availability and latency objectives against an error budget, with a short-window burn-rate alert — so you hear about a budget you'll exhaust before it's gone.

Logs & custom metrics

A searchable log explorer that correlates every line to the trace that emitted it, and a one-line API (Vigilance::increment() / gauge()) for your own business KPIs on the dashboard.

Query it from your AI agent

An optional MCP server exposes your errors, runs, APM, traces, logs, SLOs and release health to your AI agent — so it can investigate and fix against live data, and even drive the fleet (pause / resume / clear / cancel a queue, restart workers). Read-only and redacted by default; writes are gated and audited.

Why Vigilance

Built for production, not just local debugging

Sampling decided at dispatch time, size caps, secret redaction, an optional dedicated DB connection and a crash-proof capture guard — so it stays cheap at scale.

Feature comparison between Horizon, Telescope and Vigilance.
Capability	Horizon	Telescope	Vigilance
Queue drivers	Redis only	all	all (database · redis · sqs · beanstalkd · sync)
Job lifecycle	✓	✓	✓ one row/run + parameters
Worker supervisor + autoscale	✓ (Redis)	—	✓ every driver
Artisan commands	—	view	✓ capture & run
Scheduler monitoring	—	partial	✓ late / failed / grace
Whole-app APM + route percentiles	—	—	✓ Pulse-parity · p50/p95/p99 · Apdex
Manual dispatch / run from UI	—	—	✓ allowlisted + audited
Error tracking (grouped issues)	—	view	✓ web · queue · command · browser
Real User Monitoring	—	—	✓ Core Web Vitals + JS errors
SLOs + error budgets	—	—	✓ burn-rate alerts
Trace-correlated logs	—	view	✓ searchable + linked to traces
Alerting channels	—	—	✓ mail · Slack · Discord · Teams · webhooks · incidents
Release health / deploy gating	—	—	✓ before/after regression guard + rollback alert
Anomaly detection	—	—	✓ dynamic baselines
AI agent access (MCP)	—	—	✓ every dashboard view — read-only + gated writes
Production-oriented	✓	debug tool	✓ sampled · capped · guarded

Replace Horizon — on any driver

A worker supervisor that runs everywhere

One vigilance:supervise process runs and auto-scales your worker pools — the way Horizon does for Redis, but for database, SQS and Beanstalkd too. Define supervisors per environment; each manages a pool per queue with load-based balancing.

Autoscaling by backlog or time-to-clear, throttled by max-shift & cooldown.
Graceful pause / continue / restart / terminate — even on Windows (cache control-plane + signals).
Per-queue control — pause a single queue (timed or indefinite) while the rest keep draining, clear a backlog or cancel pending jobs — from the dashboard, CLI or MCP, all audited.
Crash recovery — dead workers respawn; a live Workers dashboard shows pools & heartbeats.

chaos-tested 0 orphans database · redis · sqs · beanstalkd

// config/vigilance.php
'environments' => [
  'production' => [
    'payments' => [
      'connection' => 'redis',
      'queue'       => ['payments'],
      'balance'     => 'auto',
      'min_processes' => 2,
      'max_processes' => 10,
      'max_time'    => 3600,
    ],
  ],
],

# run the heartbeat on each app server
php artisan vigilance:check

# enable per-request / per-job tracing
VIGILANCE_TRACING=true
VIGILANCE_TRACING_SAMPLE=0   # keep only slow + failed

APM & Tracing

Performance visibility without the SaaS bill

Whole-app APM (servers, slow requests, queries, outgoing HTTP, cache, exceptions, per-user usage) plus deep per-request waterfalls — self-hosted, driver-agnostic, and engineered to be cheap at scale.

Recorders capture in microseconds and flush after the response — zero request latency.
Per-recorder sampling, thresholds & grouping keep storage bounded.
An Ingest export seam fans the same feed out to an external APM.

Front-to-back observability

Errors, RUM, SLOs, custom metrics & logs

One dashboard for the whole picture — every layer captured cheaply, flushed after the response, sampled and bounded. Read the full observability guide →

Issues — a fingerprinted error inbox across web, queue, command & browser, with stacktrace and context.
Routes & Web Vitals — per-route p50/p95/p99 + Apdex, and RUM of Core Web Vitals from real users.
SLOs & incidents — error budgets with burn-rate alerts; fired alerts tracked as incidents with MTTR.
Logs & custom metrics — searchable logs correlated to traces, plus a one-line business-metrics API.
Release health — every deploy gets a before/after verdict; a bad release fires a rollback-ready alert and anomaly detection catches the rest.

// custom business metrics — anywhere in your app
Vigilance::increment('signups');
Vigilance::gauge('cart_value', $cart->total());

// .env — turn on RUM, then drop @vigilanceRum in your layout head
VIGILANCE_RUM=true
VIGILANCE_LOGS=true            # trace-correlated log explorer
VIGILANCE_DISCORD_WEBHOOK=https://discord.com/api/webhooks/…

Quick start

Up and running in three commands

Migrations auto-load and the stylesheet is bundled — no host build step, no extra infrastructure.

composer require anousss007/vigilance
php artisan vigilance:install   # publishes config + next steps
php artisan migrate

Lock down the dashboard (local-only until you do) — via a gate, like Horizon:

use Illuminate\Support\Facades\Gate;

Gate::define('viewVigilance', fn ($user) => $user->isAdmin());

Prefer a closure? Vigilance::auth(fn ($r) => …) works too. The dashboard then lives at /vigilance.

Configuration & customization

Sensible defaults, tunable for production

Everything lives in config/vigilance.php — fully documented inline. The defaults are safe out of the box; these are the knobs that matter at scale.

Keep it cheap at scale

Sampling, caps & retention

Vigilance is bounded by design. Sample successful runs (failures are always kept), cap stored payloads, redact secrets and prune on a schedule — so monitoring never becomes the thing you have to monitor.

Dispatch-time sampling — a sampled-out success costs zero DB writes.
Secret redaction by key name before anything is stored.
Dedicated DB connection to keep writes off your primary.

# .env — recommended production profile
VIGILANCE_SAMPLE_RATE=0.1          # keep 10% of successes
VIGILANCE_DB_CONNECTION=monitoring # optional dedicated conn
VIGILANCE_RETENTION_DAYS=7
VIGILANCE_FAILED_RETENTION_DAYS=30  # keep failures longer
VIGILANCE_TRACING=true             # slow + errored only

// config/vigilance.php
'path'       => 'vigilance',        // dashboard URL
'middleware' => ['web'],          // request stack

'control' => [
  'enabled'  => false,           // RCE — opt in
  'jobs'     => ['mode' => 'marker'],
  'commands' => ['mode' => 'list', 'allow' => ['mail:*']],
],

'redact' => ['password', 'token', 'secret'],

Make it yours

Publish, theme & extend

The dashboard is a standalone Livewire UI — no Filament, no host build step. Publish what you want to own, pick the cards you want on the APM page, and forward telemetry anywhere.

vendor:publish the config, views or migrations to customize them.
Compose the APM card list; recorders have per-card thresholds & sampling.
Implement the Ingest seam to fan telemetry out to an external APM.

Console

Command reference

Setup & maintenance

vigilance:installPublish config & print next steps (--provider publishes the gate stub)

vigilance:doctorDiagnose the install and surface common misconfigurations

vigilance:pruneDelete old runs and trim metric snapshots

vigilance:snapshotCapture a throughput / runtime / wait-time snapshot

vigilance:schedule-syncSync defined scheduled tasks into monitors

vigilance:deployRecord a deployment marker (feeds release health)

vigilance:sourcemapsUpload JS source maps so RUM browser errors are symbolicated

Worker supervision

vigilance:superviseRun & auto-scale your queue workers (replaces queue:work)

vigilance:statusShow running supervisors, their workers and any paused queues

vigilance:pause / continuePause / resume all supervisors — or a single queue with --queue= (--for= for a timed pause)

vigilance:restartGracefully restart all workers (e.g. after a deploy)

vigilance:terminateGracefully stop the supervisor and its workers

APM & uptime

vigilance:checkCapture server stats + flush telemetry — the heartbeat

vigilance:apm-workDrain buffered telemetry (Redis write-behind ingest)

vigilance:healthPing configured uptime URLs; record availability + latency

Give your queues a control center.

Free, MIT-licensed, and self-contained. Install it in three commands and open /vigilance.

Get started View on Packagist