Dumpio

The window has three areas: the sidebar (left), the dump list (center), and the detail panel (right), with a header above the list and detail.

Sidebar#

• Servers – an All Servers row with the total count plus one row per server (color dot, live status — pulsing green when active, PROTOCOL · host:port, and dump count). Click to filter to a single server.
• Filter by flag – a toggle for each flag (red, yellow, blue, green, purple, pink, gray) with counts. Several flags can be active at once (logical OR); a Clear flag filters button appears when a filter is on.
• Channels – shown when dumps carry channels; All Channels plus #channel rows with counts.

All counts in the sidebar are computed from all dumps, not the filtered view.

Header#

• A search field with a scope selector (All / Keys / Values) and a regular-expression toggle (.*).
• Stats: the number of dumps (filtered/total when a filter is active, otherwise just the total), N errors (exceptions), N data (non-exceptions), and N new (dumps from the last 60 seconds, self-updating).
• Pin – keeps the window always on top (persisted).
• Export – saves all dumps to a JSON file (disabled when the list is empty).
• Clear – deletes all dumps (disabled when the list is empty).

Filtering and search#

Filters combine with AND logic — a dump must pass all active filters:

1. Server – a specific server, or all.
2. Flags – when some flags are selected, the dump's flag must be among them (dumps without a flag don't show while a flag filter is active).
3. Channel – a specific channel, or all.
4. Type – a filter for a single dump type (also available as tabs above the list).
5. Timeframe – the dropdown next to the search box limits the list to what arrived within the last 5 minutes, 15 minutes, hour or 24 hours (Any time by default). It is relative to now, so the list keeps trimming itself as time passes, and the control is highlighted while a window is active.
6. Search – matches metadata (origin/channel) and the content itself.

Search behavior:

• Plain mode is case-insensitive substring search; regex mode uses /query/i (an invalid regex simply matches nothing, it doesn't crash).
• Scope determines what is searched: All (keys and values), Keys (object keys only), Values (values only). Values are stringified (numbers, booleans, null, undefined included).
• Deep content is searched up to a node limit; extremely large content above the limit is treated as a non-match.

All filters and the search query are persisted between runs, so the workspace opens exactly as you left it.

Archives#

The sidebar's Archives section is where a session goes when you're done with it but don't want to lose it. Archive this session asks for a name, stores every dump currently in the stream, and clears the stream so you can start fresh. Click an archive to reopen it (it merges back in), × to delete it. Archives are also commands in the palette, under Open archive.

Saved filters#

A filter combination you keep coming back to — "failed queries on the API server", "everything on #checkout" — can be saved by name and restored in one click.

• Narrow the stream down however you like, then use Save current filters at the bottom of the sidebar and type a name.
• The saved filter captures the whole bar: server, flags, channel, type, timeframe, search query, search scope and regex mode.
• Click a saved filter to restore it; while the bar matches it, the entry is highlighted. Saving under an existing name updates that entry instead of adding a duplicate.
• The × on a saved filter deletes it, and every saved filter is also a command in the palette (⌘K / Ctrl+K), under Saved filter.

Saved filters live with the rest of your filter state — locally, per machine.

The stream: new, unread, pause#

• The NEW label – a brief (~4 s) highlight for just-received dumps.
• Unread markers – a green left border, a bold title, and a dot remain until you actually open the dump (by click or keyboard). Selecting a dump marks it read.
• Pause (p or the toggle in the bar) – truly freezes the list. Incoming dumps are buffered and the "N new – click to show" banner lets them in; resuming flushes the stream automatically. Repeated dedup dumps are collapsed in the buffer so a loop can't flood it.
• Deduplication – dumps carrying a dedupeKey (from the SDK's count() / once() / limit() helpers) collapse onto an existing row, which floats back to the top and is marked unread again, with a ×N badge.

Desktop notifications & image previews#

• A notify dump raises a real OS notification the moment it arrives — even when the Dumpio window is hidden — and clicking the notification brings the app forward. The dump itself is stored and listed like any other, so you keep the record of what fired.
• An image dump shows a data: URI inline (the bytes travelled with the dump). A remote http(s) image is not fetched until you tick Load remote image, so an image dump can't work as a tracking pixel; Open in browser hands the URL to your real browser instead.
• A json dump opens on a searchable tree with a Raw tab for the source; an invalid body still shows, with the parser error above it.

Display modifiers sent by the SDK#

A dump can carry presentation hints from the client's fluent builder, and the detail panel honours them:

• size('sm'|'md'|'lg') (small() / large()) scales the detail body up or down.
• expand() / collapse() open the value tree fully, or start it closed, instead of the default two levels.
• hide() keeps the value masked: the list row shows a hidden badge and the detail panel shows a Hidden value placeholder you click to reveal. Selecting another dump masks it again.

Dumps without hints render exactly as before.

Grouping: screens & requests#

The list can group related dumps so a run reads as a unit:

• Requests — dumps that share a requestId (stamped by the SDK per HTTP request) appear under a request header showing the label (METHOD /path), the response status and total time when the SDK sent a request summary, and a dump count. Click the header to open a waterfall of that request's dumps in the detail panel — each on a shared time axis, with a bar sized by its duration (query time, measure, HTTP response time) so a slow query or a burst of N+1s stands out. It opens with a profile summary — total time, dump count, query count and time, HTTP, errors, and the slowest span. When the SDK sent spans (Dumpio::span() and friends), the timeline is a tree: each section's work is indented under it, coloured by category, so a request reads as "controller → db → view" instead of bars that happen to overlap. Dumps that aren't spans — a query, a log line — appear under whichever span was running when they happened. The panel has a second tab, Queries, which groups the request's SQL the way a profiler does: identical statements (the same query with different literals) collapse into one row with a ×N count, ordered by the time they cost in total — a pattern that costs 300 ms across 40 calls matters more than one 80 ms outlier. Above them sit the counts: queries, total time, distinct statements, how many repeat, and how many cross the N+1 threshold. Expanding a row shows the formatted query and every individual call with its bindings, time and timestamp. The header's chevron folds/unfolds the group. If the same query runs 3+ times within the request, the header also shows an amber N+1 ×N badge (a likely N+1 problem; hover it for the query).
• Screens — a newScreen(label) control message inserts a screen: <label> separator; subsequent dumps fall under it until the next screen.

Dumps with neither stay ungrouped, exactly as an ungrouped stream.

Log-viewer mode#

The Stream / Logs toggle in the toolbar switches the list into a dense, tail-style view of log dumps: one line each (level · time · #channel · message), level-colored. A row of level filter chips (Error / Warning / Info / Debug, with counts) lets you narrow to the levels you care about. Selecting a row opens the full record in the detail panel, as usual. The mode is remembered across sessions.

Paused requests (breakpoints)#

When an app calls the SDK's pause(), its request blocks and a banner appears above the list — Paused: <label> with Continue and Stop buttons. Continue lets the request proceed; Stop ends the script. (A viewer-side timeout auto-continues, so a forgotten breakpoint never hangs the app forever.) This is separate from the toolbar's stream Pause, which only freezes the list.

Copying data#

• The detail header: Copy JSON (always), Copy cURL (only for HTTP dumps).
• In a JSON/variable tree: copy the path to a node (e.g. user.roles[0].name) and the value; URL strings are clickable and open in the browser.
• The command palette: Copy selected dump as JSON.

Jump to editor#

A file:line location in exceptions, stack frames, and variable-dump callers becomes a clickable link that opens your editor at that line. You choose the editor in Settings → Appearance → Editor (saved per machine). Supported:

The Off option renders locations as plain text.

Command palette#

Open it with ⌘K / Ctrl+K (works even while typing). Fuzzy search for commands; move with ↑/↓, Home/End, run with Enter, close with Esc.

Available commands:

• Actions: Clear all dumps, Export dumps, Pause/Resume stream, Copy selected dump as JSON.
• View: toggle light/dark theme, comfortable/compact density, open settings.
• Type / server / flag / channel filters: set any filter to a value (or "All").

Keyboard shortcuts#

Shortcuts are fixed (not customizable) and are ignored while typing in a field, except Esc and the command palette.

Movement is clamped to the ends (no wrap-around).

Appearance#

• Theme: light / dark / system (system follows the OS and updates at runtime).
• Accent color: blue, violet, emerald, rose, amber, cyan — recolors buttons, links, and active states.
• View mode: detailed / compact (how much each dump shows).
• List density: comfortable / compact (row height).
• Font size: small / medium / large.