Mide y depura el rendimiento con Google Analytics 4 y BigQuery

Aprende a enviar datos de Web Vitals a las propiedades Google Analytics 4 y exportar los datos para analizarlos en BigQuery y Looker Studio.

Minhaz Kazi

Philip Walton

Google proporciona varias herramientas, como Search Console, PageSpeed Insights (PSI) y el Informe sobre la experiencia del usuario en Chrome (CrUX), que permiten a los desarrolladores ver el rendimiento de sus sitios en función de las métricas de Core Web Vitals para sus usuarios reales en el campo.

Estas herramientas son excelentes, ya que te brindan una vista de alto nivel del rendimiento de los usuarios reales de tu sitio y no requieren ninguna configuración para comenzar a usarlas.

Sin embargo, existen algunos motivos fundamentales por los que no debes depender solo de estas herramientas para medir el rendimiento de tu sitio:

• Las herramientas basadas en CrUX registran datos por períodos mensuales o de 28 días anteriores. Esto significa que deberás esperar mucho tiempo después de realizar cualquier cambio para poder ver los resultados.
• Las herramientas basadas en CrUX solo se pueden segmentar por una cantidad limitada de dimensiones, como el país, el tipo de conexión y la categoría del dispositivo (computadora de escritorio o dispositivo móvil). No puedes segmentar los datos por dimensiones específicas de tu empresa (por ejemplo, usuarios que interactuaron, usuarios de un grupo de experimentos en particular, etcétera).
• Las herramientas basadas en CrUX pueden decirte cuál es tu rendimiento, pero no pueden decirte por qué. Con las herramientas de estadísticas, puedes enviar datos adicionales para ayudarte a hacer un seguimiento de los problemas y depurarlos.

Por estos motivos, recomendamos a todos los propietarios de sitios que supervisen las métricas de las Métricas web esenciales con su herramienta de estadísticas existente. En esta publicación, se explica cómo puedes usar las herramientas gratuitas que ofrece Google para hacerlo.

Una vez que tengas todo configurado, podrás crear paneles como los siguientes:

Si quieres obtener una descripción general visual de todos los pasos que se describen aquí, mira nuestra charla de Google I/O 2021:

Medir

Medir el rendimiento siempre fue posible con Google Analytics mediante métricas personalizadas, pero hay algunas funciones nuevas en Google Analytics 4 (GA4) que deberían entusiasmar a los desarrolladores en particular.

• Parámetros de evento personalizado sin configuración
• Exportación de BigQuery gratuita para que puedas consultar tus datos con SQL

Si bien la interfaz web de Google Analytics tiene herramientas de análisis potentes, es difícil superar la potencia y flexibilidad del acceso a los datos de eventos sin procesar con un lenguaje de consulta que probablemente ya conozcas.

Para comenzar a medir las métricas web esenciales con Google Analytics 4 y BigQuery, debes hacer lo siguiente:

1. Crea una propiedad Google Analytics 4 y un proyecto de BigQuery.
2. Habilita la exportación a BigQuery en la configuración de tu propiedad de Google Analytics para que todos los datos que recibas se propaguen automáticamente en las tablas de tu proyecto de BigQuery.
3. Agrega la biblioteca de JavaScript web-vitals a tu sitio para poder medir las métricas de Core Web Vitals y enviar los datos a Google Analytics 4, incluidos los datos de atribución.

Analizar

Una vez que hayas terminado de configurar todo, deberías ver que los datos de eventos se propagan en la interfaz de BigQuery y deberías poder consultar los datos de la siguiente manera:

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

Esta es una vista previa de los resultados de esa consulta:

Cómo consultar datos de métricas web

Antes de comenzar a consultar los datos de eventos de las métricas Web Vitals, es importante que comprendas cómo se agregan los datos.

Lo más importante que debes comprender es que, en algunos casos, es posible que se reciban varios eventos para la misma métrica en la misma página. Esto puede suceder si cambia el valor de la métrica y se informa un valor actualizado (un evento común con CLS).

En el caso de los eventos de Web Vitals, el último valor enviado siempre es el más preciso, por lo que, antes de realizar cualquier análisis, es importante filtrar solo esos valores. El fragmento de código que proporciona la biblioteca de JavaScript de web-vitals para enviar datos a Google Analytics 4 incluye el envío de un ID único por métrica, por lo que puedes usar la siguiente consulta para limitar tus resultados solo al último valor recibido 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', '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
)

Ten en cuenta que todas las demás consultas a las que se hace referencia en esta entrada comenzarán con esta subconsulta.

Consultas de ejemplo

En las siguientes secciones, se muestran algunos ejemplos de consultas comunes de Web Vitals que podrías ejecutar.

LCP, INP y CLS en el percentil 75 (p75) en todo el sitio

# 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 los valores de LCP individuales de mayor a 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

Puntuaciones de LCP (p75) de las 10 páginas más populares

# 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

Las 10 páginas principales con el peor 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

En las consultas anteriores, se muestra cómo consultar los datos de las métricas de las Métricas web, lo que es útil para comprender tu rendimiento actual y cómo evoluciona con el tiempo. Sin embargo, ¿qué puedes hacer si tu rendimiento es peor de lo esperado, pero no sabes por qué?

Saber cuáles son tus puntuaciones no es útil si no puedes tomar medidas para solucionar los problemas.

En Cómo depurar el rendimiento en el campo, se explica cómo puedes enviar información de depuración adicional con tus datos de estadísticas. Si sigues las instrucciones detalladas en esa publicación, deberías ver que la información de debugging también aparece en BigQuery.

Consultas de ejemplo

En las siguientes consultas, se muestra cómo usar el parámetro de evento debug_target para ayudar a identificar la causa raíz de los problemas de rendimiento.

Principales elementos que contribuyen al CLS

El debug_target es una cadena de selector CSS que corresponde al elemento en la página que es más relevante para el valor de la métrica.

Con CLS, debug_target representa el elemento más grande del mayor cambio de diseño que contribuyó al valor de CLS. Si no se cambió ningún elemento, el valor de debug_target será null.

La siguiente consulta mostrará las páginas de peor a mejor según su CLS con el percentil 75, 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

Si sabes qué elementos de la página cambiarán, debería ser mucho más fácil identificar y solucionar la causa raíz del problema.

Ten en cuenta que es posible que los elementos que se informan aquí no sean los mismos que ves cambiar cuando depuras tus páginas a nivel local. Por eso, es tan importante capturar estos datos en primer lugar. Es muy difícil solucionar problemas que no puedes detectar.

Cómo depurar otras métricas

La consulta anterior muestra los resultados para la métrica de CLS, pero se puede usar exactamente la misma técnica con el fin de informar sobre los objetivos de depuración para LCP y INP. Solo reemplaza la cláusula where por la métrica relevante para depurar de la siguiente manera:

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

Una vez más, puedes consultar Cómo depurar el rendimiento en el campo para obtener instrucciones sobre cómo recopilar y enviar información de depuración para cada una de las métricas de las Métricas web esenciales.

Visualizar

Puede ser difícil obtener estadísticas solo con los resultados de la consulta. Por ejemplo, en la siguiente consulta, se enumeran los valores diarios del percentil 75 para la LCP en el conjunto de datos.

# 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

A partir de estos resultados de la consulta, es difícil identificar tendencias o valores atípicos solo con mirar los datos.

En esos casos, visualizar los datos puede ayudarte a obtener estadísticas más rápido.

Visualiza los resultados de las consultas en Looker Studio

BigQuery proporciona una forma rápida de visualizar cualquier resultado de consulta a través de Data Studio. Looker Studio es una herramienta de visualización de datos y paneles gratuita. Para visualizar los resultados de tu consulta, después de ejecutarla en la IU de BigQuery, haz clic en el botón Explorar datos y selecciona Explorar con Looker Studio.

Esta acción creará un vínculo directo de BigQuery a Looker Studio en la vista de exploración. En esta vista, puedes seleccionar qué campos deseas visualizar, elegir los tipos de gráfico, configurar filtros y crear gráficos ad hoc para realizar análisis visuales rápidos. A partir de los resultados de la consulta anterior, puedes crear este gráfico de líneas para ver la tendencia de los valores de LCP a lo largo del tiempo:

Con este vínculo directo entre BigQuery y Looker Studio, puedes crear gráficos rápidos a partir de cualquiera de tus consultas y realizar análisis visuales. Sin embargo, si deseas realizar un análisis adicional, considera consultar varios gráficos en un panel interactivo para obtener una vista más integral o poder desglosar los datos. Tener un panel práctico significa que no tienes que escribir consultas ni generar gráficos de forma manual cada vez que quieres analizar tus métricas.

Puedes crear un panel en Looker Studio con el conector nativo de BigQuery. Para ello, navega a datastudio.google.com, crea una fuente de datos nueva, selecciona el conector de BigQuery y elige el conjunto de datos con el que quieres trabajar:

Materializa datos de métricas web

Cuando creas paneles de datos de eventos de métricas web, como se describió anteriormente, no es eficiente usar el conjunto de datos de exportación de Google Analytics 4 directamente. Debido a la estructura de los datos de GA4 y el procesamiento previo requerido para las métricas web, algunas partes de tu consulta se ejecutarán varias veces. Esto crea dos problemas: el rendimiento del panel y los costos de BigQuery.

Puedes usar el modo de zona de pruebas de BigQuery sin cargo. Con el nivel de uso gratuito de BigQuery, el primer TB de datos de consultas que se procesan por mes es gratis. Para los métodos de análisis que se mencionan en esta publicación, a menos que uses un conjunto de datos demasiado grande o lo consultes con frecuencia, deberías poder mantenerte dentro de este límite gratuito cada mes. Sin embargo, si tienes un sitio web con mucho tráfico y quieres supervisar las diferentes métricas con regularidad mediante un panel interactivo rápido, te sugerimos procesar previamente y materializar tus datos de métricas web y, al mismo tiempo, usar las funciones de eficiencia de BigQuery, como la partición, el agrupamiento en clústeres y el almacenamiento en caché.

La siguiente secuencia de comandos procesará previamente tus datos de BigQuery (tabla de origen) y creará una tabla materializada (tabla de destino). Cuando uses esta consulta para tu propio conjunto de datos, también te recomendamos que definas un período para la tabla de origen para reducir la cantidad de datos procesados.

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

Este conjunto de datos materializado tiene varias ventajas:

• La estructura de datos es plana y más fácil de consultar.
• Solo retiene los eventos de Métricas web del conjunto de datos original de GA4.
• La ID de sesión, el tipo de usuario (nuevo o recurrente) y la información de la participación de la sesión están disponibles directamente en las columnas.
• La tabla está particionada por fecha y agrupada por nombre de métrica. Esto suele reducir la cantidad de datos que se procesan para cada consulta.
• Ya que no necesitas usar comodines para consultar esta tabla, se pueden almacenar los resultados de la consulta en caché hasta por 24 horas. Esto reduce los costos si repites la misma consulta.
• Si usas BigQuery BI Engine, puedes ejecutar operadores y funciones de SQL optimizados en esta tabla.

Puedes consultar directamente esta tabla materializada desde la IU de BigQuery o usarla en Looker Studio con el conector de BigQuery.

Usa el conector de métricas web

Dado que crear un panel desde cero lleva mucho tiempo, desarrollamos una solución empaquetada que creará un panel de plantilla para ti. Primero, asegúrate de haber materializado la tabla de Métricas web con la consulta anterior. Luego, accede al conector de Métricas web de Looker Studio con este vínculo: goo.gle/web-vitals-connector.

Después de proporcionar una autorización única, deberías ver la siguiente pantalla de configuración:

Proporciona el ID de la tabla de BigQuery materializada (es decir, la tabla de destino) y el ID de tu proyecto de facturación de BigQuery. Después de hacer clic en Conectar, Looker Studio creará un panel con una nueva plantilla y asociará tus datos con él. Puedes editar, modificar y compartir el panel de control como desees. Si creas un panel una vez, no tienes que volver a visitar el vínculo del conector, a menos que quieras crear varios paneles a partir de diferentes conjuntos de datos.

Navega por el panel

A medida que navegas por el panel, puedes ver las tendencias diarias de las métricas de Métricas web y algunos datos de uso de tu sitio web, como usuarios y sesiones, en la pestaña Resumen.

En la pestaña User Analysis, puedes seleccionar una métrica y, luego, obtener un desglose del percentil de métricas, así como el recuento de usuarios, según las diferentes métricas empresariales y de uso.

La pestaña Análisis de la ruta de la página te ayudará a identificar las áreas con problemas en tu sitio web. Aquí, puedes elegir una métrica para ver la descripción general. Pero también puedes ver el mapa de dispersión de todas las rutas de la página con el valor de percentil en el eje Y y el recuento de registros en el eje X. El mapa de dispersión puede ayudar a identificar páginas que tienen valores de métricas inferiores a los esperados. Una vez que selecciones las páginas con el diagrama de dispersión de la tabla Ruta de la página, podrás desglosar aún más el área del problema si ves la tabla Destino de depuración.

La pestaña Análisis de ingresos es un ejemplo de cómo puedes supervisar tu negocio y las métricas de rendimiento en el mismo lugar. En esta sección, se muestran todas las sesiones en las que el usuario realizó una compra. Puedes comparar los ingresos obtenidos con la experiencia del usuario durante una sesión específica .

Uso avanzado

A medida que te familiarices con el conjunto de datos, podrás editar el panel y agregar tus propios gráficos para obtener un análisis más detallado y segmentado. Para que el panel sea más útil, puedes seguir estos pasos:

• Configura una consulta programada en BigQuery para obtener datos actualizados. La consulta de materialización que ejecutamos antes solo toma una instantánea de tus datos en ese momento. Si deseas mantener tu panel actualizado con datos nuevos, puedes ejecutar una consulta programada que se ejecutará todos los días y agregar a tu tabla materializada los datos nuevos.
• Combina datos de origen (p.ej., CRM) para obtener estadísticas comerciales. En la tabla materializada, puedes agregar user_id como una columna independiente. Esto te permitirá unir tus datos de origen. Si tus datos de origen aún no están en BigQuery, puedes cargarlos o usar una fuente de datos federada.
• Registra la versión de tu sitio o aplicación como un parámetro en los datos que envías a Google Analytics y agrégala como una columna en la tabla materializada. Luego, puedes agregar esos datos de versión como una dimensión en tus gráficos para que sea más fácil ver cómo los cambios en la versión afectan el rendimiento.
• Si esperas un uso considerablemente alto del conjunto de datos a través de la consulta directa o el panel, puedes probar la versión pagada de BigQuery BI Engine.

Resumen

En esta publicación, se abordaron los conceptos básicos para usar Google Analytics 4 y BigQuery para medir y depurar el rendimiento con datos de usuarios reales recopilados en el campo. También se explicó cómo crear informes y paneles automatizados con Looker Studio y el Conector de Métricas web para que la visualización de los datos sea lo más fácil posible.

Estas son algunas conclusiones clave de esta publicación:

• Medir el rendimiento con datos de usuarios reales es fundamental para comprender, depurar y optimizar tu sitio.
• Puedes obtener estadísticas más detalladas cuando tus métricas de rendimiento y las de tu negocio están en el mismo sistema. Google Analytics y BigQuery hacen esto posible.
• La exportación de datos sin procesar de Google Analytics a BigQuery te brinda un potencial ilimitado para realizar análisis personalizados y detallados con un lenguaje de consulta que probablemente ya conozcas.
• Google tiene varias APIs y herramientas de visualización, como Looker Studio, que te brindan la libertad de crear tus informes exactamente de la forma en que deseas.