User guideWayseer 0.28.3Contents

Lenses

A lens is a way of looking at the same world. Switching lens keeps the focus, the selection, the filter and the time window, and Backspace returns to the lens before.

The lens bar across the top names every lens with its key, and a line under one marks the lens showing. Click a name to switch to it. Detail shows faint until something is focused, since it opens on the focus. A key rebound in the config's keymap shows in the bar as bound. In a narrow window the bar shows the keys alone. Compare has no key, so nothing is marked while it shows. chrome: {lens_bar: false} in the config hides the bar (config).

The selection follows you from lens to lens. Topology frames the focus and the selection, Timeline gives each selected entity a lane, and Stream near the focus includes the selection's neighbors. Flow draws the selection's bands over the rest, and Geo rings the marks that hold it. Grid and Treemap move to a metric or measure that shows the selection, if the one on screen shows none of it and the filter lets it through. After that, m still picks any other.

Status shows as light: healthy entities are quiet, degraded ones warm, failed ones bright.

In Topology, when a warning or worse arrives on an entity, one ring spreads out from it in the event's color and fades within half a second, so you see change as it happens. Info events ripple only on the focus or the selection. Only events that arrive while Wayseer is running ripple, never those it loads from before. With reduce_motion the ring stays still and fades.

Focusing an entity in Topology brings it and its direct neighbors forward: everything more than one link away dims and softens out of focus, easing in as the camera flies there. The theme's depth sets how soft, and effects: low keeps it sharp (configuration).

Topology draws entities in round groups, packed close with a narrow gap between them:

• hosts and what runs on them, by their cluster attribute;
• in a Kubernetes cluster, each namespace with what is in it, its daemon set pods too, and the cluster's nodes together;
• anything else, by the module it came from.

Groups take their places as the layout starts and keep them; a new group finds room beside them. 0 (home) frames them all.

Zoomed out past the point where entities would merge, each group is one disc: its name, how many entities it holds, and the color and rings of the worst status among them. The largest groups are named first. A small group's name goes beside its disc when there is room, and otherwise waits until you zoom in. Entities grouped by their module are drawn as discs for the area they are in, with their count. A group that fills much of the screen breaks up into these area discs, so zooming in on one goes smoothly to its entities.

Links between two groups pull gently, so a namespace keeps its shape however many nodes its pods run on, and within a namespace each workload gathers on its own. Topology draws two kinds of link only for the entity under the pointer or in focus: links between groups, and a namespace's links to its members, which the group already shows. Hover a node to see the pods on it, a pod to see its node and namespace, or a namespace to see all it holds. Other links within a group, and to anything grouped by its module, always show.

Status never relies on color alone. In Topology and Detail, a degraded entity has one ring, a failed one two, a down one is hollow with a slash, and an unknown one is hollow. Elsewhere (Timeline lanes, Stream rows, Detail's event list, the palette and the status bar) a small mark says the same:

A stretch of a Timeline lane that was not ok starts with its mark when it is wide enough to hold one. Topology's labels write an unhealthy entity's reason, and Detail and the hover card write its status and reason.

Moving around

Rest the pointer on an entity, an event mark, a band in Flow or a group in Geo for a moment and a peek card shows its most important facts. An entity's card names what it is in, such as a disk's host, since many disks share a name like nvme1n1. It never takes a click.

Detail needs a focus: with nothing focused, 5 says so in the status bar. Its neighbors ring it in groups named for how they are linked, with a count: runs here · 4 are what run on it, such as a host's services and processes; members · 9 are what belong to it, such as its CPUs and disks; depends on and used by are what it needs and what needs it, such as a database; talks to and talked to by are what it calls or sends to, and what calls it. In Detail, clicking a neighbor opens it. Esc closes Detail back to the lens behind it, still focused on the entity.

Grid

Grid opens on a metric of the focus's kind. With nothing focused, it opens on a metric every module shares, such as cpu.utilisation, over a set whose tiles all fit, else over the most entities. m and M step through the metrics the world's entities offer; o sorts hottest first or by name. To show one metric directly, run it from the palette:

>grid.show metric=cpu.utilisation kind=host

Once its series have loaded, Grid leaves out entities that have no series for the metric, and the header says how many, such as 312 without data. A source such as Prometheus cannot say beforehand which of its targets export a metric, so they show as empty tiles until then.

When none of them have it, the header says so, such as no hosts have go_goroutines in this window, and draws no tiles. m and M then step over that metric and kind until the module's metrics change, or entities of that kind come or go. If every other choice is empty too, they step as usual. A choice that is empty only under the filter is still offered.

Tiles are laid out in rows across the whole width, hottest at the top left, and are as large as the room allows: a few tiles are large enough to show their sparkline's shape, and many shrink together until they fit. A tile is never taller than half the grid, nor about 220 pixels, and keeps a shape between 1.5 and 2.5 times as wide as it is tall, so sparklines compare at a glance. Tiles too small for text show only their color and sparkline, and the header says point at a tile for its name: point at one and its name and value show in the header at once, with its peek card a moment later. When the filter changes how many tiles there are, they move to their new places; with reduced motion they change at once.

Grid draws only as many tiles as the window has room for while each is still tall enough for its sparkline, and never more than 500, the hottest first; it never scrolls. When there are more, the header says how many, such as 500 of 2184 services or, in a small window, 132 of 400 hosts, and the filter narrows them, for example to one job or namespace. A source that can rank its own values, such as Prometheus, sends only its hottest few hundred, as many as the window shows, so a Grid over thousands of targets loads as fast as one over a few.

Treemap

Treemap draws every entity as a tile whose area is its share of a number: a volume's size_bytes, a service's http.requests, a table's row count. Tiles nest the way sources link entities, a directory inside its parent or a service inside the team that owns it, and entities with no parent are grouped under their kind. A group is as large as its tiles together, and its header says its total.

Only numbers that add up can size tiles: bytes, bits, counts, seconds and rates. Percentages and ratios never do, since two half-full disks are not one full disk. Treemap opens on the number the most entities share; m and M step through the others. When a number has a partner with used in place of size, total, capacity, limit or quota, such as used_bytes beside size_bytes, a bar along each tile's foot shows how full it is. A value used beyond its size fills the bar, and the header says how many were out of range.

Anything not ok has an edge down its left in its status color, and its status mark at the top right, as in the table above.

A tile is labeled only where its name fits whole. Treemap draws at most 2,000 tiles, the largest first; a group's smallest tiles past that are summed into one tile, such as 418 more. Clicking it drills into the group, and the filter narrows what is counted: an entity it leaves out adds nothing to its group.

Flow

Flow draws traffic as a Sankey diagram. Entities that only send stand at the left, those that only receive at the right, and each one in between stands one column past the furthest entity sending to it. A band runs from sender to receiver, as wide as its rate. An entity's bar is as tall as the larger of its traffic in and out, and its label gives that rate, such as 506/s or 1.5 MiB/s.

Traffic comes from modules that give an edge a rate: the file module's rate columns (file module), Prometheus flow queries between entities other modules found (Prometheus), or any module speaking contract 1.4. With none, Flow says nothing in view carries traffic.

Flow shows one unit at a time: requests, messages or bytes per second, since a request and a byte are not the same size. It opens on the unit most flows carry, and the header counts the flows in the others; m and M step through them.

Bands are quiet. A band takes its receiver's status color only when that is warn or worse, and the receiver's bar and its status mark say the same. The selection's bands are drawn over the rest in the accent color. Where traffic runs in a loop, the smallest flow in the loop is drawn running back, fainter. A flow too small to see is drawn as a hairline, and its peek card says so.

Focusing an entity narrows Flow to the traffic within two steps of it, upstream and downstream, and the header says around it. An entity with no traffic leaves everything in view, and the header says it carries none. Typing flow of checkout in the palette brings Flow to the front narrowed to checkout in one step. Labels are placed where they clear every other label and bar, the largest entities first; the rest show their names in a peek card. When there are more entities than fit, Flow scrolls.

Flow shows live rates. When the time window is in the past, the header says so at the right.

Geo

Geo draws the entities that have a place on a quiet world map: land as hairlines, and each entity as a disc. Where entities are close at the zoom shown, they are one disc, larger the more it holds, with the count beside it, so no two discs overlap. A disc is colored only when something in it is at warn or worse, in the color of the worst, with its status mark beside it. The header counts the entities on the map, the places they are at, and the entities with no place.

Places come from modules that send them, or from names under places in your config, such as eu-west-1 or Amsterdam, that an entity's region, zone or city attribute holds. A host with no place of its own takes its cluster's (configuration). With no places at all, Geo says so and where they come from. The map is Natural Earth's, bundled with Mind's Eye; nothing is looked up or downloaded. Type map of Amsterdam or where is db-01? in the palette to show Geo there (palette).

Zooming in splits groups as their places come apart. Entities at one place, such as the hosts of one cluster, stay one disc until you are close enough that nothing else is near, then spread around the place, the worst nearest it. Clicking a group zooms in until it splits. Its peek card counts what it holds by status and by kind.

Focusing an entity flies to its place, close enough that it shows alone. Groups split and join with the same easing as Topology, and with reduce_motion they change at once.

Compare

Compare puts two entities side by side, or one entity over the time window and the window of the same length just before it. Select two entities with Shift+click, or focus one and select another, and press c; press C to compare the focus with before. x swaps the sides. In the palette, compare db-01 and db-02 and compare with yesterday do the same by name, and >compare.before ago=7d compares the focus with the same window a week earlier.

Each side is headed with its entity's name, status and sources, and the window it covers. Below, each metric has a row: its newest value and sparkline on each side, with the difference in the middle. The difference is always the right side less the left, in the metric's unit, such as +34.5% or -2.3 GiB, with the difference of the means beneath. A difference is shown only as finely as the values it is taken from: means of 12.3% and 12.2% differ by -0.1%, and values that read the same differ by 0, in the muted color. A metric's two sparklines share one scale when their units agree, so the higher line is the higher value. When the units differ, or a side has no samples, the difference is –. A metric only one side has says not on this side on the other.

When the sides are two entities, their attributes follow, and those that differ are marked ≠. A merged entity counts as one side, with the metrics and attributes of all its members; where two members have the same metric, the one it is named after wins.

Compare fades in, or appears at once with reduce_motion. A bookmark saved in Compare keeps the focus and the lens behind it, not the pair.

Stream

s raises the least severity shown, wrapping round to all; n switches between events near the focus and all events; t scrolls back to the newest.

The filter

The filter narrows every lens at once (palette and filter). Topology dims what it leaves out, so the map stays in place; the other lenses show only what it matches.

Merged entities

When two modules describe the same machine, such as Prometheus's db-07:9100 and an inventory's db-07.lan, identity rules link them, and the lenses show them as one entity:

• Topology draws one node, named for the member with the most links. It takes the worst status of any member, and every member's links end at it. Its label says how many sources describe it, such as 2 sources.
• Grid names each tile after its group, and the filter keeps a tile when it matches any member.
• Flow draws one bar for the group, and sums its members' flows to and from each other entity. Flows between members are left out.
• The palette lists the group once, with its sources counted.
• Detail opens the whole group. It shows every member's metrics, each marked with its module, and every member's events and neighbors. Under sources it lists each member with its module, kind, status and attributes.
• The model sees the group once, with the refs of the other members. A citation of any member links to the group.

To see the members apart, run >view.merge from the palette. Run it again to merge them. Backspace also undoes it, and bookmarks keep the setting.