- Docs
- Resources
- Agent Pool & Device Farm
- How the numbers work
How the numbers work
Every number, state and time limit in Device Farm, how it is calculated, and an example you can check against your own screen.
In short
On this page you can
- Understand when an agent, a node and its devices count as Online or Offline.
- Read the performance cards: Workers (active/total), Active sessions, Peak.
- Check how the Min of a farm run and its device metrics are worked out.
- Know the timeouts of live sessions, installs and long runs.
How to use it
- Find the number you see on screen in the headings below.
- Read the formula box: what is counted and where it comes from.
- Compare the worked example with your own values.
- If a number still looks wrong, follow the link to the matching fix.
Agent: Online and Offline#
The rule for test agents (heartbeat every 5 seconds, Offline after 90 seconds of silence, checked every 30 seconds) and a worked example are on the Quick Start page: When is an agent Online? The list on Test Agents refreshes every 5 seconds and on every connect or disconnect. Smartest Server is always shown as Online.
Node and devices: Online and Offline#
heartbeat = the node reports itself about every 30 s
Offline = no heartbeat for 180 s
OR no heartbeat for 60 s AND the node's live connection is closed
checked = every 20 s
then = every device of that node → Offline
every active run on that node → Failed
back = the node registers again → node and devices Online
Example: a node PC loses power at 14:00:05; its last heartbeat was 14:00:00 and its connection drops with it. At the first check after 14:01:00 (60 s of silence, connection closed) the node turns Offline, so between about 14:01:00 and 14:01:20. Its four phones show “Node offline”, and a run that was active on one of them is closed as Failed. If only the connection blips while heartbeats keep coming, nothing changes.
Last Heartbeat#
age = now − last heartbeat (seconds) age < 60 → "just now" age < 3,600 → floor(age ÷ 60) "min ago" age < 86,400 → floor(age ÷ 3,600) "h ago" otherwise → floor(age ÷ 86,400) "d ago"
Example: a heartbeat 7,500 seconds ago shows “2 h ago” (7,500 ÷ 3,600 = 2.08). A healthy node always shows “just now”.
Agent performance cards#
Total RAM = physical memory ÷ 1024³, 1 decimal, GB CPU cores = logical cores (threads) Free disk = free space on the system drive ÷ 1024³, 1 decimal, GB Active sessions = browser sessions (Selenium + Playwright) open right now Peak = highest Active sessions since the agent started Workers (active/total) = tests running now / tests the machine runs at the same time Queued = tests waiting for a free worker
Example: a VM shows Workers 3 / 5, Queued 2, Active sessions 3, Peak 5. Three tests run, two wait, and at some point since the agent started five browsers were open together. A pipeline with ten tests on this agent finishes in batches of five at best.
Read it right on Smartest Server: Workers and Queued count every test running on the server, including other companies’ tests; the Worker timeline shows only yours. A high Queued number there is the reason runs wait (see server busy).
Agent performance charts#
CPU % / RAM % / Swap % = machine-wide use at the sample time
Browser processes = processes whose name contains chromium, chrome,
headless_shell, firefox, webkit, playwright or node
Browser RSS (MB) = memory used by those processes together
System RAM (MB) = memory in use on the machine
Disk I/O (MB/s) = (bytes read or written since the last sample ÷ 1,048,576)
÷ seconds since the last sample
JMeter / k6 users = virtual users of a load test (line shown only if > 0 in the range)
history = up to 24 h, about one point per minute
live = one new point every 3 s while the browser tab is visible
Example: Appium runs on Node.js, so an idle mobile agent can show Browser processes of 1 or more with no browser open. Twelve Chrome processes for three tests is normal: one browser uses several processes.
The time range (30m, 1h, 4h, 12h, 24h) only cuts the view; it does not load other data.
Worker timeline#
one row = one test job (test case or schedule) bar start = the time the job started bar end = the last time the job was seen running visible = jobs of your own company's projects only title = "Worker timeline (active/total active)"
Example: a test started at 10:02:10 and was last seen at 10:05:40. With range 1h the bar covers 3.5 of 60 minutes, about 6% of the width. Hover it for “Duration: 3m 30s”.
Tab counts#
Nodes (n) = nodes you can see Devices (n) = devices you can see (before filters) Recent runs (n) = runs loaded: at most 200 (users of the cloud service: 100)
Example: Recent runs (200) with “showing last 200” means older runs exist but are not loaded.
Device counts#
Available = devices in state ONLINE Busy = devices in state BUSY (a run or a live session holds them) Offline = every other state (offline, maintenance, unknown) devices total = Available + Busy + Offline, before filters Showing n = devices left after filters, search and tags
Example: 10 devices: 6 Available, 1 Busy, 3 Offline. Filter OS = Android 14 and Availability = Available: “Showing 2 devices”, the strip still says 6 / 1 / 3 and 10 total.
Recent runs › Min#
run ends normally → Min = ceil(duration in seconds ÷ 60), at least 1 run closed by the cleanup (node dead or active for 120 min) → status Failed, Min = floor(duration in minutes), at least 1 still running → "—"
| Duration | Calculation | Min |
|---|---|---|
| 40 s | ceil(40 ÷ 60) = 1 | 1 |
| 61 s | ceil(61 ÷ 60) = 2 | 2 |
| 5 min 0 s | ceil(300 ÷ 60) = 5 | 5 |
| Node died after 7 min 50 s | floor(7.8) = 7 | 7 · Failed |
Every started minute counts as a full minute.
Run telemetry#
big number = the last sample of the main line (the app's line if it has data, else the device's) Temperature = °C, axis 0–60; big number turns red at ≥ 40 °C; also shows Peak Battery = %, shows Lowest (the drain), not Peak Memory = app MB; "%n" = round(app MB ÷ device total RAM × 100); Peak CPU = app %, and the whole device as a second line; Peak Peak / Lowest = highest / lowest sample of the main line during the run
Example: memory samples 410, 520 and 480 MB on a phone with 3,800 MB: the card shows 480 MB %13 (480 ÷ 3,800 = 12.6%) and Peak 520. Temperature samples 36, 39, 41 °C: 41 °C in red, Peak 41. Emulators have no temperature or battery sensor.
App Library counts#
Applications = apps in the library Versions = stored builds; each app keeps one build, so Versions = Applications Android / iOS = apps per platform MB stored = sum of file sizes ÷ 1,048,576, 1 decimal n app(s) missing package id = apps with no package id or bundle ID (hidden when 0) limit = 30 apps per company
Example: 4 Android apps of 52.4, 61.0, 18.3 and 9.9 MB and 1 iOS app of 140.2 MB: Applications 5 · Versions 5 · Android / iOS 4/1 · 281.8 MB stored.
Live session timings#
first connection timeout = 75 s (Android) · 105 s (iOS) reconnect timeout = 30 s (Android) · 45 s (iOS) automatic retries = 3, after waits of 4 s, 10 s, 20 s label while retrying = "Reconnecting… (n/3)" farm device lease = 180 s, renewed while the stream is open
Example: an Android stream drops at 11:00:00. The window waits 4 s and reconnects (30 s budget); if that fails it waits 10 s, then 20 s. After the third failure it shows “Connection failed” and Try Again. If your browser crashed instead, the farm device frees itself by about 11:03:00.
Other time limits#
| Limit | Value | What happens |
|---|---|---|
| Installing an app on a device | 6 min | The device is marked “timed out — no result from the device”. |
| One farm run | 120 min | The run is closed as Failed and the device returns to Available. |
| Node commands not picked up | 30 min | The queued command is dropped. |
Didn’t find your answer?Write to support with your project name and what you see on screen.
info@smartestqa.ai