Nosso painel dizia que o miniprograma estava saudável. Os carregamentos eram rápidos, a taxa de erros estava reta e o console do anfitrião concordava com os dois. Enquanto isso, o suporte não parava de encaminhar prints de um checkout que nunca terminava. Passamos dois dias caçando um bug que não aparecia em nenhum gráfico, porque o número que teria explicado tudo — quanto tempo o anfitrião levou para nos entregar o controle — nunca nos foi exposto.
Olha, anfitrião é plataforma, não é instrumento. Ele te dá as métricas que decidiu dar, e a distância entre essas métricas e o que a pessoa viveu levou quase todo o nosso tempo de depuração. O primeiro trabalho não é coletar mais dados: é ser honesto sobre o que você não enxerga.
O que dá para medir de verdade
A partir do momento em que sua primeira linha de JavaScript roda, você está em terreno próprio. Erros, rejeições não tratadas, os tempos das suas requisições, os passos do seu funil: tudo isso dá para capturar com um SDK do lado do cliente, marcar com release e anfitrião e mandar para um lugar só. Isso é monitoramento de usuários reais, e é justamente a parte que mais times deixam de construir porque o console do anfitrião já parece convincente.
Antes dessa primeira linha, você está chutando. O anfitrião iniciou, resolveu o pacote, subiu um runtime e só então chamou seu código. Nada disso é cronometrado para você. Dá para medir do seu ponto de entrada até a primeira pintura e dar um nome honesto, mas chamar isso de «tempo de inicialização» é mentira: a parte mais lenta de uma partida a frio costuma acontecer antes de você existir. Já vimos um timeout no checkout terminar num proxy do anfitrião que não enxergávamos, enquanto nosso gráfico bonitinho mostrava um carregamento interno rapidíssimo.
| Métrica | Dá para obter | Alternativa | Onde engana |
|---|---|---|---|
| Tempo de entrega do anfitrião, antes do seu código | Não, pela camada JS não | Medir da entrada até a primeira pintura, com nome preciso | Um número interno rápido esconde uma inicialização lenta do anfitrião |
| Erros JS e rejeições não tratadas | Sim, com um SDK de erros | Capturar com breadcrumbs e etiqueta de release por anfitrião | Os stacks mudam entre runtimes; não junte tudo às cegas |
| Latência das suas requisições | Sim, medida no cliente | Cronometrar cada fetch de ponta a ponta | DNS e o proxy do anfitrião ficam fora da medição |
| Passos do funil de negócio | Sim, se você instrumentar | Definir eventos uma vez e emitir em todo anfitrião | A analytics do anfitrião e seu funil nunca vão fechar exatamente |
| Memória e quadros | Em parte, e varia por anfitrião | Amostrar tarefas longas e quadros perdidos pelo lado JS | Os painéis da plataforma usam definições diferentes das suas |
| Sessões sem crash | Do anfitrião, se ele publicar | Comparar com seus próprios limites de sessão | A sessão dele e a sua começam em instantes diferentes |
Onde os números ficam caros ou enganam
Vamos falar de dinheiro primeiro. RUM com fidelidade total num miniprograma com tráfico real são muitíssimos eventos, e a conta não é o único custo: os payloads competem com justamente o orçamento de primeira carga que você tenta proteger. Então você amostra. E no instante em que amostra, as falhas raras que você mais precisava ver são as que mais fácil caem fora. Mantemos eventos de erro em captura cheia e amostramos só os de timing rotineiro. É uma troca deliberada, não um padrão que recomendamos a todo mundo.
Privacidade é a próxima restrição, e não é negociável. Qualquer coisa que identifique uma pessoa, reconstrua um caminho por um formulário ou tire impressão digital do aparelho precisa de base legal e de uma janela de retenção curta. O jeito mais fácil de errar é logar um payload inteiro porque era conveniente durante o debug. Todos já fizemos isso. Não deve ficar em produção.
E tem a armadilha da comparação. Dois anfitrões vão te dar dois números com o mesmo nome e definições diferentes: início de sessão, usuário ativo, até o que conta como página. Coloque os dois lado a lado num gráfico só e você fabricou uma tendência a partir de vocabulário. Mantemos painéis por anfitrião e nos recusamos a desenhar uma linha única atravessando os dois. Também não leia métrica de plataforma como métrica de usuário: a plataforma dizer que o app dela abriu bem não diz nada sobre alguém ter conseguido pagar.
Construa o funil do seu lado
Então paramos de tentar reconstruir o painel do anfitrião e traçamos uma linha no meio. De um lado, o que é nosso: nossos eventos, nossos erros e nossos tempos a partir da primeira linha de código, definidos uma vez e emitidos igual em todo anfitrião. Do outro, o que só podemos inferir. Essa linha está no runbook agora, e é a primeira coisa que quem chega novo lê.
Quando chega um ticket, olhamos nosso funil antes dos números da plataforma. Não porque a plataforma esteja errada, mas porque ela responde a outra pergunta. Um anfitrião consegue te dizer que o app dele abriu. Não consegue te dizer se alguém terminou o checkout. O vão entre essas duas frases é onde esse trabalho mora de verdade.
Fontes
- MDN — Performance API — as primitivas de tempo que você lê do seu próprio código.
- web.dev — guia prática de métricas de usuários reais e dados de campo.
- Sentry — como agregação de erros e amostragem funcionam na prática.
- Documentação do framework de Mini Programs do WeChat — quais interfaces de dados o anfitrião expõe e que buracos deixa.