Mierzenie i debugowanie skuteczności za pomocą Google Analytics 4 i BigQuery

Dowiedz się, jak przesyłać dane Web Vitals do usług w Google Analytics 4 i eksportować dane do analizy w BigQuery i Looker Studio.

Minhaz Kazi

Philip Walton

Google udostępnia kilka narzędzi – Konsolę wyszukiwarki, PageSpeed Insights (PSI) i Raport na temat użytkowania Chrome (CrUX) – które pozwalają deweloperom sprawdzać, jak ich witryny wypadają na tle podstawowych wskaźników internetowych w przypadku rzeczywistych użytkowników w praktyce.

Te narzędzia są świetne, ponieważ zapewniają ogólny wgląd w skuteczność witryny w śród rzeczywistych użytkowników. Nie wymagają żadnej konfiguracji.

Istnieje jednak kilka ważnych powodów, dla których nie warto polegać tylko na tych narzędziach do pomiaru skuteczności witryny:

• Narzędzia oparte na Crux generują raporty z danymi z poprzednich 28 dni lub z danych miesięcznych. Oznacza to, że po wprowadzeniu zmian musisz odczekać długo, zanim zobaczysz wyniki.
• Narzędzia oparte na CrUX można dzielić na segmenty tylko według ograniczonej liczby wymiarów, np. kraju, typu połączenia i kategorii urządzenia (komputer lub urządzenie mobilne). Nie możesz dzielić danych według wymiarów specyficznych dla Twojej firmy (np. zaangażowanych użytkowników, użytkowników z określonej grupy eksperymentalnej itp.).
• Narzędzia oparte na pliku CrUX mogą Ci pokazać jak skutecznie działa Twoja witryna, ale nie mogą Ci powiedzieć dlaczego. Za pomocą narzędzi analitycznych możesz wysyłać dodatkowe dane, które pomogą Ci śledzić i rozwiązywać problemy.

Dlatego zalecamy wszystkim właścicielom witryn monitorowanie podstawowych wskaźników internetowych za pomocą istniejących narzędzi analitycznych. Z tego artykułu dowiesz się, jak używać bezpłatnych narzędzi Google do tego celu.

Gdy wszystko będzie gotowe, możesz tworzyć panele takie jak te:

Jeśli chcesz zobaczyć wizualny przegląd wszystkich opisanych tu kroków, obejrzyj nasz wykład z Google I/O 2021:

Zmierz odległość

W Google Analytics zawsze można było mierzyć skuteczność za pomocą danych niestandardowych, ale w Google Analytics 4 (GA4) jest kilka nowych funkcji, które szczególnie zainteresują programistów.

• parametr zdarzenia niestandardowego, parametr „0”;
• bezpłatny eksport do BigQuery, dzięki któremu możesz wysyłać zapytania do danych za pomocą języka SQL;

Interfejs internetowy Google Analytics zawiera zaawansowane narzędzia analityczne, ale trudno przebić możliwości i elastyczność uzyskiwania dostępu do nieprzetworzonych danych zdarzeń za pomocą języka zapytań, który prawdopodobnie już znasz.

Aby zacząć mierzyć podstawowe wskaźniki internetowe za pomocą Google Analytics 4 i BigQuery, musisz wykonać 3 czynności:

1. Utwórz usługę w Google Analytics 4 i projekt BigQuery.
2. W konfiguracji usługi w Google Analytics włącz BigQuery Export, aby wszystkie otrzymane dane były automatycznie wypełniane w tabelach projektów BigQuery.
3. Dodaj do swojej witryny bibliotekę JavaScript web-vitals, aby móc mierzyć wskaźniki Core Web Vitals i przesyłać dane do Google Analytics 4, w tym dane atrybucji.

Analizuj

Po zakończeniu konfiguracji w interfejsie BigQuery powinny pojawić się dane o zdarzeniach i będzie można wysyłać zapytania o takie dane w ten sposób:

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

Oto podgląd wyników tego zapytania:

Zapytania o dane wskaźników internetowych

Zanim zaczniesz wysyłać zapytania o dane zdarzeń Web Vitals, musisz zrozumieć, jak są one agregowane.

Najważniejsze jest to, że w niektórych przypadkach może dojść do otrzymania wielu zdarzeń dotyczących tych samych danych na tej samej stronie. Może się to zdarzyć, jeśli wartość danych ulegnie zmianie i zostanie zaktualizowana zaktualizowana wartość (częste zjawisko w przypadku CLS).

W przypadku zdarzeń Web Vitals ostatnia wysyłana wartość jest zawsze najdokładniejsza, dlatego przed przeprowadzeniem analizy warto 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żdej metryki, więc możesz użyć tego zapytania, aby ograniczyć wyniki tylko do ostatniej otrzymanej wartości dla każdego identyfikatora metryki:

# 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', 'INP', '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, o których mowa w tym poście, będą się zaczynać od tego zapytania podrzędnego.

Przykładowe zapytania

W kolejnych sekcjach znajdziesz kilka przykładów typowych zapytań Web Vitals, które możesz wykonać.

LCP, INP i CLS w 75. percentylu (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', 'INP', '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 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', 'INP', '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

wyniki LCP (p75) 10 najpopularniejszych stron;

# 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', 'INP', '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 z najgorszym wskaźnikiem 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', 'INP', '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

Poprzednie zapytania pokazują, jak wysyłać zapytania o dane wskaźników internetowych, które są przydatne do zrozumienia bieżącej skuteczności i jej trendów na przestrzeni czasu. Co możesz zrobić, jeśli skuteczność jest niższa niż oczekiwana, a nie wiesz, dlaczego?

Wiedza o tym, jakie są Twoje wyniki, nie jest przydatna, jeśli nie możesz podjąć działań i rozwiązać problemów.

W artykule Debugowanie skuteczności w polu znajdziesz informacje o tym, jak wysyłać dodatkowe informacje debugowania wraz z danymi statystycznymi. Jeśli wykonasz instrukcje podane w tym poście, informacje debugowania powinny pojawić się też w BigQuery.

Przykładowe zapytania

Z tych zapytań dowiesz się, jak używać parametru zdarzenia debug_target do identyfikowania przyczyn problemów z wydajnością.

Najpopularniejsze elementy mające wpływ na CLS

debug_target to ciąg znaków selektora CSS odpowiadający elementowi na stronie, który jest najbardziej odpowiedni do wartości danych.

W przypadku CLS wartość debug_target reprezentuje największy element z największego przesunięcia układu, który przyczynił się do wartości CLS. Jeśli żadne elementy się nie przesunęły, wartość debug_target będzie równa null.

To zapytanie spowoduje wyświetlenie stron z listy od najgorszej (najniższej) do najlepszej (najwyższej) według ich CLS w 75 centylu pogrupowanym 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', 'INP', '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 o tym, które elementy na stronie się przesuwają, powinna znacznie ułatwić zidentyfikowanie i usunięcie przyczyny problemu.

Pamiętaj, że elementy zgłoszone tutaj mogą nie być tymi samymi elementami, które zmieniają się podczas debugowania stron lokalnie. Dlatego tak ważne jest gromadzenie tych danych. Trudno jest naprawić coś, czego nie uważasz za problem.

Debugowanie innych danych

Poprzednie zapytanie zawiera wyniki dotyczące wskaźnika CLS, ale tej samej techniki można użyć do tworzenia raportów o celach debugowania dla LCP i INP. Aby debugować, zastąp klauzulę where odpowiednimi danymi:

WHERE metric_name = 'INP'
WHERE metric_name = 'LCP'

Instrukcje dotyczące zbierania i przesyłania informacji debugowania dla każdego z podstawowych wskaźników internetowych znajdziesz w artykule Debugowanie wydajności w polu.

Wyświetl wizualizację

Uzyskanie statystyk na samym poziomie zapytań może być trudne. Na przykład to zapytanie wyświetla dzienne wartości 75. procentyla LCP w 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', 'INP', '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 tych wyników zapytania trudno jest zidentyfikować trendy lub wartości odstające, po prostu analizując dane.

W takich przypadkach wizualizacja danych może pomóc Ci szybciej uzyskać statystyki.

Wizualizacja wyników zapytań w Looker Studio

BigQuery umożliwia szybkie wizualizowanie wyników zapytań w Studiu danych. Looker Studio to bezpłatne narzędzie do wizualizacji danych i tworzenia paneli. Aby wizualizować wyniki zapytania, po jego wykonaniu w interfejsie BigQuery kliknij przycisk Eksploruj dane i wybierz Eksploruj za pomocą Looker Studio.

Spowoduje to utworzenie bezpośredniego połączenia z BigQuery w eksploracji w Looker Studio. W tym widoku możesz wybrać pola, które chcesz zwizualizować, wybrać typy wykresów, filtry konfiguracji i tworzyć doraźne wykresy, aby szybko analizować wizualną. Na podstawie wyników poprzedniego zapytania możesz utworzyć wykres liniowy, aby zobaczyć trend wartości LCP na przestrzeni czasu:

Dzięki bezpośredniemu połączeniu BigQuery z Looker Studio możesz szybko tworzyć wykresy na podstawie dowolnego zapytania i przeprowadzać analizy wizualne. Jeśli jednak chcesz przeprowadzić dodatkową analizę, możesz wyświetlić kilka wykresów na interaktywnym panelu, aby uzyskać bardziej kompleksowy obraz lub przefiltrować dane. Dzięki przydatnemu panelowi nie musisz ręcznie pisać zapytań ani generować wykresów za każdym razem, gdy chcesz analizować dane.

W Looker Studio możesz utworzyć panel za pomocą natywnego połączenia z BigQuery. Aby to zrobić, otwórz stronę 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ć:

Tworzenie danych podstawowych wskaźników internetowych

Podczas tworzenia pulpitów na podstawie danych zdarzeń wskaźników internetowych, jak opisano wcześniej, nie warto bezpośrednio używać zestawu danych eksportowanego z Google Analytics 4. Ze względu na strukturę danych GA4 i wymagania wstępnej obróbki danych niezbędne do tworzenia wskaźników Web Vitals niektóre części zapytania będą wykonywane wielokrotnie. Powoduje to 2 problemy: wydajność panelu i koszty BigQuery.

Możesz bezpłatnie korzystać z trybu piaskownicy BigQuery. W ramach poziomu bezpłatnego użytkowania w BigQuery pierwsze 1 TB danych zapytań przetworzonych w miesiącu jest bezpłatne. W przypadku metod analizy opisanych w tym poście, jeśli nie używasz znacznie dużego zbioru danych lub regularnie wykonujesz na nim duże zapytania, nie musisz przekraczać tego limitu w każdym miesiącu. Jeśli jednak masz witrynę z dużą liczbą wizyt i chcesz regularnie monitorować różne wskaźniki za pomocą szybkiego interaktywnego panelu, zalecamy wstępne przetwarzanie i materializowanie danych o wydajności witryny z korzystaniem z funkcji zwiększających wydajność BigQuery, takich jak partycjonowanie, grupowanie i buforowanie.

Ten skrypt przetworzy wstępnie 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ść przetwarzanych 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', 'INP', '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');

Ten zmaterializowany zbiór danych ma kilka zalet:

• Struktura danych jest spłaszczona i ułatwia tworzenie zapytań.
• Zachowuje tylko zdarzenia Web Vitals z pierwotnego zbioru danych GA4.
• Identyfikator sesji, typ użytkownika (nowy lub powracający) oraz informacje o zaangażowaniu w sesję są dostępne bezpośrednio w kolumnach.
• Tabela jest dzielona według daty i zagnieżdżana według nazwy danych. Zwykle zmniejsza to ilość danych przetwarzanych w przypadku każdego zapytania.
• Ponieważ do wysyłania zapytań do tej tabeli nie musisz używać symboli wieloznacznych, wyniki zapytań mogą być przechowywane w pamięci podręcznej przez maksymalnie 24 godziny. Pozwala to zmniejszyć koszty powtarzania tych samych zapytań.
• Jeśli używasz mechanizmu BI BigQuery, możesz w tej tabeli uruchamiać zoptymalizowane funkcje i operatory SQL.

Możesz wysłać zapytanie bezpośrednio do tej zmaterializowanej tabeli z poziomu interfejsu BigQuery lub użyć jej w Looker Studio za pomocą łącznika BigQuery.

Używanie łącznika Web Vitals

Tworzenie panelu od podstaw jest czasochłonne, dlatego opracowaliśmy pakiet rozwiązań, który utworzy dla Ciebie panel na podstawie szablonu. Najpierw sprawdź, czy tabela Web Vitals została zmaterializowana za pomocą poprzedniego zapytania. Następnie otwórz oprogramowanie sprzęgające Web Vitals do Looker Studio przy użyciu tego linku: goo.gle/web-vitals-connector

Po udzieleniu jednorazowego upoważnienia powinien wyświetlić się ten ekran konfiguracji:

Podaj zmaterializowany identyfikator tabeli BigQuery (czyli tabeli docelowej) oraz identyfikator rozliczeniowy projektu BigQuery. Po kliknięciu opcji połącz Looker Studio utworzy nowy panel na podstawie szablonu i powiąże z nim Twoje dane. Możesz edytować, modyfikować i udostępniać pulpit według własnego uznania. Jeśli utworzysz panel raz, nie musisz ponownie korzystać z 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 możesz na karcie Podsumowanie sprawdzać codzienne trendy dotyczące wskaźników Web Vitals oraz informacje o użytkowaniu witryny, takie jak liczba użytkowników i sesji.

Na karcie Analiza użytkowników możesz wybrać dane, a potem uzyskać podział na odsetki danych oraz liczbę użytkowników według różnych danych o użytkowaniu i danych biznesowych.

Karta Analiza ścieżki do strony pomoże Ci zidentyfikować problemowe obszary w Twojej witrynie. Tutaj możesz wybrać dane, aby wyświetlić ich przegląd. Widzisz też mapę punktową wszystkich ścieżek na stronie z wartością percentylową na osi Y i liczbą rekordów na osi X. Mapa rozproszeń może pomóc w identyfikowaniu stron, na których wartości danych są niższe niż oczekiwane. Po wybraniu stron za pomocą wykresu rozrzutu w tabeli Ścieżka strony możesz dokładniej przyjrzeć się obszarowi problemowemu, korzystając z tabeli Błąd do debugowania.

Karta Analiza przychodów to przykład tego, jak możesz monitorować dane o swoim biznesie i o skuteczności w tym samym miejscu. Ta sekcja przedstawia wszystkie sesje, w których użytkownik dokonał zakupu. Możesz porównać uzyskane przychody z doświadczeniem użytkownika w określonej sesji.

Zaawansowane użycie

Gdy lepiej poznasz zbiór danych, możesz edytować panel i dodać do niego własne wykresy, aby uzyskać bardziej szczegółową i celową analizę. Aby ułatwić sobie korzystanie z panelu, możesz:

• Skonfiguruj zaplanowane zapytanie w BigQuery, aby uzyskać zaktualizowane dane. Wykonane wcześniej zapytanie o materializację tworzy tylko zrzut danych w danym momencie. Jeśli chcesz aktualizować swój panel o nowe dane, możesz uruchomić zaplanowane zapytanie, które będzie wykonywane codziennie i dołączanie tabeli zmaterializowanej z nowymi danymi.
• Złączanie danych własnych (np. z systemu CRM) w celu uzyskiwania statystyk biznesowych. W zmaterializowanej tabeli możesz dodać kolumnę user_id jako osobną kolumnę. Dzięki temu możesz złączać dane własne. Jeśli Twoje dane własne nie są jeszcze w BigQuery, możesz je przesłać lub użyć federowanego źródła danych.
• Raportuj wersję witryny lub aplikacji jako parametr w danych wysyłanych do Google Analytics i dodaj go jako kolumnę w zmaterializowanej tabeli. Następnie możesz dodać dane o tej wersji jako wymiar na wykresach, aby łatwiej było Ci sprawdzać, jak zmiany w wersji wpływają na skuteczność.
• Jeśli spodziewasz się znacznego wykorzystania zbioru danych przez bezpośrednie zapytanie lub panel, możesz spróbować użyć płatnej wersji BigQuery BI Engine.

Podsumowanie

W tym artykule omówiliśmy podstawy korzystania z Google Analytics 4 i BigQuery do pomiaru i debugowania skuteczności na podstawie danych o prawdziwych użytkownikach zebranych w warunkach rzeczywistych. W tym artykule znajdziesz też informacje o tym, jak tworzyć automatyczne raporty i panele informacyjne za pomocą narzędzia Looker Studio oraz połączenia Web Vitals, aby jak najłatwiej zwizualizować dane.

Oto kilka kluczowych wniosków z tego posta:

• Pomiar wydajności na podstawie rzeczywistych danych o użytkownikach jest kluczowy dla zrozumienia, debugowania i optymalizowania witryny.
• Bardziej szczegółowe statystyki możesz uzyskać, gdy dane o skuteczności i dane biznesowe znajdują się w tym samym systemie. Umożliwia to Google Analytics i BigQuery.
• Eksportowanie nieprzetworzonych danych Google Analytics do BigQuery daje nieograniczone możliwości przeprowadzania zaawansowanych analiz niestandardowych za pomocą języka zapytań, który prawdopodobnie już znasz.
• Google udostępnia wiele interfejsów API i narzędzi do wizualizacji, takich jak Looker Studio, które dają Ci swobodę tworzenia raportów dokładnie w taki sposób, w jaki chcesz.