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 exportarlos para analizarlos en BigQuery y Looker Studio.

Minhaz Kazi
Minhaz Kazi
X GitHub
Philip Walton

Google ofrece varias herramientas: Búsqueda Consola, PageSpeed Insights (PSI) y la experiencia del usuario de Chrome Denunciar (CrUX), que les permite a los desarrolladores ver el rendimiento de sus sitios en comparación con Core Web Métricas para sus usuarios reales en la .

Estas herramientas son muy útiles porque brindan una vista de alto nivel de la rendimiento del usuario real y no requiere ninguna configuración para comenzar a usarlos.

Sin embargo, existen algunas razones importantes por las que no desea confiar en estas solo para medir el rendimiento de tu sitio:

  • Las herramientas basadas en CrUX informan los datos por períodos mensuales o de 28 días anteriores. Esto significa que tendrás que esperar mucho tiempo después de realizar cualquier cambio antes de puedan ver los resultados.
  • Las herramientas basadas en CrUX solo se pueden segmentar por una cantidad limitada de dimensiones, como las siguientes: el país, el tipo de conexión y la categoría del dispositivo (computadoras de escritorio o dispositivos móviles). No puedes segmentar los datos por dimensiones específicas para tu empresa (por ejemplo, participación usuarios, usuarios de un grupo experimental particular, etc.).
  • Las herramientas basadas en CrUX pueden decirte cuál es tu rendimiento, pero no te indican te por qué. Con las herramientas de estadísticas, puedes enviar datos adicionales para realizar un seguimiento errores y depurar errores.

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

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

Captura de pantalla del informe del Conector de métricas web

Captura de pantalla del informe del Conector de métricas web

Si deseas obtener un resumen visual de todos los pasos descritos aquí, consulta nuestra charla de Google I/O 2021:

Medir

Siempre hemos podido medir el rendimiento con Google Analytics usando métricas personalizadas, pero hay algunas funciones nuevas de Google Analytics 4 (GA4) que los desarrolladores sobre todo debería estar emocionado.

Si bien la interfaz web de Google Analytics cuenta con herramientas de análisis eficaces, el poder y la flexibilidad del acceso a datos de eventos sin procesar usando una consulta un lenguaje de programación que probablemente ya conozcas.

Para comenzar a medir las Métricas web esenciales con Google Analytics 4 y BigQuery, sigue estos pasos: debes hacer tres cosas:

  1. Cómo crear una cuenta de Google Analytics 4 propiedad y una Proyecto de BigQuery.
  2. Habilita la exportación a BigQuery. en la configuración de tu propiedad de Google Analytics, por lo que todos los datos que recibas se automáticamente en las tablas de tu proyecto de BigQuery.
  3. Agrega el código JavaScript web-vitals. en tu sitio para que puedas medir las métricas de Métricas web esenciales y enviar los datos a Google Analytics 4, incluidos los datos de atribución.

Analizar

Cuando termines, deberías ver que los datos de eventos se propagan en 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')

Aquí hay una vista previa de los resultados de esa consulta:

Datos de eventos de Métricas web en BigQuery

Consulta datos de Métricas web

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

El aspecto más importante es que, en algunos casos, varios eventos puede ser recibidos para la misma métrica, en la misma página. Esto puede suceder si 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 es siempre el más preciso, por lo que antes de realizar cualquier análisis, es importante filtrar solo por esos valores. El fragmento de código que proporciona la biblioteca JavaScript web-vitals al que se deben enviar los datos Google Analytics 4 incluye enviar un ID único por métrica, de modo que puedes usar el siguiente consulta para limitar los resultados solo al último valor recibido de cada ID de la 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 búsquedas a las que se hace referencia en esta publicación comenzarán con esta subconsulta.

Consultas de ejemplo

En las siguientes secciones, se muestran ejemplos de consultas comunes de Métricas web que puedes que se quiere 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 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', '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

# 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

Las consultas anteriores muestran cómo consultar los datos de métricas web, lo cual es útil. para comprender su rendimiento actual y sus tendencias a lo largo del tiempo. Sin embargo, ¿qué puede hacer si su rendimiento es peor de lo esperado, pero no está seguro? ¿por qué?

Saber cuáles son tus puntuaciones no es útil si no puedes realizar alguna acción y solucionar los problemas.

El rendimiento de la depuración en el campo explica cómo puedes enviar información de depuración adicional con tus datos de Analytics. Si sigue las instrucciones que se detallan en esa publicación, deberías ver que información de seguridad también aparecen en BigQuery.

Consultas de ejemplo

Las siguientes consultas muestran cómo usar el parámetro del evento debug_target para ayudar para identificar la causa raíz de los problemas de rendimiento.

Principales elementos que contribuyen a CLS

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

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

La siguiente consulta mostrará una lista de las páginas de peor a mejor según su CLS en el 75.o 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 de la consulta para los elementos principales que contribuyen a CLS

Saber qué elementos de la página están cambiando debería facilitar mucho para identificar y solucionar la causa raíz del problema.

Tenga en cuenta que los elementos que se informan aquí podrían no ser los mismos que notas cambios cuando depuras tus páginas de manera local, motivo por el cual es importante capturar estos datos en primer lugar. Es muy difícil arreglar las cosas que no sabes que son problemas.

Cómo depurar otras métricas

La consulta anterior muestra los resultados de la métrica CLS, pero es exactamente igual. se puede usar para generar informes sobre los objetivos de depuración para INP y LCP. Justo Reemplaza la cláusula WHERE por la métrica relevante para depurar:

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

Una vez más, puedes consultar Rendimiento de la depuración en para obtener instrucciones sobre cómo recopilar y enviar información de depuración para cada una de las métricas de Core Web Vitals

Visualizar

Obtener estadísticas con solo mirar los resultados de la consulta puede ser un desafío solos. Por ejemplo, la siguiente consulta enumera los valores diarios del percentil 75 para LCP del 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 por mirando los datos.

Resultados de la consulta del valor de la métrica diaria

En esos casos, visualizar los datos puede ayudarte a obtener estadísticas 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 los datos a Looker Studio. Looker Studio es una herramienta de visualización de datos y una herramienta de panel de control que es de uso gratuito. Para visualizar los resultados de tu consulta, Después de ejecutar tu consulta en la IU de BigQuery, haz clic en el botón Explorar datos y selecciona Explorar con Looker Studio.

Opción Explorar con Looker Studio en BigQuery

Con esta acción, se creará un vínculo directo de BigQuery a Looker Studio en la exploración. vista. En esta vista, puedes seleccionar los campos que deseas visualizar, elegir tipos de gráficos, filtros de configuración y creación de gráficos ad hoc para 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 Valores de LCP a lo largo del tiempo:

Gráfico de líneas de valores diarios de LCP en Looker Studio

Con este vínculo directo entre BigQuery y Looker Studio, puedes crear gráficos a partir de cualquiera de tus consultas y hacer análisis visuales. Sin embargo, si quieres hacer un análisis adicional, es posible que veas varios gráficos un panel interactivo para obtener una vista más integral o desglosar en los datos. Tener un panel útil significa que no tienes que escribir consultas y generar gráficos manualmente cada vez que quieras analizar tus métricas.

Puedes crear un panel en Looker Studio con la herramienta nativa de BigQuery conector. Para ello, sigue estos pasos: navega a datastudio.google.com, crea una nueva la fuente de datos, selecciona el conector de BigQuery y elige el conjunto de datos que deseas trabajar con:

Usa el conector nativo de BigQuery en Looker Studio

Materializa datos de métricas web

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

Puedes usar la zona de pruebas de BigQuery sin cargo. Con la API de BigQuery nivel de uso gratuito, el primer TB de datos de consultas que se procesan por mes es gratis. Para los métodos de análisis discutimos en esta publicación, a menos que uses un conjunto de datos muy grande o consultas al conjunto de datos con regularidad, deberías poder mantenerte este límite gratuito todos los meses. Pero si tienes un sitio web con mucho tráfico y quieres supervisamos periódicamente diferentes métricas con un rápido panel interactivo, sugerir el procesamiento previo y la materialización de los datos de métricas web y, al mismo tiempo, aprovechar 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 los datos de BigQuery (tabla de origen) y crear una tabla materializada (tabla de destino). Cuando use esta consulta para su propia en un conjunto de datos, también puedes definir un período para que la tabla 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.
  • ID de sesión, tipo de usuario (nuevo o recurrente) y la información de la participación de la sesión está directamente disponible en columnas.
  • La tabla es particionada por fecha y agrupado por nombre de métrica. Esto suele reducir la cantidad de datos procesados para cada para cada búsqueda.
  • Dado que no necesitas usar comodines para consultar esta tabla, los resultados de la consulta pueden se almacenan en caché por hasta 24 horas. Esto reduce los costos por repetir el mismo para cada búsqueda.
  • Si usas el motor de BI de BigQuery, puedes ejecutar funciones SQL optimizadas y operadores en este desde una tabla de particiones.

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

Como crear un panel desde cero lleva mucho tiempo, desarrollamos un que creará un panel de plantilla para ti. Primero, asegúrate de materializó la tabla de Métricas web con la consulta anterior. Luego, accede al Conector de métricas web para Looker Studio con este vínculo: goo.gle/web-vitals-connector

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

Pantalla de autorización del conector de métricas web

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

Mientras navegas por el panel, puedes ver las tendencias diarias de las Métricas web y cierta información de uso de tu sitio web, como usuarios y sesiones, en la pestaña Resumen.

En la pestaña Análisis de usuarios, puedes seleccionar una métrica y, luego, obtener un desglose de el percentil de métricas y el recuento de usuarios según los diferentes usos métricas.

La pestaña Análisis de la ruta de la página te ayudará a identificar las áreas problemáticas en la sitio web. Aquí, puedes elegir una métrica para ver la descripción general. Pero también puedes ver Mapa de dispersión de todas las rutas de la página con el valor de percentil en el eje y y el registro contar en el eje X. El mapa de dispersión puede ayudar a identificar páginas que tienen una a los valores de métrica esperados. Una vez que selecciones las páginas con la función gráfico de la tabla Ruta de la página, puedes desglosar el área con más detalles visualizando la tabla Debug Target.

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, puedes editar el panel y agregar tus propios gráficos para obtener un análisis más completo y específico. Para que el panel sea más útil, puedes seguir estos pasos:

  • Configura una consulta programada en BigQuery para obtener datos actualizados. La materialización la consulta que ejecutamos antes solo toma una instantánea de tus datos en ese momento. Si y quieres mantener tu panel actualizado con datos nuevos, puedes ejecutar una que se ejecutará todos los días y agregarás tu tabla materializada con los nuevos de datos no estructurados.
  • Une datos de origen (p.ej., CRM) para obtener estadísticas empresariales. En la fase puedes agregar user_id como una columna separada. Esto te permitirá unirte a tu de los datos de origen. Si tus datos de origen aún no están en BigQuery, puedes cargar los datos o usan una cuenta de datos federados fuente.
  • Informa la versión de tu sitio o app como un parámetro en los datos que envías a Google Analytics y agrégalos como una columna en la tabla materializada. Luego, puedes agregar esos datos de versiones como una dimensión en sus gráficos para que sea más fácil ver los cambios de versión afectan el rendimiento.
  • Si esperas un uso significativamente alto del conjunto de datos a través de consulta o el panel, puedes intentar usar la versión pagada de BigQuery BI Engine.

Resumen

En esta publicación, se trataron los conceptos básicos de cómo usar Google Analytics 4 y BigQuery para medir y depurar el rendimiento con datos de usuarios reales recopilados en el campo. Integra también se explicó cómo crear informes y paneles automatizados con Looker Studio y el conector de métricas web visualizar los datos de la manera 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 cuando tus métricas de rendimiento y tu empresa están en el mismo sistema. Google Analytics y BigQuery hacen que esto como sea posible.
  • La exportación de datos sin procesar de Google Analytics desde BigQuery te brinda un potencial ilimitado para un análisis personalizado y detallado con un lenguaje de consulta que probablemente ya conozcas.
  • Google tiene varias APIs y herramientas de visualización, como Looker Studio, que brindan la libertad de crear sus informes exactamente como desea. construyen.