#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum CodecError {
Capacity,
}
pub(super) trait EncodingTarget {
fn append(&mut self, bytes: &[u8]) -> Result<(), CodecError>;
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) enum Scalar<'a> {
String(&'a str),
Signed(i64),
Unsigned(u64),
Bool(bool),
Null,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) struct Field<'a> {
pub(super) name: &'a str,
pub(super) value: Scalar<'a>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) struct JsonlRecord<'a> {
pub(super) timestamp_unix_ms: u128,
pub(super) level: &'a str,
pub(super) event: &'a str,
pub(super) trace_id: Option<&'a str>,
pub(super) span_id: Option<&'a str>,
pub(super) parent_span_id: Option<&'a str>,
pub(super) fields: &'a [Field<'a>],
pub(super) dropped_events: u64,
}
pub(super) fn encode_jsonl(
target: &mut impl EncodingTarget,
record: JsonlRecord<'_>,
) -> Result<(), CodecError> {
target.append(b"{\"timestamp_unix_ms\":")?;
unsigned(target, record.timestamp_unix_ms)?;
target.append(b",\"level\":")?;
string(target, record.level)?;
target.append(b",\"event\":")?;
string(target, record.event)?;
optional_string(target, b",\"trace_id\":", record.trace_id)?;
optional_string(target, b",\"span_id\":", record.span_id)?;
optional_string(target, b",\"parent_span_id\":", record.parent_span_id)?;
for field in record.fields {
target.append(b",")?;
string(target, field.name)?;
target.append(b":")?;
scalar(target, field.value)?;
}
if record.dropped_events != 0 {
target.append(b",\"dropped_events\":")?;
unsigned(target, u128::from(record.dropped_events))?;
}
target.append(b"}\n")
}
fn optional_string(
target: &mut impl EncodingTarget,
key: &[u8],
value: Option<&str>,
) -> Result<(), CodecError> {
if let Some(value) = value {
target.append(key)?;
string(target, value)?;
}
Ok(())
}
fn scalar(target: &mut impl EncodingTarget, value: Scalar<'_>) -> Result<(), CodecError> {
match value {
Scalar::String(value) => string(target, value),
Scalar::Signed(value) => signed(target, value),
Scalar::Unsigned(value) => unsigned(target, u128::from(value)),
Scalar::Bool(true) => target.append(b"true"),
Scalar::Bool(false) => target.append(b"false"),
Scalar::Null => target.append(b"null"),
}
}
fn string(target: &mut impl EncodingTarget, value: &str) -> Result<(), CodecError> {
target.append(b"\"")?;
let bytes = value.as_bytes();
let mut plain_start = 0;
for (index, byte) in bytes.iter().copied().enumerate() {
let escape = match byte {
b'"' => Some(&b"\\\""[..]),
b'\\' => Some(&b"\\\\"[..]),
0x08 => Some(&b"\\b"[..]),
0x0c => Some(&b"\\f"[..]),
b'\n' => Some(&b"\\n"[..]),
b'\r' => Some(&b"\\r"[..]),
b'\t' => Some(&b"\\t"[..]),
0x00..=0x1f => None,
_ => continue,
};
target.append(&bytes[plain_start..index])?;
if let Some(escape) = escape {
target.append(escape)?;
} else {
let encoded = [b'\\', b'u', b'0', b'0', hex(byte >> 4), hex(byte & 0x0f)];
target.append(&encoded)?;
}
plain_start = index + 1;
}
target.append(&bytes[plain_start..])?;
target.append(b"\"")
}
const fn hex(value: u8) -> u8 {
match value {
0..=9 => b'0' + value,
_ => b'a' + value - 10,
}
}
fn signed(target: &mut impl EncodingTarget, value: i64) -> Result<(), CodecError> {
if value < 0 {
target.append(b"-")?;
}
unsigned(target, u128::from(value.unsigned_abs()))
}
fn unsigned(target: &mut impl EncodingTarget, mut value: u128) -> Result<(), CodecError> {
let mut buffer = [0_u8; 39];
let mut cursor = buffer.len();
loop {
cursor -= 1;
buffer[cursor] = b'0' + u8::try_from(value % 10).expect("decimal digit fits in u8");
value /= 10;
if value == 0 {
break;
}
}
target.append(&buffer[cursor..])
}
#[cfg(test)]
mod tests {
use super::*;
struct FixedTarget<const N: usize> {
bytes: [u8; N],
length: usize,
}
impl<const N: usize> FixedTarget<N> {
const fn new() -> Self {
Self {
bytes: [0; N],
length: 0,
}
}
}
impl<const N: usize> EncodingTarget for FixedTarget<N> {
fn append(&mut self, bytes: &[u8]) -> Result<(), CodecError> {
let end = self
.length
.checked_add(bytes.len())
.ok_or(CodecError::Capacity)?;
if end > N {
return Err(CodecError::Capacity);
}
self.bytes[self.length..end].copy_from_slice(bytes);
self.length = end;
Ok(())
}
}
fn record<'a>(fields: &'a [Field<'a>]) -> JsonlRecord<'a> {
JsonlRecord {
timestamp_unix_ms: 1_725_000_000_123,
level: "info",
event: "domain.event",
trace_id: Some("0123456789abcdef0123456789abcdef"),
span_id: Some("0123456789abcdef"),
parent_span_id: None,
fields,
dropped_events: 0,
}
}
#[test]
fn encodes_real_jsonl_fields_and_escapes_without_intermediate_buffer() {
let fields = [
Field {
name: "message",
value: Scalar::String("引号\"、换行\n和\u{1f}"),
},
Field {
name: "minimum",
value: Scalar::Signed(i64::MIN),
},
Field {
name: "count",
value: Scalar::Unsigned(u64::MAX),
},
Field {
name: "accepted",
value: Scalar::Bool(true),
},
Field {
name: "optional",
value: Scalar::Null,
},
];
let mut target = FixedTarget::<1024>::new();
encode_jsonl(&mut target, record(&fields)).unwrap();
let encoded = &target.bytes[..target.length];
serde_json::from_slice::<serde_json::Value>(&encoded[..encoded.len() - 1]).unwrap();
assert!(encoded.ends_with(b"}\n"));
assert!(encoded.windows(6).any(|value| value == br#"\u001f"#));
}
#[test]
fn capacity_failure_is_explicit_and_never_grows_target() {
let mut target = FixedTarget::<16>::new();
assert_eq!(
encode_jsonl(&mut target, record(&[])),
Err(CodecError::Capacity)
);
assert_eq!(target.bytes.len(), 16);
}
}