Skip to main content
Live inspection lets your team watch the device of one of your own testers while the app is open: the log lines it writes, its memory and power state, and masked wireframes of the screen. Your team can also send it three commands. It is meant for your internal and test builds: a tester reproduces a bug while you watch, instead of describing it later. Nothing streams from anyone else’s device. Live inspection needs two keys, and the device shows when it is being watched.

The two keys

A device takes part only when both are turned:
  1. The project marks it as an internal tester. An owner or admin marks a person in People, for up to a year. The API can also mark one install.
  2. The app allows it on the device. The app calls setLiveInspection(true), behind its own setting (“Let my team see my activity live”). It is off until the app turns it on, and the SDK keeps the choice across launches until the app turns it off. Nothing else turns it on: not the policy, not a command, not Apsio. An app that never calls it never takes part, so production builds stay out by default.
The call, and how to read the choice back, is on each SDK: iOS, Android and React Native. It can be made before start. The Flutter SDK has no live inspection yet (why). Even with both keys, the device goes live only while:
  • the user’s consent is granted and the kill switch is off;
  • the app has its installation id (an app that turns it off, installationId: false, never takes part);
  • the app is in the foreground.

What the tester sees

While anyone on your team watches, the device shows “Your team is viewing this app live” at the top of the screen, above the app’s content and inside the safe area. It names your team, never a person: the device does not know who is watching. It takes no touch, and the screen reader announces it each time it appears (on iOS, each notice too). The SDK gives the app no way to hide or restyle it. System screens, such as alerts and the share sheet, and on iOS the app’s own alert-level windows, can cover it. Each command that runs adds a short notice under it for 3 seconds: “Your team took a screenshot”, “Your team collected diagnostics” or “Your team raised the log level for 30 minutes”. The indicator and its notices are never recorded: replay, live wireframes, screen views and taps leave them out.

What your team sees

  • Log lines: copies of the records the SDK writes for the logs and errors families, after redaction, whatever sampling and triggers say; each body cut to 4 KB.
  • Memory and power: the memory footprint, the thermal state and the power saving mode, and the battery when the SDK’s battery option is on (see each SDK).
  • Wireframes of the screen when the app records replay: full frames, masked exactly as replay masks them. Taking them does not change the session’s replay, its segments or its budget.
Live inspection never sends what consent, an opt-out or the kill switch stopped. It sends no log lines or wireframes of a family the app turned off in code or the policy sets to never, and refuses diagnostics while the logs family is off.

Commands

Owners and admins can send a device in a live session one of three commands. None runs code or changes the app’s state, and each shows its notice on the device when it runs. Records released only because of a command carry apsio.sampling.released = live, and are stored, kept and erased like every other record.

When it pauses and ends

The channel runs in the foreground only; nothing is kept or scheduled in the background. It pauses while the app is interrupted (for 2 seconds or more), and while the device saves power or data: Low Power Mode and Low Data Mode on iOS, Battery Saver and Data Saver on Android. Under Low Data Mode or Data Saver the device sends nothing at all. A live session ends:
  • at once, when the app goes to the background, consent or live inspection is withdrawn, or the kill switch turns on;
  • when the person stops being a tester, at the device’s next check-in (within about two minutes);
  • after 60 seconds paused;
  • 30 minutes after it started, unless someone watching renews it;
  • after 10 MB sent in the session.
A device sends at most 50 MB a day (UTC), a count it keeps across launches; past it, it does not go live again until the day ends.

Privacy

  • Nothing streamed is stored. Log lines, metrics, wireframes and screenshots go to the people watching, and Apsio does not store them. Live data is never written to disk on the device: lines wait in memory only until the next upload, a lost upload of lines and wireframes is lost (the people watching see a gap), and only a command’s result is sent once more after a failure.
  • The tester stays unnamed. The device proves it is a tester with a one-way proof and never sends the user hash. Like every SDK request, live requests carry the install id. Apsio keeps only the tester’s one-way hash and its last 4 characters, and erasing the user removes them as a tester.
  • People only. Only a signed-in person watches, never a project token, an agent or an upload token. Any member of the organization can watch; only owners and admins send commands.
  • Audited. Opening a view is live.view.start, and a command device_command.send and device_command.result, in the audit log (Settings › Activity), never with the install id, the user hash, a screenshot or diagnostics.
  • The connection. HTTPS to the live host the policy names only (plain HTTP only to this machine, for local testing), never following a redirect, with no cache. The SDK sets no cookies and the live host sets none (on Android, a cookie handler the app installs for the whole process still applies: see Android).

Watching a device

On a tester’s page in People, the Live tab opens the view. Any member of the organization can open it, and each opening is audited as live.view.start. Leaving the tab closes it. The view shows the tester’s devices, with a device picker when there are several:
  • the log lines, newest first, filtered by text and lowest level, with Pause;
  • memory and battery over the last minute (battery only with the SDK’s battery option);
  • a wireframe of the screen.
Owners and admins send the three commands from the tab. Each is confirmed before it goes, and its result shows under it: the screenshot’s wireframe, the diagnostics, or until when the log level is raised. The tab says why a device is not live: none online, in the background, Low Power Mode, paused or ended. It offers Renew while a session is live, and when its 30 minutes or 10 MB are up. The view itself closes after 30 minutes unless renewed. For scripts, a signed-in person opens a view with POST /v1/projects/{projectId}/live/tickets and the tester’s id: the answer is a WebSocket URL to open within 60 seconds, and the view closes after 30 minutes unless renewed (30 tickets a minute per person). Owners and admins send commands with POST /v1/projects/{projectId}/live/commands (10 a minute per person); the device answers within 2 minutes, and 409 means it is not in a live session. The API reference lists their fields. How devices take part is in the specification: live inspection.