Skip to content

Logical map

The logical map is the dependency graph of your infrastructure: hosts, individual checks, collectors, and aggregates as nodes, dependencies between them as edges. Unlike the physical map, it has alerting effect — edges here drive inhibition (suppressing child alerts when a parent is down).

A logical map is tenant-wide, not tied to a site.

Nodes

Node type What it shows
Host Live status as color (OK/WARNING/CRITICAL/NO_DATA/UNKNOWN)
Check A single service on a host
Collector A collector VM; has only one outgoing handle (edges can only be dragged from the collector)
Aggregate K-of-N redundancy of several like-kind members
Sub-map Reference to another logical map — clicking jumps into it
Decorative object Freely named decorative node (see Maps & sites)

Nodes can be arranged by drag-and-drop or auto-arranged (auto-layout).

Viewing and editing

Maps open in a pure view — nothing shifts while looking, no "save?" question when leaving. Editing starts via the pencil at the top right; the check mark saves and ends editing without asking, the X next to it discards. Rename, delete and "New map" live in the ⋯ menu. On the phone maps are deliberately view-only.

While editing, changes can be undone and redone (icon buttons or Ctrl+Z / Ctrl+Y) — positions, sizes, zones, objects, texts, images and decorative lines; one gesture is exactly one step. Created or deleted dependencies are excluded: they are saved immediately.

Drawing dependencies

Connection handles only appear in edit mode. Dragging an edge between two nodes opens a confirmation dialog stating the direction in plain words plus a reverse option — so you confirm who depends on whom before the edge is saved. Dependencies are only possible between devices, checks and aggregates of the same tenant; if linking fails (edge exists, target not found, cycle), the reason is shown.

Drawing convention: provider → dependent

You always draw from the provider to the dependent — dragging an edge from the switch to the VM means "the VM depends on the switch". If the switch fails, the VM's alert is suppressed (inhibition), not the other way round.

Edges dock role-stable: they leave the provider at the bottom and reach the dependent at the top; only real neighbours connect sideways. While dragging, the handles show their role (filled = provides, ring = becomes dependent). Branches can be collapsed — a "+N" chip with status bar shows what is hidden; a red device always stays visible. "Arrange" lays out unconnected devices as a grid and leaves texts, objects and images where they are.

Derived collector→host lines (from the host's assignment to its collector) are always dotted — they show who probes whom but were not drawn manually.

Zones

A zone (formerly "bubble") groups hosts as a panel with header and status bar; selected status hosts determine its colour. Dragging from the zone border to a host — or from zone to zone — creates the matching dependencies via the status hosts (zone↔zone as a cross product), drawn as one bundled line. The zone itself is never part of a dependency; it only lives in the map.

Live status

Nodes color themselves by the current status of the underlying host/check/aggregate. The status poll runs in the background and only updates color — positions stay untouched, a refresh never accidentally moves your layout.

What a dependency actually does

A drawn dependency is more than decoration — it drives inhibition: if the supplier host is unreachable (not: any single check on it being red), alerts of all dependent nodes are suppressed. The "dependency down" badge in the error overview follows the same chain transitively across multiple levels.

Details on the inhibition logic, reachability hints, and suppression rules: Dependencies & inhibition.

Decorative edges stay harmless

On the logical map you can also draw freely labeled decorative edges and nodes (text, object, arrow) in addition to real dependencies. These live exclusively in the map configuration, never in the dependencies table, and have no alerting effect — see Maps & sites.

Managing dependencies from the host

Besides drawing on the map, you also manage dependencies directly on the host: host detail → manage panel → dependencies. There you see:

  • The host's own dependencies (host↔host)
  • A dedicated section "collector on this host" — one click links the collector running on this VM
  • A read-only "further links (map)" — edges drawn on the map for this host's checks (previously invisible here)

Both views — the map and the manage panel — read the same edges and stay consistent.

Aggregates on the map

An aggregate appears as its own node. Clicking opens a popup with status, edit (name/K/members), and delete — no jump to an "owner host", because an aggregate doesn't have one.

Sub-maps

A node can reference another logical map (sub-map) — a container with no edges of its own, only within the same tenant. A sub-map's status is a "worst status wins" rollup over its contents, recursive with cycle protection. A map can't reference itself directly or in a cycle — this is rejected on save.

Next