February 2023 Summaries

The author of this text is an engineer who emphasizes the importance of treating application performance like a feature. He shares his experience with using Sentry, a tool for monitoring and analyzing performance issues, to transform vague problems into concrete, actionable ones. The author argues that users care deeply about performance and notice even small improvements. To prioritize performance effectively, he recommends transforming abstract woes into concrete issues, defining and contextualizing user pain, and elevating ad-hoc decision-making to contractual obligation through processes and tests.

The new cloud data gathering feature for Sentry's Python SDK allows users to obtain detailed information about the region and hosting environment of their cloud services when an issue occurs, enabling them to quickly identify potential issues and make informed decisions about their distributed services. This feature is now available to everyone using the Sentry SDK, building on inspiration from OpenTelemetry SDKs, and provides a valuable tool for both cloud veterans and newcomers alike.

Sentry’s Frontend Tests: Migrating from Enzyme to React Testing Library` is a story of how Sentry, a company that practices continuous delivery and automates testing for its large React codebase, successfully migrated its frontend tests from Enzyme to React Testing Library (RTL). The migration took over a year and four months, involved contributions from 17 engineers, and spanned 803 test suites and 4,937 tests. The team evaluated the benefits of using RTL, including improved accessibility, better performance, and enhanced testing capabilities. They also encountered challenges such as poor performance when using certain queries and missing ARIA roles on elements. Despite these obstacles, the team persevered and eventually completed the migration with 644 files converted to use RTL at the time of completion. The successful migration has improved Sentry's frontend tests and made them more confident in their testing process.

Sentry has announced its support for OpenTelemetry (OTel), an open standard for observability, allowing developers to capture and make their data actionable with Sentry's modern Application Performance Monitoring (APM). With support now available for Golang, Node.js, Python, Ruby, Java, and .NET, developers can combine the power of Sentry with performance data from OpenTelemetry instrumented applications. This integration enables users to get down to the line of code or function causing issues quickly, without sifting through data or switching between tools. By adding a few lines of code, developers can start tracing slow-loading pages and request, identifying errors, and getting context to fix problems rapidly.

Third-party JavaScript libraries and SDKs provide developers with tools to build modern web experiences, Sentry's Next.js SDK now supports Vercel's Edge runtime, allowing developers to monitor their applications in real-time, identify issues quickly, and resolve them faster. The new feature enables visibility into applications running on Vercel's Middleware and Edge routes, giving developers confidence to build and deploy applications in the edge environment with ease. To get started, simply add a sentry.edge.config.js or sentry.edge.config.ts file to your project, following instructions found in Sentry's GitHub Issue and manual setup docs.

Sentry has launched Session Replay, a tool that helps developers troubleshoot difficult-to-reproduce problems by providing video-like reproductions of user sessions on their web applications. This feature bridges the gap between code and user experience, allowing developers to understand how issues manifest in the UI. Unlike other session replay products, Sentry's approach prioritizes sampling sessions when users encounter errors, ensuring that developers have access to relevant data quickly. The tool also provides strong privacy protections, masking sensitive user data and applying project-level settings like PII scrubbing and IP redacting. By using Session Replay, developers can reproduce and resolve issues faster, fix slow performance-related problems, and triage issues with confidence, ultimately saving time and resources for their teams.

Get started with Jetpack Compose`, a declarative UI toolkit by Google, allows building native Android apps. It's gaining traction, with 160 of the top 1,000 Android apps using it. The main advantage is concise and easier-to-understand UI code, leading to improved maintainability and reduced development time. However, its ecosystem is still limited compared to traditional XML Views. To get started, use Android Studio, create a new project, or enable Jetpack Compose in an existing app. Build UI using composable functions that describe how the UI should look and behave, with modifiers changing visual appearance and behavior. Interact with data using MutableState, LiveData, or StateFlow, which make composables re-render when value changes, making UI dynamic. Organize code for maintainability, avoid "god" files, and follow MVVM architecture to separate business logic from UI. Monitor errors and performance in production with tools like Sentry to ensure a bug-free app. With its growing ecosystem and adoption by companies like Lyft and Twitter, Jetpack Compose is becoming an essential tool for Android developers.

Sentry has moved its Profiling feature for Python and Node.js SDKs to beta, making it free to use while in beta, with plans to reach general availability later. Profiling helps catch performance bottlenecks by providing exact file/line number information, allowing developers to optimize code and improve application performance. Recent updates include support for `gevent` and improved transaction profiling, as well as enhancements to the user experience, such as linking from functions in the flame graph to GitHub code and visualizing spans from transactions on the flame graph. Early customers have found Profiling to be a valuable tool when used alongside Sentry Performance, which identifies slow-running database queries and external calls. With Profiling, developers can correlate profiles with transactions, identify root causes of slow requests, and quickly fix them.

Profiling is a crucial tool for developers to ensure their code meets performance goals, and it's especially important in production where predicting slow lines of code can be challenging. Profiling tools capture a snapshot of resource usage, known as a profile, which allows developers to directly map resource usage to specific lines of code. While tracing is another performance monitoring tool that tracks the flow and timing of requests, profiling provides more granular information about internal issues causing slowdowns. There are different types of profilers, including ad hoc, continuous, and transaction-based profiling, each with its own strengths and weaknesses. Profiling can be done continuously, ad hoc, or in a hybrid manner, and it can have varying levels of performance overhead depending on the approach used. Deterministic and sampling profilers collect profiles differently, with deterministic profilers capturing all function calls and exception events for accuracy, while sampling profilers prioritize performance by collecting samples at regular intervals. Overall, profiling is an essential tool for developers to optimize their code and ensure a good user experience.

Profiling is a crucial tool for understanding performance issues in production, providing granular details about code hotspots that can help developers identify and fix problems. Modern profiling tools have advanced significantly since their inception, offering low overhead and continuous data collection, making them suitable for production use. Unlike system metrics, logging, and tracing alone, which provide only a partial view of performance, profiling offers detailed insights into specific lines of code, facilitating accurate diagnosis and resolution of issues. By leveraging profiling in conjunction with other tools like tracing, developers can gain a comprehensive understanding of their application's performance and make data-driven decisions to optimize its performance.

The Sentry team has implemented support for local variables in the Node.js SDK, allowing developers to include variable values in stack traces sent to Sentry, providing a closer debugging experience. This feature was made possible by leveraging Node's inspector API, which allows interaction with a running Node.js process and its environment, including the call stack, heap, and runtime information. The team has implemented a caching mechanism to ensure that local variables are attached to the correct error event, even when errors pass through the Sentry event pipeline before all variable values are returned. With this feature, developers can now reproduce issues locally with a debugger attached and have access to local variable data in their stack traces on Sentry events, making it easier to identify and fix reported errors.