#[cfg(feature = "content")]
use super::check_antibot_response;
use super::EngineRouter;
use crate::common::metrics_shim::{counter, histogram};
use crate::engines::engine_client::{
EngineError, InternalScrapeRequest, InternalScrapeResponse, ScraperEngine,
};
use log::{debug, info, warn};
use std::sync::atomic::Ordering;
use std::sync::Arc;
use std::time::{Duration, Instant};
type RaceCompletion =
Result<(String, InternalScrapeResponse, Duration), (String, EngineError, Duration)>;
type RaceFuture = std::pin::Pin<Box<dyn std::future::Future<Output = RaceCompletion> + Send>>;
impl EngineRouter {
pub(super) async fn route_race_mode(
&self,
request: &InternalScrapeRequest,
candidates: Vec<(f64, Arc<dyn ScraperEngine>)>,
start_time: Instant,
) -> Result<InternalScrapeResponse, EngineError> {
let remaining = request
.timeout
.checked_sub(start_time.elapsed())
.unwrap_or(Duration::from_millis(0));
if remaining.is_zero() {
return Err(EngineError::Timeout(request.timeout));
}
let pending = build_race_pool(request, candidates, remaining);
self.race_until_win(request, pending, remaining, start_time)
.await
}
async fn race_until_win(
&self,
request: &InternalScrapeRequest,
mut pending: Vec<RaceFuture>,
remaining: Duration,
start_time: Instant,
) -> Result<InternalScrapeResponse, EngineError> {
use futures::future;
use tokio::time;
let timeout_duration = remaining.max(Duration::from_millis(100));
let deadline = time::Instant::now() + timeout_duration;
let total_candidates = pending.len();
let mut last_error: Option<EngineError> = None;
loop {
if pending.is_empty() {
return self
.finish_race_all_failed(request, total_candidates, last_error)
.await;
}
if time::Instant::now() >= deadline {
warn!(
"Race mode timed out after {:?} for request to {}",
timeout_duration, request.url
);
if let Some(e) = last_error {
return Err(e);
}
return Err(EngineError::Timeout(timeout_duration));
}
match time::timeout_at(deadline, future::select_all(pending)).await {
Ok((result, _index, others)) => {
pending = others;
if let Some(outcome) = self
.handle_race_completion(request, result, start_time, &mut last_error)
.await
{
return outcome;
}
}
Err(_) => {
warn!(
"Race mode timed out after {:?} for request to {}",
timeout_duration, request.url
);
return Err(EngineError::Timeout(timeout_duration));
}
}
}
}
#[cfg_attr(not(feature = "content"), allow(unused_variables))]
async fn handle_race_completion(
&self,
request: &InternalScrapeRequest,
result: RaceCompletion,
start_time: Instant,
last_error: &mut Option<EngineError>,
) -> Option<Result<InternalScrapeResponse, EngineError>> {
match result {
Ok((engine_name, response, response_time)) => {
#[cfg(feature = "content")]
if let Some(reason) = self.discard_race_antibot_challenge(
&engine_name,
&request.url,
&response,
response_time,
) {
*last_error = Some(EngineError::AntiBotDetected(reason));
return None;
}
self.record_race_win(&engine_name, response_time, start_time)
.await;
Some(Ok(response))
}
Err((engine_name, e, response_time)) => {
self.record_race_failure(&engine_name, &e, response_time)
.await;
*last_error = Some(e);
None
}
}
}
async fn finish_race_all_failed(
&self,
request: &InternalScrapeRequest,
total_candidates: usize,
last_error: Option<EngineError>,
) -> Result<InternalScrapeResponse, EngineError> {
warn!(
"Race mode: all {} candidates failed for {}",
total_candidates, request.url
);
let antibot_detected = matches!(last_error, Some(EngineError::AntiBotDetected(_)));
if antibot_detected && !request.needs_js {
let mut js_request = request.clone();
js_request.needs_js = true;
info!("Race mode: all candidates hit anti-bot, retrying once with needs_js=true");
return Box::pin(self.route_internal(&js_request)).await;
}
Err(last_error.unwrap_or(EngineError::AllEnginesFailed(
"race mode: all engines failed".to_string(),
)))
}
#[cfg(feature = "content")]
fn discard_race_antibot_challenge(
&self,
engine_name: &str,
request_url: &str,
response: &InternalScrapeResponse,
response_time: Duration,
) -> Option<String> {
if let Some(detection) = check_antibot_response(response, request_url) {
if detection.needs_browser {
self.update_engine_stats(engine_name, false, response_time);
self.metrics
.record_engine_failure(engine_name, &detection.reason);
warn!(
"Race mode: {} returned anti-bot challenge ({:?}): {}, \
discarding and racing remaining candidates",
engine_name, detection.tech, detection.reason
);
return Some(detection.reason);
}
}
None
}
async fn record_race_win(
&self,
engine_name: &str,
response_time: Duration,
start_time: Instant,
) {
self.update_engine_stats(engine_name, true, response_time);
self.circuit_breaker.record_success(engine_name).await;
self.metrics.total_requests.fetch_add(1, Ordering::Relaxed);
self.metrics
.successful_requests
.fetch_add(1, Ordering::Relaxed);
self.metrics
.record_engine_latency(engine_name, response_time);
self.metrics.record_engine_success(engine_name);
counter!(
"crawlrs_engine_success_total",
"engine" => engine_name.to_string(),
"result" => "success"
)
.increment(1);
histogram!(
"crawlrs_engine_duration_seconds",
"engine" => engine_name.to_string()
)
.record(response_time.as_secs_f64());
self.hedge_controller.record_latency(response_time);
info!(
"Race mode: {} won in {:?}, total time: {:?}",
engine_name,
response_time,
start_time.elapsed()
);
}
async fn record_race_failure(
&self,
engine_name: &str,
e: &EngineError,
response_time: Duration,
) {
self.update_engine_stats(engine_name, false, response_time);
self.metrics.total_requests.fetch_add(1, Ordering::Relaxed);
self.metrics.failed_requests.fetch_add(1, Ordering::Relaxed);
self.metrics
.record_engine_failure(engine_name, &e.to_string());
counter!(
"crawlrs_engine_success_total",
"engine" => engine_name.to_string(),
"result" => "failure"
)
.increment(1);
debug!(
"Race mode: {} failed ({}) in {:?}, continuing with remaining candidates",
engine_name, e, response_time
);
if e.is_retryable() {
self.circuit_breaker.record_failure(engine_name).await;
}
}
}
fn clone_race_request(
request: &InternalScrapeRequest,
remaining: Duration,
) -> InternalScrapeRequest {
let remaining_clone = remaining;
InternalScrapeRequest {
url: request.url.clone(),
method: request.method,
headers: request.headers.clone(),
timeout: remaining_clone,
needs_js: request.needs_js,
needs_screenshot: request.needs_screenshot,
screenshot_config: request.screenshot_config.clone(),
mobile: request.mobile,
proxy: request.proxy.clone(),
skip_tls_verification: request.skip_tls_verification,
needs_tls_fingerprint: request.needs_tls_fingerprint,
use_fire_engine: request.use_fire_engine,
actions: request.actions.clone(),
body: request.body.clone(),
sync_wait_ms: request.sync_wait_ms,
block_ads: request.block_ads,
block_media: request.block_media,
session_id: request.session_id.clone(),
wait_for: request.wait_for.clone(),
needs_mllm: request.needs_mllm,
}
}
fn build_race_pool(
request: &InternalScrapeRequest,
candidates: Vec<(f64, Arc<dyn ScraperEngine>)>,
remaining: Duration,
) -> Vec<RaceFuture> {
let race_candidates: Vec<_> = candidates.into_iter().take(3).collect();
debug!(
"Race mode: launching {} engines concurrently for {}",
race_candidates.len(),
request.url
);
let mut race_futures: Vec<RaceFuture> = Vec::new();
for (_score, engine) in race_candidates {
race_futures.push(build_race_future(
&engine,
clone_race_request(request, remaining),
));
}
race_futures
}
fn build_race_future(
engine: &Arc<dyn ScraperEngine>,
request_clone: InternalScrapeRequest,
) -> RaceFuture {
let engine_name = engine.name().to_string();
let engine_clone = engine.clone();
Box::pin(async move {
let engine_start = Instant::now();
match engine_clone.scrape(&request_clone).await {
Ok(response) => Ok((engine_name, response, engine_start.elapsed())),
Err(e) => Err((engine_name, e, engine_start.elapsed())),
}
})
}