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.

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

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

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

  • As ferramentas baseadas no CrUX geram dados por períodos mensais ou anteriores de 28 dias. Isso significa que, depois de fazer qualquer alteração, você terá que 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 dividir os dados por dimensões específicas para sua empresa (por exemplo: usuários engajados, usuários de um grupo experimental específico etc.).
  • As ferramentas baseadas no CrUX podem informar qual é sua performance, mas não informam o motivo. Com as 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 métricas das Core Web Vitals usando a ferramenta de análise atual. Nesta postagem, explicamos como usar ferramentas sem custo financeiro oferecidas pelo Google para fazer isso.

Depois de configurar tudo, você poderá criar painéis como estes:

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

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

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

Medida

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

Embora a interface da Web do Google Analytics tenha ferramentas de análise eficientes, é difícil superar a força 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 fazer três coisas:

  1. Crie uma propriedade do Google Analytics 4 e um projeto do BigQuery.
  2. Ative o BigQuery Export na configuração da propriedade do Google Analytics para que todos os dados recebidos sejam preenchidos automaticamente nas tabelas do projeto do BigQuery.
  3. 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

Depois de fazer a configuração, você verá os dados de eventos sendo preenchidos na interface do BigQuery e poderá consultar os dados desta 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 pode acontecer se o valor da métrica for alterado e um valor atualizado for informado (uma ocorrência comum com CLS).

Para eventos das Métricas da Web, o último valor enviado é sempre o mais preciso. Portanto, antes de realizar qualquer análise, é importante filtrar apenas por 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 podem ser feitas.

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 ao 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
# 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 das Métricas da Web, o que é útil para entender sua performance atual e as tendências ao longo do tempo. Mas o que fazer se seu desempenho for pior do que o esperado, mas você não tiver certeza do motivo?

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

Depurar o desempenho no campo explica como enviar mais 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 serão exibidas 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 do 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 da CLS. Se nenhum elemento for mudado, o valor debug_target vai 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 muito 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, é tão importante capturar esses dados. É muito difícil consertar tudo 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 os destinos de depuração de 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 o artigo Depurar desempenho no campo para conferir instruções sobre como coletar e enviar informações de depuração para cada uma das Core Web Vitals.

Visualizar

Pode ser difícil conseguir insights apenas observando 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 ajudar você a ter insights mais rapidamente.

Conferir os resultados da consulta no Looker Studio

O BigQuery oferece uma maneira rápida de visualizar qualquer resultado de consulta por meio do Data Studio. O Looker Studio é uma ferramenta de visualização de dados e painéis de uso sem custo financeiro. Para visualizar os resultados da consulta, depois de executá-la 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 exploração. Nessa visualização, você pode selecionar os campos que quer ver, escolher tipos de gráfico, configurar filtros e criar gráficos ad hoc para 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 da 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 outras análises, analise vários gráficos em um painel interativo para ter uma visão mais holística ou detalhar os dados. Ter um painel prático 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, acesse datastudio.google.com, crie uma nova fonte de dados, selecione o conector do BigQuery e escolha o conjunto de dados com que 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: o desempenho do painel e os custos do BigQuery.

Você pode usar o modo sandbox do BigQuery sem custo financeiro. Com o nível de uso sem custo financeiro do BigQuery, não é preciso pagar pelo primeiro 1 TB de dados de consulta processados por mês. Para os métodos de análise discutidos nesta postagem, a menos que você esteja usando um conjunto de dados significativamente grande ou consulte com frequência o conjunto de dados, é possível permanecer dentro desse limite todos os meses. No entanto, se você tem um site de tráfego intenso e quer monitorar regularmente métricas diferentes usando um painel interativo rápido, sugerimos o pré-processamento e a materialização dos seus 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 seus dados do BigQuery (tabela de origem) e criar uma tabela materializada (tabela de destino). Ao usar essa consulta para seu próprio conjunto de dados, convém também 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 diretamente nas colunas.
  • A tabela é partitioned por data e armazenada 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 essa 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 BigQuery BI Engine, poderá executar funções e operadores SQL otimizados nessa tabela.

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

Como usar o conector de Métricas da Web

Como criar um painel do zero é demorado, desenvolvemos uma solução empacotada que criará um painel de modelo para você. Primeiro, confira se você materializou a tabela das Core Web Vitals usando a consulta acima. Depois, acesse o conector de 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 usando conjuntos de dados diferentes.

Ao navegar pelo painel, é possível ver 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 do usuário, é possível selecionar uma métrica e, em seguida, receber um detalhamento do percentil de métricas, além da contagem de usuários por diferentes métricas de uso e negócios.

A guia Análise do caminho da página ajuda a identificar áreas com problemas no seu site. Aqui é possível escolher uma métrica para ter uma visão geral. Também é possível conferir o mapa de dispersão de todos os caminhos de página com o valor de percentil no eixo Y e contagem de registros no eixo X. Ele ajuda a identificar páginas com valores de métricas menores do que o 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 da receita é um exemplo de como monitorar as métricas de negócios e de desempenho no mesmo lugar. essa seção mostra todas as sessões em que o usuário fez uma compra. É possível comparar a receita gerada com 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 análises mais ricas e segmentadas. Para tornar o painel mais útil, siga estas etapas:

  • Configure a consulta programada no BigQuery para receber dados atualizados. A consulta de materialização que executamos acima cria apenas um snapshot dos seus dados naquele momento. Para manter o painel atualizado com novos dados, execute uma consulta programada todos os dias e anexe os novos dados à tabela materializada.
  • Combinar dados próprios (por exemplo, CRM) para 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 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 um uso significativamente intenso do conjunto de dados por meio de consulta direta ou do painel, tente usar 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 o desempenho com dados de usuários reais coletados no campo. Também explicou como criar relatórios e painéis automatizados usando o Looker Studio e o conector das Web Vitals para facilitar a visualização dos dados.

Confira algumas conclusões importantes desta postagem:

  • Medir o desempenho com dados reais do usuário é fundamental para entender, depurar e otimizar seu site.
  • É possível ter insights mais detalhados quando as 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 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 permitem criar seus relatórios exatamente da maneira que você quiser.