Unreal Engine crash reporting now available on gaming consoles with trace-connected logs
Unreal Engine crash reporting now available on gaming consoles with trace-connected logs
With the first major release of the Sentry Unreal SDK (now on v1.2.0, and you can also explore in our interactive sandbox), we’ve made some important improvements to support cross-platform Unreal developers when it comes to platform coverage, debugging with user feedback, and performance monitoring improvements . Here’s what’s new:
Gaming console support
The Sentry Unreal SDK now uses Unreal’s platform extensions to support consoles (Xbox, PlayStation 5 and Nintendo Switch), so you can get the full context on fatal and non-fatal events (including full native crash support) across devkits and retail devices all in one place. You can read more about gaming console support.
Previously, the Unreal SDK’s architecture made adding new platform support complex and error-prone. However, its redesign laid the foundation for adopting the platform extensions (which function almost like plugins) allowing console-specific code to be integrated in a modular way. This allows us to avoid hardcoded references to platform APIs and widespread changes in the core SDK, while also simplifying development and ensuring that low-level implementation details (protected by NDAs) remain properly encapsulated.
Structured logs
Structured logs are now available in the Unreal SDK as well. You can capture and connect log output with errors, crashes, and performance issues in your game. That means when a player gets stuck in a loading screen or a crash occurs right after asset streaming, you’ll have the exact log trail leading up to the failure, accessible directly from the issue or trace view.
Public API changes and new features
Major releases give us a good excuse to rethink our APIs and make the breaking changes we’ve been putting off like...
CI infrastructure improvements
Since our last update on automating plugin builds and testing using GitHub Actions for CI, we've significantly expanded our platform and engine version coverage. A major milestone in this effort is the addition of Windows support, a crucial platform for many Unreal Engine games.
To achieve this, we built our own Linux and Windows Docker images containing Unreal Engine. Official Epic Games Docker images only provide Linux support and are based on older distributions that are difficult to maintain, while Windows Docker images are not available at all.
Beyond that, we've laid substantial groundwork to extend our workflows to include consoles and we'll be sharing more details on that in future engineering blog posts.
User Feedback API
The new User Feedback API provides the ability to collect additional feedback in your own UI when a user experiences an error. It overcomes previous limitations like the requirement for an event ID, offering greater flexibility in submission. The SDK creates the HTTP request so you don’t have to deal with posting data via HTTP:
USentrySubsystem* SentrySubsystem = GEngine->GetEngineSubsystem<USentrySubsystem>();
FString EventId = SentrySubsystem->CaptureMessage("Message with feedback");
USentryFeedback* UserFeedback = NewObject<USentryFeedback>();
UserFeedback->Initialize("Feedback message");
UserFeedback->SetName("Jon Doe");
UserFeedback->SetContactEmail("test@sentry.io");
UserFeedback->SetAssociatedEvent(EventId);
SentrySubsystem->CaptureFeedback(UserFeedback);
// OR
SentrySubsystem->CaptureFeedbackWithParams("Feedback message", "Jon Doe", "test@sentry.io", EventId);To learn more (including how to achieve the same result using blueprint), read the docs.
Performance monitoring
Additionally, performance monitoring has been significantly advanced to support distributed tracing and the sampling of spans and transactions using custom functions. If you have, for example, a complex menu system that’s experiencing performance issues, tracing can reveal whether slowdowns are coming from UI rendering, backend API calls to fetch server lists, or asset loading for character previews, so you can drill into the exact code that’s causing the problem.
One of our most requested features was support for custom attachments like, like config or log files, on desktop platforms. We first implemented this in the underlying SDKs that the plugin relies on and as a result this functionality is now available to users of the Unreal SDK as well. That means that if a crash happens when a player opens a multiplayer lobby, you can attach the server response log to understand what data and state triggered the issue.
New demo and inclusion on FAB
Sentry Tower Defense
It’s crucial to have an appropriate environment to effectively test your game engine SDK. We developed a tower defense Unreal demo game to serve as a reference for developers who are considering integrating Sentry into your game. The demo illustrates how to instrument code with Sentry and gives an understanding of what types of errors can be captured and which data is included in corresponding reports.
Sentry on FAB
To enhance accessibility the latest Sentry SDK plugin is now available on FAB (formerly the Unreal Engine Marketplace). Previously, we maintained two distinct plugin versions - one on GitHub releases and another on FAB - each with unique differences and limitations. We have now unified these offering the same package everywhere, simplifying maintenance for us and providing you with greater flexibility in integrating Sentry.
New SDK structure aligned to Unreal’s standards
Unreal Engine encourages devs to follow its naming conventions and directory structures, especially when it comes to cross-platform development. We aligned the Sentry SDK with Unreal's standards by completely redesigning the internals of our codebase. This included organizing source files into platform-specific directories and re-naming most of the existing scripts/classes.This approach significantly reduces the complexity of certain parts of the SDK. For instance, instead of relying on awkward #if PLATFORM_X preprocessor directives to wrap platform-specific code, we switched to using proper abstractions and common interfaces:
// ------- Before
#if PLATFORM_ANDROID
#include "Android/AndroidSentrySubsystem.h"
#elif PLATFORM_APPLE
#include "Apple/AppleSentrySubsystem.h"
#elif PLATFORM_DESKTOP
#include "Desktop/DesktopSentrySubsystem.h"
#endif
...
#if PLATFORM_ANDROID
SubsystemNativeImpl = MakeShareable(new SentrySubsystemAndroid());
#elif PLATFORM_IOS || PLATFORM_MAC
SubsystemNativeImpl = MakeShareable(new SentrySubsystemApple());
#elif PLATFORM_DESKTOP
SubsystemNativeImpl = MakeShareable(new SentrySubsystemDesktop());
#endif
// ------- After
#include SENTRY_COMPILED_PLATFORM_HEADER(SentrySubsystem.h)
...
SubsystemNativeImpl = MakeShareable(new FPlatformSentrySubsystem());Getting started with the Sentry Unreal SDK
Getting set up is quick. Drop in the plugin, connect your project, and start seeing what’s actually happening behind your game’s loading screens and frame drops.
Have questions or feedback?
Join the conversation in our Discord
Email us at gaming-updates@sentry.io
New to Sentry? Try Sentry for free.
