A QA tester is on a real Android phone. They tap Pay, wait a second, and get a toast: "Something went wrong. Please try again."
They do the right thing and open the request list. The checkout call is there. Status 200, response body looks fine, latency is normal. As far as the network is concerned, nothing went wrong.
So the bug goes to a developer with a screenshot of a toast and a screenshot of a 200, and the developer does what we all do: tries it on their own phone, on their own build, and it works.
The answer was on the tester's phone the whole time. Somewhere in the app, a line like "checkout: couldn't map the order response, the total field was missing" was written to the device log, a few milliseconds after that 200 arrived. Nobody connected to that phone with a cable, so nobody saw it.
The short version, as a video.
Two halves of one bug
When a screen breaks, you need two things:
- What went over the network. The request, the response, the status, the timing. A debugging proxy gives you this, from any device you point at it.
- What the app did with it. Which branch it took, what it failed to parse, what it decided to show. That lives in your app's own logs.
The trouble is where the second half lives. On a phone it's in the system log, which you only see with a cable and the right tool open at the right moment. In a crash reporter, it only exists if the app crashed, and a toast isn't a crash. And in either place, it isn't attached to the request that caused it, so you are matching timestamps across two tools by eye.
What App Logs adds
Proxycept is a hosted debugging proxy for testing your own apps: QA phones, simulators, teammates and CI point at one endpoint and the captures land in one shared console. App Logs is the second half. Your app's own code sends the log lines you choose, from your QA and dev builds, into that same console, next to its traffic.
To be precise about what it is:
- It's the lines your code sends, and nothing else. The SDK doesn't read the system log, doesn't report crashes and doesn't record sessions. If your code doesn't log it, it isn't there.
- Sending logs doesn't need the proxy. The SDK uploads over HTTPS on its own, so you don't need proxy settings or a CA certificate on the phone just to see logs. You need the proxy for the traffic half, and to connect the two.
- SDKs: Swift for iOS and Kotlin for Android, added to your project from source (there's no package-registry release yet). React Native, Flutter and Kotlin Multiplatform are available as source previews. The quickstart guide has the setup for each, and the compatibility details.
The workflow, start to finish
1. Register the app. In the console, App Logs lives under Understand. Add an application, open Setup & keys, and create an ingestion key. The key can only send logs: it can't read anything, it expires after 30 days, and you can revoke it.
2. Log at the decisions, not everywhere. The lines that pay off are the ones at the points where the app chooses what to do: a response it couldn't map, a fallback it took, a state it didn't expect. Give each one a severity and a category ("checkout", "auth", "sync") so you can filter later.
3. Watch it live. Open the app on the phone and the events appear in the console. You can search messages and filter by severity, category, app version, debug session and installation, which is what makes "only this tester's phone, only this build" a two-click question.
4. Connect a log line to its request. This is the part that closes the gap, and there are two ways to do it:
- Exact match. The app logs an event with a request ID and sends the same ID in a header on that request. If your API already returns its own request ID, you can tell Proxycept to read that header instead, from the request or the response. Open the captured request, and its detail view lists the log events that carry that ID, labelled with which header matched.
- Related, by session. Link a debug session from the app to a capture session in the console. The capture's App logs timeline then shows those events too, labelled "Related (linked session)" rather than "Exact request marker". Related means they happened in the same test run. It doesn't prove one caused the other, and the console doesn't pretend it does.
Back to the checkout bug. The tester opens the checkout request in the capture, and right under the 200 is the warning the app logged about the missing total field. The developer doesn't need the phone, the cable or the repro. The response body and the line explaining what the app made of it are on one screen, and the whole team sees the same thing.
Shared, because the bug isn't yours alone
The logs live in the workspace, not on a device. A developer, a QA engineer and a lead can look at the same request and the same log lines from their own machines. On team plans, viewers can read logs, and only editors can create apps and keys.
Privacy and limits
This is for testing your own apps on your team's devices, so treat it that way:
- Use it in QA and dev builds. Don't ship a permanent ingestion key in your production app.
- Don't log what you wouldn't paste into a ticket. Secrets and card-number patterns are redacted on the device and again on the server, but that's best effort. Keep personal data out of the message in the first place.
- Short retention. Events are kept for three days, then deleted, and they aren't included in database backups.
- Shared capture links don't include app logs. A read-only link to a capture shows the traffic, not the logs.
- Attaching logs to a support report is opt-in. If you ever ask us for help, there's an unticked consent box, and at most 25 sanitized events go with it.
- If a build leaves your team, for example to outside beta testers, tell them it sends diagnostic logs and get their consent first.
And the limits worth knowing up front: delivery is queued and retried, not instant, and a log call that hasn't been flushed when the app is killed may not arrive. The exact link only works for requests that pass through a capture profile. And App Logs is a paid feature: network capture is on the free plan, App Logs needs Solo ($12/month) or a team plan.
Try it
- Read the App Logs quickstart and pick your SDK.
- Add one log line at the place your app maps a response, and run it on a QA build.
- Point the same phone at a capture profile, make the request, and open it. The log line should be sitting next to it.
Disclosure: I build Proxycept, so weigh the framing accordingly. If the quickstart trips you up somewhere this post didn't warn you about, tell me in the comments. I'd rather fix the guide than have you work around it.
Top comments (0)