use crate::{EventStream, Sink};
use std::cell::{Cell, RefCell};
use std::rc::Rc;
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum DiagnosticEvent {
TransactionStarted {
id: u64,
},
NodeProcessed {
node: u64,
rank: usize,
signal: bool,
},
ObserverFired {
observer: u64,
},
DeferredWriteQueued {
transaction: u64,
},
CycleRejected,
TransactionEnded {
id: u64,
processed: usize,
fired: usize,
deferred: usize,
},
}
thread_local! {
static DIAGNOSTICS: RefCell<Option<Rc<Diagnostics>>> = const { RefCell::new(None) };
static FLUSHING: Cell<bool> = const { Cell::new(false) };
}
pub struct Diagnostics {
buffer: RefCell<Vec<DiagnosticEvent>>,
sink: Sink<DiagnosticEvent>,
}
impl Diagnostics {
pub fn install() -> Rc<Self> {
assert!(
DIAGNOSTICS.with(|d| d.borrow().is_none()),
"diagnostics already installed on this thread"
);
let diagnostics = Rc::new(Self {
buffer: RefCell::new(Vec::new()),
sink: Sink::new(),
});
DIAGNOSTICS.with(|d| *d.borrow_mut() = Some(diagnostics.clone()));
diagnostics
}
pub fn uninstall(&self) {
let is_current = DIAGNOSTICS.with(|d| {
d.borrow()
.as_ref()
.is_some_and(|current| std::ptr::eq(Rc::as_ptr(current), self))
});
if is_current {
DIAGNOSTICS.with(|d| *d.borrow_mut() = None);
}
}
pub fn events(&self) -> EventStream<DiagnosticEvent> {
self.sink.stream()
}
pub fn flush(&self) {
if FLUSHING.get() {
return;
}
FLUSHING.set(true);
let events: Vec<DiagnosticEvent> = std::mem::take(&mut *self.buffer.borrow_mut());
for event in events {
self.sink.send(event);
}
FLUSHING.set(false);
}
pub(crate) fn emit(event: DiagnosticEvent) {
if FLUSHING.get() {
return;
}
DIAGNOSTICS.with(|d| {
if let Some(diagnostics) = d.borrow().as_ref() {
diagnostics.buffer.borrow_mut().push(event);
}
});
}
pub(crate) fn flush_global() {
DIAGNOSTICS.with(|d| {
if let Some(diagnostics) = d.borrow().as_ref() {
diagnostics.flush();
}
});
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
pub enum LogLevel {
Error,
Warn,
Info,
Debug,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct LogRecord {
pub level: LogLevel,
pub message: String,
}
thread_local! {
static LOGGER: RefCell<Option<Rc<Logger>>> = const { RefCell::new(None) };
}
pub struct Logger {
min_level: Cell<LogLevel>,
sink: Sink<LogRecord>,
}
impl Logger {
pub fn install(min_level: LogLevel) -> Rc<Self> {
assert!(
LOGGER.with(|l| l.borrow().is_none()),
"logger already installed on this thread"
);
let logger = Rc::new(Self {
min_level: Cell::new(min_level),
sink: Sink::new(),
});
LOGGER.with(|l| *l.borrow_mut() = Some(logger.clone()));
logger
}
pub fn uninstall(&self) {
let is_current = LOGGER.with(|l| {
l.borrow()
.as_ref()
.is_some_and(|current| std::ptr::eq(Rc::as_ptr(current), self))
});
if is_current {
LOGGER.with(|l| *l.borrow_mut() = None);
}
}
pub fn records(&self) -> EventStream<LogRecord> {
self.sink.stream()
}
pub fn set_min_level(&self, level: LogLevel) {
self.min_level.set(level);
}
pub fn log(&self, level: LogLevel, message: impl Into<String>) {
if level <= self.min_level.get() {
self.sink.send(LogRecord {
level,
message: message.into(),
});
}
}
pub fn debug(&self, message: impl Into<String>) {
self.log(LogLevel::Debug, message);
}
pub fn info(&self, message: impl Into<String>) {
self.log(LogLevel::Info, message);
}
pub fn warn(&self, message: impl Into<String>) {
self.log(LogLevel::Warn, message);
}
pub fn error(&self, message: impl Into<String>) {
self.log(LogLevel::Error, message);
}
}
pub fn log(level: LogLevel, message: impl Into<String>) {
LOGGER.with(|l| {
if let Some(logger) = l.borrow().as_ref() {
logger.log(level, message);
}
});
}
pub fn log_debug(message: impl Into<String>) {
log(LogLevel::Debug, message);
}
pub fn log_info(message: impl Into<String>) {
log(LogLevel::Info, message);
}
pub fn log_warn(message: impl Into<String>) {
log(LogLevel::Warn, message);
}
pub fn log_error(message: impl Into<String>) {
log(LogLevel::Error, message);
}