Esta página foi traduzida pela API Cloud Translation.

Meça e depure a performance com o Google Analytics 4 e o BigQuery

Saiba como enviar dados das Métricas da Web para as propriedades do Google Analytics 4 e exportar os dados para análise no BigQuery e no Looker Studio.

Minhaz Kazi

Philip Walton

O Google oferece várias ferramentas, como o Search Console, o PageSpeed Insights (PSI) e o Chrome User Experience Relatório (CrUX, na sigla em inglês), que permitem aos desenvolvedores ver o desempenho dos sites em relação às métricas do Core Web Vitals para usuários reais em campo.

Essas ferramentas são excelentes porque oferecem uma visão de alto nível do desempenho real do usuário no site e não exigem nenhuma configuração para começar a ser usadas.

No entanto, existem alguns motivos importantes para você não confiar nessas ferramentas sozinhas para medir o desempenho do seu site:

As ferramentas baseadas no CrUX informam os dados por períodos mensais ou anteriores de 28 dias. Isso significa que, depois de fazer qualquer alteração, será necessário esperar muito tempo para ver os resultados.
As ferramentas baseadas no CrUX só podem ser segmentadas por um número limitado de dimensões, como país, tipo de conexão e categoria do dispositivo (computador ou dispositivo móvel). Não é possível fatiar os dados por dimensões específicas para sua empresa (por exemplo: usuários engajados, usuários em um determinado grupo experimental etc.).
As ferramentas baseadas no CrUX podem informar qual é seu desempenho, mas não informam o porquê. Com ferramentas de análise, é possível enviar mais dados para ajudar a rastrear e depurar problemas.

Por esses motivos, recomendamos que todos os proprietários de sites monitorem as Core Web Vitals usando a ferramenta de análise atual. Nesta postagem, explicamos como usar as ferramentas sem custo financeiro oferecidas pelo Google para fazer isso.

Assim que tudo estiver configurado, você poderá criar painéis como estes:

Captura de tela do relatório do conector das Métricas da Web

Se você quiser uma visão geral de todas as etapas descritas aqui, confira nossa palestra do Google I/O 2021:

Medida

Sempre foi possível medir a performance com o Google Analytics usando métricas personalizadas, mas há alguns novos recursos no Google Analytics 4 (GA4) que os desenvolvedores em particular precisam gostar.

Parâmetros de evento personalizado e sem configuração
Exportação sem custo financeiro do BigQuery, para que você possa consultar seus dados usando SQL

Embora a interface da Web do Google Analytics tenha ferramentas de análise eficientes, é difícil superar a eficiência e a flexibilidade do acesso a dados brutos de eventos usando uma linguagem de consulta que você provavelmente já conhece.

Para começar a medir as Core Web Vitals usando o Google Analytics 4 e o BigQuery, você precisa:

Crie uma propriedade do Google Analytics 4 e um projeto do BigQuery.
Ative a exportação do BigQuery na configuração da propriedade do Google Analytics para que todos os dados recebidos sejam preenchidos automaticamente nas tabelas do projeto do BigQuery.
Adicione a biblioteca JavaScript web-vitals ao seu site para medir as métricas das Core Web Vitals e enviar os dados ao Google Analytics 4.

Analisar

Após a configuração, você verá os dados de eventos sendo preenchidos na interface do BigQuery e poderá consultar os dados da seguinte maneira:

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

Aqui está uma prévia dos resultados dessa consulta:

Dados de eventos das Métricas da Web no BigQuery

Consultar dados das Métricas da Web

Antes de começar a consultar os dados de eventos das Métricas da Web, é importante entender como os dados são agregados.

O mais importante é entender que, em alguns casos, vários eventos podem ser recebidos para a mesma métrica, na mesma página. Isso poderá acontecer se o valor da métrica for alterado e um valor atualizado for informado (uma ocorrência comum com CLS).

Para os eventos das Métricas da Web, o último valor enviado é sempre o mais preciso. Portanto, antes de realizar qualquer análise, é importante filtrar apenas esses valores. O snippet de código fornecido pela biblioteca web-vitals JavaScript para enviar dados ao Google Analytics 4 inclui o envio de um ID exclusivo por métrica. Assim, você pode usar a consulta a seguir para limitar os resultados apenas ao último valor recebido de cada ID de métrica:

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

Todas as outras consultas mencionadas nesta postagem começarão com essa subconsulta.

As próximas seções mostram alguns exemplos de consultas comuns das Métricas da Web que convém realizar.

Exemplos de consultas

LCP, FID e CLS no percentil 75% (p75) em todo o site

# 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

Todos os valores individuais de LCP do maior para o menor

# 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

Pontuações da LCP (p75) das 10 páginas mais acessadas

# 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

10 principais páginas com os piores índices de 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', '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

Depuração

As consultas acima mostram como consultar os dados da métrica das Métricas da Web, o que é útil para entender sua performance atual e as tendências dela ao longo do tempo. No entanto, o que fazer se o desempenho for pior do que o esperado, mas você não tiver certeza do motivo?

Saber quais são suas pontuações não é útil se você não conseguir agir e corrigir os problemas.

Depurar o desempenho no campo explica como você pode enviar outras informações de depuração com seus dados de análise. Se você seguir as instruções detalhadas nesta postagem, verá que as informações de depuração também aparecem no BigQuery.

As consultas a seguir mostram como usar o parâmetro de evento debug_target para ajudar a identificar a causa raiz dos problemas de desempenho.

Exemplos de consultas

Principais elementos que contribuem para a CLS

O debug_target é uma string de seletor de CSS que corresponde ao elemento na página mais relevante para o valor da métrica.

Com a CLS, o debug_target representa o maior elemento da maior mudança de layout que contribuiu para o valor do CLS. Se nenhum elemento for modificado, o valor de debug_target será null.

A consulta a seguir listará as páginas do pior para o melhor de acordo com a CLS no 75o percentil, agrupadas por 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

Resultado da consulta para os principais elementos que contribuem para a CLS

Saber quais elementos da página estão mudando facilita a identificação e a correção da causa raiz do problema.

Lembre-se de que os elementos informados aqui podem não ser os mesmos que você vê mudando ao depurar suas páginas localmente. Por isso, é muito importante capturar esses dados. É muito difícil corrigir coisas que você não percebe que são problemas!

Depurar outras métricas

A consulta acima mostra os resultados da métrica de CLS, mas a mesma técnica pode ser usada para gerar relatórios sobre destinos de depuração para LCP e FID. Basta substituir a cláusula where pela métrica relevante para depurar:

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

Novamente, você pode consultar Depurar desempenho no campo para instruções sobre como coletar e enviar informações de depuração para cada uma das métricas das Core Web Vitals.

Visualizar

Pode ser desafiador conseguir insights apenas analisando os resultados da consulta. Por exemplo, a consulta a seguir lista os valores diários do 75o percentil para LCP no conjunto de dados.

# 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

Com esses resultados de consulta, é difícil identificar tendências ou outliers apenas observando os dados.

Resultados da consulta de valor de métrica diário

Nesses casos, visualizar os dados pode ajudá-lo a obter insights mais rapidamente.

Conferir os resultados da consulta no Looker Studio

Com o BigQuery, é possível visualizar rapidamente qualquer resultado de consulta por meio do Data Studio. O Looker Studio é uma ferramenta de visualização de dados e painéis sem custos financeiros. Para visualizar os resultados da consulta, depois de executar a consulta na IU do BigQuery, clique no botão Explorar dados e selecione Explorar com o Looker Studio.

Opção "Explorar com o Looker Studio" no BigQuery

Isso cria um link direto do BigQuery para o Looker Studio na visualização de análise. Nela, você pode selecionar os campos que quer visualizar, escolher tipos de gráfico, configurar filtros e criar gráficos específicos para uma análise visual rápida. Com base nos resultados da consulta acima, crie este gráfico de linhas para ver a tendência dos valores de LCP ao longo do tempo:

Gráfico de linhas de valores diários de LCP no Looker Studio

Com esse link direto entre o BigQuery e o Looker Studio, é possível criar gráficos rápidos de qualquer consulta e fazer análises visuais. No entanto, se você quiser fazer uma análise adicional, convém analisar vários gráficos em um painel interativo para ter uma visão mais holística ou para detalhar os dados. Ter um painel útil significa que você não precisa escrever consultas e gerar gráficos manualmente sempre que quiser analisar suas métricas.

É possível criar um painel no Looker Studio usando o conector nativo do BigQuery. Para isso, navegue até datastudio.google.com, crie uma nova fonte de dados, selecione o conector do BigQuery e escolha o conjunto de dados com o qual você quer trabalhar:

Como usar o conector nativo do BigQuery no Looker Studio

Materializar os dados das Métricas da Web

Ao criar painéis dos dados de eventos das Métricas da Web, conforme descrito acima, não é eficiente usar o conjunto de dados de exportação do Google Analytics 4 diretamente. Devido à estrutura dos dados do GA4 e ao pré-processamento necessário para as Métricas da Web, partes da sua consulta serão executadas várias vezes. Isso cria dois problemas: desempenho do painel e custos do BigQuery.

É possível usar o modo sandbox do BigQuery sem custo financeiro. Com o nível de uso sem custo financeiro do BigQuery, o primeiro 1 TB de dados de consulta processados por mês é sem custo financeiro. Para os métodos de análise discutidos nesta postagem, a menos que você use um conjunto de dados significativamente grande ou consulte com frequência o conjunto de dados, é possível permanecer dentro desse limite sem custo financeiro todos os meses. No entanto, se você tiver um site de tráfego intenso e quiser monitorar regularmente métricas diferentes usando um painel interativo rápido, recomendamos fazer o pré-processamento e a materialização dos dados do Web Vitals enquanto usa os recursos de eficiência do BigQuery, como particionamento, clustering e armazenamento em cache.

O script a seguir vai pré-processar os dados do BigQuery (tabela de origem) e criar uma tabela materializada (tabela de destino). Ao usar essa consulta no seu conjunto de dados, é possível definir um período para a tabela de origem a fim de diminuir a quantidade de dados processados.

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

Esse conjunto de dados materializado tem várias vantagens:

A estrutura de dados é simplificada e mais fácil de consultar.
Ele retém apenas os eventos das Métricas da Web do conjunto de dados original do GA4.
As informações sobre o ID da sessão, o tipo de usuário (novo x recorrente) e o engajamento da sessão estão disponíveis nas colunas.
A tabela é partitioned por data e em cluster por nome de métrica. Isso geralmente reduz a quantidade de dados processados para cada consulta.
Como você não precisa usar caracteres curinga para consultar a tabela, os resultados da consulta podem ser armazenados em cache por até 24 horas. Isso reduz os custos de repetir a mesma consulta.
Se você usar o mecanismo do BigQuery BI, poderá executar funções e operadores SQL otimizados nessa tabela.

É possível consultar essa tabela materializada diretamente na interface do BigQuery ou usá-la no Looker Studio com o conector do BigQuery.

Como usar o conector das Métricas da Web

Como fazer um painel do zero é demorado, desenvolvemos uma solução em pacote que criará um painel de modelo para você. Primeiro, confira se você materializou a tabela das Core Web Vitals usando a consulta acima. Em seguida, acesse o conector das Métricas da Web para o Looker Studio neste link: goo.gle/web-vitals-connector

Depois de fornecer uma autorização única, você verá a seguinte tela de configuração:

Tela de autorização do conector das Métricas da Web

Forneça o ID da tabela materializada do BigQuery (ou seja, a tabela de destino) e o ID do projeto de faturamento do BigQuery. Depois de clicar em "Conectar", o Looker Studio vai criar um novo painel com modelo e associar seus dados a ele. Você pode editar, modificar e compartilhar o painel como quiser. Se você criar um painel uma vez, não precisará acessar o link do conector novamente, a menos que queira criar vários painéis a partir de diferentes conjuntos de dados.

Navegar pelo painel

Ao navegar pelo painel, é possível conferir as tendências diárias das Métricas da Web e algumas informações de uso do seu site, como usuários e sessões, na guia Resumo.

Na guia Análise de usuários, é possível selecionar uma métrica e, em seguida, acessar um detalhamento do percentil de métricas, bem como a contagem de usuários por diferentes métricas de uso e negócios.

A guia Análise de caminho da página ajuda a identificar áreas problemáticas no seu site. Aqui é possível escolher uma métrica para ter uma visão geral. e o mapa de dispersão de todos os caminhos de página com o valor do percentil no eixo Y e a contagem de registros no eixo X. Ele ajuda a identificar páginas com valores de métrica abaixo do esperado. Depois de selecionar as páginas usando o gráfico de dispersão da tabela Caminho da página, é possível detalhar ainda mais a área problemática visualizando a tabela Destino de depuração.

A guia Análise de receita é um exemplo de como monitorar suas métricas de negócios e desempenho no mesmo lugar. Essa seção mostra todas as sessões em que o usuário fez uma compra. Você pode comparar a receita ganha e a experiência do usuário durante uma sessão específica .

Uso avançado

À medida que você se familiariza com o conjunto de dados, pode editar o painel e adicionar seus próprios gráficos para uma análise mais detalhada e segmentada. Para tornar o painel mais útil, siga estas etapas:

Configure uma consulta programada no BigQuery para receber dados atualizados. A consulta de materialização executada acima faz apenas um snapshot dos dados no momento. Para manter o painel atualizado com novos dados, é possível executar uma consulta programada todos os dias e anexar os novos dados à tabela materializada.
Mesclar dados próprios (por exemplo, CRM) para extrair insights de negócios. Na tabela materializada, é possível adicionar user_id como uma coluna separada. Isso permitirá que você junte seus dados próprios. Se os dados próprios ainda não estiverem no BigQuery, carregue os dados ou use uma fonte de dados federada.
Informe a versão do seu site ou app como um parâmetro nos dados enviados ao Google Analytics e adicione-os como uma coluna na tabela materializada. Em seguida, adicione esses dados da versão como uma dimensão nos gráficos para facilitar a visualização das mudanças de versão afetam o desempenho.
Se você espera uma utilização significativamente intensa do conjunto de dados por consulta direta ou pelo painel, use a versão paga do BigQuery BI Engine.

Resumo

Esta postagem abordou os conceitos básicos de como usar o Google Analytics 4 e o BigQuery para medir e depurar a performance com dados de usuários reais coletados em campo. Também explicou como criar relatórios e painéis automatizados usando o Looker Studio e o conector da Web Vitals para facilitar a visualização dos dados.

Alguns aprendizados importantes desta postagem:

Medir o desempenho com dados reais de usuários é fundamental para entender, depurar e otimizar seu site.
É possível conseguir insights mais detalhados quando suas métricas de desempenho e de negócios estão no mesmo sistema. O Google Analytics e o BigQuery tornam isso possível.
A exportação do BigQuery de dados brutos do Google Analytics oferece potencial ilimitado para análises personalizadas e detalhadas usando uma linguagem de consulta que você provavelmente já conhece.
O Google tem uma série de APIs e ferramentas de visualização, como o Looker Studio, que dão a você a liberdade de criar seus relatórios exatamente da maneira que quiser.