The discussion centers on building an Application Usage dashboard leveraging the ControlUp `process_stops` index and addresses several technical questions related to data collection, metric definitions, and field completeness.
Data from clients are collected per process exit event, with each process stop generating a record. However, data upload to the backend is batched rather than immediate, using cache files that upload roughly every 10 minutes. This means a slight delay exists between the process exit and when the data becomes available in the index. For aggregation, timestamps such as `stoptime` or `starttime` should be used as the event time, not the record creation time.
Regarding the definitions and units of key metrics like `averageworkingset_long`, `totalcputime`, or `average_user_input_delay`, no official public documentation explicitly details these metrics at field level. Users are encouraged to utilize the ControlUp AI Assistant to obtain clarifications. General ControlUp documentation may offer broader context, but precise field definitions are typically obtained through these support channels.
The `publisher_name` field may be inconsistently populated for the same process version, such as `mspaint.exe 11.2609`. This is because `publisher_name` is derived from executable file metadata or Authenticode signatures at the time the stop record is finalized. If the process terminates too quickly or the file metadata cannot be accessed—common in WindowsApps or MSIX environments—this field can be blank. Filtering results with `ispartial = false` helps ensure higher-quality data where `publisher_name` is meaningful, though blanks can be coalesced to “Unknown” or reports can group by additional identifiers like process path or file version. The `ispartial` flag indicates completeness of core stop/performance data but does not guarantee all enrichment fields like `publisher_name` or `upn` are filled.
The `upn` (User Principal Name) field, representing the user context, is also sometimes missing. This occurs when the process runs under system or service accounts, when only a username or SID is available without a UPN, or when no meaningful interactive user is associated with the process ID. This variability is expected in diverse Windows session or security contexts.
For aggregation and analysis, it is advised to use `stoptime` or `starttime` as the primary timestamps and group data by friendly process names or combinations of process name and version/path as needed. Nullable metrics such as input delay or network fields should be explicitly filtered or appropriately handled when aggregating. Multiple rows often represent distinct instances or sessions rather than duplicates.
An alternative data source, the `app_focus` index, provides per-minute records of an application’s focus time and typically offers richer user identity and application name details. However, `app_focus` does not track discrete process launches as accurately as `process_stops`. Use cases focused on launch frequency benefit from the `process_stops` data, whereas `app_focus` better reflects actual user engagement duration with an application window.
Finally, a notable resolution mentioned was that the `upn` omission was fixed by updating the domain list in Employee settings, which contained only a single domain. Also, `publisher_name` is updated only once per day per process, which can affect its consistency across records. If persistent issues arise, it is advisable to open a support ticket for deeper investigation and to provide sample data for analysis.
For more details on ControlUp metrics and indexing, users can refer to the ControlUp documentation at https://docs.controlup.com and explore interactive help via the ControlUp AI Assistant. Contact ControlUp support at support@controlup.com for unresolved cases or to report suspected data enrichment issues.
Read the entire ‘Understanding and Aggregating ControlUp process_stops Data for Application Usage Dashboards’ thread below:
I’m building an Application Usage dashboard based on the `process_stops` index and have a few questions:
• How frequently is data sent from the client to the backend? Is it sent when a process stops or in batches?
• Is there documentation describing the exact units and definitions of metrics such as `averageworkingset_long`, `totalcputime`, `average_user_input_delay`, etc.?
• Why is `publisher_name` not always populated for the same process/version? For example, with `mspaint.exe` `11.2609`, some records contain `Microsoft Corporation`, while others are empty. See screenshot.
• Under what circumstances is `upn` not populated?
Mainly trying to make sure I interpret and aggregate the `process_stops` data correctly.
Hi Rico,
Thank you for posting. Let’s break down the response below
How often data is sent (stop event vs batch)
On the endpoint, a record is created when a process exits (one document per process instance / PID lifecycle).
Upload to the backend is batched, not one HTTP call per stop:
1. Stop events are written to local cache files (StopProcessEventsCache).
2. The agent uploads those cache files on a schedule via cache upload (SendCacheFileEvents), typically with many stop events per POST.
Cache files for this telemetry class rotate on roughly a ~10 minute cadence; the upload job usually runs on a shorter interval when the agent is online. Expect a small delay between exit and the document in the index. If the device is offline, events can queue locally until upload succeeds.
For aggregation, treat stoptime (or starttime) as the process event time, not necessarily _created.
There does not appear to be a public document stating the units and metrics for each data index field. However, the AI Assistant should be able to provide this information. Have you tried that?
Regardless, here are the metrics you named:, with interactive elements
Why publisher_name can be empty for the same process/version (e.g. mspaint 11.2609)
publisher_name is populated from executable file metadata / Authenticode signature when the agent finalizes the stop record.
The same processname, path, and processfileversion can still show mixed publisher values because enrichment is per stop event, not per static app catalog. Rows are often blank when:
• The process exited before file metadata could be read (short-lived stops)
• ispartial = true (incomplete stop record)
• The binary could not be read at stop (access, path, or some WindowsApps / MSIX layouts)
That matches a pattern where most mspaint rows have no publisher but some show Microsoft Corporation when signature read succeeded for that instance.
For reporting: try filtering ispartial = false when publisher quality matters; coalesce blank to Unknown; or group on processnamewithpath + processfileversion alongside publisher_name.
When upn is not populated
upn is the User Principal Name (user@domain) for the user context tied to that process instance, when the agent resolves it.
It is commonly empty when:
• The process ran under SYSTEM, a service account, or other non-interactive identity
• Only username (DOMAIN\user) or usersid is available — local accounts, some session types, or identity resolution that did not return a UPN
• No meaningful interactive user is associated with that PID
In some OS contexts, specific conditions may also lead to the UPN being empty
Aggregation tips (so counts and sums stay correct)
1. Time bucketing: use stoptime (or starttime for “launches”) as the primary timestamp.
2. Usage: count rows or sum(duration_ms) / sum(totalcputime) grouped by friendlyprocessname or processname (+ version/path if needed).
3. Nullable metrics: input delay, network fields, launch time — filter or coalesce explicitly.
4. Quality filters: for publisher or UPN analysis, consider ispartial = false.
5. Multiple rows per “app” are usually multiple instances (PIDs, sessions, or launch paths), not duplicate bad data.
Perhaps (Desktops) and / (Dashboards) can keep me honest here, but if neither these answers nor the AI Assistant succeeds in providing an effective response, please either contact your CSM/TRM for additional insights, or contact Support at support@controlup.com
Hi Rico, for application usage I would advice to rely on app_focus data instead of process_stops. App_focus really contains a per minute record of how long in that minute someone was working with the application. Process stops just contains the number of minutes someone had the process open and it only records it at the end of the process
Also app focus has better appname descriptions and upns etc etc
Hi,
I agree that `app_focus` is useful, especially for understanding how long an application is actually in focus. However, it seems to be missing quite a bit of the additional information available in `process_stops`, and in my testing it wasn’t noticeably faster either.
For example, today I’ve launched Paint 5 times. `process_stops` correctly shows those 5 individual launches, while `app_focus` only shows 1. So if I use `app_focus` for application launch/usage frequency, it gives me the wrong picture.
Also worth mentioning: the built-in legacy DEX Application Usage report uses `process_stops` as well. So I think both datasets have value, just for slightly different purposes.
yeah true so app_focus is not application starts indeed. Its really how long was the window in focus and it has to be the main window in that minute
Many many thanks for the explanation. One thing I noticed though: in my examples, `ispartial = false` for all records, while both `publisher_name` and `upn` are still missing in many of them.
So the `ispartial` explanation doesn’t seem to apply here. Could this be a bug or an issue in the enrichment/resolution process?
If so, I can raise a ticket.
Hi
Fair point!
`ispartial = false` likely means core stop/perf data looked complete, not that `publisher_name` or `upn` were resolved.
Those may be separate enrichments, so either can still be empty on “complete” rows.
Publisher may come from per-stop file/signature reads. Same mspaint version might show Microsoft Corporation sometimes and blank other times, which can be more variable on WindowsApps / MSIX paths. That may be enrichment inconsistency, not bad `ispartial` data.
UPN may not always align with username / usersid: username without UPN can happen depending on how the session was identified.
We can’t call it a bug from the screenshot alone; optional fields may be best-effort. If most complete rows are missing publisher for the same path/version, sample rows + tenant + agent version could help us see if it’s a known pattern or worth R&D review. This will definitely require a ticket so that we can spend more time on it.
Hey, most of the data is from the same device, same user and same app version.
Duly noted. We will need a ticket after all to make sure all our bases are covered
UPN issue is fixed; domain list in the Employee settings, contained only one domain.
Publisher will only be filled in once per day per process.
Thanks to the great supportguy ()
Continue reading and comment on the thread ‘Understanding and Aggregating ControlUp process_stops Data for Application Usage Dashboards’. Not a member? Join Here!
Categories: All Archives, ControlUp Dashboards, ControlUp for Desktops
