From 46a645abb66751ade248a947772d936f5fda0948 Mon Sep 17 00:00:00 2001 From: Chris Wessels Date: Thu, 29 Oct 2026 09:29:31 +0000 Subject: [PATCH] fix(telemetry): preserve long query durations --- src/client_query.rs | 8 +++---- src/indexing_performance.rs | 32 +++++++++++++++++++++++-- src/reports.rs | 48 +++++++++++++++++++++++++++++++++---- 3 files changed, 78 insertions(+), 10 deletions(-) diff --git a/src/client_query.rs b/src/client_query.rs index 345058b9..2c9d8103 100644 --- a/src/client_query.rs +++ b/src/client_query.rs @@ -316,7 +316,7 @@ async fn run_indexer_queries( .query_indexer(deployment_url, auth, &indexer_query) .in_current_span() .await; - let response_time_ms = start_time.elapsed().as_millis() as u16; + let response_time_ms = reports::response_time_ms(start_time.elapsed()); let report = reports::IndexerRequest { indexer, deployment, @@ -428,7 +428,7 @@ async fn run_indexer_queries( tracing::trace!(indexer_request = indexer_request.request); } - let response_time_ms = client_response_time.as_millis() as u16; + let response_time_ms = reports::response_time_ms(client_response_time); let ideal_response_time_ms = indexer_requests .iter() .filter(|i| i.result.is_ok()) @@ -716,7 +716,7 @@ pub async fn handle_indexer_query( .query_indexer(deployment_url, indexer_auth, &payload) .in_current_span() .await; - let response_time_ms = start_time.elapsed().as_millis() as u16; + let response_time_ms = reports::response_time_ms(start_time.elapsed()); let indexer_request = reports::IndexerRequest { indexer: indexing_id.indexer, deployment: indexing_id.deployment, @@ -724,7 +724,7 @@ pub async fn handle_indexer_query( receipt, subgraph_chain: subgraph.chain, result: result.clone(), - response_time_ms: indexer_start_time.elapsed().as_millis() as u16, + response_time_ms: reports::response_time_ms(indexer_start_time.elapsed()), seconds_behind, blocks_behind, request: payload, diff --git a/src/indexing_performance.rs b/src/indexing_performance.rs index eb93e79b..50efad91 100644 --- a/src/indexing_performance.rs +++ b/src/indexing_performance.rs @@ -52,7 +52,7 @@ impl IndexingPerformance { indexer: IndexerId, deployment: DeploymentId, success: bool, - latency_ms: u16, + latency_ms: u32, latest_block: Option, ) { self.msgs @@ -60,7 +60,8 @@ impl IndexingPerformance { indexer, deployment, success, - latency_ms, + // The selection library accepts u16 milliseconds. Never wrap slow requests. + latency_ms: u16::try_from(latency_ms).unwrap_or(u16::MAX), latest_block, }) .unwrap(); @@ -183,3 +184,30 @@ mod feedback_tests { } } } + +#[cfg(test)] +mod latency_tests { + use super::*; + + #[test] + fn selection_feedback_saturates_instead_of_wrapping_slow_requests() { + let data = Box::leak(Box::new(DoubleBuffer::default())); + let (msgs, mut rx) = mpsc::unbounded_channel(); + let performance = IndexingPerformance { data, msgs }; + for (milliseconds, expected) in [ + (250, 250), + (65_535, 65_535), + (65_536, 65_535), + (70_000, 65_535), + ] { + performance.feedback( + thegraph_core::alloy::primitives::Address::ZERO.into(), + [0; 32].into(), + false, + milliseconds, + None, + ); + assert_eq!(rx.try_recv().unwrap().latency_ms, expected); + } + } +} diff --git a/src/reports.rs b/src/reports.rs index 2c045473..f3ac57de 100644 --- a/src/reports.rs +++ b/src/reports.rs @@ -8,9 +8,14 @@ use tokio::{sync::mpsc, time::Instant}; use crate::{concat_bytes, errors, indexer_client::IndexerResponse, receipts::Receipt}; +/// Milliseconds for the protobuf uint32 fields, saturating only at the wire type's limit. +pub fn response_time_ms(duration: Duration) -> u32 { + u32::try_from(duration.as_millis()).unwrap_or(u32::MAX) +} + pub struct ClientRequest { pub id: String, - pub response_time_ms: u16, + pub response_time_ms: u32, pub result: Result<(), errors::Error>, pub api_key: String, pub user: String, @@ -28,7 +33,7 @@ pub struct IndexerRequest { pub receipt: Receipt, pub subgraph_chain: String, pub result: Result, - pub response_time_ms: u16, + pub response_time_ms: u32, pub seconds_behind: u32, pub blocks_behind: u64, // TODO: rm pub request: String, @@ -115,7 +120,7 @@ impl Reporter { indexed_chain: indexer_request.subgraph_chain.clone(), url: indexer_request.url.clone(), fee_grt: indexer_request.receipt.value() as f64 * 1e-18, - response_time_ms: indexer_request.response_time_ms as u32, + response_time_ms: indexer_request.response_time_ms, seconds_behind: indexer_request.seconds_behind, result: indexer_request .result @@ -155,7 +160,7 @@ impl Reporter { .result .map(|()| "success".to_string()) .unwrap_or_else(|err| err.to_string()), - response_time_ms: client_request.response_time_ms as u32, + response_time_ms: client_request.response_time_ms, request_bytes: client_request.request_bytes, response_bytes: client_request.response_bytes, total_fees_usd, @@ -417,3 +422,38 @@ mod buffer_tests { .purge(rdkafka::producer::PurgeConfig::default().queue()); } } + +#[cfg(test)] +mod long_duration_tests { + use super::*; + + #[test] + fn milliseconds_preserve_long_requests_and_saturate_at_wire_limit() { + for milliseconds in [ + 0, + 65_535, + 65_536, + 70_000, + u64::from(u32::MAX), + u64::from(u32::MAX) + 1, + ] { + let actual = response_time_ms(Duration::from_millis(milliseconds)); + assert_eq!(u64::from(actual), milliseconds.min(u64::from(u32::MAX))); + } + } + + #[test] + fn protobuf_round_trip_preserves_long_client_and_indexer_durations() { + let message = ClientQueryProtobuf { + response_time_ms: response_time_ms(Duration::from_secs(70)), + indexer_queries: vec![IndexerQueryProtobuf { + response_time_ms: response_time_ms(Duration::from_secs(66)), + ..Default::default() + }], + ..Default::default() + }; + let decoded = ClientQueryProtobuf::decode(message.encode_to_vec().as_slice()).unwrap(); + assert_eq!(decoded.response_time_ms, 70_000); + assert_eq!(decoded.indexer_queries[0].response_time_ms, 66_000); + } +}