use std::collections::BTreeMap;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use serde::{Deserialize, Deserializer, Serialize};
use super::{AttrValue, Attributes};
use crate::core::{Error, Result};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum SpanKind {
#[default]
Internal,
Server,
Client,
Producer,
Consumer,
Unspecified,
}
impl SpanKind {
pub fn parse(s: &str) -> SpanKind {
let t = s.trim().to_ascii_lowercase();
let t = t.strip_prefix("span_kind_").unwrap_or(&t);
match t {
"internal" | "1" => SpanKind::Internal,
"server" | "2" => SpanKind::Server,
"client" | "3" => SpanKind::Client,
"producer" | "4" => SpanKind::Producer,
"consumer" | "5" => SpanKind::Consumer,
_ => SpanKind::Unspecified,
}
}
}
impl From<&opentelemetry::trace::SpanKind> for SpanKind {
fn from(k: &opentelemetry::trace::SpanKind) -> Self {
use opentelemetry::trace::SpanKind as K;
match k {
K::Internal => SpanKind::Internal,
K::Server => SpanKind::Server,
K::Client => SpanKind::Client,
K::Producer => SpanKind::Producer,
K::Consumer => SpanKind::Consumer,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum StatusCode {
#[default]
Unset,
Ok,
Error,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct SpanStatus {
pub code: StatusCode,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SpanEvent {
pub name: String,
pub time_micros: u64,
#[serde(default)]
pub attributes: Attributes,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SpanLink {
pub trace_id: String,
pub span_id: String,
#[serde(default)]
pub attributes: Attributes,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Span {
pub trace_id: String,
pub span_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub parent_span_id: Option<String>,
pub name: String,
#[serde(default, deserialize_with = "de_kind")]
pub kind: SpanKind,
pub service_name: String,
pub start_micros: u64,
pub end_micros: u64,
pub duration_micros: u64,
#[serde(default, deserialize_with = "de_status")]
pub status: SpanStatus,
#[serde(default)]
pub attributes: Attributes,
#[serde(default)]
pub events: Vec<SpanEvent>,
#[serde(default)]
pub links: Vec<SpanLink>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase", from = "TraceWire")]
pub struct Trace {
pub trace_id: String,
pub spans: Vec<Span>,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct TraceWire {
trace_id: String,
#[serde(default)]
spans: Vec<Span>,
}
impl From<TraceWire> for Trace {
fn from(w: TraceWire) -> Self {
Trace::new(w.trace_id, w.spans)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TraceSummary {
pub trace_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub root_service_name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub root_name: Option<String>,
pub start_micros: u64,
pub duration_micros: u64,
pub span_count: usize,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TraceSearchQuery {
pub service: Option<String>,
pub operation: Option<String>,
pub tags: BTreeMap<String, String>,
pub min_duration: Option<Duration>,
pub max_duration: Option<Duration>,
pub start: Option<SystemTime>,
pub end: Option<SystemTime>,
pub limit: usize,
}
impl Default for TraceSearchQuery {
fn default() -> Self {
TraceSearchQuery {
service: None,
operation: None,
tags: BTreeMap::new(),
min_duration: None,
max_duration: None,
start: None,
end: None,
limit: 20,
}
}
}
impl TraceSearchQuery {
pub fn service(service: impl Into<String>) -> Self {
TraceSearchQuery {
service: Some(service.into()),
..Default::default()
}
}
pub fn operation(mut self, op: impl Into<String>) -> Self {
self.operation = Some(op.into());
self
}
pub fn tag(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
self.tags.insert(key.into(), value.into());
self
}
pub fn limit(mut self, limit: usize) -> Self {
self.limit = limit;
self
}
pub fn matches(&self, trace: &Trace) -> bool {
let summary = trace.summary();
let start = UNIX_EPOCH + Duration::from_micros(summary.start_micros);
let dur = Duration::from_micros(summary.duration_micros);
let span_ok = |s: &Span| {
self.service.as_ref().is_none_or(|v| &s.service_name == v)
&& self.operation.as_ref().is_none_or(|v| &s.name == v)
&& self.tags.iter().all(|(k, v)| match s.attributes.get(k) {
Some(AttrValue::String(x)) => x == v,
Some(other) => &other.to_string() == v,
None => false,
})
};
trace.spans.iter().any(span_ok)
&& self.min_duration.is_none_or(|d| dur >= d)
&& self.max_duration.is_none_or(|d| dur <= d)
&& self.start.is_none_or(|t| start >= t)
&& self.end.is_none_or(|t| start <= t)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct DependencyLink {
pub parent: String,
pub child: String,
pub call_count: u64,
}
#[derive(Debug, Clone, PartialEq)]
pub struct SpanNode {
pub span: Span,
pub children: Vec<SpanNode>,
}
fn normalize_hex(id: &str, len: usize, what: &str) -> Result<String> {
let t = id.trim();
let t = t
.strip_prefix("0x")
.or_else(|| t.strip_prefix("0X"))
.unwrap_or(t);
if t.is_empty() || t.len() > len || !t.bytes().all(|b| b.is_ascii_hexdigit()) {
return Err(Error::validation(format!("invalid {what} {id:?}")));
}
let out = format!("{:0>len$}", t.to_ascii_lowercase());
if out.bytes().all(|b| b == b'0') {
return Err(Error::validation(format!("invalid {what}: all zeros")));
}
Ok(out)
}
pub fn normalize_trace_id(id: &str) -> Result<String> {
normalize_hex(id, 32, "trace id")
}
pub fn normalize_trace_id_or_native(id: &str) -> Result<String> {
native_or(id, 32, "trace id")
}
pub fn normalize_span_id_or_native(id: &str) -> Result<String> {
native_or(id, 16, "span id")
}
fn native_or(id: &str, len: usize, what: &str) -> Result<String> {
let t = id.trim();
if t.is_empty() {
return Err(Error::validation(format!("invalid {what}: empty")));
}
let hex = t
.strip_prefix("0x")
.or_else(|| t.strip_prefix("0X"))
.unwrap_or(t);
if hex.len() <= len && !hex.is_empty() && hex.bytes().all(|b| b.is_ascii_hexdigit()) {
return normalize_hex(t, len, what);
}
Ok(t.to_string())
}
pub fn normalize_span_id(id: &str) -> Result<String> {
normalize_hex(id, 16, "span id")
}
pub fn sort_spans(spans: &mut [Span]) {
spans.sort_by(|a, b| {
a.start_micros
.cmp(&b.start_micros)
.then_with(|| a.span_id.cmp(&b.span_id))
});
}
pub fn build_tree(spans: &[Span]) -> Vec<SpanNode> {
let mut sorted = spans.to_vec();
sort_spans(&mut sorted);
let ids: std::collections::HashSet<&str> = sorted.iter().map(|s| s.span_id.as_str()).collect();
let mut children: BTreeMap<String, Vec<Span>> = BTreeMap::new();
let mut roots = Vec::new();
for s in &sorted {
match &s.parent_span_id {
Some(p) if ids.contains(p.as_str()) && p != &s.span_id => {
children.entry(p.clone()).or_default().push(s.clone())
}
_ => roots.push(s.clone()),
}
}
fn attach(span: Span, children: &mut BTreeMap<String, Vec<Span>>) -> SpanNode {
let kids = children.remove(&span.span_id).unwrap_or_default();
SpanNode {
children: kids.into_iter().map(|k| attach(k, children)).collect(),
span,
}
}
roots
.into_iter()
.map(|r| attach(r, &mut children))
.collect()
}
fn micros(t: SystemTime) -> u64 {
t.duration_since(UNIX_EPOCH)
.map(|d| d.as_micros() as u64)
.unwrap_or(0)
}
fn kv_attributes(kvs: &[opentelemetry::KeyValue]) -> Attributes {
kvs.iter()
.map(|kv| (kv.key.to_string(), attr_value(&kv.value)))
.collect()
}
fn attr_value(v: &opentelemetry::Value) -> AttrValue {
use opentelemetry::{Array, Value};
match v {
Value::Bool(b) => (*b).into(),
Value::I64(i) => (*i).into(),
Value::F64(f) => (*f).into(),
Value::String(s) => s.as_str().into(),
Value::Array(Array::Bool(a)) => a.clone().into(),
Value::Array(Array::I64(a)) => a.clone().into(),
Value::Array(Array::F64(a)) => a.clone().into(),
Value::Array(Array::String(a)) => a
.iter()
.map(|s| s.as_str().to_string())
.collect::<Vec<_>>()
.into(),
other => other.to_string().into(),
}
}
impl Span {
pub fn from_span_data(data: &opentelemetry_sdk::trace::SpanData, service_name: &str) -> Span {
use opentelemetry::trace::{SpanId, Status};
let start = micros(data.start_time);
let end = micros(data.end_time).max(start);
let status = match &data.status {
Status::Unset => SpanStatus::default(),
Status::Ok => SpanStatus {
code: StatusCode::Ok,
message: None,
},
Status::Error { description } => SpanStatus {
code: StatusCode::Error,
message: Some(description.to_string()).filter(|d| !d.is_empty()),
},
};
Span {
trace_id: data.span_context.trace_id().to_string(),
span_id: data.span_context.span_id().to_string(),
parent_span_id: (data.parent_span_id != SpanId::INVALID)
.then(|| data.parent_span_id.to_string()),
name: data.name.to_string(),
kind: SpanKind::from(&data.span_kind),
service_name: service_name.to_string(),
start_micros: start,
end_micros: end,
duration_micros: end - start,
status,
attributes: kv_attributes(&data.attributes),
events: data
.events
.iter()
.map(|e| SpanEvent {
name: e.name.to_string(),
time_micros: micros(e.timestamp),
attributes: kv_attributes(&e.attributes),
})
.collect(),
links: data
.links
.iter()
.map(|l| SpanLink {
trace_id: l.span_context.trace_id().to_string(),
span_id: l.span_context.span_id().to_string(),
attributes: kv_attributes(&l.attributes),
})
.collect(),
}
}
}
impl Trace {
pub fn new(trace_id: impl Into<String>, mut spans: Vec<Span>) -> Self {
sort_spans(&mut spans);
Trace {
trace_id: trace_id.into(),
spans,
}
}
pub fn tree(&self) -> Vec<SpanNode> {
build_tree(&self.spans)
}
pub fn children_of(&self, parent_name: &str) -> Vec<String> {
let parents: Vec<&str> = self
.spans
.iter()
.filter(|s| s.name == parent_name)
.map(|s| s.span_id.as_str())
.collect();
self.spans
.iter()
.filter(|s| {
s.parent_span_id
.as_deref()
.is_some_and(|p| parents.contains(&p))
})
.map(|s| s.name.clone())
.collect()
}
pub fn summary(&self) -> TraceSummary {
let roots = self.tree();
let root = roots.first().map(|n| &n.span);
let start = self.spans.iter().map(|s| s.start_micros).min().unwrap_or(0);
let end = self
.spans
.iter()
.map(|s| s.end_micros)
.max()
.unwrap_or(start);
TraceSummary {
trace_id: self.trace_id.clone(),
root_service_name: root.map(|s| s.service_name.clone()),
root_name: root.map(|s| s.name.clone()),
start_micros: start,
duration_micros: end.saturating_sub(start),
span_count: self.spans.len(),
}
}
}
fn de_status<'de, D: Deserializer<'de>>(d: D) -> std::result::Result<SpanStatus, D::Error> {
#[derive(Deserialize)]
#[serde(untagged)]
enum Wire {
Code(StatusCode),
Object {
code: StatusCode,
#[serde(default)]
message: Option<String>,
},
}
Ok(match Wire::deserialize(d)? {
Wire::Code(code) => SpanStatus {
code,
message: None,
},
Wire::Object { code, message } => SpanStatus { code, message },
})
}
fn de_kind<'de, D: Deserializer<'de>>(d: D) -> std::result::Result<SpanKind, D::Error> {
Ok(SpanKind::parse(&String::deserialize(d)?))
}