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 diversi strumenti: la Ricerca console, PageSpeed Insights (PSI) e l'esperienza utente di Chrome Segnala (CrUX), che consente agli sviluppatori di vedere le prestazioni dei loro siti rispetto al Web Core Vitals per i loro utenti reali nel campo.
Questi strumenti sono ottimi in quanto ti offrono una visione d'insieme dell'aspetto del tuo sito prestazioni degli utenti reali e non richiedono alcuna configurazione per iniziare a utilizzarli.
Tuttavia, esistono alcuni motivi fondamentali per cui non conviene utilizzare questi strumenti per misurare il rendimento del 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 vedere i risultati.
- Gli strumenti basati su CrUX possono essere segmentati solo in base a un numero limitato di dimensioni, ad esempio il paese, il tipo di connessione e la categoria del dispositivo (computer o dispositivo mobile). Non puoi suddividere i dati in base a dimensioni specifiche per la tua attività (ad es. "engaged" utenti, utenti di un determinato gruppo sperimentale e così via).
- Gli strumenti basati su CrUX sono in grado di dirti quali sono le tue prestazioni, ma non sono in grado di dirti scopri perché. Con gli strumenti di analisi puoi inviare dati aggiuntivi per monitorare eseguire il debug e il debug.
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 le applicazioni strumenti offerti da Google per questo scopo.
Una volta completata la configurazione, potrai creare dashboard come le seguenti:
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 metriche personalizzate, ma sono alcune delle nuove funzionalità di Google Analytics 4 (GA4) che gli sviluppatori di cui entusiasmarsi.
- Zero-config, personalizzato evento parametri
- Esportazione senza costi in BigQuery, puoi eseguire query sui tuoi dati utilizzando il linguaggio SQL
Sebbene l'interfaccia web di Google Analytics disponga di potenti strumenti di analisi, è difficile battere la potenza e la flessibilità dell'accesso non elaborato ai dati degli eventi utilizzando una query lingua che probabilmente conosci già.
Per iniziare a misurare Core Web Vitals utilizzando Google Analytics 4 e BigQuery: devi fare tre cose:
- Creare un account Google Analytics 4 personalizzata e una Progetto BigQuery.
- Attiva BigQuery Export nella configurazione delle proprietà Google Analytics, in modo che tutti i dati che vengono compilate automaticamente nelle tabelle del progetto BigQuery.
- Aggiungi il codice JavaScript web-vitals nel tuo sito, in modo da poter misurare le metriche di Core Web Vitals e inviare i dati a Google Analytics 4, inclusi i dati di attribuzione.
Analizza
Al termine della configurazione, i dati sugli eventi verranno visualizzati in BigQuery ed eseguire query sui dati nel seguente modo:
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 di Web Vitals, è importante capire come vengono aggregati i dati.
La cosa più importante da capire è che, in alcuni casi, più eventi può essere ricevute per la stessa metrica, nella stessa pagina. Ciò può accadere se il valore della metrica modifiche e viene registrato un valore aggiornato (si verifica spesso con la metrica CLS).
Per gli eventi Web Vitals, l'ultimo valore inviato è sempre il più accurato, quindi prima di eseguire qualsiasi analisi, è importante filtrare solo in base a quei valori. Lo snippet di codice fornito dalla libreria JavaScript delle funzionalità web per inviare i dati a Google Analytics 4 include l'invio di un ID univoco per metrica, in modo che tu possa utilizzare 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 viene fatto riferimento in questo post inizieranno con questo una sottoquery.
Esempi di query
Le prossime sezioni mostrano alcuni esempi di query Web Vitals che potresti che vuoi eseguire.
LCP, INP e CLS al 75° percentile (p75) in tutto il 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
Prime 10 pagine con la 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', '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, il che è utile per comprendere il tuo rendimento attuale e le relative tendenze nel tempo. Ma che cosa puoi fare se il rendimento è inferiore al previsto, ma non sei sicuro perché?
Sapere quali sono i tuoi punteggi non è utile se non sei in grado di agire e risolvere i problemi.
La sezione Prestazioni di debug sul campo spiega come puoi inviare ulteriori informazioni di debug con i tuoi dati di analisi. Se segui le istruzioni dettagliate nel post, dovresti vedere che il debug vengono visualizzate anche in BigQuery.
Esempi di query
Le seguenti query mostrano come utilizzare il parametro evento debug_target per aiutarti
identificare la causa principale
dei problemi di prestazioni.
Elementi principali che contribuiscono alla metrica CLS
debug_target è una stringa del selettore CSS che corrisponde all'elemento su
la 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 è stato spostato,
Il valore di debug_target sarà null.
La seguente query elencherà le pagine dalla peggiore alla migliore in base alla relativa CLS al 75°
percentile, raggruppato 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 stanno cambiando dovrebbe rendere molto più facile a identificare e risolvere la causa principale del problema.
Tieni presente che gli elementi qui riportati potrebbero non essere gli stessi che che cambia quando esegui il debug delle pagine localmente. Ecco perché per acquisire questi dati. È molto difficile sistemare le cose che non riconosci sono problemi.
Esegui il debug di altre metriche
La query precedente mostra i risultati per la metrica CLS, ma gli stessi risultati per generare report sui target di debug per LCP e INP. Soltanto sostituisci la clausola WHERE con la metrica pertinente di cui eseguire il debug:
WHERE metric_name = 'INP'
WHERE metric_name = 'LCP'
Anche in questo caso, puoi fare riferimento a Rendimento del debug nel campo per istruzioni su come raccogliere e inviare informazioni di debug per ciascuna delle metriche di Core Web Vitals.
Visualizza
Può essere difficile ottenere insight semplicemente guardando i risultati delle query da soli. 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, visualizzare i dati può aiutarti a ricavare insight più rapidamente.
Visualizzare i risultati della query in Looker Studio
BigQuery offre un modo rapido per visualizzare qualsiasi risultato delle query Studio. Looker Studio è una visualizzazione di dati e dashboarding senza costi. Per visualizzare i risultati della query, dopo aver eseguito la query nell'interfaccia utente di BigQuery, fai clic sul pulsante Esplora dati e Seleziona Esplora con Looker Studio.
Nell'esplorazione verrà creato un link diretto da BigQuery a Looker Studio vista. In questa visualizzazione puoi selezionare i campi da visualizzare, scegliere tipi di grafici, impostare filtri e creare grafici ad hoc per un'analisi visiva rapida. Dai risultati della query precedente, puoi creare questo grafico a linee per vedere la tendenza delle Valori LCP nel tempo:
Grazie al collegamento diretto tra BigQuery e Looker Studio, puoi creare rapidi di qualsiasi query ed eseguire analisi visive. Tuttavia, se vuoi per ulteriori analisi, può essere utile esaminare diversi grafici dashboard interattiva per avere una visione più olistica o visualizzare in dettaglio all'interno dei dati. La disponibilità di una dashboard pratica ti consente di non dover scrivere query e generare i grafici manualmente ogni volta che vuoi analizzare le metriche.
Puoi creare una dashboard in Looker Studio utilizzando lo strumento native di rete. Per farlo, vai a datastudio.google.com, crea una nuova origine dati, seleziona il connettore BigQuery e scegli il set di dati da lavora con:
Materializza i dati di Web Vitals
Quando crei dashboard dei dati sugli eventi Web Vitals come descritto in precedenza, non hanno la capacità di usare direttamente il set di dati di esportazione di Google Analytics 4. A causa delle la struttura dei dati GA4 e la pre-elaborazione richiesta per Web Vitals specifiche, parti della query verranno eseguite più volte. Questo crea due problemi: le prestazioni della dashboard e i costi di BigQuery.
Puoi utilizzare la sandbox di BigQuery senza costi aggiuntivi. Con BigQuery livello di utilizzo senza costi, il primo TB di dati di query elaborati al mese è senza costi. Per i metodi di analisi discussi in questo post, a meno che non utilizzi un set di dati molto grande interrogano in modo intensivo il set di dati con regolarità, dovresti essere in grado di rimanere questo limite senza costi ogni mese. Ma se hai un sito web a traffico elevato e vuoi monitorare regolarmente metriche diverse usando una dashboard veloce e interattiva, suggerire di pre-elaborare e materializzare i dati Web Vitals durante l'utilizzo 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 creare una tabella materializzata (tabella di destinazione). Quando utilizzi questa query per conto tuo set di dati, puoi anche definire 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.
- ID sessione, tipo di utente (nuovi e ricorrenti) e informazioni sul coinvolgimento della sessione è disponibile direttamente nelle colonne.
- La tabella è partizionato per data e in cluster per nome della metrica. Questo di solito 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 possono essere memorizzate nella cache per un massimo di 24 ore. In questo modo si riducono i costi associati alla ripetizione dello stesso query.
- Se utilizzi BigQuery BI Engine, puoi eseguire funzioni SQL ottimizzate e operatori su questo tabella.
Puoi eseguire query su questa tabella materializzata direttamente dall'interfaccia utente di BigQuery o utilizzarla in Looker Studio con il connettore BigQuery.
Utilizza Web Vitals Connector
Poiché creare una dashboard da zero richiede molto tempo, abbiamo sviluppato un pacchetto che creerà una dashboard basata su modelli. Innanzitutto, assicurati di hanno materializzato la tabella Web Vitals utilizzando la query precedente. Poi accedi a Connettore Web Vitals per Looker Studio tramite questo link: goo.gle/web-vitals-connector
Dopo aver fornito un'autorizzazione una tantum, dovresti vedere quanto segue schermata di configurazione:
Fornisci l'ID tabella BigQuery materializzata (ad es. la tabella di destinazione) e ID progetto di fatturazione BigQuery. Dopo aver fatto clic su Connetti, Looker Studio crea un nuova dashboard basata su modelli e associarvi i tuoi dati. Puoi modificare, modificare e condividi la dashboard come preferisci. Se crei una dashboard una volta, visitare nuovamente il link del connettore, a meno che non si desideri creare di dashboard da set di dati diversi.
Navigare nella dashboard
Navigando nella dashboard, puoi vedere le tendenze giornaliere dei Web Vitals metriche e alcune informazioni sull'utilizzo del tuo sito web, come utenti e sessioni, la scheda Riepilogo.
Nella scheda Analisi utente puoi selezionare una metrica e ottenere un'analisi dettagliata il percentile delle metriche e il conteggio degli utenti per diversi utilizzi e attività metriche di valutazione.
La scheda Analisi del percorso di pagina ti consente di identificare le aree problematiche sul sito web. Qui puoi scegliere una metrica per visualizzare la panoramica. ma vedi anche mappa a dispersione di tutti i percorsi pagina con il valore percentile sull'asse y e registra conta sull'asse x. La mappa a dispersione può aiutarti a identificare le pagine con rispetto a quelli previsti. Dopo aver selezionato le pagine utilizzando la della tabella Percorso pagina, puoi visualizzare in dettaglio l'area del problema visualizzazione della tabella Target di debug.
La scheda Analisi delle entrate è un esempio di come puoi monitorare la tua attività le metriche di rendimento e quelle di rendimento. Questa sezione traccia le sessioni in cui l'utente ha effettuato un acquisto. Puoi confrontare le entrate generate 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 creare grafici per un'analisi più completa e mirata. Per rendere la dashboard più utile, puoi procedere nel seguente modo:
- Configura una query pianificata in BigQuery per ottenere dati aggiornati. La materializzazione che abbiamo eseguito in precedenza crea solo un'istantanea dei dati in quel momento. Se vuoi mantenere la dashboard aggiornata con nuovi dati, puoi eseguire una che verrà eseguita ogni giorno e aggiungerà alla tabella materializzata il nuovo e i dati di Google Cloud.
- Unire i dati proprietari (ad es. il CRM) per ottenere approfondimenti sull'attività. Nella sezione
tabella, puoi aggiungere
user_idcome colonna separata. In questo modo potrai partecipare dati proprietari. Se i dati proprietari non sono già presenti in BigQuery, puoi puoi caricare i dati o usano dati federati Fonte. - Segnala il tuo sito o la versione dell'app come parametro nei dati che invii a Google Analytics e aggiungilo come colonna nella tabella materializzata. Poi puoi aggiungere i dati della versione come dimensione nei grafici per facilitare la visualizzazione le modifiche alla versione influiscono sulle prestazioni.
- Se prevedi un utilizzo significativo del set di dati tramite accesso diretto o la dashboard, puoi provare a usare la versione a pagamento di BigQuery BI Google Cloud.
Riepilogo
Questo post riguarda le nozioni di base su come utilizzare Google Analytics 4 e BigQuery per misurare il rendimento ed eseguirne il debug con i dati di utenti reali raccolti sul campo. it ha anche spiegato come creare dashboard e report automatici utilizzando Looker Studio. e Web Vitals Connector per per visualizzare i dati nel modo più semplice possibile.
Alcuni concetti chiave di questo post:
- Misurare il rendimento con i dati reali degli utenti è fondamentale per comprendere eseguire il debug e l'ottimizzazione del sito.
- Puoi ottenere informazioni più approfondite quando le tue metriche sul rendimento e la tua attività le metriche sono nello stesso sistema. Grazie a Google Analytics e BigQuery, possibile.
- L'esportazione BigQuery dei dati non elaborati di Google Analytics ti offre potenziale illimitato per un'analisi personalizzata e approfondita mediante un linguaggio di query che probabilmente già conosci.
- Google dispone di varie API e strumenti di visualizzazione, come Looker Studio, che offrono la libertà di creare i report nel modo desiderato l'IA generativa.