Wyłącz monitorowanie wydajności Firebase

Podczas tworzenia i testowania aplikacji przydatne może się okazać wyłączenie monitorowania wydajności.

Na przykład wyłączając Monitorowanie wydajności podczas procesu tworzenia aplikacji , możesz:

  • Wyłącz pewne funkcje monitorowania wydajności (takie jak te udostępniane przez wtyczkę Performance Monitoring Gradle ) w kompilacjach debugowania, ale włącz ponownie funkcje kompilacji wydania.

  • Wyłącz monitorowanie wydajności podczas tworzenia aplikacji, ale pozwól aplikacji na ponowne włączenie jej w czasie wykonywania.

  • Wyłącz monitorowanie wydajności podczas tworzenia aplikacji i nie zezwalaj aplikacji na jej ponowne włączenie w czasie wykonywania.

Możesz także zbudować aplikację z włączonym monitorowaniem wydajności, ale użyj Firebase Remote Config, aby zapewnić sobie elastyczność w zakresie wyłączania (i ponownego włączania) monitorowania wydajności w aplikacji produkcyjnej. Dzięki tej opcji możesz nawet skonfigurować aplikację tak, aby użytkownicy mogli wyrazić zgodę lub zrezygnować z monitorowania wydajności.

Wyłącz monitorowanie wydajności podczas procesu tworzenia aplikacji

Możesz wyłączyć monitorowanie wydajności podczas procesu kompilacji , wyłączając wtyczkę Performance Monitoring Gradle i/lub wyłączając bibliotekę systemu Android do monitorowania wydajności .

Podczas programowania i debugowania wyłączenie wtyczki jest przydatne, ponieważ instrumentacja wtyczki może przyczynić się do wydłużenia czasu kompilacji. Można jednak rozważyć pozostawienie włączonej biblioteki, aby nadal móc przeglądać dane dotyczące wydajności od uruchomienia aplikacji, ślady aplikacji na pierwszym planie i aplikacji w tle, a także wszelkie niestandardowe ślady kodu w aplikacji.

Wyłącz wtyczkę Gradle do monitorowania wydajności

Możesz wyłączyć wtyczkę Performance Monitoring, dodając flagę instrumentationEnabled , korzystając z następujących opcji:

Wyłącz wtyczkę za pomocą flagi właściwości rozszerzenia

Używając flagi właściwości rozszerzeń , możesz wyłączyć wtyczkę monitorowania wydajności dla określonego wariantu kompilacji w czasie kompilacji.

  1. W pliku Gradle na poziomie głównym (na poziomie projektu) ( <project>/build.gradle.kts lub <project>/build.gradle ) upewnij się, że zależność wtyczki Gradle dla systemu Android jest określona jako wersja 3.4.0 lub nowsza.

    W przypadku wcześniejszych wersji wtyczki Android Gradle nadal możesz wyłączyć wtyczkę monitorowania wydajności dla określonego wariantu kompilacji, ale wkład w czas kompilacji dla tego wariantu nie zostanie całkowicie wyeliminowany.

  2. Dodaj następującą flagę do pliku Gradle modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle ), a następnie ustaw ją na false , aby wyłączyć wtyczkę monitorowania wydajności.

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

Wyłącz wtyczkę za pomocą flagi właściwości projektu

Używając flagi właściwości projektu , możesz wyłączyć wtyczkę monitorowania wydajności dla wszystkich wariantów kompilacji w czasie kompilacji.

Dodaj następującą flagę do pliku gradle.properties , a następnie ustaw ją na false , aby wyłączyć wtyczkę monitorowania wydajności.

// ...

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

Wyłącz bibliotekę Androida do monitorowania wydajności

Jeśli wyłączysz bibliotekę monitorowania wydajności w czasie kompilacji, możesz zdecydować, czy zezwolić aplikacji na włączanie biblioteki w czasie wykonywania.

Wyłącz bibliotekę w czasie kompilacji, ale pozwól aplikacji na włączenie jej w czasie wykonywania

Dodaj następujący element <meta-data> do pliku AndroidManifest.xml swojej aplikacji:

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

Wyłącz bibliotekę w czasie kompilacji, ale nie zezwalaj aplikacji na włączanie jej w czasie wykonywania

Dodaj następujący element <meta-data> do pliku AndroidManifest.xml swojej aplikacji:

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

Wyłącz aplikację w czasie wykonywania za pomocą zdalnej konfiguracji

Firebase Remote Config umożliwia wprowadzanie zmian w zachowaniu i wyglądzie aplikacji, dlatego stanowi idealny sposób na wyłączenie monitorowania wydajności we wdrożonych instancjach aplikacji.

Aby wyłączyć zbieranie danych przez monitorowanie wydajności przy następnym uruchomieniu aplikacji na Androida, użyj przykładowego kodu pokazanego poniżej. Aby uzyskać więcej informacji na temat korzystania ze zdalnej konfiguracji w aplikacji na Androida, zobacz Korzystanie ze zdalnej konfiguracji Firebase na Androidzie .

  1. Upewnij się, że Remote Config znajduje się w sekcji dependencies pliku Gradle modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <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. Skonfiguruj zdalną konfigurację i wyłącz monitorowanie wydajności, jeśli perf_disable jest ustawione na 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. Dodaj następujący kod do MainActivity.java , aby pobrać i aktywować wartości zdalnej konfiguracji:

    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. Aby wyłączyć monitorowanie wydajności w konsoli Firebase, utwórz parametr perf_disable w projekcie swojej aplikacji, a następnie ustaw jego wartość na true .

    Ta zmiana spowoduje wywołania „braku operacji” zestawu SDK do monitorowania wydajności (NOOP), eliminując wszelkie znaczące skutki używania zestawu SDK do monitorowania wydajności w aplikacji.

    Jeśli ustawisz wartość perf_disable na false , monitorowanie wydajności pozostanie włączone.