Welcome to Encatch Docs

Live Debugger

Watch the requests the Encatch SDKs and feedback links send from one user or device as they happen, to check your integration and find out why a form did or didn't show

Beta: early access on request

The live debugger is in beta and is being switched on organization by organization. If you don't see Live debugger in your project's menu, contact support@encatch.com and we'll turn it on for you.

Overview

The live debugger shows the requests that reach Encatch from one person, device, or browser tab, live, while you use your app or a form. It captures requests from:

Use it to answer questions like:

  • Did identify run, and with which user?
  • Which forms did the SDK fetch, and why didn't the one I expected show?
  • Did the feedback link load the form, and was the response submitted, or did it come back with an error?
  • Is one person sending far more requests than expected? That usually points to something in the app, such as an SDK call that runs again every time a screen or component redraws.
  • How many requests is the whole project getting right now, and on which APIs?

When to use it

  • While integrating the SDK. Keep the live debugger open as you add Encatch to your app, and check each call as you write it: identify, screens, events, and forms showing and being submitted.
  • When product and engineering check an integration together. A product manager can watch the requests while trying the app and confirm that the right user is identified, the right events and screens are tracked, and forms show when they should, without reading code or asking a developer for logs. When something looks wrong, both can point at the same request.
  • When something looks off in production. Once your access is approved, capture the one user or device that has the problem and watch what their app actually sends.
  • To see how busy the project is. Project traffic shows every request the project receives during the session, from everyone, per API.

Nothing is captured until you start a session, and only the requests that match who you chose are captured. Sessions are short and nothing is kept afterwards, so the live debugger is for checking an integration as you work, not for long-term monitoring.

Who can use it

  • Project members with the Live debugger permission.
  • In Sandbox projects you can use it at any time.
  • In Production projects your project needs approved access first. See Production projects: requesting access.

Where to find it:

  • Sandbox projects: select Live debugger in the main menu, under Connect.
  • Production projects: open Settings and select Live debugger under Debugging.

Start a session

  1. Under Choose who to capture, pick what to capture by and enter the value. See How to filter.
  2. Select Connect.
  3. Use your app or open the feedback link, or ask the person you're helping to. Requests appear in the list as they reach Encatch.

A session runs for a fixed time, shown on the page, and then stops by itself. Select Disconnect to stop it sooner, or Reconnect to start a new one with the same filter. An ended session stays on the page for a while, so you can still go through its requests.

How to filter

There are two kinds of filter. The first decides who is captured: requests outside it are never seen. The second only narrows what's shown from what was captured, and clearing it brings everything back.

Choose who to capture

Capture byWhat you getUse it when
User (user name or Encatch user ID)That person on every device they use. Add a Device ID to limit it to one of their devices.You know who has the problem. Their requests from before identify have no user yet, so capture their device to see those too.
Device IDOne app install or browser, including requests from before identify. The device ID comes with every SDK request.Something goes wrong at sign-in, or for visitors who aren't identified.
SDK session IDOne app launch or browser tab. Capturing stops when the app starts a new SDK session.You want a single visit and nothing else.
IP addressEveryone on that network, which can be many people (offices, mobile networks). Choose Anonymous visitors only to leave out identified users.You're testing from your own network and don't know the device ID yet.
  • You capture one thing at a time. The only combination is a user on one device.
  • To change who is captured while the session runs, select Change next to the filter, edit it, and select Apply. You don't need to reconnect. Only the person who connected can change the filter.
  • From a captured request you can narrow the capture down: open the request and, under Capture instead, pick This user, This user on this device, This device, This SDK session, or Everyone on this IP. This is the quickest way to go from an IP address to one device.

People who open a feedback link are usually not identified, and the link runs in their browser, so capture by Device ID or IP address rather than User. To check a link yourself, capture your own IP address with Anonymous visitors only, open the link, then open one of its requests and pick This device under Capture instead to follow only your browser.

Narrow the request list

Above the request list, Filtered by shows who the session is capturing. Below it:

  • All / Errors: show every request, or only the ones that failed.
  • API: show one API, such as identify, fetching forms, or submitting a response.
  • Hide pings: hide the SDK's regular background check-ins, so the requests that matter stand out.
  • Search: matches the summary, user, device, SDK session, and IP address.
  • Time range: drag across the session chart to look at part of the session. Double-click the chart, or select Show whole session, to see all of it again.

The Requests and Errors totals, the chart, and Download CSV all follow these filters.

What you see

  • Requests: each request's time, API, outcome, a short summary, and the user. Outcomes are:
    • Success: the request worked.
    • Skipped: Encatch answered without an error but didn't do the work, for example because the user doesn't exist yet or couldn't be loaded.
    • Error: the request failed. The HTTP status and error code are shown.
  • Request details: select a request to see the user, device, SDK session, IP address, platform, and SDK version, the device information that came with it, and what was sent and returned. Answers, text people type, contact details, and the values of user properties are left out, and other sensitive values are masked.
  • Session chart: requests and errors over the session.
  • Project traffic: how many requests the whole project is getting per API, from everyone, not only the people you're capturing. It shows counts only, no details.
  • Download CSV: the requests in the list, with every detail.

When a lot of requests match in a short time, the extra ones are counted but not listed: they're included in the totals and the chart but have no details, and they aren't in the CSV. The page tells you when this happens.

Sharing the live debugger

To keep the live debugger instant and accurate for everyone, the number of sessions is limited:

  • One session per organization at a time. Teammates see that a session is running and when it ends. Members of the same project can watch it, but only the person who connected can change the filter or disconnect.
  • When every session is taken, select Join the queue to wait for your turn. The page shows your place in the queue. When a session frees up, it's held for you for a short time, so keep the page open and select Connect when it's your turn.

Production projects: requesting access

Sandbox projects can use the live debugger at any time. Production projects carry real users' data, so access has to be approved by Encatch first.

  1. Open Live debugger in your production project and select Request access.
  2. Choose how long you need it (1 day, 2 days, 5 days, or 7 days) and say why, for example the problem you're looking into.
  3. Select Request access. The request shows as Waiting for approval, and you can Withdraw it while it waits.

The Encatch team reviews the request and may approve it for a different length of time. You don't get an automatic alert when it's approved: the Encatch team will let you know, and the live debugger shows the access the next time you open it. While access is open, every member of the project with the Live debugger permission can connect.

When access ends, whether it runs out or Encatch ends it early, new sessions can't start, and a running session stops within seconds. The page tells you why and shows Encatch's note, if there is one. Request access again to keep debugging.

Privacy

  • Only requests that match who you chose to capture are recorded, and only while a session runs.
  • Answers to forms, text people type (including in AI follow-up questions), contact details sent with a feedback link, and the values of user properties are never shown. Other sensitive values are masked.
  • Captured requests aren't stored after the session.
  • In production projects, access is only open for the period Encatch approved.

Troubleshooting

No requests are showing

  • Check the filter value: a user ID must be the one your app passes to identify, and a device ID or SDK session ID must come from the same app and browser you're using.
  • Requests from before identify have no user. Capture the device to see them.
  • When capturing by IP address, use the public address Encatch sees, not the one your computer or phone shows on the local network (such as 192.168.x.x). A VPN, a company proxy, a private relay, or a phone switching between Wi-Fi and mobile data all change that address, and so does a network that uses IPv6 instead of IPv4. Check your public address on the same device and connection you're testing with, or capture by device instead.
  • Make sure your app uses this project's publishable SDK key. Requests sent with another project's key show up in that project instead.
  • Check Project traffic: if the project gets requests but your session doesn't, the filter doesn't match. If the project gets none, the SDK isn't reaching Encatch.

Requests show as Skipped

  • The user doesn't exist in Encatch yet (for example, the first request after identify) or couldn't be loaded. The SDK keeps working and the next requests normally succeed.

Requests fail with 429 Too Many Requests

  • The project, user, or IP address went over a rate limit. See Rate Limits.

I can't connect

  • Another session in your organization is running, or every session is taken: wait, or join the queue.
  • In a production project, your access may have ended. Request access again.

Things to know

  • Only live requests are shown. The live debugger shows requests as they happen while a session is running. It can't show anything that happened before you connected.
  • Each session lasts 15 minutes. You can start a new session as many times as you need, as long as you're within the allowed access window. For production projects, that's the period Encatch approved. See Production projects: requesting access.
  • Only one session can run in your organization at a time. This applies across all projects in the organization, so two projects can't run sessions at the same time.

Was this page helpful?