Misura ed esegui il debug del rendimento con Google Analytics 4 e BigQuery

Scopri come inviare i dati di Web Vitals alle proprietà Google Analytics 4 ed esportarli per l'analisi in BigQuery e Looker Studio.

Google offre una serie di strumenti, Search Console, PageSpeed Insights (PSI) e il Report sull'esperienza utente di Chrome (CrUX, che consentono agli sviluppatori di controllare le prestazioni dei loro siti rispetto alle metriche Segnali web essenziali per i loro utenti reali sul campo.

Questi strumenti sono straordinari in quanto offrono una visione generale delle prestazioni reali degli utenti del tuo sito e non richiedono alcuna configurazione per iniziare a utilizzarli.

Tuttavia, esistono alcuni motivi critici per cui non vuoi fare affidamento solo su questi strumenti per misurare il rendimento del tuo sito:

• Gli strumenti basati su CrUX generano report sui dati per periodi di 28 giorni mensili o precedenti. Ciò significa che, dopo aver apportato eventuali modifiche, dovrai attendere molto tempo prima di poter visualizzare i risultati.
• Gli strumenti basati su CrUX possono essere segmentati solo in base a un numero limitato di dimensioni, ad esempio paese, tipo di connessione e categoria dispositivo (computer o dispositivo mobile). Non puoi suddividere i dati in base a dimensioni specifiche per la tua attività, ad esempio utenti coinvolti, utenti di un determinato gruppo sperimentale e così via.
• Gli strumenti basati su CrUX sono in grado di indicare le tue prestazioni, ma non il perché. Con gli strumenti di analisi puoi inviare dati aggiuntivi per monitorare i problemi ed eseguirne il debug.

Per questi motivi, consigliamo a tutti i proprietari di siti di monitorare le metriche di Core Web Vitals utilizzando il loro strumento di analisi esistente. Questo post spiega come usare gli strumenti senza costi offerti da Google a questo scopo.

Una volta completata la configurazione, potrai creare dashboard come queste:

Se vuoi una panoramica visiva di tutti i passaggi descritti qui, dai un'occhiata alla nostra conferenza da Google I/O '21:

Misura

Misurare il rendimento è sempre stato possibile con Google Analytics utilizzando le metriche personalizzate, ma Google Analytics 4 (GA4) offre alcune nuove funzionalità di cui gli sviluppatori dovrebbero essere entusiasti.

• Parametri di evento personalizzati e zero a configurazione
• Esportazione senza costi in BigQuery, per eseguire query sui tuoi dati utilizzando SQL

Sebbene l'interfaccia web di Google Analytics disponga di potenti strumenti di analisi, è difficile battere la potenza e la flessibilità dell'accesso ai dati non elaborati sugli eventi utilizzando un linguaggio di query che probabilmente già conosci.

Per iniziare a misurare i Segnali web essenziali con Google Analytics 4 e BigQuery, devi eseguire tre operazioni:

1. Crea una proprietà Google Analytics 4 e un progetto BigQuery.
2. Abilita l'esportazione BigQuery nella configurazione della proprietà Google Analytics in modo che tutti i dati che ricevi vengano completati automaticamente nelle tabelle del progetto BigQuery.
3. Aggiungi la libreria JavaScript degli elementi web essenziali al tuo sito, in modo da poter misurare le metriche di Core Web Vitals e inviare i dati a Google Analytics 4.

Analizza

Al termine della configurazione, i dati sugli eventi dovrebbero essere compilati nell'interfaccia di BigQuery e dovresti essere in grado di eseguire query sui dati in questo modo:

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

Ecco un'anteprima dei risultati della query:

Eseguire query sui dati di Web Vitals

Prima di iniziare a eseguire query sui dati degli eventi Web Vitals, è importante comprendere come vengono aggregati i dati.

La cosa più importante da capire è che, in alcuni casi, è possibile ricevere più eventi per la stessa metrica e sulla stessa pagina. Questo può accadere se il valore della metrica cambia e viene segnalato un valore aggiornato (un'occorrenza comune con CLS).

Per gli eventi Web Vitals, l'ultimo valore inviato è sempre il più preciso, quindi prima di eseguire qualsiasi analisi, è importante filtrare solo in base a quei valori. Lo snippet di codice fornito dalla libreria JavaScript degli eventi web per inviare dati a Google Analytics 4 include l'invio di un ID univoco per metrica, quindi puoi utilizzare la seguente query per limitare i risultati solo all'ultimo valore ricevuto per ogni ID metrica:

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

Tieni presente che tutte le altre query a cui viene fatto riferimento in questo post inizieranno con questa sottoquery.

Le prossime sezioni mostrano alcuni esempi di query di Web Vitals comuni che potresti voler eseguire.

Esempi di query

LCP, FID e CLS al 75% percentile (p75) nell'intero sito

# 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

Tutti i singoli valori LCP dal più alto al più basso

# 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

Punteggi LCP (p75) delle 10 pagine più popolari

# 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

Prime 10 pagine con il CLS peggiore (p75)

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

esegui il debug

Le query precedenti mostrano come eseguire query sui dati della metrica Web Vitals, che è utile per comprendere le prestazioni attuali e le relative tendenze nel tempo. Ma che cosa puoi fare se il tuo rendimento è inferiore alle aspettative, ma non sai perché?

Sapere quali sono i tuoi punteggi non è utile se non sei in grado di intervenire e risolvere i problemi.

Debug delle prestazioni sul campo spiega come inviare ulteriori informazioni di debug con i dati di analisi. Se segui le istruzioni dettagliate nel post, dovresti vedere che le informazioni di debug vengono visualizzate anche in BigQuery.

Le seguenti query mostrano come utilizzare il parametro evento debug_target per identificare la causa principale dei problemi di prestazioni.

Esempi di query

Elementi principali che contribuiscono alla metrica CLS

debug_target è una stringa del selettore CSS che corrisponde all'elemento della pagina più pertinente al valore della metrica.

Con CLS, debug_target rappresenta l'elemento più grande della più grande variazione del layout che ha contribuito al valore CLS. Se nessun elemento viene spostato, il valore di debug_target sarà null.

La seguente query elencherà le pagine dal peggiore al migliore in base al CLS al 75° percentile, raggruppate per 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

Sapere quali elementi della pagina stanno cambiando dovrebbe facilitare l'identificazione e la risoluzione della causa principale del problema.

Tieni presente che gli elementi segnalati qui potrebbero non essere gli stessi che cambiano quando esegui il debug delle tue pagine localmente, motivo per cui è così importante acquisire questi dati prima di tutto. È molto difficile sistemare cose di cui non si rendono conto che sono problemi.

Esegui il debug di altre metriche

La query precedente mostra i risultati per la metrica CLS, ma è possibile utilizzare la stessa tecnica per generare report sui target di debug per LCP e FID. Sostituisci la clausola "WHERE" con la metrica pertinente per eseguire il debug:

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

Puoi consultare l'articolo Prestazioni del debug sul campo per istruzioni su come raccogliere e inviare informazioni di debug per ciascuna metrica di Segnali web essenziali.

Visualizzazione

Può essere difficile ottenere insight semplicemente guardando i risultati delle query. Ad esempio, la seguente query elenca i valori giornalieri del 75° percentile per LCP nel set di dati.

# 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

Dai risultati di queste query è difficile identificare tendenze o valori anomali semplicemente esaminando i dati.

In questi casi, visualizzare i dati può aiutarti a ricavare insight più rapidamente.

Visualizzare i risultati delle query in Looker Studio

BigQuery offre un modo rapido per visualizzare i risultati di qualsiasi query tramite Data Studio. Looker Studio è uno strumento senza costi per la visualizzazione dei dati e la creazione di dashboard. Per visualizzare i risultati della query, dopo averla eseguita nell'interfaccia utente di BigQuery, fai clic sul pulsante Esplora dati e seleziona Esplora con Looker Studio.

Verrà creato un collegamento diretto da BigQuery a Looker Studio nella visualizzazione di esplorazione. In questa visualizzazione puoi selezionare i campi da visualizzare, scegliere i tipi di grafici, configurare i filtri e creare grafici ad hoc per una rapida analisi visiva. Dai risultati della query precedenti, puoi creare questo grafico a linee per visualizzare la tendenza dei valori LCP nel tempo:

Grazie a questo collegamento diretto tra BigQuery e Looker Studio, puoi creare grafici veloci da qualsiasi query ed eseguire analisi visive. Tuttavia, se vuoi eseguire analisi aggiuntive, ti consigliamo di esaminare diversi grafici di una dashboard interattiva per ottenere una visione più olistica o per poter visualizzare in dettaglio i dati. Grazie a una pratica dashboard, non dovrai scrivere query e generare grafici manualmente ogni volta che vuoi analizzare le metriche.

Puoi creare una dashboard in Looker Studio utilizzando il connettore BigQuery nativo. Per farlo, accedi a datastudio.google.com, crea una nuova origine dati, seleziona il connettore BigQuery e scegli il set di dati con cui vuoi lavorare:

Materializza i dati di Web Vitals

Durante la creazione di dashboard dei dati sugli eventi di Web Vitals come descritto sopra, non è efficiente utilizzare direttamente il set di dati di esportazione di Google Analytics 4. A causa della struttura dei dati GA4 e della pre-elaborazione richiesta per le metriche di Segnali web, alcune parti della query verranno eseguite più volte. Questo crea due problemi: le prestazioni della dashboard e i costi di BigQuery.

Puoi utilizzare senza costi la modalità sandbox di BigQuery. Con il livello di utilizzo senza costi di BigQuery, il primo TB di dati di query elaborati al mese è senza costi. Per i metodi di analisi trattati in questo post, dovresti riuscire a rispettare questo limite senza costi ogni mese, a meno che tu non stia utilizzando un set di dati molto grande o esegua regolarmente query sul set di dati. Tuttavia, se hai un sito web con molto traffico e vuoi monitorare regolarmente diverse metriche utilizzando una dashboard rapida interattiva, ti consigliamo di pre-elaborare e materializzare i dati Web Vitals, utilizzando al contempo funzionalità per l'efficienza di BigQuery come partizionamento, clustering e memorizzazione nella cache.

Lo script seguente pre-elabora i dati BigQuery (tabella di origine) e crea una tabella materializzata (tabella di destinazione). Quando utilizzi questa query per il tuo set di dati, potresti anche definire un intervallo di date per la tabella di origine al fine di ridurre la quantità di dati elaborati.

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

Questo set di dati materializzato presenta diversi vantaggi:

• La struttura dei dati è smussata e facilita l'esecuzione di query.
• Mantiene solo gli eventi Web Vitals del set di dati GA4 originale.
• Le informazioni relative a ID sessione, tipo di utente (nuovo/di ritorno) e coinvolgimento della sessione sono direttamente disponibili nelle colonne.
• La tabella è partitioned per data e raggruppata per nome della metrica. In questo modo si riduce la quantità di dati elaborati per ogni query.
• Poiché non è necessario utilizzare caratteri jolly per eseguire query su questa tabella, i risultati delle query possono essere memorizzati nella cache per un massimo di 24 ore. In questo modo si riducono i costi per la ripetizione della stessa query.
• Se utilizzi il motore BI di BigQuery, puoi eseguire funzioni e operatori SQL ottimizzati in questa tabella.

Puoi eseguire query direttamente su questa tabella materializzata dall'interfaccia utente di BigQuery o utilizzarla in Looker Studio tramite il connettore BigQuery.

Utilizzare il connettore Web Vitals

Poiché creare una dashboard da zero richiede molto tempo, abbiamo sviluppato una soluzione in pacchetto che crea un modello di dashboard per te. Innanzitutto, assicurati di aver materializzato la tabella Web Vitals utilizzando la query precedente. Quindi, accedi al connettore Web Vitals per Looker Studio utilizzando questo link: goo.gle/web-vitals-connector

Dopo aver fornito un'autorizzazione una tantum, dovresti visualizzare la seguente schermata di configurazione:

Fornisci l'ID tabella BigQuery materializzata (ovvero la tabella di destinazione) e l'ID progetto di fatturazione BigQuery. Dopo aver fatto clic su Connetti, Looker Studio crea una nuova dashboard basata su modelli a cui associa i tuoi dati. Puoi modificare e condividere la dashboard a tuo piacimento. Se crei una dashboard una sola volta, non devi visitare di nuovo il link del connettore, a meno che tu non voglia creare più dashboard da set di dati diversi.

Navigare nella dashboard

Mentre esplori la dashboard, puoi visualizzare le tendenze giornaliere delle metriche Web Vitals e alcune informazioni sull'utilizzo per il tuo sito web, come utenti e sessioni, nella scheda Riepilogo.

Nella scheda Analisi degli utenti, puoi selezionare una metrica e ottenere una suddivisione del percentile delle metriche e del conteggio degli utenti in base a metriche di utilizzo e aziendali diverse.

La scheda Analisi del percorso delle pagine ti consente di identificare le aree problematiche del tuo sito web. Qui puoi scegliere una metrica per visualizzarne la panoramica. Ma vedi anche la mappa a dispersione di tutti i percorsi pagina con il valore percentile sull'asse y e il numero di record sull'asse x. La mappa a dispersione può aiutarti a identificare le pagine che hanno valori delle metriche inferiori rispetto alle aspettative. Dopo aver selezionato le pagine utilizzando il grafico a dispersione della tabella Percorso pagina, puoi visualizzare in dettaglio l'area del problema visualizzando la tabella Destinazione di debug.

La scheda Analisi delle entrate è un esempio di come puoi monitorare le metriche relative alla tua attività e al tuo rendimento da un unico posto. Questa sezione indica tutte le sessioni in cui l'utente ha effettuato un acquisto. Puoi confrontare le entrate con quelle dell'esperienza utente durante una sessione specifica .

Utilizzo avanzato

Man mano che acquisisci familiarità con il set di dati, puoi modificare la dashboard e aggiungere grafici per un'analisi più completa e mirata. Per rendere la dashboard più utile, procedi nel seguente modo:

• Configura una query pianificata in BigQuery per ottenere dati aggiornati. La query di materializzazione che abbiamo eseguito sopra acquisisce solo uno snapshot dei tuoi dati in quel momento. Se vuoi mantenere la dashboard aggiornata con i nuovi dati, puoi eseguire una query pianificata che verrà eseguita ogni giorno e aggiungere la tabella materializzata con i nuovi dati.
• Unisci dati proprietari (ad es. CRM) per approfondimenti aziendali. Nella tabella materializzata, puoi aggiungere user_id come colonna separata. In questo modo potrai unire i tuoi dati proprietari. Se i tuoi dati proprietari non sono già in BigQuery, puoi caricarli o utilizzare un'origine dati federata.
• Segnala il tuo sito o la versione dell'app come parametro nei dati inviati a Google Analytics e aggiungilo come colonna nella tabella materializzata. Poi puoi aggiungere i dati della versione come dimensione nei grafici per vedere più facilmente le modifiche della versione che influiscono sulle prestazioni.
• Se prevedi un utilizzo significativo del set di dati tramite query dirette o la dashboard, puoi provare a utilizzare la versione a pagamento di BigQuery BI Engine.

Riepilogo

In questo post sono descritte le nozioni di base sull'utilizzo di Google Analytics 4 e BigQuery per misurare ed eseguire il debug delle prestazioni con i dati sugli utenti reali raccolti sul campo. Ha anche spiegato come creare dashboard e report automatizzati utilizzando Looker Studio e Web Vitals Connector per semplificare il più possibile la visualizzazione dei dati.

Alcuni concetti chiave di questo post:

• La misurazione del rendimento in base ai dati utente reali è fondamentale per comprendere, eseguire il debug e ottimizzare il sito.
• Puoi ottenere informazioni più dettagliate quando le metriche sul rendimento e le metriche aziendali si trovano nello stesso sistema. Google Analytics e BigQuery rendono questo possibile.
• L'esportazione in BigQuery dei dati non elaborati di Google Analytics offre un potenziale illimitato per un'analisi personalizzata e approfondita utilizzando un linguaggio di query che probabilmente già conosci.
• Google dispone di una serie di API e strumenti di visualizzazione, come Looker Studio, che ti offrono la libertà di creare i report esattamente nel modo in cui vuoi che vengano creati.