Desativar o Monitoramento de desempenho do Firebase

Durante o desenvolvimento e o teste de apps, pode ser útil desativar o Performance Monitoring.

Por exemplo, ao desativar o Performance Monitoring durante o processo de build do app, é possível:

• Desativar algumas funcionalidades do Performance Monitoring (como aquelas fornecidas pelo plug-in do Gradle para o Performance Monitoring) nos seus builds de depuração, mas ativá-los novamente no seu build de lançamento.

• Desativar o Performance Monitoring ao criar seu app, mas permitir que ele o ative novamente no ambiente de execução.

• Desativar o Performance Monitoring ao criar o app e não permitir que ele o ative novamente no ambiente de execução.

Também é possível criar o app com o Performance Monitoring ativado, mas usar o Firebase Remote Config para ter flexibilidade para desativar (e reativar) o Performance Monitoring no app de produção. Com essa opção, é possível até configurar o app para permitir que os usuários ativem ou desativem o uso do Performance Monitoring.

Desativar o Performance Monitoring durante o processo de build do app

Para desativar o Performance Monitoring durante o processo de build, desative o plug-in do Gradle para o Performance Monitoring e/ou desative a biblioteca Performance Monitoring para Android.

Durante o desenvolvimento e a depuração, a desativação do plug-in é útil porque a instrumentação pelo plug-in pode contribuir para aumentar o tempo de compilação. No entanto, é recomendado manter a biblioteca ativada para que você ainda possa visualizar dados de desempenho da inicialização do app e traces do uso do aplicativo em primeiro e segundo plano, além de traces de código personalizados no seu app.

Desativar o plug-in do Gradle para o Performance Monitoring

Para desativar o plug-in do Performance Monitoring, adicione uma flag instrumentationEnabled usando as seguintes opções:

• Propriedade de extensão: desativa o plug-in para uma variante de build específica no tempo de compilação

• Propriedade do projeto: desativa o plug-in para todas as variantes de build no tempo de compilação

Desativar o plug-in por meio de uma sinalização de Propriedade de extensão

Ao usar uma flag de Propriedade de extensões, é possível desativar o plug-in do Performance Monitoring para uma variante de build específica no tempo de compilação.

1. No arquivo Gradle no nível raiz (para envolvidos no projeto) (<project>/build.gradle.kts ou <project>/build.gradle), verifique se a dependência do Plug-in do Android para Gradle está especificada como v3.4.0. ou mais tarde.

   Para versões anteriores do Plug-in do Android para Gradle, ainda é possível desativar o plug-in do Performance Monitoring para uma variante de build específica, mas a contribuição do tempo de compilação para essa variante não será completamente eliminada.

2. Adicione a seguinte flag ao arquivo do Gradle do módulo (nível do app) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle) e defina-a como false para desativar o plug-in do Performance Monitoring.

   Kotlin

   import com.google.firebase.perf.plugin.FirebasePerfExtension
   
   // ...
   
   android {
     // ...
     buildTypes {
       getByName("debug") {
         configure<FirebasePerfExtension> {
           // Set this flag to 'false' to disable @AddTrace annotation processing and
           // automatic monitoring of HTTP/S network requests
           // for a specific build variant at compile time.
           setInstrumentationEnabled(false)
         }
       }
     }
   }

   Groovy

   android {
     // ...
     buildTypes {
       debug {
         FirebasePerformance {
           // Set this flag to 'false' to disable @AddTrace annotation processing and
           // automatic monitoring of HTTP/S network requests
           // for a specific build variant at compile time.
           instrumentationEnabled false
         }
       }
     }
   }

Desativar o plug-in por meio de uma sinalização de Propriedade do projeto

Ao usar uma flag de Propriedade do projeto, é possível desativar o plug-in do Performance Monitoring para todas as variantes de build no tempo de compilação.

Adicione a seguinte flag ao arquivo gradle.properties e defina-a como false para desativar o plug-in do Performance Monitoring.

// ...

// Set this flag to 'false' to disable @AddTrace annotation processing and
// automatic monitoring of HTTP/S network requests
// for all build variants at compile time.
firebasePerformanceInstrumentationEnabled=false

Desativar a biblioteca do Android para o Performance Monitoring

Quando você desativa a biblioteca do Performance Monitoring no tempo de compilação, é possível decidir se permitirá que o app ative a biblioteca no ambiente de execução.

Desativar a biblioteca no momento da compilação, mas permitir que o app seja ativado no momento da execução

Adicione o seguinte elemento <meta-data> ao arquivo AndroidManifest.xml do app:

  <application>
    <meta-data
      android:name="firebase_performance_collection_enabled"
      android:value="false" />
  </application>

Desativar a biblioteca no momento da compilação, mas não permitir que o app seja ativado no momento da execução

Adicione o seguinte elemento <meta-data> ao arquivo AndroidManifest.xml do app:

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

Desativar o app no ambiente de execução usando a Remote Config

A Firebase Remote Config permite fazer alterações no comportamento e na aparência do app. Portanto, você pode usá-la para desativar o Performance Monitoring em instâncias implantadas do app.

Para desativar a coleta de dados do Performance Monitoring na próxima vez em que seu app Android for iniciado, use o exemplo de código mostrado abaixo. Para mais informações sobre como usar a Remote Config em um app Android, consulte Usar a Firebase Remote Config no Android.

1. Verifique se Remote Config está na seção dependencies do arquivo do Gradle do módulo (nível do app) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle):

   Kotlin+KTX

     implementation("com.google.firebase:firebase-config-ktx:22.0.1")
   

   Java

     implementation("com.google.firebase:firebase-config:22.0.1")
   

2. Configure a Remote Config e desative o Performance Monitoring se perf_disable estiver definido como true:

   Kotlin+KTX

   // Setup remote config
   val config = Firebase.remoteConfig
   
   // You can uncomment the following two statements to permit more fetches when
   // validating your app, but you should comment out or delete these lines before
   // distributing your app in production.
   // val configSettings = remoteConfigSettings {
   //     minimumFetchIntervalInSeconds = 3600
   // }
   // config.setConfigSettingsAsync(configSettings)
   // Load in-app defaults from an XML file that sets perf_disable to false until you update
   // values in the Firebase Console
   
   // Observe the remote config parameter "perf_disable" and disable Performance Monitoring if true
   config.setDefaultsAsync(R.xml.remote_config_defaults)
       .addOnCompleteListener { task ->
           if (task.isSuccessful) {
               Firebase.performance.isPerformanceCollectionEnabled = !config.getBoolean("perf_disable")
           } else {
               // An error occurred while setting default parameters
           }
       }
   MainActivity.kt

   Java

   // Setup remote config
   final FirebaseRemoteConfig config = FirebaseRemoteConfig.getInstance();
   
   // You can uncomment the following two statements to permit more fetches when
   // validating your app, but you should comment out or delete these lines before
   // distributing your app in production.
   // FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder()
   //       .setMinimumFetchIntervalInSeconds(3600)
   //       .build();
   // config.setConfigSettingsAsync(configSettings);
   // Load in-app defaults from an XML file that sets perf_disable to false until you update
   // values in the Firebase Console
   
   //Observe the remote config parameter "perf_disable" and disable Performance Monitoring if true
   config.setDefaultsAsync(R.xml.remote_config_defaults)
           .addOnCompleteListener(new OnCompleteListener<Void>() {
               @Override
               public void onComplete(@NonNull Task<Void> task) {
                   if (task.isSuccessful()) {
                       if (config.getBoolean("perf_disable")) {
                           FirebasePerformance.getInstance().setPerformanceCollectionEnabled(false);
                       } else {
                           FirebasePerformance.getInstance().setPerformanceCollectionEnabled(true);
                       }
                   } else {
                       // An error occurred while setting default parameters
                   }
               }
           });
   MainActivity.java

3. Adicione o seguinte código a MainActivity.java para buscar e ativar valores da Remote Config:

   Kotlin+KTX

   // Remote Config fetches and activates parameter values from the service
   val config = Firebase.remoteConfig
   config.fetch(3600)
       .continueWithTask { task ->
           if (!task.isSuccessful) {
               task.exception?.let {
                   throw it
               }
           }
           config.activate()
       }
       .addOnCompleteListener(this) { task ->
           if (task.isSuccessful) {
               // Parameter values successfully activated
               // ...
           } else {
               // Handle errors
           }
       }
   MainActivity.kt

   Java

   //Remote Config fetches and activates parameter values from the service
   final FirebaseRemoteConfig config = FirebaseRemoteConfig.getInstance();
   config.fetch(3600)
           .continueWithTask(new Continuation<Void, Task<Boolean>>() {
               @Override
               public Task<Boolean> then(@NonNull Task<Void> task) throws Exception {
                   if (!task.isSuccessful()) {
                       throw task.getException();
                   }
                   return config.activate();
               }
           })
           .addOnCompleteListener(new OnCompleteListener<Boolean>() {
               @Override
               public void onComplete(@NonNull Task<Boolean> task) {
                   if (task.isSuccessful()) {
                       // Parameter values successfully activated
                       // ...
                   } else {
                       // Handle errors
                   }
               }
           });
   MainActivity.java

4. Para desativar o Performance Monitoring no console do Firebase, crie um parâmetro perf_disable no projeto do app e defina o valor dele como true.

   Essa alteração fará chamadas para as chamadas "sem operação" (NoOPs, na sigla em inglês) do SDK do Performance Monitoring, eliminando qualquer efeito significativo do uso do SDK do Performance Monitoring no desempenho do app.

   Se você definir o valor de perf_disable como false, o Performance Monitoring permanecerá ativado.