Mierzenie i debugowanie skutecznoś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.

Google udostępnia wiele narzędzi – konsolę wyszukiwania, PageSpeed Insights (PSI) i Raport na temat użytkowania Chrome (CrUX), które pozwalają deweloperom sprawdzać skuteczność witryn w porównaniu z danymi podstawowych wskaźników internetowych na potrzeby rzeczywistych użytkowników w ich zakresie.

Narzędzia te są bardzo przydatne, ponieważ dają ogólny wgląd w rzeczywistą wydajność witryny dla użytkowników i nie wymagają absolutnie żadnej 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 według miesięcy lub poprzednich 28 dni. Oznacza to, że po wprowadzeniu jakichkolwiek zmian trzeba będzie długo czekać, zanim zobaczysz wyniki.
• Narzędzia oparte na 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 dzielić danych według wymiarów związanych z Twoją działalnością (np. zaangażowanych użytkowników, użytkowników z konkretnej grupy eksperymentalnej itp.).
• Narzędzia te mogą określić wydajność, ale nie pomogą. Narzędzia analityczne pozwalają wysyłać dodatkowe dane, które pomagają w wykrywaniu i debugowaniu problemów.

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 wykorzystać w tym celu bezpłatne narzędzia oferowane przez Google.

Po zakończeniu konfiguracji możesz utworzyć następujące panele informacyjne:

Jeśli interesuje Cię omówienie wszystkich opisanych tu czynności, obejrzyj naszą prezentację z Google I/O 2021:

Zmierz odległość

Mierzenie skuteczności było zawsze możliwe w Google Analytics za pomocą danych niestandardowych, ale w Google Analytics 4 (GA4) pojawiło się kilka nowych funkcji, które szczególnie powinni zainteresować deweloperów.

• parametr zdarzenia niestandardowego, parametr „0”;
• możliwość bezpłatnego eksportowania do BigQuery, aby móc wysyłać zapytania o dane za pomocą SQL

Chociaż interfejs internetowy Google Analytics ma zaawansowane narzędzia analityczne, trudno jest go prześcignąć z możliwością i elastycznością dostępu do nieprzetworzonych danych zdarzeń za pomocą znanego języka zapytań.

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 mierzyć podstawowe wskaźniki internetowe i wysył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:

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

Zanim zaczniesz wykonywać zapytania o dane zdarzenia 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ć otrzymanych wiele zdarzeń związanych z tymi samymi danymi. 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 unikalnych identyfikatorów dla poszczególnych rodzajów danych. Dzięki temu możesz za pomocą tego zapytania ograniczyć wyniki tylko do ostatnio odebranej 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', '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, do których odwołuje się ten post, zaczną się od tego podzapytania.

Przykładowe zapytania

W kolejnych sekcjach znajdziesz kilka przykładów typowych zapytań dotyczących wskaźników internetowych, które możesz uruchomić.

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 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', '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

wynik 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 o najgorszej wartości 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 tworzyć zapytania o dane wskaźników internetowych, które pomagają zrozumieć bieżącą wydajność i jej zmiany w czasie. Ale co możesz zrobić, jeśli skuteczność jest niższa od oczekiwanej, ale nie wiesz, dlaczego?

Wiedza o tym, jakie są wyniki, nie jest pomocna, jeśli nie jesteś w stanie podjąć działań i rozwiązać problemów.

Sekcja Dane debugowania w polu zawiera informacje o tym, jak wraz z danymi analitycznymi wysyłać dodatkowe informacje na potrzeby debugowania. Jeśli wykonasz instrukcje opisane w tym poście, dane debugowania również powinny się pojawić w BigQuery.

Przykładowe zapytania

Podane niżej zapytania pokazują, jak używać parametru zdarzenia debug_target, aby łatwiej identyfikować główną przyczynę problemów z wydajnością.

Najpopularniejsze elementy mające wpływ na CLS

debug_target to ciąg selektora arkusza CSS odpowiadający elementowi na stronie, który jest najbardziej związany z wartością danych.

W CLS 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 nie został przesunięty, debug_target ma wartość 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ę zmieniają, powinna znacznie ułatwić znalezienie i usunięcie głównej przyczyny problemu.

Pamiętaj, że widoczne tutaj elementy mogą nie być tymi samymi elementami, które widzisz zmieniające się podczas debugowania stron lokalnie, dlatego tak ważne jest, aby przechwycić te dane. Bardzo ciężko jest naprawić coś, z czego nie zdajesz sobie sprawy, że to problem!

Debugowanie innych danych

Poprzednie zapytanie pokazuje wyniki dla danych CLS, ale w raportach dotyczących celów debugowania dla LCP i INP można użyć dokładnie tej samej metody. Wystarczy zastąpić klauzulę „w miejscu” odpowiednimi danymi do debugowania:

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

Instrukcje dotyczące zbierania i przesyłania informacji o debugowaniu w przypadku poszczególnych podstawowych wskaźników internetowych znajdziesz w artykule Debugowanie wydajności w tym polu.

Wyświetl wizualizację

Uzyskanie statystyk na samym poziomie 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', '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 bardzo trudno jest zidentyfikować trendy lub odchylenia od normy na podstawie samych danych.

W takich przypadkach wizualizacja danych może pomóc w szybszym wyciąganiu wniosków.

Wizualizacja wyników zapytań w Looker Studio

BigQuery umożliwia szybką wizualizację wyników zapytań w Studiu danych. Looker Studio to bezpłatne narzędzie do wizualizacji i paneli informacyjnych. Aby wizualizować 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 wglądu. 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ć ten wykres liniowy, aby zobaczyć trendy wartości LCP w czasie:

Dzięki temu bezpośredniemu połączeniu między BigQuery a Looker Studio możesz tworzyć szybkie wykresy na podstawie dowolnych zapytań i przeprowadzać analizy wizualne. Jeśli jednak chcesz przeprowadzić dodatkową analizę, możesz spojrzeć na kilka wykresów w interaktywnym panelu informacyjnym, aby uzyskać bardziej całościowy widok lub móc przeanalizować dane. Dzięki przydatnemu panelowi nie musisz pisać zapytań ani ręcznie generować wykresów, za każdym razem, gdy chcesz analizować wskaźniki.

Panel w Looker Studio możesz utworzyć za pomocą natywnego oprogramowania sprzęgającego BigQuery. W tym celu 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ć:

Realizuj dane ze wskaźników internetowych

Podczas tworzenia paneli z danymi zdarzeń internetowych wskaźników internetowych w opisany wcześniej sposób nie warto bezpośrednio używać zbioru danych eksportu Google Analytics 4. Ze względu na strukturę danych w GA4 i wstępne przetwarzanie danych wskaźników internetowych część zapytania będzie działać wiele razy. Powoduje to 2 problemy: wydajność panelu i koszty BigQuery.

Z trybu piaskownicy BigQuery możesz korzystać bezpłatnie. W przypadku bezpłatnego poziomu wykorzystania BigQuery pierwsze 1 TB danych zapytań przetwarzanych miesięcznie 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ę o dużym natężeniu ruchu i chcesz regularnie monitorować różne wskaźniki za pomocą szybkiego, interaktywnego panelu, sugerujemy wstępne przetwarzanie i materializację danych o podstawowych wskaźnikach internetowych przy jednoczesnym wykorzystaniu funkcji BigQuery zwiększających wydajność, takich jak partycjonowanie, grupowanie i buforowanie.

Poniższy skrypt wstępnie przetworzy Twoje dane BigQuery (tabela źródłowa) i utworzy tabelę zmaterializowaną (tabelę docelową). Podczas używania tego zapytania do własnego zbioru danych możesz też określić 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 on tylko zdarzenia wskaźników internetowych z pierwotnego zbioru danych GA4.
• Identyfikator sesji, typ użytkownika (nowi lub powracający) oraz informacje o zaangażowaniu w sesję są bezpośrednio dostępne w kolumnach.
• Tabela jest partitioned według daty i grupowana według nazwy wskaźnika. Zwykle zmniejsza to ilość danych przetwarzanych przy każdym zapytaniu.
• 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. Zmniejsza to koszty powtarzania tego samego zapytania.
• Jeśli używasz silnika analityki biznesowej BigQuery, możesz w tej tabeli uruchomić zoptymalizowane funkcje i operatory SQL.

Możesz bezpośrednio przesłać zapytanie do tej zmaterializowanej tabeli z poziomu 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 podstaw jest czasochłonne, dlatego opracowaliśmy pakiet rozwiązania, które pozwoli Ci utworzyć szablon panelu. Najpierw upewnij się, że tabela wskaźników internetowych została zmaterialowana 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 przyznaniu jednorazowej autoryzacji powinien wyświetlić się następujący ekran konfiguracji:

Podaj identyfikator zmaterializowanej tabeli BigQuery (tj. tabeli docelowej) i identyfikator projektu rozliczeniowego BigQuery. Gdy klikniesz Połącz, Looker Studio utworzy nowy panel z szablonem i powiąże z nim Twoje dane. Panel możesz edytować, modyfikować i udostępniać 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

W poruszaniu się po panelu na karcie Podsumowanie możesz obserwować dzienne trendy w danych wskaźników internetowych i niektóre informacje o wykorzystaniu witryny, np. użytkowników i sesje.

Na karcie Analiza użytkowników możesz wybrać dane, a potem zobaczyć zestawienie centyli danych i liczby użytkowników według różnych wskaźników wykorzystania i firmowych.

Karta Analiza ścieżki do strony ułatwia wykrywanie problematycznych obszarów witryny. Tutaj możesz wybrać dane, aby wyświetlić ogólne informacje. Widać też mapę rozproszoną wszystkich ścieżek do strony z wartością percentyla na osi Y i liczbą rejestru na osi x. Mapa punktowa może pomóc w wykryciu stron, które mają niższe od oczekiwanych wartości danych. Po wybraniu stron za pomocą wykresu punktowego w tabeli Ścieżka do strony możesz dokładniej przeanalizować problem, wyświetlając tabelę Debugowanie docelowe.

Karta Analiza przychodów to przykład sposobu monitorowania w jednym miejscu danych o firmie i skuteczności. W tej sekcji widoczne są wszystkie sesje, w których użytkownik dokonał zakupu. Możesz porównać przychody i wrażenia użytkowników w trakcie danej sesji .

Zaawansowane użycie

W miarę jak lepiej poznasz zbiór danych, możesz edytować panel i dodawać własne wykresy, aby przeprowadzać bardziej szczegółową i ukierunkowaną analizę. Aby ułatwić sobie korzystanie z panelu, możesz:

• Skonfiguruj zaplanowane zapytanie w BigQuery, aby uzyskać zaktualizowane dane. Zapytanie zmaterializowane, które uruchomiliśmy wcześniej, zawiera tylko przegląd Twoich danych dostępnych w tej chwili. 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łączaj dane własne (np. z systemu CRM), aby uzyskiwać statystyki biznesowe. W tabeli zmaterializowanej możesz dodać user_id jako oddzielną kolumnę. Dzięki temu możesz złączać dane własne. Jeśli danych własnych nie ma jeszcze w BigQuery, możesz je wczytać lub użyć sfederowanego źródła danych.
• Zgłoś wersję witryny lub aplikacji jako parametr w danych przesyłanych do Google Analytics i dodaj tę wersję jako kolumnę w tabeli zmaterializowanej. Następnie możesz dodać dane tej wersji jako wymiar na wykresach, aby łatwiej zauważyć, że zmiany wersji wpływają na skuteczność.
• Jeśli spodziewasz się znacznego zwiększenia wykorzystania zbioru danych za pomocą bezpośredniego zapytania lub panelu, spróbuj użyć płatnej wersji silnika analityki biznesowej BigQuery.

Podsumowanie

W tym poście omówiliśmy podstawy korzystania z Google Analytics 4 i BigQuery do mierzenia i debugowania skuteczności na podstawie zebranych w terenie danych rzeczywistych użytkowników. Wyjaśniliśmy też, jak tworzyć automatyczne raporty i panele za pomocą Looker Studio i oprogramowania sprzęgającego do wskaźników internetowych, aby maksymalnie ułatwić wizualizację danych.

Oto kilka kluczowych wniosków z tego posta:

• Pomiar skuteczności na podstawie rzeczywistych danych użytkowników ma kluczowe znaczenie dla zrozumienia, debugowania i optymalizacji witryny.
• Dokładniejsze 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.
• Eksport nieprzetworzonych danych Google Analytics do BigQuery zapewnia nieograniczony potencjał w zakresie szczegółowych, niestandardowych analiz z wykorzystaniem języka zapytań, który prawdopodobnie już znasz.
• Google oferuje wiele interfejsów API i narzędzi do wizualizacji, takich jak Looker Studio, dzięki którym możesz tworzyć raporty dokładnie tak, jak chcesz.