use std::collections::{BTreeSet, VecDeque};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex, MutexGuard};
use std::time::Duration;
use async_trait::async_trait;
use crate::core::{Error, Result};
use crate::logging::{
poll_tail, BatchOptions, BatchingLogClient, ExportOptions, ExportResult, LogExporter,
LogQueryClient, LogRecord, LogSearchResult, RecordCallback, SearchOptions, SortOrder,
TailHandle, TailOptions,
};
enum Planned {
Fail(Error),
Reject(usize),
}
#[derive(Default)]
struct Inner {
records: Mutex<Vec<LogRecord>>,
planned: Mutex<VecDeque<Planned>>,
batches: Mutex<Vec<(usize, bool)>>,
delay: Mutex<Option<Duration>>,
shutdowns: AtomicUsize,
}
#[derive(Clone, Default)]
pub struct MemoryLogExporter {
inner: Arc<Inner>,
}
impl std::fmt::Debug for MemoryLogExporter {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("MemoryLogExporter")
.field("records", &self.len())
.finish()
}
}
fn lock<T>(m: &Mutex<T>) -> MutexGuard<'_, T> {
m.lock().unwrap_or_else(|e| e.into_inner())
}
impl MemoryLogExporter {
pub fn new() -> Self {
Self::default()
}
pub fn client(&self, opts: BatchOptions) -> Result<BatchingLogClient> {
BatchingLogClient::builder(Arc::new(self.clone()))
.batch_options(opts)
.build()
}
pub fn records(&self) -> Vec<LogRecord> {
lock(&self.inner.records).clone()
}
pub fn len(&self) -> usize {
lock(&self.inner.records).len()
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn clear(&self) {
lock(&self.inner.records).clear();
}
pub fn batches(&self) -> Vec<(usize, bool)> {
lock(&self.inner.batches).clone()
}
pub fn shutdown_calls(&self) -> usize {
self.inner.shutdowns.load(Ordering::SeqCst)
}
pub fn fail_next(&self, error: Error) {
lock(&self.inner.planned).push_back(Planned::Fail(error));
}
pub fn reject_next(&self, n: usize) {
lock(&self.inner.planned).push_back(Planned::Reject(n));
}
pub fn set_delay(&self, delay: Option<Duration>) {
*lock(&self.inner.delay) = delay;
}
pub fn query(&self) -> MemoryLogQuery {
MemoryLogQuery {
exporter: self.clone(),
}
}
}
#[async_trait]
impl LogExporter for MemoryLogExporter {
async fn export(&self, records: &[LogRecord], opts: ExportOptions) -> Result<ExportResult> {
lock(&self.inner.batches).push((records.len(), opts.gzip));
let delay = *lock(&self.inner.delay);
if let Some(d) = delay {
tokio::time::sleep(d).await;
}
let planned = lock(&self.inner.planned).pop_front();
match planned {
Some(Planned::Fail(e)) => Err(e),
Some(Planned::Reject(n)) => {
let n = n.min(records.len());
let keep = records.len() - n;
lock(&self.inner.records).extend_from_slice(&records[..keep]);
Ok(ExportResult::partial(
keep,
n,
Some(Error::validation(format!("{n} records rejected"))),
))
}
None => {
lock(&self.inner.records).extend_from_slice(records);
Ok(ExportResult::accepted(records.len()))
}
}
}
async fn shutdown(&self) -> Result<()> {
self.inner.shutdowns.fetch_add(1, Ordering::SeqCst);
Ok(())
}
}
#[derive(Clone, Debug)]
pub struct MemoryLogQuery {
exporter: MemoryLogExporter,
}
#[async_trait]
impl LogQueryClient for MemoryLogQuery {
async fn search(&self, query: &str, opts: SearchOptions) -> Result<LogSearchResult> {
let offset = match &opts.cursor {
Some(c) => c
.parse::<usize>()
.map_err(|_| Error::validation(format!("invalid cursor {c:?}")))?,
None => 0,
};
let mut hits: Vec<LogRecord> = self
.exporter
.records()
.into_iter()
.filter(|r| query.is_empty() || query == "*" || r.contains_text(query))
.filter(|r| opts.start.is_none_or(|s| r.timestamp >= s))
.filter(|r| opts.end.is_none_or(|e| r.timestamp <= e))
.collect();
hits.sort_by_key(|r| r.timestamp);
if opts.order == SortOrder::Desc {
hits.reverse();
}
let total = hits.len();
let page: Vec<LogRecord> = hits.into_iter().skip(offset).take(opts.limit).collect();
let next = offset + page.len();
Ok(LogSearchResult {
next_cursor: (next < total).then(|| next.to_string()),
total: Some(total as u64),
records: page,
})
}
async fn tail(
&self,
query: &str,
on_record: RecordCallback,
opts: TailOptions,
) -> Result<TailHandle> {
Ok(poll_tail(Arc::new(self.clone()), query, on_record, opts))
}
async fn list_streams(&self) -> Result<Vec<String>> {
Ok(vec!["default".to_string()])
}
async fn list_labels(&self) -> Result<Vec<String>> {
let labels: BTreeSet<String> = self
.exporter
.records()
.iter()
.flat_map(|r| r.attributes.keys().chain(r.resource.keys()).cloned())
.collect();
Ok(labels.into_iter().collect())
}
}