Transaction Monitoring for Android App

⚙️ Configure Transaction Monitoring for an Android Application

📄 Overview

GermainUX transactions measure the duration and outcome context of important operations performed by an Android application.

A transaction can represent:

Custom transaction monitoring requires the application to call:

✏️ Transaction Design

Before adding instrumentation, define:

Use stable transaction names such as:

Do not generate a different transaction name for every execution. Dynamic values should not be included in the name because they prevent meaningful aggregation.

🚀 Start a Transaction

Start the transaction immediately before the operation being measured.

☕ Java

String transactionName = "Customer Search";

GermainAPM.startTransaction(
    transactionName,
    "CustomerSearchView",
    "Search request"
);

🍃 Kotlin

val transactionName = "Customer Search"

GermainAPM.startTransaction(
    transactionName,
    "CustomerSearchView",
    "Search request"
)

The view name and additional information are optional. Use them only when they add useful, non-sensitive context.

🛑 End a Transaction

End the transaction after the operation completes:

Java

GermainAPM.endTransaction(
    transactionName
);

Kotlin

GermainAPM.endTransaction(
    transactionName
)

The name supplied to endTransaction() must match the transaction started by startTransaction().

Every started transaction should have a corresponding end call. Otherwise, GermainUX cannot calculate its complete duration.

🔧 Monitor an Asynchronous Java Operation

Use try, catch, and finally so that the transaction ends whether the operation succeeds or fails.

private final ExecutorService executor =
    Executors.newSingleThreadExecutor();

public void loadCustomerData() {
    String transactionName = "Customer Data Load";

    GermainAPM.startTransaction(
        transactionName,
        "CustomerView",
        "Load customer data"
    );

    executor.execute(() -> {
        try {
            customerRepository.load();
        } catch (IOException error) {
            GermainAPM.collectException(
                "CustomerDataLoadException",
                error,
                false
            );

            handleLoadFailure(error);
        } finally {
            GermainAPM.endTransaction(
                transactionName
            );
        }
    });
}

Do not use Android AsyncTask for new implementations because it is deprecated. Use the concurrency mechanism already approved for the application.

🎯 Monitor a Kotlin Coroutine

fun loadCustomerData() {
    val transactionName = "Customer Data Load"

    GermainAPM.startTransaction(
        transactionName,
        "CustomerView",
        "Load customer data"
    )

    applicationScope.launch {
        try {
            customerRepository.load()
        } catch (error: IOException) {
            GermainAPM.collectException(
                "CustomerDataLoadException",
                error,
                false
            )

            handleLoadFailure(error)
        } finally {
            GermainAPM.endTransaction(
                transactionName
            )
        }
    }
}

Start and end the transaction around the actual operation being measured. Starting too early can include unrelated user or scheduling time, while starting too late can exclude important preparation work.

🛰️ Monitor a Network Request

fun submitOrder() {
    val transactionName = "Order Submission"

    GermainAPM.startTransaction(
        transactionName,
        "CheckoutView",
        "Submit order"
    )

    applicationScope.launch {
        try {
            val response = orderService.submitOrder()

            if (!response.isSuccessful) {
                GermainAPM.collectError(
                    "OrderSubmissionFailed",
                    "Order service returned an unsuccessful response."
                )
            }
        } catch (error: IOException) {
            GermainAPM.collectException(
                "OrderSubmissionException",
                error,
                false
            )
        } finally {
            GermainAPM.endTransaction(
                transactionName
            )
        }
    }
}

Do not include request bodies, authentication headers, payment information, or sensitive response content in the transaction details.

Report Transaction Failures

endTransaction() completes the duration measurement. When an operation fails, also report the failure using the appropriate API:

Example:

try {
    performSynchronization();
} catch (IOException error) {
    GermainAPM.collectException(
        "SynchronizationException",
        error,
        false
    );
} finally {
    GermainAPM.endTransaction(
        "Data Synchronization"
    );
}

Use GermainUX categorization and correlation to associate the error or exception with the transaction and user session.

🤝 Nested and Concurrent Transactions

Transactions may overlap when the application performs concurrent operations.

When adding instrumentation:

If individual concurrent instances must be distinguished, use the correlation capabilities supported by the installed library rather than adding a unique value to the transaction name.

💼 Business-Process Transactions

Transactions can represent individual steps in a larger business process.

For example:

GermainUX can use these transactions with screens, events, sessions, and errors to analyze:

🏷️ Transaction Attributes

The basic startTransaction() call supports a transaction name, view name, and additional information.

Use additional information only for low-cardinality, non-sensitive context. Suitable examples include:

Avoid:

📊 Analyze Transactions

In GermainUX, transactions can be analyzed by:

Use percentiles and affected-user counts alongside averages. Averages can hide severe delays experienced by a subset of users.

🔔 Alerts

Configure alerts for conditions such as:

Use minimum-volume and sustained-duration conditions to reduce noise.

✅ Validation

After adding transaction monitoring:

1. Execute the operation successfully.

2. Confirm that the transaction appears in GermainUX.

3. Verify its name, view, duration, and session.

4. Force a controlled failure.

5. Confirm that the transaction still ends.

6. Verify that the related error or exception is captured.

7. Test cancellation and timeout paths.

8. Test concurrent executions.

9. Confirm that no sensitive details are collected.

10. Compare release-build behavior with the debug build.

11. Measure instrumentation overhead.

🐛 Troubleshooting

A transaction never completes

Verify that:

Transaction durations are too long

Check whether the transaction begins before unrelated work, user input, queue waiting, or background scheduling. Move the start point to the actual beginning of the operation if those delays are not part of the intended measurement.

Transaction durations are too short

Confirm that the transaction does not end before an asynchronous operation finishes. End it from the completion, failure, or cancellation path rather than immediately after starting the async request.

Transactions are combined incorrectly

Verify that:

Errors are not associated with transactions

Confirm that:

ℹ️ Get More Information

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

Contact GermainUX Support.