Since 0.1.165, UI and server telemetry carry a host tag and attribute with one of
codex, claude, cursor, mac or other. Codex, Claude, Cursor and other MCP
Apps hosts load the same panel and server; the Mac app runs the same server and shared UI.
Behavior never depends on this value; it only attributes measurements and errors.
- The Mac page names itself (
data-host="mac"); the Mac app also starts the server withMOBILE_DEV_HOST=mac. - MCP Apps panels are labelled once connected:
codexwhen the host advertises OpenAI extensions, otherwise the host's reported name mapped bytelemetryHost(claudefor Claude,cursorfor Cursor, elseother). Before the Cursor plugin, Cursor sessions were reported asother. Calls before connecting carry no host. - The server labels itself from the connecting MCP client's name on initialize and
reports
otheruntil then. - In hosts that render no MCP Apps panel, such as Claude Code, and with
MOBILE_DEV_PANEL=browser, as in T3 Code's Codex threads, the panel can open in a browser beside the chat. Its page names itself with the server's label for the chat host, so the panel is attributed to that host. Its requests join the host's server session with the same trace propagation; the browser page adds no telemetry of its own. Page server and cleanup failures are captured asbrowser_panel.requestandbrowser_panel.close. Thebrowser_panel.sessionsgauge measures active browser MCP sessions on creation, deletion, expiry and shutdown, withcomponent=server. It contains no session IDs, URLs or tokens and honors telemetry opt-out.browser_panel.context_updatecounts the page's model context updates byoutcome(stored,invalidortoo_large), andbrowser_panel.context_bytesrecords the size of stored updates in bytes; the context's text and images are never sent. - Packages that download the panel's native parts, such as Claude's, measure that
step.
panel_runtime.readyrecords, in milliseconds, how long the runtime took to be ready on a panel's first backend start in a server, byoutcome:cachedwhen a complete folder was already there,downloadedfor a download, checksum check and extraction, orfailedwith a boundedreason(network,http,checksum,archiveorfilesystem).panel_runtime.download_bytesrecords the archive size of each download. A failure surfaces as the expecteddownload_failedoutcome; checksum, archive and filesystem failures are also captured aspanel_runtime.prepareerrors with apanel_runtime_failuretag, while offline machines and unreachable releases are not. URLs, paths and versions are never attributes, and both honor telemetry opt-out. Browser sessions expire after five idle minutes; active requests prevent expiry, and open tabs send a ping every 30 seconds. - The server's metadata allowlist accepts only these values; the raw host or client name is never sent.
Earlier releases have no host value. Surfaces, measurement names, units and
boundaries are unchanged in every host.
The Mac app loads its page through the server's ui://mobile-dev/mac.html resource,
so the page receives the same server-owned environment, opt-out and anonymous
identity as the Codex panel. Mac builds are development-only for now; the SwiftUI
shell has no native Sentry SDK.
Since 0.1.177, release MCP servers send basic product analytics to Mixpanel's EU
project to count installations and feature use. instrumentProductAnalytics
(packages/core/src/analytics.ts) wraps the tools/call handler and reports
Tool Called with the tool name and a success or error outcome; the chat
client's initialization reports Session Started. Every event carries only
host, plugin_version, os (process.platform), a timestamp, an insert ID and
the server-owned installation ID as distinct_id. Tools isFrequentTool lists are
skipped. Events are batched (50 per request, at most 500 queued), sent every 30
seconds and when the plugin closes; failed batches are dropped. Requests go to
api-eu.mixpanel.com/track?ip=0&verbose=1: Mixpanel neither stores nor geolocates
the IP, and reports rejected batches in its reply.
Each connected session also queues an installation profile with the same
distinct_id, host, plugin_version and os. Profiles are sent through
api-eu.mixpanel.com/engage?ip=0&verbose=1 with $ip: "0", so they appear in
Mixpanel's Users view without IP-derived location, names or account details.
Existing events join the profile by installation ID. Profiles are pseudonymous,
not a guarantee of anonymisation under data protection law. A failed profile
update stays pending until the next flush; closing makes one final attempt and
discards any pending update. Profile failures do not prevent event delivery.
Development builds send nothing, and neither does the iOS mirror service. The
choice is made when the server starts: MOBILE_DEV_TELEMETRY=off turns analytics
off along with Sentry; MOBILE_DEV_ANALYTICS=off or DO_NOT_TRACK=1 turns off only
analytics, including profile updates. analytics.flush counts each Mixpanel request
with component=server and outcome=success only when Mixpanel accepted the batch.
The bounded endpoint attribute distinguishes track event batches from engage
profile updates; before installation profiles, the metric counted only event batches.
The panel UI sends nothing to Mixpanel, and its CSP is unchanged.
Since 0.1.164, application metrics in the UI, Node servers and native helpers use
independent 0.5% point sampling before SDK buffering and network transmission.
This reduces metric point volume by 99.5% on average, including automatic Node
runtime measurements and frequent outcome counters. Retained values, units,
surface/context attribution and timing-window boundaries are unchanged. Every
retained point carries telemetry.sample_rate=0.005; user and session identifiers
remain excluded. Sampling is independent of the existing 10% trace sampling.
Gauge and distribution queries describe the retained sample. Counter totals and
timing .samples totals now count only retained observations; multiply sums by
200 to estimate unsampled totals. Do not compare raw totals across this version
boundary. Rare operations may have no retained metric points, so metrics are
for aggregate trends rather than a complete operation history.
Expected host-thread closure, cancellation, unavailable/offline/unauthorized or stopped devices, unavailable foreground apps, unsupported host capabilities and explicit session/concurrency limits do not create error events. Unexpected timeouts, malformed responses, implementation errors and native crashes remain reportable. Handled JavaScript failures are sampled at 5%, deduplicated by scrubbed signature for one hour and capped at 20 reports per SDK runtime per hour. New unhandled JavaScript failures bypass the handled-error sample and cap; their repeated signatures are still deduplicated. The signature table is bounded at 256 entries per hour. Native crash/error capture remains unsampled.
These client controls leave headroom for growth but cannot enforce a shared organization billing quota. Older installed releases and other projects retain their own reporting policies. All existing privacy, environment, anonymous error identity, opt-out, hidden-panel collection and timer/observer cleanup rules remain in effect.
Since 0.1.159, remembered physical iOS devices without a reported transport are
successful discovery results. Discovery failures use ios.devices.discovery
handled-error reporting with the existing scrubbing and outcome metrics. Repeated
failures report once per continuous category episode; a successful discovery resets
the episode. Diagnostics identify schema fields without including device values.
Discovery sampling exclusions, UI timings and surface attribution retain their
existing boundaries. No new collector or native telemetry is added.
Since 0.1.170, the server waits Baguette's standard 10 seconds for the simulator list
instead of 2, because CoreSimulator can take seconds to answer while a device boots.
Cannot reach Baguette at [url]. The operation was aborted due to timeout errors now
mean an unresponsive backend rather than a slow one. A failed list from the server's
own running Baguette reports that failure; earlier releases probed the port and
reported it as Port N already answers HTTP but has no valid Baguette device list.
Baguette start failures report once per continuous failure episode, from the first
operation that captures one, whichever tool or operation triggered the start. Callers
that only log the failure or were cancelled leave the report for a later capture. Later
captures with the same scrubbed message count as server.error.repeated under the
caller's operation, and a successful start resets the episode. Ports, PIDs and timestamps do not start a new episode. Episode keys and
signatures stay local. No new metric, attribute or native telemetry is added.
Since 0.1.158, opening device intent is applied before screen connections start.
Existing MCP operation traces, ui.video.first_frame, rendering/input timings,
and discovery/error measurements remain on the active path with their existing
boundaries and units. Layout and device context follow the selected target; target
arguments and device IDs are not added to telemetry. Startup waits for the host's
opening input or result, and teardown prevents deferred device startup.
Since 0.1.147, server processes select the bundled Undici 8.12.1 HTTP dispatcher
before telemetry initialization and HTTP requests. This avoids the uncaught macOS
setTypeOfService EINVAL exception in Codex's Node 24.19.0 built-in dispatcher.
Node's existing fetch and Web API globals remain in use. Sentry's outgoing HTTP
instrumentation, sampled MCP traces, error capture, scrubbing, environments and
opt-out retain their existing boundaries. Process shutdown flushes telemetry
before destroying the owned dispatcher and cancelling remaining HTTP requests.
No socket monkey patch or process-level exception suppression is added.
Since 0.1.143, ui.memory.heap_used, ui.memory.heap_total and
ui.memory.heap_limit report Chromium's performance.memory JavaScript heap
values in bytes. They sample at UI telemetry startup and on the existing
30-second collection timer while the panel is visible, using the active surface,
view, layout and device context in both development and release environments.
Recording and comparison cards initialize their surface before startup collection.
ui.memory.supported reports 1 when that API is available and 0 otherwise;
unavailable APIs emit no heap values, and negative or non-finite values are
discarded. Hidden panels and telemetry opt-out perform no memory reads. Teardown
clears the existing collection timer. No new timer, Replay, profiling, DOM
recording or native instrumentation is added.
These are non-standard JavaScript heap estimates, not total renderer RSS or GPU, video or image memory. Chromium can share heaps across frames or omit separate worker heaps, so surface attributes identify the sampling context rather than exclusive ownership of the measured memory. Samples uploaded before a renderer crash can show preceding heap growth; an abrupt crash may lose the final buffered samples and is not itself reported by this collection.
App Flow uses the app-flow UI surface. ui.app_flow.start measures the start request, ui.app_flow.start_to_progress ends on the first progress event, and ui.app_flow.graph_process measures local graph layout/derivation. Fixed complete/error counters record terminal outcomes. app_flow.decision_wait.duration measures time parked for the active Codex agent, with a fixed outcome; this time is excluded from the engine's exploration budget. Deterministic Fast additionally records app_flow.runtime.connect with a fixed ready/recovered/unavailable outcome (a run that adopts an already-launched app probes its Metro port once before the sweep and records that check on this same series; recovered means the dev server had to be restarted first), app_flow.runtime.command for the navigate, readiness, nav-state and links boundaries, and app_flow.runtime.state counts for its persistent CDP connection lifecycle. nav-state is a new operation on the existing command series rather than a new name, so the cost of reading navigator state over the persistent connection stays comparable with the CLI read it replaces. Fast also records app_flow.runtime.settle (the readiness poll loop's duration, with a fixed stop reason of settled/stable-not-quiet/timeout/budget/no-answer), app_flow.runtime.verify (the arrival check's duration, with a fixed runtime/judge path and the verdict), and app_flow.runtime.navigate counts with a fixed exact/nested/refused outcome. These are one measurement per operation: the settle loop's individual polls, which run every 40ms, are deliberately not metered. The per-run Fast log file (<project>/runs/fast-*.jsonl) is local diagnostic output only and never feeds telemetry. These measurements describe plugin runtime work, not device rendering or app performance. While a sweep runs, the engine republishes the graph document on a bounded interval and the panel re-reads it on a similar one so captures appear without ending the run; status, decision, and result polling are excluded from MCP trace sampling. Prompts, responses, screenshots, source hashes, runtime fingerprints, project paths, run/request IDs, graph content, device identifiers, route names, params, and token data are never attached to these measurements. UI timing windows flush on surface changes and disposal; provider timers are cleared on submit, cancellation, suspension, and server teardown.
The default screen sweep is now the model-free adaptive pipeline: runtime navigation first, then a deep-link fallback, then an existing verified replay. It reuses the same app_flow.runtime.* measurement names and boundaries as deterministic Fast so runtime costs remain comparable; the winning strategy stays local graph data and is not added as telemetry metadata. Adaptive never invokes the arrival judge or turns a partial deep-link landing into an interactive last hop: incomplete runtime evidence is recorded as an uncertain runtime verification and left for the explicit AI continuation. Thus the existing app_flow.runtime.verify path split remains comparable while adaptive adds model-free uncertain verdicts to its runtime side. After that pass, ui.app_flow.ai_completion_start counts one explicit press of “Explore N with AI” — now the confirm button inside the screen picker, so it counts a started continuation exactly as before, while the number of screens it was pointed at is not attached. Opening that picker counts once as ui.app_flow.ai_picker_open, a bounded count with only the shared App Flow surface attributes and nothing about which screens it listed; previewing a row reuses the existing ui.app_flow.focus_screen count, since it is the same viewport move the in-canvas jump picker makes. The panel's header help popover counts one open as ui.app_flow.help_open, a bounded count with only the shared App Flow surface attributes and nothing about the project, run or flow. It is a bounded count with only the shared App Flow surface attributes: the unresolved count, screen identities, route names, failure notes and project path are not attached. The continuation reuses captured and settled non-actionable results, and its existing decision-wait and exploration measurements cover only screens still eligible for interactive exploration.
App Flow's UI-state pass opens the UI states a screen's own source proves it can open, photographs each one and rolls the app back. It runs in two places that share one per-screen primitive and therefore one set of series: inside the screen sweep, for each delivered screen, when the panel's per-project "Capture UI states" switch is on (the sweep's start request carries one captureUiStates boolean, default off, and the pass reuses the sweep's own CDP connection, device and capture context), and as the standalone mobile_appflow_explore_ui tool, which opens its own connection to an already-launched app. Folding it into the sweep moved the measurements with it: they now describe the sweep's active path and carry the same surface: 'app-flow' attribution as the rest of the sweep. It records app_flow.runtime.presentation, one millisecond measurement per opened presentation with a closed outcome (captured/failed) and kind (state/control/mount) pair; app_flow.runtime.presentation_pass, one millisecond measurement per screen's pass with a closed outcome (completed/failed/cancelled) — a deliberate change of meaning: it previously covered one whole standalone run, and a sweep with the switch on now emits one per delivered screen, covering that screen's binding collection, listing, open/settle/screenshot/rollback of every state and the final unwind, never the sweep's own work around it; and app_flow.runtime.presentation_unbound, a single bounded count per screen's pass (the live-binding collection runs per screen, because bindings only exist for what is mounted) of the live bindings Metro's source maps could not resolve onto a source site (attribute stage: configure is the unplaced total; no-frames, foreign-frames and symbolicate-failed are emitted beside it only when non-zero and say which stage of the join stopped, as counts of records with no readable bundle frame, frames from another server, and failed Metro lookups; the join also matches a stack's bundle URL by port rather than origin, since the device reaches Metro as 127.0.0.1 while the host names it localhost, and the first symbolication timeout is 15 seconds and the setup command's 20 seconds, deliberate changes to what the join counts as a failure; the run log's uiStates.join carries the same stage counts plus how many records were emitted and how many matches the device attached, and uiStates.failure now names the stage a failed pass stopped in — setup-timeout, setup-failed, list-timeout, list-failed or pass-failed — instead of always pass-failed), counted once per screen's pass rather than once per binding; and app_flow.runtime.presentation_refused, a bounded count per screen's pass and closed-set reason (unbound, not-in-view, disabled, no-owner, ambiguous-owner, no-control, ambiguous-control, not-loaded, unsupported, no-binding, ambiguous-binding, ambiguous-callback, unmet-condition, already-open, owner-mismatch, already-mounted, target, empty, other) of presentations the device refused, with a stage of list or open, so a screen that offers nothing can be told apart from one whose controls could not be matched to their source; presentation_unbound now also counts opener-JSX records (the entry leg) the source join could not place, not only hook bindings, which is a deliberate widening of what it counts; and app_flow.runtime.presentation_open_session, one millisecond measurement per sweep (or run) for scanning the project's static catalog and attaching to the runtime, with a closed outcome (ready/unavailable), so the once-per-project cost is visible apart from the per-screen cost. A failure to capture UI states never fails the sweep; the unexpected ones (a transport failure mid-pass, an unwind that did not reach level 0) go through the server error reporter under the operation app_flow.capture_ui_states, while benign ones (no runtime to attach to, no UI states in the source) are counted as expected outcomes, and a failed unwind additionally stops further UI-state capture for the rest of that sweep. State openers are now gated on their opener JSX being live on the focused screen exactly as controls are, so unbound now means that an opener's JSX was not bound to a live fiber (previously it also covered a state with no binding, which is the new no-binding reason); this is a deliberate change of what the refusal counts mean, and the five new reasons are closed-set. Mount previews now carry the reference's two export guards and a drawn-content check, which add four more closed-set reasons: owner-mismatch (the named export is not the named component), already-mounted (the app already renders that component, so a second cold copy would show none of the live provider state), target (the expected component did not mount) and empty (it mounted but nothing under it draws). The last two come from a new presentation-content command, billed under app_flow.runtime.command like the others, which returns only three numbers and never reads app content. The settle after an open is now bounded at four seconds instead of inheriting the thirty-second route-settle bound: that bound is sized for a deep link resolving a whole route, and a presentation opens over an already-settled screen, so the full thirty seconds was being paid on every screen whose state drew nothing and the blank frame was then photographed anyway. Openers reaching the same destination are listed once, and the run log's uiStates record gains aliased (those duplicates, included in candidates) and listedKinds (listed counts by kind). A control's dismissal is now confirmed by the presented content leaving the committed tree rather than by the controller's shape, which never changed and so made every control close run to its four-second deadline and fail. The local run log (never sent anywhere) gains a per-node uiStates record of counts and closed-set categories (candidates, refused at list and at open by reason, opened, captured, unplaced records, whether the unwind reached level 0 and how a dismissal was confirmed, and whether that screen latched capture off). Its runtime handshake and its four device commands are billed to the existing app_flow.runtime.connect and app_flow.runtime.command series — the commands under new operation values presentation-setup, presentation-configure, presentations, presentation-open and presentation-rollback — so the cost of driving the app stays comparable with the Fast reach path beside it rather than arriving under new names. These three presentation* names are a deliberate re-addition after the removal recorded below, not a revival of the removed series: the pass they describe opens states by calling the app's own setters over an app that is already on a screen, it taps nothing and asks no model anything, and none of the removed app_flow.runtime.state_capture / app_flow.states.* names is reused. Dashboards built on those removed names stay silent. Screen names, node ids, route names, recipe ids, component names, source paths, screenshots and device identifiers are never attached to any of these; the per-variant detail stays in the project's own saved flow document, which never leaves the machine. The panel side of that pass adds one UI count, ui.app_flow.capture_ui_states_start, once per user-started run that has the "Capture UI states" switch on (it replaces the count the removed "Start UI Explore" button made, and carries nothing beyond the surface attributes), and one UI gauge, ui.app_flow.ui_states_rendered: how many captured UI-state rows the rendered graph offers in total, set once per node-set change on the app-flow surface. It is a plain count of rows, so no screen, route, node, recipe or component name, source path or screenshot ever rides on it, and it is separate from the "Captured N of M screens" headline, which counts screens. Like the three presentation* names above it is a new series under a new meaning, not a revival of the removed ui.app_flow.states_rendered / ui.app_flow.state_viewed pair: it measures what the graph renders after a pass, not what a removed runtime pass captured, and dashboards built on the removed names stay silent. The captured states now also have a canvas of their own — screens as parent nodes, their states as children — selected from the panel's view picker, and both canvases carry two jump pickers (by screen, by UI state) that move the viewport onto a chosen item. That canvas adds ui.app_flow.ui_states_graph_process and ui.app_flow.ui_states_graph_render, the same local layout and render boundaries ui.app_flow.graph_process and ui.app_flow.graph_render measure for the flow graph, and one gauge, ui.app_flow.ui_state_nodes, how many state cards it draws, set once per node-set change. The pickers add two fixed counts, ui.app_flow.focus_screen and ui.app_flow.focus_ui_state, one per jump. All five are plain numbers on the app-flow surface: which screen or state was chosen, its route, node, recipe or component name, its source path and its screenshot are never attached, so the counts say the pickers are used without saying what they were pointed at.
App Flow's manual path recorder — the panel's "Record path" button — now reports three bounded series on the same app-flow surface and device_platform attribution as the sweep beside it. app_flow.manual.start is one millisecond measurement per started recording, from the request to the first live wireframe, with a closed device attribute of launched (the recorder adopted the app the user had already launched, so it paid no native build, simulator boot or Metro cold start), warm (it reused a device a previous recording or replay on this project parked) or booted (it opened its own). That attribute is the point of the series: it says whether reuse is actually happening and what a start costs on each path. app_flow.manual.act is one measurement per recorded interaction, covering the device call and the route settle behind it, with a closed action (tap/fill/scroll) and outcome (ok/failed) pair — a failed interaction is a normal state of this surface, not an exception, and it is counted here rather than reported. app_flow.manual.stop is one count per saved recording with a closed outcome of verified (the recording published and replayed) or fallback (it was saved as a literal command list), plus the same device attribute. All three are one measurement per operation, never one per snapshot poll: the recorder's two-second wireframe refresh is deliberately not metered. Screen names, node ids, routes, slugs, element labels, typed text, recorded commands, screenshots, project paths and device identifiers are never attached to any of them, so these say how long a recording took and how it ended without saying what was recorded.
The App Flow runtime state-variant pass has been removed from the product, and with it the app_flow.runtime.state_capture, app_flow.states.node and app_flow.states.phase server series and the ui.app_flow.states_rendered and ui.app_flow.state_viewed UI measurements introduced in 0.1.141. This is a deliberate change of meaning rather than a rename: the pass they described no longer runs, no replacement series stands in for them, and dashboards or alerts built on those five names will go permanently silent from this release. The states App Flow progress phase and the stateCaptureMode start option are gone for the same reason. Every other App Flow series above — app_flow.runtime.{connect,command,settle,verify,navigate,state}, app_flow.decision_wait.duration and the ui.app_flow.* start/progress/graph measurements — keeps its existing name, unit, attributes and boundaries, so sweep coverage stays comparable across this release.
Since 0.1.141, the path attribute on app_flow.runtime.verify covers a wider set of arrivals on the runtime side. Deterministic Fast now accepts the runtime's own readiness snapshot whenever that snapshot is complete — the target screen found and focused, its parameters matching, content present, and the dispatched navigator path focused — regardless of whether the readiness poll ended on settled or gave up on a timeout. Screens that never go quiet (live feeds) previously fell through to the vision judge and were counted as judge; they are now counted as runtime. The series name, unit (milliseconds), attribute names and verdict values are unchanged, so durations stay comparable across releases while the runtime/judge split shifts towards runtime at this release. The judge path remains for incomplete evidence. No new data is collected.
Since 0.1.172, an owned Android backend starts only after the device reports sys.boot_completed=1, because adb lists a device seconds before Android starts the system services scrcpy needs. android.backend.boot_wait.samples and android.backend.boot_wait.duration measure that wait in milliseconds, only when the first check found the device still booting, with a fixed outcome of booted or timeout (after 120 s). They use the simulator surface and Android device platform, send no serials, device names or adb output, and honor telemetry opt-out. The wait ends before process spawn, so android.backend.startup.duration keeps excluding device boot.
Android panel stream-opening calls allow 180 s for the boot wait, backend startup and request overhead. Existing UI connection and first-frame timings continue to measure the whole connection attempt.
Since 0.1.140, android.emulator.adb_reconnects counts adb transport reconnects for emulators that stay unauthorized, with a fixed trigger (boot while waiting for an AVD, selection for an already running emulator). It uses the simulator surface and Android emulator context and sends no serials, AVD names or adb output. Existing Android startup diagnostics and MCP tool errors cover the boot outcome.
Since 0.1.139, ios.accessibility_bridge.restarts counts restarts of the simulator's CoreSimulatorBridge after a describe-UI read reported no accessibility data, with a fixed outcome (recovered, unavailable or failed). Failed restarts also report a handled simulator.accessibility_bridge error. The existing inspection.tool errors, sampled MCP traces and ui.annotations.inspection timings cover the retried read. No device identifiers, accessibility content or command output are sent.
Since 0.1.134, physical iOS capture runs in the shared ios-mirror-service Node process. Existing native packet-processing, input acknowledgement, connection, resource, and crash instrumentation stays attached to the active capture. Native resource measurements now overlap that service's Node process rather than each chat's MCP process. The service uses centralized server initialization, its packaged development/release environment, and server-owned anonymous installation/process-session identity. UI decode/render timings and sampled MCP operations retain their existing boundaries. Subscriber keyframe requests no longer invalidate the shared native queue or release another panel’s touch. The native packet-processing and recovery measurements remain on this active path; the rebuilt addon retains matching debug symbols.
ios.mirror.shared.captures and ios.mirror.shared.subscribers report active counts. ios.mirror.shared.queue_dropped counts frames discarded by subscriber queue overflow. Counts aggregate in 30-second windows and flush on service shutdown, using the simulator surface and physical iOS context. No per-frame events, device identifiers, subscription IDs, payloads, or paths are sent. The service clears its collection timer on shutdown and honors telemetry opt-out.
Since 0.1.170, a physical iOS bezel that can't be rendered no longer fails mobile_ios_mirror_session. Mirroring opens without the frame, and an unexpected render failure reports a handled ios-mirror.bezel error. The server keeps a missing frame for five minutes, so each hardware model reports at most once in that window instead of on every panel reconnect. A device type that Xcode doesn't have is expected: it counts as an unsupported_platform outcome and sends no event. Earlier releases reported these failures as mobile_ios_mirror_session errors, so compare ios-mirror.bezel with those events when reading trends. No metrics are added. The existing server.error.outcome count carries the new operation value.
Since 0.1.132, plugin.update.operations counts release checks and installations
by fixed operation and outcome, and plugin.update.duration measures their
duration in milliseconds. Cache hits emit no extra measurement. These measure
plugin work and do not attach device context, version strings, GitHub responses,
CLI output, paths, or profile details. Offline checks count as unavailable;
installation failures report a fixed error message. The existing MCP wrapper
preserves sampled UI/server tracing and action outcomes on the active workspace
surface. UI counters record successful updates and dismissed banners without
release details. All collection honors telemetry opt-out.
Since 0.1.146, update commands run from the stable Codex profile directory and verify already-installed updates even when the marketplace reports no changed roots. Existing installation duration, outcome, handled-error, and MCP tracing coverage remains on this path with the same boundaries and units. Execution and invalid-response errors use fixed messages without implying a network failure; raw CLI errors and output are not sent to telemetry.
Since 0.1.167, update checks measure the Codex store catalog lookup instead of
GitHub HTTP requests. The existing operation count and duration names and units
remain unchanged. The install operation is replaced by migrate, covering
verification and GitHub cleanup; its successful outcome is migrated. Checks can
report migration while the GitHub installation remains. UI events
ui.plugin_update.store_opened and ui.plugin_update.migrated distinguish opening
the store from completing cleanup; the old installed event is removed. Fixed
migration errors retain handled-error coverage. A missing or disabled store
installation is an expected user action condition and does not report an error.
No CLI output, store metadata,
versions, paths, or user data are included. Disposal aborts CLI requests and clears
the UI timer and visibility listener.
Since 0.1.170, the fixed plugin.update.migrate error carries a plugin_update_step
tag (catalog, remove-plugin, remove-marketplace, verify or save) and a
plugin_update_failure tag (codex-not-found, command-failed, invalid-response,
store-unavailable, foreign-marketplace, not-removed, not-verified,
cache-write or unknown). The message, metrics and boundaries are unchanged, and
no CLI output or store response is included.
Since 0.1.171, the same update-check measurements cover the anonymous HTTP
store lookup and local CLI installation checks. Failed checks add a bounded
failure attribute using the existing update failure categories. Metric names,
units, cache-hit exclusions, opt-out and migration-step error coverage are
preserved. No endpoint response, authentication data or raw error is recorded.
Closing the updater aborts its HTTP and CLI requests.
Since 0.1.178, those update and migration measurements also cover GitHub repository
identity verification for the legacy marketplace. The existing names, units,
cache-hit exclusions and migration-step tags remain unchanged. API failures use
the bounded repository-unavailable failure category; malformed metadata uses
invalid-response. Repository names, URLs, IDs and response bodies are never
added to telemetry. Store installations without the legacy marketplace do not
perform this verification.
Since 0.1.129, discovery command failures retain bounded discovery_command, discovery_cause,
discovery_termination, and optional discovery_signal tags. Failed exception
contexts contain only numeric elapsed_ms, deadline_ms, and an optional exit
status from 0 to 255. Command identifiers are fixed product enums. Foreground
helpers emit a versioned, strictly validated error-code record on stderr;
connection, service opening, query, response, and cleanup failures stay distinct.
Helper-owned timeouts count as timeouts even when the helper exits with status 1.
Parent deadlines, explicit cancellation, native signals, missing executables, and
output limits retain separate classifications. Known simctl/ADB lifecycle text
is classified locally into fixed causes; text never enters these diagnostics.
The existing discovery stage/failure tags, exception-text and Node system-error scrubbing, anonymous error attribution, telemetry opt-out, UI discovery metrics, and trace exclusions remain. Server episode signatures and error fingerprints also distinguish command/cause; numeric timing and exit status do not become metric attributes, episode keys, or grouping dimensions. This diagnostic change preserves command deadlines, retry intervals, and discovery concurrency. Native Baguette and iOS FPS helpers are rebuilt with matching debug symbols; their shared Sentry initialization and aggregate measurements remain unchanged.
Since 0.1.128, MCP resource failures retain one original handler exception. Resource
callbacks normalize thrown values and classify aborted reads before the Sentry
SDK observes them. A request-scoped reporting flag excludes the generated
JSON-RPC exception only after that same request's failure has been accounted
for. Unowned protocol failures and transport failures remain reportable. Guarded
tools retain their original server capture and isError response semantics.
Expected outcomes are classified at their source with bounded typed reasons:
session expiry/explicit closure, unavailable or unauthorized devices, explicit
unsupported platform checks, and invalid user/resource input. The shared
beforeSend also applies this classification to automatic SDK captures. Existing
AbortError exclusions remain. Backend response validation, startup failures,
missing bundled dependencies, active-operation timeouts, and collector crashes
are not suppressed by these classifications. UI stream opening now carries the
reconnect abort signal; cancellation without an aborted operation and host
“thread not found” failures remain reportable.
Cancelled stream requests close sessions that finish opening after cancellation
or before a discarded response. Unexpected cleanup failures retain their own
stream.cancel_cleanup capture. Response delivery releases cancellation ownership;
failed response delivery closes its undelivered session. CPU, Display FPS and log session
starts follow the same ownership and report their cleanup failures as stream.cancel_cleanup;
their tool failures after request cancellation count as cancelled. Physical iOS mirror startup now also captures
unexpected server errors before returning the existing visible failure.
Server discovery failures no longer create a second generic UI exception. The
UI retains its visible error, ui.device_apps.discovery_failure counts, and
ui.device_apps.discovery timing, and reports its own transport/response defects
with bounded classification and a fixed message. Server discovery and UI-only
discovery failures report once per continuous failure signature. Each local
failure table holds at most 64 entries and starts a new episode after success,
a signature change, or five minutes without a failure. UI selection/visibility
changes also reset their discovery episode. Stream-opening transport retries
share an episode only within the same reconnect abort signal. Device/session
keys and signature strings stay local and never enter Sentry payloads.
server.error.outcome counts expected and unexpected outcomes; its operation,
outcome and optional discovery attributes are bounded product classifications.
server.error.repeated, ui.device_apps.discovery_repeated, and
ui.stream.open_repeated count failures omitted from exception reporting.
ui.operation.expected.<reason> counts UI lifecycle outcomes. These counters use
the existing SDK/UI aggregate collection. ui.action.result now also counts
rejected calls and explicit cancellation, using the request's starting context.
Error fingerprints extend default stack grouping with operation, bounded error
category, resource kind, and available discovery stage/failure. Anonymous IDs
are excluded from grouping and metrics. UI SDK consecutive-event deduplication
is replaced by explicit episode ownership so recovery and separate operations
can report the same exception shape again. Existing scrubbing, installation
attribution, opt-out, release/environment metadata, trace propagation, frequent
trace exclusions, and performance measurement boundaries are unchanged. No
native telemetry or symbols change in this reporting work.
Since 0.1.113, failed screenshot attachments display a panel notice instead of
failing silently. Existing screenshot.attach error capture retains the original
exception and operation, and screenshot-capture measurements keep their current
boundaries. Image data and host error details are not added to telemetry. This
changes failure feedback; it does not resolve the host image-validator overflow.
Since 0.1.112, discovery errors carry bounded discovery_stage and
discovery_failure tags alongside device platform and kind. Stages distinguish
device validation, running-app enumeration, foreground lookup, generic discovery,
UI transport, and response validation. Failures distinguish missing executables,
timeouts, command failures, invalid responses, cancellation, and unknown errors.
The server annotates the original error without copying its command or output;
strict enum metadata carries the classification to the UI. Existing exception
scrubbing, cancellation exclusions, discovery timing windows, failure counts,
and frequent-tool trace exclusions remain. No app lists, device IDs, command
arguments, output, or error payloads are added to telemetry. Historical command
failures are not considered resolved by this diagnostic change.
Since 0.1.111, physical iOS log-session shutdown cancels pending device discovery and its subprocess. Existing MCP operation timing and bounded iOS parsing measurements keep their boundaries; cancelled discovery produces no reconnect error and starts no reader. The UI cleanup deadline remains five seconds.
Since 0.1.110, JavaScript error scrubbing removes the automatic Node system-error context. This prevents child-process command arguments, device identifiers, local paths, and command output from bypassing exception-text scrubbing. Error messages, source locations, anonymous attribution, and existing performance measurements retain their collection boundaries.
Version 0.1.108 corrects the compatibility manifest's working directory so the launcher and existing server telemetry can start. It changes no telemetry boundaries or collection. The Codex installation smoke check verifies the resolved launch configuration and telemetry opt-out in the sidebar resource.
Since 0.1.121, MCP discovery and runtime directly use Codex's bundled Node from its workspace dependency cache. The existing centralized Sentry initialization, anonymous attribution, build environment, opt-out, runtime metrics, and MCP traces remain on the same server path, with telemetry opt-out explicitly forwarded by the MCP manifest. Launcher failures occur before the server SDK starts and are available in desktop startup logs. The Mobile Dev and setup skills inspect startup failures when tools are missing; those diagnostics stay local and do not send host logs, paths, or tool inventories to Sentry.
Since 0.1.101, logs.ios.parse measures Node-side iOS record parsing, default system-noise filtering, and conversion in milliseconds before buffering. Bounded 30-second windows report sample count, mean, P95, and maximum; shutdown flushes the remaining window and stops its timer. Measurements use the logs surface and iOS simulator/physical kind, with no log content, subsystem names, sender paths, device IDs, or filter text. Existing UI query/filter timings, Node runtime coverage, and physical helper native.logs.process timings retain their boundaries. The rebuilt physical helper emits sender image paths locally for framework filtering and retains matching native symbols. The expanded subsystem families and dot-separated child matching in 0.1.114 remain inside this same measurement boundary; metric names, units, attribution, and cleanup are unchanged.
Since 0.1.94, shared selected-device discovery retains the frequent-tool trace
exclusion and handled server-error coverage, now under device_apps.discover.
ui.device_apps.discovery measures the discovery round trip in milliseconds with
bounded aggregate windows; ui.device_apps.discovery_failure counts current-query
failures. Queries cancelled by selection or visibility changes do not report
measurements. Results crossing a surface or telemetry-context change are excluded
so their duration is not attributed to the next surface or device. No bundle IDs,
PIDs, device IDs, app lists, or query output are sent. Existing CPU batch-processing
coverage and native Baguette crash/resource telemetry are preserved.
Since 0.1.147, app control tools (mobile_list_apps, mobile_launch_app,
mobile_stop_app, mobile_install_app, mobile_open_url, mobile_app_icons,
mobile_app_links, mobile_app_permissions, mobile_set_app_permission, and
mobile_send_push) use the existing sampled MCP traces. Unexpected simctl, adb,
aapt2, or plutil failures are reported under app_control.<action> with a fixed
message, because command output can contain bundle IDs, URLs, device serials, and
local paths. Expected outcomes such as a missing app, an unhandled URL, an
unrequested permission, or a stopped device count only through
server.error.outcome. Since 0.1.170 these reports and outcome counts also carry
the device command tags described below, and a simulator that is shutting down
counts as a stopped device. Extracted app icons and Android labels stay in the server's
memory cache and are returned only to the panel.
The device popover's App tab records ui.app_tools.list, .icons, .launch,
.stop, .open_url, .permission, .push, and .language round trips in
milliseconds with bounded aggregate windows, and counts ui.app_tools.failure. Since 0.1.161 app icons come from a cache shared by
every panel in the view, so an icon requested by one panel is not fetched again by
another; each caller keeps its own timing name (ui.app_tools.icons, ui.storage.icons).
Results that finish after a surface or device change are not recorded. Recent URLs
and the last picked app stay in the panel's local storage and are never sent.
The Storage tool (mobile_app_storage, mobile_app_storage_table, mobile_app_storage_file, mobile_clear_app_storage) uses the storage
surface. The server records app_storage.operation.duration in milliseconds and
app_storage.operation.samples per operation (read, clear, reset, table, file) with the device
platform and a success or failure outcome. The duration covers listing the data
directory, reading and decoding the requested stores, filtering results before
returning them, and for clears stopping the app first. Scoped reads skip decoding
unselected stores; duration therefore depends on the requested scope. Unexpected failures report under app_storage.<operation> with a fixed
message; a release Android build, a missing app, or a stopped device counts only
through server.error.outcome. The panel records ui.storage.list_apps, .icons, .read, .table, .file,
.clear, .reset, and .launch round trips, ui.storage.process for validating
a snapshot and computing the Changes feed, gauges ui.storage.stores and ui.storage.entries,
and counts ui.storage.failure. Bundle IDs, store names, paths, keys, values, and
file names are never sent to Sentry. Filtered table names and cell values from
mobile_app_storage_table, and filtered file contents from mobile_app_storage_file,
are returned to the host application; this is separate from telemetry. See
storage result filtering. Since 0.1.161 the Changes tab reads storage again every
5 seconds while it is open and the page is visible; each read is one ui.storage.read
sample, and the interval stops when the tab, panel, or page is hidden. The panel
lists installed apps each time it opens, when the selected device boots or reconnects,
and on Refresh; each listing is one ui.storage.list_apps sample, and a listing
already in flight is reused rather than repeated.
Since 0.1.152, mobile_app_language and mobile_set_app_language use the same
app control coverage under app_control.language and app_control.set_language.
Language tags are not sent. The device settings tools report unexpected Baguette or
serve-emu failures under device_settings.read or device_settings.<setting> with a
fixed message. Since 0.1.170 they carry the device command tags described below,
and a failure on a device that stopped or went away during the request counts as
device_unavailable through server.error.outcome instead of a report. The check
reads the device list without starting a backend, giving Baguette two seconds; when
Baguette or adb cannot list devices, the failure is reported as before. Android throttling runs through a local
proxy on the Mac, so its adb failures report under device_settings.network;
throttling a device that already uses its own proxy counts only through
server.error.outcome. When the plugin first
starts an Android backend, it clears a throttle left by a plugin process that exited;
unexpected adb failures there report under device_settings.network_recovery, and a
device that went away counts only through server.error.outcome. Proxy
addresses and traffic are not sent. Since 0.1.155, expected device setting and app
control outcomes reach server.error.outcome as documented; earlier releases skipped
them. The Device tab
records ui.device_settings.change round trips in milliseconds and counts
ui.device_settings.failure, with the same surface and device-change exclusions as
the App tab. Setting values, throttle presets, and device IDs are not sent.
Device setting and app control reports keep their fixed messages, so their Sentry
issues keep grouping as before. Since 0.1.170 they add these device command tags,
which their server.error.outcome counts also carry:
device_platform:iosorandroid, from the tool's target.device_command: the program and subcommand or backend route that failed, such assimctl_launch,simctl_privacy,adb_shell_am,adb_install,plutil,baguette_interface,baguette_start,serve_emu_night_mode, orserve_emu_start. A Baguette start that fails on its device list or its own process namesbaguette_simulatorsorbaguette_serveinstead ofbaguette_start. It is absent when the failure did not come from a named command, such as a reply that failed validation. Labels come from code; anything else is sent asother.device_command_failure:exit,signal,deadline,cancelled,output_limit,missing_executable,system_error,connection_failed,http_status,rejected,invalid_response,unexpected_output, orunknown. The value comes from error codes, HTTP statuses, and error types. Messages and output are never read.device_command_status: the exit status (0 to 255) forexit, or the HTTP status forhttp_status.device_command_signal: the signal name forsignal, orother.
Arguments, output, replies, bundle IDs, URLs, serials, and paths are not sent.
serve-emu startup failures under device_settings.* keep their android_startup_*
tags.
Saved chart cards use the recording surface and view. Existing readiness,
interaction and frame-pacing coverage is preserved. ui.recording.process and
ui.recording.derive measure result validation and chart/summary processing;
ui.recording.change_density measures highlight calculation on sample updates
and is cached across range selection changes;
ui.recording.reveal measures completed entrance drawing in milliseconds,
using the existing bounded timing windows. Since 0.1.84, the line traces its
measured curve with the fill following it. Since 0.1.85, the entrance pause is
550 ms and change highlights fade in after drawing finishes. The intentional
pause and highlight fade are excluded from the reveal timing;
ui.recording.message_ack ends when the host acknowledges a button's message. Since 0.1.98, ui.recording.context_attach measures the preceding context attachment round trip in milliseconds, including failed writes. Both use the active recording surface. Recording IDs, titles, ranges and context text remain local. Handled action errors use a fixed telemetry message.
Since 0.1.168, the tools that show a recording send its ID, summary and, when it fits,
a preview (every sample, without per-thread CPU or Android frame timelines) instead of
its full samples, because hosts cap tool results. The card draws the preview at once and,
where the host lets cards call tools, reads the full recording with
mobile_read_performance_recording. Readiness ends at the first chart drawn, preview or
full. ui.recording.preview counts previews shown, and ui.recording.load measures the
full read in milliseconds. ui.recording.process and the ui.recording.samples,
fps_samples and display_frames gauges describe full recordings only, so they stay
comparable with releases that sent full recordings; previews are only counted. A host
returning the recording without its structured samples is a handled error with a fixed
message; a server's own refusal, such as a deleted recording, is shown without a report.
Either way a preview on screen stays. Bounded event
counts record range selections and Ask/Open actions. storage.bytes with
kind: recordings measures local saved-file storage. Recording polling is excluded
from trace sampling, and hidden cards stop polling. None of these measurements
contains device CPU/memory values, recording IDs, titles or selected intervals.
Comparison cards use the comparison surface and view, preserving shared
readiness, interaction, browser frame pacing and teardown coverage. Bounded
ui.comparison.process measures result validation; since 0.1.168, comparisons use
previews as single recordings do when they fit: ui.comparison.preview counts them and
ui.comparison.load measures reading every compared recording. As for recordings,
ui.comparison.process and the comparison size gauges describe full recordings only. ui.comparison.derive covers
overlay series, whole-run summaries and, since the card's redesign, finding each
run's sharp changes; ui.comparison.summary covers shared
selection summaries. ui.comparison.commit measures the card render through its
DOM commit in milliseconds; it does not measure paint or device rendering.
ui.comparison.message_ack ends at host acknowledgement. On hosts with composer
pills, Ask puts the comparison's reference in a pill and sends a one-line message,
as recording actions do; ui.comparison.context_attach measures that attachment
round trip in milliseconds, including failed writes. Numeric gauges count
runs, CPU/memory samples, FPS samples, retained display frames and overlay rows.
Counters record range selection, run toggles and Ask actions;
ui.comparison.change_selected counts choosing a listed sharp change, which also
counts as a range selection, and ui.comparison.memory_scale_changed counts
switching the memory charts between absolute values and change from each run's
first reading. No recording IDs,
titles, selections or device measurements enter this telemetry. The comparison
MCP operation retains the existing sampled server trace and handled-error path.
ui.annotations.tree_processing measures local element processing in milliseconds, including React Native nodes when available. Since 0.1.66, normal inspection validates flat records here; server-side tree flattening falls within ui.annotations.inspection, which measures the MCP inspection round trip, including native accessibility and optional Metro work. ui.annotations.runtime_available counts snapshots with runtime elements. ui.annotations.inspection_fallback counts native-tool retries. ui.annotations.inspection_truncated counts snapshots that reach the collector's work or measurement limits. Inspection timing includes failed calls and retries. It uses the current simulator surface and the same bounded timing windows as other UI measurements. Tree contents and selected regions are not sent to Sentry.
Since 0.1.69, inspection timing also includes the bounded Metro source-map lookup. ui.annotations.source_available counts snapshots with at least one resolved source location; ui.annotations.message_build measures text construction for Send to chat. Source-map transport failures use the existing server error handler with a fixed message. Source paths, component names, creation stacks, note text and images are never sent to Sentry.
ui.annotations.selection_context measures the bounded hierarchy and instance lookup for a selection. ui.annotations.context_build measures annotation text construction for composer attachments. Both use milliseconds and the active simulator surface. These timings contain no selected nodes, React keys, labels, bounds or source paths.
Since 0.1.92, Android inspection timing also includes the full-resolution display-size read and bounds scaling. Existing inspection, fallback and tree-processing coverage stays on the active selection path. Display sizes and element bounds remain local.
Since 0.1.93, ui.video.paint and the platform frame counters also cover frames drawn to the local buffer while Select freezes the visible screen. These remain bounded plugin processing measurements, not device FPS. Recovery uses the same surface attribution and timing units; screenshots and element details remain local.
ui.annotations.send measures the host send round trip, including composer retries. Outcome counters distinguish success, a missing composer, timeout and other failures. Unexpected send failures use a fixed error message. No message content goes to Sentry. A timeout keeps notes for a manual retry; it never triggers an automatic resend, since delivery may have succeeded without acknowledgement.
The standard-host attachment bar reuses these annotation measurements. On standard hosts,
the measured operation includes publishing selection context before preparing the
chat draft. ui.annotations.send_success means the host accepted the request;
it does not confirm user submission or a model response. Notes remain until the
user clears them. Message/context construction timings, surface attribution, and
content scrubbing are preserved; no note text or selection evidence enters telemetry.
The Testing panel's recorder measures ui.testing.tree_read, the read that resolves a tap into a
selector, and counts ui.testing.record_start/record_stop, ui.testing.step_tap,
ui.testing.step_assert, ui.testing.step_unresolved, ui.testing.hover_walk,
ui.testing.menu_open. Editing a recorded step counts ui.testing.step_duplicate,
ui.testing.step_reorder, and ui.testing.step_recommand_action/ui.testing.step_recommand_assert
when a step is pointed at another command — the same action/assertion split the recording counters
use, so a flow's shape stays readable whether a step was recorded or edited into place. They are
counts of an edit, carrying no selector, element name, command text or position. Pressing Record
on a flow that already has steps counts ui.testing.record_resume or ui.testing.record_new
alongside ui.testing.record_start, and only where there was a question to answer — it says
whether that choice is carrying its weight, and carries nothing about the flow itself.
Recording an agentic step counts ui.testing.step_agent_act, ui.testing.step_agent_assert or
ui.testing.step_agent_wait,
kept apart from ui.testing.step_tap/step_assert because the two answer different questions:
whether the recorder can pin a step, and whether a user reached for the agent instead. They are
counts only — the instruction the user wrote is free text about their own app, so it is never
sent, and neither is the vision mode chosen for an agent.assert. ui.testing.agent_params
gauges how many params an act step was recorded with, which is what says whether the editor is
reached for at all; it is a count of rows, never a key, a value or the text they were typed into.
A recorded swipe counts ui.testing.step_action like every other non-tap pinned command, so the
action/assertion split stays the boundary it was; the direction and the gesture's coordinates are
not sent.
ui.testing.step_assert now covers every assertion the menu can record, not only toBeVisible
and toHaveText; it is the same boundary — a step recorded that reads the screen rather than
acting on it — so counts stay comparable across the release. Selectors, element names and the
recorded source are not sent; these are counts only. The timing's
meaning changed when the recorder moved to the test runner's own element tree: it now measures an
agent-device snapshot of the device projected by the project's @e2e-dev/mobile (around a tenth of
a second against a booted iPhone 17 Pro), where it previously measured a Baguette describe-ui
loopback of tens of milliseconds. It is the same boundary — the wait a tap pays before its step is
named — so the measurement stays comparable in purpose, but not in magnitude; read a step across
that release as a change of read path, not a regression. The recorder caches the tree for 1.5 s and
invalidates it on every input, so a warm hover or wheel walk is answered locally and not measured.
ui.testing.tree_chrome_only is gone with the Baguette path, since the runner's snapshot is rooted
at the application and cannot report only the simulator's chrome; ui.testing.tree_empty replaces
it and counts a tree with no elements at all. Handled failures of the read and of releasing the
device go through captureServerError as testing.tool and testing.release. No element names,
labels, placeholders, testIDs, roles, bounds, bundle ids, project paths, device identifiers or
emitted test source are attached to any of these.
An agent recording — the user's own coding agent writing the flow through
mobile_testing_agent_*, see docs/agent-recording.md — is measured on both
sides of the one boundary it crosses. In the server, testing.agent.screen.duration times the
element read an agent asks for before each step, testing.agent.screen.samples counts those reads
by outcome, and testing.agent.screen.elements gauges how big the screen it answered with was.
That read is the only thing in an agent recording that costs anything — a flow is ten to twenty of
them — and the element count is a size, never content. In the panel,
ui.testing.agent_session_start counts a session the panel adopted,
ui.testing.agent_step_adopted counts each step as it arrives, ui.testing.agent_session_abort
counts the user pressing Stop on the banner, and ui.testing.agent_adopt times the adopt that
makes a step appear. The goal sentence, the test's title, the instruction of an agent step and
every element name the read answered with are the user's own content about their own app and are
not sent; these are counts, durations and sizes only. Handled failures of the agent tools go
through captureServerError as testing.agent, beside testing.tool and testing.release.
Running a recorded test measures ui.testing.run, which brackets the panel's whole call — the
runner spawned, the project resolved and the report read — and counts ui.testing.run_passed or
ui.testing.run_failed from the verdict. It is deliberately not the duration shown beside that
verdict: that one is the runner's own number from the report, and the two answer different
questions. Play until here, the run a line of the preview offers, counts ui.testing.run_until
as well, so a flow tried a step at a time is not read as a flow run end to end; it is counted
beside the verdict, not instead of it. The test's title, its path, the project path, the steps and
the runner's output are the user's own content and are not sent.
Unsaved recordings — the flows the panel keeps so one survives the panel document being rebuilt —
measure ui.testing.draft_save, the autosave write, and count ui.testing.draft_restore when one
is reopened into the step list and ui.testing.draft_delete when the user throws one away. The
measurement brackets the panel's call and the list refresh that follows it, so it says what the
keep costs the user between one edit and the next; the keep the panel makes as it is torn down is
not measured, because the document it would be attributed to is going away. The title, the file name, the project path, the
steps and everything they name are the user's own content and are not sent; these are counts
and a duration. An autosave that fails is silent on screen and goes through captureUiError as
testing.draft_save; the server's own keep of a finished agent recording goes through
captureServerError as testing.agent.draft. Deleting one of the project's own stored tests
counts ui.testing.test_delete, beside ui.testing.draft_delete: they are the two halves of the
panel's list and answer different questions — a recording thrown away before it was ever saved, and
a test removed from the repository. The file name, its path and the project path are not sent, and
listing the stored tests is not measured: it is a folder read the panel does on open, not a wait
the user sits through.
Selecting a stored test counts ui.testing.test_preview and measures that same name from the
read request through its response. A failed read goes through captureUiError as
testing.test_preview. The test source and path are not sent.
Editing a project test counts ui.testing.test_edit and measures ui.testing.test_stage around
the temporary write. Save counts and measures ui.testing.test_save; Undo counts and measures
ui.testing.test_undo. Handled staging, save and undo failures go through captureUiError as
testing.test_stage, testing.test_save and testing.test_undo. The source, path, and command are not sent.
ui.testing.record_prepare times the warm tree read Record now does before the mirror can resolve
an element, which is the wait the preparing... overlay is explaining. It is deliberately not
folded into ui.testing.tree_read: that one covers every read, warm and cold, during a recording,
while this one answers "how long is Record unusable for" — the number the overlay exists because
of. A read that fails still records the timing, because the wait happened; it carries no selector,
element name, bundle id or project path.
The Testing panel records on Android emulators as well as iOS simulators, so ui.testing.tree_read,
ui.testing.record_prepare and the testing.agent.screen.* metrics now carry a platform
attribute (ios or android; two values, no device ids). One series hid that waiting on an
emulator is a different number from waiting on a simulator. Names, units and boundaries are
unchanged, and no span or per-frame event was added.
Since 0.1.99, ui.logs.foreground_change counts automatic app-filter changes applied while Logs is active, including selected-device and process-lifetime changes. From 0.1.103, these changes update the visible query and local process identity mapping instead of restarting a scoped collector. ui.logs.app_identity measures batch insertion with native PID-to-app joins and discovery updates in milliseconds, using bounded aggregate windows. Hidden or closed log views defer row processing until reopened. Shared ui.device_apps.discovery timing and handled discovery-error coverage remain in place, including Android's foreground PID lookup; native session operations retain MCP tracing, Node runtime coverage, and logs.ios.parse timings. No app IDs, PIDs, package names, device IDs, or query text are attached to these measurements. Native helper telemetry and symbols are unchanged.
Since 0.1.99, ui.logs.query_parse measures query compilation in milliseconds once per edit, including automatic app-clause edits from 0.1.103. Existing ui.logs.filter, buffered/filtered row gauges, and search counts cover keyword filtering and visible age refreshes; filtering time still covers snapshot derivation and grouping. Query text, field values, regex patterns, and validation messages remain local. Age refresh timers stop when Logs closes, unmounts, or the document becomes hidden.
ui.logs.send measures log attachment and chat delivery in milliseconds, including queued context writes and composer retries. The existing log send counter and error coverage remain in place. No log text, stack traces or device IDs go to Sentry.
ui.logs.session_expired counts expired sessions that trigger automatic recovery. It uses the active Logs context without sending session IDs, error text or log content.
ui.logs.retention measures bounded buffer updates in milliseconds. ui.logs.evicted counts rows removed locally to meet the shared row and text limits; ui.logs.dropped still counts only rows lost from the server buffer. Existing filter timing and row gauges cover the resulting list. These measurements contain no log text or source metadata.
Since 0.1.165 the projects are named mobile-dev-ui, mobile-dev-server and mobile-dev-native; they were codex-mobile-dev-* before. Project IDs and DSNs are unchanged, so history and incoming events continue in the same projects. The React UI reports to mobile-dev-ui (project 4512181027471440). The main Node MCP server and the iOS mirroring service report to mobile-dev-server, distinguished by the component attribute. The agent-device-wrapper component no longer reports, because the plugin servers run agent-device themselves. Native helpers report to mobile-dev-native: Baguette, physical iOS mirroring, iOS FPS and logs, and Android CPU and FPS collectors. All three projects use release mobile-dev@<plugin version>.
TraceSift cards use the tracesift surface, which is also the workspace tool of the same name: the tool's upload pane, cards and explorer are the same surface the inline card reports, so its measurements stay comparable across the two entry points and the server's metadata validation accepts tracesift as both a surface and a view. tracesift.operation.duration measures local service readiness as part of analysis, profile upload and analysis, stable host-view registration when the host supplies it, persisted-analysis restoration from either a host view or replayed tool input, handoff generation, and invoking tracesift explore with a persisted compact analysis, in milliseconds; tracesift.operation.samples records the bounded operation and success/failure outcome. ui.tracesift.pick measures the app-to-server round trip that opens the host's file dialog and waits for a choice, so a slow dialog is told apart from a slow analysis; ui.tracesift.pick_cancelled counts dialogs closed without a file and ui.tracesift.pick_failed counts hosts with no dialog at all, and tracesift.operation adds a pick operation for the same call on the server. ui.tracesift.analyze measures the panel-initiated analysis round trip, counted by ui.tracesift.analyze and ui.tracesift.analyze_failed; the server's existing analyze and ready operations still measure the service side of that same work, whether the model or the panel started it. The card no longer asks for a project folder: Investigate hands the finding to the chat as written, because the chat already works in the reader's project. The ui.tracesift.project_* measurements stopped with that change; the server's project operation remains only for the folder tools, which nothing in the card calls. The card shows one finding at a time, and ui.tracesift.finding_selected counts moving to another one from the sidebar's list or timeline, which says whether readers look past the first finding. ui.tracesift.reset counts returning to the upload pane, which also sets tracesift_view to upload and clears the card gauge so a dropped reading's figures are not read against the next one. ui.tracesift.process measures result validation, ui.tracesift.remember measures the app-to-server registration round trip for a live card, ui.tracesift.restore measures the app-to-server restore round trip after a card view is recreated, ui.tracesift.handoff measures the app-to-server handoff round trip, and ui.tracesift.message_ack ends when the host acknowledges the investigation message. On hosts with composer pills, Investigate and investigating picks put the hand-off in a pill and send a one-line message, and ui.tracesift.context_attach measures that attachment round trip in milliseconds, including failed writes, which count as send failures. ui.tracesift.explore counts opening the embedded explorer, and ui.tracesift.payload measures that app-to-server round trip, which carries the finding's full call tree or commit timeline through MCP; ui.tracesift.payload_bytes records how large those delivered payloads are, and tracesift.operation adds a payload operation for the same fetch on the server. Since Explore renders in-panel, the older meaning of ui.tracesift.explore (a successful CLI browser launch) now belongs to the ui.tracesift.explore_browser counter and its ui.tracesift.explore_browser timing and ui.tracesift.explore_browser_failed counter. ui.tracesift.explore_too_large counts the findings the bridge refused on size or serialization depth, which Explore then opens in the browser window instead of reporting as a failure; those opens are counted and timed by the ui.tracesift.explore_browser measurements like any other browser launch, so a rise in panel refusals is read against them rather than against ui.tracesift.explore_failed. Explorer readiness reuses ui.surface.ready, which the tool restarts from the moment it is opened rather than from the workspace frame that holds it, and tracesift_view distinguishes cards, explorer and the tool's upload pane so explorer work is not attributed to the card list; navigating back resets that context. tracesift_profile distinguishes a cpu recording from a react one, taken from the analysis when it arrives, so the two explorers' payload and processing timings are not read as one figure; it is set with the analysis and never derived from the device, the profile's contents or its path. Picking inside the explorer counts ui.tracesift.pick_on and pick_off for the mode, ui.tracesift.frame_add and frame_remove per click, and pick_clear for emptying the set, which switching picking off with picks standing also counts; ui.tracesift.selected_frames gauges how many picks the open reading holds and is reset to zero whenever that set is dropped — emptying it, switching picking off, closing the explorer, or taking a new analysis — so one reading's picks are never read against another's. The same counters and gauge cover both explorers: since 0.1.157 a React recording's components are picked the same way a CPU task's frames are, told apart by tracesift_profile rather than by counter names, so the measurement boundaries stay comparable across releases. Sending them counts ui.tracesift.pick_investigate, with pick_investigate_empty when the reader sent nothing placeable and pick_investigate_failed when the description could not be built at all; delivery reuses the existing ui.tracesift.message_ack timing and the composer and delivery counters. A card-count gauge and bounded counters cover registration successes and failures, restore hits, misses and failures, Investigate actions, Explore openings and failures, hand-off copies and copy failures, handoff failures, composer unavailability, send failures, and unconfirmed delivery. Readiness, shared interaction, visibility, and cleanup measurements use the existing UI aggregation. The chosen file's name is shown in the pane while analysis runs and is never sent as telemetry. Profile paths and contents, filenames, card text, frame, component and file names, selected frame and component names and their node, fiber and commit identifiers, task, root, and commit indices, analysis/card/host-view identifiers, handoffs, service URLs, process identifiers, tokens, and TraceSift diagnostics are never added to telemetry; replayed profile inputs are hashed only for local lookup. Expected setup, validation, expiry, cancellation, and version outcomes use existing expected-error classification; unexpected transport and malformed-response failures retain handled server/UI error coverage. These measurements describe plugin and local-service work, not the profiled app's performance.
The environments are development and release. npm run build and npm run package default to development, including local installed packages. For a public release, run npm run build:release followed by npm run package:release. Packaging rejects a build from the other environment. The package stores its environment in dist/telemetry-environment.json; Node telemetry, native helpers and the served UI use that setting. Live reload does not determine the environment. Set MOBILE_DEV_ENVIRONMENT=development or MOBILE_DEV_ENVIRONMENT=release in the MCP launch environment to override explicitly, then restart the MCP processes and reopen the panel.
Baguette startup, input repair, simulator foreground detection and physical iOS
bezel rendering discover required Swift compatibility libraries
from the host's selected full Xcode installation before launching the native
helper. Existing sampled MCP traces and UI app-discovery timings include discovery;
handled failures retain their tool error paths. Since 0.1.170, physical iOS bezel
failures report under ios-mirror.bezel instead. Setup failures use fixed messages without
developer directories or scanner output. Native telemetry initialization and
matching dSYMs are preserved; rebuilds remove build-toolchain rpaths and re-sign
the executable before retaining symbols. No additional telemetry fields or
measurement boundaries are introduced.
Since 0.1.117, Android's bundled serve-emu backend runs under Node.js. Existing MCP error capture, sampled tool traces, UI readiness, and input acknowledgement measurements remain on the active paths. android.backend.startup.samples and android.backend.startup.duration measure owned backend launches from process spawn through matching device health readiness or startup failure, in milliseconds, with a fixed outcome of ready or failed. These measure plugin backend startup, excluding emulator boot. They carry only product attributes, never device IDs, process diagnostics, paths, or input content, and honor telemetry opt-out. The child backend retains its local frame, queue, and recovery diagnostics without emitting per-frame Sentry events.
Since 0.1.128, owned Android launches also send bounded startup diagnostics to the parent over Node IPC. The child sends at most one progress message per fixed stage, one first-failure message, and one aggregate completion message. No SDK is initialized in the child. Summaries are strictly validated before telemetry; arguments, output, paths, device names, serials, socket/session identifiers and credentials are never included. Collection stops after initial scrcpy readiness or startup rollback, and telemetry opt-out disables child collection and the post-failure device check. Existing overall startup metrics and sampled MCP trace boundaries remain unchanged; timeout values and retry behavior are unchanged.
android.backend.startup.stage.samples, .stage.mean, .stage.max and
.stage.outcomes distinguish server lookup/hash, cache probe, push/cache
publication/copy, forwarding, socket readiness/polling, socket connections,
video preamble and rollback. Socket readiness measures the whole wait; socket
polling measures individual commands aggregated into one summary. Stage durations
include cancellation settling. .queue.mean and .execution.mean distinguish
executor admission wait from local ADB process lifetime through pipe closure;
.execution.spawned counts measured commands that actually spawned. These are
monotonic plugin timings in milliseconds, not device-only execution latency.
Measurements are aggregated per stage per launch, never sent per poll or frame.
.active_backends, .in_flight and .stopping_backends count owned active,
starting and stopping backends in this MCP process. android.backend.process_shutdown.duration
measures SIGTERM to local child exit; it does not establish remote scrcpy exit.
.device_state.samples and .device_state.duration record a bounded, asynchronous
ADB device-list check after failure, with only online/offline/unauthorized/missing/
unknown state. The before-state comes from the existing online-device preflight.
An unavailable or failed check records unknown, never inferred device state.
The check does not delay the failed tool response and is cancelled on disposal.
All diagnostics explicitly use the simulator surface and Android device platform,
with emulator/physical kind and emulator/wired/localNetwork/unknown transport.
Errors retain their original message and stack plus fixed android_startup_stage,
android_startup_outcome, android_device_state_before, android_transport and
android_cleanup_overlap tags. Existing anonymous error attribution, environment,
release, scrubbing and opt-out remain in the parent. Installation and process-session
IDs never enter performance measurements. These diagnostics distinguish failure
mechanisms; they do not by themselves identify the cause of an ADB stall.
Since 0.1.170, the server records the inode and modification time of its bundle file
(server.mjs, or the chunk beside it in split builds) when it loads. Every error event
from a server whose file is gone carries install_integrity: removed, as when an update
or uninstall deletes the running version's folder; another file in its place gives
replaced. Split builds name chunks by content, so an in-place update there reads as
removed. A missing bundled serve-emu or Baguette runtime also carries bundled_runtime
(serve-emu or baguette), with install_integrity: incomplete when the server's file
is unchanged, so the installation it started from lacks the runtime. A runtime file that
exists but cannot be read or run is not reported as missing. Only these fixed values are
sent, never paths. The panel no longer retries a missing runtime on every reconnect.
Missing-runtime errors now have new messages and are created in install-integrity.ts,
so they group into new Sentry issues; compare them with MOBILE-DEV-SERVER-68
(serve-emu) and MOBILE-DEV-SERVER-7C (Baguette) when reading trends.
Unhandled JavaScript errors and rejected promises, React render errors, and handled MCP tool failures produce issues. Expected stopped-device errors and cancelled operations are excluded. Sentry traces 10% of ordinary tool actions, continuing the UI trace through the MCP bridge. Frame reads, polling, discovery and pointer input are excluded from trace sampling. The SDK does not record MCP arguments or results.
Device requests retain the ordinary sampled MCP trace. device_picker.prepare
measures candidate discovery/validation in milliseconds, excluding time spent waiting
for the user. device_picker.result counts accept, cancel, decline and failed
outcomes; device_picker.selected records only the number of selected devices.
Attributes contain only the selection mode, outcome and form, the native form used
(openai or mcp), which replaced mode. Its card and browse values and the
unsupported and rendered outcomes belonged to the removed devices card, and hosts
without a form no longer list the tool. When candidates are omitted, prepare
also covers discovery of every device, so compare it with validation-only samples by
whether candidates were passed. Unexpected handled failures
use fixed messages. Device IDs/names, app labels, questions, operation details and
thumbnails are never sent to Sentry. The form is rendered by the host, so plugin UI
readiness/render timing cannot measure that surface.
Physical iOS display rejections, including an active phone or VoIP call, appear in the panel's Screen unavailable state while it retries. These expected device responses preserve native connection timing, sampled MCP traces and ui.action.result outcomes on the simulator surface. Their localized descriptions remain local and do not produce separate Sentry issues.
The plugin servers for Codex, Claude and Cursor serve agent-device's commands as device_<command> tools, measured like its other tools by the server's MCP instrumentation (tools/call device_<command> spans). The runtime starts on the first command; agent_device.runtime.ready measures that start, from the first command to a connected runtime, in milliseconds. Handled failures use static messages under agent_device.<command>, agent_device.start, agent_device.exit and agent_device.cleanup, and its storage measurements come from the server process. Incoming trace metadata continues through to the native MCP request; discovery and session lookups (device_devices, device_apps, device_appstate, device_capabilities, device_session, device_events) are excluded from sampling. Handled native failures use static error messages so app content and tool payloads cannot enter telemetry. The standalone agent-device server, its agent_device.catalog.ready measurement and its agent-device-wrapper component were removed.
| Measurement | Collection and interpretation |
|---|---|
| Node CPU and memory | Sentry runtime metrics every 30 seconds: process CPU utilization, RSS, heap, external memory and array buffers. Each Node launcher is measured separately; the agent-device daemon is outside this coverage. |
| Native resources | native.cpu.utilization, native.memory.rss and native.process.uptime, sampled every 30 seconds and at startup/shutdown. CPU is a ratio where 1 is one fully occupied core. The iOS mirroring addon shares the Node process, so its resource measurements overlap Node's rather than representing another process. |
| Native operations | Bounded timing windows for connection, physical iOS input acknowledgement and video packet processing, iOS log processing, Android CPU sampling, and FPS read/processing. Filter by component, runtime_platform and surface to identify the responsible helper. Baguette currently records resources and crashes. |
| Node responsiveness | Automatic event-loop delay, utilization and process uptime. |
| UI JavaScript heap | ui.memory.heap_used, ui.memory.heap_total and ui.memory.heap_limit in bytes at startup and every 30 seconds while visible, when Chromium's performance.memory is available. ui.memory.supported distinguishes unsupported contexts. These estimates do not measure total renderer or GPU memory. |
| UI responsiveness | Browser tracing captures available web vitals. Custom metrics record visible animation-frame intervals, intervals over 50 ms, Event Timing interaction durations, long tasks and long animation frames where supported. |
| Product surfaces | Metrics carry surface=app-flow, simulator, logs, performance, storage, app-intel, tracesift, recording or comparison, plus view, visible device layout and monitoring state. App Flow readiness/graph work, log filter time, buffered/filtered rows, performance batch processing, App Intelligence generation and graph size, canvas draw time and time to first video frame help explain slow surfaces. |
| Frame capture | ui.screenshot.capture measures synchronous canvas PNG encoding and base64 extraction in milliseconds for Select captures and physical iOS screenshots. ui.screenshot.encode measures PNG decoding, bounded JPEG encoding, and base64 extraction for chat attachments in milliseconds. Screenshot tools retain sampled MCP traces and report handled capture, attachment, and clipboard failures without image content. |
| Pasted input | Command-V paste uses the existing ordered device input queue and ui.device_input.round_trip timing through MCP acknowledgement. It retains simulator surface/device context and existing input failure reporting. Clipboard content and validation failures are not sent to Sentry. |
| Storage | Every five minutes, a server with agent-device measures its session state directory and the shared Apple runner cache in bytes, from the runtime's first start. It skips symlinks and sends only the storage kind and size. |
| Usage | Surface views and visible time, tool action outcomes, log searches, attachments and send-to-chat actions are counted without their content. |
UI timings are aggregated into bounded 30-second windows with .samples, .mean, .p95 and .max; windows also close on a surface or context change. The p95 uses a reservoir of up to 256 observations and describes that window, rather than the percentile of all measurements across users. Filter by environment, release, surface and layout to compare like workloads. ui.frame_interval measures browser callback pacing, not actual rendered FPS. Event Timing measures interaction duration through the next paint; ui.device_input.round_trip measures the device input request through its MCP acknowledgement. Neither measures device touch-to-photon latency. ui.interaction.supported identifies whether the browser supports that API. Codex's embedded UI does not expose reliable renderer CPU, total memory or disk measurements. Since 0.1.80, recording processing, derivation, change-density, and reveal timings include the FPS track when present. ui.recording.fps_samples gauges the count of saved FPS intervals, never their measured values. Since 0.1.86, ui.recording.process also covers parsing retained Android display frames, and ui.recording.display_frames gauges their count on the recording surface. Since 0.1.87, ui.recording.derive also includes jank classification and presentation-interval statistics. Whole-run derivation runs when recording data changes; selected-range recomputation is measured separately under the same timing name, without repeating full-run processing during a drag. Device CPU/memory/FPS and frame timestamps, tokens, jank metadata, and derived device jank/pacing values remain local and are not forwarded to Sentry. No per-frame telemetry is emitted.
Native helpers use the pinned Sentry Native 0.17.1 in-process crash backend. It captures fatal signals with stack addresses and module debug IDs; the Rust wrapper also reports task panics with a static message and source location. Crash reports are retained in a private cache and sent on the helper's next start. Host caches live under ~/Library/Caches/mobile-dev/sentry; Android caches live under /data/local/tmp/mobile-dev-sentry. Android collectors relay envelopes through ADB stderr to the Node transport, preserving their stdout data protocol. Native timings use the same bounded 30-second .samples, .mean, .p95 and .max windows as UI timings. iOS FPS timing covers received-counter processing; Android FPS timing includes Perfetto flush/readback. Video timing covers packet assembly and queue work, not decoding or device rendering.
Error and crash events carry only a generated anonymous user.id and a telemetry_session tag. The Node server creates one random installation ID per local OS account, stored with owner-only permissions in ~/Library/Application Support/mobile-dev/telemetry/anonymous-user-id. It survives plugin updates, project changes, and app restarts, and is shared with the served UI and native helpers. Each MCP process creates a new random session ID; its UI panels and child helpers share that session. These are plugin server sessions, not chat or device sessions. Sentry's affected-user count therefore approximates affected installations: one person on two machines counts twice, while people sharing an OS account count once. No OpenAI account ID, email, name, IP address, device ID, or host identifier is used. IDs are excluded from performance metrics and span attributes. Stop the MCP processes and delete the identity file to reset it; telemetry opt-out creates no ID.
Session Replay, minidumps, screenshots and profiling are disabled. Requests, account details, app log content, tool payloads, automatic console breadcrumbs and exception source context are excluded. JavaScript error text redacts common tokens, identifiers, URLs, email addresses and local home paths. Native reports retain source basenames and debug IDs, omit absolute module paths, and never send Rust panic payloads. Safe product attributes and source locations remain available for diagnosis. MOBILE_DEV_TELEMETRY=off disables reporting across JavaScript and native helpers.
Builds generate debug IDs and source maps under the ignored .sentry/ directory. Each page and server bundle keeps its maps in its own folder: .sentry/ui/<page> (mcp-app, codex, mac) and .sentry/server with host servers under .sentry/server/<host>. npm run sentry:upload uploads both trees, so every host's bundles share the release and its debug IDs. Host servers keep the shared server's component, metric names and boundaries; Codex's plugin.update.* metrics now come only from Codex's server. Native rebuilds retain macOS dSYMs and unstripped Android ELF files in .sentry/native before stripping the bundled binaries. Release runs can reuse each helper's exact build artifact, restoring the vendor files and matching symbols together after SHA-256 verification. Reused symbols are still uploaded by the current release's Sentry step. Native helpers receive the current release and environment at runtime, so reuse preserves release attribution, measurement boundaries and debug IDs. Symbols, source maps and the upload credential are excluded from the plugin package. Native builds require CMake and Ninja, with an Android NDK for Android collectors. The SDK source archive is pinned and checked by SHA-256. Store the organization build token in the ignored .env.sentry-build-plugin file at the repository root:
SENTRY_AUTH_TOKEN=your_org_token
SENTRY_ORG=your_organization_slug
That file is also listed in .worktreeinclude for local worktrees. Use the organization slug, rather than a team slug, for SENTRY_ORG. npm run sentry:upload reads the file in preference to shell settings, creates the shared release in all three projects, uploads JavaScript maps and native debug files, and finalizes the release. Rebuild native helpers and run npm run build before uploading so symbols and maps match the packaged code. Runtime reporting needs only the public DSNs; it does not need this token. Build and upload are separate commands. npm run test:native-telemetry verifies a real isolated crash, Rust panic privacy, metrics, opt-out and the Android relay transport against a local receiver.
Since 0.1.130, simulator definition HTTP 404 errors retain their existing message,
simulator.tool operation, UI surface context, anonymous installation/session
attribution, trace propagation and retry behavior. Baguette adds a versioned local
definition_diagnostic object at the actual failure boundary. Server error tags
definition_stage and definition_failure distinguish simulator lookup, profile
read/parsing/missing chrome identifier, panel lookup, chrome read/parsing,
composite read/layout/rasterization, missing screen geometry, slice
read/rasterization, and final assembly. Read failures distinguish missing files,
permission denial and other unreadable files. definition_cached_failure marks
negative-cache hits, which retain the original asset failure stage/category even
when another bezel route populated the cache. No raw filesystem errors are sent.
definition_model accepts only a fixed allowlist of public Apple device-type
names (never renamed simulator names); unknown models become unknown.
definition_runtime and definition_xcode_version accept only bounded numeric
version strings. The Xcode version comes from the Xcode selected by Baguette's
existing developer-directory resolver, rather than the plugin build toolchain.
definition_panel and definition_device_state describe the backend's request
snapshot. definition_backend_version accepts the pinned Baguette version;
definition_backend_source=pinned verifies the diagnostic's source commit against
the plugin's pin, and definition_backend_mode distinguishes embedded and external
backends. These are error tags only, not performance attributes or identifiers.
definition_device_before records the successful booted-device validation.
After a definition 404, the server performs one bounded device-list read (up to
two seconds) and adds definition_device_after: a lifecycle state, missing,
unreachable, or unknown. This is later evidence, not proof of the exact state
when the definition failed. It performs no boot, repair or definition retry.
Existing connection timings include this failure-only diagnostic read. A missing,
unrecognized, malformed, oversized (over 4 KiB) or interrupted diagnostic response
is tagged response/unclassified; the original HTTP error remains intact. The
body is never attached to Sentry. Device IDs, local paths, raw response bodies,
logs, arbitrary names and credentials remain excluded. Collection uses the
existing centralized Sentry initialization, environment and telemetry opt-out.
Native rebuilds retain matching Baguette dSYMs, and release uploads continue to
upload those symbols with the plugin release.
App Intelligence uses the app-intel surface. app_intel.operation.duration and
.samples measure bounded generation, query, snapshot, clear and folder-picker
operations by success, failure or cancellation. The UI records generation/load/picker round
trips, surface readiness, and gauges only the counts of files and screens in the
displayed snapshot. ui.app_intel.flow_layout times building and placing the
per-screen dependency graph — the hop layering, its boundary grouping and the
geometry for the chosen reading direction — and ui.app_intel.flow_nodes gauges
how many cards it drew, which is what drives that cost. The panel no longer has a
directory treemap, so the Atlas measurements ui.app_intel.atlas_layout,
ui.app_intel.atlas_cells, ui.app_intel.view_switch and ui.app_intel.zoom are
gone rather than renamed; flow_layout and flow_nodes keep their meaning and
units, so their history stays comparable even though they now cover grouping and
placement as well. ui.app_intel.group_collapse, .group_expand and
.group_show_all count folding a boundary away, bringing it back and opening one
past its row cap, ui.app_intel.boundary_highlight counts lighting one boundary's
connectors up, ui.app_intel.project_switch counts picking a remembered
project instead of the host folder picker, ui.app_intel.clear counts throwing a
saved graph away, and ui.app_intel.boundary_filter
counts how often the entry-point filter is changed. All of these count the change
only; which boundary, project or direction was picked is not an attribute. Project paths, source paths, screen and package names, source
contents, queries, diagnostics, graph edges and snapshot identifiers remain local
and are never telemetry attributes.
A Fast screen sweep now runs with no decision provider unless the panel's per-project "Judge unclear screens with AI" switch is on, so the judge path described above is reachable in Fast only when that switch asked for it; with it off, a screen whose runtime evidence is incomplete is recorded unreached instead of being sent to the judge, and app_flow.runtime.verify emits no judge arrivals for that run. The series, its unit and its attributes are unchanged — the runtime/judge split simply shifts further towards runtime for Fast runs started with the switch off. The panel adds one UI count beside ui.app_flow.capture_ui_states_start and with the same shape, ui.app_flow.judge_unclear_screens_start, once per user-started run that has the switch on, so how often Fast pays for the decision loop is visible; it carries nothing beyond the shared surface attributes — no project path, screen, route or verdict. A Fast run with the switch off is also started straight from the panel rather than through a chat message, so it records ui.app_flow.start where a chat-started sweep records none; that is the existing split between the two start paths, not a new measurement.
Since 0.1.141, deterministic Fast harvests route parameters from the link
elements in the app's React tree, one read per captured screen while any
uncaptured route still has an unresolved parameter. The read is billed to the
existing app_flow.runtime.command series under a new operation value,
links, so its cost stays comparable with the nav-state read beside it rather
than arriving as a separate name. app_flow.runtime.links counts the outcome of
each read with a fixed value: usable when at least one destination produced a
stored record, unmatched when destinations were read but none matched a
parameterised route, empty when the tree named none, and failed when the read
threw (which latches the harvest off for the rest of the sweep). Counts and
durations only: the harvested destinations themselves — route names, URL paths
and parameter values — are never attached, matching the parameter store's own
refusal to log values, and the per-screen detail stays in the local sweep log.
No new data leaves the machine.
A screen node now offers a second replay variant, runtime replay, which puts the
app on that screen by dispatching through the app's own navigator with its parsed
route and the parameter values previous sweeps observed, instead of re-walking a
recorded path. It reuses deterministic Fast's own connection and render port, so
its handshake, its navigate, readiness and nav-state commands, its settle
and its navigate outcome are billed to the existing
app_flow.runtime.{connect,command,settle,verify,navigate,state} series with
their existing names, units and attributes — a replay's runtime cost is therefore
directly comparable with a sweep's, which is the point of sharing the transport
rather than writing a second one. Two names are new:
app_flow.runtime_replay, a bounded count per replay, and
app_flow.runtime_replay.duration, one millisecond measurement per replay
covering device preparation, the handshake, the dispatch and the settle. Both
carry a single closed-set outcome: ok, no-map and no-node (a panel
pointing at a map that has been rebuilt or cleared), unresolved-params (the
route needs a parameter no sweep has ever observed a value for, which is refused
rather than dispatched with a guessed value), unavailable (no reachable
development runtime), refused (a reachable runtime that declined the route) and
failed. The panel side adds ui.app_flow.runtime_replay, its own round-trip
duration, and a count of the same name carrying the same closed-set outcome. Node
ids, route names, URL paths, parameter names and parameter values are never
attached to any of them, matching the parameter store's own refusal to log
values; the route and the reason a dispatch was refused appear only in the local
console line and in the error shown on the node, neither of which leaves the
machine. No new data is collected.
Since 0.1.179, resource_saving.apply counts successful and failed applications of
the selected virtual-device profile, and resource_saving.duration records the
whole operation in milliseconds, including iOS verification or Android package
readback. Attributes are limited to component=server, surface=simulator,
device_platform, virtual device_kind, enabled, and outcome. Failures use a
fixed-message resource_saving.apply error report. Preferences have separate
fixed-message resource_saving.read and resource_saving.set reports.
The UI records ui.resource_saving.change duration and
ui.resource_saving.failure through the existing UI operation helper. All paths
use the existing sampling, scrubbing and telemetry opt-out. No device IDs, AVD
names, packages, service lists, paths, command arguments, CLI output or preference
contents are attached. There are no background samplers or per-frame spans for
this feature. Benchmark process measurements are local report artifacts and are
not submitted to Sentry. Existing startup, stream and input coverage is retained.