use std::borrow::Cow;
use std::fmt;
use std::sync::atomic::{AtomicU64, Ordering};
static COUNTER: AtomicU64 = AtomicU64::new(0);
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct RequestId(u128);
impl RequestId {
pub fn generate() -> Self {
let millis = chrono::Utc::now().timestamp_millis().max(0) as u128;
let counter = COUNTER.fetch_add(1, Ordering::Relaxed) as u128;
RequestId((millis << 64) | counter)
}
pub fn from_u128(v: u128) -> Self {
RequestId(v)
}
pub fn as_u128(&self) -> u128 {
self.0
}
pub fn parse_hex(s: &str) -> Option<Self> {
let s = s.trim();
let normalized = if s.contains('-') {
Cow::Owned(s.replace('-', ""))
} else {
Cow::Borrowed(s)
};
if normalized.is_empty() || normalized.len() > 32 {
return None;
}
u128::from_str_radix(&normalized, 16)
.ok()
.filter(|value| *value != 0)
.map(RequestId)
}
}
impl fmt::Display for RequestId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{:032x}", self.0)
}
}
impl Default for RequestId {
fn default() -> Self {
Self::generate()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn generate_is_monotonic_within_process() {
let a = RequestId::generate();
let b = RequestId::generate();
assert_ne!(a, b, "连续生成的 request_id 不应相同");
assert!(b.as_u128() > a.as_u128(), "request_id 应单调递增");
}
#[test]
fn display_is_32_hex_chars() {
let id = RequestId::from_u128(0x0192_f4a1_c3d5_0000_0000_0000_0000_002a);
let s = id.to_string();
assert_eq!(s.len(), 32, "应为 32 位定宽十六进制: {}", s);
assert!(s.chars().all(|c| c.is_ascii_hexdigit()));
}
#[test]
fn parse_hex_roundtrip() {
let id = RequestId::from_u128(0xdead_beef);
let parsed = RequestId::parse_hex(&id.to_string()).expect("应能解析");
assert_eq!(id, parsed);
}
#[test]
fn parse_hex_rejects_invalid() {
assert!(RequestId::parse_hex("").is_none());
assert!(RequestId::parse_hex("xyz").is_none());
assert!(RequestId::parse_hex(&"f".repeat(33)).is_none());
}
#[test]
fn parse_hex_accepts_upstream_short_form() {
let parsed = RequestId::parse_hex("2a").expect("短十六进制应可解析");
assert_eq!(parsed.as_u128(), 0x2a);
}
#[test]
fn parse_hex_accepts_hyphenated_uuid() {
let uuid = "550e8400-e29b-41d4-a716-446655440000";
let parsed = RequestId::parse_hex(uuid).expect("UUID 应可解析");
assert_eq!(parsed.as_u128(), 0x550e8400_e29b_41d4_a716_446655440000);
assert!(RequestId::parse_hex("not-a-hex-id-zz").is_none());
}
}