crea tu propio validador de eventos de datalayer con google cloud functions, GTM y firestore

Imagina que estás construyendo un puente. Este puente no es uno cualquiera; es el enlace entre la recopilación de datos de tu sitio web o aplicación (los vehículos) y la calidad de los análisis que puedes realizar (el destino). Pero hay un problema: no todos los vehículos que cruzan este puente son aptos para el viaje. Aquí es donde la validación de eventos del DataLayer se convierte en nuestra caseta de peaje, asegurándonos de que solo los vehículos (datos) adecuados hagan el viaje.

Configurando el entorno

Antes de empezar a construir, necesitas asegurarte de tener todas las herramientas y materiales. Esto incluye una cuenta de Google Cloud Platform, acceso a Google Tag Manager, y un entendimiento básico de JavaScript y Python. Es como preparar el terreno y tener listos los planos antes de iniciar la construcción del puente.

Paso 1: Crear una Cloud Function

Este paso es como diseñar el sistema de peaje para nuestro puente. Queremos asegurarnos de que se cobre a los vehículos correctos y de la manera más eficiente posible. Al crear una Cloud Function, estás estableciendo la base de este sistema de peaje. La función actuará como un filtro, dejando pasar solo los datos que cumplen con ciertos criterios.

1. Configuración Inicial: Imagina que estás eligiendo el lugar para el peaje. Necesitas asegurarte de que sea accesible y que el flujo del tráfico (los datos) pueda gestionarse eficientemente. Aquí es donde configuras tu Cloud Function en Google Cloud Platform, seleccionando Python como tu entorno de ejecución, debido a su versatilidad y facilidad de uso.
2. Desplegar el Código: Piensa en esto como en construir la infraestructura física del peaje. El código que implementes será como las barreras que suben y bajan, permitiendo o denegando el paso basado en si los vehículos cumplen con las normas establecidas.

Paso 2: Manejo de CORS y Validación de JSON

Al construir un puente, uno de los aspectos más importantes es asegurarse de que sea seguro y accesible solo para aquellos que tienen permiso para cruzarlo. En el mundo digital, esto se traduce en implementar políticas de seguridad que regulen cómo y quién puede enviar información a tus servicios. Aquí es donde entra en juego el manejo de CORS y la validación de JSON en nuestra construcción del validador de eventos de DataLayer.

CORS: Las Barreras del Puente

Imagina el CORS (Cross-Origin Resource Sharing) como un sistema de barreras en tu puente. Estas barreras están diseñadas para abrirse solo para vehículos autorizados provenientes de ciertas rutas. En el contexto de una Cloud Function, CORS asegura que solo las solicitudes de orígenes conocidos y permitidos puedan comunicarse con tu función. Sin esta configuración, estarías exponiendo tu puente a un flujo potencialmente caótico de tráfico de todas direcciones, lo cual podría ser peligroso y contraproducente.

La configuración de CORS implica definir un conjunto de cabeceras HTTP que determinan cómo se comparten los recursos entre diferentes orígenes. Por ejemplo, si solo deseas permitir solicitudes de tu propio sitio web, configurarías las cabeceras de CORS para aceptar solicitudes solo de ese dominio. Este proceso es como programar las barreras de tu puente para reconocer y permitir el paso solo a los vehículos que vienen de rutas aprobadas.

Validación de JSON: Inspección de Seguridad

La validación de JSON, por otro lado, es como la inspección de seguridad en el peaje. Cada vehículo (en este caso, solicitud) que llega al puente lleva consigo cierta información que necesita ser verificada antes de permitirle el paso. La validación de JSON asegura que esta información esté en el formato correcto y contenga todos los elementos necesarios para cruzar el puente.

Cuando una solicitud llega a tu Cloud Function, la validación de JSON examina los datos enviados para asegurarse de que están estructurados correctamente y son lo que esperabas recibir. Si los datos no pasan la inspección (por ejemplo, si faltan elementos críticos o el formato es incorrecto), la solicitud se rechaza, similar a cómo un vehículo que no pasa la inspección de seguridad se le niega el acceso al puente.

Implementar tanto CORS como la validación de JSON en tu Cloud Function es esencial para mantener la seguridad y la integridad de los datos que cruzan el «puente» de tu sistema de validación de eventos de DataLayer. Al asegurarte de que solo las solicitudes autorizadas y correctamente formateadas puedan pasar, estás protegiendo la calidad y la confiabilidad de los datos que recopilas y analizas.

from flask import Flask, escape, jsonify, request

def validate_events(request):
    if request.method == 'OPTIONS':
        # Configura tus cabeceras de CORS para preflight request
        headers = {
            'Access-Control-Allow-Origin': '*',  # Permite dominios específicos según tu política de CORS
            'Access-Control-Allow-Methods': 'POST',
            'Access-Control-Allow-Headers': 'Content-Type',
            'Access-Control-Max-Age': '3600'
        }
        return ('', 204, headers)

    # Aplica las cabeceras de CORS a todas las respuestas
    headers = {'Access-Control-Allow-Origin': '*'}

    # Validación de JSON
    request_json = request.get_json(silent=True)
    if not request_json or 'event_id' not in request_json:
        return jsonify({"message": "Petición inválida. Se requiere JSON con 'event_id'."}), 400, headers
    
    # Continúa con la lógica de validación aquí...

Este código es un ejemplo de cómo podrías configurar el manejo de CORS y la validación de JSON en tu función. Actúa como las barreras y la inspección de seguridad, asegurando que solo las solicitudes adecuadas y bien formadas tengan acceso al puente, manteniendo la seguridad y la eficiencia de tu sistema de validación de eventos de DataLayer.

Con el paso 2 completado, hemos establecido una base sólida para nuestra Cloud Function, asegurando que solo las solicitudes apropiadas y correctamente estructuradas puedan proceder. Este es un paso crucial en la construcción de un sistema de validación efectivo y seguro.

Paso 3: Conectar con Firestore para Almacenar Reglas de Validación

Tras asegurar nuestro puente con un efectivo sistema de barreras (CORS) y una rigurosa inspección de seguridad (validación de JSON), el siguiente paso es construir la oficina de administración del puente, donde se almacenan los registros de todos los vehículos autorizados y sus características. En nuestro caso, esta oficina es Firestore, la base de datos NoSQL de Google Cloud, donde almacenaremos las reglas de validación para cada evento de DataLayer que queremos verificar.

Firestore: El Registro Central

Imagina Firestore como un gran archivo o registro central donde se almacenan los detalles de cada vehículo (evento de DataLayer) que tiene permiso para cruzar el puente. Cada registro incluye información específica, como el tipo de vehículo, el peso permitido, y otras características únicas que deben ser verificadas en el peaje (validación del evento).

Para comenzar, necesitas crear una colección en Firestore llamada validation-rules. Piensa en esta colección como un gran archivador, donde cada cajón (documento) representa un evento específico de DataLayer con sus reglas de validación correspondientes. La estructura podría verse así:

• Colección: validation-rules
  • Documento: event_id_1
    • Campo: event_type = «click»
    • Campo: category = «button»
    • Campo: action = «purchase»
  • Documento: event_id_2
    • Campo: event_type = «view»
    • Campo: category = «page»
    • Campo: action = «landing»

Conectando la Cloud Function con Firestore

Una vez que tu registro de validación está establecido en Firestore, el siguiente paso es conectar tu Cloud Function a este registro. Esto es equivalente a equipar tu oficina de administración con teléfonos y computadoras para que el personal del peaje (tu Cloud Function) pueda consultar rápidamente si un vehículo tiene permiso para cruzar.

La conexión se realiza utilizando el SDK de Firestore para Python. Primero, asegúrate de haber agregado google-cloud-firestore a tus dependencias. Luego, en tu Cloud Function, inicializa el cliente de Firestore y consulta el documento correspondiente al event_id recibido en el evento de DataLayer:

google.cloud import firestore

def validate_events(request):
    # Asumiendo que la validación de CORS y JSON ya se ha realizado
    
    # Inicializa el cliente de Firestore
    db = firestore.Client()

    # Extrae el event_id del evento de DataLayer
    request_json = request.get_json()
    event_id = request_json['event_id']

    # Consulta Firestore para obtener las reglas de validación
    doc_ref = db.collection('validation-rules').document(event_id)
    doc = doc_ref.get()

    if not doc.exists:
        # Si no existe un documento para ese event_id, rechaza el evento
        return jsonify({'message': 'Regla de validación no encontrada para event_id: {}'.format(event_id)}), 400
    else:
        validation_rule = doc.to_dict()
        # Continúa con la lógica de validación específica...

Este código actúa como el enlace entre tu Cloud Function y Firestore, permitiéndote recuperar las reglas específicas de validación para cada evento. Es como si, cada vez que un vehículo se presenta en el peaje, el personal llamara a la oficina de administración para verificar si cumple con las normativas registradas en el archivo.

Beneficios de Utilizar Firestore

Usar Firestore como el «archivo» de tus reglas de validación ofrece varios beneficios, como:

• Flexibilidad: Puedes actualizar las reglas de validación en tiempo real sin necesidad de modificar o redeployar tu Cloud Function.
• Escalabilidad: Firestore maneja automáticamente el crecimiento de tus datos, permitiendo que tu sistema de validación escale junto con el tráfico de tu aplicación o sitio web.
• Fiabilidad: Al ser un producto de Google Cloud, Firestore ofrece una alta disponibilidad y durabilidad, asegurando que tus reglas de validación estén siempre accesibles cuando las necesites.

Al final de este paso, has logrado establecer una conexión vital entre tu sistema de validación (la Cloud Function) y el registro central de reglas de validación (Firestore). Esto te permite una gestión eficiente y dinámica de las reglas, facilitando un proceso de validación robusto y adaptable.

Paso 4: Validar el Evento

Habiendo establecido nuestras políticas de CORS y asegurado que solo recibimos solicitudes bien formadas (gracias a nuestra validación de JSON), es momento de entrar en el corazón de nuestra operación: la validación del evento en sí. Este proceso es comparable a la inspección final en nuestra metáfora del puente, donde cada vehículo (evento) es meticulosamente revisado para asegurar que cumpla con todas las normativas antes de permitirle continuar su viaje.

La Inspección Final: Validación Detallada

En este punto, cada solicitud ha llegado a la caseta de peaje, listo para ser inspeccionado. Esta inspección no es superficial; cada parte del vehículo (datos del evento) se comprueba contra un estándar preestablecido (las reglas de validación almacenadas en Firestore). Es un proceso detallado y meticuloso, donde la exactitud es clave.

Imagina cada regla de validación como un criterio específico de seguridad para el puente —peso máximo, número de ejes, tipo de carga, etc.— que cada vehículo debe cumplir. En el contexto de nuestra Cloud Function, estos criterios se traducen en los campos y valores específicos que cada evento de DataLayer debe contener para considerarse válido.

Implementación de la Validación

La implementación práctica de este paso implica recuperar las reglas de validación pertinentes de Firestore, basadas en el event_id que cada solicitud trae consigo, y luego comparar meticulosamente estos criterios con los datos del evento presentados. Aquí es donde el diseño y la estructura de tu Firestore juegan un papel crucial, facilitando una recuperación rápida y eficiente de las reglas de validación.

google.cloud import firestore
from flask import jsonify

def validate_event(request_json):
    db = firestore.Client()
    event_id = request_json['event_id']
    doc_ref = db.collection('validation-rules').document(event_id)
    doc = doc_ref.get()

    if not doc.exists:
        return jsonify({'message': f'Regla de validación no encontrada para event_id: {event_id}'}), 400

    validation_rule = doc.to_dict()

    # Comparar cada campo del evento con las reglas de validación
    if all(request_json.get(key) == value for key, value in validation_rule.items()):
        return jsonify({'message': f'Validación exitosa para event_id: {event_id}'}), 200
    else:
        return jsonify({'message': f'Validación fallida para event_id: {event_id}'}), 400

En este ejemplo, la función validate_event actúa como nuestro inspector final. Recupera las reglas de validación basadas en el event_id proporcionado, y luego compara estos criterios con los datos del evento. Si todos los campos coinciden con lo esperado, el evento es validado con éxito; de lo contrario, se rechaza.

La Importancia de la Precisión

La precisión en este paso es crucial. Al igual que en la inspección de un vehículo, pasar por alto incluso el detalle más pequeño puede resultar en fallos graves más adelante. De manera similar, permitir que un evento de DataLayer no validado pase a través de este proceso puede contaminar tus análisis con datos incorrectos o irrelevantes, llevando a conclusiones erróneas.

La validación detallada de eventos asegura que solo los datos de alta calidad fluyan a través de tu sistema, permitiéndote confiar en los análisis e informes generados a partir de estos datos. Como cualquier ingeniero o constructor te dirá, la integridad estructural de un puente depende de la atención meticulosa a cada detalle, y lo mismo se aplica a la integridad de tus sistemas de datos.

Con el paso 4 completado, hemos asegurado que nuestro «puente» no solo es seguro y accesible solo para los autorizados, sino que también garantiza que cada «vehículo» que pasa cumple con todos los criterios necesarios para asegurar un tránsito seguro y eficiente de los datos hacia su destino final. Este enfoque meticuloso hacia la validación de eventos es lo que sustenta la recopilación de datos confiable y precisa, fundamental para cualquier análisis de datos significativo.

Paso 5: Integración con Google Tag Manager (GTM)

Llegamos al último tramo de nuestro viaje: integrar el sistema de validación con Google Tag Manager (GTM). Imaginemos GTM como el sistema de control de tráfico que dirige a los vehículos hacia el puente, asegurándose de que tomen la ruta correcta y cumplan con los requisitos para el peaje. En nuestro contexto, GTM se encargará de enviar los eventos de DataLayer a nuestra Cloud Function para su validación, actuando como un intermediario entre tu sitio web y el sistema de validación.

Configuración en GTM

Para integrar GTM con nuestra Cloud Function, necesitamos crear un tag personalizado que dispare una solicitud HTTP a la función cada vez que ocurra un evento específico en nuestro sitio web. Este proceso es similar a instalar señales de tráfico y semáforos que guían a los vehículos directamente hacia el peaje, asegurándose de que sigan la ruta deseada y estén listos para la inspección.

1. Crear un Tag Personalizado: En GTM, crea un nuevo tag y selecciona «Tag personalizado HTML» como tipo. Este tag contendrá el código JavaScript necesario para enviar datos de eventos a tu Cloud Function.
2. Configurar el Disparador: Decide cuándo quieres que este tag se active. Esto puede basarse en una variedad de interacciones del usuario, como clics en botones, envíos de formularios o cargas de página. Estos disparadores son como los sensores en la carretera que detectan cuándo un vehículo se aproxima al peaje y activan el proceso de validación.
3. Escribir el Código JavaScript: Dentro de tu tag personalizado, escribe el código JavaScript que captura los datos del evento de DataLayer y los envía a tu Cloud Function a través de una solicitud HTTP POST. Aquí es donde preparas a los «vehículos» (datos del evento) para su inspección, asegurándote de que toda la información necesaria esté incluida y correctamente formateada antes de enviarla al «peaje» (Cloud Function).

<script>
  var eventData = {
      'event_id': '123',
      'event': 'select_content',
      'method': 'click',
      // aquí en realidad cogeríamos el evento y los parámetros de forma dinámica
  };

  var endpoint = 'https://us-central1-tu-proyecto.cloudfunctions.net/validate_events'; //a rellenar con el endpoint de tu cloud function

  fetch(endpoint, {
    method: 'POST',
    body: JSON.stringify(eventData),
    headers: {
      'Content-Type': 'application/json'
    },
  })
  .then(response => response.json())
  .then(data => console.log('Validación:', data))
  .catch(error => console.error('Error:', error));
</script>

4. Probar y Publicar: Antes de hacer que tu tag personalizado y disparadores estén activos, realiza pruebas exhaustivas para asegurarte de que los eventos se envían y validan correctamente. Una vez que estés satisfecho con los resultados, publica los cambios en GTM.

Conclusión: Construyendo Puentes hacia Datos de Calidad

A lo largo de este viaje, hemos explorado cómo construir un sistema robusto y eficiente para validar eventos de DataLayer, utilizando Google Cloud Functions, Firestore, y Google Tag Manager. Cada paso del proceso ha sido como construir un puente: desde asegurar los fundamentos con CORS y validación de JSON, pasando por establecer un sistema de registro en Firestore, hasta dirigir el tráfico correctamente con GTM y finalmente inspeccionar cada vehículo (evento) para asegurar su validez.

Este puente que hemos construido no es meramente una estructura física, sino un enlace crítico hacia la recopilación de datos de alta calidad. En el mundo del análisis web y el marketing digital, los datos de calidad son el fundamento sobre el cual se construyen todas las decisiones estratégicas. Al igual que un puente bien construido facilita el movimiento seguro y eficiente de personas y bienes, un sistema de validación de eventos de DataLayer bien diseñado asegura que los datos que recopilas son precisos, confiables y listos para ser analizados.

Reflexiones Finales

• Precisión en la validación: Al igual que la atención a los detalles es crucial en la construcción de puentes, la precisión en la validación de eventos de DataLayer es vital para asegurar la integridad de los datos. Un pequeño error o una omisión pueden llevar a conclusiones erróneas y decisiones mal informadas.
• Flexibilidad y adaptabilidad: Al igual que los puentes requieren mantenimiento y actualizaciones para servir a las necesidades cambiantes de una ciudad, tu sistema de validación debe ser flexible y capaz de adaptarse a las nuevas demandas del negocio y cambios en la estrategia de datos.
• Importancia de la integración: La integración fluida entre GTM y Cloud Functions, similar a la integración entre diferentes tramos de un puente, es esencial para mantener el flujo constante de datos. Una integración efectiva facilita la automatización del proceso de validación, ahorrando tiempo y recursos.

Al finalizar este tutorial, no solo has aprendido cómo establecer un sistema de validación para tus eventos de DataLayer, sino que también has ganado una comprensión más profunda de por qué la calidad de los datos es crucial y cómo asegurarla efectivamente. Como arquitectos de nuestros propios sistemas de datos, es nuestra responsabilidad construir puentes sólidos y confiables que conecten el mundo real con el análisis digital, permitiéndonos tomar decisiones basadas en información precisa y veraz.

Este sistema de validación de eventos de DataLayer es más que un conjunto de pasos técnicos; es una filosofía de cómo acercarse a los datos y el análisis. Al seguir esta guía, has puesto la piedra angular para asegurar que tu recopilación de datos sea tan confiable, segura y eficiente como los puentes que conectan ciudades y culturas alrededor del mundo.