Voltar para o Blog
Quest Log

Telemetria no Jogo: O Que Medir Para Tomar Decisão com Dados

Desenvolvedor olhando um painel com gráficos de retenção e funil de progressão de um jogo

Telemetria de jogos é coletar eventos pra decidir com dado, não no achismo. Veja que métricas importam, como instrumentar sem virar bagunça e LGPD.

Você passou meses fazendo um jogo, lançou, e agora a pergunta que não cala: as pessoas estão jogando do jeito que você imaginou? A telemetria de jogos existe pra responder isso sem você precisar adivinhar. Em vez de olhar o jogo da sua cadeira e supor que a fase três está num bom ritmo, você coleta os eventos que acontecem dentro do jogo, junta os dados e vê o comportamento real de quem está do outro lado da tela. É a diferença entre decidir no achismo e decidir com dado na mão.

Em mais de 20 anos fazendo software que cliente paga pra usar, a lição que mais se repete é essa: o que você acha que o usuário faz quase nunca é o que ele faz de verdade. Jogo não foge à regra. O jogador encontra caminhos que você não previu, trava em pontos que você achava fáceis e larga o jogo num momento que pra você fazia todo sentido continuar. Telemetria é o instrumento que mostra esse descompasso, e analytics de jogo é o trabalho de transformar essa informação em decisão.

O que é telemetria de jogos e por que ela importa

Telemetria é coletar eventos. Um evento é qualquer coisa que acontece e que você quer registrar: o jogador iniciou uma sessão, terminou a fase dois, morreu pela quinta vez no mesmo chefe, abriu a loja, fechou a loja sem comprar, comprou. Cada um desses momentos vira um registro com um nome e, se fizer sentido, alguns detalhes (qual fase, quanto tempo levou, quanta vida restava). O jogo manda esses registros pra um lugar onde você consegue olhar tudo junto depois.

Por que isso vale o esforço? Porque sem dado você está cego. Você lança, vê o número de downloads subir, fica feliz, e não tem ideia se a galera está chegando no final ou abandonando no tutorial. Os reviews contam um pedaço da história, mas só de quem se deu ao trabalho de escrever, que costuma ser a minoria mais animada ou mais irritada. O silêncio da maioria é o que telemetria revela. Ela transforma o "acho que está bom" num "sei onde estão os problemas".

Vale separar dois termos que andam juntos. Telemetria é a coleta, os eventos que o jogo dispara e envia. Analytics de jogo é a leitura, o ato de pegar esses eventos e tirar conclusão. Coletar sem analisar é encher um banco de dados que ninguém olha. Analisar sem ter coletado direito é inventar história. As duas pontas precisam existir, e a parte que dá trabalho de verdade não é coletar, é decidir o que vale a pena coletar.

As métricas de jogo que importam de verdade

Tem uma armadilha clássica aqui: medir tudo. Você sai instrumentando cada clique, cada movimento, cada frame, e acaba com um mar de dado que ninguém consegue ler. Comece pelo contrário. Pergunte primeiro o que você precisa saber, e só então decida que evento coletar. Estas são as métricas de jogo que respondem às perguntas certas pra quase todo projeto.

Retenção D1 e D7. A pergunta mais importante de todas: a pessoa volta? Retenção de dia 1 mede quantos dos que jogaram hoje voltam amanhã. Retenção de dia 7 mede quantos ainda estão por aqui uma semana depois. Se quase ninguém volta no dia seguinte, o problema raramente é falta de conteúdo lá no fim do jogo, é o começo, o tutorial, a primeira impressão. Se a galera volta na primeira semana mas some no mês, falta motivo pra continuar. Retenção aponta onde o jogo perde gente, e as métricas de retenção D1, D7 e D30 explicadas a fundo ajudam a ler cada janela sem confundir um problema de começo com um de meio de jogo. E quando o dado apontar queda no retorno diário, uma recompensa diária bem desenhada é uma das alavancas mais diretas pra mexer nessa curva.

Duração e número de sessões. Quanto tempo dura uma sessão típica e quantas vezes a pessoa abre o jogo. Esses dois números dizem muito sobre o ritmo. Sessões muito curtas podem indicar que o jogador desiste rápido, ou podem ser o desenho certo pra um jogo de pegar e largar. O que importa é comparar com a sua intenção. Se você desenhou pra sessões longas e os dados mostram sessões de poucos minutos, alguma coisa está afastando a pessoa antes da hora.

Funil de progressão. Aqui mora o ouro. O funil mostra quantos jogadores passam de cada etapa: terminaram o tutorial, chegaram na fase dois, na fase três, no chefe final. Quando você vê os números caindo de degrau em degrau, fica óbvio onde está o gargalo. Se 80% terminam o tutorial mas só 30% passam da primeira fase, essa fase tem um problema, dificuldade, clareza ou tédio. O funil te leva direto ao ponto que precisa de conserto, sem chute.

Churn. É o outro lado da retenção: a taxa de quem para de jogar e não volta mais. Olhar churn ajuda a entender não só quantos saem, mas quando saem. Um pico de abandono sempre no mesmo ponto é um sinal vermelho gritando que ali tem algo errado.

Métricas de receita, quando há monetização. Se o jogo vende algo, dá pra medir conversão (quantos dos jogadores chegam a comprar) e receita por usuário. Esses números só fazem sentido junto com os de comportamento. Conversão alta com retenção baixa significa que você ganha pouco de cada um porque eles somem cedo. Entender essa relação é parte de pensar a monetização de jogos indie de forma sustentável, e não como um número solto.

Repare numa coisa: essas métricas não são curiosidades. Cada uma existe pra te fazer agir. Se ela não muda nenhuma decisão sua, ela não merece estar no painel.

Como instrumentar eventos sem virar bagunça

A diferença entre telemetria que ajuda e telemetria que vira um pântano está na disciplina na hora de instrumentar. Duas regras seguram quase todo o caos.

Primeira: nomeie os eventos com critério. Escolha um padrão e siga ele em todo lugar. Se você usa fase_concluida, não invente level_complete na tela seguinte. Nomes inconsistentes são o que transforma análise num inferno, porque você acaba com dois eventos que significam a mesma coisa e nenhum gráfico bate. Defina um padrão simples no começo (verbo no passado, snake_case, em português ou inglês, tanto faz, desde que seja só um) e respeite.

Segunda: mande só o que você vai usar. Cada propriedade extra num evento é dado que você vai precisar armazenar, filtrar e entender depois. Se você não tem uma pergunta que aquela informação responde, não mande. É tentador registrar a posição exata do jogador a cada segundo "por via das dúvidas", mas isso enche tudo de ruído e custa armazenamento sem retorno. Colete pensando na pergunta, não no que dá pra coletar.

Na prática, instrumentar um evento em Godot 4 é simples. Você cria uma função central que dispara o evento e chama ela nos pontos certos do jogo. Algo assim, em GDScript tipado:

extends Node

# Função central de telemetria. Todo evento passa por aqui.
func registrar_evento(nome: String, dados: Dictionary = {}) -> void:
    var evento: Dictionary = {
        "nome": nome,
        "timestamp": Time.get_unix_time_from_system(),
        "sessao_id": _sessao_id,
        "props": dados,
    }
    _fila.append(evento)
    # Aqui você envia para o GameAnalytics ou para seu endpoint.

# Exemplo de chamada quando o jogador termina uma fase:
func _on_fase_concluida(numero_fase: int, tempo: float) -> void:
    registrar_evento("fase_concluida", {
        "fase": numero_fase,
        "tempo_segundos": tempo,
    })

O ponto importante não é o código, é a arquitetura: um único lugar por onde todo evento passa. Assim, no dia que você trocar de ferramenta ou quiser adicionar um filtro de privacidade, mexe num lugar só. Espalhar chamadas de telemetria por cinquenta scripts diferentes é a receita pra nunca mais conseguir mudar nada.

Repare que a função acima só empilha o evento numa fila (_fila) e não envia nada. Isso é de propósito, e é um detalhe que separa telemetria que atrapalha de telemetria que passa despercebida. Se você disparar uma requisição de rede a cada morte do jogador, o jogo engasga em quem tem conexão ruim, justamente a pessoa que você não quer irritar. A prática que resolve isso é acumular os eventos e mandar em lote, de tempos em tempos ou quando a fila enche:

extends Node

var _fila: Array[Dictionary] = []
var _intervalo: float = 30.0
var _tamanho_maximo_lote: int = 50

func _ready() -> void:
    var timer: Timer = Timer.new()
    timer.wait_time = _intervalo
    timer.autostart = true
    timer.timeout.connect(_enviar_lote)
    add_child(timer)

# Envia tudo que estiver na fila e esvazia. Chamado pelo timer
# ou quando a fila passa do tamanho máximo.
func _enviar_lote() -> void:
    if _fila.is_empty():
        return
    var lote: Array[Dictionary] = _fila.duplicate()
    _fila.clear()
    # Aqui vai o HTTPRequest para o GameAnalytics ou seu endpoint.
    print("Enviando ", lote.size(), " eventos")

func _notification(what: int) -> void:
    # Garante o envio do que sobrou quando o jogo fecha.
    if what == NOTIFICATION_WM_CLOSE_REQUEST:
        _enviar_lote()

Dois cuidados que fazem o lote funcionar na prática: mande o que sobrou quando o jogo fecha (o NOTIFICATION_WM_CLOSE_REQUEST acima), senão você perde a última sessão inteira, e trate o lote como descartável se o envio falhar numa conexão ruim, porque dado de analytics perdido é um problema pequeno perto de um jogo travado. Telemetria boa é invisível pra quem joga.

Black Friday: leve 3, pague 2
Travou no código ou na arte? Na Black Friday, leve os dois.

Curso de Godot + curso de Arte 2D + um curso bônus que você só descobre lá dentro. De R$ 2.691 por R$ 997, acesso vitalício, em até 18x no cartão.

Quero os 3 cursos com Godot
Suporte no WhatsAppAcesso vitalício7 dias de garantia

Ferramentas: a gratuita e a do evento próprio

Você tem basicamente dois caminhos, e dá pra começar por um e migrar depois.

O caminho mais rápido é uma ferramenta pronta de analytics de jogo. O GameAnalytics é a escolha mais comum pra quem está começando porque tem plano gratuito pensado pra games e integra com Godot, Unity e Unreal sem custo pra projeto pequeno. Você instala, configura, dispara os eventos e ganha painéis de retenção, funil e sessão sem montar nada. A vantagem é o tempo: em uma tarde você está coletando dado. A limitação é que você joga pelas regras da ferramenta, manda os dados pra um serviço de terceiro e tem menos controle sobre o formato.

O outro caminho é o evento próprio: você monta um endpoint simples num servidor seu e o jogo manda os eventos pra lá. Dá mais controle (o formato é seu, os dados ficam onde você quiser, fica mais fácil cuidar de privacidade) e custa o trabalho de manter esse servidorzinho de pé e construir suas próprias visualizações. Pra um solo no começo, costuma ser cedo demais. Pra um projeto que cresce e precisa de controle fino, vale o investimento.

Conselho prático: comece no gratuito. Resolva primeiro o problema de ter qualquer dado, que é melhor que dado nenhum, e só pense em infraestrutura própria quando a ferramenta pronta começar a te limitar de verdade. Trocar depois é trabalho, mas é trabalho de projeto que deu certo, e esse é um bom problema de se ter.

Privacidade e LGPD não são opcionais

Coletar dado de jogador no Brasil significa entrar no escopo da LGPD, e isso não é detalhe de letra miúda. A boa notícia é que telemetria bem feita já caminha junto com privacidade, porque a regra de ouro das duas é a mesma: colete só o que vai usar.

Algumas práticas que mantêm você no caminho certo. Use IDs anônimos, não dado pessoal. Pra medir retenção, você precisa saber que é o mesmo aparelho voltando, e pra isso basta um identificador gerado aleatoriamente. Não precisa, e não deve, mandar nome, e-mail ou nada que identifique a pessoa dentro do evento. Informe na política de privacidade o que você coleta e pra quê, em linguagem que dê pra entender. Respeite quem não quer ser rastreado: ofereça um jeito de desligar a coleta e honre essa escolha. E minimize: aquele princípio de mandar só o que vai usar não é só sobre organização, é sobre conformidade. Quanto menos dado pessoal você toca, menor o risco e menor a sua responsabilidade.

Tem um detalhe específico de monetização aqui. Se o jogo tem compras dentro do app, os eventos de compra envolvem dado mais sensível e às vezes regras de loja além da LGPD. Trate esses eventos com cuidado extra: registre que houve uma compra e o valor pra suas métricas de receita, mas não armazene dado de pagamento do jogador, que isso é responsabilidade da plataforma, não sua.

Os eventos mínimos que todo jogo deveria disparar

Se você está começando e não sabe por onde abrir a instrumentação, essa é a lista enxuta que responde às perguntas da maioria dos projetos. Cada evento abaixo existe porque alimenta uma métrica que muda decisão, não porque é bonito de ver no painel.

  • sessao_iniciada e sessao_encerrada: a base de tudo. Com os dois você calcula duração de sessão, número de sessões por jogador e retenção. Sem eles, nenhuma das métricas de retorno fecha.
  • fase_iniciada e fase_concluida: montam o funil de progressão. O par (entrou na fase, terminou a fase) é o que revela o degrau onde a galera desiste.
  • fase_abandonada: dispare quando o jogador sai no meio de uma fase, com um campo dizendo em que ponto (tempo decorrido ou checkpoint). É o evento que separa "a fase é longa" de "a fase espanta".
  • jogador_morreu: com a causa (queda, chefe, inimigo comum) e a fase. Picos de morte sempre no mesmo lugar são o sinal mais barato de problema de balanceamento.
  • config_alterada: quando o jogador baixa a dificuldade, desliga a música ou mexe num acessibilidade. Isso conta uma história que review nenhum conta.
  • compra_iniciada e compra_concluida: só se o jogo vende algo. O par mede conversão e, de quebra, mostra quem abriu a loja e desistiu.

Repare que são poucos eventos e todos no passado (o verbo descreve algo que já aconteceu). Comece por esses seis ou sete, deixe rodar uma semana, e só acrescente um evento novo quando tiver uma pergunta concreta que os atuais não respondem. Instrumentar é mais fácil de aumentar do que de limpar depois.

Como validar a telemetria antes de confiar no dado

O erro que estraga análise não é medir pouco, é confiar num número que está errado na origem. Dado sujo é pior que dado nenhum, porque ele parece confiável e te leva a decidir errado com convicção. Antes de olhar qualquer gráfico, garanta que o que o jogo manda é o que você acha que ele manda.

A prática que pega quase todo bug de instrumentação é uma camada de debug que imprime cada evento na hora que ele sai, enquanto você joga no editor:

extends Node

@export var debug_telemetria: bool = true

func registrar_evento(nome: String, dados: Dictionary = {}) -> void:
    if debug_telemetria:
        print("[TELEMETRIA] ", nome, " -> ", dados)
    # ... segue o empilhamento na fila e o envio em lote.

Com isso ligado, três armadilhas aparecem na cara. A primeira é o evento duplicado: você dispara fase_concluida e vê ele imprimir duas vezes, porque a transição de cena chama o sinal dois caminhos diferentes. A segunda é o evento no lugar errado: um jogador_morreu disparado dentro do _process em vez de uma vez na morte enche o log de milhares de linhas por segundo. A terceira é o evento que nunca sai: você testa a fase inteira e o compra_concluida não imprime, porque o ponto de chamada ficou dentro de um if que nunca é verdadeiro.

Depois que o log local está limpo, valide a outra ponta: confirme no painel do GameAnalytics (ou no seu endpoint) que o evento chegou com os campos certos. É comum o jogo disparar certinho e o dado sumir por um nome que a ferramenta não reconhece ou por um lote perdido numa conexão ruim. Só confie na métrica quando os dois lados, jogo e painel, concordam no mesmo evento. Esse cuidado de meia hora evita semanas decidindo em cima de dado que mentiu desde o começo.

Plano de tracking: escreva as perguntas antes do código

Antes de instrumentar o primeiro evento, vale gastar meia hora num documento simples, o plano de tracking. Ele tem quatro colunas: a pergunta que você quer responder, o evento que responde, as propriedades mínimas e a decisão que muda dependendo da resposta. Se não dá pra preencher a última coluna, o evento não entra.

Um exemplo concreto, pra um jogo de plataforma com dez fases:

PerguntaEventoPropriedadesDecisão que ela muda
Onde o jogador desiste?fase_abandonadafase, checkpointRebalancear ou encurtar a fase
A fase 4 está difícil demais?jogador_morreufase, causa, posiçãoMover inimigo, adicionar checkpoint
O tutorial ensina o pulo duplo?habilidade_usadahabilidade, faseReescrever o trecho de ensino
Alguém usa o modo assistido?config_alteradaopção, valorManter, divulgar ou remover a opção

Esse documento vira a fonte da verdade do nome dos eventos e evita que você invente level_complete numa tela e fase_concluida na outra. Ele também deixa claro quando parar: se a pergunta já foi respondida e a decisão já foi tomada, o evento pode até sair do jogo na próxima versão.

Mapa de calor de morte: o evento que mais rende

Dos eventos da lista mínima, o jogador_morreu com posição é o que mais entrega por linha de código, porque ele vira um mapa de calor: pontos no mapa da fase mostrando onde a galera morre. A diferença em relação ao "registrar a posição a cada segundo" que eu desaconselhei lá em cima é que aqui a posição só sai num momento que importa, uma vez por morte.

Arredondar a posição para uma grade reduz ruído e tamanho do dado, e já agrupa mortes vizinhas no mesmo ponto:

const TAMANHO_CELULA: float = 32.0

func registrar_morte(fase: int, causa: String, posicao: Vector2) -> void:
    var celula: Vector2i = Vector2i((posicao / TAMANHO_CELULA).floor())
    registrar_evento("jogador_morreu", {
        "fase": fase,
        "causa": causa,
        "celula_x": celula.x,
        "celula_y": celula.y,
    })

Na análise, você conta as mortes por célula e desenha por cima de um print da fase. Um aglomerado forte num ponto que você achava tranquilo quase sempre é um problema de leitura (o jogador não viu o perigo) e não de dificuldade pura, o mesmo raciocínio da curva de dificuldade do jogo. Você nem precisa de ferramenta pronta pra isso: exportar os eventos em CSV e plotar já resolve.

Opt-out na prática: respeitar quem não quer ser medido

Falei em oferecer um jeito de desligar a coleta. Na arquitetura de função central, isso custa poucas linhas, porque todo evento passa pelo mesmo lugar:

var coleta_ativa: bool = true

func carregar_preferencia() -> void:
    var config: ConfigFile = ConfigFile.new()
    if config.load("user://privacidade.cfg") == OK:
        coleta_ativa = config.get_value("telemetria", "ativa", true)

func registrar_evento(nome: String, dados: Dictionary = {}) -> void:
    if not coleta_ativa:
        return
    # ... segue o empilhamento na fila e o envio em lote.

Coloque o interruptor na tela de opções, explique em uma frase o que é coletado e salve a escolha. Se o jogador desligar, nada sai, nem o evento de que ele desligou. Os detalhes jurídicos, como base legal e o que escrever na política, estão no guia de LGPD em jogos e dados do jogador.

Telemetria antes do lançamento: demo e playtest

Não espere o lançamento pra ligar a telemetria. Uma demo pública, como a de um Steam Next Fest, é o primeiro momento em que gente desconhecida joga seu jogo em volume, e é exatamente quando o funil de abandono e o mapa de morte mais ensinam, porque ainda dá tempo de mudar. Separe os dados por versão (mande a versão do build em todo evento) pra não misturar o comportamento da demo com o do jogo final.

Telemetria também não substitui assistir gente jogando. O número mostra onde o jogador trava; o playtest com observação mostra por quê. Os dois juntos fecham o ciclo. Se você usa Godot, o hub de ferramentas Godot reúne os tutoriais que ajudam a montar a parte técnica.

Erros comuns de quem começa a medir

  • Ligar a telemetria sem pergunta. Sem plano de tracking, você acumula dado que ninguém lê.
  • Não mandar a versão do build. Sem ela, não dá pra saber se a queda veio do patch novo ou de uma mudança no público.
  • Ler média em vez de distribuição. Tempo médio de sessão esconde que metade sai em dois minutos e a outra metade joga uma hora. Olhe a distribuição.
  • Tirar conclusão com pouca gente. Com poucas dezenas de jogadores, uma variação pode ser acaso. Trate como pista e confirme com mais dado ou com playtest.
  • Esquecer de medir receita junto com comportamento. Se o jogo vende algo, as métricas de monetização como ARPU e LTV só fazem sentido lado a lado com retenção.

De número a decisão: fugindo da métrica de vaidade

Aqui está a parte que separa quem usa telemetria de quem só coleciona gráfico bonito. Dado que não vira decisão é decoração. A pergunta que você faz na frente de qualquer número precisa ser: e daí? Se a resposta for "nada, só é legal de ver", você está olhando uma métrica de vaidade.

Métrica de vaidade é o número que sempre sobe e te faz sentir bem sem te dizer o que fazer. Total acumulado de downloads é o exemplo clássico: ele nunca cai, parece ótimo, e não muda nenhuma escolha sua. Comparado com ele, retenção de dia 7 pode ser desconfortável de olhar (porque às vezes é baixa), mas ela te diz exatamente onde agir. A métrica útil é a que, dependendo do valor, te leva a fazer algo diferente.

O fluxo que funciona é simples. Você olha o funil de progressão e vê que metade dos jogadores abandona na fase três. Isso é uma pergunta, não uma resposta: por quê? Você vai investigar, talvez assistir a algumas sessões, talvez ver que ali tem um chefe que mata todo mundo. Você ajusta o balanceamento, lança o patch, e volta pro funil pra ver se a queda diminuiu. Quando você quer ir além do "mudei e melhorou" e ter certeza de que foi a sua mudança que fez efeito, o passo seguinte é o teste A/B em jogos, que compara duas versões com jogadores reais em vez de confiar só no antes e depois. Esse ciclo, medir, entender, agir, medir de novo, é o coração de qualquer estratégia de liveops que se sustenta. Telemetria sem esse ciclo é só um custo. Com ele, vira a ferramenta mais barata de melhorar seu jogo que existe.

Não precisa de muito pra começar. Três ou quatro métricas que você acompanha de verdade e que te fazem mexer no jogo já colocam você à frente da maioria, que ou não mede nada ou se afoga medindo tudo. Escolha as perguntas que importam, instrumente os eventos que respondem a elas com nome limpo e dado mínimo, respeite a privacidade de quem joga, e use cada número pra decidir uma coisa de cada vez. O jogo melhora pelo que os dados mostram, não pelo que você imagina da sua cadeira. E essa é a virada toda.

Perguntas frequentes

O que é telemetria de jogos?

Telemetria de jogos é a prática de coletar eventos que acontecem dentro do jogo (como início de sessão, fim de fase, morte do jogador ou uma compra) e enviar esses dados pra um lugar onde você consiga analisar. O objetivo é entender o que os jogadores realmente fazem, pra decidir com base em comportamento e não em achismo.

Qual a diferença entre telemetria e analytics de jogo?

Telemetria é a parte da coleta: os eventos que o jogo dispara e manda pra fora. Analytics é a parte da leitura: pegar esses dados, montar métricas e tirar conclusões. Na prática a gente usa as duas palavras quase como sinônimos, mas vale lembrar que coletar dado sem analisar não serve de nada, e analisar exige ter coletado direito antes.

Quais métricas de jogo realmente importam pra um indie?

Comece com poucas e acionáveis: retenção de dia 1 e dia 7, duração e número de sessões, e o funil de progressão pra ver onde o jogador desiste. Se o jogo tem monetização, adicione conversão e receita por usuário. O resto é detalhe que você acrescenta quando essas já estiverem respondendo às suas perguntas.

Telemetria de jogo precisa seguir a LGPD?

Sim. Se você coleta dado de jogador no Brasil, a LGPD se aplica. A regra prática é coletar só o que vai usar, evitar dado pessoal sempre que possível (mande IDs anônimos, não nome ou e-mail dentro do evento), informar na política de privacidade o que é coletado e respeitar o pedido de quem não quer ser rastreado.

Qual ferramenta de analytics de jogo usar de graça?

O GameAnalytics tem um plano gratuito pensado pra games e integra com Godot, Unity e Unreal sem custo pra projetos pequenos. É um bom ponto de partida. A alternativa é montar seu próprio endpoint de evento, que dá mais controle e privacidade, mas exige manter um servidorzinho. Dá pra começar no gratuito e migrar depois se precisar.

O que é métrica de vaidade?

Métrica de vaidade é o número que parece importante mas não muda nenhuma decisão sua, como total acumulado de downloads ou seguidores. Ela sobe sempre e faz você se sentir bem, mas não responde a pergunta certa. Métrica útil é aquela que, dependendo do valor, te leva a fazer algo diferente no jogo.

O que é um plano de tracking?

É um documento curto, feito antes de instrumentar, que lista a pergunta que você quer responder, o evento que responde, as propriedades mínimas de cada evento e a decisão que muda conforme a resposta. Ele padroniza os nomes dos eventos e impede que você colete dado sem uso.

Como fazer um mapa de calor de mortes no meu jogo?

Dispare um evento a cada morte com a fase, a causa e a posição do jogador arredondada para uma grade, por exemplo células de 32 pixels. Depois conte as mortes por célula e desenhe por cima de uma imagem da fase. Aglomerados em pontos que pareciam tranquilos costumam indicar problema de leitura visual.