Send client and rust version to server

Cargo.toml

@@ -23,6 +23,7 @@ reqwest = { version = "0.12.8", optional = true, default-features = false, featu
 futures-util = { version = "0.3.31", optional = true }
 derive_builder = { version = "0.20.2" }
 thiserror = "1.0.64"
+rustc_version = "0.4"
 
 [dev-dependencies]
 tonic-build = { version = "0.12.3", features = ["prost"] }

src/client/collection.rs

@@ -20,17 +20,26 @@ use crate::qdrant::{
     SparseVectorConfig, UpdateCollection, UpdateCollectionClusterSetupRequest,
     UpdateCollectionClusterSetupResponse, VectorsConfigDiff,
 };
+use crate::user_agent::UserAgentInterceptor;
 
 impl QdrantClient {
     // Access to raw collection API
     pub async fn with_collections_client<T, O: Future<Output = anyhow::Result<T, Status>>>(
         &self,
-        f: impl Fn(CollectionsClient<InterceptedService<Channel, TokenInterceptor>>) -> O,
+        f: impl Fn(
+            CollectionsClient<
+                InterceptedService<
+                    InterceptedService<Channel, TokenInterceptor>,
+                    UserAgentInterceptor,
+                >,
+            >,
+        ) -> O,
     ) -> anyhow::Result<T, Status> {
         self.channel
             .with_channel(
                 |channel| {
                     let service = self.with_api_key(channel);
+                    let service = InterceptedService::new(service, UserAgentInterceptor::new());
                     let mut client =
                         CollectionsClient::new(service).max_decoding_message_size(usize::MAX);
                     if let Some(compression) = self.cfg.compression {

src/client/mod.rs

@@ -21,6 +21,7 @@ pub use crate::auth::TokenInterceptor;
 use crate::channel_pool::ChannelPool;
 pub use crate::payload::Payload;
 use crate::qdrant::{qdrant_client, HealthCheckReply, HealthCheckRequest};
+use crate::user_agent::UserAgentInterceptor;
 
 /// A builder for `QdrantClient`s
 #[deprecated(since = "1.10.0", note = "use `qdrant_client::QdrantBuilder` instead")]
@@ -81,12 +82,20 @@ impl QdrantClient {
     // Access to raw root qdrant API
     pub async fn with_root_qdrant_client<T, O: Future<Output = Result<T, Status>>>(
         &self,
-        f: impl Fn(qdrant_client::QdrantClient<InterceptedService<Channel, TokenInterceptor>>) -> O,
+        f: impl Fn(
+            qdrant_client::QdrantClient<
+                InterceptedService<
+                    InterceptedService<Channel, TokenInterceptor>,
+                    UserAgentInterceptor,
+                >,
+            >,
+        ) -> O,
     ) -> Result<T, Status> {
         self.channel
             .with_channel(
                 |channel| {
                     let service = self.with_api_key(channel);
+                    let service = InterceptedService::new(service, UserAgentInterceptor::new());
                     let mut client = qdrant_client::QdrantClient::new(service)
                         .max_decoding_message_size(usize::MAX);
                     if let Some(compression) = self.cfg.compression {

src/client/points.rs

@@ -20,17 +20,26 @@ use crate::qdrant::{
     UpdateBatchPoints, UpdateBatchResponse, UpdatePointVectors, UpsertPoints, VectorsSelector,
     WithPayloadSelector, WithVectorsSelector, WriteOrdering,
 };
+use crate::user_agent::UserAgentInterceptor;
 
 impl QdrantClient {
     // Access to raw points API
     pub async fn with_points_client<T, O: Future<Output = anyhow::Result<T, Status>>>(
         &self,
-        f: impl Fn(PointsClient<InterceptedService<Channel, TokenInterceptor>>) -> O,
+        f: impl Fn(
+            PointsClient<
+                InterceptedService<
+                    InterceptedService<Channel, TokenInterceptor>,
+                    UserAgentInterceptor,
+                >,
+            >,
+        ) -> O,
     ) -> anyhow::Result<T, Status> {
         self.channel
             .with_channel(
                 |channel| {
                     let service = self.with_api_key(channel);
+                    let service = InterceptedService::new(service, UserAgentInterceptor::new());
                     let mut client =
                         PointsClient::new(service).max_decoding_message_size(usize::MAX);
                     if let Some(compression) = self.cfg.compression {

src/client/snapshot.rs

@@ -14,16 +14,25 @@ use crate::qdrant::{
     DeleteFullSnapshotRequest, DeleteSnapshotRequest, DeleteSnapshotResponse,
     ListFullSnapshotsRequest, ListSnapshotsRequest, ListSnapshotsResponse,
 };
+use crate::user_agent::UserAgentInterceptor;
 
 impl QdrantClient {
     pub async fn with_snapshot_client<T, O: Future<Output = anyhow::Result<T, Status>>>(
         &self,
-        f: impl Fn(SnapshotsClient<InterceptedService<Channel, TokenInterceptor>>) -> O,
+        f: impl Fn(
+            SnapshotsClient<
+                InterceptedService<
+                    InterceptedService<Channel, TokenInterceptor>,
+                    UserAgentInterceptor,
+                >,
+            >,
+        ) -> O,
     ) -> anyhow::Result<T, Status> {
         self.channel
             .with_channel(
                 |channel| {
                     let service = self.with_api_key(channel);
+                    let service = InterceptedService::new(service, UserAgentInterceptor::new());
                     let mut client =
                         SnapshotsClient::new(service).max_decoding_message_size(usize::MAX);
                     if let Some(compression) = self.cfg.compression {

src/lib.rs

@@ -139,6 +139,7 @@ mod grpc_macros;
 mod manual_builder;
 mod payload;
 mod qdrant_client;
+mod user_agent;
 // Deprecated modules
 /// Deprecated Qdrant client
 #[deprecated(

src/qdrant_client/collection.rs

@@ -15,6 +15,7 @@ use crate::qdrant::{
     UpdateCollection, UpdateCollectionClusterSetupRequest, UpdateCollectionClusterSetupResponse,
 };
 use crate::qdrant_client::{Qdrant, QdrantResult};
+use crate::user_agent::UserAgentInterceptor;
 
 /// # Collection operations
 ///
@@ -25,13 +26,21 @@ use crate::qdrant_client::{Qdrant, QdrantResult};
 impl Qdrant {
     pub(super) async fn with_collections_client<T, O: Future<Output = Result<T, Status>>>(
         &self,
-        f: impl Fn(CollectionsClient<InterceptedService<Channel, TokenInterceptor>>) -> O,
+        f: impl Fn(
+            CollectionsClient<
+                InterceptedService<
+                    InterceptedService<Channel, TokenInterceptor>,
+                    UserAgentInterceptor,
+                >,
+            >,
+        ) -> O,
     ) -> QdrantResult<T> {
         let result = self
             .channel
             .with_channel(
                 |channel| {
                     let service = self.with_api_key(channel);
+                    let service = InterceptedService::new(service, UserAgentInterceptor::new());
                     let mut client =
                         CollectionsClient::new(service).max_decoding_message_size(usize::MAX);
                     if let Some(compression) = self.config.compression {

src/qdrant_client/mod.rs

@@ -21,6 +21,7 @@ use crate::auth::TokenInterceptor;
 use crate::channel_pool::ChannelPool;
 use crate::qdrant::{qdrant_client, HealthCheckReply, HealthCheckRequest};
 use crate::qdrant_client::config::QdrantConfig;
+use crate::user_agent::UserAgentInterceptor;
 use crate::QdrantError;
 
 /// [`Qdrant`] client result
@@ -132,13 +133,21 @@ impl Qdrant {
     // Access to raw root qdrant API
     async fn with_root_qdrant_client<T, O: Future<Output = Result<T, Status>>>(
         &self,
-        f: impl Fn(qdrant_client::QdrantClient<InterceptedService<Channel, TokenInterceptor>>) -> O,
+        f: impl Fn(
+            qdrant_client::QdrantClient<
+                InterceptedService<
+                    InterceptedService<Channel, TokenInterceptor>,
+                    UserAgentInterceptor,
+                >,
+            >,
+        ) -> O,
     ) -> QdrantResult<T> {
         let result = self
             .channel
             .with_channel(
                 |channel| {
                     let service = self.with_api_key(channel);
+                    let service = InterceptedService::new(service, UserAgentInterceptor::new());
                     let mut client = qdrant_client::QdrantClient::new(service)
                         .max_decoding_message_size(usize::MAX);
                     if let Some(compression) = self.config.compression {

src/qdrant_client/points.rs

@@ -13,6 +13,7 @@ use crate::qdrant::{
     UpdateBatchResponse, UpdatePointVectors, UpsertPoints,
 };
 use crate::qdrant_client::{Qdrant, QdrantResult};
+use crate::user_agent::UserAgentInterceptor;
 
 /// # Point operations
 ///
@@ -22,13 +23,21 @@ use crate::qdrant_client::{Qdrant, QdrantResult};
 impl Qdrant {
     pub(crate) async fn with_points_client<T, O: Future<Output = Result<T, Status>>>(
         &self,
-        f: impl Fn(PointsClient<InterceptedService<Channel, TokenInterceptor>>) -> O,
+        f: impl Fn(
+            PointsClient<
+                InterceptedService<
+                    InterceptedService<Channel, TokenInterceptor>,
+                    UserAgentInterceptor,
+                >,
+            >,
+        ) -> O,
     ) -> QdrantResult<T> {
         let result = self
             .channel
             .with_channel(
                 |channel| {
                     let service = self.with_api_key(channel);
+                    let service = InterceptedService::new(service, UserAgentInterceptor::new());
                     let mut client =
                         PointsClient::new(service).max_decoding_message_size(usize::MAX);
                     if let Some(compression) = self.config.compression {

src/qdrant_client/snapshot.rs

@@ -12,6 +12,7 @@ use crate::qdrant::{
     ListFullSnapshotsRequest, ListSnapshotsRequest, ListSnapshotsResponse,
 };
 use crate::qdrant_client::{Qdrant, QdrantResult};
+use crate::user_agent::UserAgentInterceptor;
 
 /// # Snapshot operations
 ///
@@ -21,13 +22,21 @@ use crate::qdrant_client::{Qdrant, QdrantResult};
 impl Qdrant {
     async fn with_snapshot_client<T, O: Future<Output = Result<T, Status>>>(
         &self,
-        f: impl Fn(SnapshotsClient<InterceptedService<Channel, TokenInterceptor>>) -> O,
+        f: impl Fn(
+            SnapshotsClient<
+                InterceptedService<
+                    InterceptedService<Channel, TokenInterceptor>,
+                    UserAgentInterceptor,
+                >,
+            >,
+        ) -> O,
     ) -> QdrantResult<T> {
         let result = self
             .channel
             .with_channel(
                 |channel| {
                     let service = self.with_api_key(channel);
+                    let service = InterceptedService::new(service, UserAgentInterceptor::new());
                     let mut client =
                         SnapshotsClient::new(service).max_decoding_message_size(usize::MAX);
                     if let Some(compression) = self.config.compression {

src/user_agent.rs

@@ -0,0 +1,46 @@
+use rustc_version::version_meta;
+use tonic::service::Interceptor;
+use tonic::{Request, Status};
+
+pub struct UserAgentInterceptor {
+    rust_version: Option<String>,
+    rust_client_version: Option<String>,
+}
+
+impl Default for UserAgentInterceptor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl UserAgentInterceptor {
+    pub fn new() -> Self {
+        let rust_version = Some(version_meta().unwrap().semver.to_string());
+        let rust_client_version = Some(env!("CARGO_PKG_VERSION").to_string());
+
+        Self {
+            rust_version,
+            rust_client_version,
+        }
+    }
+}
+
+impl Interceptor for UserAgentInterceptor {
+    fn call(&mut self, mut req: Request<()>) -> Result<Request<()>, Status> {
+        let user_agent_value = format!(
+            "rust-client/{} rust/{}",
+            self.rust_version.clone().unwrap_or_default(),
+            self.rust_client_version.clone().unwrap_or_default()
+        );
+        req.metadata_mut().insert(
+            "x-user-agent",
+            user_agent_value.parse().map_err(|_| {
+                Status::invalid_argument(format!(
+                    "Malformed user-agent value: {}",
+                    user_agent_value
+                ))
+            })?,
+        );
+        Ok(req)
+    }
+}