Settings and license

Settings opens from the cog at the right of the header; the plan beside it opens straight on License. Its sections are listed down the left:

• This machine — General, Recording and Console: the same whichever project is selected.
• Project — Capture and Redact, for the project chosen at the top of the group.
• Account — License.

General

Setting	Default	What it does
JSON font size	10 px	Between 10 and 20. Applies to every JSON view: request bodies, responses and traces.
Open the trace when a request is sent	On	Off, the runner stays in view with its response, and the trace is opened from Request History when you want it.
Leave the service name off hops under the same service	Off	A call a service makes reads POST localhost:8083/reserve under Shop API · POST /v1/orders, instead of naming the service again.
Show a call and the handler that answered it as one hop	On	A call out of one service and the request arriving in the next share a line when they agree. A pair that does not — one that failed — stays as two.
Show the timeline bars in Hops	On	Each hop’s bar beside its name: where in the request it ran, and for how long.
Mark a running service whose code was edited	On	Watches the folder a running service was started from, and marks its node edited when a file there changes. Off, nothing is watched.

Recording

These decide how much of each request is recorded. They apply to services started after the change: stop and run a service again to use them.

Setting	Default	What it does
Record execution	On	On, a service records what its own code did inside each request. Off, only its hops are traced: a send is then around a third of the size, and the service runs without the recorder slowing it.
Record requests from outside Debugt	Off	On, a request that did not come from the runner — Postman, a browser, a phone — is recorded too, and kept in Request History marked outside.
Max steps	5,000	How many steps of one request a service records before it stops and marks the recording cut short. From 500 up to your plan’s limit: 5,000 on Free, 200,000 on Pro.
Max size	4 MB	How large one request’s recording may grow, between 1 and 64 MB. A larger recording costs the service memory while the request runs.
Max repeats per line	0	0 records every run. Above 0, a line is recorded that many times within one call and further runs are folded into a count — so a hot loop no longer fills the step limit, but its middle runs cannot be stepped through one by one.
Value depth	6 levels	How deep a recorded value is written out, between 2 and 20. Below it, an object or array shows only as [Object] or [Array], in the value and in what Copy copies. Deeper costs the service time on every line that changes a large value, and fills Max size sooner.
Value items	50 entries	How many entries of an array, map or set a recorded value shows, between 10 and 1,000. The rest are counted. More costs the service time, and fills Max size sooner.

Value depth and Value items are read by the Node, Python, Go and Java recorders alike. A value’s own size limit grows with them, so a value written out deeper is not then cut short for its length.

A launch configuration can set its own step limit with DEBUGT_EXEC_MAX_STEPS in its env. It is still held to your plan’s limit.

Console

The canvas console’s look.

Setting	Default	What it does
Font size	10 px	Between 10 and 18. Its lines grow with it.
Background opacity	10	How solid its background is over the canvas, between 10 and 100: low to read the canvas through it, high to read the console over a busy one.

Reset to defaults puts both back.

Capture

What is left out of traces and recordings. These lists are per project — the one chosen in Settings’ Project group — and are saved under ~/.debugt. They apply to services started after the change.

Don’t capture

Types that a recording shows as a one-line placeholder instead of in full, matched by class name — the value’s own class or any it is built on. There by default, each can be switched back on:

• Node’s HTTP layer, which Express’s req and res are: IncomingMessage, ServerResponse, ClientRequest, Socket, TLSSocket.
• Fastify’s request and reply, Flask’s application, and the Request of Flask, Werkzeug, Starlette and fetch.
• Mongoose’s internals: the module (Mongoose), its connection (NativeConnection), a query not yet awaited (Query) and a collection (Collection, the MongoDB driver’s too). A document is left alone — it records as its fields.

Add your own — a database connection, a large client object — by name, or by clicking Don’t capture beside a value in a recording.

Don’t capture hops

Calls left out of traces entirely: a health check, a metrics scrape, a telemetry exporter.

• A path such as /health matches requests a service receives and calls it makes.
• A URL such as https://api.segment.io matches calls it makes.
• Matched as a prefix ending at /, ? or :, so /health is not /healthcheck. Use * for anything, as in /metrics*.
• Choose a method, or ANY.

A skipped call carries no trace header either, so what it reaches is left out with it.

Redact

Values kept as redacted instead of what they were. Per project, like Capture, in three tabs. A body field or a recorded variable can be unticked to keep it in the clear for a while without taking it off the list.

Headers

Headers a trace records as redacted — on the runner’s own hop and in every service the project starts. These are always redacted:

authorization, proxy-authorization, cookie, set-cookie, x-api-key, apikey, x-amz-security-token

Add your own, such as a tenant or session token. Applies to services started after the change.

Body fields

Fields whose values traces and Request History keep as redacted — in a JSON body at any depth, and in a form body — for every send and every hop of the project: access_token, password. None by default. The runner still shows the answer it got as it got it, so a token can still be copied from there. Applies from the next send; what is already kept is left as it was.

Recorded variables

Names whose values a recording keeps as redacted: a variable, a key inside a value, an object’s field — in Node, Python, Go and Java services. Matched anywhere in a name, whatever its case: ssn takes out customerSsn. They are taken out in the service as it records, so the value never leaves it.

• Always redacted: password, passwd, secret, token, api_key, authorization, credential, private_key and cookie.
• username is on a new project’s list from the start, marked default. Unlike those above, it can be unticked or removed: a username is often what a recording is read for.
• One service can add names of its own, or switch one of the project’s off for itself alone, in its window’s Redaction section — see Canvases.

Applies to services started after the change. A running service whose list changed is offered a restart.

License

Shows the plan Debugt is on and what it allows: how many services run at once, how many steps of a request are recorded, how many overrides a library holds, and how many shared links are open.

The Free plan

No license, and none needed. Debugt works with no account and no network: up to 5 services running at once, 5,000 recorded steps a request, 5 overrides in each project’s override library, and 3 shared links open at once, each lasting up to 3 days. Pro takes the limit off services and libraries, records up to 200,000 steps, and keeps 50 links open for up to 7 days; a team member’s seat keeps 100, for up to 14 days. Request History has no limit on any plan: how many sends it keeps is yours to set. Get a license opens the pricing page.

Activating Pro

1. Buy a license on the pricing page. The key arrives by email.
2. Paste it into License key — it looks like DBGT-XXXXX-XXXXX-XXXXX-XXXXX — and choose Activate.

A license is good on three of your machines at once. Activating a fourth is refused until one is released.

Once it is active

• The license is checked on your machine and renewed once a day while there is a connection. Offline, or with the license server out of reach, it stays good for 14 days.
• Check now renews it straight away — after renewing a subscription, for instance.
• Remove from this machine takes the license off this machine and frees its place for another. The key still works.
• Manage on the website opens your account: the machines the license is on, a new key, and your billing.

If a license stops counting

Debugt goes back to the Free plan and says why, in Settings → License:

• The license server says no — the subscription ran out, the license was refunded or revoked, or it was removed from this machine on your account. Pro ends at the next renewal, within a day while you are online, or at once with Check now. The 14 days are for being offline, not for a license the server has ended.
• It could not be renewed for 14 days — no connection, or the server out of reach for that long.
• It was activated on another machine — the license on this one was copied from there.

It never stops a running service and never hides anything already on your machine: back on the Free plan, more than 5 services simply will not start until fewer are running. Renew it, or enter the key again, and Pro is back.

What a license check sends

The license key when you activate, a hash of your machine’s id, Debugt’s version, and the license token when it renews. Nothing about your services, requests or traces. The full list is on the privacy page.

VS Code settings

A few settings live in VS Code’s own settings, under Debugt:

Setting	Default	Meaning
debugt.port	4400	The port Debugt’s page is served on, on this machine only.
debugt.openIn	app-window	app-window opens Debugt in a window of its own; browser-tab uses your default browser.
debugt.openUiOnStartup	false	Open Debugt when VS Code starts.
debugt.licenseServer	empty	The license server’s address, for a network that reaches it another way. Empty uses Debugt’s own. Your license key, and every send you share, go there; Settings → License says so when it is set.
debugt.shareWebsite	empty	Where a shared send’s link opens. Empty uses debugt.dev. For working on Debugt’s own website.

The last two are read from your user settings only. A workspace’s .vscode/settings.json cannot set them, so a repository you open cannot send your license key, or your shared sends, somewhere of its choosing.

Where settings are kept

Setting	Kept
Capture and Redact, hosts, kinds, environment profiles, the broker, the override library	Per project, under ~/.debugt
Mark edited services, Record requests from outside	For this machine, in ~/.debugt/settings.json
Font size, trace display, recording limits, the console’s look	In this browser
The license	In VS Code’s secret storage — your system’s keychain