Skip to main content
Capturing a snapshot in production for the first time takes only a few minutes. You pick a meaningful line in your source code, describe the probe through the HyperProbe panel in VS Code, and wait for your running application to hit that line. When it does, HyperProbe collects all local variables, your watch expressions, and the call stack — without pausing the process or requiring a redeploy.

​
Prerequisites

Before you begin, make sure you have:
  • The @hyperprobe/node-sdk (or Java SDK) installed and running inside your application. The agent must be connected and its status must appear as online in the HyperProbe panel.
  • The HyperProbe VS Code extension installed and connected to your backend. You should see at least one active source in the Source dropdown.
If no sources appear in the dropdown, your agent has not yet checked in with the broker. Give it up to 60 seconds after startup, then verify your brokerUrl, serviceId, and environment values in your SDK configuration.

​
Place the probe

1

Choose a meaningful line

Pick a line that runs on real user traffic and sits at a point where the data you care about is in scope. Good candidates are lines immediately after a request is parsed, inside a function that handles user input, or at the start of a database operation.Avoid lines inside tight loops or extremely high-frequency hot paths unless you plan to use a condition to narrow captures.
2

Open the file in VS Code

Navigate to the file in the VS Code editor. Having the file open is not strictly required, but it makes it easier to note the exact line number you want to instrument.
3

Open the HyperProbe panel

Click the HyperProbe icon in the VS Code activity bar to open the panel. Select Insert a Snapshot from the action list.
4

Select your source

Click the Source dropdown and choose the entry that matches your target service, environment, and commit. The label format is:
Service: my-api | Env: production | Commit: a3f92c1
The commit SHA ensures your probe targets exactly the build currently running. If multiple instances of the same service are online, they share the same probe definition.
5

Enter the file path and line number

In the Filename & Line fields, enter:
  • The relative path to the source file as it appears in your repository (for example, src/handlers/user.ts).
  • The line number where you want the snapshot to fire.
If you are using TypeScript with source maps configured, enter the path and line number from your original source file — HyperProbe resolves the compiled location automatically.
6

Add watch expressions

Enter one or more expressions to evaluate when the probe fires. Watch expressions let you capture values that require computation, not just plain local variables.
req.body.userId
user.subscription.plan
items.filter(i => i.status === 'pending').length
formatCurrency(order.total)
You can add as many expressions as you need. Local variables are always captured automatically — watch expressions are for anything that requires property access, filtering, or method calls.
If you are unsure what is in scope, create the probe with no watch expressions first. After the first capture, review the Variables panel and add watch expressions for anything that needs deeper evaluation.
7

Add a condition (optional)

Enter a boolean expression to filter when the probe fires. The probe only captures when the condition evaluates to true.
req.body.userId === '7a3f9c12'
request.method === 'POST'
order.total > 1000
retryCount >= 3
Use conditions to narrow captures to a specific user ID, request type, or error scenario. This is especially useful in high-traffic environments where you want one or two targeted captures rather than a broad sample.
8

Set the hit limit

Choose how many times the probe should capture before it auto-expires.
  • 1 — One-shot capture. Use this when you want a single definitive snapshot.
  • 3–5 — Good for debugging intermittent issues where the bug doesn’t reproduce every time.
  • 10–20 — Use with a condition so each capture is meaningful and the volume stays manageable.
Avoid setting a high hit limit on a frequently executed line without a narrowing condition. A busy endpoint hitting 1,000 requests per second with a limit of 20 generates 20 captures very quickly and may produce more data than you need.
9

Click Create

Click Create. HyperProbe sends the probe definition to the backend and the agent picks it up on its next sync cycle (within 60 seconds by default). A green indicator appears next to the probe entry once it is live.

​
Trigger and inspect

1

Trigger the code path

Perform whatever action in your application causes the instrumented line to execute. This might be making an API request, submitting a form, or triggering a background job.
2

Watch for captures in the panel

In the HyperProbe panel, the probe entry updates as captures arrive. Click the probe to open the Snapshot Inspector.
3

Inspect the captured state

The inspector shows three collapsible sections:
  • Watch Expressions — The evaluated result of each expression you specified, displayed as an expandable tree. Nested objects are fully navigable.
  • Variables — All local variables captured at the instrumented line, scoped to the selected call frame. Use the search box to filter by name.
  • Call Stack — Every stack frame at the moment of capture. Click any frame to switch the Variables panel to that frame’s local scope.
4

Navigate multiple hits

If your hit limit was greater than 1, use the arrow controls at the top of the inspector to page through captures. The counter shows Hit N / Total, with hit 1 being the oldest capture.You can also type a number directly into the counter to jump to a specific hit.
5

Delete the probe when you are done

Once you have the information you need, delete the probe from the panel. Leaving probes active indefinitely is harmless — they auto-expire when the hit limit is reached — but removing them explicitly keeps the panel tidy and frees resources on the agent.

​
What to do next

  • Learn how to protect sensitive variable values from appearing in captures: Redacting sensitive data
  • Understand the safety mechanisms that prevent probes from impacting production: Safety guardrails
  • Set up source maps if you are using TypeScript or a bundler: Source maps