Disabilita il monitoraggio delle prestazioni di Firebase

Durante lo sviluppo e il test dell'app, potresti trovare utile disabilitare il monitoraggio delle prestazioni.

Ad esempio, disabilitando il monitoraggio delle prestazioni durante il processo di creazione dell'app , puoi:

  • Disabilita alcune funzionalità di Performance Monitoring (come quelle fornite dal plug-in Performance Monitoring Gradle ) nelle build di debug, ma riattiva le funzionalità per la build di rilascio.

  • Disabilita il monitoraggio delle prestazioni durante la creazione dell'app, ma consenti all'app di riattivarla in fase di runtime.

  • Disattiva il monitoraggio delle prestazioni durante la creazione dell'app e non consentire all'app di riattivarla in fase di runtime.

Puoi anche creare la tua app con il monitoraggio delle prestazioni abilitato , ma utilizza Firebase Remote Config per avere la flessibilità di disabilitare (e riattivare) il monitoraggio delle prestazioni nella tua app di produzione. Con questa opzione, puoi persino configurare la tua app per consentire agli utenti di attivare o disattivare l'utilizzo del monitoraggio delle prestazioni.

Disabilita il monitoraggio delle prestazioni durante il processo di creazione dell'app

Puoi disabilitare il monitoraggio delle prestazioni durante il processo di creazione disabilitando il plug-in Gradle di monitoraggio delle prestazioni e/o disabilitando la libreria Android di monitoraggio delle prestazioni .

Durante lo sviluppo e il debug, disabilitare il plugin è utile perché la strumentazione del plugin può contribuire ad aumentare il tempo di compilazione. Potresti, tuttavia, prendere in considerazione la possibilità di mantenere la libreria abilitata in modo da poter comunque visualizzare i dati sulle prestazioni dalle tracce di avvio dell'app, app in primo piano e app in background, nonché eventuali tracce di codice personalizzato nella tua app.

Disabilita il plugin Gradle per il monitoraggio delle prestazioni

Puoi disabilitare il plug-in Performance Monitoring aggiungendo un flag instrumentationEnabled utilizzando le seguenti opzioni:

  • Proprietà estensione : disabilita il plug-in per una variante di build specifica in fase di compilazione

  • Proprietà progetto : disabilita il plug-in per tutte le varianti di build in fase di compilazione

Disabilita il plugin tramite un flag di proprietà dell'estensione

Utilizzando un flag Proprietà estensioni , puoi disabilitare il plug-in Monitoraggio delle prestazioni per una variante di build specifica in fase di compilazione.

  1. Nel file Gradle a livello di root (a livello di progetto) ( <project>/build.gradle.kts o <project>/build.gradle ), assicurati che la dipendenza del plug-in Gradle Android sia specificata come v3.4.0 o successiva.

    Per le versioni precedenti del plug-in Android Gradle, puoi comunque disabilitare il plug-in Monitoraggio delle prestazioni per una variante di build specifica, ma il contributo in termini di tempo di creazione per tale variante non verrà completamente eliminato.

  2. Aggiungi il seguente flag al file Gradle del tuo modulo (a livello di app) (solitamente <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle ), quindi impostalo su false per disabilitare il plug-in Monitoraggio delle prestazioni.

    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
          }
        }
      }
    }
    

Disabilitare il plugin tramite un flag Proprietà progetto

Utilizzando un flag Proprietà progetto , puoi disabilitare il plug-in Monitoraggio delle prestazioni per tutte le varianti di build in fase di compilazione.

Aggiungi il seguente flag al tuo file gradle.properties , quindi impostalo su false per disabilitare il plug-in Monitoraggio delle prestazioni.

// ...

// 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

Disabilita la libreria Android di monitoraggio delle prestazioni

Se disabiliti la libreria Performance Monitoring in fase di compilazione, puoi scegliere se consentire alla tua app di abilitare la libreria in fase di runtime.

Disabilita la libreria in fase di compilazione, ma consenti all'app di abilitarla in fase di runtime

Aggiungi il seguente elemento <meta-data> al file AndroidManifest.xml della tua app:

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

Disabilita la libreria in fase di compilazione, ma non consentire alla tua app di abilitarla in fase di runtime

Aggiungi il seguente elemento <meta-data> al file AndroidManifest.xml della tua app:

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

Disabilita la tua app in fase di esecuzione utilizzando Remote Config

Firebase Remote Config ti consente di apportare modifiche al comportamento e all'aspetto della tua app, quindi fornisce un modo ideale per consentirti di disabilitare il monitoraggio delle prestazioni nelle istanze distribuite della tua app.

Per disabilitare la raccolta dei dati di monitoraggio delle prestazioni al successivo avvio dell'app Android, utilizza il codice di esempio mostrato di seguito. Per ulteriori informazioni sull'utilizzo di Remote Config in un'app Android, consulta Utilizzare Firebase Remote Config su Android .

  1. Assicurati che Remote Config sia nella sezione dependencies del file Gradle del tuo modulo (a livello di app) (solitamente <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle ):

    Kotlin+KTX

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

    Java

      implementation("com.google.firebase:firebase-config:21.6.1")
    
  2. Configura Remote Config e disabilita il monitoraggio delle prestazioni se perf_disable è impostato su 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
            }
        }

    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
                    }
                }
            });
  3. Aggiungi il seguente codice a MainActivity.java per recuperare e attivare i valori di 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
            }
        }

    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
                    }
                }
            });
  4. Per disabilitare il monitoraggio delle prestazioni nella console Firebase, crea un parametro perf_disable nel progetto della tua app, quindi imposta il suo valore su true .

    Questa modifica effettuerà chiamate alle chiamate "nessuna operazione" (NOOP) di Performance Monitoring SDK, eliminando eventuali effetti significativi sulle prestazioni dell'app derivanti dall'uso di Performance Monitoring SDK nella tua app.

    Se imposti il ​​valore di perf_disable su false , il monitoraggio delle prestazioni rimane abilitato.