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, a ich użycie nie wymaga ż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.

Z tego powodu zalecamy wszystkim właścicielom witryn monitorowanie danych podstawowych wskaźników internetowych za pomocą dotychczasowego narzędzia analitycznego. 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.

• Parametry zdarzenia o zerowej konfiguracji
• bezpłatny eksport do BigQuery, dzięki któremu możesz wysyłać zapytania do swoich 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 rozpocząć pomiar podstawowych wskaźników internetowych za pomocą Google Analytics 4 i BigQuery, musisz wykonać 3 działania:

1. Utwórz usługę w Google Analytics 4 i projekt BigQuery.
2. Włącz BigQuery Export w konfiguracji usługi w Google Analytics, aby wszystkie otrzymane dane były automatycznie wypełniane w tabelach projektu 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 skonfigurowaniu usługi dane o zdarzeniach powinny się wypełniać w interfejsie BigQuery i powinna być możliwość wysyłania do nich zapytań w taki 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 dotyczące 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ę tak zdarzyć, jeśli wartość danych ulegnie zmianie i zostanie zgłoszona nowa wartość (częsty przypadek w przypadku CLS).

W przypadku zdarzeń Web Vitals ostatnia wysłana wartość jest zawsze najbardziej dokładna, dlatego przed przeprowadzeniem analizy ważne jest, aby filtrować 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 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', '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 Analytics. 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ą.

Najważniejsze elementy wpływające na CLS

debug_target to ciąg selektora arkusza 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 żaden element się nie przesunął, wartość debug_target będzie równa null.

To zapytanie wyświetla strony od najgorszej do najlepszej pod względem CLS w 75. procentylu, pogrupowane według 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ę

Analiza wyników zapytania może być trudna, jeśli nie weźmiemy pod uwagę innych informacji. 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 wybierać pola, które chcesz wizualizować, wybierać typy wykresów, konfigurować filtry i tworzyć doraźne wykresy na potrzeby szybkiej analizy wizualnej. 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 złącze BigQuery i wybierz 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 omówionych w tym poście, o ile nie używasz bardzo dużego zbioru danych ani nie wysyłasz regularnie dużej liczby zapytań do zbioru danych, powinieneś mieścić się w tym bezpłatnym limicie co miesiąc. 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 łatwiej ją przeszukiwać.
• 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 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 w narzędziu Looker Studio łącznik Web Vitals, korzystając z 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 uznania. Jeśli panel został już utworzony, nie musisz ponownie otwierać linku do usługi łączącej, chyba że chcesz utworzyć kilka paneli na podstawie 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 rozrzutu może pomóc w identyfikowaniu stron, na których wartości danych są niższe od oczekiwanych. Po wybraniu stron za pomocą wykresu rozrzutu w tabeli Ścieżka strony możesz dokładniej przyjrzeć się obszarowi problemowemu, korzystając z tabeli Debugowanie celu.

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ć bogatsze i bardziej ukierunkowane wyniki analizy. Aby panel był bardziej przydatny, wykonaj te czynności:

• Skonfiguruj zaplanowane zapytanie w BigQuery, aby otrzymywać zaktualizowane dane. Wykonane wcześniej zapytanie o materializację tworzy tylko zrzut danych w danym momencie. Jeśli chcesz, aby panel był zawsze aktualizowany o nowe dane, możesz uruchomić zaplanowane zapytanie, które będzie wykonywane codziennie i dodawać nowe dane do tabeli zmaterializowanej.
• Złączanie danych własnych (np. z systemu CRM) na potrzeby analiz 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 sprawdzić, 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 najważniejsze wnioski z tego posta:

• Pomiar skuteczności na podstawie rzeczywistych danych o użytkownikach jest kluczowy do 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żliwiają to Google Analytics i BigQuery.
• Eksportowanie nieprzetworzonych danych Google Analytics do BigQuery daje nieograniczone możliwości przeprowadzania szczegółowych, niestandardowych analiz 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.