# end user device monitoring

Monitoring and observability of end-user devices, including tracing requests from a user's device to a SaaS application.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Monitor and troubleshoot employee devices with Datadog End User Device Monitoring

DevFeed: [Monitor and troubleshoot employee devices with Datadog End User Device Monitoring](<https://devfeed.tech/articles/monitor-and-troubleshoot-employee-devices-with-datadog-end-user-device-monitoring-129357.md>)

Original publisher: [Read original article](<https://www.datadoghq.com/blog/end-user-device-monitoring/>)

Author: Erica Ho; Paolo Padua

Published: 2026-11-10T00:00:00Z

Content type: article

Language: en

Sources: [Datadog](<https://devfeed.tech/sources/datadog-the-monitor-blog.md>)

Topics: [end user device monitoring](<https://devfeed.tech/topics/end-user-device-monitoring.md>), [datadog](<https://devfeed.tech/topics/datadog.md>), [digital experience monitoring](<https://devfeed.tech/topics/digital-experience-monitoring.md>), [bits ai](<https://devfeed.tech/topics/bits-ai.md>), [Network](<https://devfeed.tech/topics/network.md>), [Support](<https://devfeed.tech/topics/support.md>), [Monitoring](<https://devfeed.tech/topics/monitoring.md>), [datadog agent](<https://devfeed.tech/topics/datadog-agent.md>)

Tags: [access-point](<https://devfeed.tech/tags/access-point.md>), [act](<https://devfeed.tech/tags/act.md>), [actions](<https://devfeed.tech/tags/actions.md>), [bits-ai](<https://devfeed.tech/tags/bits-ai.md>), [datadog](<https://devfeed.tech/tags/datadog.md>), [device](<https://devfeed.tech/tags/device.md>), [devices](<https://devfeed.tech/tags/devices.md>), [digital-experience-monitoring](<https://devfeed.tech/tags/digital-experience-monitoring.md>), [employee](<https://devfeed.tech/tags/employee.md>), [employees](<https://devfeed.tech/tags/employees.md>), [end-user](<https://devfeed.tech/tags/end-user.md>), [end-user-device-monitoring](<https://devfeed.tech/tags/end-user-device-monitoring.md>), [file](<https://devfeed.tech/tags/file.md>), [infrastructure-monitoring](<https://devfeed.tech/tags/infrastructure-monitoring.md>), [monitor](<https://devfeed.tech/tags/monitor.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [network-device-monitoring](<https://devfeed.tech/tags/network-device-monitoring.md>), [networks](<https://devfeed.tech/tags/networks.md>), [problems](<https://devfeed.tech/tags/problems.md>), [root-cause-analysis](<https://devfeed.tech/tags/root-cause-analysis.md>), [tickets](<https://devfeed.tech/tags/tickets.md>), [trace](<https://devfeed.tech/tags/trace.md>), [troubleshoot](<https://devfeed.tech/tags/troubleshoot.md>), [user](<https://devfeed.tech/tags/user.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

Datadog End User Device Monitoring extends the Datadog Agent to employee laptops and workstations, bringing device health, application activity, and network context together so IT can identify emerging fleet-wide issues and investigate before employees report them. Its Command Center groups related findings into issue cards ranked by severity, with root-cause evidence, diagnostic history, and suggested next steps; Bits Investigation updates cards as issues spread and links relevant past investigations. Network Path traces real traffic hop by hop to SaaS applications, helping locate connection degradation. In the article's example, this pinpointed a congested branch access point, allowing IT to move employees temporarily and the Network team to adjust its configuration. Teams can continue analysis in Bits Chat and coordinate incidents, workflows, notifications, and linked Jira or ServiceNow work; Datadog Work Management keeps investigation and task history synchronized. Command Center is described as in preview, while EUDM is stated to be generally available.

### Source excerpt

Catch degrading devices before employees file tickets, trace issues across devices and networks, and resolve recurring problems with Datadog End User Device Monitoring.

## Tracing Business Operations, Not HTTP Calls -- Part 2

DevFeed: [Tracing Business Operations, Not HTTP Calls -- Part 2](<https://devfeed.tech/articles/tracing-business-operations-not-http-calls-part-2-88054.md>)

Original publisher: [Read original article](<https://proandroiddev.com/tracing-business-operations-not-http-calls-part-2-517ba3b6f228?source=rss----c72404660798---4>)

Author: Damian Petla | Tilt

Published: 2026-10-15T17:06:30Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [tracing](<https://devfeed.tech/topics/tracing.md>), [OpenTelemetry](<https://devfeed.tech/topics/opentelemetry.md>), [Grafana](<https://devfeed.tech/topics/grafana.md>), [end user device monitoring](<https://devfeed.tech/topics/end-user-device-monitoring.md>), [Production Engineering](<https://devfeed.tech/topics/production-engineering.md>)

Tags: [business-operations](<https://devfeed.tech/tags/business-operations.md>), [distributed-tracing](<https://devfeed.tech/tags/distributed-tracing.md>), [grafana](<https://devfeed.tech/tags/grafana.md>), [graphql](<https://devfeed.tech/tags/graphql.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [mobile-development](<https://devfeed.tech/tags/mobile-development.md>), [observability](<https://devfeed.tech/tags/observability.md>), [opentelemetry](<https://devfeed.tech/tags/opentelemetry.md>), [tracing](<https://devfeed.tech/tags/tracing.md>)

### AI overview

The trace root is a bounded business operation, such as placing a bid, rather than an individual HTTP call. In Tilt's Kotlin Multiplatform pipeline, developers opt in by passing a typed operation to the terminal; pipeline sources and an Apollo interceptor then capture operation, network attempt and HTTP spans, with W3C traceparent linking backend spans into Grafana Tempo. Streams trace setup through the first real combined state, while per-emission tracing is deferred; WebSocket connections use standalone roots. The article describes practical alpha SDK workarounds, including handling exporter failures, replacing a thread-unsafe batch processor and using a server-synced clock. Production tracing is feature-flagged and enabled by user cohort without device sampling; root status distinguishes recovered retries and cancellation from failures. The author reports that traces exposed network, WebSocket, backend and stale-state issues, while noting older app versions emit no traces.

### Source excerpt

Part 2 of 2. Part 1: Everything Is a Source covers the small pipeline framework this tracing is built on. When a user at Tilt says "my bid didn't go through", what actually happened? The app read the current user, sent a GraphQL mutation, maybe retried it, maybe refreshed a token, and the backend called two more services. Before this summer I could see pieces of that in different tools, but never the whole thing as one story. This article is about how I designed and shipped mobile distributed tracing for Tilt's Android and iOS apps, using OpenTelemetry in a Kotlin Multiplatform module and Grafana on the other end. The short version: the trace root is the business operation, not the HTTP call, and because of the pipeline from Part 1, opting a function into tracing costs one argument: .buildOnce(ShopperTracedOperation.MakeBid(roomId, auctionId, bidValue)) The longer version includes an alpha SDK, a coroutine context that will not move, and a few bugs that nobody would have found without traces. What I could not see Tilt is a live shopping app. Sellers run live auctions, and an auction often lasts only a few seconds. If placing a bid hangs, the bid does not count, and the user does not care whether it was their network, the app or the backend. When complaints like "the auction froze" came in, diagnosing them was slow and largely guesswork. The app had a small per-request performance tracker that emitted start, end and error events. It was a flat list of timings: no parent and child, no trace ID, no link to anything the backend saw. And by then nothing was consuming it anyway. The deeper problem was the unit of measurement. In the shared module, business operations live in repositories, and a single repository function often combines several queries and subscriptions. Tracing each GraphQL operation on its own would give me accurate numbers for the wrong thing. Tracing a whole app session would give me one giant trace that nobody can investigate. So the goal became: one

## Platform teams should think tracing first

DevFeed: [Platform teams should think tracing first](<https://devfeed.tech/articles/platform-teams-should-think-tracing-first-61229.md>)

Original publisher: [Read original article](<https://platformengineering.org/blog/platform-teams-should-think-tracing-first>)

Author: Kaspar von Grünberg

Published: 2026-09-28T09:18:07Z

Content type: article

Language: en

Sources: [Platform Engineering Blog](<https://devfeed.tech/sources/platform-engineering-blog.md>)

Topics: [tracing](<https://devfeed.tech/topics/tracing.md>), [Platform Engineering](<https://devfeed.tech/topics/platform-engineering.md>), [end user device monitoring](<https://devfeed.tech/topics/end-user-device-monitoring.md>), [autonomous software teams](<https://devfeed.tech/topics/autonomous-software-teams.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [observability](<https://devfeed.tech/tags/observability.md>), [platform-engineering](<https://devfeed.tech/tags/platform-engineering.md>), [tracing](<https://devfeed.tech/tags/tracing.md>)

### AI overview

Platform teams have traditionally prioritized logs and metrics because they are cheaper to adopt, while tracing requires code changes and context propagation across services. As platforms serve more autonomous teams and AI agents, the article argues tracing should be a default observability capability: traces follow requests across team boundaries, whereas dashboards and logs assume a human reader can connect the signals. It frames tracing as a platform architecture decision and says the piece offers two tests for evaluating vendors.

### Source excerpt

Discover why platform teams must prioritize tracing to support autonomous teams and AI coding agents across complex engineering architectures.

## Latency percentiles are not additive

DevFeed: [Latency percentiles are not additive](<https://devfeed.tech/articles/latency-percentiles-are-not-additive-25907.md>)

Original publisher: [Read original article](<https://chao2zhang.medium.com/latency-percentiles-are-not-additive-4f306ced9cd6?source=rss-d19045640fe------2>)

Author: Chao Zhang

Published: 2023-10-07T17:02:37Z

Content type: article

Language: en

Sources: [Chao Zhang](<https://devfeed.tech/sources/stories-by-chao-zhang-on-medium.md>)

Topics: [Latency](<https://devfeed.tech/topics/latency.md>), [end user device monitoring](<https://devfeed.tech/topics/end-user-device-monitoring.md>), [Cache](<https://devfeed.tech/topics/cache.md>)

Tags: [app-development](<https://devfeed.tech/tags/app-development.md>), [backend](<https://devfeed.tech/tags/backend.md>), [caching](<https://devfeed.tech/tags/caching.md>), [client](<https://devfeed.tech/tags/client.md>), [latency](<https://devfeed.tech/tags/latency.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [network](<https://devfeed.tech/tags/network.md>), [observability](<https://devfeed.tech/tags/observability.md>), [perceived-latency](<https://devfeed.tech/tags/perceived-latency.md>), [performance](<https://devfeed.tech/tags/performance.md>), [production](<https://devfeed.tech/tags/production.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [tracing](<https://devfeed.tech/tags/tracing.md>)

### AI overview

Adding the p90 latencies of sequential requests does not determine the feature's p90: the combined percentile depends on how request latencies align across users. In the example, two requests each have p90 of 910 ms, yielding a naive 1,820 ms sum; with 128 ms average network latency, the excerpt gives 1,948 ms for a pessimistic case and 1,228 ms when high latencies fall on different users. Client processing and hard-to-measure network delay also affect perceived latency, and caching or skipped requests add further nuance. Treat percentile sums as indicative rather than conclusive; measure and trace end-to-end latency from the client in production.

### Source excerpt

Generated from https://mage.space/ When we are estimating the latency spanning multiple requests on the backend, we tend to use napkin math to add 90th percentile (p90) of those requests and use their summation as the estimation. However, the summation is often too pessimistic and follow me to understand why that is the case. In this simplified example, we have a UI feature displayed on the client after request A and request B are completed. Request B depends on request A, so they are sequential. The illustration of perceived latency with Request A and Request B We have backend latency p90(Request A) = 910ms, and p90(Request B) = 910ms, so we conclude the feature latency to be p90(Feature) = p90(Request A) + p90(Request B) = 1820ms. The above math is common in the latency analysis of our engineering requirement document. What did we miss here? A few points: Client logic: Client code does have non-trivial complexity. Regardless of iOS or Android, any caching layer, data transformation layer and view layer could add latency at the magnitude of 100ms or more. Network latency: The device needs to be connected to Home Wifi or 5G network, and then hit the nodes through ISP, CDN, Data Center and eventually reached our application server. These are perceived by the end user but very difficult to measure. Latency percentiles are not additive: p90(Request A and B) ≠ p90(Request A) + p90(Request B) Let's assume our feature has 10 end users from Alice to Jessica. And let's ignore client logic and estimate the network latency to be 128ms (Average of 2 RTT from US West to US East). In the most pessimistic case (napkin math pitfall!), Alice has the lowest backend latency for both requests and Jessica has the highest latency for both requests. p90(Request A and B) is 1948ms = p90(Request A) + p90(Request B) + avg(network latency) = 910ms + 910ms + 128ms. In the most optimistic though, Alice has the lowest backend latency for request A but the highest backend latency for request B,