Increase the gRPC payload limits from 10MiB to 20MiB. (#4227)

By default our REST client sends batch of 10MiB that gets expanded to
a little bit more after the lines are identified and the batch is
converted to a different format.

If the ingest request is sent to a searcher (like when we use helm with
an ingress pointing to a searcher), it has to be forwarded to an
ingester via gRPC.

This solution is imperfect as the rest payload is actually configurable.

quickwit/quickwit-codegen/src/codegen.rs

@@ -588,8 +588,8 @@ fn generate_client(context: &CodegenContext) -> TokenStream {
             {
                 let connection_keys_watcher = balance_channel.connection_keys_watcher();
                 let client = #grpc_client_package_name::#grpc_client_name::new(balance_channel)
-                    .max_decoding_message_size(10 * 1024 * 1024)
-                    .max_encoding_message_size(10 * 1024 * 1024);
+                    .max_decoding_message_size(20 * 1024 * 1024)
+                    .max_encoding_message_size(20 * 1024 * 1024);
                 let adapter = #grpc_client_adapter_name::new(client, connection_keys_watcher);
                 Self::new(adapter)
             }

quickwit/quickwit-rest-client/src/models.rs

@@ -48,21 +48,25 @@ impl ApiResponse {
         Ok(())
     }
 
-    async fn api_error(self) -> Error {
-        let code = self.inner.status();
-        if let Ok(error_payload) = self.inner.json::<ErrorResponsePayload>().await {
-            Error::from(ApiError {
-                message: Some(error_payload.message),
-                code,
-            })
+    async fn extract_error_message(self) -> Option<String> {
+        let error_body_bytes = self.inner.bytes().await.ok()?;
+        let error_body_text = std::str::from_utf8(&error_body_bytes).ok()?;
+        if let Ok(error_payload) = serde_json::from_str::<ErrorResponsePayload>(error_body_text) {
+            Some(error_payload.message)
         } else {
-            Error::from(ApiError {
-                message: None,
-                code,
-            })
+            Some(error_body_text.to_string())
         }
     }
 
+    async fn api_error(self) -> Error {
+        let code = self.inner.status();
+        let error_message = self.extract_error_message().await;
+        Error::from(ApiError {
+            message: error_message,
+            code,
+        })
+    }
+
     pub async fn deserialize<T: DeserializeOwned>(self) -> Result<T, Error> {
         if self.inner.status().is_client_error() || self.inner.status().is_server_error() {
             Err(self.api_error().await)