Wyłącz Monitorowanie wydajności Firebase

Podczas tworzenia i testowania aplikacji warto wyłączyć monitorowanie wydajności.

Jeśli na przykład wyłączysz monitorowanie wydajności podczas tworzenia aplikacji, możesz:

  • Wyłącz niektóre funkcje monitorowania wydajności (takie jak te udostępniane przez wtyczkę Gradle monitorowania wydajności) w kompilacjach do debugowania, ale włącz je ponownie w kompilacji wersji.

  • Wyłącz monitorowanie wydajności podczas tworzenia aplikacji, ale zezwól aplikacji na jej ponowne włączanie w czasie działania.

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

Możesz też utworzyć aplikację z włączonym Monitorowaniem wydajności, ale używając Zdalnej konfiguracji Firebase, aby zapewnić elastyczność w wyłączaniu (i ponownym włączeniu) Monitorowania wydajności w aplikacji produkcyjnej. Dzięki tej opcji możesz nawet skonfigurować aplikację tak, aby użytkownicy mogli ją włączać lub wyłączać.

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

Aby wyłączyć monitorowanie wydajności podczas procesu kompilacji, wyłącz wtyczkę Gradle monitorowania wydajności lub wyłącz bibliotekę Androida monitorowania wydajności.

Wyłączenie wtyczki na etapie programowania i debugowania jest przydatne, ponieważ stosowanie przez nią ustawień może wydłużyć czas kompilacji. Być może warto jednak pozostawić włączoną bibliotekę, aby nadal mieć widoczne dane o wydajności z uruchamiania aplikacji, z aplikacji na pierwszym planie i z aplikacji w tle, a także ze wszystkich niestandardowych logów czasu kodu w aplikacji.

Wyłączanie wtyczki Gradle monitorowania wydajności

Możesz wyłączyć wtyczkę Monitorowanie wydajności, dodając flagę instrumentationEnabled za pomocą tych opcji:

  • Extension Property – wyłącza wtyczkę dla konkretnego wariantu kompilacji w czasie kompilacji

  • Project Property – wyłącza wtyczkę dla wszystkich wariantów kompilacji w czasie kompilacji

Wyłączanie wtyczki za pomocą flagi właściwości rozszerzenia

Używając flagi Extensions Property, możesz wyłączyć wtyczkę Monitorowania wydajności dla konkretnej wersji kompilacji podczas kompilacji.

  1. Sprawdź, czy w pliku Gradle na poziomie głównym (na poziomie projektu) (<project>/build.gradle.kts lub <project>/build.gradle) określono zależność wtyczki Androida do obsługi Gradle w wersji 3.4.0 lub nowszej.

    We wcześniejszych wersjach wtyczki Androida do obsługi Gradle nadal możesz wyłączyć wtyczkę Monitor wydajności dla określonej wersji kompilacji, ale jej czas trwania nie zostanie całkowicie wyeliminowany.

  2. Dodaj tę 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 wartość 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łączanie wtyczki za pomocą flagi właściwości projektu

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

Dodaj do pliku gradle.properties tę flagę, 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łączanie biblioteki monitorowania wydajności na Androida

Jeśli wyłączysz bibliotekę monitorowania wydajności podczas kompilacji, możesz zdecydować, czy chcesz zezwolić aplikacji na jej włączenie w czasie działania.

Wyłącz bibliotekę podczas kompilacji, ale zezwól aplikacji na jej włączenie w czasie działania

Dodaj ten element <meta-data> do pliku AndroidManifest.xml aplikacji:

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

Wyłącz bibliotekę w czasie kompilowania, ale nie zezwalaj aplikacji na włączanie jej w czasie działania

Dodaj ten element <meta-data> do pliku AndroidManifest.xml aplikacji:

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

Wyłączanie aplikacji w czasie działania za pomocą Zdalnej konfiguracji

Zdalna konfiguracja Firebase umożliwia wprowadzanie zmian w działaniu i wyglądzie aplikacji, dzięki czemu stanowi idealny sposób na wyłączenie monitorowania wydajności we wdrożonych instancjach aplikacji.

Aby wyłączyć zbieranie danych w ramach Monitorowania wydajności przy następnym uruchomieniu aplikacji na Androida, skorzystaj z przykładowego kodu podanego poniżej. Więcej informacji o korzystaniu ze Zdalnej konfiguracji w aplikacji na Androida znajdziesz w artykule o używaniu Zdalnej konfiguracji Firebase na Androidzie.

  1. Sprawdź, czy zdalna konfiguracja 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:22.0.0")

    Java 

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

  2. Skonfiguruj Zdalną konfigurację i wyłącz monitorowanie wydajności, jeśli perf_disable ma wartość 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. Dodaj do pliku MainActivity.java ten kod, 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
        }
    }
    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. Aby wyłączyć monitorowanie wydajności w konsoli Firebase, utwórz parametr perf_disable w projekcie aplikacji, a następnie ustaw jego wartość na true.

    Ta zmiana będzie powodować wywołania „brak operacji” w pakiecie SDK Performance Monitoring, co wyeliminuje znaczny wpływ korzystania z tego pakietu na wydajność aplikacji.

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