Web dashboard configuration

This page describes Darling v3.13.0. The source of this page is on GitHub at that version.

Audience: operators.

This page covers the web block of darling.json. It moved here from the Darling operator guide. To turn the dashboard on and look at it, see The web dashboard.

web

The embedded web dashboard — a browser view of the monitoring store, served over HTTP on its OWN port (default 5153), separate from the MCP server. It is a distinct surface from ### mcp: its own enable flag, port, token, and exposure block, because the two gate different blast radii (the MCP token guards analyze_server‘s live outbound connections to your monitored SQL Servers; the web dashboard reads the collected store and, for a sign-in that can make changes, queues commands and edits settings in that store, as below, but never runs SQL an operator wrote against a monitored server). It connects to the store as its own least-privilege web role on a managed store and on the compose distribution’s own store; on any other bring-your-own store it connects as postgres.webConnectionString, or as the owner when that is unset (see What a web token can reach). Loopback-only by default; see Opt-in Network Endpoints (LAN) to reach it from the LAN.

Quiet window (#6231). set_quiet_window (server or the whole fleet, an end, an optional start, a reason) and clear_quiet_window give planned work a time-boxed mute. A quiet window is a mute rule with only a server scope (or none) and an end; the new optional start (starts_at_utc, store rung V208) lets it be set ahead of the work, and until the start passes get_mute_rules lists it with state: upcoming and it mutes nothing. Both tools are write tools. A client with mcp.allowWrites and a token, or an operator token in mcp.tokens, is served them. They are never offered to an investigating agent. create_mute_rule and update_mute_rule take the same start, the Mute Rules page and the Viewer’s mute dialog show and set it, and an end that is not after the start is refused. A window lasts at most 7 days and starts at most 7 days from now. A server, or the fleet, can have one quiet window upcoming or active at a time: a second set_quiet_window for the same scope answers refused and names the first, which clear_quiet_window removes. Each answer gives the rule id and the call that undoes it. Recurring mute rules (#7040). A mute rule can repeat on a schedule (store rung V231). The fields are recur_days (day names such as Mon or Monday, any case, or omitted for every day), recur_start and recur_end (HH:mm), and recur_time_zone. A window that ends before it starts crosses midnight and belongs to the day it starts. The zone is an IANA id such as America/New_York. A Windows id is converted, and the service host’s zone is used when times are given with none. The rule mutes only inside a window, and only between its starts_at_utc and expires_at_utc. The Mute Rules page, POST /api/mute-rules and PATCH /api/mute-rules/{id} take the same four fields. A PATCH sends recur_start and recur_end together. Sending all four as null clears the schedule. The service refuses one time without the other, equal times, days or a zone without times, a days list with no valid day, and a zone it does not know. The page shows the message under the field it names. The Mute Rules page fills the zone with the browser’s. Each rule in get_mute_rules and on the page carries recur_days, recur_start_time, recur_end_time, recur_time_zone, a one-line schedule, in_window_now and next_window_start_utc. An older service does not know the schedule. See the V231 note in Running Darling day to day.

Database state expectations (#6397). get_database_state_expectations lists a server’s databases with the state each is in now, the state the Database State alert expects (expected_state, is_user_override) and a status (as_expected, deviating, ignored or pending). set_database_state_expected sets one database’s expected state, IGNORE (never alert for it) or CLEAR (remove the row; the service learns a baseline again from the next observation). The SQL is one copy, DatabaseStateExpectedStore, that the Viewer’s override editor runs too. The write is served only with mcp.allowWrites and a token, is never offered to an investigating agent (an agent working an alert could otherwise silence it), refuses a database that is not in the latest collected snapshot and a state outside the allowed list, and answers with previous and the undo call. The mcp role gets INSERT/UPDATE/DELETE on config.database_state_expected; its read already ran on the SELECT it holds on all of config. On a bring-your-own store, re-run tools/provision-roles.sql to add the grant.

Investigation admin over MCP (#6400). With mcp.allowWrites and a bearer token, or for an operator token in mcp.tokens, write_investigation_note (note_text, optional server_name, metric_name, days; approved as written), approve_investigation_note and reject_investigation_note (note_id of a pending agent note) and close_investigation_request (request_id, reason) do what the web’s Write a note, Approve, Reject and Close do, through the same store code, with the same checks and refusals. start_practice_request (request_id of a judged case), save_environment_profile (profile_text, optional server_name or tag_id, optional expected_modified_at; a blank text removes the profile) and record_investigation_feedback (request_id, verdict, optional corrected_verdict, missed_step, comment; recorded under the token’s name) do what the web’s Start practice, profile Save and feedback form do the same way. Each answer shows the row before and after. The change is recorded as person:mcp and the token’s name (named token NAME), or legacy token for the endpoint’s one legacy token, and the service log line carries the client’s own name. The first four have no undo, because the web has no way to reopen a request, return a decided note to pending or delete a note; a practice request is closed with close_investigation_request, a replaced feedback record is restored by recording its ‘before’ again, and a profile edit is restored by saving the answer’s ‘before’ profile text again. An investigation agent is never offered these tools: it proposes a note through submit_investigation_report, and a person decides it.

Run collectors now (#5941). On a server’s Collection Health tab, a seat that can edit sees a Run all collectors now button and a Run now button on each collector row. Run all runs every enabled collector for that server once, now, and leaves disabled collectors out. Run now runs just that collector once, even if it is disabled; its schedule and enabled state do not change. A collector that does not apply to the server’s engine is skipped and the result says so. Use it to check collection right after installing an extension or changing a setting. Guards: a second request for the same server is refused while one is queued or running, a request within 60 seconds of the last one for that server is refused (the message says when the next is allowed), and the run takes a slot from the same limit as scheduled collection, so clicks on several servers cannot run more at once than the schedule does. A read-only seat sees no buttons and gets 403. The same action is the MCP tool run_collectors_now (served with mcp.allowWrites). Run all puts extra load on the monitored server, so prefer one collector when one is enough.

Generate now and Ask AI on the web (#6389). On a server’s Recommendations tab, a seat that can edit sees a Generate now button. It queues the same analyze_now command the Viewer’s Generate now queues (no arguments, one server), through config.request_analyze_now, because the web’s web login holds no INSERT on the command queue. The page shows progress, then re-reads the findings when the service finishes. Guards: a second request for the same server is refused while one is queued or running, and one within 15 seconds of the last is refused, and a web click and an MCP analyze_now for the same server share one guard. A read-only seat sees no button and gets 403. A store you brought yourself needs Darling/tools/provision-roles.sql run again to add the function; until then the tab says so and points to the Viewer. Every finding card also has Ask AI, which copies the same investigation prompt the Viewer’s Ask AI copies, built by one shared builder with the finding’s window on the server’s own clock. It only builds text for your own MCP client: the web holds no model key and makes no model call.

Incident actions over MCP (#6230). With mcp.allowWrites and a bearer token, or for an operator token in mcp.tokens, test_connection (one registered server, by name), analyze_now (one server) and purge_now (whole store, optional retention_days 1 to 3650; the first call queues nothing and shows each collector’s retention and the oldest time kept with a confirm_value the first call issues, and only a second call that passes it back queues the purge; the value works once and expires after 5 minutes) queue the same command the Viewer and the CLI queue, through config.request_mcp_command, the only way the mcp login writes a command row (it names analyze_now, purge_now, test_connect and reload, builds a connection test from the stored server row, and refuses any other type). Each answer gives a command_id; get_command_result shows the result once the service has run it on its next poll. A purge cannot be undone. get_agent_changes lists agent changes with their called_id and can_undo, and undo_plan_change undoes a plan force or unforce: it shows the statement first and writes only on confirm: true with that statement, and it needs that server’s force_plan switch and remediation login, the same gate as the force tools. The three queued tools are never offered to an agent sent to investigate an alert. set_agent_actions_enabled (argument enabled) turns the service-wide agent switch off (enabled: true is refused: a person turns it on in the Viewer or the web dashboard), and undo_agent_change (argument called_id) undoes a mute rule, custom alert rule, threshold override or deadlock signature merge change, both by the code behind the Viewer and the web routes (PUT /api/agent-changes/switch and PUT /api/agent-changes/{id}/undo), so the refusals are the same (already_undone, not_found, expired, not_undoable, changed_since) and a plan change is pointed to undo_plan_change. Each answer gives the state before and after, and the journal names the caller as mcp: plus the token and client. Neither is ever offered to an agent sent to investigate an alert.

Collection state over MCP (#6230). With mcp.allowWrites on, or for an operator token in mcp.tokens, an MCP client can pause_collection and resume_collection (all collection), disable_server and enable_server (one server), set_server_excluded_databases (one server’s excluded databases, the same write the Viewer’s Excluded Databases editor makes), set_server_xe_session_databases (one server’s list of databases that get Extended Events sessions, the same write the Viewer’s editor makes: only listed databases get new sessions, an empty list means every database, Excluded Databases still wins, sessions already in unlisted databases stay until you drop them, and it matters on Azure SQL Database) and reload_config. get_collection_state reads whether collection is paused and each server’s enabled flag, excluded databases and monthly cost, and get_server_settings (#6402) reads the fields edit_server changes for one server (never a password or external ID). Pause and resume queue the same pause and resume commands the Viewer queues, through config.request_mcp_command: the answer gives the command id and the read that shows the result (get_command_result, then get_collection_state), and the row is stamped mcp. The other writes run the command plane’s own plan, so the SQL and the checks exist once; each answer gives the previous value and the exact call that undoes it, and each server write logs at Warning with the tool, the server and the caller. A server is found the way edit_server and remove_server find one (the storage name list_servers shows works); a name that matches several servers is answered with the candidates. None of the seven is offered to an investigation agent. The mcp role holds no write on config.config_service.paused: a store that an earlier build granted it loses the grant on the next start, and a self-managed store re-runs tools/provision-roles.sql. edit_server still refuses is_enabled, excluded_databases and xe_session_databases, and its refusal names these tools.

Known patterns over MCP (#6398). With mcp.allowWrites on (and a token), or for an operator token in mcp.tokens, create_known_pattern, update_known_pattern and delete_known_pattern add, replace and remove the entries get_known_patterns lists, the same writes the web editor makes (note is required and at most 500 characters; server_id, metric_name, time_of_day, time_zone, window_minutes and expires_at_utc are optional, and a field left out means any / UTC / the default window / never). They call the same store functions as the web routes and refuse the same things (a missing or over-long note, an unknown time zone, a server_id that is not registered, a bad time or expiry), and write nothing when they refuse. update_known_pattern replaces the whole entry, as the web editor’s save does. Each answer carries the entry before and after and an undo call (a delete’s undo re-creates the entry under a new id). The mcp role holds EXECUTE on the three functions and nothing on the table. These tools are never offered to an agent that Darling sends to investigate an alert; it may read with get_known_patterns.

Key Default Notes
enabled false Off by default — a headless service does not open a local port unless you ask
port 5153 Chosen so all four local surfaces coexist on one machine (Dashboard 5150, Lite 5151, Darling MCP 5152)
allowTokenlessLoopback false On, a loopback-only dashboard with no token serves local browsers without one, for reads only, and every start logs a line saying so. A change (adding a server, editing a view, muting an alert) is refused with 403 and a message that names the token setting. Off, an enabled dashboard with no token does not start. A configured token gates every request either way.
allowAdminWrites false when the key is missing Managed store only. A new install writes true here (the installer’s darling.json and darling.sample.json); a darling.json without the key, such as one from 3.11, keeps it off until you set it. On, a person signed in to the dashboard as an admin (the shared token, or an OIDC admin) can make its Admin writes (routes and environment profiles, threshold overrides, alert settings (the daily report and database protection), people, sign-ins and grants, report feedback, server actions, note decisions, undoing an agent change and the agent switch, closing a request, writing a note, practice requests, and case export) through a second small connection pool. That pool signs in as the managed admin login, the one the Viewer uses. Every other request stays on the web login. Off turns those writes off on the managed store, and the Admin page says so under its heading. Adding and editing servers are not on that list: they follow the edit seat through the web login’s own grants, so the Servers tab still saves with this setting off. Every start logs which of the two it is. With OIDC on and no role mapping, every signed-in user has the edit seat. With this setting on, every one of them can make these writes. Every start with OIDC on and no role mapping logs a warning that names web.network.oidc.roleClaim, on any kind of store; map roles before you turn this on. On a store you bring yourself, including the compose store, this setting does nothing. There, what an edit seat can change depends on the grants of the web’s own store login. File-only; restart to change
allowWindowsAuthOverUnverifiedTls false Adding or editing a server in the dashboard defaults to Windows authentication, where the service presents its own computer account to the host the form names. Off, the dashboard refuses a Windows-authentication server that also sets trust_server_certificate or an encrypt_mode other than Mandatory or Strict, because the service could not confirm which server it reached. To save such a server, use a verified certificate (trust_server_certificate false and encrypt_mode Mandatory or Strict), use SQL authentication, or turn this on. An edit is judged only when it changes the machine the entry names or its sign-in and certificate settings (the host, the port, the auth type, trust_server_certificate, encrypt_mode or the Query Store replica), on the server as it would be saved, so changing a display name, a threshold or a tag is never refused. read_only_intent and multi_subnet_failover do not change the host the entry names, so they are not judged. On, the dashboard accepts the combination. SQL authentication and the Entra modes are not affected. It is the dashboard twin of mcp.allowWindowsAuthOverUnverifiedTls. The setting is not written by the installer. File-only; restart to change.

What the dashboard can change. Besides reading the store, a sign-in that can edit adds, edits and removes monitored servers. It also edits alert routes, mute rules and custom alert rules, and runs the commands and changes the settings described above.

Daily Health Report settings (#7041). On the Admin page, the Settings tab lists the alert settings read only, with one exception: a signed-in admin also gets a form under the Daily Health Report rows. It holds the checkbox “Send a daily health report”, the “Send at” time (HH:mm), the “Time zone” (an IANA id, starting at the browser’s zone for a report that is off and has no zone yet, blank for the service host’s zone) and an optional “Title”. Save writes through PUT /api/alert-settings/daily-report, which runs the same validation as update_alert_settings, so a refused value shows the service’s own sentence. Preview builds the report with get_daily_health_report and shows it on the page without sending anything. A dashboard on the managed store needs web.allowAdminWrites for the save, like the other Admin writes. The other alert settings stay in the Viewer and over MCP. See Daily Health Report.

Database Protection overdue ages (#7611). A full backup counts as overdue after 168 hours, a log backup after 60 minutes and a CHECKDB after 336 hours, until you change them. A signed-in admin gets a second form on the Settings tab, under the alert thresholds, with one box for each age: hours from 1 to 1440, minutes from 1 to 86400 and hours from 1 to 8760. Save writes through PUT /api/alert-settings/database-protection, which runs the same validation as update_alert_settings. The Viewer’s Settings window has the same three boxes beside the overdue alerts. A server or a single database can override each age in Threshold Overrides, using the keys backup_overdue.threshold_hours, log_backup_overdue.threshold_minutes and checkdb_overdue.threshold_hours.

A token is required on loopback too. Once web.enabled is on, the dashboard starts only with a token. Set web.network.encryptedToken (from --encrypt-password) or web.network.token (the token itself, env:NAME or file:PATH), and leave web.network.listen out to stay loopback-only. On Windows, use encryptedToken. env:NAME and file:PATH references are for the compose and Linux setups, where there is no DPAPI. To make a token, use the PowerShell one-liner under MCP endpoint. The browser then shows a sign-in page: paste the token there once, and it is exchanged for a session cookie. With no token the dashboard does not start, and the service log names these settings. --print-web-token, run elevated on the service host, prints the configured token. To serve local browsers with no token, set web.allowTokenlessLoopback to true. The dashboard then serves reads only, and every start logs a line saying so. A token shorter than the floor below (16 characters, 6 of them different) still signs a browser in, but the dashboard serves reads only until a longer one is set.

Named tokens with a role (web.network.tokens, #7735). The shared token above always signs a browser in as an edit seat. To hand a person a token that can only look, add entries shaped like mcp.tokens: each has a name (1 to 64 of A-Za-z0-9._:-), one of encryptedToken (from --encrypt-password) or token (the value, env:NAME or file:PATH), and a role. The roles are the mcp.tokens words: reader without a tag scope signs in to the same read-only seat an OIDC viewer gets (every page and every read, and every change refused with 403 by the dashboard’s write gate, the composer’s saves, alert rules, mute rules, dismissals, server add and edit, Run now and Analyze now included), and operator signs in to the edit seat, with its changes stamped with the entry’s name. A named token stamps its name on every edit, the same way a signed-in person’s subject is stamped. Give each token a name nobody else signs in with. There is no agent seat on the web. The shared token stays required and keeps its edit seat, so a site that adds no entries sees no change. The same rules as mcp.tokens apply: each value must clear the token floor, names and values must be unique, a value the shared token or any MCP token has is refused, a name is not one of web, mcp, cli, viewer, invalid or unclaimed in any case (the names the dashboard, the MCP surface, the command line and the Viewer stamp their own changes with, and the mcp.tokens placeholders: a token’s name is what its changes are stamped with), and an entry that cannot be served is left out with one Critical line that names it and never its value. --validate-config reports the same findings. The sign-in form is the same one, the service log names the token that signed in and its role, and the sign-in throttle is unchanged. A named token’s session cookie carries its name only: the role is read from the configuration at every request, and a token removed from the list (which takes a restart, like the rest of this block) ends its sessions on their next request.

Scoped reader tokens (#7988). Add allowedTagIds to a named reader token to restrict its monitoring data to servers in selected server-tag subtrees. These are server tags, separate from query tags. Supply a nonempty array of positive integer tag IDs; multiple IDs grant the union of their subtrees. allowedTagIds applies only to entries in web.network.tokens: the shared token, an OIDC viewer and the mcp.tokens entries are unaffected by it.

For example, with PROD and the tags Finance and Operations beneath it, granting Finance includes servers assigned to Finance or its descendants. It excludes Operations, servers assigned only to PROD, and untagged servers. Granting PROD includes both child subtrees. The scoped tag tree does not expose Finance’s PROD ancestor or its Operations sibling.

Configuration Result
allowedTagIds omitted or null The named token keeps its existing unrestricted server visibility, subject to its role.
allowedTagIds: [42] A reader sees servers assigned to tag 42 or its descendants. Replace 42 with the intended tag’s actual ID, shown in the Viewer’s tag manager and stored in the config.server_tags table.
Positive IDs that do not exist, or tag subtrees with no assigned servers Those IDs grant no servers. Other valid IDs in the array still grant their subtrees; there is no fallback to the whole fleet.
Empty array, zero or negative IDs, or a scope on an operator token The token is not served. Validation and the service’s Critical log explain the invalid entry without logging its value.

Scoped sessions can use Fleet Overview, the SQL Server and PostgreSQL server tabs, FinOps, Alert History, Job History, Investigations and their reports, and Fleet Sweeps. Server lists, query results, counts and sweep comparisons are restricted to permitted servers. Shared view definitions, known patterns and global alert settings require unrestricted access.

The service enforces this restriction on API requests as well as navigation. A server-specific read must identify a permitted server; changing a URL or request parameter cannot expand the grant. Scoped tokens remain read-only, cannot open Admin or other unsupported management pages, and receive 403 for unsupported API routes. Existing unrestricted readers, operators and the shared token retain their permission rules.

The session cookie carries the token’s name; the service obtains its role and tag grant from configuration on each request. Changing named-token configuration requires a service restart. Changes to server-tag assignments or the tag hierarchy apply on subsequent requests without signing in again. Scoped reads do not reuse unrestricted cached results.

Collector-service health describes the shared monitoring service. Sweep server lists and totals are scoped, while the shared collector-health indicator is explicitly labelled. Scoped tokens are supported on a store’s direct dashboard; the front-door proxy does not forward their grants, refuses a scoped token at its sign-in form, and logs one Critical line at start when a scoped entry is configured on a front-door host. The standalone Viewer continues to use its own store login, and MCP token permissions are unchanged.

Administrators configure scoped tokens in the service configuration.

"web": {
  "network": {
    "encryptedToken": "<the shared token, the edit seat>",
    "tokens": [
      { "name": "readers", "encryptedToken": "<--encrypt-password output>", "role": "reader" },
      { "name": "ops", "token": "env:DARLING_WEB_OPS_TOKEN", "role": "operator" },
      // Replace 42 with the Finance server tag's actual ID.
      { "name": "finance", "token": "env:DARLING_WEB_FINANCE_TOKEN", "role": "reader", "allowedTagIds": [42] }
    ]
  }
}

Viewer-managed team access groups

Advanced web access starts off. A Viewer administrator can select Enable advanced web access in the sidebar to show Web Access Groups and allow group-token sign-in alongside existing dashboard sign-in methods. Clearing the checkbox hides group management, blocks group-token sign-in and invalidates group sessions. Re-enabling access lets users sign in again with their existing enabled group tokens. Every flip of the switch writes a row to the group journal, config.web_access_group_events, with the database role that made it and when.

The Viewer stores these groups in the PostgreSQL control plane, separately from web.network.tokens. The service’s web dashboard must be enabled and its password-sealing key healthy before it can accept a new token. The existing network, TLS, Origin, sign-in throttle and cookie protections also apply to managed groups.

  1. Set up the server tags and hierarchy in Manage Tags. For example, create Finance under Production and assign its servers to Finance or its descendants.
  2. Open Web Access Groups, choose New group, and enter a unique name (1–64 letters, digits, dots, underscores, colons or hyphens). Names are fixed at creation; delete and recreate a group to rename it. A store holds at most 256 groups. Delete a group you no longer need before you create another.
  3. Choose Selected tags and their descendants and select one or more tags, or explicitly choose All servers. Selected subtrees are combined. Finance grants Finance and its descendants, not Production-only servers or Finance’s siblings. All servers includes untagged and newly registered servers. Every managed group is read-only. A tag-scoped group gets the scoped reader’s page set and server filtering described above; a group over All servers signs in with the reach of a named reader token, every reader page and every server, and no administrative page.
  4. Choose Create group and token. Viewer generates a random token and seals it to the service’s existing published key, using the existing key-trust checks. The service validates and activates it on its supervisor poll (normally within five seconds). Viewer shows the token only after the matching group and generation are active. Copy it while it is visible: closing the window, changing selection, refreshing or clearing the field removes it from the display. It cannot be retrieved later; rotate it if it is lost.
  5. Give the team its dashboard address and token separately. The team pastes the token into the dashboard’s existing sign-in form. Do not append it to a URL: query-string tokens are refused.

Maintenance. Select the group, edit its tag scope or Enabled state, and choose Save changes. Scope changes keep the token and apply on the next web request. Tag assignments and inheritance are resolved from current store data. A tag-scoped group’s reach follows its tags live. Anyone who can assign tags to servers or move a tag under another tag changes which servers the group’s holders see. They see the change on their next request. The web and MCP roles can write both tag tables, and the dashboard and the MCP tag tools do so. Only a tag delete is written to the group journal, so a tag assignment or move leaves no journal row. Removing a tag removes that grant; if no grants remain, the group sees no servers. An empty grant never becomes All servers. Disabling a group refuses its current sessions and sign-ins; enabling it again permits its current token and unexpired sessions again.

Rotation and deletion. Rotate token replaces the generation immediately: the old token and old browser sessions stop working, even while the new token is pending. Delete group revokes its token and sessions. Recreating the same name uses a fresh immutable identity and does not revive them. Changes use revision checks; if another administrator or service activation changed the group meanwhile, refresh before retrying.

Pending or refused tokens. A pending token is not a working credential. If Viewer times out waiting, check that the service’s direct web dashboard is enabled and that its sealing key is healthy; refresh, then rotate to receive a new one-time token. A managed name or token that conflicts with an existing file/shared/MCP credential is refused without disabling that existing credential. A conflicting name requires deleting the group and creating one with a different name. An unreadable token requires rotation with the current service key.

Rolling back. Only builds that have the V261 migration keep the group tables closed to blanket grants. An older build restores those grants when it starts. The viewer, web, MCP and admin logins can then read the group rows, including the sealed token (ciphertext only). They still cannot write them. Delete the groups before you roll back past V261, or see Rolling back to an older build.

Authorization and storage. Viewer management requires permission to execute the protected group-management function; the product admin role is granted it. Viewer, web and MCP roles cannot manage groups, and consumer roles cannot read the stored sealed credential. A managed browser cookie carries the immutable group ID and token generation under the existing HMAC signature. Each page load and each API request checks current group state and grants through the web-role metadata read; the page’s own scripts and stylesheets carry no data and are served without that check. Store/key failures refuse managed access rather than reusing stale grants: a signed-in session’s request answers 503 while the store cannot be read, and a sign-in attempt in that state gets the same refusal as an unknown token. Requests already admitted can finish; revocation does not recall data already delivered. Shared/file tokens, OIDC and standalone Viewer/MCP permissions retain their existing behaviour. Managed groups are supported on the store’s direct dashboard, not the front-door proxy, and do not create new web/MCP administration endpoints.

web.network.tls takes a PFX file, a PEM pair or an entry in the Windows certificate store. For the store, use "tls": { "store": { "thumbprint": "..." } }, or use "subject": "dashboard.example.com" to serve the newest valid certificate for that name. location defaults to LocalMachine and name defaults to My. Give one form only.

The service account needs Read on the key. Use certlm.msc (All Tasks, Manage Private Keys), or run PerformanceMonitor.Darling.Service.exe --grant-cert-key-access <thumbprint> from an elevated prompt. The service reads the certificate at start, so restart it after a renewal. The Web TLS Certificate Expiring alert catches a restart that you missed. A store certificate that cannot be used keeps the dashboard loopback-only and logs a Critical line. Certificate from the Windows certificate store has the selectors, the key access step and every failure.

Once enabled, open http://localhost:5153/ in a browser on the service host. Like the MCP server, enabled/port here are the file SEED; after first start they live in the control plane and the Viewer’s Settings toggles them LIVE (the service starts/stops/rebinds the dashboard within seconds — no restart). If the port is already in use at startup, the web host logs an error and retries on a calm cadence; collection is unaffected.

What you see. The dashboard opens on a Fleet Overview: a card per enabled server with a status dot, six per-metric health bands (CPU, threads, memory, blocking, deadlocks, collectors), and its last collection time — all banded server-side, so the browser only renders (a server the service has just registered and not yet collected from shows an amber “Awaiting first collection”, never a red offline; one that stopped reporting reads Offline however long ago it stopped). Above the cards a worst-first “Needs attention” list surfaces the servers to look at, or an all-healthy line when there is nothing to chase. Click a card to drill into one server: an overview, wait stats with a trend for the heaviest wait, active queries, a CPU chart, memory and file-I/O trends, and collection health — the same collected data the viewer shows, over inline charts. A fleet-wide Alert History page (with a server filter box) rounds out phase 1, a Custom Views page hosts the composer for the saved dashboards/notebooks in config.custom_views, and an Alert Rules page edits the user-authored custom alert rules (evaluated on a managed or compose store; on any other bring-your-own store they can be authored but do not fire, since its web role comes from tools/provision-roles.sql, which does not create the resolve function the evaluator needs, #3970). A Fleet Sweeps page (#3466) renders the scheduled whole-fleet sweep reports as a timeline at a configurable viewing span (default the last hour): each sweep’s document diffs against the previous sweep (band transitions with reasons, arrivals and departures), carries the watch-item worklist with its hysteresis position, states the alert master switch on every sweep and renders the would-have-paged ledger whenever one was taken under mute — and a sweep that could not prove its instruments were alive renders LOUDLY (a red banner and a marked timeline row), because quiet is not clean. The sweep cadence shown there is read from get_alert_settings‘ fleet_sweep group; the Settings window and update_alert_settings own the knob. Channel delivery of sweep content is bounded at a daily rollup, a ceiling rather than a default, per the issue’s delivery ruling: at most one INFO post per day through the existing alert channels, summarizing the trailing day’s band transitions, watch-item openings and closings, instrument-liveness incidents, and — whenever any covered sweep ran under the alert master switch — the would-have-paged ledger those sweeps carried, so the operator sees what the silence cost. A day with nothing to say posts nothing (the collector-cost digest’s own discipline — the web feed is where the affirmative, instrument-proved all-clear lives at full cadence), and the rollup’s delivery is itself master-gated: with alerts_enabled: false the sweeps keep publishing here and to get_sweep_reports, nothing reaches the channel, and the first rollup after re-enable states how many of its covered sweeps ran muted — older muted days stay readable on this page permanently rather than arriving as a re-enable flood. The HTTP API also carries the mute-rule write endpoints (/api/mute-rules, #3450) — their page UI is deferred; the endpoints are the deliverable — all writes gated on the editing seat. Otherwise it is a read-only view — no settings, no live-server queries — and it refreshes every 60 seconds (pausing while the tab is hidden). The frontend ships fully self-contained (no CDN, no fonts, no remote anything), so it works on an air-gapped host with no internet access.

A web dashboard that fronts other stores. A service with frontDoor.enabled serves this same dashboard, with a store picker, and sends each page call to one of its stores. The web settings above (token, allowFrom, OpenID Connect) decide who can sign in to the front door. The webUrl and webToken of each store are in the frontDoor block. See The front door.