Pomiar i debugowanie wydajności za pomocą Google Analytics 4 i BigQuery

Dowiedz się, jak przesyłać dane ze wskaźników internetowych do usług w Google Analytics 4 oraz eksportować je do analizy w BigQuery i Looker Studio.

Minhaz Kazi

Philip Walton

Google udostępnia wiele narzędzi – Search Console, PageSpeed Insights (PSI) i Raport na temat użytkowania Chrome (CrUX) – dzięki którym deweloperzy mogą sprawdzić skuteczność swoich witryn w odniesieniu do podstawowych wskaźników internetowych ich rzeczywistych użytkowników w tej branży.

Narzędzia te są świetne, ponieważ zapewniają ogólny wgląd w skuteczność witryny w praktyce dla użytkowników. Korzystanie z nich absolutnie nie wymaga konfiguracji.

Jest jednak kilka ważnych powodów, dla których nie chcesz polegać wyłącznie na tych narzędziach do pomiaru wydajności witryny:

• Narzędzia oparte na CrUX raportują dane z podziałem na okresy miesięczne lub poprzednie 28-dniowe. Oznacza to, że będzie trzeba odczekać jakiś czas po wprowadzeniu jakichkolwiek zmian, zanim będzie można zobaczyć wyniki.
• Narzędzia oparte na raporcie CrUX można dzielić na segmenty tylko według ograniczonej liczby wymiarów, takich jak kraj, typ połączenia i kategoria urządzenia (komputer lub urządzenie mobilne). Nie możesz podzielić danych według wymiarów związanych z Twoją działalnością (np. zaangażowanych użytkowników, użytkowników w konkretnej grupie eksperymentalnej itp.).
• Narzędzia oparte na interfejsie raportu na temat użytkowania Chrome powiedzą Ci, jaka jest wydajność, ale nie potrafią powiedzieć, dlaczego. Dzięki narzędziom analitycznym możesz wysyłać dodatkowe dane, które pomagają śledzić i debugować problemy.

Dlatego zalecamy wszystkim właścicielom witryn monitorowanie podstawowych wskaźników internetowych za pomocą istniejących narzędzi analitycznych. Z tego posta dowiesz się, jak wykorzystać w tym celu bezpłatne narzędzia oferowane przez Google.

Po skonfigurowaniu ustawień możesz utworzyć takie panele:

Jeśli chcesz dowiedzieć się więcej o wszystkich krokach, które są tu opisane, obejrzyj naszą prezentację z Google I/O 2021:

Zmierz odległość

Pomiar skuteczności w Google Analytics zawsze był możliwy z wykorzystaniem danych niestandardowych, ale w Google Analytics 4 (GA4) pojawiły się nowe funkcje, które szczególnie spodobają się deweloperom.

• bez konfiguracji, niestandardowych parametrów zdarzeń.
• bezpłatny BigQuery Export, umożliwiający wykonywanie zapytań o dane za pomocą SQL.

Interfejs internetowy Google Analytics udostępnia zaawansowane narzędzia analityczne, ale trudno jest przebić możliwości i elastyczność, jakie daje dostęp do nieprzetworzonych danych zdarzeń, używając dobrze znanego języka zapytań.

Aby rozpocząć pomiary podstawowych wskaźników internetowych za pomocą Google Analytics 4 i BigQuery, musisz wykonać 3 czynności:

1. Utwórz usługę Google Analytics 4 i projekt BigQuery.
2. Włącz BigQuery Export w konfiguracji usługi Google Analytics, aby wszystkie otrzymywane dane były automatycznie wypełniane w tabelach projektów BigQuery.
3. Dodaj do swojej witryny bibliotekę JavaScript web-vitals, aby mierzyć podstawowe wskaźniki internetowe i wysyłać je do Google Analytics 4.

Analizuj

Gdy wszystko będzie gotowe, w interfejsie BigQuery powinny pojawić się dane zdarzeń i będziesz mieć możliwość wysyłania do nich zapytań w ten sposób:

SELECT * FROM `my_project_id.analytics_XXXXX.events_*`
WHERE event_name IN ('LCP', 'FID', 'CLS')

Oto podgląd wyników tego zapytania:

Wysyłanie zapytań o dane dotyczące wskaźników internetowych

Zanim zaczniesz tworzyć zapytania dotyczące danych zdarzeń ze wskaźników internetowych, musisz wiedzieć, jak te dane są agregowane.

Pamiętaj, że w niektórych przypadkach na tej samej stronie może zostać odebranych wiele zdarzeń związanych z tym samym rodzajem danych. Może się tak zdarzyć, jeśli wartość danych ulegnie zmianie i w raporcie zostanie zaktualizowana zaktualizowana wartość (często występuje w przypadku CLS).

W przypadku zdarzeń wskaźników internetowych ostatnia wysłana wartość jest zawsze najdokładniejsza, więc przed przeprowadzeniem analizy należy odfiltrować tylko te wartości. Fragment kodu udostępniany przez bibliotekę JavaScript Web-vitals do wysyłania danych do Google Analytics 4 obejmuje wysyłanie unikalnego identyfikatora dla każdego rodzaju danych. Możesz więc za pomocą poniższego zapytania ograniczyć wyniki tylko do ostatnio otrzymanej wartości każdego identyfikatora danych:

# Subquery all Web Vitals events from the last 28 days
WITH web_vitals_events AS (
  SELECT event_name as metric_name, * EXCEPT(event_name, is_last_received_value) FROM (
    SELECT *, IF (ROW_NUMBER() OVER (
      PARTITION BY (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'metric_id')
      ORDER BY (SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = 'metric_value') DESC
    ) = 1, true, false) AS is_last_received_value
    FROM `bigquery_project_id.analytics_XXXXX.events_*`
    WHERE event_name in ('CLS', 'FID', 'LCP') AND
      _TABLE_SUFFIX BETWEEN FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 28 DAY)) AND FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY))
  ) WHERE is_last_received_value
)

Pamiętaj, że wszystkie inne zapytania, do których odwołuje się ten post, będą się zaczynać od tego podzapytania.

W kolejnych sekcjach podajemy kilka przykładów typowych zapytań dotyczących wskaźników internetowych, które mogą Ci się przydać.

Przykładowe zapytania

LCP, FID i CLS na poziomie 75% percentyla (p75) w całej witrynie

# Subquery all Web Vitals events from the last 28 days
WITH web_vitals_events AS (
  SELECT event_name as metric_name, * EXCEPT(event_name, is_last_received_value) FROM (
    SELECT *, IF (ROW_NUMBER() OVER (
      PARTITION BY (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'metric_id')
      ORDER BY (SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = 'metric_value') DESC
    ) = 1, true, false) AS is_last_received_value
    FROM `bigquery_project_id.analytics_XXXXX.events_*`
    WHERE event_name in ('CLS', 'FID', 'LCP') AND
      _TABLE_SUFFIX BETWEEN FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 28 DAY)) AND FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY))
  ) WHERE is_last_received_value
)
# Main query logic
SELECT
  metric_name,
  APPROX_QUANTILES(metric_value, 100)[OFFSET(75)] AS p75,
  COUNT(1) as count
FROM (
  SELECT
    metric_name,
    ROUND((SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = "metric_value"), 3) AS metric_value,
  FROM web_vitals_events
)
GROUP BY 1

Wszystkie indywidualne wartości LCP od najwyższej do najniższej

# Subquery all Web Vitals events from the last 28 days
WITH web_vitals_events AS (
  SELECT event_name as metric_name, * EXCEPT(event_name, is_last_received_value) FROM (
    SELECT *, IF (ROW_NUMBER() OVER (
      PARTITION BY (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'metric_id')
      ORDER BY (SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = 'metric_value') DESC
    ) = 1, true, false) AS is_last_received_value
    FROM `bigquery_project_id.analytics_XXXXX.events_*`
    WHERE event_name in ('CLS', 'FID', 'LCP') AND
      _TABLE_SUFFIX BETWEEN FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 28 DAY)) AND FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY))
  ) WHERE is_last_received_value
)
# Main query logic
SELECT
  ROUND((SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = "metric_value"), 3) AS metric_value,
FROM web_vitals_events
WHERE metric_name = 'LCP'
ORDER BY metric_value DESC

Oceny LCP (p75) na 10 najpopularniejszych stronach

# Subquery all Web Vitals events from the last 28 days
WITH web_vitals_events AS (
  SELECT event_name as metric_name, * EXCEPT(event_name, is_last_received_value) FROM (
    SELECT *, IF (ROW_NUMBER() OVER (
      PARTITION BY (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'metric_id')
      ORDER BY (SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = 'metric_value') DESC
    ) = 1, true, false) AS is_last_received_value
    FROM `bigquery_project_id.analytics_XXXXX.events_*`
    WHERE event_name in ('CLS', 'FID', 'LCP') AND
      _TABLE_SUFFIX BETWEEN FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 28 DAY)) AND FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY))
  ) WHERE is_last_received_value
)
# Main query logic
SELECT
  page_path,
  APPROX_QUANTILES(metric_value, 100)[OFFSET(75)] AS LCP,
  COUNT(1) as count
FROM (
  SELECT
    REGEXP_SUBSTR((SELECT value.string_value FROM UNNEST(event_params) WHERE key = "page_location"), r'\.com(\/[^?]*)') AS page_path,
    ROUND((SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = "metric_value"), 3) AS metric_value,
  FROM web_vitals_events
  WHERE metric_name = 'LCP'
)
GROUP BY 1
ORDER BY count DESC
LIMIT 10

10 stron o najniższym wskaźniku CLS (p75)

# Subquery all Web Vitals events from the last 28 days
WITH web_vitals_events AS (
  SELECT event_name as metric_name, * EXCEPT(event_name, is_last_received_value) FROM (
    SELECT *, IF (ROW_NUMBER() OVER (
      PARTITION BY (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'metric_id')
      ORDER BY (SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = 'metric_value') DESC
    ) = 1, true, false) AS is_last_received_value
    FROM `bigquery_project_id.analytics_XXXXX.events_*`
    WHERE event_name in ('CLS', 'FID', 'LCP') AND
      _TABLE_SUFFIX BETWEEN FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 28 DAY)) AND FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY))
  ) WHERE is_last_received_value
)
# Main query logic
SELECT
  page_path,
  APPROX_QUANTILES(metric_value, 100)[OFFSET(75)] AS CLS,
  COUNT(1) as count
FROM (
  SELECT
    REGEXP_SUBSTR((SELECT value.string_value FROM UNNEST(event_params) WHERE key = "page_location"), r'\.com(\/[^?]*)') AS page_path,
    ROUND((SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = "metric_value"), 3) AS metric_value,
  FROM web_vitals_events
  WHERE metric_name = 'CLS'
)
GROUP BY 1
HAVING count > 50 # Limit to relatively popular pages
ORDER BY CLS DESC
LIMIT 10

Debugowanie

Podane wyżej zapytania pokazują, jak wykonywać zapytania na danych wskaźników internetowych, co pomaga zrozumieć bieżącą skuteczność i jej trendy w czasie. Co jednak zrobić, gdy skuteczność okaże się niższa od oczekiwanej, ale nie wiesz dlaczego?

Znajomość tego wyniku nie będzie przydatna, jeśli nie jesteś w stanie podjąć działania i rozwiązać problemy.

Sekcja Debuguj wyniki w polu wyjaśnia, jak za pomocą danych analitycznych przesłać dodatkowe informacje na potrzeby debugowania. Jeśli wykonasz instrukcje opisane w tym poście, dane debugowania powinny też pojawić się w BigQuery.

Przy podanych niżej zapytaniach pokazujemy, jak używać parametru zdarzenia debug_target do identyfikowania głównej przyczyny problemów z wydajnością.

Przykładowe zapytania

Najważniejsze elementy przyczyniające się do CLS

debug_target to ciąg selektora arkusza CSS odpowiadający elementowi na stronie, który ma największe znaczenie dla wartości danych.

W przypadku CLS debug_target reprezentuje największy element z największej zmiany układu, która miała wpływ na wartość CLS. Jeśli żadne elementy nie zostały przesunięte, wartość debug_target będzie wynosić null.

To zapytanie wyświetli listę stron od najgorszego do najlepszych według ich CLS w 75 percentylu. Są one pogrupowane według parametru debug_target:

# Subquery all Web Vitals events from the last 28 days
WITH web_vitals_events AS (
  SELECT event_name as metric_name, * EXCEPT(event_name, is_last_received_value) FROM (
    SELECT *, IF (ROW_NUMBER() OVER (
      PARTITION BY (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'metric_id')
      ORDER BY (SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = 'metric_value') DESC
    ) = 1, true, false) AS is_last_received_value
    FROM `bigquery_project_id.analytics_XXXXX.events_*`
    WHERE event_name in ('CLS', 'FID', 'LCP') AND
      _TABLE_SUFFIX BETWEEN FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 28 DAY)) AND FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY))
  ) WHERE is_last_received_value
)
# Main query logic
SELECT
  page_path,
  debug_target,
  APPROX_QUANTILES(metric_value, 100)[OFFSET(75)] AS CLS,
  COUNT(1) as count
FROM (
  SELECT
    REGEXP_SUBSTR((SELECT value.string_value FROM UNNEST(event_params) WHERE key = "page_location"), r'\.com(\/[^?]*)') AS page_path,
    (SELECT value.string_value FROM UNNEST(event_params) WHERE key = "debug_target") as debug_target,
    ROUND((SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = "metric_value"), 3) AS metric_value,
    *
  FROM web_vitals_events
  WHERE metric_name = 'CLS'
)
GROUP BY 1, 2
HAVING count > 50 # Limit to relatively popular pages
ORDER BY CLS DESC

Wiedza na temat tego, które elementy na stronie się zmieniają, powinna znacznie ułatwić identyfikację i naprawienie głównej przyczyny problemu.

Pamiętaj, że raportowane tu elementy mogą nie być tymi samymi, które możesz zauważyć, gdy debugujesz strony lokalnie. Dlatego tak ważne jest odnotowywanie tych danych. Bardzo trudno jest rozwiązać problemy, o których nie masz pojęcia.

Debugowanie innych wskaźników

Powyższe zapytanie pokazuje wyniki wskaźnika CLS, ale w ten sam sposób można generować raporty o celach debugowania w przypadku LCP i FID. Wystarczy, że zastąpisz klauzulę „where” odpowiednimi danymi do debugowania:

WHERE metric_name = 'CLS'
WHERE metric_name = 'LCP'

Aby dowiedzieć się, jak zbierać i wysyłać dane debugowania w przypadku poszczególnych podstawowych wskaźników internetowych, zajrzyj do sekcji Debugowanie wydajności w polu.

Wyświetl wizualizację

Uzyskanie statystyk na podstawie samych wyników zapytań może być trudne. Na przykład to zapytanie zawiera listę dziennych wartości 75 centyla dla LCP w zbiorze danych.

# Subquery all Web Vitals events from the last 28 days
WITH web_vitals_events AS (
  SELECT event_name as metric_name, * EXCEPT(event_name, is_last_received_value) FROM (
    SELECT *, IF (ROW_NUMBER() OVER (
      PARTITION BY (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'metric_id')
      ORDER BY (SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = 'metric_value') DESC
    ) = 1, true, false) AS is_last_received_value
    FROM `bigquery_project_id.analytics_XXXXX.events_*`
    WHERE event_name in ('CLS', 'FID', 'LCP') AND
      _TABLE_SUFFIX BETWEEN FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 28 DAY)) AND FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY))
  ) WHERE is_last_received_value
)
# Main query logic
SELECT
  event_date,
  metric_name,
  APPROX_QUANTILES(ROUND(metric_value, 2), 100)[OFFSET(75)] AS p75
FROM
  (
    SELECT
      event_date,
      metric_name,
      ROUND((SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = 'metric_value'), 3) AS metric_value
    FROM web_vitals_events
    WHERE
      metric_name = 'LCP'
  )
GROUP BY
  1, 2
ORDER BY event_date

Na podstawie takich wyników zapytań trudno jest dostrzec trendy lub wartości odstające tylko na podstawie danych.

W takich przypadkach wizualizacja danych może pomóc w szybszym generowaniu wniosków.

Wizualizacja wyników zapytań w Looker Studio

BigQuery umożliwia szybką wizualizację wyników zapytań za pomocą Studia danych. Looker Studio to bezpłatne narzędzie do wizualizacji i panelu informacyjnego. Aby zwizualizować wyniki zapytania, po uruchomieniu zapytania w interfejsie BigQuery kliknij przycisk Przeglądaj dane i wybierz Przeglądaj w Looker Studio.

Spowoduje to utworzenie bezpośredniego połączenia między BigQuery a Looker Studio w widoku eksploracji. W tym widoku możesz wybrać pola, które chcesz wizualizować, typy wykresów i filtry konfiguracji oraz tworzyć wykresy doraźne, aby przeprowadzić szybką analizę wizualną. Na podstawie powyższych wyników zapytania możesz utworzyć ten wykres liniowy, aby zobaczyć trend wartości LCP na przestrzeni czasu:

Dzięki bezpośredniemu połączeniu BigQuery z Looker Studio możesz tworzyć szybkie wykresy na podstawie dowolnych zapytań i przeprowadzać analizę wizualną. Jeśli jednak chcesz przeprowadzić dodatkową analizę, możesz skorzystać z kilku wykresów w interaktywnym panelu informacyjnym, aby uzyskać bardziej całościowy obraz lub uzyskać możliwość analizy danych. Dzięki przydatnemu panelowi nie musisz za każdym razem tworzyć zapytań ani generować wykresów ręcznie za każdym razem, gdy chcesz przeanalizować dane.

Panel możesz utworzyć w Looker Studio za pomocą natywnego oprogramowania sprzęgającego BigQuery. Aby to zrobić, wejdź na datastudio.google.com, utwórz nowe źródło danych, wybierz oprogramowanie sprzęgające BigQuery i wskaż zbiór danych, z którym chcesz pracować:

Wykorzystanie danych ze wskaźników internetowych

Podczas tworzenia paneli z danymi zdarzeń ze wskaźników internetowych w sposób opisany powyżej nie jest efektywne używanie bezpośrednio zbioru danych eksportu Google Analytics 4. Ze względu na strukturę danych GA4 i wstępne przetwarzanie wymagane w przypadku danych dotyczących wskaźników internetowych niektóre fragmenty zapytań będą wyświetlane wielokrotnie. Powoduje to 2 problemy: wydajność panelu i koszty BigQuery.

Możesz bezpłatnie korzystać z trybu piaskownicy BigQuery. W przypadku poziomu bezpłatnego BigQuery pierwszy 1 TB danych dotyczących zapytań przetwarzanych miesięcznie jest bezpłatny. W przypadku metod analizy omówionych w tym poście, o ile nie korzystasz ze bardzo dużego zbioru danych lub regularnie wysyłasz do niego zapytania, możesz zmieścić się w tym bezpłatnym limicie co miesiąc. Jeśli jednak masz witrynę o dużym natężeniu ruchu i chcesz regularnie sprawdzać różne wskaźniki za pomocą szybkiego interaktywnego panelu, zalecamy wstępne przetwarzanie i materializowanie danych wskaźników internetowych z wykorzystaniem funkcji wydajności BigQuery, takich jak partycjonowanie, grupowanie i buforowanie.

Ten skrypt wstępnie przetworzy dane BigQuery (tabela źródłowa) i utworzy tabelę zmaterializowaną (tabelę docelową). Jeśli używasz tego zapytania do własnego zbioru danych, możesz też zdefiniować zakres dat dla tabeli źródłowej, aby zmniejszyć ilość przetworzonych danych.

# Materialize Web Vitals metrics from GA4 event export data

# Replace target table name
CREATE OR REPLACE TABLE bigquery_project_id.ga4_demo_dev.web_vitals_summary
  PARTITION BY DATE(event_timestamp)
  CLUSTER BY metric_name
AS
SELECT
  ga_session_id,
  IF(
    EXISTS(SELECT 1 FROM UNNEST(events) AS e WHERE e.event_name = 'first_visit'),
    'New user',
    'Returning user') AS user_type,
  IF(
    (SELECT MAX(session_engaged) FROM UNNEST(events)) > 0, 'Engaged', 'Not engaged')
    AS session_engagement,
  evt.* EXCEPT (session_engaged, event_name),
  event_name AS metric_name,
  FORMAT_TIMESTAMP('%Y%m%d', event_timestamp) AS event_date
FROM
  (
    SELECT
      ga_session_id,
      ARRAY_AGG(custom_event) AS events
    FROM
      (
        SELECT
          ga_session_id,
          STRUCT(
            country,
            device_category,
            device_os,
            traffic_medium,
            traffic_name,
            traffic_source,
            page_path,
            debug_target,
            event_timestamp,
            event_name,
            metric_id,
            IF(event_name = 'LCP', metric_value / 1000, metric_value) AS metric_value,
            user_pseudo_id,
            session_engaged,
            session_revenue) AS custom_event
        FROM
          (
            SELECT
              (SELECT value.int_value FROM UNNEST(event_params) WHERE key = 'ga_session_id')
                AS ga_session_id,
              (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'metric_id')
                AS metric_id,
              ANY_VALUE(device.category) AS device_category,
              ANY_VALUE(device.operating_system) AS device_os,
              ANY_VALUE(traffic_source.medium) AS traffic_medium,
              ANY_VALUE(traffic_source.name) AS traffic_name,
              ANY_VALUE(traffic_source.source) AS traffic_source,
              ANY_VALUE(
                REGEXP_SUBSTR(
                  (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'page_location'),
                  r'^[^?]+')) AS page_path,
              ANY_VALUE(
                (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'debug_target'))
                AS debug_target,
              ANY_VALUE(user_pseudo_id) AS user_pseudo_id,
              ANY_VALUE(geo.country) AS country,
              ANY_VALUE(event_name) AS event_name,
              SUM(ecommerce.purchase_revenue) AS session_revenue,
              MAX(
                (
                  SELECT
                    COALESCE(
                      value.double_value, value.int_value, CAST(value.string_value AS NUMERIC))
                  FROM UNNEST(event_params)
                  WHERE key = 'session_engaged'
                )) AS session_engaged,
              TIMESTAMP_MICROS(MAX(event_timestamp)) AS event_timestamp,
              MAX(
                (
                  SELECT COALESCE(value.double_value, value.int_value)
                  FROM UNNEST(event_params)
                  WHERE key = 'metric_value'
                )) AS metric_value,
            FROM
              # Replace source table name
              `bigquery_project_id.analytics_XXXXX.events_*`
            WHERE
              event_name IN ('LCP', 'FID', 'CLS', 'first_visit', 'purchase')
            GROUP BY
              1, 2
          )
      )
    WHERE
      ga_session_id IS NOT NULL
    GROUP BY ga_session_id
  )
CROSS JOIN UNNEST(events) AS evt
WHERE evt.event_name NOT IN ('first_visit', 'purchase');

Taki zmaterializowany zbiór danych ma kilka zalet:

• Struktura danych jest spłaszczona i łatwiejszego wyszukiwania zapytań.
• Zachowuje tylko zdarzenia wskaźników internetowych z pierwotnego zbioru danych GA4.
• Informacje o identyfikatorze sesji, typie użytkownika (nowy a powracający) i zaangażowaniu w sesję są dostępne bezpośrednio w kolumnach.
• Tabela jest partitioned według daty i grupowana według nazwy wskaźnika. Zwykle zmniejsza to ilość danych przetwarzanych w przypadku każdego zapytania.
• Ponieważ do wysyłania zapytań do tej tabeli nie trzeba używać symboli wieloznacznych, wyniki zapytań mogą być przechowywane w pamięci podręcznej przez maksymalnie 24 godziny. Pozwala to zmniejszyć koszty powtarzania tego samego zapytania.
• Jeśli używasz silnika analityki biznesowej BigQuery, możesz w tej tabeli uruchomić zoptymalizowane funkcje i operatory SQL.

Zapytanie o tę tabelę zmaterializowaną możesz wysłać bezpośrednio z interfejsu BigQuery lub użyć jej w Looker Studio za pomocą oprogramowania sprzęgającego BigQuery.

Korzystanie z oprogramowania sprzęgającego Web Vitals

Tworzenie panelu od zera jest czasochłonne, dlatego opracowaliśmy pakietowe rozwiązanie, które utworzy szablon panelu. Najpierw upewnij się, że tabela wskaźników internetowych została zmaterializowana za pomocą podanego wyżej zapytania. Następnie otwórz oprogramowanie sprzęgające wskaźników internetowych w Looker Studio, korzystając z tego linku: goo.gle/web-vitals-connector.

Po udzieleniu jednorazowej autoryzacji powinien wyświetlić się ten ekran konfiguracji:

Podaj identyfikator zmaterializowanej tabeli BigQuery (np. tabelę docelową) oraz identyfikator projektu rozliczeniowego BigQuery. Gdy klikniesz Połącz, Looker Studio utworzy nowy panel oparty na szablonie i powiąże z nim Twoje dane. Możesz go edytować, modyfikować i udostępniać według własnego uznania. Jeśli utworzysz panel raz, nie musisz ponownie klikać linku do oprogramowania sprzęgającego, chyba że chcesz utworzyć wiele paneli z różnych zbiorów danych.

Poruszanie się po panelu

Podczas poruszania się po panelu na karcie Podsumowanie możesz zobaczyć dzienne trendy wskaźników internetowych oraz niektóre informacje o korzystaniu z Twojej witryny, np. o użytkownikach i sesjach.

Na karcie Analiza użytkowników możesz wybrać dane, a potem zobaczyć podział centyla danych i liczby użytkowników według różnych zastosowań i danych biznesowych.

Karta Analiza ścieżki do strony pomaga zidentyfikować problematyczne obszary w witrynie. Tutaj możesz wybrać dane, aby wyświetlić podsumowanie. Widać też jednak mapę punktową wszystkich ścieżek do strony z wartością percentyla na osi Y i liczbą rekordów na osi X. Mapa punktowa może pomóc w wykrywaniu stron z wartościami danych niższymi od oczekiwanych. Po wybraniu stron na wykresie punktowym w tabeli Ścieżka do strony możesz przeanalizować problem, wyświetlając tabelę Cel debugowania.

Karta Analiza przychodów jest przykładem sposobu, w jaki możesz w jednym miejscu monitorować dane o firmie i skuteczności. Ta sekcja ukazuje wszystkie sesje, w których użytkownik dokonał zakupu. Możesz porównać przychody uzyskane przez użytkowników z wrażeniami użytkowników z danej sesji .

Zaawansowane użycie

Gdy już się zapoznasz ze zbiorem danych, będziesz mieć możliwość edytowania panelu i dodawania własnych wykresów, które zapewnią bogatszą i bardziej ukierunkowaną analizę. Aby zwiększyć przydatność panelu, możesz wykonać te czynności:

• Skonfiguruj zaplanowane zapytanie w BigQuery, aby uzyskać zaktualizowane dane. Uruchomione powyżej zapytanie materializacji tworzy jedynie migawkę Twoich danych. Jeśli chcesz, aby panel był aktualizowany o nowe dane, możesz uruchomić zaplanowane zapytanie, które będzie wykonywane codziennie, i dołączyć nowe dane do tabeli zmaterializowanej.
• Łączenie danych własnych (np. z systemu CRM) na potrzeby statystyk biznesowych. W tabeli zmaterializowanej możesz dodać user_id jako oddzielną kolumnę. Umożliwi Ci to złączanie danych własnych. Jeśli Twoich danych własnych nie ma jeszcze w BigQuery, możesz je wczytać lub użyć sfederowanego źródła danych.
• Raportowanie wersji witryny lub aplikacji jako parametru w danych przesyłanych do Google Analytics i dodawanie ich jako kolumny w tabeli zmaterializowanej. Następnie możesz dodać dane o tej wersji jako wymiar do wykresów, aby łatwiej sprawdzać, jak zmiany wersji wpływają na wydajność.
• Jeśli spodziewasz się znacznego intensywności wykorzystania zbioru danych w ramach bezpośredniego zapytania lub w panelu, możesz wypróbować płatną wersję Mechanizmu analityki biznesowej BigQuery.

Podsumowanie

W tym poście omówiliśmy podstawy korzystania z Google Analytics 4 i BigQuery do pomiaru i debugowania skuteczności z wykorzystaniem zebranych w tej dziedzinie danych użytkowników. Wyjaśniliśmy też, jak za pomocą Looker Studio i oprogramowania sprzęgającego ze wskaźnikami internetowymi tworzyć automatyczne raporty i panele, aby ułatwić wizualizację danych.

Oto kilka najważniejszych wniosków z tego posta:

• Pomiar skuteczności za pomocą rzeczywistych danych o użytkownikach ma kluczowe znaczenie dla zrozumienia, debugowania i optymalizacji witryny.
• Możesz uzyskać dokładniejsze statystyki, jeśli dane o skuteczności i biznesowe znajdują się w tym samym systemie. Umożliwiają to Google Analytics i BigQuery.
• Eksport nieprzetworzonych danych Google Analytics do BigQuery zapewnia nieograniczony potencjał dogłębnej, niestandardowej analizy z użyciem języka zapytań, które pewnie już znasz.
• Google udostępnia wiele interfejsów API i narzędzi do wizualizacji, np. Looker Studio, dzięki którym możesz tworzyć raporty dokładnie tak, jak chcesz.