Todos os produtos
Search

Este produto

    Tair (Redis® OSS-Compatible):Suggestions for handling common Latency events

    Central de documentação

    Tair (Redis® OSS-Compatible):Suggestions for handling common Latency events

    Última atualização: Jun 26, 2026

    Use esta referência para identificar a causa raiz de um evento de latência do Redis e aplicar a correção adequada.

    Antes de começar

    Verifique estas causas comuns antes de analisar eventos específicos:

    1. Comandos lentos. Comandos que varrem todas as chaves (por exemplo, KEYS) bloqueiam a thread principal. Revise os logs de consultas lentas para encontrá-los. Consulte Consultar logs de consultas lentas.

    2. Chaves grandes. Chaves grandes retardam a evicção e a expiração. Use a análise de chaves offline para identificá-las. Consulte Usar o recurso de análise de chaves offline.

    3. Alto uso de memória. Quando a memória ocupada excede o limite maxmemory, o Redis executa ciclos de evicção com frequência. Consulte Alterar as configurações de uma instância.

    Contexto

    O Redis 2.8.13 introduziu o monitoramento de latência, que coleta dados dos últimos 160 segundos e registra apenas o evento de maior latência por segundo.

    O Tair (compatível com Redis OSS) oferece insights de latência, uma alternativa avançada. Esse recurso registra até 27 eventos com a duração de execução de todos os comandos e retém estatísticas de latência dos últimos três dias. Para obter os nomes dos eventos e seus respectivos limiares de latência, consulte Eventos especiais comuns.

    Eventos comuns de latência

    Alguns eventos possuem uma relação pai-filho:

    • **AofWrite** é o evento pai. Sempre que o Redis grava dados em um arquivo append-only (AOF), ele registra AofWrite junto com exatamente um de três eventos filhos: AofWriteAlone, AofWriteActiveChild ou AofWritePendingFsync. Para encontrar a causa específica, execute a análise do evento filho.

    • **EvictionCycle** é o evento pai para evicção. Analise EvictionDel e EvictionLazyFree em conjunto para determinar a causa da latência de evicção.

    Evento

    O que mede

    Causa comum

    O que fazer

    EvictionCycle

    Tempo para um ciclo completo de evicção, incluindo seleção de chaves, exclusão e espera da thread em segundo plano

    Múltiplos fatores — analise EvictionDel e EvictionLazyFree para identificar a causa exata

    Revise o uso de chaves e otimize os dados do negócio. Caso as evicções sejam frequentes, aumente a escala da instância para manter o uso de memória abaixo de maxmemory.

    EvictionDel

    Tempo para excluir chaves durante um ciclo de evicção

    Evicção de chaves grandes

    Evite chaves grandes. Ative a evicção assíncrona: defina lazyfree-lazy-eviction como yes. Para evicções frequentes, aumente a escala da instância.

    EvictionLazyFree

    Tempo de espera para que as threads em segundo plano liberem memória

    Não há chaves passíveis de evicção disponíveis enquanto as threads em segundo plano liberam memória (por exemplo, ao excluir chaves grandes)

    Ajuste a política de evicção de memória usando o parâmetro maxmemory-policy. Se a evicção for frequente, escale a instância.

    ExpireCycle

    Tempo para um ciclo de expiração de chaves

    Exclusão de chaves grandes

    Evite o uso de chaves grandes. Ative a expiração assíncrona: defina lazyfree-lazy-expire como yes e exclua os dados expirados regularmente no console.

    ExpireDel

    Tempo para excluir chaves durante um ciclo de expiração de chaves

    Exclusão de chaves grandes

    Não utilize chaves grandes.

    AofWrite

    Tempo total para gravar dados em AOFs

    Múltiplos fatores — analise AofWriteAlone, AofWriteActiveChild e AofWritePendingFsync para identificar a causa exata

    Se a persistência de dados não for necessária, desative o AOF: defina appendonly como no.

    AofWriteAlone

    Tempo para uma gravação de AOF sem processos filhos simultâneos ou fsync pendente

    Grande volume de gravação ou gargalos de desempenho do disco

    Caso o AOF não seja necessário, configure appendonly como no.

    AofWriteActiveChild

    Tempo para uma gravação de AOF enquanto processos filhos também gravam no disco

    Concorrência de E/S de disco do processo filho com gravações de AOF

    Quando o AOF não for necessário, altere appendonly para no.

    AofWritePendingFsync

    Tempo para uma gravação de AOF durante a execução de um fsync em segundo plano

    Concorrência do fsync em segundo plano com gravações de AOF

    Se não precisar do AOF, mude appendonly para no.

    Commands

    Tempo para comandos regulares (não rotulados como rápidos)

    Comandos que percorrem todos os dados, como KEYS

    Revise os logs de consultas lentas para encontrar comandos de longa duração. Use a análise de chaves offline para verificar a existência de chaves grandes.

    FastCommand

    Tempo para comandos rápidos com complexidade O(1) ou O(log N)

    Comandos rápidos que copiam grandes quantidades de dados (por exemplo, GET em uma chave grande)

    Identifique e divida chaves grandes. Consulte Identificar e lidar com chaves grandes e hotkeys.

    Fork

    Tempo para chamar fork()

    Reescritas de AOF

    Caso não precise de persistência de dados, desative o AOF configurando appendonly como no.

    Próximos passos