use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use crate::core::{Error, Result};
use crate::tracing::{
normalize_trace_id, sort_spans, AttrValue, Attributes, Span, SpanEvent, SpanKind, SpanStatus,
StatusCode, Trace, TraceSummary,
};
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZipkinEndpoint {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub service_name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ipv4: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub ipv6: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub port: Option<u16>,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct ZipkinAnnotation {
#[serde(default)]
pub timestamp: u64,
#[serde(default)]
pub value: String,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ZipkinSpan {
pub trace_id: String,
pub id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub parent_id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub kind: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub timestamp: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub duration: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub local_endpoint: Option<ZipkinEndpoint>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub remote_endpoint: Option<ZipkinEndpoint>,
#[serde(default)]
pub annotations: Vec<ZipkinAnnotation>,
#[serde(default)]
pub tags: BTreeMap<String, String>,
}
fn is_hex_len(id: &str, lens: &[usize]) -> bool {
lens.contains(&id.len()) && id.bytes().all(|b| b.is_ascii_hexdigit())
}
pub fn is_hex_trace_id(id: &str) -> bool {
is_hex_len(id.trim(), &[16, 32])
}
pub fn zipkin_trace_id(id: &str, operation: &str) -> Result<String> {
let lower = id.trim().to_ascii_lowercase();
if !is_hex_len(&lower, &[16, 32]) || lower.bytes().all(|b| b == b'0') {
return Err(Error::validation(format!(
"{operation}: trace id must be 16 or 32 hex characters"
)));
}
Ok(lower)
}
pub fn zipkin_spans_from_body(body: &Value) -> Vec<ZipkinSpan> {
body.as_array()
.into_iter()
.flatten()
.filter(|s| {
s.get("traceId").is_some_and(Value::is_string)
&& s.get("id").is_some_and(Value::is_string)
})
.filter_map(|s| serde_json::from_value(s.clone()).ok())
.collect()
}
pub fn zipkin_traces_from_body(body: &Value) -> Vec<Vec<ZipkinSpan>> {
body.as_array()
.into_iter()
.flatten()
.map(zipkin_spans_from_body)
.filter(|t| !t.is_empty())
.collect()
}
pub fn strings_from_body(body: &Value) -> Vec<String> {
crate::native::strings(Some(body))
}
pub fn is_bookkeeping_tag(key: &str) -> bool {
key.starts_with("otel.") || key == "error" || key == "w3c.tracestate"
}
pub fn annotation_to_event(annotation: &ZipkinAnnotation) -> SpanEvent {
let value = &annotation.value;
if let (Some(first), Some(last)) = (value.find('|'), value.rfind('|')) {
if first > 0 && last > first {
let json = &value[first + 1..last];
let parsed = if json.is_empty() {
Ok(Value::Object(Default::default()))
} else {
serde_json::from_str::<Value>(json)
};
if let Ok(Value::Object(map)) = parsed {
return SpanEvent {
name: value[..first].to_owned(),
time_micros: annotation.timestamp,
attributes: map.into_iter().collect(),
};
}
}
}
SpanEvent {
name: value.clone(),
time_micros: annotation.timestamp,
attributes: Attributes::new(),
}
}
pub fn zipkin_span_to_span(span: &ZipkinSpan) -> Span {
let tags = &span.tags;
let start = span.timestamp.unwrap_or(0);
let duration = span.duration.unwrap_or(0);
let code = tags
.get("otel.status_code")
.map(|c| c.to_ascii_uppercase())
.unwrap_or_default();
let status = if code == "STATUS_CODE_ERROR" || code == "ERROR" {
SpanStatus {
code: StatusCode::Error,
message: tags
.get("otel.status_description")
.filter(|m| !m.is_empty())
.cloned(),
}
} else if code == "STATUS_CODE_OK" || code == "OK" {
SpanStatus {
code: StatusCode::Ok,
message: None,
}
} else if tags.contains_key("error") {
SpanStatus {
code: StatusCode::Error,
message: None,
}
} else {
SpanStatus::default()
};
let attributes: Attributes = tags
.iter()
.filter(|(k, _)| !is_bookkeeping_tag(k))
.map(|(k, v)| (k.clone(), AttrValue::String(v.clone())))
.collect();
let kind = match span.kind.as_deref() {
None => SpanKind::Internal,
Some(k) => match SpanKind::parse(k) {
SpanKind::Internal => SpanKind::Unspecified,
other => other,
},
};
Span {
trace_id: normalize_trace_id(&span.trace_id)
.unwrap_or_else(|_| span.trace_id.to_ascii_lowercase()),
span_id: span.id.to_ascii_lowercase(),
parent_span_id: span
.parent_id
.as_deref()
.filter(|p| !p.is_empty())
.map(str::to_ascii_lowercase),
name: span.name.clone().unwrap_or_default(),
kind,
service_name: span
.local_endpoint
.as_ref()
.and_then(|e| e.service_name.clone())
.unwrap_or_default(),
start_micros: start,
end_micros: start + duration,
duration_micros: duration,
status,
attributes,
events: span.annotations.iter().map(annotation_to_event).collect(),
links: Vec::new(),
}
}
pub fn zipkin_trace_to_trace(spans: &[ZipkinSpan]) -> Option<Trace> {
let first = spans.first()?;
let mut out: Vec<Span> = spans.iter().map(zipkin_span_to_span).collect();
sort_spans(&mut out);
Some(Trace {
trace_id: normalize_trace_id(&first.trace_id)
.unwrap_or_else(|_| first.trace_id.to_ascii_lowercase()),
spans: out,
})
}
pub fn summarize(trace: &Trace) -> TraceSummary {
let mut summary = trace.summary();
if summary.root_name.is_none() {
if let Some(earliest) = trace.spans.first() {
summary.root_name = Some(earliest.name.clone());
summary.root_service_name = Some(earliest.service_name.clone());
}
}
summary
}