Leistung mit Google Analytics 4 und BigQuery messen und Fehler beheben

Hier erfahren Sie, wie Sie Web Vitals-Daten an Google Analytics 4-Properties senden und die Daten zur Analyse in BigQuery und Looker Studio exportieren.

Google stellt eine Reihe von Tools zur Verfügung, darunter die Search Console, PageSpeed Insights (PSI) und den Chrome User Experience Report (CrUX), mit denen Entwickler sehen können, wie ihre Websites im Vergleich zu den Core Web Vitals-Messwerten für ihre tatsächlichen Nutzer vor Ort abschneiden.

Diese Tools bieten einen umfassenden Überblick über die tatsächliche Leistung Ihrer Website und erfordern keinerlei Einrichtung.

Es gibt jedoch einige kritische Gründe, warum du dich bei der Messung der Websiteleistung nicht ausschließlich auf diese Tools verlassen solltest:

• Die Daten werden entweder monatlich oder in den vorangegangenen 28 Tagen erfasst. Sie müssen also lange warten, nachdem Sie Änderungen vorgenommen haben, bevor Sie die Ergebnisse sehen.
• CrUX-basierte Tools können nur nach einer begrenzten Anzahl von Dimensionen segmentiert werden, z. B. Land, Verbindungstyp und Gerätekategorie (Computer oder Mobilgerät). Sie können die Daten nicht nach Dimensionen aufteilen, die für Ihr Unternehmen spezifisch sind (z. B. aktive Nutzer oder Nutzer in einer bestimmten Testgruppe).
• Tools, die auf Chrome UX basieren, geben Aufschluss über die Leistung, jedoch nicht darüber, warum. Mit Analysetools können Sie zusätzliche Daten senden, um Probleme zu ermitteln und zu beheben.

Daher empfehlen wir allen Websiteinhabern, die Core Web Vitals-Messwerte mit ihrem vorhandenen Analysetool im Blick zu behalten. In diesem Beitrag erfahren Sie, wie Sie dies mit den kostenlosen Tools von Google erreichen können.

Sobald Sie alles eingerichtet haben, können Sie Dashboards wie diese erstellen:

Eine grafische Übersicht über alle hier beschriebenen Schritte findest du in unserem Vortrag von der Google I/O 21:

Messen

In Google Analytics war es schon immer möglich, die Leistung mithilfe von benutzerdefinierten Messwerten zu messen. Allerdings gibt es in Google Analytics 4 (GA4) einige neue Funktionen, die besonders für Entwickler interessant sind.

• benutzerdefinierte Ereignisparameter ohne Konfigurationsaufwand
• Kostenloser BigQuery-Export, für den Sie Ihre Daten mit SQL abfragen können

Auch wenn die Google Analytics-Weboberfläche über leistungsstarke Analysetools verfügt, ist der Zugriff auf Rohdaten zu Ereignissen mit einer Abfragesprache, die Sie wahrscheinlich bereits kennen, kaum zu übertreffen.

Wenn Sie Core Web Vitals mit Google Analytics 4 und BigQuery messen möchten, müssen Sie drei Schritte ausführen:

1. Erstellen Sie eine Google Analytics 4-Property und ein BigQuery-Projekt.
2. Aktivieren Sie in der Konfiguration Ihrer Google Analytics-Property den BigQuery-Export, damit alle empfangenen Daten automatisch in Ihre BigQuery-Projekttabellen eingefügt werden.
3. Fügen Sie Ihrer Website die JavaScript-Bibliothek web-vitals hinzu, damit Sie die Core Web Vitals-Messwerte messen und die Daten an Google Analytics 4 senden können.

Analysieren

Sobald die Einrichtung abgeschlossen ist, sollten Ereignisdaten in der BigQuery-Benutzeroberfläche angezeigt werden und Sie sollten die Daten wie folgt abfragen können:

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

Vorschau der Ergebnisse dieser Abfrage:

Web Vitals-Daten abfragen

Bevor Sie mit der Abfrage Ihrer Web Vitals-Ereignisdaten beginnen, sollten Sie wissen, wie die Daten aggregiert werden.

Wichtig ist zu verstehen, dass in einigen Fällen auf derselben Seite mehrere Ereignisse für denselben Messwert empfangen werden können. Dies kann passieren, wenn sich der Messwert ändert und ein aktualisierter Wert gemeldet wird (was bei CLS häufig der Fall ist).

Bei Web Vitals-Ereignissen ist der zuletzt gesendete Wert immer der genaueste. Daher sollten Sie vor einer Analyse nur nach diesen Werten filtern. Das Code-Snippet der JavaScript-Bibliothek „web-vitals“ zum Senden von Daten an Google Analytics 4 beinhaltet das Senden einer eindeutigen ID pro Messwert. Mit der folgenden Abfrage können Sie die Ergebnisse auf den zuletzt erhaltenen Wert einer Messwert-ID beschränken:

# 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
)

Alle anderen Abfragen, auf die in diesem Beitrag verwiesen wird, beginnen mit dieser Unterabfrage.

In den nächsten Abschnitten finden Sie einige Beispiele für häufige Web Vitals-Abfragen, die Sie ausführen können.

Beispielabfragen

LCP, FID und CLS im 75. Perzentil (P75) für die gesamte Website

# 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

Alle einzelnen LCP-Werte vom höchsten zum niedrigsten Wert

# 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

LCP-Werte (P75) der zehn beliebtesten Seiten

# 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

Die 10 Seiten mit der schlechtesten CLS (S. 75)

# 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

Debuggen

Mit den oben genannten Abfragen wird gezeigt, wie Sie die Web Vitals-Messwertdaten abfragen können. Dadurch können Sie Ihre aktuelle Leistung besser nachvollziehen und erkennen, wie sich diese im Laufe der Zeit entwickelt. Aber was können Sie tun, wenn Ihre Leistung schlechter als erwartet ist, Sie aber nicht sicher sind, warum?

Es ist nicht hilfreich, zu wissen, was Ihre Bewertungen sind, wenn Sie keine Maßnahmen ergreifen und die Probleme nicht beheben können.

In Debug-Leistung vor Ort wird erläutert, wie Sie mit Ihren Analysedaten zusätzliche Informationen zur Fehlerbehebung senden können. Wenn Sie der Anleitung in diesem Post folgen, sollten diese Informationen zur Fehlerbehebung auch in BigQuery angezeigt werden.

In den folgenden Abfragen wird gezeigt, wie Sie mit dem Ereignisparameter debug_target die Ursache von Leistungsproblemen ermitteln können.

Beispielabfragen

Wichtigste Elemente, die zu CLS beitragen

debug_target ist ein CSS-Selektorstring, der dem Element auf der Seite entspricht, das für den Messwert am relevantesten ist.

Bei CLS stellt das debug_target das größte Element aus der größten Layoutverschiebung dar, die zum CLS-Wert beigetragen hat. Wenn keine Elemente verschoben wurden, ist der Wert für debug_target null.

Mit der folgenden Abfrage werden die Seiten vom schlechtesten zum besten nach ihrer CLS im 75. Perzentil aufgelistet, gruppiert nach 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

Wenn Sie wissen, welche Elemente auf der Seite sich ändern, ist es viel einfacher, die Ursache des Problems zu identifizieren und zu beheben.

Die hier aufgeführten Elemente entsprechen möglicherweise nicht den Elementen, die sich verändern, wenn Sie die Fehler auf Ihren Seiten lokal beheben. Deshalb ist es so wichtig, diese Daten von vornherein zu erfassen. Es ist sehr schwierig, Dinge zu beheben, von denen Sie nicht wissen, dass es sich um Probleme handelt!

Andere Messwerte debuggen

Die obige Abfrage stellt die Ergebnisse für den CLS-Messwert bereit. Es kann jedoch mit derselben Methode auch Berichte zu den Fehlerbehebungszielen für LCP und FID erstellt werden. Ersetzen Sie dazu einfach die WHERE-Klausel durch den entsprechenden Messwert für die Fehlerbehebung:

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

Wie Sie Informationen zur Fehlerbehebung für jeden Core Web Vitals-Messwert erfassen und senden, erfahren Sie unter Fehlerbehebung bei der Leistung im Feld.

Visualisieren

Es kann schwierig sein, allein die Abfrageergebnisse zu betrachten. Die folgende Abfrage listet beispielsweise die täglichen 75. Perzentilwerte für den LCP im Dataset auf.

# 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

Anhand dieser Abfrageergebnisse ist es schwierig, Trends oder Ausreißer allein durch eine Betrachtung der Daten zu identifizieren.

In solchen Fällen können Sie durch die Visualisierung der Daten schneller Erkenntnisse gewinnen.

Abfrageergebnisse in Looker Studio visualisieren

Mit BigQuery können Sie Abfrageergebnisse schnell über Data Studio visualisieren. Looker Studio ist ein Tool zur Datenvisualisierung und Dashboarding, das kostenlos verwendet werden kann. Zum Visualisieren der Abfrageergebnisse klicken Sie nach dem Ausführen der Abfrage in der BigQuery-Benutzeroberfläche auf die Schaltfläche Daten ansehen und wählen Sie Mit Looker Studio auswerten aus.

Dadurch wird in der Explore-Ansicht eine direkte Verknüpfung von BigQuery zu Looker Studio erstellt. In dieser Ansicht können Sie die Felder auswählen, die Sie visualisieren möchten, Diagrammtypen auswählen, Filter einrichten und Ad-hoc-Diagramme für eine schnelle visuelle Analyse erstellen. Aus den obigen Abfrageergebnissen können Sie dieses Liniendiagramm erstellen, um den Trend der LCP-Werte im Zeitverlauf zu sehen:

Über diese direkte Verknüpfung zwischen BigQuery und Looker Studio können Sie schnelle Diagramme aus allen Ihren Abfragen erstellen und visuelle Analysen durchführen. Wenn Sie jedoch zusätzliche Analysen durchführen möchten, können Sie sich mehrere Diagramme in einem interaktiven Dashboard ansehen, um einen umfassenderen Überblick zu erhalten oder die Daten aufzuschlüsseln. Ein praktisches Dashboard bedeutet, dass Sie nicht jedes Mal, wenn Sie Ihre Messwerte analysieren möchten, Abfragen schreiben und Diagramme manuell generieren müssen.

In Looker Studio können Sie ein Dashboard mit dem nativen BigQuery-Connector erstellen. Rufen Sie dazu datastudio.google.com auf, erstellen Sie eine neue Datenquelle, wählen Sie den BigQuery-Connector und dann das Dataset aus, mit dem Sie arbeiten möchten:

Materialize Web Vitals-Daten

Wenn Sie wie oben beschrieben Dashboards mit Web Vitals-Ereignisdaten erstellen, ist es nicht effizient, das Google Analytics 4-Export-Dataset direkt zu verwenden. Aufgrund der Struktur der GA4-Daten und der für die Web Vitals-Messwerte erforderlichen Vorverarbeitung werden Teile Ihrer Abfrage am Ende mehrmals ausgeführt. Dies führt zu zwei Problemen: der Dashboard-Leistung und den BigQuery-Kosten.

Sie können den BigQuery-Sandbox-Modus kostenlos verwenden. Bei der kostenlosen Nutzungsstufe von BigQuery ist das erste Terabyte (1 TB) an verarbeiteten Abfragedaten pro Monat kostenlos. Bei den Analysemethoden, die in diesem Beitrag erläutert werden, sollten Sie das kostenlose Limit jeden Monat nicht überschreiten, es sei denn, Sie verwenden ein sehr großes Dataset oder führen regelmäßig umfassende Abfragen des Datasets durch. Wenn Sie jedoch eine Website mit hohem Traffic haben und verschiedene Messwerte regelmäßig über ein schnelles interaktives Dashboard überwachen möchten, empfehlen wir die Vorverarbeitung und Materialisierung Ihrer Web Vitals-Daten und die Nutzung von BigQuery-Effizienzfeatures wie Partitionierung, Clustering und Caching.

Das folgende Skript verarbeitet Ihre BigQuery-Daten (Quelltabelle) vor und erstellt eine materialisierte Tabelle (Zieltabelle). Wenn Sie diese Abfrage für Ihr eigenes Dataset verwenden, können Sie auch einen Zeitraum für die Quelltabelle definieren, um die verarbeitete Datenmenge zu reduzieren.

# 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');

Dieses materialisierte Dataset hat mehrere Vorteile:

• Die Datenstruktur ist vereinfacht und einfacher abfragen.
• Es werden nur die Web Vitals-Ereignisse aus dem ursprünglichen GA4-Dataset beibehalten.
• Sitzungs-ID, Nutzertyp (neu oder wiederkehrend) und Informationen zur Sitzungsinteraktion sind direkt in Spalten verfügbar.
• Die Tabelle wird nach Datum partitioned und nach Messwertnamen geclustert. Dadurch wird in der Regel die pro Abfrage verarbeitete Datenmenge reduziert.
• Da Sie zum Abfragen dieser Tabelle keine Platzhalter verwenden müssen, können Abfrageergebnisse bis zu 24 Stunden im Cache gespeichert werden. Dies reduziert die Kosten für die Wiederholung derselben Abfrage.
• Wenn Sie die BigQuery BI Engine verwenden, können Sie optimierte SQL-Funktionen und -Operatoren für diese Tabelle ausführen.

Sie können diese materialisierte Tabelle direkt über die BigQuery-UI abfragen oder sie in Looker Studio mit dem BigQuery-Connector verwenden.

Verwenden des Web Vitals-Connectors

Da es zeitaufwendig ist, ein Dashboard von Grund auf neu zu erstellen, haben wir eine Paketlösung entwickelt, die ein Vorlagen-Dashboard für Sie erstellt. Prüfen Sie zuerst, ob Sie Ihre Web Vitals-Tabelle mithilfe der obigen Abfrage materialisiert haben. Rufen Sie dann den Web Vitals-Connector für Looker Studio über diesen Link auf: goo.gle/web-vitals-connector.

Nachdem Sie eine einmalige Autorisierung erteilt haben, sollten Sie den folgenden Konfigurationsbildschirm sehen:

Geben Sie die ID der materialisierten BigQuery-Tabelle (die Zieltabelle) und die ID Ihres BigQuery-Abrechnungsprojekts an. Wenn Sie auf „Verbinden“ klicken, wird in Looker Studio ein neues Dashboard mit Ihren Daten erstellt. Sie können das Dashboard nach Belieben bearbeiten, ändern und teilen. Wenn Sie ein Dashboard einmal erstellen, müssen Sie den Connector-Link nicht noch einmal aufrufen, es sei denn, Sie möchten mehrere Dashboards aus verschiedenen Datasets erstellen.

Im Dashboard navigieren

Im Dashboard werden auf dem Tab Zusammenfassung die täglichen Trends der Web Vitals-Messwerte sowie einige Nutzungsdaten für Ihre Website (z. B. Nutzer und Sitzungen) angezeigt.

Auf dem Tab Nutzeranalyse können Sie einen Messwert auswählen und dann das Messwertperzentil sowie die Nutzerzahl nach verschiedenen Nutzungs- und Geschäftsmesswerten aufschlüsseln.

Mithilfe des Tabs Seitenpfadanalyse können Sie Problembereiche auf Ihrer Website identifizieren. Hier können Sie einen Messwert auswählen, um die Übersicht anzuzeigen. Sie sehen aber auch die Streukarte aller Seitenpfade mit dem Perzentilwert auf der y-Achse und der Datensatzanzahl auf der x-Achse. Mithilfe der Streukarte lassen sich Seiten identifizieren, deren Messwerte niedriger als erwartet sind. Nachdem Sie die Seiten mithilfe des Streudiagramms der Tabelle Seitenpfad ausgewählt haben, können Sie den Problembereich in der Tabelle Fehlersuche-Ziel weiter aufschlüsseln.

Der Tab Umsatzanalyse ist ein Beispiel dafür, wie Sie Ihre Geschäfts- und Leistungsmesswerte an einem Ort überwachen können. In diesem Abschnitt sehen Sie alle Sitzungen, bei denen die Nutzenden etwas gekauft haben. Sie können den erzielten Umsatz mit dem der Nutzererfahrung während einer bestimmten Sitzung vergleichen .

Fortgeschrittene Nutzung

Wenn Sie sich mit dem Dataset vertraut machen, können Sie das Dashboard bearbeiten und Ihre eigenen Diagramme hinzufügen, um umfassendere und zielgerichtete Analysen zu erstellen. So können Sie das Dashboard hilfreicher gestalten:

• Richten Sie eine geplante Abfrage in BigQuery ein, um aktualisierte Daten zu erhalten. Die oben ausgeführte Materialisierungsabfrage erstellt zu diesem Zeitpunkt nur einen Snapshot Ihrer Daten. Wenn Sie Ihr Dashboard mit neuen Daten auf dem neuesten Stand halten möchten, können Sie eine geplante Abfrage ausführen, die jeden Tag ausgeführt wird und die materialisierte Tabelle mit den neuen Daten anhängt.
• Führen Sie selbst erhobene Daten (z.B. CRM) zusammen, um Geschäftseinblicke zu gewinnen. In der materialisierten Tabelle können Sie user_id als separate Spalte hinzufügen. So können Sie Ihre selbst erhobenen Daten zusammenführen. Wenn sich Ihre selbst erhobenen Daten nicht bereits in BigQuery befinden, können Sie entweder die Daten laden oder eine föderierte Datenquelle verwenden.
• Sie können Ihre Website- oder App-Version als Parameter in den Daten melden, die Sie an Google Analytics senden, und sie der materialisierten Tabelle als Spalte hinzufügen. Anschließend können Sie diese Versionsdaten als Dimension in Ihre Diagramme aufnehmen, um leichter zu erkennen, wie sich Versionsänderungen auf die Leistung auswirken.
• Wenn Sie eine stark intensive Nutzung des Datasets durch direkte Abfragen oder das Dashboard erwarten, können Sie die kostenpflichtige Version von BigQuery BI Engine verwenden.

Zusammenfassung

In diesem Beitrag wurden die Grundlagen der Verwendung von Google Analytics 4 und BigQuery zum Messen und Debuggen der Leistung mit realen Nutzerdaten behandelt, die vor Ort erfasst wurden. Außerdem wurde erläutert, wie mit Looker Studio und dem Web Vitals-Connector automatisierte Berichte und Dashboards erstellt werden, um die Visualisierung der Daten so einfach wie möglich zu gestalten.

Die wichtigsten Erkenntnisse aus diesem Post:

• Die Leistungsmessung mit echten Nutzerdaten ist für das Verständnis, die Fehlerbehebung und die Optimierung Ihrer Website von entscheidender Bedeutung.
• Ausführlichere Informationen erhalten Sie, wenn sich Ihre Leistungsmesswerte und Ihre Geschäftsmesswerte im selben System befinden. Google Analytics und BigQuery machen dies möglich.
• Der BigQuery-Export von Google Analytics-Rohdaten bietet Ihnen unbegrenztes Potenzial für detaillierte benutzerdefinierte Analysen mit einer Abfragesprache, die Sie wahrscheinlich bereits kennen.
• Google bietet eine Reihe von APIs und Visualisierungstools wie Looker Studio, mit denen Sie Ihre Berichte ganz nach Ihren Wünschen erstellen können.