Get started with Performance Monitoring for Android

Before you begin

If you haven't already, add Firebase to your Android project.

In your project-level build.gradle file, make sure to include Google's Maven repository in both your buildscript and allprojects sections.

Step 1: Add the Performance Monitoring SDK to your app

The Performance Monitoring SDK enables monitoring of automatic duration traces and any additional custom traces in your app.

In your module (app-level) Gradle file (usually app/build.gradle):

// ...

dependencies {
  // ...

  implementation 'com.google.firebase:firebase-core:17.0.1'

  // Add the dependency for the Performance Monitoring library
  implementation 'com.google.firebase:firebase-perf:18.0.1'
}

Recompile your app.

Step 2: Add the Performance Monitoring plugin to your app

The Performance Monitoring Gradle plugin enables instrumentation that provides @AddTrace annotation processing and automatic HTTP/S network request monitoring.

How the Performance Monitoring plugin works

Before your code is converted to DEX files, the Performance Monitoring plugin uses the Transform API and the ASM bytecode instrumentation framework to visit your app's compiled class files and to instrument the code (to measure performance). The time it takes to instrument your code largely depends on the number and size of your classes.

If your app takes more time to compile than you'd like, consider the following options:

Disable the Performance Monitoring plugin for your debug builds at compile time
Modularize your code to optimize your build speed

firebase-plugins is deprecated at v2.0.0.
Instead, you must add the Performance Monitoring plugin explicitly, as shown in the following steps.

To add the Performance Monitoring plugin to your app:

In your module (app-level) Gradle file (usually app/build.gradle):

apply plugin: 'com.android.application'
// Apply the Performance Monitoring plugin
apply plugin: 'com.google.firebase.firebase-perf'

dependencies {
  // ...
}

In your root-level (project-level) Gradle file (build.gradle), add the rules to include the Performance Monitoring plugin.

buildscript {

    repositories {
      // Check that you have the following line (if not, add it):
      google()  // Google's Maven repository
      // Add the Bintray repository
      jcenter()
    }

    dependencies {
      // ...

      // To benefit from the latest Performance Monitoring plugin features,
      // update your Android Gradle Plugin dependency to at least v3.4.0
      classpath 'com.android.tools.build:gradle:3.4.0'

      classpath 'com.google.gms:google-services:4.3.0'  // Google Services plugin

      // Add the dependency for the Performance Monitoring plugin
      classpath 'com.google.firebase:perf-plugin:1.3.0'  // Performance Monitoring plugin
    }
}

Recompile your app.

Step 3: Check the Firebase console for Performance Monitoring results

Build your app in Android Studio.
Test your app using either:
- An Android emulator with a recent image and Google Play services 15.0.0 or later
- A test device with Google Play services 15.0.0 or later.
Confirm that Performance Monitoring results display in the Firebase console.

Results usually display within 12 hours.

Step 4: (Optional) Add custom traces and custom metrics

A custom trace is a report of performance data associated with some of the code in your app. To learn more about custom traces, see the Performance Monitoring overview.

You can have multiple custom traces in your app, and it's possible to have more than one custom trace running at a time. Each custom trace can have one or more metrics to count performance-related events in your app, and those metrics are associated with the traces that create them.

Note that names for custom traces and metrics must meet the following requirements: no leading or trailing whitespace, no leading underscore (_) character, and max length is 32 characters.

Import these Performance Monitoring classes at the top of your .java or .kt file:

import com.google.firebase.perf.FirebasePerformance;
import com.google.firebase.perf.metrics.Trace;

To start and stop a custom trace, wrap the code that you want to trace with lines of code similar to the following (this example uses a custom trace name of test_trace):

Java

Trace myTrace = FirebasePerformance.getInstance().newTrace("test_trace");
myTrace.start();

// code that you want to trace

myTrace.stop();MainActivity.java

Kotlin

val myTrace = FirebasePerformance.getInstance().newTrace("test_trace")
myTrace.start()

// code that you want to trace

myTrace.stop()MainActivity.kt

To add a custom metric, add lines of code similar to the following each time that the event occurs. For example, this custom metric counts performance-related events that occur in your app, such as cache hits and misses (using example event names of item_cache_hit and item_cache_miss and an increment of 1).

Java

Trace myTrace = FirebasePerformance.getInstance().newTrace("test_trace");
myTrace.start();

// code that you want to trace (and log custom metrics)
Item item = cache.fetch("item");
if (item != null) {
    myTrace.incrementMetric("item_cache_hit", 1);
} else {
    myTrace.incrementMetric("item_cache_miss", 1);
}

myTrace.stop();MainActivity.java

Kotlin

val myTrace = FirebasePerformance.getInstance().newTrace("test_trace")
myTrace.start()

// code that you want to trace (and log custom metrics)
val item = cache.fetch("item")
if (item != null) {
    myTrace.incrementMetric("item_cache_hit", 1)
} else {
    myTrace.incrementMetric("item_cache_miss", 1)
}

myTrace.stop()MainActivity.kt

Step 5: (Optional) Trace specific methods using `@AddTrace`

You can add the @AddTrace annotation to methods in your app and provide a string to identify the resulting custom trace. This causes a trace to start at the beginning of this method and to stop when the method completes.

Note, though, that for custom traces created with the @AddTrace annotation, you cannot add custom metrics.

For example, to create a trace called onCreateTrace that runs when the onCreate() method is called, use code similar to the following:

Java

@Override
@AddTrace(name = "onCreateTrace", enabled = true /* optional */)
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
}MainActivity.java

Kotlin

@AddTrace(name = "onCreateTrace", enabled = true /* optional */)
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
}MainActivity.kt

Step 6: (Optional) Add monitoring for specific network requests

Performance Monitoring collects network requests automatically. Although this includes most network requests for your app, some might not be reported.

To include custom network requests in Performance Monitoring, add the following code to your app:

Java

HttpMetric metric =
        FirebasePerformance.getInstance().newHttpMetric("https://www.google.com",
                FirebasePerformance.HttpMethod.GET);
final URL url = new URL("https://www.google.com");
metric.start();
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setDoOutput(true);
conn.setRequestProperty("Content-Type", "application/json");
try {
    DataOutputStream outputStream = new DataOutputStream(conn.getOutputStream());
    outputStream.write(data);
} catch (IOException ignored) {
}
metric.setRequestPayloadSize(data.length);
metric.setHttpResponseCode(conn.getResponseCode());
printStreamContent(conn.getInputStream());

conn.disconnect();
metric.stop();MainActivity.java

Kotlin

val metric = FirebasePerformance.getInstance().newHttpMetric("https://www.google.com",
        FirebasePerformance.HttpMethod.GET)
val url = URL("https://www.google.com")
metric.start()
val conn = url.openConnection() as HttpURLConnection
conn.doOutput = true
conn.setRequestProperty("Content-Type", "application/json")
try {
    val outputStream = DataOutputStream(conn.outputStream)
    outputStream.write(data)
} catch (ignored: IOException) {
}

metric.setRequestPayloadSize(data.size.toLong())
metric.setHttpResponseCode(conn.responseCode)
printStreamContent(conn.inputStream)

conn.disconnect()
metric.stop()MainActivity.kt

The HTTP/S network requests that you specifically capture in this way appear in the Firebase console along with the network requests that Performance Monitoring captures automatically.

Step 7: Deploy your app then review results

After you've validated Performance Monitoring using one or more test devices, you can deploy the updated version of your app to your users.

You can monitor performance data in the Firebase console.

Known issues

The Performance Monitoring Gradle plugin v1.1.0 can cause a mismatch in Guava dependencies, resulting in the following error:

Error:Execution failed for task ':app:packageInstantRunResourcesDebug'.
> com.google.common.util.concurrent.MoreExecutors.directExecutor()Ljava/util/concurrent/Executor;

If you see this error, you can either:

Upgrade the Performance Monitoring plugin to v1.1.1 or later (the most recent is v1.3.0).

Replace the Performance Monitoring plugin dependency line in your root-level (project-level) Gradle file (build.gradle), as follows:

buildscript {
  // ...

  dependencies {
    // ...

    // Replace the standard Performance Monitoring plugin dependency line, as follows:
    classpath ('com.google.firebase:perf-plugin:1.1.0') {
                exclude group: 'com.google.guava', module: 'guava-jdk5'
    }
  }
}

Performance Monitoring only supports monitoring HTTP/S network requests made using the OkHttp HTTP client v3.x.x.
Performance Monitoring reports the total payload size for HTTP/S network requests based on the value set in the HTTP content-length header. This value might not always be accurate.
Performance Monitoring only supports the main process in multi-process Android apps.
The Performance Monitoring Gradle plugin is not compatible with the following:
- DexGuard, which disables automatic traces and HTTP/S network request monitoring. However, custom traces added using the Performance Monitoring SDK behave normally if your app uses DexGuard.
- Jack, which is deprecated.

Debug your integration

You can enable debug logging for Performance Monitoring at build time, by adding a <meta-data> element to your app's AndroidManifest.xml file, like so:

<application>
    <meta-data
      android:name="firebase_performance_logcat_enabled"
      android:value="true" />
</application>

You can view trace and HTTP/S network request logging using logcat filtering. Performance Monitoring log messages are tagged with FirebasePerformance, and you can filter them using following command:

adb logcat -s FirebasePerformance

Next steps

Review a sample of traces and network requests.
Review and run the Performance Monitoring Android code sample on GitHub.
Learn more about automatic traces.
Learn more about monitoring custom attributes.

Get started with Performance Monitoring for Android

Before you begin

Step 1: Add the Performance Monitoring SDK to your app

Step 2: Add the Performance Monitoring plugin to your app

Step 3: Check the Firebase console for Performance Monitoring results

Step 4: (Optional) Add custom traces and custom metrics

Java

Kotlin

Java

Kotlin

Step 5: (Optional) Trace specific methods using @AddTrace

Java

Kotlin

Step 6: (Optional) Add monitoring for specific network requests

Java

Kotlin

Step 7: Deploy your app then review results

Known issues

Debug your integration

Next steps

Step 5: (Optional) Trace specific methods using `@AddTrace`