Error and Exception Monitoring for Android App

⚙️ Configure Error, Exception, and Crash Monitoring for Android

📖 Overview

The GermainUX Mobile App library can collect:

Error data can be correlated with the application version, Android version, device, user session, screen, fragment, transaction, and preceding application events.

Error Types

Use the appropriate GermainUX event for each condition:

Do not report expected user validation, such as a required field left empty, as an application error unless the software itself is failing to operate as intended.

🤖 Automatic Crash Detection

Unhandled-exception monitoring is enabled automatically after GermainUX initialization unless it is explicitly disabled:

config.setAutomaticUnhandledExceptionsMonitoring(false);

When an unhandled exception terminates the application, GermainUX attempts to capture:

Delivery is attempted before the application process terminates, but Android does not guarantee enough execution time to transmit crash telemetry immediately.

⛔ Disable Automatic Crash Detection

Disable automatic monitoring only when required, such as when:

☕ Java

GermainAPMConfiguration config =
    new GermainAPMConfiguration(
        "https://YOUR_GERMAINUX_HOST/ingestion/fact"
    );

config.setAutomaticUnhandledExceptionsMonitoring(false);

GermainAPM.init(this, config);

🚀 Kotlin

val config = GermainAPMConfiguration(
    "https://YOUR_GERMAINUX_HOST/ingestion/fact"
)

config.setAutomaticUnhandledExceptionsMonitoring(false)

GermainAPM.init(this, config)

When multiple crash libraries are installed, verify that their uncaught-exception handlers are compatible and that the original handler chain is preserved.

🤝 Report a Crash Explicitly

Use collectCrash() only when the application is treating the condition as a crash or terminal failure.

☕ Java

try {
    runCriticalOperation();
} catch (Throwable error) {
    GermainAPM.collectCrash(
        "CriticalOperationCrash",
        error,
        false
    );

    throw error;
}

🚀 Kotlin

try {
    runCriticalOperation()
} catch (error: Throwable) {
    GermainAPM.collectCrash(
        "CriticalOperationCrash",
        error,
        false
    )

    throw error
}

Parameters:

collectCrash() also records application closure and uptime context. Do not use it for a condition after which the application continues normally. Use collectException() or collectError() instead.

Avoid catching Throwable solely for monitoring in normal application code. The preceding example represents a terminal boundary where the failure is reported and rethrown.

💡 Report Handled Exceptions

Use collectException() inside existing exception-handling logic when the exception is operationally meaningful.

📝 Basic example

Java:

try {
    loadCustomerData();
} catch (IOException error) {
    GermainAPM.collectException(error);

    showCachedData();
}

Kotlin:

try {
    loadCustomerData()
} catch (error: IOException) {
    GermainAPM.collectException(error)

    showCachedData()
}

The application remains responsible for handling the exception. Reporting it to GermainUX does not recover the failed operation or alter the application flow.

🏷️ Custom exception name

Use a stable custom name when the default exception class does not provide enough business or technical context.

Java:

try {
    submitOrder();
} catch (IOException error) {
    GermainAPM.collectException(
        "OrderSubmissionException",
        error,
        false
    );

    displayRetryOption();
}

Kotlin:

try {
    submitOrder()
} catch (error: IOException) {
    GermainAPM.collectException(
        "OrderSubmissionException",
        error,
        false
    )

    displayRetryOption()
}

The third parameter identifies whether the reported exception represents a StrictMode violation.

Use consistent names rather than including record IDs, user names, timestamps, or dynamic error values in the event name.

❗ Report Application Errors

Use collectError() when an important failure occurs without an exception.

Examples include:

☕ Java

if (!response.isSuccessful()) {
    GermainAPM.collectError(
        "CustomerSyncFailed",
        "The customer synchronization request failed."
    );

    displayRetryOption();
}

🚀 Kotlin

if (!response.isSuccessful) {
    GermainAPM.collectError(
        "CustomerSyncFailed",
        "The customer synchronization request failed."
    )

    displayRetryOption()
}

Keep error content concise and free of sensitive data.

Do not pass:

🔍 StrictMode Violations

Android StrictMode can identify development and runtime policy violations such as:

The violations available depend on the Android version and the StrictMode policies enabled by the application.

StrictMode findings are not automatically equivalent to production crashes. Some violations log a warning, while others can be configured to terminate the application. Categorize them according to their actual behavior and impact.

Use StrictMode cautiously in production. Validate the selected policies and penalties in a test environment before rollout.

🏷️ Categorize Errors in GermainUX

Configure categories that distinguish:

This prevents user validation and low-value diagnostic events from inflating the KPI used for software failures.

📈 Analyze Errors

Use GermainUX dashboards to analyze errors by:

Prioritize errors based on user impact, recurrence, severity, affected business process, and whether they were introduced by a recent release.

🔔 Alerts

Configure alerts for conditions such as:

Avoid sending an alert for every individual occurrence of a high-volume error. Use aggregation, minimum affected-user counts, persistence, and severity rules.

🔒 Privacy and Obfuscation

Before enabling error reporting:

Obfuscated stack traces may require the corresponding mapping file to identify the original classes and methods.

✅ Validation

Test the integration in a nonproduction build:

1. Initialize GermainUX.

2. Report a controlled application error.

3. Report a handled exception.

4. Trigger an unhandled exception in a safe test scenario.

5. Confirm that the crash is associated with the correct session.

6. Verify application, version, device, screen, and transaction context.

7. Confirm that the release build provides usable stack traces.

8. Verify that sensitive values are excluded.

9. Test alert thresholds and recipients.

10. Confirm that another installed crash handler still works, if applicable.

🔧 Troubleshooting

💥 Unhandled crashes are not collected

Verify that:

A crash that terminates the process immediately may not be transmitted until the library has another opportunity to send retained telemetry, if supported by the installed version.

🔎 Handled exceptions are missing

Confirm that:

📄 Stack traces are unreadable

Check:

🔁 Duplicate crashes appear

Verify that:

ℹ️ Get More Information

GermainUX can help determine which monitoring, analytics and automation capabilities are appropriate for your Android App environment.

Contact GermainUX Support.