Monitoraggio delle prestazioni delle implementazioni delle funzionalità

1. Panoramica

In questo codelab imparerai a monitorare le prestazioni della tua app durante il lancio di una funzionalità. La nostra app di esempio avrà funzionalità di base ed è impostata per visualizzare un'immagine di sfondo diversa in base a un flag di Firebase Remote Config. Esamineremo l'applicazione di tracce per monitorare le prestazioni dell'app, implementeremo una modifica di configurazione dell'app, ne monitoreremo l'effetto e vedremo come possiamo migliorare le prestazioni.

Obiettivi didattici

• Come aggiungere Firebase Performance Monitoring alla tua app mobile per ottenere metriche immediate (ad esempio l'ora di inizio dell'app e i frame lenti o bloccati)
• Come aggiungere tracce personalizzate per comprendere i percorsi di codice critici dei percorsi degli utenti
• Come utilizzare la dashboard Performance Monitoring per comprendere le metriche e tenere traccia di modifiche importanti come l'implementazione di una funzionalità
• Come configurare gli avvisi sul rendimento per monitorare le metriche chiave
• Come implementare una modifica di Firebase Remote Config

Prerequisiti

• Android Studio 4.0 o versioni successive
• Un emulatore Android con livello API 16 o superiore.
• Java 8 o versioni successive
• Conoscenza di base di Firebase Remote Config

2. Configura il progetto di esempio

Scarica il codice

Esegui questo comando per clonare il codice campione per questo codelab. Verrà creata una cartella denominata codelab-perf-rc-android sul computer:

$ git clone https://github.com/FirebaseExtended/codelab-feature-rollout-performance.git

Se non hai Git sul computer, puoi anche scaricare il codice direttamente da GitHub.

Importa il progetto nella cartella firebase-perf-rc-android-start in Android Studio. È probabile che vengano visualizzate alcune eccezioni di runtime o un avviso relativo a un file google-services.json mancante. Correggeremo questo problema nella sezione successiva.

In questo codelab utilizzerai il plug-in Firebase Assistant per registrare la tua app per Android con un progetto Firebase e aggiungere i file di configurazione, i plug-in e le dipendenze Firebase necessari al tuo progetto Android, il tutto da Android Studio.

Collegare l'app a Firebase

1. Vai ad Android Studio/Guida > Verifica la disponibilità di aggiornamenti per assicurarti di utilizzare le ultime versioni di Android Studio e dell'Assistente Firebase.
2. Seleziona Strumenti > Firebase per aprire il riquadro Assistente.

3. Scegli Performance Monitoring da aggiungere alla tua app, poi fai clic su Inizia a utilizzare Performance Monitoring.
4. Fai clic su Connetti a Firebase per collegare il tuo progetto Android a Firebase (si aprirà la console Firebase nel browser).
5. Nella console Firebase, fai clic su Aggiungi progetto e inserisci un nome per il progetto Firebase (se ne hai già uno, puoi selezionare il progetto esistente). Fai clic su Continua e accetta i termini per creare il progetto Firebase e una nuova app Firebase.

A questo punto dovresti visualizzare una finestra di dialogo per collegare la nuova app Firebase al tuo progetto Android Studio.

6. Fai clic su Connetti.
7. Apri Android Studio. Nel riquadro Assistente viene visualizzata la conferma che la tua app è collegata a Firebase.

Aggiungere Performance Monitoring all'app

Nel riquadro Assistente di Android Studio, fai clic su Aggiungi Performance Monitoring all'app.

Dovresti visualizzare una finestra di dialogo Accetta modifiche, dopodiché Android Studio deve sincronizzare l'app per assicurarsi che siano state aggiunte tutte le dipendenze necessarie.

Infine, nel riquadro Assistente di Android Studio dovresti vedere il messaggio che indica che tutte le dipendenze sono configurate correttamente.

Come passaggio aggiuntivo, attiva il logging di debug seguendo le istruzioni riportate nel passaggio "(Facoltativo) Attivare il logging di debug". Le stesse istruzioni sono disponibili anche nella documentazione pubblica.

3. Esegui l'app

Ora dovresti vedere il file google-services.json nella directory del modulo (a livello di app) della tua app, che ora dovrebbe essere compilata. In Android Studio, fai clic su Esegui > Esegui "app" per creare ed eseguire l'app sull'emulatore Android.

Quando l'app è in esecuzione, dovresti prima vedere una schermata iniziale come questa:

Dopo alcuni secondi, viene visualizzata la pagina principale con l'immagine predefinita:

Cosa succede sotto il cofano?

La schermata iniziale è implementata in SplashScreenActivity e svolge le seguenti operazioni:

1. In onCreate(), inizializziamo le impostazioni di Firebase Remote Config e recuperiamo i valori di configurazione che definirai nella dashboard di Remote Config più avanti in questo codelab.
2. In executeTasksBasedOnRC() leggiamo il valore di configurazione del flag seasonal_image_url. Se il valore config fornisce un URL, scarichiamo l'immagine in modo sincrono.
3. Al termine del download, l'app passa a MainActivity e chiama finish() per terminare SplashScreenActivity.

In MainActivity, se seasonal_image_url è definito tramite Remote Config, la funzionalità verrà attivata e l'immagine scaricata verrà visualizzata come sfondo della pagina principale. In caso contrario, verrà visualizzata l'immagine predefinita (mostrata sopra).

4. Configura Remote Config

Ora che la tua app è in esecuzione, puoi configurare il nuovo flag della funzionalità.

1. Nel riquadro a sinistra della Console Firebase, individua la sezione Coinvolgimento e poi fai clic su Remote Config.
2. Fai clic sul pulsante Crea configurazione per aprire il modulo di configurazione e aggiungere seasonal_image_url come chiave del parametro.
3. Fai clic su Aggiungi descrizione, poi inserisci la descrizione: Shows a seasonal image (replaces default) in the main page when the restaurant list is empty.
4. Fai clic su Aggiungi nuovo -> Valore condizionale -> Crea nuova condizione.
5. Per il nome della condizione, inserisci Seasonal image rollout.
6. Per la sezione Applies if..., seleziona User in random percentile <= 0%. Lasciala disattivata fino a quando non sarà il momento di implementarla in un passaggio successivo.
7. Fai clic su Crea condizione. Utilizzerai questa condizione in un secondo momento per implementare la nuova funzionalità per i tuoi utenti.

7. Apri il modulo per la creazione del primo parametro e individua il campo Valore per l'implementazione delle immagini stagionali. Inserisci l'URL in cui verrà scaricata l'immagine stagionale: https://images.unsplash.com/photo-1552691021-7043334e0b51
8. Lascia il valore predefinito su una stringa vuota. Ciò significa che verrà mostrata l'immagine predefinita nel codice di base anziché un'immagine scaricata da un URL.
9. Fai clic su Salva.

Puoi vedere che la nuova configurazione viene creata come bozza.

10. Fai clic su Pubblica modifiche e conferma le modifiche in alto per aggiornare l'app.

5. Aggiungere il monitoraggio del tempo di caricamento dei dati

L'app precarica alcuni dati prima di mostrare MainActivity e mostra una schermata iniziale per nascondere questa procedura. Non vuoi che gli utenti aspettino troppo in questa schermata, quindi in genere è utile monitorare il tempo di visualizzazione della schermata iniziale.

Firebase Performance Monitoring offre un modo per farlo. Puoi impostare le tracce di codice personalizzato per monitorare le prestazioni di un codice specifico nella tua app, ad esempio il tempo di caricamento dei dati e il tempo di elaborazione della nuova funzionalità.

Per monitorare il tempo di visualizzazione della schermata iniziale, dovrai aggiungere una traccia di codice personalizzata a SplashScreenActivity, ovvero il Activity che implementa la schermata iniziale.

1. Inizializza, crea e avvia una traccia di codice personalizzata denominata splash_screen_trace:

SplashScreenActivity.java

// ...
import com.google.firebase.perf.FirebasePerformance;
import com.google.firebase.perf.metrics.Trace;
// ...

public class SplashScreenActivity extends AppCompatActivity {

    private static final String TAG = "SplashScreenActivity";
    private static final String SEASONAL_IMAGE_URL_RC_FLAG = "seasonal_image_url";

    // TODO: Initialize splash_screen_trace
    private final Trace splashScreenTrace = FirebasePerformance.startTrace("splash_screen_trace");
    
    // ...
}

2. Termina la traccia nel metodo onDestroy() di SplashScreenActivity:

SplashScreenActivity.java

@Override
protected void onDestroy() {
    super.onDestroy();

    // TODO: Stop the splash_screen_trace here
    splashScreenTrace.stop();
}

Poiché la nuova funzionalità scarica ed elabora un'immagine, aggiungerai una seconda traccia di codice personalizzata che terrà traccia del tempo aggiuntivo che la funzionalità è stata aggiunta a SplashScreenActivity.

1. Inizializza, crea e avvia una traccia di codice personalizzata denominata splash_seasonal_image_processing:

SplashScreenActivity.java

private void executeTasksBasedOnRC(FirebaseRemoteConfig rcConfig) {
    String seasonalImageUrl = rcConfig.getString(SEASONAL_IMAGE_URL_RC_FLAG);
    Log.d(TAG, SEASONAL_IMAGE_URL_RC_FLAG + ": " + seasonalImageUrl);

    if (!seasonalImageUrl.isEmpty()) {
        // TODO: Start the splash_seasonal_image_processing here
        final Trace seasonalImageProcessingTrace = FirebasePerformance
            .startTrace("splash_seasonal_image_processing");

        // ...
    }
}

2. Termina la traccia nei metodi onLoadFailed() e onResourceReady() di RequestListener:

SplashScreenActivity.java

Glide.with(SplashScreenActivity.this.getApplicationContext())
    .asBitmap()
    .load(seasonalImageUrl)
    .signature(new ObjectKey(Utils.getCacheUUID()))
    .listener(new RequestListener<Bitmap>() {
        @Override
        public boolean onLoadFailed(
            @Nullable GlideException e,
            Object model, Target<Bitmap> target,
            boolean isFirstResource) {

            // TODO: Stop the splash_seasonal_image_processing here
            seasonalImageProcessingTrace.stop();

            launchMainActivity();
            return true;
        }

        @Override
        public boolean onResourceReady(Bitmap resource, Object model,
            Target<Bitmap> target, DataSource dataSource,
            boolean isFirstResource) {

            // TODO: Stop the splash_seasonal_image_processing here
            seasonalImageProcessingTrace.stop();

            launchMainActivity();
            return true;
        }
     })
     .preload();

Ora che hai aggiunto tracce di codice personalizzate per monitorare la durata della schermata iniziale (splash_screen_trace)) e il tempo di elaborazione della nuova funzionalità (splash_seasonal_image_processing), esegui di nuovo l'app in Android Studio. Dovresti vedere un messaggio di logging contenente Logging trace metric: splash_screen_trace, seguito dalla durata della traccia. Non vedrai un messaggio di log per splash_seasonal_image_processing perché non hai ancora attivato la nuova funzionalità.

6. Aggiungi un attributo personalizzato alla traccia

Per le tracce di codice personalizzate, Performance Monitoring registra automaticamente gli attributi predefiniti (metadati comuni come versione dell'app, paese, dispositivo e così via) in modo da poter filtrare i dati per la traccia nella console di Firebase. Puoi anche aggiungere e monitorare gli attributi personalizzati.

Nella tua app hai appena aggiunto due tracce di codice personalizzate per monitorare la durata della schermata iniziale e il tempo di elaborazione della nuova funzionalità. Un fattore che potrebbe influire su queste durate è se l'immagine visualizzata è quella predefinita o se deve essere scaricata da un URL. E chissà, alla fine potrebbero esserci diversi URL da cui scaricare un'immagine.

Aggiungiamo quindi a queste tracce di codice personalizzate un attributo personalizzato che rappresenti l'URL dell'immagine stagionale. In questo modo, potrai filtrare i dati sulla durata in base a questi valori in un secondo momento.

1. Aggiungi l'attributo personalizzato (seasonal_image_url_attribute) per splash_screen_trace all'inizio del metodo executeTasksBasedOnRC:

SplashScreenActivity.java

private void executeTasksBasedOnRC(FirebaseRemoteConfig rcConfig) {
    String seasonalImageUrl = rcConfig.getString(SEASONAL_IMAGE_URL_RC_FLAG);
    Log.d(TAG, SEASONAL_IMAGE_URL_RC_FLAG + ": " + seasonalImageUrl);

    // TODO: Add a custom attribute "seasonal_image_url_attribute" to splash_screen_trace
    if (seasonalImageUrl.isEmpty()) {
        splashScreenTrace.putAttribute("seasonal_image_url_attribute", "unset");
    } else {
        splashScreenTrace.putAttribute("seasonal_image_url_attribute", seasonalImageUrl);
    }

    // ...
}

2. Aggiungi lo stesso attributo personalizzato per splash_seasonal_image_processing subito dopo la chiamata a startTrace("splash_seasonal_image_processing"):

SplashScreenActivity.java

if (!seasonalImageUrl.isEmpty()) {
    // TODO: Start the splash_seasonal_image_processing here
    final Trace seasonalImageProcessingTrace = FirebasePerformance
        .startTrace("splash_seasonal_image_processing");

    // TODO: Add a custom attribute "seasonal_image_url_attribute" to splash_seasonal_image_processing
    seasonalImageProcessingTrace
        .putAttribute("seasonal_image_url_attribute", seasonalImageUrl);

    // ...
}

Ora che hai aggiunto un attributo personalizzato (seasonal_image_url_attribute) per entrambe le tracce personalizzate (splash_screen_trace e splash_seasonal_image_processing), esegui di nuovo l'app in Android Studio. Dovresti visualizzare un messaggio di log contenente Setting attribute 'seasonal_image_url_attribute' to 'unset' on trace 'splash_screen_trace'. Non hai ancora attivato il parametro Remote Config seasonalImageUrl, motivo per cui il valore dell'attributo è unset.

L'SDK Performance Monitoring raccoglierà i dati traccianti e li invierà a Firebase. Puoi visualizzare i dati nella dashboard Rendimento della Console Firebase, che illustreremo nel dettaglio nel passaggio successivo del codelab.

7. Configurare la dashboard Rendimento

Configurare la dashboard per monitorare la funzionalità

Nella Console Firebase, seleziona il progetto che contiene l'app Friendly Eats.

Nel riquadro di sinistra, individua la sezione Release e monitoraggio e poi fai clic su Rendimento.

Nella scheda delle metriche dovresti vedere la dashboard Rendimento con i tuoi primi punti dati. L'SDK Performance Monitoring raccoglie i dati sul rendimento della tua app e li mostra entro pochi minuti dalla raccolta.

In questa scheda puoi monitorare le metriche chiave della tua app. La visualizzazione predefinita include la durata dell'analisi del momento di inizio dell'app, ma puoi aggiungere le metriche che più ti interessano. Poiché stai monitorando la nuova funzionalità che hai aggiunto, puoi personalizzare la dashboard in modo da visualizzare la durata della traccia del codice personalizzato splash_screen_trace.

1. Fai clic su una delle caselle vuote di Seleziona una metrica.
2. Nella finestra di dialogo, seleziona il tipo di traccia Tracce personalizzate e il nome della traccia splash_screen_trace.

3. Fai clic su Seleziona metrica. Dovresti vedere la durata di splash_screen_trace aggiunta alla tua dashboard.

Puoi utilizzare gli stessi passaggi per aggiungere altre metriche che ti interessano, in modo da vedere rapidamente come cambia il loro rendimento nel tempo e anche con release diverse.

La scheda delle metriche è un potente strumento per monitorare il rendimento delle metriche chiave utilizzate dagli utenti. Per questo codelab, hai a disposizione un piccolo insieme di dati in un intervallo di tempo limitato, quindi utilizzerai altre visualizzazioni della dashboard che ti aiuteranno a capire il rendimento dell'implementazione della funzionalità.

8. Implementare la funzionalità

Ora che hai configurato il monitoraggio, puoi implementare la modifica di Firebase Remote Config (seasonal_image_url)) che hai configurato in precedenza.

Per implementare una modifica, torna alla pagina Remote Config nella console di Firebase per aumentare il percentile di utenti della condizione di targeting. In genere, implementi le nuove funzionalità per una piccola parte di utenti e aumenti la percentuale solo quando hai la certezza che non ci siano problemi. Tuttavia, in questo codelab siete gli unici utenti dell'app, quindi potete impostare il percentile al 100%.

1. Fai clic sulla scheda Condizioni nella parte superiore della pagina.
2. Fai clic sulla condizione Seasonal image rollout aggiunta in precedenza.
3. Modifica il percentile in 100%.
4. Fai clic su Salva condizione.
5. Fai clic su Pubblica modifiche e conferma le modifiche.

Torna in Android Studio e riavvia l'app nell'emulatore per vedere la nuova funzionalità. Dopo la schermata iniziale, dovresti vedere la nuova schermata principale con stato vuoto.

9. Controllare le modifiche al rendimento

Ora puoi controllare il rendimento del caricamento della schermata iniziale utilizzando la dashboard Rendimento della Console Firebase. In questo passaggio del codelab, utilizzerai diverse parti della dashboard per visualizzare i dati sul rendimento.

1. Nella scheda principale Dashboard, scorri verso il basso fino alla tabella delle tracce e poi fai clic sulla scheda Tracce personalizzate. In questa tabella vengono visualizzate le tracce di codice personalizzato aggiunte in precedenza, oltre ad alcune tracce predefinite.
2. Ora che hai attivato la nuova funzionalità, cerca la traccia di codice personalizzato splash_seasonal_image_processing, che ha misurato il tempo necessario per scaricare ed elaborare l'immagine. Dal valore Durata della traccia, puoi vedere che il download e l'elaborazione richiedono una quantità di tempo significativa.

3. Poiché hai dati per splash_seasonal_image_processing, puoi aggiungere la durata di questa traccia alla scheda delle metriche nella parte superiore della scheda Dashboard.

Come in precedenza, fai clic su una delle caselle Seleziona una metrica vuote. Nella finestra di dialogo, seleziona il tipo di traccia Tracce personalizzate e il nome della traccia splash_seasonal_image_processing. Infine, fai clic su Seleziona metrica per aggiungere questa metrica alla scheda delle metriche.

4. Per confermare ulteriormente le differenze, puoi esaminare più approfonditamente i dati relativi al periodo splash_screen_trace. Fai clic sulla scheda splash_screen_trace nel riquadro delle metriche, poi fai clic su Visualizza dettagli metrica.

5. Nella pagina dei dettagli, in basso a sinistra viene visualizzato un elenco di attributi, incluso l'attributo personalizzato creato in precedenza. Fai clic sull'attributo personalizzato seasonal_image_url_attribute per visualizzare la durata della schermata iniziale per ogni URL dell'immagine stagionale a destra:

6. I valori della durata della schermata iniziale saranno probabilmente un po' diversi da quelli nello screenshot sopra, ma dovresti avere una durata maggiore quando l'immagine viene scaricata da un URL rispetto all'utilizzo dell'immagine predefinita (rappresentata da "unset").

In questo codelab, il motivo di questa durata maggiore potrebbe essere semplice, ma in un'app reale potrebbe non essere così evidente. I dati sulla durata raccolti provengono da dispositivi diversi che eseguono l'app in diverse condizioni di connessione di rete e queste condizioni potrebbero essere peggiori del tuo previsto. Diamo un'occhiata a come esamineresti il problema nel caso in cui si trattasse di una situazione reale.

7. Fai clic su Rendimento nella parte superiore della pagina per tornare alla scheda principale Dashboard:
8. Nella tabella delle tracce nella parte inferiore della pagina, fai clic sulla scheda Richieste di rete. In questa tabella vengono visualizzate tutte le richieste di rete della tua app aggregate in pattern URL, incluso il pattern URL images.unsplash.com/**. Se confronti il valore di questo tempo di risposta con il tempo complessivo necessario per il download e l'elaborazione dell'immagine (ovvero la durata della traccia splash_seasonal_image_processing), puoi notare che gran parte del tempo viene impiegata per il download dell'immagine.

Risultati sul rendimento

Utilizzando Firebase Performance Monitoring, hai riscontrato il seguente impatto sugli utenti finali con la nuova funzionalità attivata:

1. Il tempo di utilizzo di SplashScreenActivity è aumentato.
2. La durata di splash_seasonal_image_processing è stata molto elevata.
3. Il ritardo era dovuto al tempo di risposta per il download dell'immagine e al tempo di elaborazione corrispondente necessario per l'immagine.

Nel passaggio successivo, attenuerai l'impatto sul rendimento ripristinando la funzionalità e identificando le modalità di miglioramento dell'implementazione.

10. Esegui il rollback della funzionalità

Aumentare il numero di durante la schermata iniziale non è consigliabile. Uno dei principali vantaggi di Remote Config è la possibilità di mettere in pausa e annullare l'implementazione senza dover rilasciare un'altra versione agli utenti. In questo modo puoi reagire rapidamente ai problemi (come quelli di prestazioni rilevati nell'ultimo passaggio) e ridurre al minimo il numero di utenti insoddisfatti.

Come soluzione rapida, reimposta il percentile di implementazione su 0 in modo che tutti gli utenti vedano di nuovo l'immagine predefinita:

1. Torna alla pagina Remote Config nella Console Firebase.
2. Fai clic su Condizioni nella parte superiore della pagina.
3. Fai clic sulla condizione Seasonal image rollout aggiunta in precedenza.
4. Modifica il percentile su 0%.
5. Fai clic su Salva condizione.
6. Fai clic su Pubblica modifiche e conferma le modifiche.

Riavvia l'app in Android Studio e dovresti vedere la schermata principale dello stato vuoto originale:

11. Risolvere i problemi di prestazioni

In precedenza, nel codelab hai scoperto che il download di un'immagine per la tua schermata iniziale ha causato il rallentamento della tua app. Dando un'occhiata più da vicino all'immagine scaricata, puoi notare che stai utilizzando la risoluzione originale dell'immagine, che era superiore a 2 MB. Una soluzione rapida al problema di rendimento consiste nel ridurre la qualità a una risoluzione più appropriata, in modo che il download dell'immagine richieda meno tempo.

Esegui di nuovo l'implementazione del valore di Remote Config

1. Torna alla pagina Remote Config nella console Firebase.
2. Fai clic sull'icona Modifica per il parametro seasonal_image_url.
3. Aggiorna il Valore per l'implementazione delle immagini stagionali in https://images.unsplash.com/photo-1552691021-7043334e0b51?w=640, poi fai clic su Salva.

4. Fai clic sulla scheda Condizioni nella parte superiore della pagina.
5. Fai clic su Implementazione delle immagini stagionali, quindi reimposta il percentile su 100%.
6. Fai clic su Salva condizione.

7. Fai clic sul pulsante Pubblica modifiche.

12. Testa la correzione e configura gli avvisi

Eseguire l'app localmente

Dopo aver impostato il nuovo valore di configurazione in modo da utilizzare un URL dell'immagine di download diverso, esegui di nuovo l'app. Questa volta, dovresti notare che il tempo trascorso sulla schermata iniziale è più breve di prima.

Visualizzare il rendimento delle modifiche

Torna alla dashboard Rendimento nella Console Firebase per visualizzare l'aspetto delle metriche.

1. Questa volta utilizzerai la tabella delle tracce per accedere alla pagina dei dettagli. In basso nella tabella delle tracce, nella scheda Tracce personalizzate, fai clic sulla traccia personalizzata splash_seasonal_image_processing per visualizzare di nuovo una visualizzazione più dettagliata della metrica relativa alla durata.

2. Fai clic sull'attributo personalizzato seasonal_image_url_attribute per visualizzare di nuovo la suddivisione degli attributi personalizzati. Se passi il mouse sopra gli URL, vedrai un valore che corrisponde al nuovo URL dell'immagine di dimensioni ridotte: https://images.unsplash.com/photo-1552691021-7043334e0b51?w=640 (con ?w=640 alla fine). Il valore della durata associato a questa immagine è notevolmente più breve del valore dell'immagine precedente e più accettabile per i tuoi utenti.

3. Ora che hai migliorato le prestazioni della schermata iniziale, puoi configurare avvisi che ti informeranno quando una traccia supera una soglia da te impostata. Apri la dashboard Rendimento e fai clic sull'icona del menu extra (con tre puntini) per splash_screen_trace, quindi fai clic su Impostazioni avvisi.

4. Fai clic sul pulsante di attivazione/disattivazione per attivare l'avviso Durata. Imposta il valore della soglia in modo che sia leggermente superiore al valore visualizzato. In questo modo, se la soglia splash_screen_trace supera la soglia, riceverai un'email.

5. Fai clic su Salva per creare l'avviso. Scorri verso il basso fino alla tabella delle tracce, poi fai clic sulla scheda Tracce personalizzate per verificare che l'avviso sia attivo.

13. Complimenti!

Complimenti! Hai abilitato l'SDK Firebase Performance Monitoring e raccolto tracce per misurare le prestazioni di una nuova funzionalità. Hai monitorato le principali metriche sulle prestazioni per l'implementazione di una nuova funzionalità e hai reagito rapidamente quando è stato rilevato un problema di prestazioni. Tutto ciò è stato possibile grazie alla possibilità di apportare modifiche alla configurazione con Remote Config e di monitorare i problemi di prestazioni in tempo reale.

Argomenti trattati

• Aggiunta dell'SDK Firebase Performance Monitoring alla tua app
• Aggiunta di una traccia di codice personalizzata al codice per misurare una funzionalità specifica
• L'impostazione di un parametro Remote Config e di un valore condizionale per controllare/implementare una nuova funzionalità
• Informazioni su come utilizzare la dashboard di monitoraggio delle prestazioni per identificare i problemi durante un'implementazione
• Configurare gli avvisi sulle prestazioni per ricevere una notifica quando le prestazioni della tua app superano una soglia impostata

Scopri di più

• firebase.google.com
• Iniziare a utilizzare Performance Monitoring per Android
• Iniziare a utilizzare Firebase Remote Config