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

Scopri come inviare i dati di Segnali web 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 Chrome User Experience Report (CrUX), che consentono agli sviluppatori di verificare le prestazioni dei loro siti rispetto alle metriche Segnali web essenziali per gli utenti reali sul campo.

Questi strumenti sono straordinari perché offrono una visione d'insieme delle prestazioni reali degli utenti del tuo sito e, per iniziare a utilizzarli, non richiedono alcuna configurazione.

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

• Gli strumenti basati su CrUX registrano i dati per periodi mensili o di 28 giorni 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 del dispositivo (computer o dispositivo mobile). Non puoi suddividere i dati in base a dimensioni specifiche della tua attività, ad esempio utenti coinvolti, utenti in un determinato gruppo sperimentale e così via.
• Gli strumenti basati su CrUX sono in grado di indicare le tue prestazioni, ma non possono dirti perché. Con gli strumenti di analisi puoi inviare dati aggiuntivi per tenere traccia dei problemi ed eseguirne il debug.

Per questi motivi, consigliamo a tutti i proprietari di siti di monitorare le metriche di Segnali web essenziali utilizzando il proprio strumento di analisi esistente. In questo post puoi usare gli strumenti senza costi offerti da Google per farlo.

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

Per una panoramica visiva di tutti i passaggi descritti qui, dai un'occhiata alla nostra presentazione di Google I/O '21:

Misura

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

• Parametri evento personalizzati senza configurazione
• Esportazione in BigQuery senza costi, per eseguire query sui dati tramite 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 sugli eventi non elaborati 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 BigQuery Export nella configurazione della proprietà Google Analytics in modo che tutti i dati che ricevi vengano completati automaticamente nelle tabelle di progetto BigQuery.
3. Aggiungi la libreria JavaScript dei vitali web al tuo sito, in modo da poter misurare le metriche di Segnali web essenziali e inviare i dati a Google Analytics 4.

Analisi

Al termine della configurazione, i dati sugli eventi dovrebbero comparire nell'interfaccia 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:

Esegui query sui dati di Web Vitals

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

La cosa più importante da capire è che, in alcuni casi, è possibile ricevere più eventi per la stessa metrica 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 di Segnali web, 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 dei Servizi 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.

Nelle sezioni successive vengono mostrati alcuni esempi di query di Segnali web 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 di 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 (pag. 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

Debug

Le query precedenti mostrano come eseguire query sui dati della metrica Segnali web, utili per comprendere le prestazioni attuali e le relative tendenze nel tempo. Ma cosa puoi fare se il rendimento è peggiore del previsto, ma non sai perché?

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

La sezione 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 al CLS

debug_target è una stringa del selettore CSS che corrisponde all'elemento della pagina più pertinente per il 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 vengono spostati dovrebbe facilitare l'identificazione e la risoluzione della causa principale del problema.

Tieni presente che gli elementi riportati qui potrebbero non essere gli stessi che cambiano durante il debug locale delle pagine, motivo per cui è così importante acquisire innanzitutto questi dati. È molto difficile risolvere problemi che 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. Per eseguire il debug, sostituisci la clausola WHERE con la metrica pertinente:

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

Anche in questo caso, puoi consultare Prestazioni del debug sul campo per istruzioni su come raccogliere e inviare informazioni di debug per ciascuna delle metriche di Segnali web essenziali.

Visualizza

Può essere difficile ottenere insight semplicemente guardando solo 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 osservando 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 i dati e seleziona Esplora con Looker Studio.

Verrà creato un collegamento diretto da BigQuery a Looker Studio nella vista Esplorazione. In questa visualizzazione, puoi selezionare i campi da visualizzare, scegliere i tipi di grafici, impostare 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 rapidi da qualsiasi query ed eseguire analisi visive. Tuttavia, se vuoi eseguire analisi aggiuntive, ti consigliamo di esaminare diversi grafici in una dashboard interattiva per ottenere una visione più olistica o per visualizzare i dati in dettaglio. 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 lavorare:

Materializza i dati di Web Vitals

Quando crei dashboard dei dati sugli eventi di Segnali web 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 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 descritti 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 eseguendo regolarmente query sul set di dati. Tuttavia, se hai un sito web con traffico elevato e vuoi monitorare regolarmente diverse metriche utilizzando una dashboard interattiva veloce, ti consigliamo di pre-elaborare e materializzare i dati Web vitals utilizzando al contempo le funzionalità per l'efficienza di BigQuery come il partizionamento, il clustering e la 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 voler 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 è suddivisa e consente di eseguire query più facilmente.
• Conserva solo gli eventi Web Vitals del set di dati GA4 originale.
• Le informazioni relative a ID sessione, tipo di utente (nuovi e di ritorno) e coinvolgimento delle sessioni sono direttamente disponibili nelle colonne.
• La tabella è partitioned per data e raggruppata per nome della metrica. In genere, ciò riduce la quantità di dati elaborati per ogni query.
• Poiché non è necessario utilizzare caratteri jolly per eseguire query su questa tabella, i risultati possono essere memorizzati nella cache per un massimo di 24 ore. In questo modo vengono ridotti i costi derivanti dalla ripetizione della stessa query.
• Se utilizzi il motore BI di BigQuery, puoi eseguire operatori e funzioni SQL ottimizzati in questa tabella.

Puoi eseguire query direttamente su questa tabella materializzata dall'interfaccia utente di BigQuery o utilizzarla in Looker Studio con 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 Segnali web utilizzando la query in alto. 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 materializzato (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 come preferisci. Se crei una dashboard una sola volta, non dovrai 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, nella scheda Riepilogo puoi vedere le tendenze giornaliere delle metriche di Web Vitals e alcune informazioni sull'utilizzo del tuo sito web, come utenti e sessioni.

Nella scheda Analisi utente, puoi selezionare una metrica per poi 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 della pagina ti consente di identificare le aree problematiche del tuo sito web. Qui puoi scegliere una metrica per visualizzare la panoramica. Tuttavia, viene visualizzata 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ò aiutare a identificare le pagine con valori della metrica inferiori al previsto. Dopo aver selezionato le pagine tramite il grafico a dispersione della tabella Percorso pagina, puoi visualizzare in dettaglio l'area del problema visualizzando la tabella Target di debug.

La scheda Analisi delle entrate è un esempio di come puoi monitorare le metriche sull'attività e sul rendimento da un unico posto. Questa sezione mostra tutte le sessioni in cui l'utente ha effettuato un acquisto. Puoi confrontare le entrate ottenute con l'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 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 in precedenza crea solo uno snapshot dei tuoi dati in quel momento. Se vuoi mantenere aggiornata la tua dashboard 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 sull'attività. 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 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 sulla versione come dimensione nei grafici per vedere più facilmente che le modifiche della versione influiscono sulle prestazioni.
• Se prevedi un utilizzo intensivo del set di dati tramite una query diretta o la dashboard, puoi provare a utilizzare la versione a pagamento di BigQuery BI Engine.

Riepilogo

Questo post illustra le nozioni di base sull'utilizzo di Google Analytics 4 e BigQuery per misurare ed eseguire il debug del rendimento con i dati di utenti reali raccolti sul campo. Inoltre, ha spiegato come creare report e dashboard automatizzati utilizzando Looker Studio e Web Vitals Connector per semplificare il più possibile la visualizzazione dei dati.

Alcuni concetti chiave tratti da 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 quelle della tua attività si trovano nello stesso sistema. Google Analytics e BigQuery lo rendono possibile.
• L'esportazione BigQuery dei dati non elaborati di Google Analytics offre un potenziale illimitato per un'analisi approfondita e personalizzata 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.