November 2022 Summaries

When Codecov joins the Sentry family, it aims to leverage its test analytics capabilities to enhance application monitoring, focusing on making developer productivity more efficient. Both companies share a common goal of building developer-first tools that prioritize user experience and code reliability. By integrating Codecov's features with Sentry, users can expect improved issue detection, enhanced test suite analysis, and continued innovation in both products. The long-term vision is to bring the two offerings together in a cohesive story while maintaining independent value for each product.

Sentry has recently improved its JavaScript stack traces by introducing JavaScript Source Scopes, which parse the original code to reconstruct source scopes and resolve scope information via source maps. This approach is more effective than relying solely on source maps, as it allows for better decisions on function names and surrounding context. The new implementation also handles anonymous callback functions, class methods, and object literal properties more accurately. As a result, stack traces are now easier to read and understand, with improved function names and additional contextual information such as class names.

Measuring application performance in Swift using Sentry's Custom Instrumentation allows developers to track big data-handling functions, measure metrics like throughput and latency, and display error impacts across multiple services. By setting up performance monitoring, developers can configure trace sample rates and implement custom transactions to measure specific function execution times. Child spans enable more granular measurement by attaching mini-transactions to the main transaction, allowing for detailed analysis of individual steps within a function. Additionally, binding transactions to the current scope enables measuring complex functions with multiple branches. With Sentry's Custom Instrumentation, developers can gain insights into their app's performance and improve it by identifying slowest parts of the code.

The Sentry team has announced the alpha release of Python profiling for WSGI applications, which provides code-level insights into application performance in production. The profiling tool is free to use while in alpha and allows developers to set a sampling rate on the SDK. To get started with Python profiling, simply set the `profiles_sample_rate` parameter when initializing the Sentry SDK. The profiling tool captures samples at a frequency of ~100Hz and sends them to Sentry for visualization as flame graphs. Flame graphs enable users to quickly spot hot code paths and optimize resource consumption. The Sentry team has also optimized their own application using Python profiling, identifying performance bottlenecks such as parsing dates in the `zerofill` function, which was improved by switching to a faster date parsing method. Additionally, the team identified an issue with Django's prefetch_related technique causing slow queries, which they were able to optimize by manually fetching related objects and constructing the response. The Sentry team emphasizes that profiling complements performance by providing detailed line-level information to fix performance issues.

We have successfully set up and utilized the @sentry/profiling-node package for Node.js, leveraging Sentry's Performance product to profile our code and identify performance bottlenecks. By setting a sampling rate and instrumenting our services with Sentry, we can collect profiles that provide granular insights into execution time, allowing us to pinpoint slow functions and optimize code. Through profiling, we were able to find issues in test setup code and optimize it without impacting developer experience, as well as identify performance problems outside of our service, such as memory leaks in a third-party library. By enabling profiling, we can halve p75 durations and improve user experience or provide faster feedback loops for developers. With Sentry's Performance product providing the logical next set of information to resolve performance-related issues, we have seen success finding optimization opportunities in all Node.js based projects where profiling was added.

We run our Python tests in hundreds of environments really fast by using a combination of tools such as pytest, Flake8, black, mypy, Tox, GitHub Actions, and scripting to optimize the test suite's performance. We initially ran the tests sequentially, which took 40 minutes, but then implemented changes that allowed us to run the tests in parallel, reducing the time to around 10 minutes. These improvements were achieved by splitting up the test suite into smaller frameworks, using Tox's `--parallel` command, and creating separate GitHub Actions workflows for each framework. Additionally, we removed unused tools from our workflow and started logging slow tests to identify areas for further optimization.

Python 3.11 was released on October 24th, 2022, bringing several improvements that make Python faster and more user-friendly. The new version includes a faster execution speed, with some benchmarks showing a 25% speedup compared to the previous version. Additionally, Python 3.11 introduces new features such as tomllib, asyncio's task groups, improved exception handling, typing improvements, including Self type, variadic generics, LiteralString, Never, assert_never, and assert_type. These enhancements aim to make Python more efficient, easier to use, and provide better support for developers.

Sentry recently launched its Performance Issues feature, which helped discover and fix common performance problems in projects. The team tested the feature internally and with alpha users before turning it on for all Sentry users. When they did, they found an N+1 issue in the code of djangoproject.com's docs version switcher that was causing duplicate issues. The issue was fixed by changing a line of code to use `select_related` instead of `filter`. This change simplified the query and resolved the problem. The feature can currently detect N+1 issues in all Sentry-supported backend languages, including Python, and automatically detects slow transactions and spans that could be bottlenecks in an application. Developers can learn more about performance monitoring with Sentry by checking out its documentation.

This is a major overhaul of Sentry's Performance Monitoring product, introducing Dynamic Sampling which moves beyond traditional static, magic number sampling, offering flexibility and reducing configuration complexity. The new approach aims to maximize the value of all data seen by Sentry, with intelligent decisions on baseline sample rates and adaptive sampling to capture more value when it makes sense. This change has significant implications for pricing and packaging, as the value of a stored event is enormous but the value of the total stream of data is minimal, requiring a fundamental shift in the business model. The feature is currently available to new customers and will be rolled out to existing customers with opt-in options, offering transparency and controls to influence sampling decisions.