Mide y depura el rendimiento con Google Analytics 4 y BigQuery

Aprende a enviar datos de Métricas web a las propiedades Google Analytics 4 y a exportarlos para analizarlos en BigQuery y Looker Studio.

Google ofrece una serie de herramientas, como Search Console, PageSpeed Insights (PSI) y el Informe sobre la experiencia del usuario en Chrome (CrUX), que les permiten a los desarrolladores ver el rendimiento de sus sitios en comparación con las métricas de Métricas web esenciales para sus usuarios reales en el campo.

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

Sin embargo, existen algunos motivos críticos por los que no es recomendable que solo uses estas herramientas para medir el rendimiento de tu sitio:

• Las herramientas basadas en CrUX informan los datos por períodos mensuales o anteriores de 28 días. Esto significa que tendrás que esperar mucho tiempo después de realizar cualquier cambio para 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 comprometidos, usuarios de un grupo experimental en particular, etcétera).
• Las herramientas basadas en CrUX pueden decirte cuál es tu rendimiento, pero no por qué. Con las herramientas de estadísticas, puedes enviar datos adicionales para rastrear y depurar problemas.

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

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

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

Medir

La medición del rendimiento siempre ha sido posible con Google Analytics y el uso de métricas personalizadas, pero hay algunas funciones nuevas en Google Analytics 4 (GA4) que los desarrolladores en particular deberían entusiasmar.

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

Si bien la interfaz web de Google Analytics cuenta con herramientas de análisis potentes, es difícil superar la potencia y la flexibilidad del acceso a 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 realizar las siguientes tres tareas:

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

Analiza

Una vez que esté todo configurado, 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', 'FID', 'CLS')

Aquí te mostramos una vista previa de los resultados de esa consulta:

Consulta datos de Métricas web

Antes de comenzar a consultar los datos de eventos de las Métricas web, es importante comprender cómo se agregan los datos.

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

En el caso de los eventos de Métricas web, 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 JavaScript de web-vitals para enviar datos a Google Analytics 4 incluye el envío de un ID único por métrica, de modo que puedes usar la siguiente consulta y limitar los resultados solo al último valor recibido para 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
)

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

En las siguientes secciones, se muestran algunos ejemplos de consultas comunes de Métricas web que puedes ejecutar.

Consultas de ejemplo

Los valores de LCP, FID 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', '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 los valores individuales de LCP, 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', '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

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

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

Depuración

Las consultas anteriores muestran cómo consultar los datos de las métricas web, lo cual es útil para comprender tu rendimiento actual y su evolución en el tiempo. Pero ¿qué puedes hacer si tu rendimiento es peor de lo esperado, pero no sabes con certeza por qué?

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

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

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.

Consultas de ejemplo

Elementos principales que contribuyen a CLS

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

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

En la siguiente consulta, se enumerarán las páginas de peor a mejor según su CLS en el percentil 75, 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

Saber qué elementos de la página cambian debería facilitar la identificación y la solución de la causa raíz del problema.

Ten en cuenta que es posible que los elementos informados aquí no sean los mismos que ves cambiar cuando depuras las páginas de forma local, por lo que es tan importante capturar estos datos en primer lugar. Es muy difícil arreglar cosas que no notas que son problemas.

Depura otras métricas

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

WHERE metric_name = 'CLS'
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 web esenciales.

Visualizar

Obtener estadísticas puede ser difícil con solo mirar los resultados de la consulta. Por ejemplo, la siguiente consulta enumera los valores diarios del percentil 75 para el 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', '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

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

En esos casos, visualizar los datos puede ayudarte a obtener información más rápidamente.

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 y paneles de datos que es gratuita. Para visualizar los resultados de la 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 los campos que deseas visualizar, elegir los tipos de gráficos, configurar filtros y crear gráficos ad hoc para realizar un análisis visual rápido. 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, es posible que desees consultar varios gráficos en un panel interactivo para obtener una vista más integral o poder desglosar los datos. Tener un panel útil significa que no necesitas escribir consultas ni generar gráficos de forma manual cada vez que desees analizar tus métricas.

Puedes crear un panel en Looker Studio con el conector nativo de BigQuery. Para hacerlo, 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 deseas 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 de forma gratuita. 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 analizan en esta publicación, a menos que uses un conjunto de datos muy grande o consultes el conjunto de datos 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 deseas supervisar con regularidad diferentes métricas mediante un panel interactivo rápido, te sugerimos realizar un procesamiento previo y materializar tus datos de métricas web, a la vez que usas las funciones de eficiencia de BigQuery, como la partición, el agrupamiento en clústeres y el almacenamiento en caché.

Con la siguiente secuencia de comandos, se procesarán previamente tus datos de BigQuery (tabla de origen) y se creará una tabla materializada (tabla de destino). Cuando usas esta consulta para tu propio conjunto de datos, es posible que también desees definir un período para la tabla de origen a fin de 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', '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');

Este conjunto de datos materializado tiene varias ventajas:

• La estructura de datos se acopla y es más fácil consultarla.
• Solo retiene los eventos de Métricas web del conjunto de datos original de GA4.
• El ID de sesión, el tipo de usuario (nuevo en comparación con los recurrentes) y la información de participación de la sesión están disponibles directamente en las columnas.
• La tabla está partitioned por fecha y agrupada en clústeres por nombre de métrica. Por lo general, esto reduce la cantidad de datos procesados para cada consulta.
• Dado que no necesitas usar comodines para consultar esta tabla, los resultados de la consulta se pueden almacenar en caché por hasta 24 horas. Esto reduce los costos por repetir la misma consulta.
• Si usas el motor de BI de BigQuery, puedes ejecutar operadores y funciones de SQL optimizados en esta tabla.

Puedes consultar esta tabla materializada directamente 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 del proyecto de facturación de BigQuery. Luego de hacer clic en Conectar, Looker Studio creará un nuevo panel con plantilla y lo asociará con tus datos. Puedes editar, modificar y compartir el panel como desees. Si creas un panel una vez, no tienes que volver a visitar el vínculo del conector, a menos que desees crear varios paneles de diferentes conjuntos de datos.

Navega por el panel

Mientras navegas por el panel, puedes ver las tendencias diarias de las métricas de Métricas web y cierta información de uso de tu sitio web, como los usuarios y las 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 y el recuento de usuarios según diferentes métricas comerciales 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. Sin embargo, 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 mediante el diagrama de dispersión de la tabla Ruta de la página, puedes desglosar aún más el área del problema si observas 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 más con el conjunto de datos, podrás editar el panel y agregar tus propios gráficos para un análisis más detallado y orientado. 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 anteriormente 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 con los datos nuevos.
• Une datos de origen (p.ej., CRM) para obtener estadísticas de la empresa. En la tabla materializada, puedes agregar user_id como 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.
• Informa la versión de tu sitio o app como parámetro en los datos que envías a Google Analytics y agrégalo como una columna en la tabla materializada. Luego, puedes agregar esos datos de la versión como una dimensión a tus gráficos para facilitar ver cómo los cambios de la versión afectan el rendimiento.
• Si esperas un uso significativamente alto del conjunto de datos a través de una consulta directa o el panel, puedes intentar usar la versión pagada de BigQuery BI Engine.

Resumen

En esta publicación, se abordaron los conceptos básicos del uso de 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 sencilla posible.

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 si las métricas de rendimiento y las métricas empresariales están en el mismo sistema. Google Analytics y BigQuery lo hacen posible.
• La exportación de BigQuery de datos sin procesar de Google Analytics te brinda un potencial ilimitado para realizar análisis detallados y personalizados mediante un lenguaje de consulta que probablemente ya conozcas.
• Google cuenta con varias APIs y herramientas de visualización, como Looker Studio, que te brindan la libertad de compilar tus informes de la forma exacta en que quieres que se creen.