Geyser gRPC - Melhores Práticas

Começar

• Comece simples: comece com assinaturas de slot para se familiarizar com streaming antes de adicionar filtros complexos.
• Use filtros com sabedoria: assine apenas o que você precisa para reduzir a largura de banda/CPU. As transações de votação são ~70% do tráfego – solte-as se você não precisar delas.

SubscribeRequestFilterTransactions {
    vote: Some(false),   // Exclude ~70% vote txs
    failed: Some(false), // Exclude failed txs
    ..Default::default()
}

SubscribeRequestFilterTransactions {
    vote: Some(false),   // Exclude ~70% vote txs
    failed: Some(false), // Exclude failed txs
    ..Default::default()
}

Gestão de conexões

• Reconexão automática: esperar problemas de rede; reconectar com backoff exponencial.
• Ping/pong manipulação: Yellowstone gRPC servidores enviar ping. Sempre responda com pong ou o servidor pode fechar a conexão (causa comum de desconexão de ~30s).

if matches!(update.update_oneof, Some(UpdateOneof::Ping(_))) {
    subscribe_tx.send(SubscribeRequest {
        ping: Some(SubscribeRequestPing { id: 1 }),
        ..Default::default()
    }).await?;
}

if matches!(update.update_oneof, Some(UpdateOneof::Ping(_))) {
    subscribe_tx.send(SubscribeRequest {
        ping: Some(SubscribeRequestPing { id: 1 }),
        ..Default::default()
    }).await?;
}

• Recuperação de gap: uso from_slot após reconectar para evitar perda de dados (duplicados são aceitáveis).

subscribe_request.from_slot = if tracked_slot > 0 {
    Some(tracked_slot) // Optionally subtract a small buffer to dodge reorgs
} else {
    None
};

subscribe_request.from_slot = if tracked_slot > 0 {
    Some(tracked_slot) // Optionally subtract a small buffer to dodge reorgs
} else {
    None
};

Padrões de arquitectura

• Separar entrada e processamento com canais para dissociar o IO da lógica de negócios e adicionar contrapressão.

let (tx, rx) = mpsc::channel::<SubscribeUpdate>(10_000);
// ingress task reads stream and tx.send(...)
// processing task consumes rx and does business logic

let (tx, rx) = mpsc::channel::<SubscribeUpdate>(10_000);
// ingress task reads stream and tx.send(...)
// processing task consumes rx and does business logic

• Use canais limitados: escolha a capacidade com base na velocidade de processamento e na tolerância de perda de dados (menor = menos memória, mais gotas; maior = mais memória, menos gotas).

Desempenho e resiliência

• Monitorar a latência do processamento e o log quando os limiares são ultrapassados.
• Lote DB escreve; flush no tamanho ou intervalo do lote.
• Usar o iO do assync para chamadas externas; descarregar computação pesada para tarefas do trabalhador/threads.
• Reusar pedidos de assinatura para reduzir as dotações.

Erro ao manusear

• Tipos de erros distintos (stream vs processamento vs canal).
• Retrocesso exponencial na reconexão (iniciar pequeno, tampa em um máximo razoável).
• Registo/metric perdeu atualizações para rastrear as condições de consumo lento.

Gestão dos dados

• Lidar com duplicatas ao usar from_slot (cache ligado ao tempo ou restrições DB).
• Escolha o compromisso por caso de uso:
  • processado: painéis mais rápidos, pode voltar
  • confirmado: bom padrão para a maioria dos aplicativos/indexers
  • finalizado: quando é necessária certeza absoluta

Assinaturas dinâmicas

Lista de verificação da produção

• Reconexão automática com retrocesso exponencial
• Recuperação de gap usando from_slot
• Ping/pong manipulação (evitar desconexão dos 30s)
• □ Entrada e processamento separados com canais limitados/backpressure
• □ Registro de erros e métricas/alerting
• • Processamento de seguimento de latência
• • Duplicar o manuseio e a otimização do filtro
• □ Lote escreve (se persistir)
• O desligamento gracioso e verificações de saúde

Recursos adicionais

• Solana Stream SDK (suporte Geyser gRPC): https://github.com/ValidatorsDAO/solana-stream