Bugsnag: What It Is, Error Tracking and Data Collection

What is Bugsnag in Development

Bugsnag is an application stability monitoring platform founded in 2013 and acquired by SmartBear in 2019. The main difference between Bugsnag and its competitors is its focus on stability as a key product metric, rather than just error counts. The platform provides a unified dashboard for iOS, Android, React Native, Flutter, web and backend services.

Each error in Bugsnag receives an automatic severity rating (critical, warning, info) based on context: whether a crash occurred, whether a payment function was affected, or whether the error recurs for many users. The team sees not just a list of bugs, but a prioritized backlog indicating business impact.

According to SmartBear (2024), teams using Bugsnag reduce mean time to resolution by 40% thanks to automatic duplicate grouping and full event context. The platform integrates with Slack, PagerDuty, Jira, GitHub and GitLab for automatic issue creation from errors.

Stability Score and Automatic Prioritization

Stability Score is Bugsnag's key metric, showing the percentage of sessions that completed without errors. The value is calculated as the ratio of crash-free sessions to total sessions over a period. A 99.9% score means 1 in 1,000 sessions contains an error.

Stability Score thresholds are integrated with CI/CD: if after deploying a new version the score drops below a set threshold (e.g., 99.5%), Bugsnag automatically blocks the release or sends a critical alert in Slack. The Release health dashboard shows score dynamics for each application version, allowing you to track the impact of a specific change on stability.

Severity-based triage

Bugsnag uses an automatic error classification algorithm with three severity levels. Critical — application crashes, errors in payment scenarios affecting more than 5% of users. Warning — non-fatal errors (handled exceptions) affecting individual features. Info — logs, low-priority warnings. This approach prevents alert fatigue, where hundreds of notifications prevent focusing on truly critical issues.

Integrating Bugsnag SDK for Mobile Platforms

Installing the Bugsnag SDK takes 5 minutes: adding a dependency and initializing with a project API key. The Bugsnag Android SDK supports Kotlin and Java, automatically intercepts Java exceptions, ANRs and Native (C/C++) errors via signals.

Android Setup

The SDK is added via Gradle and initialized in Application.onCreate. Bugsnag automatically collects device information: model, OS version, free memory, battery level. Auto-notify is enabled by default and sends all unhandled exceptions to the Bugsnag server.

import com.bugsnag.android.Bugsnag
import com.bugsnag.android.Configuration

class App : Application() {
    override fun onCreate() {
        super.onCreate()
        val config = Configuration("YOUR_API_KEY")
        config.autoTrackSessions = true
        config.launchDurationMillis = 5_000
        Bugsnag.start(this, config)
    }
}

The code initializes the Bugsnag SDK with automatic session tracking and a maximum startup time of 5 seconds. If the application does not launch within this time, Bugsnag records a "slow launch" event as a warning.

iOS Setup

The Bugsnag iOS SDK supports Swift and Objective-C, intercepts NSException, Mach exceptions (SIGABRT, SIGSEGV) and operating system signals. The SDK is compatible with iOS 11+ and SwiftUI, automatically creates breadcrumbs for all UI events: taps, transitions, gestures.

import Bugsnag

class AppDelegate: UIResponder, UIApplicationDelegate {
    override func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions options: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        Bugsnag.start(withApiKey: "YOUR_API_KEY")
        // additional configuration
        return true
    }
}

The Swift code initializes Bugsnag with minimal configuration. All unhandled exceptions and crashes are automatically sent to the Bugsnag dashboard with full device context and call stack.

Breadcrumbs and Error State

Breadcrumbs in Bugsnag are a structured log of events preceding an error. Each breadcrumb contains a timestamp, type (navigation, request, state, error, manual) and arbitrary metadata. Bugsnag automatically records breadcrumbs for UI events in iOS and Android, application state changes (background, foreground) and network requests.

Developers can add custom breadcrumbs for business logic: "user added item to cart", "order creation request sent". When an error occurs, all breadcrumbs from the last 30 seconds are attached to the event. Bugsnag also supports "state" — an arbitrary data dictionary passed with all session errors.

Bugsnag.leaveBreadcrumb(
    message = "Order created",
    metadata = mapOf(
        "order_id" to "ORD-12345",
        "total" to "49.99"
    ),
    type = BreadcrumbType.STATE
)

Bugsnag.setExtraData(
    "user_tier", "premium"
)

The code leaves a breadcrumb about order creation and sets additional information about the user's plan. When an error occurs in this session, Bugsnag attaches context with the order number and user type.

Session tracking

Bugsnag automatically counts sessions — each application launch is considered a new session. The ratio of error sessions to total sessions forms the Stability Score. Session tracking affects pricing: Bugsnag is licensed by the number of tracked sessions, not by error volume, distinguishing it from per-event pricing models used by Sentry and competitors.

Release Tracking and CI/CD Integration

Release tracking is a mechanism that links each error to a specific application version and repository commit. Bugsnag automatically detects the version from Info.plist (iOS) or build.gradle (Android) and displays error counts by version in the dashboard. This allows you to immediately see if a problem was introduced by the latest release.

If after deploying version 2.4.1 the number of critical errors increased 3 times compared to 2.4.0, Bugsnag marks this version as "unstable" and sends an alert. CI/CD integration allows blocking promotion of a build to staging or production if the Stability Score drops below the threshold. Plugins for Jenkins, GitHub Actions and GitLab CI pass stability metrics to the pipeline.

According to Bugsnag Stability Benchmark (2024), 68% of errors in mobile applications are introduced by new versions, rather than being long-standing bugs. Release tracking reduces regression detection time from hours to minutes after deployment.

Bugsnag vs Sentry and Crashlytics

There are three main players in the error monitoring market: Bugsnag, Sentry and Firebase Crashlytics. Bugsnag stands out with its session-based pricing model (rather than per-event), focus on Stability Score and automatic severity prioritization. Sentry offers deeper performance monitoring with distributed tracing and is open source. Crashlytics is a free solution with basic features, integrated into the Firebase ecosystem.

The choice between tools depends on priorities: if the key metric is application stability in production, Bugsnag provides the most intuitive metric. If deep performance analysis with distributed tracing is needed — Sentry. For free basic monitoring with Google ecosystem integration — Crashlytics.