> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Medindo a Latência
> Aprenda a medir e analisar corretamente a latência para fluxos gRPC usando vários métodos de teste.
**AVISO CRÍTICO: Somente Data Center de Produção**
Esses testes de latência são projetados para **ambientes de data center de produção apenas**. NÃO execute esses testes em máquinas locais ou conexões de internet domésticas. A largura de banda local não pode lidar com assinaturas pesadas de Solana e produzirá resultados sem sentido que não refletem o desempenho do mundo real.
**REQUISITO DE COLOCAÇÃO: Implante Próximo ao Seu Endpoint LaserStream**
Para medições de latência significativas, você **deve** colocar sua infraestrutura de teste na mesma região do seu endpoint LaserStream escolhido. A distância de rede dominará suas medições - testar de um continente diferente mostrará a latência da rede, não o desempenho do LaserStream.
***
## Entendendo a latência em sistemas de blockchain distribuídos
Ao trabalhar com serviços de streaming de blockchain, a medição de latência torna-se complexa porque os sistemas distribuídos não têm um relógio universal. Ao contrário dos sistemas tradicionais onde você pode medir o tempo de ida e volta para um único servidor, as redes blockchain envolvem vários validadores, cada um recebendo e processando a mesma transação em momentos diferentes.
**O desafio fundamental:** Blockchains como Solana não têm um conceito de tempo absoluto. Cada nó validador globalmente receberá a mesma transação em momentos diferentes, e a confirmação depende de uma porcentagem do cluster atingir o consenso. Isso torna a medição determinística de latência impossível no sentido tradicional.
## Níveis de compromisso e prioridades de latência
Solana oferece três níveis de compromisso, cada um com características de latência diferentes:
* **Processado**: Mais rápido, confirmação de um único validador (\~400ms)
* **Confirmado**: Médio, confirmação de supermaioria (\~2-3 segundos)
* **Finalizado**: Mais lento, finalização completa da rede (\~15-30 segundos)
Para aplicações sensíveis à latência, **compromisso processado** é tipicamente o alvo. Todos os testes neste guia utilizam o nível de compromisso processado, já que a maioria dos casos de uso de alta frequência prioriza a velocidade sobre a finalidade absoluta.
## Três abordagens para medir a latência
### 1. Comparando fluxos gRPC paralelos
**Método mais confiável** - Compara dois fluxos independentes para a mesma fonte de dados, medindo qual recebe eventos idênticos primeiro.
**Vantagens:**
* Elimina problemas de sincronização de relógio
* Fornece comparação de desempenho relativo
* Mais preciso para comparar serviços
### 2. Comparação de timestamp local vs created\_at
**Confiabilidade moderada** - Mede a diferença entre quando seu sistema recebe uma mensagem e o timestamp incorporado na mensagem pelo serviço LaserStream.
**Limitações:**
* Apenas representa quando o LaserStream criou a mensagem internamente
* Atrasos a montante para o LaserStream não serão capturados
* Menos preciso do que o Método 1 para latência verdadeira de ponta a ponta
### 3. Análise de timestamp de bloco (não recomendado)
**Não recomendado** - Compara o tempo de recebimento local com o timestamp de bloco da Solana.
**Limitações significativas:**
* Timestamps de bloco têm apenas granularidade de segundo
* Solana produz blocos a cada 400ms
* Fornece informações mínimas úteis
***
## Requisitos de configuração
### Co-locação regional
Para medições de latência significativas, implante sua infraestrutura de teste no mesmo data center ou região que seu endpoint LaserStream.
**Regiões LaserStream disponíveis:**
* **ewr**: Nova York, US (Costa Leste)
* **pitt**: Pittsburgh, US (Central)
* **slc**: Salt Lake City, US (Costa Oeste)
* **ams**: Amsterdã, Europa
* **fra**: Frankfurt, Europa
* **tyo**: Tóquio, Ásia
* **sgp**: Singapura, Ásia
Para testes devnet, use:
Veja a [documentação do LaserStream gRPC](/docs/pt-BR/laserstream/grpc) para instruções completas de configuração e diretrizes de seleção de endpoint.
### Configuração do ambiente Rust
Todos os scripts de medição usam Rust com Cargo. Configuração básica:
```bash theme={"system"}
# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# Setup project
cargo new latency-testing
cd latency-testing
# Add dependencies to Cargo.toml
[dependencies]
# Async runtime
tokio = { version = "1", features = ["full"] }
# Futures utilities for StreamExt, SinkExt
futures = "0.3"
# Environment variable loading
dotenvy = "0.15"
# Logging
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["fmt", "env-filter"] }
# Yellowstone gRPC client and protocol
yellowstone-grpc-client = "8.0.0"
yellowstone-grpc-proto = "8.0.0"
# For timestamp analysis
prost-types = "0.12"
```
Crie um arquivo com suas credenciais:
```bash theme={"system"}
YS_GRPC_URL=your-comparison-endpoint
YS_API_KEY=your-comparison-api-key
LS_GRPC_URL=your-laserstream-endpoint
LS_API_KEY=your-helius-api-key
```
Obtenha sua chave de API Helius no [Painel Helius](https://dashboard.helius.dev/). O devnet do LaserStream está disponível em todos os planos. O acesso à mainnet requer um plano Business ou Professional.
***
## Método 1: Comparação de fluxo paralelo
Este script estabelece duas conexões independentes para diferentes endpoints gRPC e mede qual recebe as mesmas mensagens primeiro. Esta abordagem elimina problemas de sincronização de relógio usando tempo relativo.
```rust [expandable] theme={"system"}
use std::collections::HashMap;
use std::time::SystemTime;
use dotenvy::dotenv;
use futures::{StreamExt, SinkExt};
use tokio::sync::mpsc;
use tracing::{debug, error, info};
use yellowstone_grpc_client::{ClientTlsConfig, GeyserGrpcClient};
use yellowstone_grpc_proto::prelude::{
subscribe_update::UpdateOneof, CommitmentLevel, SubscribeRequest,
SubscribeRequestFilterBlocksMeta, SubscribeUpdate,
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum Source {
Yellowstone,
Laserstream,
}
#[derive(Default, Debug)]
struct SlotTimings {
ys_recv_ms: Option,
ls_recv_ms: Option,
}
#[tokio::main]
async fn main() -> Result<(), Box> {
let _ = dotenv();
tracing_subscriber::fmt().with_env_filter("info").init();
let ys_url = std::env::var("YS_GRPC_URL").expect("YS_GRPC_URL env variable not set");
let ls_url = std::env::var("LS_GRPC_URL").expect("LS_GRPC_URL env variable not set");
let ys_api_key = std::env::var("YS_API_KEY").ok();
let ls_api_key = std::env::var("LS_API_KEY").ok();
let commitment = CommitmentLevel::Processed;
info!(?commitment, "Starting latency comparison");
// Establish both clients
let mut ys_client = GeyserGrpcClient::build_from_shared(ys_url.clone())
.expect("invalid YS url")
.x_token(ys_api_key.clone())?
.tls_config(ClientTlsConfig::new().with_native_roots())?
.max_decoding_message_size(10 * 1024 * 1024)
.connect()
.await?;
let mut ls_client = GeyserGrpcClient::build_from_shared(ls_url.clone())
.expect("invalid LS url")
.x_token(ls_api_key.clone())?
.tls_config(ClientTlsConfig::new().with_native_roots())?
.max_decoding_message_size(10 * 1024 * 1024)
.connect()
.await?;
let (mut ys_tx, mut ys_rx) = ys_client.subscribe().await?;
let (mut ls_tx, mut ls_rx) = ls_client.subscribe().await?;
let subscribe_request = SubscribeRequest {
blocks_meta: {
let mut m = HashMap::::new();
m.insert("all".to_string(), SubscribeRequestFilterBlocksMeta::default());
m
},
commitment: Some(commitment as i32),
..Default::default()
};
ys_tx.send(subscribe_request.clone()).await?;
ls_tx.send(subscribe_request).await?;
let (agg_tx, mut agg_rx) = mpsc::unbounded_channel::<(Source, u64, i128)>();
// Spawn task for Yellowstone stream
{
let agg_tx = agg_tx.clone();
tokio::spawn(async move {
while let Some(update_res) = ys_rx.next().await {
match update_res {
Ok(update) => handle_update(Source::Yellowstone, update, &agg_tx).await,
Err(e) => {
error!(target: "ys", "stream error: {:?}", e);
break;
}
}
}
});
}
// Spawn task for Laserstream stream
{
let agg_tx = agg_tx.clone();
tokio::spawn(async move {
while let Some(update_res) = ls_rx.next().await {
match update_res {
Ok(update) => handle_update(Source::Laserstream, update, &agg_tx).await,
Err(e) => {
error!(target: "ls", "stream error: {:?}", e);
break;
}
}
}
});
}
// Aggregator – collect latencies per slot and print once we have both sources
let mut timings: HashMap = HashMap::new();
let mut deltas: Vec = Vec::new();
let mut count = 0;
println!("slot,ys_recv_ms,ls_recv_ms,delta_ms");
while let Some((source, slot, latency_ms)) = agg_rx.recv().await {
let entry = timings.entry(slot).or_default();
match source {
Source::Yellowstone => entry.ys_recv_ms = Some(latency_ms),
Source::Laserstream => entry.ls_recv_ms = Some(latency_ms),
}
if let (Some(ys), Some(ls)) = (entry.ys_recv_ms, entry.ls_recv_ms) {
let delta = ys - ls; // positive => YS arrived later
println!("{slot},{ys},{ls},{delta}");
deltas.push(delta);
count += 1;
if count % 100 == 0 {
print_statistics(&deltas, count);
}
timings.remove(&slot);
}
}
Ok(())
}
async fn handle_update(
source: Source,
update: SubscribeUpdate,
agg_tx: &mpsc::UnboundedSender<(Source, u64, i128)>,
) {
if let Some(UpdateOneof::BlockMeta(block_meta)) = update.update_oneof {
let slot = block_meta.slot;
let recv_ms = system_time_to_millis(SystemTime::now());
debug!(?source, slot, recv_ms, "BlockMeta received");
let _ = agg_tx.send((source, slot, recv_ms));
}
}
fn print_statistics(deltas: &[i128], count: usize) {
if deltas.is_empty() {
return;
}
let mut sorted_deltas = deltas.to_vec();
sorted_deltas.sort();
let median = if sorted_deltas.len() % 2 == 0 {
let mid = sorted_deltas.len() / 2;
(sorted_deltas[mid - 1] + sorted_deltas[mid]) / 2
} else {
sorted_deltas[sorted_deltas.len() / 2]
};
let min = *sorted_deltas.first().unwrap();
let max = *sorted_deltas.last().unwrap();
let sum: i128 = sorted_deltas.iter().sum();
let mean = sum / sorted_deltas.len() as i128;
let p25_idx = (sorted_deltas.len() as f64 * 0.25) as usize;
let p75_idx = (sorted_deltas.len() as f64 * 0.75) as usize;
let p95_idx = (sorted_deltas.len() as f64 * 0.95) as usize;
let p25 = sorted_deltas[p25_idx.min(sorted_deltas.len() - 1)];
let p75 = sorted_deltas[p75_idx.min(sorted_deltas.len() - 1)];
let p95 = sorted_deltas[p95_idx.min(sorted_deltas.len() - 1)];
eprintln!("--- Statistics after {} slots ---", count);
eprintln!("Delta (YS - LS) in milliseconds:");
eprintln!(" Min: {}, Max: {}", min, max);
eprintln!(" Mean: {}, Median: {}", mean, median);
eprintln!(" P25: {}, P75: {}, P95: {}", p25, p75, p95);
eprintln!(" Positive deltas (YS slower): {}/{} ({:.1}%)",
sorted_deltas.iter().filter(|&&x| x > 0).count(),
sorted_deltas.len(),
sorted_deltas.iter().filter(|&&x| x > 0).count() as f64 / sorted_deltas.len() as f64 * 100.0);
eprintln!("---");
}
fn system_time_to_millis(st: SystemTime) -> i128 {
st.duration_since(SystemTime::UNIX_EPOCH)
.unwrap()
.as_millis() as i128
}
```
**O que isso mede:** A diferença de desempenho relativa entre dois serviços de streaming. O delta mostra qual serviço entrega a mesma informação de slot primeiro.
**Métricas principais:**
* **Delta positivo**: Primeiro serviço (YS) mais lento que o segundo serviço (LS) - LaserStream é mais rápido
* **Delta negativo**: Primeiro serviço (YS) mais rápido que o segundo serviço (LS) - LaserStream é mais lento
* **Média/Mediana**: Diferença média de desempenho
* **P95**: Diferença de latência do percentil 95
**Executando o teste:**
```bash theme={"system"}
cargo run --bin latency-comparison
```
**Saída de exemplo:**
```
slot,ys_recv_ms,ls_recv_ms,delta_ms
352416939,1752168399141,1752168399140,1
352416940,1752168399526,1752168399512,14
352416941,1752168399890,1752168399877,13
```
A saída mostra diferenças de latência em tempo real e estatísticas periódicas. Um delta médio positivo indica que o segundo serviço (LaserStream) consistentemente entrega dados mais rápido.
***
## Método 2: Análise de timestamp criado
Esta abordagem compara o timestamp embutido nas mensagens contra o tempo do seu sistema local ao recebê-las.
```rust [expandable] theme={"system"}
use std::time::{Duration, SystemTime};
use dotenvy::dotenv;
use tracing::{debug, error, info};
use yellowstone_grpc_proto::prost_types::Timestamp;
use futures::StreamExt;
use futures::SinkExt;
use std::collections::HashMap;
use yellowstone_grpc_client::{ClientTlsConfig, GeyserGrpcClient};
use yellowstone_grpc_proto::prelude::{
subscribe_update::UpdateOneof, CommitmentLevel, SubscribeRequest,
SubscribeRequestFilterTransactions, SubscribeUpdate,
};
const ACCOUNTS_INCLUDE: &[&str] = &["BB5dnY55FXS1e1NXqZDwCzgdYJdMCj3B92PU6Q5Fb6DT"];
const COMMITMENT_LEVEL: &str = "processed";
#[tokio::main]
async fn main() -> Result<(), Box> {
let _ = dotenv();
tracing_subscriber::fmt().with_env_filter("info").init();
let grpc_url = std::env::var("YS_GRPC_URL").expect("GRPC_URL env variable not set");
let api_key = std::env::var("YS_API_KEY").ok();
info!("Connecting to {} …", grpc_url);
debug!(accounts_include = ?ACCOUNTS_INCLUDE, "Subscribing with accountsInclude filter");
let mut client = GeyserGrpcClient::build_from_shared(grpc_url.clone())
.expect("invalid URL")
.x_token(api_key.clone())?
.tls_config(ClientTlsConfig::new().with_native_roots())?
.connect()
.await?;
let (mut subscribe_tx, mut subscribe_rx) = client.subscribe().await?;
let mut tx_filter_map = HashMap::new();
tx_filter_map.insert(
"latency".to_string(),
SubscribeRequestFilterTransactions {
account_include: ACCOUNTS_INCLUDE.iter().map(|s| s.to_string()).collect(),
vote: Some(false),
failed: Some(false),
..Default::default()
},
);
subscribe_tx
.send(SubscribeRequest {
transactions: tx_filter_map,
commitment: Some(CommitmentLevel::Processed as i32),
..Default::default()
})
.await?;
let mut latencies: Vec = Vec::new();
let mut count = 0;
while let Some(update_res) = subscribe_rx.next().await {
match update_res {
Ok(update) => {
if let Some(UpdateOneof::Transaction(tx)) = update.update_oneof {
let recv_time = SystemTime::now();
if let Some(created_at) = update.created_at {
let created_time = SystemTime::UNIX_EPOCH + Duration::new(
created_at.seconds as u64,
created_at.nanos as u32,
);
if let Ok(latency) = recv_time.duration_since(created_time) {
let latency_ms = latency.as_millis() as i64;
latencies.push(latency_ms);
count += 1;
println!("Transaction latency: {}ms", latency_ms);
if count % 100 == 0 {
print_statistics(&latencies, count);
}
}
}
}
}
Err(e) => {
error!("Stream error: {:?}", e);
break;
}
}
}
Ok(())
}
fn print_statistics(latencies: &[i64], count: usize) {
if latencies.is_empty() {
return;
}
let mut sorted = latencies.to_vec();
sorted.sort();
let median = if sorted.len() % 2 == 0 {
let mid = sorted.len() / 2;
(sorted[mid - 1] + sorted[mid]) / 2
} else {
sorted[sorted.len() / 2]
};
let min = *sorted.first().unwrap();
let max = *sorted.last().unwrap();
let sum: i64 = sorted.iter().sum();
let mean = sum / sorted.len() as i64;
let p95_idx = (sorted.len() as f64 * 0.95) as usize;
let p95 = sorted[p95_idx.min(sorted.len() - 1)];
eprintln!("--- Statistics after {} transactions ---", count);
eprintln!("Latency (created_at to receive) in milliseconds:");
eprintln!(" Min: {}, Max: {}", min, max);
eprintln!(" Mean: {}, Median: {}", mean, median);
eprintln!(" P95: {}", p95);
eprintln!("---");
}
```
**Limitação importante:** Este método só mede desde quando o LaserStream criou a mensagem até quando você a recebeu. Não leva em conta quaisquer atrasos a montante entre o evento do blockchain e o processamento do LaserStream.
**Executando o teste:**
```bash theme={"system"}
cargo run --bin timestamp-analysis
```
**Saída de exemplo:**
```
Transaction latency: 45ms
Transaction latency: 52ms
Transaction latency: 38ms
--- Statistics after 100 transactions ---
Latency (created_at to receive) in milliseconds:
Min: 28, Max: 89
Mean: 47, Median: 45
P95: 72
---
```
Este método fornece insights sobre a latência de rede e processamento entre o LaserStream e seu aplicativo, mas deve ser usado em conjunto com o Método 1 para uma análise abrangente.
***
## Melhores práticas para testes de latência
### Princípios-chave
* **Co-locação**: Implante os testes na mesma região do seu endpoint LaserStream para minimizar a latência de rede
* **Métodos múltiplos**: Use a comparação de fluxo paralelo (Método 1) como sua métrica principal, complementada pela análise de timestamps
* **Monitoramento a longo prazo**: Execute testes por períodos prolongados para capturar diferentes condições de rede e congestionamento do blockchain
* **Análise estatística**: Foque em percentis (P95, P99) em vez de apenas médias para entender a latência na cauda
### Interpretando resultados
1. **Estabelecer linha de base**: Execute testes por pelo menos 1 hora para estabelecer desempenho básico em condições normais
2. **Identificar padrões**: Procure por padrões em picos de latência - eles se correlacionam com alta atividade do blockchain ou congestionamento da rede?
3. **Comparar percentis**: A latência P95 é frequentemente mais importante do que a latência média para a experiência do usuário
4. **Monitorar consistência**: Desempenho consistente é frequentemente mais valioso do que a latência mínima absoluta
Lembre-se de que a latência do blockchain é inerentemente variável devido aos requisitos de consenso de rede. Foque em diferenças de desempenho relativas e consistência sobre números absolutos.