February 2022 Summaries

We trimmed the Sentry JavaScript SDK file size by 20% through a multi-faceted approach that involved improving release stability, conducting thorough testing, and implementing targeted optimizations such as reducing un-minifiable public class declarations, removing unnecessary TypeScript enums, and consolidating duplicate code. By achieving measurable success with minimal disruption to users, we now have a solid foundation in place to further optimize the SDK's performance, including tree-shaking support, async loading, and internal refactorings.

The engineers at Athenian optimized their Python API server code by 100x, achieving a significant performance boost. They focused on optimizing coroutines, groupby operations, and data serialization. By ordering arguments in `asyncio.gather()` according to expected IO wait time, they reduced execution times. Using shared filters in SQLAlchemy Core improved query performance. Custom construction of Pandas DataFrames from `asyncpg.Record`s eliminated unnecessary memory copies. Iterating lists without the Global Interpreter Lock (GIL) in Cython increased speed by 10x. Zero-copy serialization using a structured numpy array array wrapper provided at least 10-50x performance improvement compared to pickle and storing fields in individual SQL table columns. Replacing pandas' groupby with pure numpy operations reduced execution times by 20-50x, depending on the dataframe size and column values. These optimizations enabled Athenian's analytics backend to process hundreds of thousands of items in milliseconds, achieving a remarkable 1000x performance improvement over their initial MVP codebase.

The .NET plugin model is plagued by assembly loading conflicts due to the complex history and rules of assembly loading in .NET, which makes it difficult to load multiple versions of the same assembly into a shared context. This issue affects Unity Package Manager (UPM) packages that bundle System DLLs with different versions, causing conflicts when used together. The Sentry SDK for .NET is one such package that requires a solution to resolve these conflicts. After considering existing options like Costura and ILMerge/ILRepack, the developers of the Sentry SDK created a new tool called Alias, which performs the following steps: renaming dependencies with unique keys, patching references in target assemblies and dependencies, and producing a group of files that will not conflict with any assemblies loaded in the plugin context. The tool is shipped as a dotnet CLI tool and can be used to resolve conflicts in UPM packages, including those from Unity.

The .NET plugin-based model, also known as the "add-in" or "extension" model, allows extension or customization of functionality by adding assemblies and config files to a directory that is scanned at application startup. However, this approach can lead to assembly conflicts due to the complex rules of assembly loading in .NET. The Sentry SDK for Unity experienced issues with UPM packages bundling the same DLLs, often with different versions, causing conflicts. To resolve these issues, the development team created a new tool called Alias, which performs the following steps: renaming dependencies with unique keys, patching references in target assemblies and dependencies, and resulting in a group of files that will not conflict with any assemblies loaded in the plugin context. The Alias tool is shipped as a dotnet CLI tool and can be used to resolve conflicts in UPM packages. Additionally, there is a draft proposal for Package shading on NuGet, which could potentially solve similar assembly conflict issues in the future.

The author of this article is a firmware engineer with experience working with health and wellness startups, who has implemented error tracking for a React-Native app using Bluetooth Low Energy (BLE). The author uses Sentry.io to track errors, including connection failures, streaming failures, and invalid sensor data. The implementation involves logging errors with relevant information such as error codes, names, firmware versions, and build numbers. The Sentry dashboard allows the firmware team to visualize the data in a digestible form, enabling them to debug issues more effectively.

To address the issue of tracking stability in Bluetooth Low Energy (BLE)-based React-Native apps, it's essential to forward error information from the device to an error tracking service. This can be achieved by using a library like react-native-ble-plx and integrating it with Sentry.io for error tracking. The app can track connection failures, streaming failures, and invalid sensor data by capturing events in Sentry and adding relevant information as tags or extras. By building dashboards in Sentry, the team can visualize errors and other analytics to help them debug issues more efficiently.

Sentry will be attending the Game Developers Conference (GDC) in San Francisco, CA, with a variety of activities including a speaking session on mobile game development, an expo floor exhibit, and a booth where attendees can meet with Sentry team members to discuss their game development issues. Sentry's event at GDC aims to help developers see what matters most in their games, solve problems quicker, and learn continuously about their titles. The company will also provide free food and drinks at Joyride Pizza, as well as custom swag for attendees.

Sentry will be attending the Game Developers Conference (GDC) in San Francisco, CA, with a speaking session, networking opportunities, and a booth where attendees can learn about error and performance monitoring for game development. Sentry's representatives will share their expertise on how to improve game development through tailored demos and meet with developers individually to discuss specific challenges. The event will also feature free food and drinks at Joyride Pizza, as well as custom swag for attendees.

We've made updates to Dashboards and Stats to help you get insights into your team's effectiveness and project health quickly, without having to manually build reports. Our new features include out-of-the-box widgets and dashboard templates that can be customized to suit your needs, as well as unlocked issue data for dashboard queries. With these updates, you can easily query issue data to gain deeper insight into your application health and team performance, and measure team effectiveness with issue stats. Additionally, we've made it easier to get started with our widget library and dashboard templates, which provide pre-built solutions to common questions and scenarios. Our goal is to help you spend less time manually building reports and more time learning about your application and team's performance.

We made updates to Dashboards and Stats to help you get insights into your team's effectiveness and project health, including pre-built widgets and dashboard templates, unlocked issue data for dashboard queries, and issue stats that measure developer velocity. These updates include a widget library with popular queries compiled into pre-built widgets that can be added to customized dashboards, as well as customizable dashboard layouts and project-specific custom dashboard templates. Issue data in Dashboards now includes the state of each issue, who it's assigned to, and when it occurred, allowing you to surface the most relevant issues for your team. Issue stats provides a view into developer velocity, helping you uncover potential bottlenecks with metrics such as new issues that happened this week and how they affected the backlog of unresolved issues.

Python's enduring popularity can be attributed to its ease of use, flexibility, portability, and numerous benefits that make it an attractive choice for developers across various skill levels. With a low entry barrier, Python's syntax is simple and easy to learn, allowing novice programmers to quickly grasp the basics. Its dynamic typing feature simplifies programming by reducing the need for explicit variable declarations and indentation, enhancing code readability. Additionally, Python's portability and cross-platform functionality make it an ideal choice for development across different operating systems and devices. The language's flexibility is also a significant factor in its popularity, as it can be applied to various domains such as web development, scientific computing, game development, AI, machine learning, e-commerce, ERP systems, image processing, and graphic design. Python's interpretive nature allows for quick debugging and identification of runtime errors, making it easier for developers to pinpoint and correct issues. Furthermore, its open-source status, extensive support community, and seamless integration with other languages and tools contribute to its widespread adoption. With a robust ecosystem of libraries, frameworks, and online resources, Python provides an attractive alternative for novice developers and startups alike.

Python's enduring popularity can be attributed to its simplicity, portability, flexibility, interpretive nature, ease of debugging, open-source status, robust support structure, and compatibility with other languages, frameworks, and tools. With a low entry barrier, Python is well-suited for novice programmers, offering a gentle learning curve while still providing a wide range of applications and use cases. Its portability allows it to be used across various operating systems, making it an ideal choice for cross-platform development. The language's flexibility enables it to be applied in numerous real-world scenarios, such as web development, scientific computing, game development, and more. Python's interpretive nature and built-in debugging tools make it easier to identify and correct errors, while its open-source status and extensive support community ensure that developers can access a wide range of resources and tools to aid in their work. Additionally, Python's compatibility with other languages and frameworks allows for seamless integration with existing development workflows.

Suspect Spans is a feature in Sentry's performance monitoring tool that helps developers quickly identify slow spans within transactions by surfacing a list of spans where the most time was spent. This feature, along with other tools like Operations Breakdown and Suspect Tags, provides a granular level of detail to help developers solve performance issues. By analyzing these features, developers can pinpoint the exact operations or "work" that are causing slow performance, allowing them to make targeted improvements to optimize their application's performance.

Suspect Spans` is a feature in Sentry's performance monitoring tool that helps developers identify slow spans within a transaction by surfacing a list of spans where the most time was spent, allowing them to quickly pinpoint and address performance issues. This feature complements other tools like `Operations Breakdown` and `Suspect Tags`, which provide different levels of granularity to help solve performance problems. By using `Suspect Spans`, developers can eliminate redundant queries, spot outliers with `Operations Breakdown`, and surface common events that slow down transactions with `Suspect Tags`. This allows them to focus on high-impact transactions and prioritize efforts on issues that impact user experience the most.

The Sentry Android SDK has been updated to automatically capture breadcrumbs for UI events, providing developers with a trail of events that led up to an error, making it easier to reproduce the steps that caused the issue.

In Android applications, Sentry's UI Breadcrumbs feature automatically reports breadcrumbs for activity lifecycle events, system events, HTTP requests, and many more, providing context to errors without requiring developers to recreate the issue. Breadcrumbs are trails of events that occur before an error, containing rich metadata about the application state such as network requests, database queries, or UI events. The Sentry Android SDK version 5.6.0 or above captures breadcrumbs for different UI events like clicks, scrolls, and swipes, with useful metadata like view ID, class, and scroll direction. When an application crashes, it displays both existing breadcrumbs and the trace of UI events that occurred prior to the crash event. To customize this behavior, developers can use the BeforeBreadcrumbCallback or disable UI breadcrumbs through the Android manifest. The feature is already supported in most client SDKs and provides critical context to errors that a stack trace alone cannot provide.

Sentry has integrated its monitoring capabilities with Serverless Stack (SST), an open-source framework for building serverless applications, allowing developers to monitor their entire full-stack app, including errors and performance metrics from Lambda functions. To enable this integration, developers can add Sentry to their SST app by grabbing the DSN, getting the Lambda layer for their region, configuring the function layers and environment variables, and wrapping their Lambda functions with the Sentry Lambda handler. This integration provides critical monitoring capabilities before deploying an SST app to production, making it easier to identify and fix issues, and ensuring a better overall user experience.

Monitoring Lambda functions in an SST application can be easily achieved by integrating Sentry, which provides real-time error tracking and performance metrics for entire full-stack apps. By following a few simple steps, developers can set up Sentry to monitor their Lambda functions, including execution duration and transactions per minute, allowing them to identify issues before going into production. With the integration of Sentry with SST, developers can gain valuable insights into their app's performance and errors, making it easier to optimize and improve their application.