Breadcrumbs
Breadcrumbs — the timeline and the performance-graph pin overlay — is available for Unreal Engine only in this release. The performance-graph pin overlay specifically is in Beta.
Overview
Breadcrumbs is a feature in the ADT Health pillar that surfaces the events leading up to a crash as a structured, filterable timeline — displayed directly on the crash detail page. It is built automatically from the system logs ADT already captures with every crash. No additional setup, configuration, or code changes are required from the game developer.
The timeline is available to anyone who can open a crash report: QA testers, developers, and anyone investigating crashes as part of their workflow.
Why Breadcrumbs Exists
When a crash report arrives in ADT, users can see that a crash happened — but not what the game was doing before it happened. The log data that describes those events has always been captured by ADT, but it was only accessible as raw text in a separate tab. Reading that raw text requires technical knowledge, takes significant time, and forces QA testers to depend on developers for context they could otherwise find themselves.
This creates a predictable bottleneck: QA testers write incomplete bug reports, developers receive follow-up questions they have to answer before they can start debugging, and investigation cycles slow down.
Breadcrumbs removes that bottleneck by turning data that was already there into something every user on the team can read and act on.
How Breadcrumbs Works
When ADT receives a crash report, it parses the system logs captured at the time of the crash and organizes each log line into a typed timeline entry. Each entry is assigned a category based on its content — Error, Warning, Hitch, Game Event, Engine, ADT Activity, or Informational — and sorted by when it occurred.
The resulting timeline appears in the Breadcrumb tab on the crash detail page. The crash event itself is displayed as a distinct marker at the top. Earlier events appear below it in order, with the oldest event at the bottom.
Users control which entries are visible through a filter panel placed above the timeline. The timeline updates immediately when filters change — no page reload required. Users can also search the timeline using a keyword to surface entries that mention a specific term.
For crashes with a long list of entries, the timeline loads additional entries automatically as the user scrolls, rather than requiring a manual "Load more" click.
For crashes from Unreal Engine games, each log entry also appears as a clickable pin on the performance graph on the session details page. This lets investigators correlate specific events with performance changes in a single view, rather than switching between tools.
Key Capabilities
Zero-configuration timeline
Every crash report that has associated log data shows a populated breadcrumb timeline. Nothing needs to be enabled, configured, or instrumented. If a game is connected to ADT and a crash is reported, the timeline appears.
Structured, categorized entries
Each entry in the timeline shows:
- A color indicator and text label for its category (for example, red + "Error")
- A short description from the log message
- How long before the crash the event occurred (for example, "3 minutes before crash")
- Expandable full detail, accessible by clicking the entry
Color and text labels are always shown together, so the timeline is readable for users with color vision impairments. Long log messages are shown in full — in the timeline and in pin tooltips — wrapping across multiple lines rather than being truncated.
Filter panel
A checkbox filter panel above the timeline controls which categories are visible. The default state shows Errors, Warnings, and Hitch entries. Game Events, ADT Activity, and Informational entries are available but hidden by default to reduce noise.
An expandable section below the main filters lists additional log categories found in that specific crash log. Users can enable any of these to surface entries from categories not shown by default.
Filter selections persist while navigating between crash reports in the same browser session, so investigators do not have to reconfigure the filter each time they open a new crash.
Keyword search
A search input above the timeline lets users type a keyword to narrow the timeline to entries whose description matches. Clearing the search restores the full filtered view. Keyword search applies alongside active filter checkboxes — both are active at the same time.
Custom filters
Users can type a keyword or a key=value pair (for example, playerId=bob) into the "Add filter" input to create a temporary filter chip. The timeline immediately shows all entries matching that term. Multiple chips can be active at once. All filters — standard checkboxes, custom chips, and keyword search — use OR logic: an entry is visible if it matches any active filter.
Custom filter chips are cleared when the user navigates away from the crash detail page or refreshes the browser. They survive a filter reset.
Game Events
Log entries that include the keyword ADTGameEvent in the message are identified and displayed as a distinct category — Game Events — with a green color indicator. The name=value pairs in those messages are highlighted to make structured event data readable without parsing raw log text. For example, Event=MissileFireRejected Player=BOT Reason=MissileLimit is displayed with each pair visually highlighted.
Game Events require no new SDK integration. Any existing UE_LOG call that includes ADTGameEvent in the message is automatically surfaced as a Game Event entry.
Performance graph overlay (Unreal Engine) — Beta
Each log entry from a crash session appears as a clickable circular pin directly on its metric line on the session performance graph, positioned at the value and time the event occurred — not in a fixed row above the chart. Pins are color-coded to match the timeline categories. When three or more entries occur within the same one-second window, they collapse into a single pin with a count badge.
Clicking a pin shows a summary of that entry — event category, description, relative timing, and a color-coded dot matching its category — without leaving the graph view. If the pinned entry is the crash itself, the crash event is shown in the popover the same way it appears in the Breadcrumb tab. Clicking a cluster badge opens a list of all entries in that group, each with its own color-coded category dot. Both the single-pin and cluster popovers include a close (✕) button, so users don't have to click outside the popover to dismiss it.
The timestamp shown for an entry is consistent across the pin popover, the crash header, and the Breadcrumb tab — there is no discrepancy between these views.
Users navigate to the session performance graph by clicking the Session ID link on the crash detail page.
Limitations and Considerations
Log quality varies by game. The breadcrumb timeline is only as informative as the logs a game produces. Games that generate rich, descriptive logs will see detailed timelines; games with minimal logging will see fewer entries.
No sensitive data redaction. Log entries are displayed exactly as they appear in the crash log. No automatic removal of player IDs, usernames, or other identifiable information is applied before display. This feature is intended for development environments. Studios with compliance requirements should review their log content before using ADT in environments with sensitive data.
Breadcrumb data is read-only. Users cannot add annotations, notes, or edits to individual entries. Entries reflect the original log content only.
No cross-session timeline. The breadcrumb timeline shows events from the specific crash session being viewed. Log entries from other sessions — even sessions from the same game build — are never included.
Unreal Engine only. Breadcrumbs — both the timeline and the performance-graph pin overlay — is available for Unreal Engine games only in this release. Unity is not yet supported.
Historical crashes are supported. The log format used by ADT has not changed, so the breadcrumb timeline works for crash reports recorded before this feature was deployed — not only for new crashes.
No API access in V1. Breadcrumb data is only available through the ADT web UI in V1. Programmatic access via the ADT API is planned for a future release.
Supported Platforms
| Engine | Timeline | Timestamps | Performance graph overlay |
|---|---|---|---|
| Unreal Engine | Full support | Yes (UTC) | Yes |
| Unity | Not yet supported | — | — |
Breadcrumbs is available for Unreal Engine only in this release. Unity support is not yet available.
How Entries Are Categorized
Each log entry is assigned to exactly one category. The assignment follows a priority order:
| Priority | Rule | Category |
|---|---|---|
| 0 | Message contains ADTGameEvent | Game Event |
| 1 | Message matches an engine lifecycle event (for example, a map load or world-ready notification) | Engine |
| 2 | Message contains [HitchDetector] | Hitch |
| 3 | Severity is Fatal: or Error: | Error |
| 4 | Severity is Warning: | Warning |
| 5 | ADT activity log entry (no higher rule matched) | ADT Activity |
| 6 | All other entries | Informational |
ADT activity entries are identified by the LogBlackBox: prefix.
An ADT activity entry that carries an Error or Warning severity is categorized as Error or Warning — severity takes priority over log source.