Nuestro panel decía que el miniprograma estaba sano. Las cargas iban rápido, la tasa de errores era plana y la consola del anfitrión daba la razón a ambas cosas. Mientras tanto, soporte no dejaba de reenviar capturas de un checkout que nunca terminaba. Pasamos dos días buscando un bug que no aparecía en ninguna de nuestras gráficas, porque la cifra que lo habría explicado —cuánto tardó el anfitrión en cedernos el control— jamás nos la expuso.
Mira, un anfitrión es una plataforma, no un instrumento. Te da las métricas que decidió darte, y la distancia entre esas métricas y lo que vivió una persona se llevó casi todo nuestro tiempo de depuración. El primer trabajo no es recoger más datos: es admitir con honestidad qué no puedes ver.
Qué puedes medir de verdad
Desde que corre tu primera línea de JavaScript, estás en terreno propio. Errores, rechazos sin capturar, tus propios tiempos de petición, los pasos de tu embudo: todo eso se captura con un SDK del lado cliente, se etiqueta con release y anfitrión y se manda a un solo sitio. Eso es monitorización de usuarios reales, y es justo la parte que más equipos dejan sin construir porque la consola del anfitrión ya parece convincente.
Antes de esa primera línea, estás adivinando. El anfitrión arrancó, resolvió el paquete, levantó un runtime y solo entonces llamó a tu código. Nada de eso se te cronometra. Puedes medir desde tu punto de entrada hasta el primer pintado y ponerle un nombre honesto, pero llamarlo «tiempo de arranque» es mentir: la parte más lenta de un arranque en frío suele ocurrir antes de que existieras. Vimos un timeout en el checkout acabar en un proxy del anfitrión al que no teníamos acceso, mientras nuestra gráfica tan bonita mostraba una carga interna de lo más rápida.
| Métrica | Se puede conseguir | Alternativa | Dónde engaña |
|---|---|---|---|
| Tiempo de entrega del anfitrión, antes de tu código | No, desde la capa JS no | Medir de la entrada al primer pintado, con un nombre preciso | Un número interno rápido tapa un arranque lento del anfitrión |
| Errores JS y rechazos sin capturar | Sí, con un SDK de errores | Capturar con breadcrumbs y etiqueta de release por anfitrión | Las trazas cambian entre runtimes; no las fusiones a ciegas |
| Latencia de tus peticiones | Sí, medida en cliente | Cronometrar cada fetch de extremo a extremo | DNS y el proxy del anfitrión quedan fuera de la medición |
| Pasos del embudo de negocio | Sí, si los instrumentas | Definir eventos una vez y emitirlos en cada anfitrión | La analítica del anfitrión y tu embudo nunca cuadrarán del todo |
| Memoria y fotogramas | En parte, y varía por anfitrión | Muestrear tareas largas y fotogramas perdidos desde JS | Los paneles de la plataforma usan definiciones distintas a las tuyas |
| Sesiones sin cuelgue | Del anfitrión, si la publica | Comparar con tus propios límites de sesión | Su sesión y la tuya empiezan en momentos distintos |
Dónde los números se encarecen o engañan
Hablemos primero de dinero. RUM con fidelidad total sobre un miniprograma con tráfico real son muchísimos eventos, y la factura no es el único coste: los payloads compiten con el presupuesto de primera carga que intentas proteger. Así que muestreas. Y en cuanto muestreas, los fallos raros que más necesitas ver son justo los que más fácil se caen. Nosotros mantenemos los eventos de error al completo y muestreamos solo los de timing rutinario. Es una decisión deliberada, no un valor por defecto que recomendemos a todo el mundo.
La privacidad es la siguiente restricción, y no se negocia. Cualquier cosa que identifique a una persona, reconstruya un recorrido por un formulario o deje huella del dispositivo necesita base legal y una ventana de retención corta. La forma más fácil de equivocarse es registrar un payload entero porque venía bien durante la depuración. Todos lo hemos hecho. No debe quedarse en producción.
Y está la trampa de comparar. Dos anfitriones te darán dos cifras con el mismo nombre y definiciones distintas: inicio de sesión, usuario activo, incluso qué cuenta como página. Ponlas una al lado de la otra en una sola gráfica y habrás fabricado una tendencia a partir de vocabulario. Nosotros mantenemos paneles por anfitrión y nos negamos a dibujar una sola línea que las cruce. Tampoco leas una métrica de plataforma como métrica de usuario: que la plataforma diga que su app abrió bien no dice nada de si alguien llegó a pagar.
Construye el embudo de tu lado
Así que dejamos de intentar reconstruir el panel del anfitrión y trazamos una raya por la mitad. A un lado, lo que es nuestro: nuestros eventos, nuestros errores y nuestros tiempos desde la primera línea de código en adelante, definidos una vez y emitidos igual en cada anfitrión. Al otro, lo que solo podemos inferir. Esa raya está ahora en el manual de guardia, y es lo primero que lee quien llega nuevo.
Cuando entra un ticket, miramos nuestro embudo antes que los números de la plataforma. No porque la plataforma se equivoque, sino porque responde a otra pregunta. Un anfitrión puede decirte que su app se abrió. No puede decirte si alguien terminó el checkout. El hueco entre esas dos frases es donde vive de verdad este trabajo.
Fuentes
- MDN — Performance API — las primitivas de tiempo que puedes leer desde tu propio código.
- web.dev — guía práctica de métricas de usuarios reales y datos de campo.
- Sentry — cómo se aplican de verdad la agregación de errores y el muestreo.
- Documentación del framework de Mini Programs de WeChat — qué interfaces de datos expone el anfitrión y qué huecos deja.