Development / Monitoring / Tools

Sentry Digs Deeper into Google’s Web Performance Metrics

30 Dec 2020 11:20am, by

Application monitoring platform provider Sentry is building on Google’s recent release of Web Vitals to further enhance its own performance monitoring stack.

Sentry’s application monitoring was designed to see “whether an issue is a meaningful error or performance issue, and reveals to developers how their code is doing as the user experiences it,” Sentry CEO Milin Desai told The New Stack. “Google’s Web Vitals establishes a clear measuring stick for the industry to gauge what is ‘best-in-class’ performance.  We’re one of the first to support this standard for performance monitoring, and integrate it into our already resolution-oriented error monitoring.”

Web Vitals offers a good first step for gauging web and mobile application performance, and specifically, the time it takes to access an application or user interface (UI) on the web. As a key metric, the Web Vitals’ threshold for acceptable page loads is that at least 75% of all users can download an application’s web page or API in four seconds or less. Again, this is a solid first step in helping to gain insight into web and mobile application performance and accessibility, but at the same time, it does not pinpoint problems specific users may have.

Sentry Performance Monitoring expands on Google’s Web Vitals by extending the sub-par four-seconds-or-less time it takes for a web interface or user interface (UI) objects to load. It does this by monitoring an individual user’s experience, as well as other data points, the company said. The key metrics that Sentry Performance draws from Web Vitals for transaction data include how slow transactions impact individual user experiences and how often slow transactions are experienced, for example.

A major customer may, for example, report poor speeds and access for your application’s transaction-completion speeds, while Web Vitals might merely show that over 90% of all users’ page load and transaction-completion speeds are lightning fast.

“From consumer products to financial institutions, customers now expect a seamless product experience as the minimum bar. But while expectations for frontend experiences have risen, developer tools to deliver a perfect experience are incomplete,” Desai said. “Engineering teams are often still using a dozen tools at once and don’t have time to instrument a host of systems graphs and backend tools to diagnose problems — end customers don’t care if it’s errors or inefficient code that are causing the issues, but developers still need best-in-class products to address both of these problems.”

With Sentry’s Performance tool for Web Vitals, Sentry’s monitoring capabilities are thus extended to scan and detect these problems that display the detailed data behind Web Vitals metrics. Specific metrics provided cover network speeds, regions and devices, the company said.

Sentry has also extended its monitoring capabilities for PHP, Node, Ruby and serverless applications, reflecting how the company seeks to offer monitoring capabilities for code unique to specific programming languages, which also include Python, JavaScript and others. While some proponents of observability may, for example, argue that observability platforms could render monitoring obsolete, Desai countered that “we see observability as a new term for an old problem that has existed for quite some time — but much of this trend is still not solving the whole problem, which is still about code health.”

“Sentry helps complete the observability picture by bringing developers and code to the systems operations stack,” Desai said. “With an increasing number of digital services and applications over the past few years, the amount of code being generated is skyrocketing and updating frequently. But while systems, machines and databases are being monitored, code is often the layer that is least monitored.”

Code monitoring is thus needed to fill gaps with the observability stack, Desai said. “Developers are increasingly taking ownership of their code in production,” Desai said. “Connecting the creators of code to those who consume it will improve application health and provide for better user experiences, ensuring those who incorporate code monitoring into their observability stack have a competitive advantage.”

Sentry is a sponsor of The New Stack.

A newsletter digest of the week’s most important stories & analyses.