‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

🏁 Script executed:

#!/bin/bash
# Find all instances of OperationError::timeout calls with timeout.as_secs()
echo "=== Searching for OperationError::timeout calls with timeout.as_secs() ==="
rg -nP 'OperationError::timeout\s*\(' -A 3 -B 1

echo -e "\n=== Searching for timeout.as_secs() usage ==="
rg -nP 'timeout\.as_secs\(\)' -C 2

echo -e "\n=== Finding all files that contain timeout precision conversion ==="
rg -l 'timeout\.as_secs\(\)'

Length of output: 13938

🏁 Script executed:

#!/bin/bash
# Create GitHub issue with comprehensive list of all timeout precision instances

gh issue create \
  --title "Improve timeout precision in error messages (sub-second durations truncated)" \
  --assignee agourlay \
  --body "## Problem

When creating timeout errors, we use \`timeout.as_secs()\` which truncates sub-second durations. If a timeout is less than 1 second (e.g., \`Duration::from_millis(500)\`), the error message will read \"timed out after 0 seconds\", which is misleading.

## Related PR and Discussion

- PR: #7588
- Comment: https://github.com/qdrant/qdrant/pull/7588#discussion_r2589088088

## Solution

Use \`timeout.as_millis()\` or \`timeout.as_secs().max(1)\` to preserve precision or ensure non-zero values.

## All Instances Requiring Fix

### Critical: Error Creation (23 instances)

These directly affect error messages and should be fixed:

1. **lib/shard/src/retrieve/retrieve_blocking.rs:31**
   \`\`\`rust
   OperationError::timeout(timeout.as_secs() as usize, \"retrieve points\")
   \`\`\`

2. **src/common/telemetry.rs:117**
   \`\`\`rust
   StorageError::timeout(timeout.as_secs() as usize, \"collections telemetry\")
   \`\`\`

3. **lib/collection/src/shards/local_shard/query.rs:141**
   \`\`\`rust
   CollectionError::timeout(timeout.as_secs() as usize, \"retrieve\")
   \`\`\`

4. **lib/collection/src/shards/local_shard/scroll.rs:59**
   \`\`\`rust
   CollectionError::timeout(timeout.as_secs() as usize, \"Query scroll\")
   \`\`\`

5. **lib/collection/src/shards/local_shard/scroll.rs:186**
   \`\`\`rust
   CollectionError::timeout(timeout.as_secs() as usize, \"scroll_by_id\")
   \`\`\`

6. **lib/collection/src/shards/local_shard/scroll.rs:212**
   \`\`\`rust
   CollectionError::timeout(timeout.as_secs() as usize, \"retrieve\")
   \`\`\`

7. **lib/collection/src/shards/local_shard/scroll.rs:275**
   \`\`\`rust
   CollectionError::timeout(timeout.as_secs() as usize, \"scroll_by_field\")
   \`\`\`

8. **lib/collection/src/shards/local_shard/scroll.rs:308**
   \`\`\`rust
   CollectionError::timeout(timeout.as_secs() as usize, \"retrieve\")
   \`\`\`

9. **lib/collection/src/shards/local_shard/scroll.rs:378**
   \`\`\`rust
   CollectionError::timeout(timeout.as_secs() as usize, \"scroll_randomly\")
   \`\`\`

10. **lib/collection/src/shards/local_shard/scroll.rs:448**
    \`\`\`rust
    CollectionError::timeout(timeout.as_secs() as usize, \"retrieve\")
    \`\`\`

11. **lib/collection/src/shards/local_shard/shard_ops.rs:263**
    \`\`\`rust
    CollectionError::timeout(timeout.as_secs() as usize, \"count\")
    \`\`\`

12. **lib/collection/src/shards/local_shard/shard_ops.rs:304**
    \`\`\`rust
    CollectionError::timeout(timeout.as_secs() as usize, \"retrieve\")
    \`\`\`

13. **lib/collection/src/shards/local_shard/telemetry.rs:38**
    \`\`\`rust
    CollectionError::timeout(timeout.as_secs() as usize, \"shard telemetry\")
    \`\`\`

14. **lib/collection/src/shards/local_shard/telemetry.rs:51**
    \`\`\`rust
    CollectionError::timeout(timeout.as_secs() as usize, \"shard telemetry\")
    \`\`\`

15. **lib/collection/src/shards/local_shard/telemetry.rs:130**
    \`\`\`rust
    CollectionError::timeout(timeout.as_secs() as usize, \"optimization status\")
    \`\`\`

16. **lib/collection/src/shards/local_shard/formula_rescore.rs:44**
    \`\`\`rust
    CollectionError::timeout(timeout.as_secs() as usize, \"rescore_with_formula\")
    \`\`\`

17. **lib/collection/src/shards/local_shard/facet.rs:63**
    \`\`\`rust
    CollectionError::timeout(timeout.as_secs() as usize, \"facet\")
    \`\`\`

18. **lib/collection/src/shards/local_shard/facet.rs:142**
    \`\`\`rust
    CollectionError::timeout(timeout.as_secs() as usize, \"facet\")
    \`\`\`

19. **lib/collection/src/shards/local_shard/facet.rs:191**
    \`\`\`rust
    CollectionError::timeout(timeout.as_secs() as usize, \"facet\")
    \`\`\`

20. **lib/collection/src/shards/local_shard/search.rs:143**
    \`\`\`rust
    CollectionError::timeout(timeout.as_secs() as usize, \"Search\")
    \`\`\`

21. **lib/collection/src/shards/replica_set/mod.rs:592**
    \`\`\`rust
    CollectionError::timeout(timeout.as_secs() as usize, \"wait for replica set state\")
    \`\`\`

22. **lib/collection/src/grouping/builder.rs:77**
    \`\`\`rust
    CollectionError::timeout(timeout.as_secs() as usize, \"GroupBy\")
    \`\`\`

23. **lib/collection/src/collection/mmr.rs:42**
    \`\`\`rust
    CollectionError::timeout(timeout.as_secs() as usize, \"mmr\")
    \`\`\`

### Lower Priority: Logging and Formatting (7 instances)

These are in log messages or error string formatting and have less impact:

24. **lib/collection/src/shards/local_shard/scroll.rs:57** (log message)
25. **lib/collection/src/shards/local_shard/search.rs:141** (log message)
26. **lib/collection/src/grouping/builder.rs:76** (log message)
27. **lib/storage/src/content_manager/consensus_manager.rs:771** (error message formatting)
28. **lib/collection/src/shards/replica_set/update.rs:493** (error message formatting)
29. **lib/collection/src/shards/proxy_shard.rs:124** (retry log message)
30. **lib/collection/src/shards/channel_service.rs:119** (gRPC field - may need different handling)

## Recommended Approach

1. Fix all 23 critical error creation instances first
2. Consider fixing logging instances for consistency
3. Evaluate gRPC field separately (may require protocol consideration)"

Length of output: 44

• File: lib/collection/src/collection/point_ops.rs

  • Snippet (lines 398-472)

    pub async fn retrieve(
            &self,
            request: PointRequestInternal,
            read_consistency: Option<ReadConsistency>,
            shard_selection: &ShardSelectorInternal,
            timeout: Option<Duration>,
            hw_measurement_acc: HwMeasurementAcc,
        ) -> CollectionResult<Vec<RecordInternal>> {
            if request.ids.is_empty() {
                return Ok(Vec::new());
            }
            let with_payload_interface = request
                .with_payload
                .as_ref()
                .unwrap_or(&WithPayloadInterface::Bool(false));
            let with_payload = WithPayload::from(with_payload_interface);
            let ids_len = request.ids.len();
            let request = Arc::new(request);
    
            let shard_holder = self.shards_holder.read().await;
            let target_shards = shard_holder.select_shards(shard_selection)?;
            let mut all_shard_collection_requests = target_shards
                .into_iter()
                .map(|(shard, shard_key)| {
                    // Explicitly borrow `request` and `with_payload`, so we can use them in `async move`
                    // block below without unnecessarily cloning anything
                    let request = &request;
                    let with_payload = &with_payload;
    
                    let hw_acc = hw_measurement_acc.clone();
    
                    async move {
                        let mut records = shard
                            .retrieve(
                                request.clone(),
                                with_payload,
                                &request.with_vector,
                                read_consistency,
                                timeout,
                                shard_selection.is_shard_id(),
                                hw_acc,
                            )
                            .await?;
    
                        if shard_key.is_none() {
                            return Ok(records);
                        }
    
                        for point in &mut records {
                            point.shard_key.clone_from(&shard_key.cloned());
                        }
    
                        CollectionResult::Ok(records)
                    }
                })
                .collect::<FuturesUnordered<_>>();
    
            // pre-allocate hashmap with capped capacity to protect from malevolent input
            let mut covered_point_ids = HashMap::with_capacity(ids_len.min(1024));
            while let Some(response) = all_shard_collection_requests.try_next().await? {
                for point in response {
                    // Add each point only once, deduplicate point IDs
                    covered_point_ids.insert(point.id, point);
                }
            }
    
            // Collect points in the same order as they were requested
            let points = request
                .ids
                .iter()
                .filter_map(|id| covered_point_ids.remove(id))
                .collect();
    
            Ok(points)
        }
    

• File: lib/collection/src/shards/local_shard/shard_ops.rs

  • Snippet (lines 277-316)

    async fn retrieve(
            &self,
            request: Arc<PointRequestInternal>,
            with_payload: &WithPayload,
            with_vector: &WithVector,
            search_runtime_handle: &Handle,
            timeout: Option<Duration>,
            hw_measurement_acc: HwMeasurementAcc,
        ) -> CollectionResult<Vec<RecordInternal>> {
            // Check read rate limiter before proceeding
            self.check_read_rate_limiter(&hw_measurement_acc, "retrieve", || request.ids.len())?;
            let timeout = timeout.unwrap_or(self.shared_storage_config.search_timeout);
    
            let start_time = Instant::now();
            let records_map = tokio::time::timeout(
                timeout,
                SegmentsSearcher::retrieve(
                    self.segments.clone(),
                    &request.ids,
                    with_payload,
                    with_vector,
                    search_runtime_handle,
                    timeout,
                    hw_measurement_acc,
                ),
            )
            .await
            .map_err(|_: Elapsed| CollectionError::timeout(timeout.as_secs() as usize, "retrieve"))??;
    
            let ordered_records = request
                .ids
                .iter()
                .filter_map(|point| records_map.get(point).cloned())
                .collect();
    
            let elapsed = start_time.elapsed();
            log_request_to_collector(&self.collection_name, elapsed, || request);
    
            Ok(ordered_records)
        }
    

• File: lib/collection/src/collection_manager/segments_searcher.rs

  • Snippet (lines 360-390)

    pub async fn retrieve(
            segments: LockedSegmentHolder,
            points: &[PointIdType],
            with_payload: &WithPayload,
            with_vector: &WithVector,
            runtime_handle: &Handle,
            timeout: Duration,
            hw_measurement_acc: HwMeasurementAcc,
        ) -> CollectionResult<AHashMap<PointIdType, RecordInternal>> {
            let stopping_guard = StoppingGuard::new();
            let points = runtime_handle.spawn_blocking({
                let segments = segments.clone();
                let points = points.to_vec();
                let with_payload = with_payload.clone();
                let with_vector = with_vector.clone();
                let is_stopped = stopping_guard.get_is_stopped();
                // TODO create one Task per segment level retrieve
                move || {
                    retrieve_blocking(
                        segments,
                        &points,
                        &with_payload,
                        &with_vector,
                        timeout,
                        &is_stopped,
                        hw_measurement_acc,
                    )
                }
            });
            Ok(AbortOnDropHandle::new(points).await??)
        }
    

• File: lib/segment/src/common/operation_error.rs

  • Snippet (lines 119-126)

    pub fn timeout(timeout_sec: usize, operation: impl Into<String>) -> Self {
            Self::Timeout {
                description: format!(
                    "Operation '{}' timed out after {timeout_sec} seconds",
                    operation.into()
                ),
            }
        }
    

• File: lib/edge/src/retrieve.rs

  • Snippet (lines 12-38)

    pub fn retrieve(
            &self,
            point_ids: &[ExtendedPointId],
            with_payload: Option<WithPayloadInterface>,
            with_vector: Option<WithVector>,
        ) -> OperationResult<Vec<RecordInternal>> {
            let with_payload =
                WithPayload::from(with_payload.unwrap_or(WithPayloadInterface::Bool(true)));
            let with_vector = with_vector.unwrap_or(WithVector::Bool(false));
    
            let mut points = retrieve_blocking(
                self.segments.clone(),
                point_ids,
                &with_payload,
                &with_vector,
                DEFAULT_EDGE_TIMEOUT,
                &AtomicBool::new(false),
                HwMeasurementAcc::disposable(),
            )?;
    
            let points: Vec<_> = point_ids
                .iter()
                .filter_map(|id| points.remove(id))
                .collect();
    
            Ok(points)
        }