From 7e76d28908e32eaa4a7f9bfc8bb6b281ba5bb496 Mon Sep 17 00:00:00 2001 From: Ning Sun Date: Mon, 16 Nov 2026 15:59:31 +0000 Subject: [PATCH] fix(postgres): account for buffered InfluxDB and OTLP COPY bodies (#10450) Signed-off-by: Ning Sun --- src/servers/src/postgres/copy_in/mod.rs | 59 ++++++---- .../src/tests/postgres_copy_in_test.rs | 104 ++++++++++++++++++ 2 files changed, 144 insertions(+), 19 deletions(-) diff --git a/src/servers/src/postgres/copy_in/mod.rs b/src/servers/src/postgres/copy_in/mod.rs index b7fbaf30865..0676557ca3f 100644 --- a/src/servers/src/postgres/copy_in/mod.rs +++ b/src/servers/src/postgres/copy_in/mod.rs @@ -251,7 +251,7 @@ pub(crate) struct CopyInState { query_ctx: QueryContextRef, payload: Payload, /// Reservations against the shared request-memory limiter for the - /// bytes buffered by a Prometheus payload, acquired per CopyData + /// bytes buffered by a table-less payload, acquired per CopyData /// chunk as it arrives and held until the buffer is flushed or the /// copy ends — the receive-stage counterpart of HTTP's /// body-accounting middleware, so concurrent unfinished COPY @@ -430,10 +430,14 @@ impl CopyInState { self.codec_format_code } - /// Prometheus bodies are charged against the shared request-memory limiter - /// as they arrive, before decode and conversion acquire additional memory. + /// Whether the payload buffers raw CopyData bytes until `CopyDone` + /// (the table-less formats); such bytes are charged against the + /// shared request-memory limiter as they arrive. fn buffers_payload(&self) -> bool { - matches!(self.payload, Payload::PromWrite { .. }) + matches!( + self.payload, + Payload::Influxdb { .. } | Payload::Otlp { .. } | Payload::PromWrite { .. } + ) } /// The payload bytes currently buffered (charged or not). @@ -542,14 +546,18 @@ impl CopyInState { } /// Takes the buffered OTLP payload and its options, if any. - fn take_otlp(&mut self) -> Option<(OtlpOptions, Vec)> { + fn take_otlp(&mut self) -> Option<(OtlpOptions, Vec, BufferedReservation)> { let Payload::Otlp { options, data } = &mut self.payload else { return None; }; if data.is_empty() { return None; } - Some((options.clone(), std::mem::take(data))) + Some(( + options.clone(), + std::mem::take(data), + self.take_reservation(), + )) } /// Takes the buffered remote-write body and its options, if any. @@ -570,19 +578,20 @@ impl CopyInState { /// Takes the buffered payload as one line-protocol request body, if /// any — the same bytes an HTTP write of the same records would /// carry. - fn take_lines(&mut self) -> PgWireResult> { + fn take_lines(&mut self) -> PgWireResult> { let Payload::Influxdb { data, precision } = &mut self.payload else { return Ok(None); }; if data.is_empty() { return Ok(None); } - let lines = String::from_utf8(std::mem::take(data)) - .map_err(|e| bad_copy_data(format!("COPY FROM STDIN data is not valid UTF-8: {e}")))?; - Ok(Some(InfluxdbRequest { + let request = InfluxdbRequest { precision: *precision, - lines, - })) + lines: String::from_utf8(std::mem::take(data)).map_err(|e| { + bad_copy_data(format!("COPY FROM STDIN data is not valid UTF-8: {e}")) + })?, + }; + Ok(Some((request, self.take_reservation()))) } } @@ -790,13 +799,23 @@ impl PostgresServerHandlerInner { // timestamp alignment and inserts are identical to an HTTP // write of the same bytes. The context stays this connection's // postgres context. - if let Some((options, bytes)) = state.take_otlp() { + if let Some((options, bytes, reservation)) = state.take_otlp() { let Some(otlp_handler) = &self.otlp_handler else { return Err(unsupported("this server is not wired for the otlp format")); }; - return self - .flush_otlp(otlp_handler, options, bytes, query_ctx) - .await; + // The reservation outlives the payload: it is dropped when + // the payload's bytes are consumed below. + let rows = self + .flush_otlp( + otlp_handler, + options, + bytes, + reservation.charged_bytes(), + query_ctx, + ) + .await?; + drop(reservation); + return Ok(rows); } if let Some((options, bytes, reservation)) = state.take_prom_write() { let Some(prom_write_state) = &self.prom_write_state else { @@ -808,7 +827,7 @@ impl PostgresServerHandlerInner { .flush_prom_write(prom_write_state, options, bytes, reservation, query_ctx) .await; } - if let Some(request) = state.take_lines()? { + if let Some((request, reservation)) = state.take_lines()? { let Some(influxdb_handler) = &self.influxdb_handler else { return Err(unsupported( "this server is not wired for the influxdb line protocol format", @@ -818,6 +837,7 @@ impl PostgresServerHandlerInner { .exec(request, query_ctx) .await .map_err(convert_err)?; + drop(reservation); return match output.data { OutputData::AffectedRows(rows) => Ok(rows as u64), OutputData::RecordBatches(_) | OutputData::Stream(_) => Ok(0), @@ -851,6 +871,7 @@ impl PostgresServerHandlerInner { otlp_handler: &crate::query_handler::OpenTelemetryProtocolHandlerRef, options: OtlpOptions, bytes: Vec, + body_reserved_bytes: u64, query_ctx: QueryContextRef, ) -> PgWireResult { use opentelemetry_proto::tonic::collector::logs::v1::ExportLogsServiceRequest; @@ -886,7 +907,7 @@ impl PostgresServerHandlerInner { .metrics( request, Arc::new(ctx), - Some((self.memory_limiter.clone(), 0)), + Some((self.memory_limiter.clone(), body_reserved_bytes)), ) .await .map_err(convert_err)?; @@ -1108,7 +1129,7 @@ impl CopyHandler for PostgresServerHandlerInner { // otherwise a pooled connection would retain failed-import // buffers until its next COPY. On success it is put back. // - // Buffered Prometheus payloads charge their bytes against the + // Buffered table-less payloads charge their bytes against the // shared request-memory limiter as they arrive (the // receive-stage counterpart of HTTP's body accounting); the // reservation is held until the buffer is flushed or the state diff --git a/tests-integration/src/tests/postgres_copy_in_test.rs b/tests-integration/src/tests/postgres_copy_in_test.rs index 939dea20115..d4b3ed0d4ad 100644 --- a/tests-integration/src/tests/postgres_copy_in_test.rs +++ b/tests-integration/src/tests/postgres_copy_in_test.rs @@ -1952,6 +1952,110 @@ async fn test_postgres_copy_in_prom_write_held_body_quota() { server.shutdown().await.unwrap(); } +/// Existing table-less formats enforce the same receive budget as Prometheus. +/// An oversized body is rejected before either format's decoder runs. +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn test_postgres_copy_in_buffered_receive_quota() { + let server = quota_test_server( + "pg_copy_buffered_receive_quota", + common_memory_manager::OnExhaustedPolicy::Fail, + ) + .await; + let client = connect(server.bind_addr().unwrap().port()).await; + for format in ["influxdb", "otlp"] { + let error = feed_copy_in( + &client, + &format!("COPY FROM STDIN WITH (FORMAT {format})"), + vec![Bytes::from(vec![b'x'; 65 * 1024])], + ) + .await + .unwrap_err(); + assert!( + error + .as_db_error() + .unwrap() + .message() + .to_lowercase() + .contains("memory") + ); + assert!(!client.simple_query("SELECT 1").await.unwrap().is_empty()); + } + server.shutdown().await.unwrap(); +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn test_postgres_copy_in_otlp_held_body_quota() { + use std::time::Duration; + + use otel_arrow_rust::proto::opentelemetry::collector::metrics::v1::ExportMetricsServiceRequest; + use otel_arrow_rust::proto::opentelemetry::common::v1::{AnyValue, KeyValue, any_value}; + use otel_arrow_rust::proto::opentelemetry::metrics::v1::{ + Exemplar, Gauge, Metric, NumberDataPoint, ResourceMetrics, ScopeMetrics, exemplar, metric, + number_data_point, + }; + use prost::Message; + + init_default_ut_logging(); + let server = quota_test_server( + "pg_copy_in_otlp_held_body", + common_memory_manager::OnExhaustedPolicy::Wait { + timeout: Duration::from_secs(30), + }, + ) + .await; + let client = connect(server.bind_addr().unwrap().port()).await; + let request = ExportMetricsServiceRequest { + resource_metrics: vec![ResourceMetrics { + scope_metrics: vec![ScopeMetrics { + metrics: vec![Metric { + name: "copy_otlp_held_body".into(), + data: Some(metric::Data::Gauge(Gauge { + data_points: vec![NumberDataPoint { + time_unix_nano: 1_700_000_000_000_000_000, + value: Some(number_data_point::Value::AsDouble(1.0)), + attributes: vec![KeyValue { + key: "host".into(), + value: Some(AnyValue { + value: Some(any_value::Value::StringValue( + "x".repeat(13 * 1024), + )), + }), + }], + exemplars: vec![Exemplar { + time_unix_nano: 1_700_000_000_000_000_000, + value: Some(exemplar::Value::AsDouble(1.0)), + ..Default::default() + }], + ..Default::default() + }], + })), + ..Default::default() + }], + ..Default::default() + }], + ..Default::default() + }], + }; + let body = request.encode_to_vec(); + let conversion = servers::otlp::metrics::to_grpc_insert_requests( + request, + &mut session::protocol_ctx::OtlpMetricCtx { + with_metric_engine: true, + ..Default::default() + }, + ) + .unwrap(); + assert_eq!(conversion.exemplars.len(), 1); + let expansion = + servers::exemplar::estimated_row_bytes([conversion.exemplars.as_slice()]).unwrap(); + assert!(body.len() < 64 * 1024); + assert!(expansion < 64 * 1024); + assert!(body.len() + expansion > 64 * 1024); + + assert_copy_rejects_held_body(&client, "COPY FROM STDIN WITH (FORMAT otlp)", body).await; + server.shutdown().await.unwrap(); +} + async fn assert_copy_rejects_held_body(client: &tokio_postgres::Client, sql: &str, body: Vec) { let error = tokio::time::timeout( std::time::Duration::from_secs(5),