Monitoraggio delle prestazioni delle implementazioni delle funzionalità

1. Panoramica

In questo codelab, imparerai a monitorare le prestazioni della tua app durante l'implementazione di una funzionalità. La nostra app di esempio avrà funzionalità di base ed è configurata per visualizzare un'immagine di sfondo diversa in base a un flag di Firebase Remote Config. Esamineremo l'instrumentazione delle tracce per monitorare le prestazioni dell'app, l'implementazione di una modifica alla configurazione dell'app, il monitoraggio dell'effetto e vedremo come migliorare le prestazioni.

Obiettivi didattici

• Come aggiungere Firebase Performance Monitoring alla tua app mobile per ottenere metriche predefinite (come il tempo di avvio 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 di monitoraggio del rendimento per comprendere le metriche e monitorare 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 versione 8 o successive
• Una conoscenza di base di Firebase Remote Config

2. Configurare il progetto di esempio

Scarica il codice

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

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

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

Importa il progetto nella cartella firebase-perf-rc-android-start in Android Studio. Probabilmente vedrai alcune eccezioni di runtime o forse un avviso relativo a un file google-services.json mancante. Correggeremo questo problema nella prossima sezione.

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, tutto da Android Studio.

Connetti la tua app a Firebase

1. Vai ad Android Studio/Guida > Controlla aggiornamenti per assicurarti di utilizzare le versioni più recenti 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 connettere il tuo progetto Android a Firebase. (Si aprirà la console Firebase nel browser.)
5. Fai clic sul pulsante per creare un nuovo progetto, quindi inserisci un nome (ad esempio, Feature Rollout Performance Codelab).
6. Fai clic su Continua.
7. Se richiesto, leggi e accetta i termini di Firebase, quindi fai clic su Continua.
8. (Facoltativo) Attiva l'assistenza AI nella console Firebase (denominata "Gemini in Firebase").
9. Per questo codelab, non hai bisogno di Google Analytics, quindi disattiva l'opzione Google Analytics.
   Puoi attivare Google Analytics facoltativamente perché fornirà opzioni di targeting di Remote Config estese. Tuttavia, questo codelab utilizza un'opzione di targeting che non richiede Google Analytics.
10. Dovresti visualizzare una finestra di dialogo per collegare la nuova app Firebase al progetto Android Studio.
    
11. Fai clic su Connetti.
12. Apri Android Studio. Nel riquadro Assistente, vedrai la conferma che la tua app è connessa a Firebase.
    

Aggiungere Performance Monitoring alla tua app

Nel riquadro Assistente di Android Studio, fai clic su Aggiungi Performance Monitoring alla tua app.

Dovresti visualizzare una finestra di dialogo per Accettare modifiche, dopodiché Android Studio dovrebbe sincronizzare la tua app per assicurarsi che siano state aggiunte tutte le dipendenze necessarie.

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

Come passaggio aggiuntivo, attiva la registrazione di debug seguendo le istruzioni riportate nel passaggio "(Facoltativo) Attiva la registrazione 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 e la tua app dovrebbe ora essere compilata. In Android Studio, fai clic su Esegui > Esegui "app" per creare ed eseguire l'app nell'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:

Che cosa succede dietro le quinte?

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 imposterai nella dashboard di Remote Config più avanti in questo codelab.
2. In executeTasksBasedOnRC(), leggiamo il valore di configurazione del flag seasonal_image_url. Se viene fornito un URL dal valore di configurazione, 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. Configurare Remote Config

Ora che l'app è in esecuzione, puoi configurare il nuovo flag di funzionalità.

1. Nel riquadro a sinistra della console Firebase, individua la sezione Engage 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, quindi inserisci questa 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. Come nome della condizione, inserisci Seasonal image rollout.
6. Per la sezione Applies if..., seleziona User in random percentile <= 0%. (Vuoi lasciare la funzionalità 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 Crea il tuo primo parametro e individua il campo Valore per l'implementazione delle immagini stagionali. Inserisci l'URL da cui verrà scaricata l'immagine stagionale: https://images.unsplash.com/photo-1552691021-7043334e0b51
8. Lascia il valore predefinito come stringa vuota. Ciò significa che verrà mostrata l'immagine predefinita nel codebase 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

La tua app precarica alcuni dati prima di mostrare MainActivity e visualizza una schermata iniziale per nascondere questo processo. Non vuoi che gli utenti aspettino troppo a lungo in questa schermata, quindi in genere è utile monitorare per quanto tempo viene visualizzata la schermata iniziale.

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

Per monitorare la durata di visualizzazione della schermata iniziale, aggiungi una traccia di codice personalizzata a SplashScreenActivity, ovvero l'Activity che implementa la schermata iniziale.

1. Inizializza, crea e avvia una traccia di codice personalizzato 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 personalizzato che monitorerà il tempo aggiuntivo che la funzionalità ha aggiunto a SplashScreenActivity.

1. Inizializza, crea e avvia una traccia di codice personalizzato 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 personalizzato 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 visualizzare 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. Aggiungere un attributo personalizzato alla traccia

Per le tracce di codice personalizzato, 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 Firebase. Puoi anche aggiungere e monitorare attributi personalizzati.

Nella tua app, hai appena aggiunto due tracce di codice personalizzato 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à, potresti avere diversi URL da cui scaricare un'immagine.

Aggiungiamo quindi un attributo personalizzato che rappresenti l'URL dell'immagine stagionale a queste tracce di codice personalizzato. 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 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) a 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 logging che contiene 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 di traccia e li invierà a Firebase. Puoi visualizzare i dati nella dashboard Rendimento della console Firebase, che spiegheremo in dettaglio nel passaggio successivo del codelab.

7. Configurare la dashboard Performance Monitoring

Configurare la dashboard per monitorare la funzionalità

Nella console Firebase, seleziona il progetto con l'app Friendly Eats.

Nel riquadro a sinistra, individua la sezione Rilascia e monitora, quindi fai clic su Rendimento.

Dovresti visualizzare la dashboard Rendimento con i primi punti dati nel pannello delle metriche. L'SDK Performance Monitoring raccoglie i dati sulle prestazioni della tua app e li visualizza entro pochi minuti dalla raccolta.

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

1. Fai clic su una delle caselle vuote 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 e dovresti visualizzare la durata di splash_screen_trace aggiunta alla dashboard.

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

Il pannello delle metriche è uno strumento potente per monitorare il rendimento delle metriche chiave sperimentate dagli utenti. Per questo codelab, hai a disposizione un piccolo insieme di dati in un intervallo di tempo ristretto, quindi utilizzerai altre visualizzazioni della dashboard che ti aiuteranno a comprendere 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 Firebase per aumentare il percentile di utenti della condizione di targeting. In genere, implementi nuove funzionalità per una piccola parte degli utenti e aumenti la percentuale solo quando hai la certezza che non ci siano problemi. In questo codelab, però, sei l'unico utente dell'app, quindi puoi impostare il percentile al 100%.

1. Fai clic sulla scheda Condizioni nella parte superiore della pagina.
2. Fai clic sulla condizione Seasonal image rollout che hai aggiunto in precedenza.
3. Modifica il percentile al 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 visualizzare la nuova funzionalità. Dopo la schermata iniziale, dovresti vedere la nuova schermata principale vuota.

9. Controllare le variazioni del rendimento

Ora esaminiamo le prestazioni del caricamento della schermata iniziale utilizzando la dashboard Rendimento nella 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, quindi fai clic sulla scheda Tracce personalizzate. In questa tabella vedrai le tracce di codice personalizzato che hai aggiunto 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 impiegato per scaricare ed elaborare l'immagine. Dal valore Durata della traccia, puoi notare che il download e l'elaborazione richiedono molto tempo.

3. Poiché disponi dei dati per splash_seasonal_image_processing, puoi aggiungere la durata di questa traccia al pannello delle metriche nella parte superiore della scheda Dashboard.

Come in precedenza, fai clic su una delle caselle vuote Seleziona una metrica. 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 al pannello delle metriche.

4. Per confermare ulteriormente le differenze, puoi esaminare più da vicino i dati relativi a splash_screen_trace. Fai clic sulla scheda splash_screen_trace nel pannello delle metriche, poi su Visualizza dettagli metrica.

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

6. I valori della durata della schermata iniziale saranno probabilmente un po' diversi da quelli nello screenshot precedente, 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 più lunga potrebbe essere semplice, ma in un'app reale potrebbe non essere così ovvio. I dati sulla durata raccolti provengono da dispositivi diversi, che eseguono l'app in varie condizioni di connessione di rete, e queste condizioni potrebbero essere peggiori di quanto ti aspetti. Vediamo come esamineresti il problema in una situazione reale.

7. Fai clic su Rendimento nella parte superiore della pagina per tornare alla scheda principale Dashboard:
8. Nella tabella delle tracce in fondo alla pagina, fai clic sulla scheda Richieste di rete. In questa tabella vedrai 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 delle immagini (ovvero la durata della traccia splash_seasonal_image_processing), puoi notare che gran parte del tempo viene speso per il download dell'immagine.

Risultati relativi al rendimento

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

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

Nel passaggio successivo, ridurrai l'impatto sul rendimento eseguendo il rollback della funzionalità e identificando come migliorare l'implementazione.

10. Eseguire il rollback della funzionalità

Aumentare il tempo di attesa degli utenti durante la schermata iniziale non è auspicabile. Uno dei principali vantaggi di Remote Config è la possibilità di mettere in pausa e invertire l'implementazione senza dover rilasciare un'altra versione agli utenti. In questo modo, puoi reagire rapidamente ai problemi (come quelli di prestazioni che hai scoperto nel passaggio precedente) e ridurre al minimo il numero di utenti insoddisfatti.

Come mitigazione rapida, reimposta la percentuale 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 che hai aggiunto in precedenza.
4. Modifica il percentile impostandolo 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 visualizzare la schermata principale originale con lo stato vuoto:

11. Risolvi i problemi di rendimento

All'inizio del codelab hai scoperto che il download di un'immagine per la schermata iniziale causava il rallentamento dell'app. Esaminando più da vicino l'immagine scaricata, noti che stai utilizzando la risoluzione originale dell'immagine, che era superiore a 2 MB. Una soluzione rapida al problema di prestazioni è ridurre la qualità a una risoluzione più appropriata, in modo che l'immagine impieghi meno tempo per essere scaricata.

Esegui di nuovo il rollout 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 a 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 imposta di nuovo 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

Esegui l'app localmente

Con il nuovo valore di configurazione impostato per utilizzare un URL dell'immagine di download diverso, esegui di nuovo l'app. Questa volta, noterai che il tempo trascorso nella schermata iniziale è inferiore rispetto a prima.

Visualizzare il rendimento delle modifiche

Torna alla dashboard Rendimento nella console Firebase per vedere l'aspetto delle metriche.

1. Questa volta utilizzerai la tabella delle tracce per accedere alla pagina dei dettagli. 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 della 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 inferiore a quello dell'immagine precedente e più accettabile per i tuoi utenti.

3. Ora che hai migliorato il rendimento della schermata iniziale, puoi configurare avvisi che ti avvisano quando una traccia supera una soglia che hai impostato. Apri la dashboard Rendimento e fai clic sull'icona del menu overflow (tre puntini) per splash_screen_trace e poi su Impostazioni avvisi.

4. Fai clic sul pulsante di attivazione/disattivazione per abilitare l'avviso Durata. Imposta il valore soglia in modo che sia leggermente superiore al valore visualizzato. In questo modo, se 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, quindi fai clic sulla scheda Tracce personalizzate per verificare che l'avviso sia attivato.

13. Complimenti!

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

Argomenti trattati

• Aggiunta dell'SDK Firebase Performance Monitoring alla tua app
• Aggiungere una traccia di codice personalizzata al codice per misurare una funzionalità specifica
• Configurazione di un parametro di Remote Config e di un valore condizionale per controllare/implementare una nuova funzionalità
• Capire come utilizzare la dashboard di monitoraggio delle prestazioni per identificare i problemi durante un rollout
• Configurazione di avvisi sul rendimento per ricevere una notifica quando il rendimento della tua app supera una soglia che hai impostato

Scopri di più

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