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

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

Minhaz Kazi

Philip Walton

Google fornisce una serie di strumenti, tra cui Search Console, PageSpeed Insights (PSI) e il Report sull'esperienza utente di Chrome (CrUX), che consentono agli sviluppatori di valutare il rendimento dei propri siti in base alle metriche di Segnali web essenziali per i loro utenti reali sul campo.

Questi strumenti sono fantastici perché ti forniscono una visione di alto livello del rendimento del tuo sito per gli utenti reali e non richiedono alcuna configurazione per iniziare a utilizzarli.

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

• Gli strumenti basati su CrUX registrano dati in base a periodi mensili o precedenti di 28 giorni. Ciò significa che dovrai attendere molto tempo dopo aver apportato eventuali modifiche prima di poter vedere 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 di 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 possono dirti che cosa è il tuo rendimento, ma non possono dirti perché. Con gli strumenti di analisi puoi inviare dati aggiuntivi per monitorare ed eseguire il debug dei problemi.

Per questi motivi, consigliamo a tutti i proprietari di siti di monitorare le metriche di Core Web Vitals utilizzando lo strumento di analisi esistente. Questo post spiega come utilizzare gli strumenti gratuiti offerti da Google per farlo.

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

La misurazione del rendimento è sempre stata possibile con Google Analytics utilizzando le metriche personalizzate, ma Google Analytics 4 (GA4) offre alcune nuove funzionalità di cui gli sviluppatori dovrebbero entusiasmare in particolare.

• Parametri evento personalizzati a configurazione zero
• BigQuery Export gratuito, perché tu possa eseguire query sui dati utilizzando SQL

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

Per iniziare a misurare Core Web Vitals utilizzando Google Analytics 4 e BigQuery, devi fare tre cose:

1. Crea una proprietà Google Analytics 4 e un progetto BigQuery.
2. Abilita l'esportazione in BigQuery nella configurazione delle proprietà di Google Analytics, in modo che tutti i dati che ricevi vengano compilati automaticamente nelle tabelle del progetto BigQuery.
3. Aggiungi la libreria JavaScript web-vitals al tuo sito per misurare le metriche Core Web Vitals e inviare i dati a Google Analytics 4, inclusi i dati di attribuzione.

Analizza

Al termine della configurazione, dovresti vedere i dati sugli eventi nell'interfaccia di BigQuery e dovresti essere in grado di eseguire query sui dati come segue:

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

Ecco un'anteprima dei risultati della query:

Esegui query sui dati di Web Vitals

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

La cosa più importante da capire è che, in alcuni casi, potrebbero essere ricevuti più eventi per la stessa metrica, nella stessa pagina. Questo può accadere se il valore della metrica cambia e viene registrato un valore aggiornato (un evento comune con CLS).

Per gli eventi Web Vitals, l'ultimo valore inviato è sempre il più accurato, quindi prima di eseguire qualsiasi analisi, è importante filtrare solo per quei valori. Lo snippet di codice fornito dalla libreria JavaScript web-vitals per inviare dati a Google Analytics 4 include l'invio di un ID univoco per metrica, pertanto 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', '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
)

Tieni presente che tutte le altre query a cui si fa riferimento in questo post inizieranno con questa subquery.

Esempi di query

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

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

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

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

Le 10 pagine principali con il peggior 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

Debug

Le query precedenti mostrano come eseguire query sui dati delle metriche Web Vitals, utili per comprendere il rendimento attuale e la sua tendenza nel tempo. Ma cosa puoi fare se il rendimento è peggiore del previsto, ma non sai perché?

Sapere cosa sono i tuoi punteggi non è utile se non riesci a intervenire e risolvere i problemi.

L'articolo Eseguire il debug del rendimento sul campo spiega come inviare ulteriori informazioni di debug con i dati di analisi. Se segui le istruzioni dettagliate riportate nel post, dovresti visualizzare le informazioni di debug anche in BigQuery.

Esempi di query

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

Elementi principali che contribuiscono al CLS

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

Con il CLS, debug_target rappresenta l'elemento più grande della variazione del layout più grande che ha contribuito al valore CLS. Se non sono stati spostati elementi, il valore di debug_target sarà null.

La seguente query elenca le pagine dal peggiore al migliore in base al CLS al 75esimo 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', '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

Sapere quali elementi della pagina si spostano dovrebbe semplificare molto la procedura per identificare e risolvere la causa principale del problema.

Tieni presente che gli elementi riportati qui potrebbero non essere gli stessi che vedi cambiare quando esegui il debug delle pagine localmente, motivo per cui è così importante acquisire questi dati. È molto difficile risolvere i problemi se non ti rendi conto che sono problemi.

Eseguire il debug di altre metriche

La query precedente mostra i risultati per la metrica CLS, ma la stessa tecnica può essere utilizzata per generare report sui target di debug per LCP e INP. Basta sostituire la clausola where con la metrica pertinente da eseguire il debug:

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

Anche in questo caso, puoi consultare la sezione Eseguire il debug del rendimento sul campo per istruzioni su come raccogliere e inviare informazioni di debug per ciascuna delle metriche di Core Web Vitals.

Visualizza

Può essere difficile ottenere informazioni solo esaminando i risultati della 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', '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

Dai risultati delle query è difficile identificare tendenze o outlier semplicemente esaminando i dati.

In questi casi, la visualizzazione dei dati può aiutarti a ricavare informazioni più rapidamente.

Visualizzare i risultati della query in Looker Studio

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

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

Con questo collegamento diretto tra BigQuery e Looker Studio, puoi creare grafici rapidi da qualsiasi query ed eseguire analisi visive. Tuttavia, se vuoi eseguire ulteriori analisi, ti consigliamo di esaminare diversi grafici in una dashboard interattiva per ottenere una visione più olistica o per poter visualizzare in dettaglio i dati. Avere una dashboard a portata di mano significa che non devi scrivere query e generare grafici manualmente ogni volta che vuoi analizzare le tue metriche.

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

Materializzare i dati di Web Vitals

Quando crei dashboard dei dati sugli eventi Web Vitals come descritto in precedenza, non è efficiente utilizzare direttamente il set di dati di esportazione di Google Analytics 4. A causa della struttura dei dati GA4 e della preelaborazione richiesta per le metriche Web Vitals, alcune parti della query verranno eseguite più volte. Ciò crea due problemi: prestazioni della dashboard e costi di BigQuery.

Puoi utilizzare la modalità sandbox di BigQuery senza costi. 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 discussi in questo post, a meno che tu non stia utilizzando un set di dati di dimensioni significative o non esegua regolarmente query complesse sul set di dati, dovresti riuscire a rispettare questo limite gratuito ogni mese. Tuttavia, se hai un sito web con traffico elevato e vuoi monitorare regolarmente metriche diverse utilizzando una dashboard interattiva rapida, ti consigliamo di eseguire la preelaborazione e la materializzazione dei dati di indicatori web, utilizzando al contempo le funzionalità di efficienza di BigQuery come il partizionamento, il clustering e la memorizzazione nella cache.

Lo script seguente eseguirà la preelaborazione dei dati BigQuery (tabella di origine) e creerà una tabella materializzata (tabella di destinazione). Quando utilizzi questa query per il tuo set di dati, ti consigliamo di definire anche un intervallo di date per la tabella di origine per 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', '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');

Questo set di dati materializzato ha diversi vantaggi:

• La struttura dei dati è bidimensionale ed è più facile eseguire query.
• Conserva solo gli eventi Web Vitals del set di dati GA4 originale.
• L'ID sessione, il tipo di utente (nuovo o di ritorno) e le informazioni sul coinvolgimento in sessione sono disponibili direttamente nelle colonne.
• La tabella è partizionata per data e clustering in cluster per nome della metrica. In questo modo, la quantità di dati elaborati per ogni query viene ridotta.
• 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 derivanti dalla ripetizione della stessa query.
• Se utilizzi BigQuery BI Engine, puoi eseguire funzioni e operatori SQL ottimizzati su questa tabella.

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

Utilizzare il connettore Web Vitals

Poiché la creazione di una dashboard da zero richiede tempo, abbiamo sviluppato una soluzione in pacchetto che crea una dashboard modello per te. Innanzitutto, assicurati di aver materializzato la tabella Web Vitals utilizzando la query precedente. Poi 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 (ad es. la tabella di destinazione) e l'ID del progetto di fatturazione BigQuery. Dopo aver fatto clic su Connetti, Looker Studio creerà una nuova dashboard basata su modelli e vi assocerà i dati. Puoi modificare, modificare e condividere la dashboard come preferisci. Se crei una dashboard una 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 navighi nella dashboard, puoi visualizzare le tendenze giornaliere delle metriche Web Vitals e alcune informazioni sull'utilizzo del tuo sito web, come utenti e sessioni, nella scheda Riepilogo.

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

La scheda Analisi dei percorsi pagina ti aiuterà a identificare le aree problematiche sul tuo sito web. Qui puoi scegliere una metrica per visualizzare la panoramica. Viene visualizzata anche la mappa di dispersione di tutti i percorsi pagina con il valore percentile sull'asse Y e il conteggio dei record sull'asse X. La mappa di dispersione può aiutarti a identificare le pagine con valori delle metriche inferiori alle aspettative. Dopo aver selezionato le pagine utilizzando il grafico a dispersione della tabella Percorso pagina, puoi esaminare ulteriormente l'area del problema visualizzando la tabella Target di debug.

La scheda Analisi delle entrate è un esempio di come puoi monitorare la tua attività e le metriche sul rendimento in un unico posto. Questa sezione mostra tutte le sessioni in cui l'utente ha effettuato un acquisto. Puoi confrontare le entrate generate rispetto all'esperienza utente durante una sessione specifica.

Utilizzo avanzato

Man mano che acquisisci familiarità con il set di dati, puoi modificare la dashboard e aggiungere i tuoi grafici per analisi più complete e mirate. Per rendere la dashboard più utile, puoi procedere nel seguente modo:

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

Riepilogo

Questo post illustra le nozioni di base su come utilizzare Google Analytics 4 e BigQuery per misurare ed eseguire il debug del rendimento con dati di utenti reali raccolti sul campo. È stato inoltre spiegato come creare report e dashboard automatici utilizzando Looker Studio e il connettore Web Vitals per semplificare al massimo la visualizzazione dei dati.

Ecco alcuni concetti chiave di questo post:

• La misurazione del rendimento con dati utente reali è fondamentale per comprendere, eseguire il debug e ottimizzare il tuo sito.
• Puoi ottenere approfondimenti più approfonditi quando le metriche sul rendimento e quelle aziendali si trovano nello stesso sistema. Google Analytics e BigQuery lo rendono possibile.
• L'esportazione BigQuery dei dati non elaborati di Google Analytics ti offre un potenziale illimitato per un'analisi personalizzata e approfondita utilizzando un linguaggio di query che probabilmente già conosci.
• Google offre una serie di API e strumenti di visualizzazione, come Looker Studio, che ti consentono di creare i report esattamente come vuoi.