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 a Pesquisa do Google Cloud, PageSpeed Insights (PSI) a experiência do usuário do Chrome Relatório (CrUX), que permitem aos desenvolvedores ver o desempenho dos sites em relação ao Core Web do Android vitals para os usuários reais no .

Essas ferramentas são ótimas porque dão a você uma visão de alto nível do comportamento o desempenho real do usuário e não exigem nenhuma configuração para serem usados.

No entanto, existem alguns motivos críticos pelos quais você não deve confiar nesses ferramentas sozinhas para avaliar o desempenho do seu site:

As ferramentas baseadas em CrUX informam dados por períodos mensais ou anteriores de 28 dias. Isso significa que você terá que esperar muito tempo depois de fazer qualquer alteração antes de para conferir os resultados.
As ferramentas baseadas em 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 celular). Você não pode dividir os dados por dimensões específicas da sua empresa (por exemplo, engajados usuários, usuários em um determinado grupo experimental etc.).
As ferramentas baseadas em CrUX podem informar qual é sua performance, mas não conseguem dizer você por quê. Com as ferramentas de análise, você pode enviar dados adicionais para ajudar a acompanhar 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. Esta postagem explica como você pode usar ferramentas que o Google oferece para fazer exatamente isso.

Depois de configurar tudo, 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:

Medir

Avaliar o desempenho sempre foi possível com o Google Analytics usando métricas personalizadas, mas há há alguns recursos novos no Google Analytics 4 (GA4) que os desenvolvedores em particular devem ser entusiasmados.

Sem configuração, personalizado evento parâmetros
Exportação sem custo financeiro do BigQuery, então você pode consultar seus dados usando SQL

Embora a interface da Web do Google Analytics tenha ferramentas de análise eficientes, ela é difícil de superar a potência e a flexibilidade do acesso a dados brutos de eventos usando uma consulta idioma 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:

Criar uma conta do Google Analytics 4 propriedade e um Projeto do BigQuery.
Ative o BigQuery Export. na configuração da propriedade do Google Analytics. Assim, todos os dados que você receber serão preenchidas automaticamente nas tabelas dos projetos do BigQuery.
Adicione o JavaScript web-vitals. biblioteca ao seu site. Assim, é possível avaliar as Core Web Vitals e enviar os dados para o Google Analytics 4, incluindo os dados de atribuição.

Analisar

Quando estiver tudo pronto, você verá os dados de eventos sendo preenchidos no BigQuery e você será capaz de consultar os dados desta forma:

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

Esta é uma prévia dos resultados dessa consulta:

Dados de eventos de 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 a entender é que, em alguns casos, vários eventos podem ser recebeu para a mesma métrica na mesma página. Isso poderá acontecer se o valor da métrica e um valor atualizado é informado (uma ocorrência comum com CLS).

Para eventos de Métricas da Web, o último valor enviado é sempre o mais preciso. antes de realizar qualquer análise, é importante filtrar apenas por esses valores. O snippet de código fornecido pela biblioteca JavaScript web-vitals para enviar dados ao O Google Analytics 4 inclui o envio de um ID exclusivo por métrica. Assim, você pode usar o seguinte consulta para limitar seus resultados apenas ao último valor recebido para cada ID da 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', '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
)

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

Exemplos de consultas

As próximas seções mostram alguns exemplos de consultas comuns nas Métricas da Web que você pode quer executar.

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

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

Pontuações de 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', '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

10 principais páginas com o pior CLS (p75)

# Subquery all Web Vitals events from the last 28 days
WITH web_vitals_events AS (
  SELECT event_name as metric_name, * EXCEPT(event_name, is_last_received_value) FROM (
    SELECT *, IF (ROW_NUMBER() OVER (
      PARTITION BY (SELECT value.string_value FROM UNNEST(event_params) WHERE key = 'metric_id')
      ORDER BY (SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = 'metric_value') DESC
    ) = 1, true, false) AS is_last_received_value
    FROM `bigquery_project_id.analytics_XXXXX.events_*`
    WHERE event_name in ('CLS', 'INP', 'LCP') AND
      _TABLE_SUFFIX BETWEEN FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 28 DAY)) AND FORMAT_DATE('%Y%m%d', DATE_SUB(CURRENT_DATE, INTERVAL 1 DAY))
  ) WHERE is_last_received_value
)
# Main query logic
SELECT
  page_path,
  APPROX_QUANTILES(metric_value, 100)[OFFSET(75)] AS CLS,
  COUNT(1) as count
FROM (
  SELECT
    REGEXP_SUBSTR((SELECT value.string_value FROM UNNEST(event_params) WHERE key = "page_location"), r'\.com(\/[^?]*)') AS page_path,
    ROUND((SELECT COALESCE(value.double_value, value.int_value) FROM UNNEST(event_params) WHERE key = "metric_value"), 3) AS metric_value,
  FROM web_vitals_events
  WHERE metric_name = 'CLS'
)
GROUP BY 1
HAVING count > 50 # Limit to relatively popular pages
ORDER BY CLS DESC
LIMIT 10

Depurar

As consultas anteriores mostram como consultar os dados das métricas das Métricas da Web, o que é útil para entender seu desempenho atual e sua tendência ao longo do tempo. Mas o que fazer se seu desempenho for pior do que o esperado, mas você não tiver certeza por quê?

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

Depurar o desempenho no campo explica como é possível enviar informações de depuração adicionais com seus dados de análise. Se você seguir as instruções detalhadas nessa publicação, você verá que a depuração de dados também aparecem no BigQuery.

Exemplos de consultas

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

Principais elementos que contribuem para a CLS

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

Com a CLS, debug_target representa o maior elemento no maior mudança de layout que contribuiu para o valor da CLS. Se nenhum elemento tiver mudado, o O valor de debug_target será null.

A consulta a seguir listará as páginas, da pior para a melhor, de acordo com a CLS na 75a percentil, agrupado 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', '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

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

Saber quais elementos da página estão mudando deve facilitar muito identificar e corrigir a causa raiz do problema.

Tenha em mente que os elementos relatados aqui podem não ser os mesmos que você vê mudanças ao depurar suas páginas localmente, e é por isso que é tão importante capturar esses dados em primeiro lugar. É muito difícil consertar coisas que você não percebe que são problemas!

Depurar outras métricas

A consulta anterior mostra os resultados da métrica de CLS, mas é exatamente o mesmo pode ser usada para informar sobre os destinos de depuração de LCP e INP. Assim substitua a cláusula where pela métrica relevante para depuração:

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

Mais uma vez, consulte Depurar o desempenho na para instruções sobre como coletar e enviar informações de depuração para cada uma das Core Web Vitals.

Visualizar

Pode ser um desafio conseguir insights apenas analisando os resultados da consulta. sozinhos. Por exemplo, a consulta a seguir lista 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', '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

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

Resultados da consulta do valor da métrica diária

Nesses casos, a visualização dos dados pode ajudar você a obter insights mais rapidamente.

Conferir os resultados da consulta no Looker Studio

O BigQuery oferece uma maneira rápida de visualizar qualquer resultado de consulta usando o Data Estúdio. O Looker Studio é uma visualização de dados e criação de painéis sem custo financeiro. Para visualizar os resultados da consulta, Depois de executar sua consulta na interface 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 durante a análise visualização. Nela, é possível selecionar os campos que você quer conferir, escolher tipos de gráficos, filtros e gráficos específicos para uma análise visual rápida. A partir dos resultados da consulta anterior, você pode criar este gráfico de linhas para ver a tendência de Valores de LCP ao longo do tempo:

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

Com essa ligação direta entre o BigQuery e o Looker Studio, é possível criar resultados gráficos de qualquer uma das suas consultas e fazer análises visuais. No entanto, se você quiser fazer análises adicionais, você pode querer olhar para vários gráficos em um painel interativo para ter uma visão mais holística ou poder detalhar nos dados. Com um painel prático, você não precisa criar consultas e gerar gráficos manualmente sempre que quiser analisar suas métricas.

Você pode criar um painel no Looker Studio usando o BigQuery nativo conector. Para isso, acesse datastudio.google.com, crie uma fonte de dados, selecione o conector do BigQuery e escolha o conjunto de dados que deseja trabalham com:

Como usar o conector nativo do BigQuery no Looker Studio

Materializar os dados das Métricas da Web

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

Você pode usar o sandbox do BigQuery sem custos financeiros. Com a nível de uso sem custo financeiro, os o primeiro 1 TB de dados de consulta processados por mês é sem custo financeiro. Para os métodos de análise discutido nesta postagem, a menos que você esteja usando um conjunto de dados significativamente grande ou consultam muito o conjunto de dados regularmente, você deve conseguir ficar dentro esse limite sem custo financeiro todos os meses. Mas se você tem um site de alto tráfego e quer monitorar regularmente diferentes métricas usando um painel de controle rápido interativo, nós sugerir o pré-processamento e a materialização dos dados das Web Vitals ao usar 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 próprio você também pode definir um período para que a tabela de origem 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', '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');

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.
ID da sessão, tipo de usuário (novos x recorrentes) e informações de engajamento da sessão está disponível diretamente nas colunas.
A tabela é particionadas por data e em cluster por nome de métrica. Isso geralmente reduz a quantidade de dados processada para cada consulta.
Como não é preciso usar caracteres curinga para consultar essa tabela, os resultados da consulta podem armazenados em cache por até 24 horas. Isso reduz os custos de repetir o mesmo consulta.
Se você usa o mecanismo BigQuery BI, pode executar funções SQL otimizadas e operadores nessa tabela.

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

Usar o conector das Métricas da Web

Como fazer um painel do zero é demorado, desenvolvemos um pacote que vai criar um modelo de painel para você. Primeiro, certifique-se de que materializaram sua tabela das Métricas da Web usando a consulta anterior. Em seguida, acesse o Conector das Métricas da Web para o Looker Studio usando este link: goo.gle/web-vitals-connector

Depois de fornecer uma autorização única, você verá o seguinte 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 seu ID do projeto de faturamento do BigQuery. Depois de clicar em "Conectar", o Looker Studio vai criar novo painel com modelo e associar seus dados a ele. É possível editar, modificar e compartilhe o painel como quiser. Se você criar um painel uma vez, terá que acessar o link do conector novamente, a menos que queira criar vários painéis de diferentes conjuntos de dados.

Navegar pelo painel

Ao navegar pelo painel, é possível ver as tendências diárias das Core Web Vitals métricas e algumas informações de uso para seu site, como usuários e sessões, em guia Resumo.

Na guia Análise do usuário, é possível selecionar uma métrica e ver um detalhamento das o percentil de métricas, bem como a contagem de usuários por uso e empresa diferentes métricas.

A guia Análise de caminho da página ajuda a identificar as áreas com problemas nos seus site. Aqui, você pode escolher uma métrica para acessar a visão geral. Mas você também encontra mapa de dispersão de todos os caminhos da página com o valor do percentil no eixo Y e no eixo X. O mapa de dispersão pode ajudar a identificar páginas com menor que os valores de métrica esperados. Depois de selecionar as páginas usando o modelo gráfico da tabela Caminho da página, analise ainda mais a área problemática visualizando a tabela Destino de depuração.

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

Uso avançado

Conforme você se familiariza com o conjunto de dados, é possível editar o painel e adicionar seus próprios gráficos para uma análise mais rica e segmentada. Para deixar o painel mais faça o seguinte:

Configurar a consulta programada no BigQuery para receber dados atualizados. A materialização executada anteriormente só captura um snapshot dos seus dados naquele momento. Se você quiser manter seu painel atualizado com novos dados, poderá realizar uma que será executada diariamente e anexar sua tabela materializada com o novo dados.
junte dados próprios (por exemplo, CRM) para ter insights de negócios. Na seção tabela, adicione user_id como uma coluna separada. Isso permitirá que você participe dados próprios. Se os dados próprios ainda não estiverem no BigQuery, será possível carregue os dados ou use um modelo de dados federados fonte.
Informe a versão do seu site ou app como um parâmetro nos dados que você envia ao Google Analytics e adicione-o como uma coluna na tabela materializada. Em seguida, você pode adicionar os dados dessa versão como uma dimensão nos seus gráficos para facilitar a visualização as alterações de versão afetam o desempenho.
Se você espera um uso significativo do conjunto de dados por meio de vendas ou o painel, use a versão paga do BigQuery BI Engine.

Resumo

Nesta postagem, explicamos como usar o Google Analytics 4 e o BigQuery para: medir e depurar o desempenho com dados de usuários reais coletados em campo. Ela também explicou como criar painéis e relatórios automatizados usando o Looker Studio e o Conector das Métricas da Web para garantir visualizar os dados da maneira mais fácil possível.

Alguns pontos importantes desta postagem:

Medir o desempenho com dados reais do usuário é fundamental para entender depurar e otimizar seu site.
Você pode ter insights mais detalhados quando suas métricas de desempenho e sua e as métricas estejam no mesmo sistema. Com o Google Analytics e o BigQuery, sempre que possível.
O BigQuery Export de dados brutos do Google Analytics oferece potencial ilimitado para análises detalhadas e personalizadas usando uma linguagem de consulta que você provavelmente já conhece.
O Google tem várias APIs e ferramentas de visualização, como o Looker Studio, que oferecem a liberdade de criar seus relatórios exatamente da maneira como você deseja que eles sejam construído.