Repository: qdrant/qdrant
File: lib/collection/src/shards/remote_shard.rs (Rust)

Code before:
                    })
                    .await?
                    .into_inner()
                }
                PointOperations::SyncPoints(operation) => {
                    let request = &internal_sync_points(
                        shard_id,
                        None, // TODO!?
                        collection_name,
                        operation,
                        wait,
                        ordering,
                    )?;
                    self.with_points_client(|mut client| async move {
                        client.sync(tonic::Request::new(request.clone())).await
                    })
                    .await?
                    .into_inner()
                }
                #[cfg(feature = "staging")]
                PointOperations::TestDelayUpsertPoints(op) => {
                    // TODO: Add gRPC support to forward staging operations to remote shards
                    // For now, staging test delay operations only execute on local shards
                    log::debug!(
                        "TestDelayUpsertPoints: skipping remote shard {} (duration: {}s)",
                        shard_id.unwrap_or(0),
                        op.duration
                    );
                    timer.set_success(true);
                    return Ok(UpdateResult {
                        operation_id: None,
                        status: crate::operations::types::UpdateStatus::Completed,
                        clock_tag: operation.clock_tag,
                    });
                }
            },
            CollectionUpdateOperations::VectorOperation(vector_ops) => match vector_ops {
                VectorOperations::UpdateVectors(update_operation) => {
                    let request = &internal_update_vectors(
                        shard_id,
                        operation.clock_tag,
                        collection_name,
                        update_operation,
                        wait,
                        ordering,
                    )?;
                    self.with_points_client(|mut client| async move {
                        client
                            .update_vectors(tonic::Request::new(request.clone()))
                            .await
                    })

Review comment (suggestion):
```suggestion
                        self.id,
```

Code after:
                    })
                    .await?
                    .into_inner()
                }
                PointOperations::SyncPoints(operation) => {
                    let request = &internal_sync_points(
                        shard_id,
                        None, // TODO!?
                        collection_name,
                        operation,
                        wait,
                        ordering,
                    )?;
                    self.with_points_client(|mut client| async move {
                        client.sync(tonic::Request::new(request.clone())).await
                    })
                    .await?
                    .into_inner()
                }
                #[cfg(feature = "staging")]
                PointOperations::TestDelay(op) => {
                    // TODO: Add gRPC support to forward staging operations to remote shards
                    // For now, staging test delay operations only execute on local shards
                    let delay = std::time::Duration::from_secs_f64(op.duration.into_inner());
                    log::debug!(
                        "TestDelay: skipping remote shard {} (duration: {delay:?})",
                        self.id
                    );
                    timer.set_success(true);
                    return Ok(UpdateResult {
                        operation_id: None,
                        status: crate::operations::types::UpdateStatus::Completed,
                        clock_tag: operation.clock_tag,
                    });
                }
            },
            CollectionUpdateOperations::VectorOperation(vector_ops) => match vector_ops {
                VectorOperations::UpdateVectors(update_operation) => {
                    let request = &internal_update_vectors(
                        shard_id,
                        operation.clock_tag,
                        collection_name,
                        update_operation,
                        wait,
                        ordering,
                    )?;
                    self.with_points_client(|mut client| async move {
                        client
                            .update_vectors(tonic::Request::new(request.clone()))
                            .await
                    })