Mobile engineering teams who use crash reports to resolve issues in their apps often struggle with identifying code ownership. When you’ve got hundreds — perhaps thousands — of crashes across multiple versions of an app, how do you figure out who is responsible for what?
Historically, this has been a tedious, manual process, largely relying on individual devs parsing through lists of crashes and combing through stack traces to spot the sections of code they’re responsible for. For enterprise orgs with large teams and multiple apps, this process isn’t just frustrating, but a significant drain on resources.
Embrace’s new Mobile Crash Owners feature now solves the headache of code ownership among large teams.
Mobile Crash Owners makes identifying code owners easy
Mobile Crash Owners, a first-of-its-kind feature, lets engineers apply their own code-ownership rules to the crashes Embrace captures, and automatically “tags” them according to your predefined rules.
Mobile engineering orgs can create rules to “tag” an individual person, a team, or even a company — making it easier than ever to understand if a third-party SDK or advertiser, for example, is at the root of your app’s crashes.
With Crash Owners by Embrace, engineers no longer have to fish through every crash to understand which ones they should be focused on. This manual work has been automated by our SDK and underlying data infrastructure, saving devs time and letting them focus on actually resolving the issue, not just claiming it.
How Embrace Mobile Crash Owners works
Embrace’s Mobile Crash Owners feature works out of the box with Github’s code-owner tagging rules. Engineers can extract their CODEOWNERS file from their Github repository and upload it directly to Embrace.
Embrace has a CODEOWNERS upload endpoint, where apps can POST their file with a “search_term” and a “tag.” Embrace tagging rules follow the Github documentation on file format. When a crash is captured by our SDK, Embrace will review the affected crash stack frames within each stack trace and compare these frames to the mapping rules in the CODEOWNERS file. For any frames that match code-owners rules, Embrace will tag these with the appropriate, designated owner.
To provide high-level visibility across codeowners, Embrace will roll up any matching code-owner stack frames to the crash level and then the group level to know which crash group they are tagged in.
Embrace then provides this data as an hourly metric count of crashes by crash group, by tag. Users can see this data directly within the Embrace dashboard via our Crash Summary view. Tagged crashes can also be viewed as Custom Metrics, which can be sent to external sources via our Metrics Forwarding API.
As code changes, apps can update their tagging rules on-demand by simply POSTing the latest version of their CODEOWNERS file. Each upload will overwrite the previous rules, and crashes will be tagged on a go-forward basis with the new rules.
The Github code-owners format is supported out of the box, but other crash tagging formats can also work with some custom instrumentation.
Why engineers love Embrace Crash Owners
In addition to spotting their tagged crashes, mobile engineers can also filter crashes by a specific tag or tag pattern. For example, engineers can filter crashes that were tagged as belonging to a specific ad SDK, or even isolate third-party-only crashes vs. true source code crashes.
Teams can also surface overlapping tags in the Crash Summary view on the dashboard. This provides an overview of all crash tags and allows for a bottoms-up approach to prioritizing and fixing crashes based on the ones that span across multiple engineers’— or even multiple teams’ — code.
Embrace takes an opinionated approach to how we present crash tagging data to provide as much directional insight as possible. If any frame in a crash’s stack trace matches a rule and is taggable, we tag it. However, we only roll up tags from the grouping frame, or the frame identified as the one causing the crash, and present that in your dashboard.
Build better mobile experiences with Embrace’s Mobile Crash Owners
Getting set up with Crash Owners is easy if you’re an Embrace customer. Use our API to upload your code owners file from Github. You should start seeing crashes tagged based on your custom rules as our SDK captures them from user sessions, and you’ll be able to view these in the dashboard or consume via our Metrics API. Check out our docs for more information.
New to Embrace? Learn more about Code Owners and how Embrace can help you build better mobile experiences by requesting a demo today.