grow-graylog 0.2.0

Rust SDK for Graylog Open by Grow Codes
Documentation
// Generated by sdk-kit 0.3.0 — do not edit; change sdk-kit and run "sdk-kit sync"
//! In-memory log exporter and query client for tests.

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,
}

/// [`LogExporter`] that stores records in memory; clones share the store.
///
/// Failures can be scripted with [`fail_next`](Self::fail_next) and
/// [`reject_next`](Self::reject_next); [`query`](Self::query) gives a [`LogQueryClient`] over
/// the stored records.
#[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 {
    /// Empty exporter.
    pub fn new() -> Self {
        Self::default()
    }

    /// A [`BatchingLogClient`] exporting here (default redaction, no resource).
    pub fn client(&self, opts: BatchOptions) -> Result<BatchingLogClient> {
        BatchingLogClient::builder(Arc::new(self.clone()))
            .batch_options(opts)
            .build()
    }

    /// Stored records in export order.
    pub fn records(&self) -> Vec<LogRecord> {
        lock(&self.inner.records).clone()
    }

    /// Number of stored records.
    pub fn len(&self) -> usize {
        lock(&self.inner.records).len()
    }

    /// Whether nothing was stored.
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }

    /// Removes every stored record.
    pub fn clear(&self) {
        lock(&self.inner.records).clear();
    }

    /// `(batch size, gzip)` of every export call, including failed ones.
    pub fn batches(&self) -> Vec<(usize, bool)> {
        lock(&self.inner.batches).clone()
    }

    /// Number of `shutdown` calls.
    pub fn shutdown_calls(&self) -> usize {
        self.inner.shutdowns.load(Ordering::SeqCst)
    }

    /// The next export call fails with `error` (calls queue up).
    pub fn fail_next(&self, error: Error) {
        lock(&self.inner.planned).push_back(Planned::Fail(error));
    }

    /// The next export call rejects its last `n` records (partial success).
    pub fn reject_next(&self, n: usize) {
        lock(&self.inner.planned).push_back(Planned::Reject(n));
    }

    /// Delays every export call (to test timeouts and blocking).
    pub fn set_delay(&self, delay: Option<Duration>) {
        *lock(&self.inner.delay) = delay;
    }

    /// Query client over the stored records.
    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(())
    }
}

/// [`LogQueryClient`] over a [`MemoryLogExporter`]. A query matches records whose body or a
/// string attribute contains it (`""` and `"*"` match everything); the cursor is an offset.
#[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())
    }
}