From 845f81ed83cde6eb6298365e5694905e995a4135 Mon Sep 17 00:00:00 2001 From: 0z5a Date: Mon, 16 Nov 2026 00:23:15 +0100 Subject: [PATCH] fix(lambda-events): make CloudWatch Logs `AwsLogs` round-trip and work with `from_value` Serialize `data` with padded STANDARD base64. Deserialize decodes with STANDARD, which requires canonical padding since base64 0.20, so the unpadded output failed to deserialize for about two payloads in three. Read the map key through a field-identifier enum instead of `&str`, so deserializers that cannot lend borrowed strings (`serde_json::from_value`, `from_reader`) work too. --- .../src/event/cloudwatch_logs/mod.rs | 55 ++++++++++++++++++- 1 file changed, 52 insertions(+), 3 deletions(-) diff --git a/lambda-events/src/event/cloudwatch_logs/mod.rs b/lambda-events/src/event/cloudwatch_logs/mod.rs index 70a9361a..6bb8fde2 100644 --- a/lambda-events/src/event/cloudwatch_logs/mod.rs +++ b/lambda-events/src/event/cloudwatch_logs/mod.rs @@ -107,10 +107,18 @@ impl<'de> Deserialize<'de> for AwsLogs { { use base64::Engine; + // An identifier enum accepts both borrowed and owned keys + // (e.g. `serde_json::from_value`) without allocating. + #[derive(Deserialize)] + #[serde(field_identifier, rename_all = "lowercase")] + enum Field { + Data, + } + let mut data = None; while let Some(key) = map.next_key()? { match key { - "data" => { + Field::Data => { let bytes = map.next_value::().and_then(|string| { base64::engine::general_purpose::STANDARD .decode(string) @@ -121,7 +129,6 @@ impl<'de> Deserialize<'de> for AwsLogs { let mut de = serde_json::Deserializer::from_reader(BufReader::new(bytes)); data = Some(LogData::deserialize(&mut de).map_err(Error::custom)?); } - _ => return Err(Error::unknown_field(key, FIELDS)), } } @@ -140,7 +147,7 @@ impl Serialize for AwsLogs { where S: Serializer, { - let base = base64::write::EncoderWriter::new(Vec::new(), &base64::engine::general_purpose::STANDARD_NO_PAD); + let base = base64::write::EncoderWriter::new(Vec::new(), &base64::engine::general_purpose::STANDARD); let mut gzip = flate2::write::GzEncoder::new(base, flate2::Compression::default()); serde_json::to_writer(&mut gzip, &self.data).map_err(SeError::custom)?; @@ -197,4 +204,46 @@ mod test { let reparsed: LogsEvent = serde_json::from_slice(output.as_bytes()).unwrap(); assert_eq!(parsed, reparsed); } + + #[test] + #[cfg(feature = "cloudwatch_logs")] + fn example_cloudwatch_logs_event_from_value_and_reader() { + let data = include_bytes!("../../fixtures/example-cloudwatch_logs-event.json"); + let parsed: LogsEvent = serde_json::from_slice(data).unwrap(); + + let value: serde_json::Value = serde_json::from_slice(data).unwrap(); + let from_value: LogsEvent = serde_json::from_value(value).unwrap(); + assert_eq!(parsed, from_value); + + let from_reader: LogsEvent = serde_json::from_reader(&data[..]).unwrap(); + assert_eq!(parsed, from_reader); + } + + #[test] + #[cfg(feature = "cloudwatch_logs")] + fn test_serialize_round_trip_pads_base64() { + use base64::Engine; + + let data = include_bytes!("../../fixtures/example-cloudwatch_logs-event.json"); + let mut event: LogsEvent = serde_json::from_slice(data).unwrap(); + + // The gzip output length changes with the message; make sure lengths that are not a + // multiple of 3 (where base64 needs padding) are covered. + let mut saw_padded = false; + for _ in 0..16 { + event.aws_logs.data.log_events[0].message.push('x'); + let json = serde_json::to_string(&event).unwrap(); + + let reparsed: LogsEvent = serde_json::from_str(&json).unwrap(); + assert_eq!(event, reparsed); + + let value: serde_json::Value = serde_json::from_str(&json).unwrap(); + let encoded = value["awslogs"]["data"].as_str().unwrap(); + let decoded = base64::engine::general_purpose::STANDARD + .decode(encoded) + .expect("awslogs.data must be standard padded base64"); + saw_padded |= decoded.len() % 3 != 0; + } + assert!(saw_padded); + } }