use std::collections::BTreeMap;
use std::future::Future;
use std::sync::Arc;
use std::time::Duration;
use serde_json::{Map, Value};
use crate::core::{Error, HealthStatus, Result};
use crate::logging::{
BatchingLogClient, LogExporter, LogQueryClient, LogRecord, LogSearchResult, RecordCallback,
SearchOptions, TailHandle, TailOptions, WaitOptions,
};
use crate::{
CreateInputOptions, CreateStreamOptions, EnsureGelfInputOptions, EnsuredInput, GelfMessage,
GelfProtocol, GelfSendOptions, GelfSendResult, GelfTransport, GelfTransportOptions,
GraylogClient as AsyncClient, GraylogConfig, IndexSet, Input, InputState, ListStreamsOptions,
LogOptions, LogQueryOptions, Message, MessageSearchOptions, MessageSearchResult, Stream,
StreamPage, SystemInfo,
};
#[derive(Debug)]
pub struct GraylogClient {
inner: AsyncClient,
runtime: Arc<tokio::runtime::Runtime>,
}
impl GraylogClient {
pub fn new(config: GraylogConfig) -> Result<Self> {
let runtime = tokio::runtime::Builder::new_multi_thread()
.worker_threads(1)
.thread_name("grow-graylog")
.enable_all()
.build()
.map_err(|e| Error::config("cannot start the tokio runtime").with_source(e))?;
let inner = {
let _guard = runtime.enter();
AsyncClient::new(config)?
};
Ok(GraylogClient {
inner,
runtime: Arc::new(runtime),
})
}
pub fn from_env() -> Result<Self> {
Self::new(GraylogConfig::from_env()?)
}
pub fn async_client(&self) -> &AsyncClient {
&self.inner
}
pub fn block_on<F: Future>(&self, future: F) -> F::Output {
self.runtime.block_on(future)
}
pub fn config(&self) -> &GraylogConfig {
self.inner.config()
}
pub fn health(&self) -> Result<HealthStatus> {
self.block_on(self.inner.health())
}
pub fn ping(&self) -> Result<Duration> {
self.block_on(self.inner.ping())
}
pub fn server_version(&self) -> Result<String> {
self.block_on(self.inner.server_version())
}
pub fn system_info(&self) -> Result<SystemInfo> {
self.block_on(self.inner.system_info())
}
pub fn list_fields(&self) -> Result<Vec<String>> {
self.block_on(self.inner.list_fields())
}
pub fn list_inputs(&self) -> Result<Vec<Input>> {
self.block_on(self.inner.list_inputs())
}
pub fn get_input(&self, id: &str) -> Result<Input> {
self.block_on(self.inner.get_input(id))
}
pub fn list_input_types(&self) -> Result<BTreeMap<String, String>> {
self.block_on(self.inner.list_input_types())
}
pub fn get_input_state(&self, id: &str) -> Result<InputState> {
self.block_on(self.inner.get_input_state(id))
}
pub fn create_input(
&self,
input_type: &str,
configuration: Map<String, Value>,
opts: CreateInputOptions,
) -> Result<String> {
self.block_on(self.inner.create_input(input_type, configuration, opts))
}
pub fn ensure_gelf_input(
&self,
protocol: GelfProtocol,
port: u16,
opts: EnsureGelfInputOptions,
) -> Result<EnsuredInput> {
self.block_on(self.inner.ensure_gelf_input(protocol, port, opts))
}
pub fn delete_input(&self, id: &str) -> Result<()> {
self.block_on(self.inner.delete_input(id))
}
pub fn list_streams(&self, opts: ListStreamsOptions) -> Result<StreamPage> {
self.block_on(self.inner.list_streams(opts))
}
pub fn get_stream(&self, id: &str) -> Result<Stream> {
self.block_on(self.inner.get_stream(id))
}
pub fn create_stream(&self, opts: CreateStreamOptions) -> Result<String> {
self.block_on(self.inner.create_stream(opts))
}
pub fn resume_stream(&self, id: &str) -> Result<()> {
self.block_on(self.inner.resume_stream(id))
}
pub fn delete_stream(&self, id: &str) -> Result<()> {
self.block_on(self.inner.delete_stream(id))
}
pub fn list_index_sets(&self) -> Result<Vec<IndexSet>> {
self.block_on(self.inner.list_index_sets())
}
pub fn search(&self, query: &str, opts: MessageSearchOptions) -> Result<MessageSearchResult> {
self.block_on(self.inner.search(query, opts))
}
pub fn search_relative(
&self,
query: &str,
range: Duration,
opts: MessageSearchOptions,
) -> Result<MessageSearchResult> {
self.block_on(self.inner.search_relative(query, range, opts))
}
pub fn get_message(&self, index: &str, id: &str) -> Result<Message> {
self.block_on(self.inner.get_message(index, id))
}
pub fn gelf_transport(
&self,
protocol: Option<GelfProtocol>,
opts: GelfTransportOptions,
) -> Result<Arc<dyn GelfTransport>> {
let _guard = self.runtime.enter();
self.inner.gelf_transport(protocol, opts)
}
pub fn send_gelf(
&self,
transport: &dyn GelfTransport,
messages: &[GelfMessage],
opts: GelfSendOptions,
) -> Result<GelfSendResult> {
self.block_on(transport.send(messages, opts))
}
pub fn log_query(&self, opts: LogQueryOptions) -> LogQuery {
LogQuery {
inner: self.inner.log_query(opts),
runtime: Arc::clone(&self.runtime),
}
}
pub fn new_log_client(&self, opts: LogOptions) -> Result<BatchingLogClient> {
let _guard = self.runtime.enter();
self.inner.new_log_client(opts)
}
pub fn new_log_client_with_exporter(
&self,
exporter: Arc<dyn LogExporter>,
opts: LogOptions,
) -> Result<BatchingLogClient> {
let _guard = self.runtime.enter();
self.inner.new_log_client_with_exporter(exporter, opts)
}
pub fn close(&self) {
self.block_on(self.inner.close());
}
}
impl Drop for GraylogClient {
fn drop(&mut self) {
self.inner.transport().close();
}
}
#[derive(Debug, Clone)]
pub struct LogQuery {
inner: crate::LogQuery,
runtime: Arc<tokio::runtime::Runtime>,
}
impl LogQuery {
pub fn search(&self, query: &str, opts: SearchOptions) -> Result<LogSearchResult> {
self.runtime.block_on(self.inner.search(query, opts))
}
pub fn tail(
&self,
query: &str,
on_record: RecordCallback,
opts: TailOptions,
) -> Result<TailHandle> {
self.runtime
.block_on(self.inner.tail(query, on_record, opts))
}
pub fn list_streams(&self) -> Result<Vec<String>> {
self.runtime.block_on(self.inner.list_streams())
}
pub fn list_labels(&self) -> Result<Vec<String>> {
self.runtime.block_on(self.inner.list_labels())
}
pub fn wait_for_log(&self, query: &str, opts: WaitOptions) -> Result<LogRecord> {
self.runtime.block_on(self.inner.wait_for_log(query, opts))
}
}