Skip to main content

Dashboard pages

A tour of every page in the dashboard: what it shows and what you can do there. Use it to find where to look when a job is stuck, failing or missing.

Quick example​

Every job has its own page at /nightshift/jobs/details/{jobId}. Log that link when you queue work, so you can follow a job from your app's logs:

using Masterly.NightShift;

public class ReportsController
{
private readonly IBackgroundJobClient _jobs;
private readonly ILogger<ReportsController> _logger;

public ReportsController(IBackgroundJobClient jobs, ILogger<ReportsController> logger)
{
_jobs = jobs;
_logger = logger;
}

public string? QueueDailyReport()
{
var jobId = _jobs.Enqueue<ReportService>(x => x.BuildDaily());
_logger.LogInformation("Daily report queued, see /nightshift/jobs/details/{JobId}", jobId);
return jobId;
}
}

How it works​

Pages are rendered on the server from the storage's monitoring API and other storage reads, each time you open them. Paths below are relative to the dashboard (for example /jobs/failed is /nightshift/jobs/failed with the default path). The counters in the sidebar and the realtime graph are refreshed by polling /stats every StatsPollingInterval milliseconds; list pages can refresh themselves with the Live toggle in the list toolbar. The toggle is remembered per page in the browser, and a list doesn't refresh while its tab is hidden. A live refresh asks for the list alone (?list-refresh=1): the page is rendered without the layout, and the Failed page skips its failure clusters.

Actions are POST requests to command routes. They are hidden for read-only users and recorded in the audit log. Actions that change a job's state (requeue, delete, enqueue now) go through the normal state machine, with a reason such as "Triggered via Dashboard UI", so filters and continuations behave as if your code made the change. When an action fails, a red bar at the top of the page shows the status the server answered with and its message.

List pages show 10, 20, 50, 100, 500 or 1000 rows per page; a URL can't ask for more than 1000.

Some pages depend on optional features. Wait times and throughput need insights (UseJobInsights()), the live activity and the Timeline need the activity feed (UseActivityFeed()), and a few pages need a storage that supports extra queries (SQL Server supports them all). When something is missing, the page says so.

Options / API​

Menu itemPathWhat it is for
(brand / Home)/Overview: metrics, live graphs, activity
Jobs/jobs/enqueued and the sub-items belowJobs by state
Jobs > Enqueued/jobs/enqueuedQueues and the jobs waiting in them
Jobs > Scheduled/jobs/scheduledDelayed jobs and pending retries
Jobs > Processing/jobs/processingJobs running now
Jobs > Succeeded/jobs/succeededFinished jobs
Jobs > Failed/jobs/failedFailed jobs, grouped by cause
Jobs > Deleted/jobs/deletedDeleted jobs
Jobs > Awaiting/jobs/awaitingContinuations waiting for their parent
Batches/batchesBatches and their progress
Chains/chainsJob chains, their steps, retry from a step
Retries/retriesJobs waiting for an automatic retry
Recurring Jobs/recurringRecurring jobs: trigger, pause, edit, import, export; /recurring/details/{id} for one job and its runs
Policies/policiesSchedule policies (business calendars): edit, preview
Timeline/timelineWhat every worker did in the last 15 minutes
Insights/insightsDuration and failure statistics per method, circuit breakers
Catalog/catalogEvery job method in your code, ready to run
Tags/tagsJobs grouped by tag
Servers/serversServers, workers, pausing processing, maintenance
Audit/auditWho did what in the dashboard
About/aboutThe configuration in effect, global filters, job functions, monitors
Wallboard/wallboardA full-screen status board

The sidebar shows counters next to Jobs, Retries, Recurring Jobs, Servers and each job state. The Jobs counter shows enqueued jobs, or turns red with the number of failed jobs when there are any.

More examples​

Layout: on every page​

  • Sidebar: navigation with counters, the Watching list (jobs you watch, see the job page below; kept in the browser, one list per dashboard path), the theme switcher (system, light, dark) and the "Back to site" link (DashboardOptions.AppPath).
  • Top bar: a live indicator, a Refresh button and Search (Ctrl+K). Search finds a job by its exact id, recurring jobs whose id contains the text, and tags containing it; start with tag: to search tags only.
  • Banners: when processing is paused (drain mode) a banner says so, with the reason, the time it started and a Resume button. Paused queues and paused servers get their own banner. A pause left behind by a server that has stopped is not in the banner; see Servers below.
  • Footer: version, the storage description (unless DisplayStorageConnectionString is false), the storage's clock where the storage has one (SQL Server, Redis, MongoDB, the in-memory storage, and Entity Framework Core on a database it reads the clock of), your app's clock (with a warning when they differ by more than 30 seconds), and how long the page took to render.

Keyboard shortcuts (press ? to see them on lists):

KeysAction
Ctrl+K or /Open search
g then j, p, f, r, s, i, c, t, b, a, hGo to Enqueued, Processing, Failed, Recurring, Servers, Insights, Catalog, Tags, Batches, Audit, Home
j / kNext / previous row in a job list
xSelect the current row
EnterOpen the current row's job
rRun the list's main action (Requeue, Enqueue now, Trigger now) on the selection, after a confirmation
dDelete the selection, after the delete button's confirmation
?List the shortcuts

The letter typed after g only navigates: g then r opens Recurring and doesn't requeue the selection.

The single-key shortcuts (/, ?, g, j, k, x, r, d) can be turned off, for speech input or to avoid accidental key presses: clear Single-key shortcuts in the ? list, or run > turn single-key shortcuts off from search. The choice is kept in the browser. Ctrl+K always works, and > turn single-key shortcuts on turns them back on.

Search and the shortcut list are dialogs that screen readers announce. Search is a combobox: the arrow keys move through the results, the number of results is announced, and closing it returns the focus where it was.

Home (Overview)​

  • Header: the number of servers, recurring jobs and retries, each a link to its page, and Wallboard.
  • State tiles: enqueued (with the number of queues), scheduled, processing, succeeded, failed, deleted and, when the storage counts them, awaiting jobs, each a link to its list and kept current while the page is open.
  • Metrics: tiles added with UseDashboardMetric(...). UseSqlServerStorage adds SQL Server tiles (schema version, connections, transactions, data and log file sizes). Without any, this row is empty. See Customization.
  • Realtime graph: succeeded, failed and deleted jobs per poll interval while the page is open, with a legend and a sentence under it that adds up the last minute ("Last minute: 12 succeeded, 1 failed"), which screen readers read as the graph's description.
  • Live activity: every state change across the cluster, newest first, as it happens: the job, its id, server and reason, its new state and the time. Click a job to open it.
  • History graph: succeeded, failed and (when the storage supports it) deleted jobs per hour for the last day, or per day for the last week, with a legend and the totals of the period under it.

Jobs > Enqueued (Queues)​

One row per queue: length, fetched jobs, wait time (median and p95 over the last 200 starts), jobs started per minute, an estimate of when the queue will be empty, and the next few jobs. A queue with waiting jobs that no worker has touched for five minutes is marked stalled. Wait and throughput need insights.

  • Pause / Resume a single queue. Its jobs are held while the other queues keep flowing.
  • Click a queue to see its jobs (/jobs/enqueued/{queue}): Delete selected, Delete all and Download CSV.
  • Click the fetched count to see jobs fetched by a worker but not yet acknowledged (/jobs/enqueued/fetched/{queue}), for storages that report them: Requeue and Delete.

Jobs > Scheduled​

Delayed jobs and when they will be enqueued. Actions: Enqueue now, Delete selected, Delete all, Download CSV.

Jobs > Processing​

Running jobs with their server, start time, reported progress, an ETA based on the method's usual duration (from insights), a "longer than usual" warning, and deadlines. A job whose server stopped reporting heartbeats is flagged "Looks like the job was aborted". Actions: Requeue, Delete selected, Delete all, Download CSV.

Deleting a processing job asks the running code to stop through its cancellation token; see Cancellation.

Jobs > Succeeded​

Finished jobs with the time they finished, the latency (from creation until processing started), the duration and the total duration. Actions: Requeue, Delete all, Download CSV.

Jobs > Failed​

  • Failure clusters: the latest 500 failures grouped by exception and method (up to 8 groups of 2 or more), with first and last occurrence. Requeue all or Delete all for a whole group.
  • The list shows the exception type and message; More details opens the job's latest failure in a side sheet, read when the sheet opens (/jobs/failed/details/{id}), so the list doesn't carry every stack trace: the exception, when and on which server it failed, the stack trace with Copy stack trace, and View job, Requeue and Delete. A job that is gone, or that never failed, says so there. Jobs with an acknowledging note show Acknowledged (on pages of more than 100 rows, only the first 100 rows are checked for notes).
  • Actions: Requeue, Delete selected, Delete all, Requeue all, Download CSV. Requeue all puts every job that is still failed back in its queue, like Delete all does for deleting.

Failed jobs don't expire unless you set a retention period (Failed jobs), so you can requeue them later. Delete the ones you don't need.

Jobs > Deleted​

Deleted jobs, with the exception when they were deleted after a failure. Actions: Requeue, Download CSV.

Jobs > Awaiting​

Continuations waiting for their parent: the parent job, the continuation options and how long it has waited. Actions: Enqueue (start it without waiting), Delete selected, Delete all. If the storage can't list awaiting jobs, the page explains that continuations still work. See Continuations.

Batches​

Every batch with a progress bar and its succeeded, failed and pending counts. Open a batch (/batches/{id}) to see its jobs, a page at a time, and the continuations that start when it finishes. On a storage without the extended API, the batch page shows its first 500 jobs and says how many more there are. Actions on a batch: Requeue failed and Delete unfinished, within the same limits as Delete all (see Things to know). See Fan-in and batches.

Chains​

Every job chain, newest first (on a storage that can't read ranges of a set, up to 100 of them), with its first step, the number of steps, when it was created and its status. A chain stays in the list while a step of it is left to run or failed for good, and for the chain retention after that. The statuses: Waiting (no step has started yet), Running, Done or Finished with failures.

Open a chain (/chains/{id}) to see it as a flowchart, top to bottom. The header shows its status, its generation (how many times it was retried), its delete behavior and how many jobs and groups it has. In the flowchart:

  • Each step is a card in its state's color: the method and its arguments (the values the server supplies, such as IJobConsole and cancellation tokens, are left out; each argument is cut to 64 characters, and all of them to 200), the state, the start condition (On success, On failure, All succeeded, Any failed and so on) with whether it was met, the progress the job reported, and the job number, when it started, how long it ran and how many times it was retried. The method links to the job's page. A step that won't run (its condition wasn't met, or it waits after a step that failed for good) is dimmed and marked Not run.
  • Parallel branches (ThenMany) sit in a Parallel group box with the group's status, how many of its jobs are still to finish, and how many succeeded and failed. The steps after a group that react to its outcome (ThenAfterAll, ThenAfterAnyFailed...) sit in an Outcomes box.
  • Links are drawn in the accent color where a condition was met, in the failure color where a step ran because something failed, and dashed to a step that won't run.
  • Zoom out, in, or to fit the width, and switch to full screen (Esc leaves it). The flowchart fits the page's width when it opens.

The first 200 steps are drawn, whole levels at a time; the others are listed below the flowchart. Chain logs, under it, merges the console lines of every step in time order (the newest 500), each linked to its step; it opens by itself when a step wrote something. Actions:

  • Retry from here on a failed or deleted step, once the chain has settled (nothing is running or waiting to run): the step runs again with everything after it, and the steps before it aren't re-run. It calls RetryChainFrom.
  • Delete while the chain is still running: deletes the steps that haven't finished, following the chain's delete behavior (Restrict refuses while a step is processing).

A step whose method was renamed or removed since the chain was created shows its step key (1.0) in place of the method, without arguments; Retry from here is refused, with the reason shown, when the retry would have to create such a step again. A step whose job has expired shows what it finished as, such as Succeeded (job expired), and counts that way in the chain's status and in its group's counts; Retry from here is offered on one that failed or was deleted, and creates its job again (it calls RetryChainFrom(chainId, stepJobId)).

A chain step's job page links to its chain next to the job's tags. Its history can show a short Scheduled state with the reason Waiting for chain ... to be recorded, when a worker took the step while its chain was being retried or replaced, or while its creation took more than 5 seconds; a first step held this way while its chain was created is then Enqueued with the reason The chain is recorded. A first step taken during a creation that takes milliseconds, as most do, shows nothing of it. A step held by a retry that was abandoned shows Scheduled, Enqueued and the state it was in before, with the reason The retry of chain ... was abandoned. A job that its chain's record doesn't list is deleted with a reason that says so: see When a step runs.

Retries​

Jobs that failed and are waiting for an automatic retry, with their current state, the reason and when the retry is due. Actions: Enqueue now (retry immediately), Delete selected, Delete all. See Retries.

Recurring Jobs​

Every recurring job on two lines: its id (a link to its page) and its job, then its schedule in words with the CRON expression, its time zone and queue, and chips for its schedule policy, From code, Paused and Retired; its next execution and its last one (the last job's state, a link to the job), each relative with the exact time under it. An error the scheduler hit is a line under the job, with More details for the whole of it. Chips show jobs that are Paused, Late (the next run, or the retry the scheduler set after an error, was due more than a minute ago and nobody started it), or disabled (the CRON expression is invalid or never fires). A job with a start or end date (RecurringJobOptions.StartAt and EndAt) shows Starts and the date until it starts, Ends and the date under its next run while it is active, and Ended once its end date has passed and it has no next execution. A summary at the top warns when jobs are late; when the list has more than one page, it counts the late jobs of the page you see and says so (the /health endpoint checks them all).

  • Trigger now, Pause, Resume, Delete for the selected jobs, and Remove all in the header. Each row also has Trigger now, Pause or Resume, Edit and, after a confirmation, Delete as row actions (shown on hover and keyboard focus, always on touch screens). Trigger now builds the job from its type, so the dashboard's process needs the job assemblies: a recurring job whose type it can't load is reported by id with the load error, and the other selected jobs are still triggered.
  • Edit a job's schedule, in a side sheet: a CRON expression or plain English ("every 15 minutes", "weekdays at 9:30"), the time zone, the queue, and how missed occurrences are handled. The editor previews the next five runs before you save, leaving out runs before the job's start date or after its end date, and shows a schedule it can't read at its field; closing it over unsaved changes asks first. Clear the queue to put the job back in the default queue. The time zone list holds the zones of the dashboard's host; a job whose zone isn't in it (an IANA id on Windows, a Windows id on Linux, or an id only your TimeZoneResolver knows) gets its zone added to the list, and the preview uses it. Open /recurring?edit={id} to go straight to a job's editor, whichever page of the list the job is on; the address then drops edit, so the reload after Save, or a refresh, doesn't open it again.
  • Export downloads every recurring job as a JSON manifest; Import applies a manifest (pasted or from a file), optionally removing jobs that aren't in it. Entries for methods the application doesn't already use as jobs are reported as errors unless DashboardOptions.AllowAnyMethodInManifestImport is set. For read-only users, Export leaves out the values of [Redacted] parameters. See Recurring job manifest.
  • Forecast (/recurring/forecast): when your recurring jobs will run in the next 24 hours or 7 days (?window=7d), each run sized by the method's median duration from insights (runs before a job's start date or after its end date are left out, and so are the runs its schedule policy blocks, those after a run the policy can't evaluate, and every run of a paused job or of a job the scheduler no longer schedules, without a next execution), and hot spots where several jobs start within the same five minutes, listed with the jobs that collide. Summary tiles count the runs, the expected busy time, the busiest hour and the hot spots; a paused job keeps its lane, empty, with a Paused chip. At most 2,000 runs of one job are projected: a job that runs more often in the window (every minute over 7 days, for example) shows "≥2000×", its band reaches the end of the window (or the job's end date), it is left out of the hot spots, and the run total says "≥".

Click a job's id to open its details page (/recurring/details/{id}): the schedule with its description, the job, time zone, queue, misfire handling, schedule policy and skip-after window, its next runs, and its last 20 runs (the storage keeps 50; GetRecurringJobRuns reads them all) with their state, scheduled time, duration, retries, server and reason. A job declared with a recurring job set shows a From code badge followed by the set's name (changes made in the dashboard are replaced the next time the app starts), and a job the set no longer declares shows Retired. Trigger now, Pause and Resume act on that job.

A removed recurring job comes back if your app registers it again at startup.

Policies​

Schedule policies as cards: the time zone and revision, the seven days of the week (an allowed day filled, with a check; Every day for a policy without a weekday rule), the time windows (a window that crosses midnight says so), the excluded dates (the first six, then +N more), the date providers, and links to the policies it requires, makes an exception for or is used by. New policy and Edit open the editor in a side sheet (closing it over unsaved changes asks first), with the same fields (windows as 09:00-17:00, dates as 2026-12-24 or 12-25 for every year); a value the server refuses is shown under its field. Saving sends the revision you opened: when someone else saved the policy in the meantime, the save is refused (409) and the editor offers to reload the policy. Delete asks first and works the same way; it is disabled while another policy uses the policy, and the server refuses it while a recurring job follows it. Saving reschedules the recurring jobs that use the policy. /policies?edit={name} opens that policy's editor, once: the address then drops edit.

Preview opens a side sheet that checks the next 20 occurrences of a CRON expression or plain-English schedule against a policy and marks each one Allowed or Blocked, with the reason. A date provider that isn't registered in the dashboard's process blocks every date of a policy that uses it, as on a server. /policies?preview={name}&cron={schedule} opens it with that schedule, once, like edit. A read-only dashboard shows the cards and the preview only.

Timeline​

A lane per worker showing what it ran in the last 15 minutes, built from the activity feed, with held or retried runs marked. Use it to spot idle workers, long runs and bursts. Under the lanes, the 25 latest runs are listed newest first, each with its state, how long it took, its server and worker, and when it started. With no runs yet, the page says so and links to the catalog to start one.

Insights​

Needs UseJobInsights() or [JobInsights] on your methods; see Insights.

  • Summary: methods tracked, runs recorded, failure rate, and which invokers (generated, compiled, reflection) ran the methods on this server.
  • Needs attention: methods whose behavior changed: a high failure rate, a run much slower than usual, or a slowdown trend.
  • Methods table: runs, failures, the median duration with the p95 and max under it, and a trend sparkline; the invoker and the last run are under the method's name.
  • Circuit breakers: circuits that are open, half-open, recently closed or have failures within their window, with their state, the failures within the window and since when, with Reset (which closes the circuit and removes it from the list until it fails again). See Retries.
  • Activity, last 7 days: a heatmap of finished jobs per hour (UTC), red where failures outnumber successes.

Catalog​

Every job method found in your code (discovered by the source generator, or added with JobCatalog.Add<T>()), grouped by type, with its parameters, how it runs (its queue, retries, timeout, concurrency limit, rate limit and time window, read from its filters and its type's, and its other filters by name) and its run statistics. The filter keeps the methods whose type, name or parameters contain the text. Run opens a form in a side sheet with one field per parameter (parameters supplied by the server, such as a cancellation token, are filled in for you) and creates the job now, later (a number of minutes or a phrase such as "in 2 hours") or as a recurring job; a number or date the job needs, JSON that doesn't parse, and the delay or the recurring job's id and schedule are checked at their fields first. See Job catalog.

Tags​

A tag cloud and a table of tags with their job counts, in name order and a page at a time. The filter box (press Enter) keeps the tags whose name contains the text, ignoring case, across all pages (/tags?filter=billing); paging then goes through the matches. Open a tag (/tags/{tag}) to list its jobs. Jobs that have expired leave their ids in the tag: the page hides them and says how many it hid, and Remove them from the tag forgets the ones on that page. Forget removes a tag without touching its jobs. See Tags and notes.

Servers​

  • Servers: a card per server with its name and id, its workers and how many of them run a job (on a bar), its queues, and when it started and last sent its heartbeat. Servers that missed their heartbeat for longer than ServerPossiblyAbortedThreshold are marked Possibly aborted and muted; they are removed automatically after the server timeout. A paused server says Paused, beside Possibly aborted when its heartbeat is late too. Pause a single server to make it stop taking jobs (after a confirmation): its workers stop fetching within a few seconds, the jobs stay in their queues for the other servers, and its running jobs finish (see Drain mode); Resume it. With one server, its busy workers are the jobs being processed. With more, each server counts its own busy workers (from the moment a worker moves a job to Processing until that job's next state change is done, across all its worker pools) and writes the count after each heartbeat; the page uses those counts when every server has one taken within two heartbeat intervals of its last heartbeat, and otherwise, as with servers of an earlier build, reads up to 500 processing jobs to tell them apart.
  • Pauses left by stopped servers: a server gets a new id every time it starts, so a pause outlives the server it was set on. Pauses whose server is no longer registered are listed here with Clear. They have no effect: the banner and /health ignore them.
  • This process: the process hosting the dashboard, its uptime, an IIS warning when it is hosted by IIS without keep-alive, and the keep-alive status.
  • Danger zone (not shown to read-only users; the header says whether processing runs or is paused): Pause processing for the whole cluster (drain mode), with an optional reason, and Resume processing; and, when the storage supports purging, Clear all jobs removes every job with its history, queues, counters and statistics but keeps recurring job definitions, servers, the audit log and drain mode (with paused queues and servers); Reset storage removes everything but the audit log, so paused processing resumes. Neither can be undone. See Purging data.
  • Job invokers in this process (in This process): how many methods ran through generated, compiled and reflection invokers. See Source-generated invokers.

Audit​

Who did what from the dashboard, newest first: what was done (marked Failed, with its status, when it failed), the user, the action's address, its targets (a job links to its page), the detail, and the time, relative and exact. Users who can change things also see the IP address of each entry; read-only users see it only when DashboardOptions.DisplayAuditIpAddressesToReadOnlyUsers is true. Choose how many entries to read (50, 100, 250 or 1000), filter them by text, or show the failed ones only. Empty when AuditLog.Enabled is false. See Audit log and activity.

About​

What this application configured, as the dashboard's process sees it, in sections you can jump to: the storage and the optional features it reports, the data compatibility level and the options turned on (default recurring time zone, stale restart limit, argument compression, deployment fencing with this process's deployment and the order it was given, followed in brackets by the current deployment when it is another one, date providers), the global filters in the order they run, the registered job functions, and the job monitors with their status. Servers in other processes may be configured differently.

Wallboard​

A full-screen status board for a TV or a second screen, with no navigation. It is always dark, whatever DarkModeEnabled says, because a dark screen is easier to read from across a room. It refreshes every 10 seconds without reloading the page (and not while its tab is hidden) and shows the time in the viewer's time zone (in UTC, marked so, when scripts are off), the overall health ("All systems go", "Needs attention", "Processing is down"), the success rate over the last hour, jobs running now with their progress, the queues, and anything that needs attention (including open circuit breakers). Storages count finished jobs per clock hour, so "the last hour" is the current hour plus the share of the previous hour that falls within the last 60 minutes, as if its jobs were spread evenly.

Job details​

Open any job id to see /jobs/details/{jobId}:

  • Header: the job's display name, plus warnings when its server is gone or stopped reporting (the job may be aborted), or when the job has finished and will expire.
  • Code: the method call with its arguments and the queue. Parameters marked [Redacted] are masked. When the dashboard can't load the job's method, it shows what the storage knows instead (type, method, the load error); the raw arguments and payload are shown only to users who aren't read-only, because [Redacted] can't be read without the method (see Read-only dashboards).
  • Toolbar: Watch (follow the job in the sidebar and get a browser notification when it finishes), Export JSON (method, arguments, history, parameters, console and notes in one file), Run again with changes (a new job from this one with edited arguments, now, later or on a schedule), and Copy as C# (the statement that creates the job again).
  • Tags, batch and chain: links to the job's tags, to its batch and to its chain.
  • Diagnosis: why the job is where it is and what would move it, for example "No running server listens to queue reports", "Retry 3 of 10 is pending" or "Parent 42 has failed and will not be retried".
  • Notes: comments for the next person, and Acknowledge to mark a failure as looked at.
  • Lineage: the jobs this one waited for and the ones waiting for it.
  • Live: for running jobs, progress, console lines and checkpoints written through the job console, updated while you watch. See Progress, console and checkpoints.
  • Parameters, Continuations and Fan-in continuations.
  • Sections added by your own job details renderers.
  • Time in each state: a bar showing how long the job spent in each state.
  • State: the full history, newest first, with each state's reason and data. Requeue and Delete are shown once the job has more than one state; Requeue isn't shown for a job that is Enqueued, which waits in its queue already. Requeue moves the job from the state it is in when the request arrives, so two clicks requeue it once. A state whose data this dashboard can't read (a continuation's next state of a type it doesn't have, for example) is shown as raw data or by its type name instead of breaking the page.

Endpoints for tools​

These routes are meant for scripts and monitoring. They go through the dashboard's authorization filters like the pages (see Letting health probes in).

RouteMethodAnswers
/pingGET200 pong, without touching the storage. Used by keep-alive and liveness probes.
/healthGETJSON health report: storage reachable, servers alive, queues served, processing not paused (pauses left by servers that are no longer registered don't count), no late or broken recurring jobs. 200 for healthy or degraded, 503 when jobs can't be processed. Reused for 5 seconds; storage errors are logged and the report only names the failed check.
/metricsGETThe same numbers in Prometheus text format: jobs by state, queue lengths, servers, recurring jobs, paused flag, health, and per-method and per-queue statistics from insights. Reused for 5 seconds. MapNightShiftHealth/MapNightShiftMetrics serve both outside the dashboard; see Health checks and probes.
/statsPOSTCurrent values of the metrics named in the metrics[] form fields, as JSON. Used by the page itself. A GET answers 405.
/activity?count=50&since={unix ms}GETThe newest activity feed entries (up to 200).
/jobs/live?jobs=1,2,3GET or POSTCurrent state, progress and console (the last 300 entries) of up to 100 jobs. With console=0 the console isn't read and entries is left out; the Processing page's rows ask for that, and don't poll while the tab is hidden.
/search?q=...GETThe search results as JSON.
/jobs/export/{jobId}GETOne job as JSON. Arguments marked [Redacted] are masked; when the method can't be loaded, the raw arguments are left out.
/jobs/{failed,succeeded,scheduled,processing,deleted}/export, /jobs/enqueued/export/{queue}GETA job list as CSV, up to 10,000 rows, sent 500 rows at a time. Columns: Id, State, Job, Time (UTC), Seconds (duration for succeeded jobs, time since start for processing and enqueued ones, delay for scheduled ones), Server (processing jobs), ExceptionType and ExceptionMessage (failed jobs, the message cut at 1,000 characters).
/recurring/exportGETThe recurring job manifest as JSON.
/recurring/preview?cron=...&timezone=...GETThe next five occurrences of a CRON expression or plain-English schedule, as the schedule editor shows them. Optional start and end (Unix milliseconds) leave out runs outside a job's start and end dates. Always answers 200; a problem is reported in the error field.
/maintenance/pause, /maintenance/resumeGETThe current drain mode status as JSON. A POST turns drain mode on or off, like the buttons on the Servers page.
/recurring/trigger-one/{id}, /recurring/pause-one/{id}, /recurring/resume-one/{id}POSTTrigger, pause or resume one recurring job.
/chains/retry/{stepJobId}, /chains/delete/{chainId}POSTRetry a settled chain from a step, or delete a running chain's unfinished steps. 204 when done; 409 with { "error": ... } when another change of the same chain holds its lock; 422 with { "error": ... } when refused or for invalid input.
/policies/save, /policies/delete/{name}/{revision}POSTSave a schedule policy from the editor's form fields, or delete it. 204 when done; 409 when the revision changed or another save or delete holds the lock; 422 with { "error": ... } for a bad value, such as a number that isn't one or overflows. A refused save names the form field of the value in "field" (name, timezone, days, windows, dates, providers, require, except...); a new policy whose name is taken answers 409 with "field": "name".

Things to know​

  • "Delete all", "Requeue all" and the maintenance buttons work on everything in the list or storage, not only the page you see. They ask for confirmation, but there is no undo.
  • One click of "Delete all", "Requeue all", "Remove all" (recurring jobs), "Requeue failed" or "Delete unfinished" (a batch) changes at most 100,000 jobs and works for at most about 20 seconds, so a proxy in front of the dashboard doesn't time out first. Then it says how many jobs it changed and how many may remain; click again to go on. It skips jobs that are no longer in the list's state, such as the deleted jobs that SQL Server still lists in a queue until a worker fetches them. These routes answer { processed, remaining, complete }.
  • Ids and names that contain /, % or ~ work in every page, link and button: job ids (a third-party storage may use any text), recurring job ids, chain and batch ids, tags, queue and server names. ASP.NET Core decodes the path except %2F, so encodeURIComponent alone would send a/b and the literal a%2Fb as the same text. The dashboard therefore writes %, / and ~ inside a path segment as ~25, ~2F and ~7E before encoding it (/recurring/details/a~2Fb is the job a/b). Links to ordinary ids are unchanged, and a %2F in a link that encoded the id with encodeURIComponent alone is still read as /.
  • One row whose state data can't be read (a duration that isn't a number, a time that isn't a date, a processing state without a server) is shown without that value, in the lists, their CSV exports and the job's page, instead of failing the page. A processing job whose state names no server shows it as Unknown.
  • Actions you take are applied by your servers: requeued jobs run only when a server listening to their queue is running.
  • Pages only read. Opening a page never changes the storage; every change is a POST from a button.
  • The dashboard formats dates in the browser, in the viewer's time zone and the dashboard's language. See Customization.

See also​