Firebase Performance Monitoring deaktivieren

Während der App-Entwicklung und beim Testen kann es hilfreich sein, Performance Monitoring

Wenn Sie beispielsweise Deaktivieren von Performance Monitoring während des App-Build-Prozesses, können Sie:

• Bestimmte Funktionen von Performance Monitoring (z. B. vom Performance Monitoring Gradle-Plug-in) in Ihren Debug-Builds verwenden, aber die Funktionen für Ihre Release-Build

• Deaktiviere Performance Monitoring beim Erstellen deiner App, erlaube deiner App aber, sie wieder zu aktivieren während der Laufzeit.

• Deaktivieren Sie Performance Monitoring beim Erstellen Ihrer App und erlauben Sie nicht, dass sie während der Laufzeit wieder aktiviert wird.

Sie können Ihre App auch mit aktiviertem Performance Monitoring erstellen, aber verwenden Sie Firebase Remote Config, um Ihnen Du kannst Performance Monitoring flexibel in deiner Produktions-App deaktivieren (und wieder aktivieren). Mit können Sie Ihre App sogar so konfigurieren, dass Nutzer mit Performance Monitoring.

Performance Monitoring während des App-Build-Prozesses deaktivieren

Sie können Performance Monitoring während des Build-Prozesses deaktivieren, indem Sie das Gradle-Plug-in Performance Monitoring deaktivieren und/oder durch Deaktivierung der Performance Monitoring-Android-Bibliothek

Während der Entwicklung und Fehlerbehebung ist es sinnvoll, das Plug-in zu deaktivieren, Instrumentierung durch das Plug-in kann die Build-Dauer erhöhen. Sie können die Bibliothek jedoch aktiviert lassen, damit Sie weiterhin Leistungsdaten aus Traces zum App-Start, zur App im Vordergrund und zur App im Hintergrund sowie alle Traces mit benutzerdefiniertem Code in Ihrer App sehen können.

Performance Monitoring-Gradle-Plug-in deaktivieren

Sie können das Plug-in Performance Monitoring deaktivieren, indem Sie ein instrumentationEnabled hinzufügen. mit den folgenden Optionen melden:

• Extension Property: deaktiviert das Plug-in für Eine bestimmte Build-Variante bei der Kompilierung

• Projekteigenschaft: Deaktiviert das Plug-in zur Kompilierungszeit für alle Buildvarianten.

Plug-in über ein Erweiterungs-Property-Flag deaktivieren

Mit einem Flag für Extensions-Properties können Sie das Performance Monitoring-Plug-in zur Compilezeit für eine bestimmte Buildvariante deaktivieren.

1. In der Gradle-Datei auf Stammebene (Projektebene) (<project>/build.gradle.kts oder <project>/build.gradle), achten Sie darauf, Die Abhängigkeit des Android-Gradle-Plug-ins ist als Version 3.4.0 oder höher angegeben.

   Bei früheren Versionen des Android-Gradle-Plug-ins können Sie das Plug-in Performance Monitoring für eine bestimmte Build-Variante, aber die Build-Zeit Beitrag für diese Variante nicht vollständig eliminiert.

2. Fügen Sie der Gradle-Datei des Moduls (auf App-Ebene) (in der Regel <project>/<app-module>/build.gradle.kts oder <project>/<app-module>/build.gradle) das folgende Flag hinzu und setzen Sie es dann auf false, um das Performance Monitoring-Plug-in zu deaktivieren.

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

Plug-in über ein Flag für Projekteigenschaften deaktivieren

Mit einem Project Property-Flag können Sie das Performance Monitoring-Plug-in für alle Build-Varianten zum Zeitpunkt der Kompilierung.

Fügen Sie der Datei gradle.properties das folgende Flag hinzu und legen Sie es auf false fest, um das Performance Monitoring-Plug-in zu deaktivieren.

// ...

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

Performance Monitoring-Android-Bibliothek deaktivieren

Wenn du die Performance Monitoring-Bibliothek bei der Kompilierung deaktivierst, kannst du auswählen, ob damit Ihre App die Bibliothek zur Laufzeit aktivieren kann.

Die Bibliothek bei der Kompilierung deaktivieren, aber Ihrer App erlauben, sie während der Laufzeit zu aktivieren

Füge dem AndroidManifest.xml deiner App das folgende <meta-data>-Element hinzu Datei:

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

Die Bibliothek bei der Kompilierung deaktivieren, aber nicht zulassen, dass Ihre App sie während der Laufzeit aktiviert

Füge dem AndroidManifest.xml deiner App das folgende <meta-data>-Element hinzu Datei:

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

Anwendung mit Remote Config zur Laufzeit deaktivieren

Mit Firebase Remote Config können Sie Verhalten und Darstellung ändern Ihrer App. Sie bietet daher eine ideale Möglichkeit, Performance Monitoring in bereitgestellten Instanzen Ihrer Anwendung.

Um die Datenerhebung durch Performance Monitoring zu deaktivieren, wenn Ihre Android-App das nächste Mal verwenden Sie den unten stehenden Beispielcode. Weitere Informationen zur Verwendung von Remote Config in einer Android-App finden Sie unter Firebase Remote Config unter Android verwenden.

1. Achten Sie darauf, dass sich Remote Config im Abschnitt dependencies Ihres module (App-Ebene) Gradle-Datei (in der Regel <project>/<app-module>/build.gradle.kts oder <project>/<app-module>/build.gradle):

   Kotlin+KTX

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

   Java

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

2. Remote Config einrichten und Performance Monitoring deaktivieren, wenn perf_disable festgelegt auf 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. Fügen Sie MainActivity.java den folgenden Code hinzu, um Remote Config-Werte abzurufen und zu aktivieren:

   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. Zum Deaktivieren von Performance Monitoring in der Firebase-Konsole erstellen Sie ein perf_disable-Element im Projekt Ihrer App und legen Sie dessen Wert auf true fest.

   Durch diese Änderung wird das Performance Monitoring-SDK aufgerufen, dass kein Vorgang ausgeführt wird. Anrufe (NOOPs). Dadurch werden sämtliche Auswirkungen auf die App-Leistung beseitigt, das Performance Monitoring SDK in Ihrer App.

   Wenn Sie den Wert von perf_disable auf false setzen, bleibt Performance Monitoring unverändert. aktiviert.