Monitorowanie wydajności wdrożeń funkcji

1. Omówienie

Z tego ćwiczenia w Codelabs dowiesz się, jak monitorować wydajność aplikacji podczas wdrażania funkcji. Nasza przykładowa aplikacja będzie miała podstawowe funkcje i jest skonfigurowana do wyświetlania innego obrazu tła na podstawie flagi Zdalnej konfiguracji Firebase. Omówimy dane instrumentacji, aby monitorować wydajność aplikacji, wprowadzać zmiany w jej konfiguracji, sprawdzać efekty i sprawdzać, jak możemy poprawić wydajność.

Czego się nauczysz

• Jak dodać Monitorowanie wydajności Firebase do aplikacji mobilnej, aby uzyskiwać gotowe dane (takie jak czas uruchamiania aplikacji oraz spowolnione lub zablokowane klatki)
• Jak dodawać niestandardowe logi czasu, aby analizować krytyczne ścieżki kodu ścieżek użytkowników
• Jak korzystać z panelu monitorowania wydajności, aby analizować dane i śledzić ważne zmiany, takie jak wdrożenie funkcji
• Jak skonfigurować alerty dotyczące skuteczności, aby monitorować kluczowe dane
• Jak wprowadzić zmianę w Zdalnej konfiguracji Firebase

Wymagania wstępne

• Android Studio 4.0 lub nowszy
• Emulator Androida z interfejsem API na poziomie 16 lub wyższym.
• Java w wersji 8 lub nowszej,
• podstawowe informacje o Zdalnej konfiguracji Firebase,

2. Konfigurowanie przykładowego projektu

Pobieranie kodu

Aby skopiować przykładowy kod na potrzeby tego ćwiczenia z programowania, uruchom następujące polecenie. Spowoduje to utworzenie na Twoim komputerze folderu o nazwie codelab-perf-rc-android:

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

Jeśli nie masz GitHuba, możesz pobrać kod bezpośrednio z tej usługi.

Zaimportuj projekt z folderu firebase-perf-rc-android-start do Android Studio. Prawdopodobnie zobaczysz wyjątki w czasie działania lub ostrzeżenie o brakującym pliku google-services.json. Poprawimy to w następnej sekcji.

W ramach tego ćwiczenia w programie użyjesz wtyczki Asystent Firebase, aby zarejestrować swoją aplikację na Androida w projekcie Firebase oraz dodać niezbędne pliki konfiguracyjne Firebase, wtyczki i zależności do swojego projektu na Androida – wszystko to z poziomu Android Studio.

Łączenie aplikacji z Firebase

1. Otwórz Android Studio lub Pomoc > Sprawdź dostępność aktualizacji, by mieć pewność, że używasz najnowszych wersji Android Studio i Asystenta Firebase.
2. Wybierz Narzędzia > Firebase, aby otworzyć panel Asystenta.

3. Wybierz Monitorowanie wydajności, aby dodać je do aplikacji, a następnie kliknij Zacznij korzystać z monitorowania wydajności.
4. Kliknij Połącz z Firebase, aby połączyć swój projekt na Androida z Firebase (spowoduje to otwarcie konsoli Firebase w przeglądarce).
5. W konsoli Firebase kliknij Dodaj projekt, a potem wpisz nazwę projektu Firebase (jeśli masz już projekt Firebase, możesz zamiast niego wybrać ten istniejący projekt). Kliknij Dalej i zaakceptuj warunki, aby utworzyć projekt Firebase i nową aplikację Firebase.

Uwaga: podczas tworzenia projektu możesz opcjonalnie wyłączyć Google Analytics. Włączenie Google Analytics udostępnia rozszerzone opcje kierowania Zdalnej konfiguracji Firebase. Jednak w tym ćwiczeniu w Codelabs użyjemy opcji kierowania, która nie wymaga Google Analytics.

Zobaczysz okno dialogowe, w którym możesz połączyć nową aplikację Firebase z projektem Android Studio.

6. Kliknij Połącz.
7. Otwórz Android Studio. W panelu Asystent zobaczysz potwierdzenie, że aplikacja jest połączona z Firebase.

Dodawanie do aplikacji Monitorowania wydajności

W panelu Asystent w Android Studio kliknij Dodaj do aplikacji monitorowanie wydajności.

Powinno się wyświetlić okno Zaakceptuj zmiany, po którym Android Studio powinien zsynchronizować aplikację, aby upewnić się, że zostały dodane wszystkie niezbędne zależności.

W panelu Asystent w Android Studio powinien wyświetlić się komunikat o powodzeniu informujący o prawidłowym skonfigurowaniu wszystkich zależności.

Dodatkowym krokiem jest włączenie rejestrowania debugowania, wykonując instrukcje podane w kroku „(Opcjonalnie) Włączanie rejestrowania debugowania”. Te same instrukcje są również dostępne w dokumentacji publicznej.

Inny sposób integracji z Monitorowaniem wydajności Firebase znajdziesz w artykule Pierwsze kroki z Monitorowaniem wydajności na Androida.

3. Uruchom aplikację

W katalogu modułu (na poziomie aplikacji) aplikacji powinien być teraz widoczny plik google-services.json, a aplikacja powinna się skompilować. W Android Studio kliknij Uruchom > Uruchom polecenie „aplikacja”, aby skompilować i uruchomić aplikację w emulatorze Androida.

Gdy aplikacja zostanie uruchomiona, najpierw zobaczysz taki ekran powitalny:

Po kilku sekundach pojawi się strona główna z obrazem domyślnym:

Co się dzieje pod maską?

Ekran powitalny jest zaimplementowany w elemencie SplashScreenActivity i wykonuje te czynności:

1. W onCreate() inicjujemy ustawienia Zdalnej konfiguracji Firebase i pobieramy wartości konfiguracyjne, które ustawisz w panelu Zdalnej konfiguracji w dalszej części tego ćwiczenia z programowania.
2. W narzędziu executeTasksBasedOnRC() odczytumy wartość konfiguracji flagi seasonal_image_url. Jeśli wartość parametru „config” zawiera adres URL, pobieramy obraz synchronicznie.
3. Po zakończeniu pobierania aplikacja przechodzi do elementu MainActivity i wywołuje funkcję finish(), aby zakończyć działanie funkcji SplashScreenActivity.

Zwykle wykonuje się równolegle inne zadania inicjowania i po ich zakończeniu wyświetla się ekran powitalny. Dla uproszczenia w naszej aplikacji mamy zadanie pobierania obrazów tylko podczas inicjowania.

W MainActivity, jeśli seasonal_image_url jest zdefiniowany za pomocą Zdalnej konfiguracji, funkcja zostanie włączona, a pobrany obraz będzie wyświetlany jako tło strony głównej. W przeciwnym razie wyświetli się obraz domyślny (widoczny powyżej).

4. Skonfiguruj Zdalną konfigurację

Gdy aplikacja jest już uruchomiona, możesz skonfigurować flagę nowej funkcji.

1. W lewym panelu konsoli Firebase znajdź sekcję Engage (Zaangażowanie) i kliknij Zdalna konfiguracja.
2. Kliknij przycisk Utwórz konfigurację, aby otworzyć formularz konfiguracji i dodaj seasonal_image_url jako klucz parametru.
3. Kliknij Dodaj opis i wpisz ten opis: Shows a seasonal image (replaces default) in the main page when the restaurant list is empty.
4. Kliknij Dodaj nowy -> Wartość warunkowa -> Utwórz nowy warunek.
5. Jako nazwę warunku wpisz Seasonal image rollout.
6. W sekcji Applies if... wybierz User in random percentile <= 0%. (Nie należy włączać tej funkcji, dopóki nie będzie można przeprowadzić jej wdrożenia w kolejnym kroku).
7. Kliknij Utwórz warunek. Użyjesz tego warunku później do udostępnienia nowej funkcji użytkownikom.

7. Otwórz formularz tworzenia pierwszego parametru i odszukaj pole Wartość wdrażania obrazów sezonowych. Wpisz adres URL, z którego chcesz pobrać obraz sezonowy: https://images.unsplash.com/photo-1552691021-7043334e0b51
8. Pozostaw wartość domyślną jako pusty ciąg znaków. Oznacza to, że zamiast obrazu pobranego z adresu URL będzie wyświetlany domyślny obraz w bazie kodu.
9. Kliknij Zapisz.

Jak widać, nowa konfiguracja została utworzona w wersji roboczej.

10. Kliknij Opublikuj zmiany i potwierdź je u góry, aby zaktualizować aplikację.

5. Dodaj monitorowanie czasu wczytywania danych

Przed wyświetleniem elementu MainActivity aplikacja wstępnie wczytuje niektóre dane i wyświetla ekran powitalny, który ukrywa ten proces. Użytkownicy nie powinni zbyt długo czekać na pojawieniu się tego ekranu, więc zwykle warto monitorować, jak długo jest wyświetlany ekran powitalny.

Pomogą Ci w tym Monitorowanie wydajności Firebase. Możesz wykorzystać niestandardowe logi czasu w celu monitorowania wydajności określonego kodu w aplikacji, np. czasu wczytywania danych czy czasu przetwarzania nowej funkcji.

Aby śledzić czas wyświetlania ekranu powitalnego, dodaj niestandardowy log czasu do SplashScreenActivity, czyli do Activity, który implementuje ekran powitalny.

1. Zainicjuj, utwórz i uruchom niestandardowy log czasu o nazwie splash_screen_trace:

Plik 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. Zakończ log czasu w metodzie onDestroy() SplashScreenActivity:

Plik SplashScreenActivity.java

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

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

Uwaga: dodany tutaj niestandardowy log czasu kodu będzie zawsze zatrzymywany po przejściu aplikacji na stronę główną, ponieważ funkcja finish() zawsze wywołuje funkcję onDestroy().

Twoja nowa funkcja pobiera i przetwarza obraz, dlatego musisz dodać drugi niestandardowy log czasu, który będzie śledzić dodatkowy czas dodawania funkcji do SplashScreenActivity.

1. Zainicjuj, utwórz i uruchom niestandardowy log czasu o nazwie splash_seasonal_image_processing:

Plik 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. Zakończ log czasu w metodach onLoadFailed() i onResourceReady() w RequestListener:

Plik 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();

Po dodaniu niestandardowych logów czasu kodu śledzących czas wyświetlania ekranu powitalnego (splash_screen_trace) oraz czas przetwarzania nowej funkcji (splash_seasonal_image_processing) ponownie uruchom aplikację w Android Studio. Powinien wyświetlić się komunikat logowania zawierający ciąg Logging trace metric: splash_screen_trace, a po nim czas trwania śledzenia. Nie zobaczysz komunikatu dziennika dotyczącego funkcji splash_seasonal_image_processing, ponieważ nie masz jeszcze włączonej nowej funkcji.

6. Dodaj atrybut niestandardowy do logu czasu

W przypadku niestandardowych logów czasu Monitorowanie wydajności automatycznie rejestruje atrybuty domyślne (typowe metadane, takie jak wersja aplikacji, kraj, urządzenie itp.), dzięki czemu możesz filtrować dane do logu czasu w konsoli Firebase. Możesz też dodawać i monitorować atrybuty niestandardowe.

Do Twojej aplikacji zostały dodane 2 niestandardowe logi czasu, aby monitorować czas wyświetlania ekranu powitalnego i czas przetwarzania nowej funkcji. Czynnikiem, który może mieć wpływ na te czasy, jest to, czy wyświetlany obraz jest obrazem domyślnym, czy też trzeba go pobrać z adresu URL. A kto wie? W przyszłości możesz pobierać zdjęcia z innych adresów URL.

Dodajmy więc do tych niestandardowych zrzutów kodu atrybut niestandardowy reprezentujący URL sezonowego obrazu. Dzięki temu dane o czasie trwania możesz później filtrować według tych wartości.

1. Dodaj atrybut niestandardowy (seasonal_image_url_attribute) dla splash_screen_trace na początku metody executeTasksBasedOnRC:

Plik 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. Dodaj ten sam atrybut niestandardowy dla atrybutu splash_seasonal_image_processing zaraz po wywołaniu startTrace("splash_seasonal_image_processing"):

Plik 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);

    // ...
}

Po dodaniu atrybutu niestandardowego (seasonal_image_url_attribute) do obu niestandardowych logów czasu (splash_screen_trace i splash_seasonal_image_processing) ponownie uruchom aplikację w Android Studio. Powinien pojawić się komunikat logowania zawierający Setting attribute 'seasonal_image_url_attribute' to 'unset' on trace 'splash_screen_trace'.. Nie włączono jeszcze parametru Zdalnej konfiguracji seasonalImageUrl. Dlatego jego wartość to unset.

Pakiet SDK do monitorowania wydajności zbierze dane śledzenia i wyśle je do Firebase. Dane te możesz przeglądać w panelu Skuteczność w konsoli Firebase. Szczegółowo wyjaśnimy to w następnym kroku ćwiczeń z programowania.

7. Konfigurowanie panelu monitorowania wydajności

Konfigurowanie panelu pod kątem monitorowania funkcji

W konsoli Firebase wybierz projekt zawierający Twoją aplikację Eats.

W panelu po lewej stronie znajdź sekcję Zwolnij i Monitorowanie i kliknij Skuteczność.

Na tablicy danych powinien wyświetlić się panel Skuteczność z pierwszymi punktami danych. Pakiet SDK Performance Monitoring zbiera dane o skuteczności aplikacji i wyświetla je w ciągu kilku minut od ich zebrania.

Uwaga: jeśli nie widzisz danych, uruchom aplikację ponownie, pozostaw aplikację włączoną przez co najmniej 30 sekund, a następnie odśwież stronę Wydajność. Jeśli nadal nie widzisz danych, poczekaj kilka minut i odśwież stronę Skuteczność.

Na tej tablicy możesz śledzić kluczowe dane dotyczące aplikacji. Widok domyślny zawiera czas trwania logu czasu uruchamiania aplikacji, ale możesz dodać wskaźniki, które są dla Ciebie najważniejsze. Śledzisz nową, dodaną przez Ciebie funkcję, więc możesz dostosować panel tak, aby wyświetlał czas trwania niestandardowego logu czasu splash_screen_trace.

1. Kliknij jedno z pustych pól Wybierz dane.
2. W oknie dialogowym wybierz typ śledzenia Niestandardowe logi czasu i nazwę logu czasu splash_screen_trace.

3. Kliknij Wybierz wskaźnik. W panelu powinien się pojawić okres splash_screen_trace.

Wykonując te same czynności, możesz dodać inne dane, które są dla Ciebie ważne. Dzięki temu możesz szybko sprawdzać, jak ich skuteczność zmienia się w czasie, a nawet w przypadku różnych wersji.

Uwaga: nowa funkcja w Twojej aplikacji nie została jeszcze włączona, więc aplikacji splash_seasonal_image_processing nie będzie na liście niestandardowych logów czasu.

Tablica danych jest zaawansowanym narzędziem do śledzenia skuteczności kluczowych danych napotykanych przez użytkowników. Na potrzeby tych ćwiczeń w programie masz niewielki zbiór danych z krótkiego przedziału czasu, więc będziesz używać innych widoków panelu, które pomogą Ci poznać wydajność wdrożenia funkcji.

8. Wdrażanie funkcji

Po skonfigurowaniu monitorowania możesz wprowadzić zmianę Zdalnej konfiguracji Firebase (seasonal_image_url) skonfigurowaną wcześniej).

Aby wdrożyć zmianę, wrócisz na stronę Zdalnej konfiguracji w konsoli Firebase i zwiększysz percentyl użytkowników dla warunku kierowania. Zwykle nowe funkcje są wdrażane wśród niewielkiej części użytkowników i zwiększane tylko wtedy, gdy masz pewność, że nie ma problemów. Jednak w ramach tego ćwiczenia w Codelabs jesteś jedynym użytkownikiem aplikacji, więc możesz zmienić centyl na 100%.

1. U góry strony kliknij kartę Warunki.
2. Kliknij dodany wcześniej warunek Seasonal image rollout.
3. Zmień percentyl na 100%.
4. Kliknij Zapisz warunek.
5. Kliknij Opublikuj zmiany i potwierdź je.

Wróć do Android Studio i ponownie uruchom aplikację w emulatorze, by zobaczyć nową funkcję. Po ekranie powitalnym powinien wyświetlić się nowy ekran główny z pustym stanem.

9. Sprawdzanie zmian skuteczności

Sprawdźmy teraz wydajność wczytywania ekranu powitalnego w panelu Wydajność w konsoli Firebase. W tym kroku ćwiczenia z programowania wykorzystasz różne części panelu, aby wyświetlać dane o skuteczności.

1. Na głównej karcie Dashboard (Panel) przewiń w dół do tabeli logów czasu, a następnie kliknij kartę Niestandardowe logi czasu. W tej tabeli zobaczysz dodane wcześniej niestandardowe logi czasu oraz kilka gotowych logów czasu.
2. Po włączeniu nowej funkcji znajdź niestandardowy zrzut kodu splash_seasonal_image_processing, który mierzy czas pobierania i przetwarzania obrazu. Na podstawie wartości Czas trwania logu czasu widać, że pobieranie i przetwarzanie zajmuje dużo czasu.

Uwaga: jeśli nie widzisz nowych danych, poczekaj kilka minut i odśwież stronę Skuteczność.

3. Masz dane dotyczące platformy splash_seasonal_image_processing, więc możesz dodać czas trwania tego logu czasu do tablicy wskaźników u góry karty Panel.

Podobnie jak wcześniej kliknij jedno z pustych pól Wybierz dane. W oknie dialogowym wybierz typ logu czasu Niestandardowe logi czasu i nazwę logu czasu splash_seasonal_image_processing. Na koniec kliknij Wybierz dane, aby dodać te dane do tablicy danych.

4. Aby potwierdzić różnice, przejrzyj dane dotyczące wskaźnika splash_screen_trace. Na tablicy danych kliknij kartę splash_screen_trace, a potem kliknij Wyświetl szczegóły danych.

5. Na stronie z informacjami w lewym dolnym rogu zobaczysz listę atrybutów, w tym utworzony wcześniej atrybut niestandardowy. Kliknij atrybut niestandardowy seasonal_image_url_attribute, aby wyświetlić czas trwania ekranu powitalnego dla każdego adresu URL obrazu sezonowego po prawej:

6. Wartości czasu wyświetlania ekranu powitalnego prawdopodobnie będą się nieco różnić od tych na zrzucie ekranu powyżej, ale czas trwania tego ekranu powinien być dłuższy w przypadku pobierania obrazu z adresu URL niż przy korzystaniu z obrazu domyślnego (reprezentowanego przez stan „Nie ustawiono”).

W tym ćwiczeniu w programowaniu przyczyna takiego długiego czasu trwania może być jasna, ale w prawdziwej aplikacji nie jest to oczywiste. Zebrane dane o czasie trwania będą pochodzić z różnych urządzeń, na których aplikacja działa w różnych warunkach połączenia sieciowego. Warunki te mogą być gorsze od oczekiwanych. Przyjrzyjmy się, jak można zbadać ten problem w realnej sytuacji.

7. U góry strony kliknij Skuteczność, aby wrócić do głównej karty Panel:
8. W tabeli logów czasu u dołu strony kliknij kartę Żądania sieciowe. W tej tabeli znajdziesz wszystkie żądania sieciowe z Twojej aplikacji zagregowane według wzorców adresów URL z uwzględnieniem wzorca adresu URL images.unsplash.com/**. Jeśli porównasz wartość tego czasu odpowiedzi z łącznym czasem potrzebnym na pobranie i przetworzenie obrazu (tj. czas trwania logu czasu splash_seasonal_image_processing), zobaczysz, że pobieranie obrazu zajęło dużo czasu.

Wyniki dotyczące skuteczności

Monitorowanie wydajności Firebase zaobserwowało następujący wpływ włączenia nowej funkcji na użytkowników:

1. Czas poświęcony na SplashScreenActivity wydłużył się.
2. Okres obowiązywania zasady splash_seasonal_image_processing był bardzo długi.
3. Opóźnienie było spowodowane czasem reakcji na pobranie obrazu i odpowiadającym mu czasem przetwarzania.

W następnym kroku zmniejszysz wpływ tej zmiany na skuteczność, wycofując ją i określając, jak możesz poprawić jej implementację.

10. Wycofaj funkcję

Zwiększenie liczby użytkowników czas oczekiwania podczas wyświetlania ekranu powitalnego jest niezalecany. Jedną z głównych zalet Zdalnej konfiguracji jest możliwość wstrzymywania i cofania wdrożenia bez konieczności udostępniania kolejnej wersji użytkownikom. Dzięki temu możesz szybko reagować na problemy (takie jak problemy z wydajnością wykryte w ostatnim kroku) i zminimalizować liczbę niezadowolonych użytkowników.

Aby szybko rozwiązać ten problem, zresetujesz centyl wdrażania z powrotem do 0, aby wszyscy użytkownicy ponownie widzieli obraz domyślny:

1. Wróć na stronę Zdalna konfiguracja w konsoli Firebase.
2. U góry strony kliknij Warunki.
3. Kliknij dodany wcześniej warunek Seasonal image rollout.
4. Zmień percentyl na 0%.
5. Kliknij Zapisz warunek.
6. Kliknij Opublikuj zmiany i potwierdź je.

Zrestartuj aplikację w Android Studio. Zobaczysz pierwotny ekran główny, który jest pusty:

11. Rozwiąż problemy ze skutecznością

Wcześniej dowiedzieliśmy się, że pobieranie obrazu ekranu powitalnego spowalnia działanie aplikacji. Gdy przyjrzeć się pobranemu obrazowi, zauważasz, że używasz jego pierwotnej rozdzielczości, która wynosi ponad 2 MB. Jednym z szybkich rozwiązań w celu rozwiązania problemu z wydajnością jest zmniejszenie jakości do bardziej odpowiedniej rozdzielczości, aby pobieranie zdjęcia trwało krócej.

Uwaga: w ramach ćwiczeń z programowania zdecydowaliśmy się rozwiązać problem przez zmniejszenie rozmiaru pliku. Istnieje jednak wiele innych sposobów jego rozwiązania. W zależności od potrzeb aplikacji możesz zastanowić się nad zmianą czasu, w jakim Zdalna konfiguracja pobiera nowe wartości, zamiast korzystać z wstępnie wczytanych wartości.

Ponownie wdróż wartość Zdalnej konfiguracji.

1. Wróć na stronę Zdalna konfiguracja w konsoli Firebase.
2. Kliknij ikonę Edytuj obok parametru seasonal_image_url.
3. W polu Wartość wdrażania obrazów sezonowych wpisz https://images.unsplash.com/photo-1552691021-7043334e0b51?w=640, a potem kliknij Zapisz.

4. U góry strony kliknij kartę Warunki.
5. Kliknij Sezonowe wdrażanie obrazów i ustaw percentyl z powrotem na 100%.
6. Kliknij Zapisz warunek.

7. Kliknij przycisk Opublikuj zmiany.

12. Przetestuj poprawkę i skonfiguruj alerty

Uruchamianie aplikacji lokalnie

Gdy nowa wartość konfiguracji jest ustawiona na używanie innego adresu URL pobierania obrazu, uruchom aplikację ponownie. Tym razem czas wyświetlania na ekranie powitalnym powinien być krótszy niż wcześniej.

Sprawdzanie skuteczności zmian

Wróć do panelu Skuteczność w konsoli Firebase, aby sprawdzić statystyki.

1. Tym razem użyjesz tabeli logów czasu, aby przejść do strony z informacjami. Na dole tabeli logów czasu na karcie Niestandardowe logi czasu kliknij niestandardowy log czasu splash_seasonal_image_processing, aby ponownie zobaczyć bardziej szczegółowy widok wskaźnika czasu trwania.

2. Kliknij atrybut niestandardowy seasonal_image_url_attribute, aby ponownie wyświetlić zestawienie atrybutów niestandardowych. Gdy najedziesz kursorem na adresy URL, zobaczysz wartość odpowiadającą nowemu adresowi URL obrazu ze zmniejszonym rozmiarem: https://images.unsplash.com/photo-1552691021-7043334e0b51?w=640 (z ?w=640 na końcu). Wartość czasu trwania powiązana z tym zdjęciem jest znacznie krótsza niż wartość poprzedniego zdjęcia i akceptowalna dla użytkowników.

Uwaga: jeśli nie widzisz nowych danych, poczekaj kilka minut i odśwież stronę Skuteczność.

3. Teraz gdy ulepszyliśmy działanie ekranu powitalnego, możesz skonfigurować alerty, które będą powiadamiać Cię, gdy ślad przekroczy ustawiony przez Ciebie próg. Otwórz panel Skuteczność i kliknij ikonę rozszerzonego menu (3 kropki) – splash_screen_trace, a następnie Ustawienia alertów.

4. Kliknij przełącznik, aby włączyć alert Czas trwania. Ustaw wartość progową na trochę wyższą od wyświetlanej wartości. Jeśli parametr splash_screen_trace przekroczy wartość progową, otrzymasz e-maila.

Uwaga: aby uniknąć uruchomienia w trakcie tworzenia aplikacji, alerty są aktywowane tylko wtedy, gdy w ciągu ostatniej godziny otrzymasz ponad 100 zdarzeń. Ponieważ to ćwiczenie w Codelabs nie generuje tylu zdarzeń, nie zobaczysz alertu.

5. Kliknij Zapisz, aby utworzyć alert. Przewiń w dół do tabeli śledzenia, a następnie kliknij kartę Niestandardowe logi czasu, aby sprawdzić, czy alert jest włączony.

13. Gratulacje!

Gratulacje! Udało Ci się włączyć pakiet SDK Firebase Performance Monitoring i zgromadzić logi czasu, aby mierzyć wydajność nowej funkcji. Monitorowaliśmy najważniejsze dane o wydajności wdrożenia nowej funkcji i szybko zareagowaliśmy na problemy z wydajnością. Wszystko to było możliwe dzięki możliwości wprowadzania zmian w konfiguracji za pomocą Zdalnej konfiguracji i monitorowania problemów z wydajnością w czasie rzeczywistym.

Omówione zagadnienia

• Dodawanie pakietu SDK Firebase Performance Monitoring do aplikacji
• Dodawanie niestandardowego logu czasu do kodu w celu pomiaru określonej cechy
• Konfigurowanie parametru Zdalnej konfiguracji i wartości warunkowej w celu sterowania/wdrażania nowej funkcji.
• Znajomość korzystania z panelu monitorowania wydajności w celu identyfikowania problemów podczas wdrażania
• Skonfigurowanie alertów dotyczących wydajności, które będą powiadamiać Cię, gdy wydajność aplikacji przekroczy wyznaczony próg

Więcej informacji

• firebase.google.com
• Wprowadzenie do Monitorowania wydajności na urządzeniach z Androidem
• Pierwsze kroki ze Zdalnej konfiguracji Firebase