meilisearch/tracing-trace/src/entry.rs

use std::borrow::Cow;

use serde::{Deserialize, Serialize};
use tracing::span::Id as TracingId;

#[derive(Debug, Serialize, Deserialize)]
pub enum Entry {
    /// A code location was accessed for the first time
    NewCallsite(NewCallsite),

    /// A new thread was accessed
    NewThread(NewThread),

    /// A new call started
    NewSpan(NewSpan),

    /// An already in-flight call started doing work.
    ///
    /// For synchronous functions, open should always be followed immediately by enter, exit and close,
    /// but for asynchronous functions, work can suspend (exiting the span without closing it), and then
    /// later resume (entering the span again without opening it).
    ///
    /// The timer for a span only starts when the span is entered.
    SpanEnter(SpanEnter),

    /// An in-flight call suspended and paused work.
    ///
    /// For synchronous functions, exit should always be followed immediately by close,
    /// but for asynchronous functions, work can suspend and then later resume.
    ///
    /// The timer for a span pauses when the span is exited.
    SpanExit(SpanExit),

    /// A call ended
    SpanClose(SpanClose),
}

#[derive(Clone, Copy, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub struct SpanId(u64);

impl From<&TracingId> for SpanId {
    fn from(value: &TracingId) -> Self {
        Self(value.into_u64())
    }
}

#[derive(Debug, Serialize, Deserialize)]
pub struct NewCallsite {
    pub call_id: ResourceId,
    pub name: Cow<'static, str>,
    pub module_path: Option<Cow<'static, str>>,
    pub file: Option<Cow<'static, str>>,
    pub line: Option<u32>,
    pub target: Cow<'static, str>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct NewThread {
    pub thread_id: ResourceId,
    pub name: Option<String>,
}

#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
pub struct SpanEnter {
    pub id: SpanId,
    pub time: std::time::Duration,
}

#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
pub struct SpanExit {
    pub id: SpanId,
    pub time: std::time::Duration,
}

#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
pub struct NewSpan {
    pub id: SpanId,
    pub call_id: ResourceId,
    pub parent_id: Option<SpanId>,
    pub thread_id: ResourceId,
}

#[derive(Clone, Copy, Debug, Serialize, Deserialize)]
pub struct SpanClose {
    pub id: SpanId,
    pub time: std::time::Duration,
}

#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub struct ResourceId(pub(crate) usize);

impl ResourceId {
    pub fn to_usize(self) -> usize {
        self.0
    }
}