use std::future::Future;
use std::time::Duration;
use serde_json::Value;
use crate::api::{GraphQLResponse, SkyWalkingCapabilities, TimeInfo};
use crate::core::{Error, HealthStatus, Result};
use crate::logging::{
BatchingLogClient, LogQueryClient, LogRecord, LogSearchResult, SearchOptions, WaitOptions,
};
use crate::native::{NativeTrace, Topology};
use crate::query::{
QueryLogsOptions, QueryLogsResult, QueryTracesOptions, QueryTracesResult, SkyWalkingEndpoint,
SkyWalkingInstance, SkyWalkingService, TopologyOptions,
};
use crate::tracing::{
DependencyLink, DependencyOptions, Trace, TraceQueryClient, TraceSearchQuery, TraceSummary,
TracingConfig, TracingHandle, WaitForTraceOptions,
};
use crate::{
SkyWalkingClient as AsyncClient, SkyWalkingConfig, SkyWalkingLogClientOptions, TimeRange,
};
#[derive(Debug)]
pub struct SkyWalkingClient {
inner: AsyncClient,
runtime: tokio::runtime::Runtime,
}
impl SkyWalkingClient {
pub fn new(config: SkyWalkingConfig) -> Result<Self> {
let runtime = tokio::runtime::Builder::new_multi_thread()
.worker_threads(1)
.thread_name("grow-skywalking")
.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(SkyWalkingClient { inner, runtime })
}
pub fn from_env() -> Result<Self> {
Self::new(SkyWalkingConfig::from_env()?)
}
pub fn async_client(&self) -> &AsyncClient {
&self.inner
}
pub fn config(&self) -> &SkyWalkingConfig {
self.inner.config()
}
pub fn block_on<F: Future>(&self, future: F) -> F::Output {
self.runtime.block_on(future)
}
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 graphql(&self, query: &str, variables: Value) -> Result<GraphQLResponse> {
self.block_on(self.inner.graphql(query, variables))
}
pub fn query(&self) -> QueryClient<'_> {
QueryClient { client: self }
}
pub fn traces(&self) -> TraceClient<'_> {
TraceClient { client: self }
}
pub fn logs(&self) -> LogsClient<'_> {
LogsClient { client: self }
}
pub fn log_client(&self, options: SkyWalkingLogClientOptions) -> Result<BatchingLogClient> {
let _guard = self.runtime.enter();
self.inner.log_client(options)
}
pub fn init_tracing(&self, config: TracingConfig) -> Result<TracingHandle> {
let _guard = self.runtime.enter();
self.inner.init_tracing(config)
}
pub fn close(&self) {
self.block_on(self.inner.close());
}
}
impl Drop for SkyWalkingClient {
fn drop(&mut self) {
self.inner.transport().close();
}
}
#[derive(Debug, Clone, Copy)]
pub struct QueryClient<'a> {
client: &'a SkyWalkingClient,
}
impl QueryClient<'_> {
fn q(&self) -> &crate::SkyWalkingQueryClient {
self.client.inner.query()
}
pub fn graphql(&self, query: &str, variables: Value) -> Result<GraphQLResponse> {
self.client.block_on(self.q().graphql(query, variables))
}
pub fn time_info(&self) -> Result<TimeInfo> {
self.client.block_on(self.q().time_info())
}
pub fn capabilities(&self) -> Result<SkyWalkingCapabilities> {
self.client.block_on(self.q().capabilities())
}
pub fn list_services(
&self,
layer: Option<&str>,
range: Option<TimeRange>,
) -> Result<Vec<SkyWalkingService>> {
self.client.block_on(self.q().list_services(layer, range))
}
pub fn find_service(&self, name: &str) -> Result<Option<SkyWalkingService>> {
self.client.block_on(self.q().find_service(name))
}
pub fn list_endpoints(
&self,
service: &str,
keyword: Option<&str>,
limit: Option<usize>,
) -> Result<Vec<SkyWalkingEndpoint>> {
self.client
.block_on(self.q().list_endpoints(service, keyword, limit))
}
pub fn list_instances(
&self,
service: &str,
range: Option<TimeRange>,
) -> Result<Vec<SkyWalkingInstance>> {
self.client
.block_on(self.q().list_instances(service, range))
}
pub fn query_traces(&self, opts: &QueryTracesOptions) -> Result<QueryTracesResult> {
self.client.block_on(self.q().query_traces(opts))
}
pub fn get_trace(&self, trace_id: &str) -> Result<Option<NativeTrace>> {
self.client.block_on(self.q().get_trace(trace_id))
}
pub fn query_logs(&self, opts: &QueryLogsOptions) -> Result<QueryLogsResult> {
self.client.block_on(self.q().query_logs(opts))
}
pub fn list_log_tag_keys(&self, range: Option<TimeRange>) -> Result<Vec<String>> {
self.client.block_on(self.q().list_log_tag_keys(range))
}
pub fn topology(&self, range: Option<TimeRange>, opts: &TopologyOptions) -> Result<Topology> {
self.client.block_on(self.q().topology(range, opts))
}
}
#[derive(Debug, Clone, Copy)]
pub struct TraceClient<'a> {
client: &'a SkyWalkingClient,
}
impl TraceClient<'_> {
fn t(&self) -> &crate::SkyWalkingTraceQueryClient {
self.client.inner.traces()
}
pub fn get_trace(&self, trace_id: &str) -> Result<Option<Trace>> {
self.client.block_on(self.t().get_trace(trace_id))
}
pub fn search_traces(&self, query: &TraceSearchQuery) -> Result<Vec<TraceSummary>> {
self.client.block_on(self.t().search_traces(query))
}
pub fn list_services(&self) -> Result<Vec<String>> {
self.client.block_on(self.t().list_services())
}
pub fn list_operations(&self, service: &str) -> Result<Vec<String>> {
self.client.block_on(self.t().list_operations(service))
}
pub fn get_dependencies(&self, opts: DependencyOptions) -> Result<Vec<DependencyLink>> {
self.client.block_on(self.t().get_dependencies(opts))
}
pub fn wait_for_trace(&self, trace_id: &str, opts: WaitForTraceOptions) -> Result<Trace> {
self.client
.block_on(self.t().wait_for_trace(trace_id, opts))
}
}
#[derive(Debug, Clone, Copy)]
pub struct LogsClient<'a> {
client: &'a SkyWalkingClient,
}
impl LogsClient<'_> {
fn l(&self) -> &crate::SkyWalkingLogQueryClient {
self.client.inner.logs()
}
pub fn search(&self, query: &str, opts: SearchOptions) -> Result<LogSearchResult> {
self.client.block_on(self.l().search(query, opts))
}
pub fn wait_for_log(&self, query: &str, opts: WaitOptions) -> Result<LogRecord> {
self.client.block_on(self.l().wait_for_log(query, opts))
}
pub fn list_streams(&self) -> Result<Vec<String>> {
self.client.block_on(self.l().list_streams())
}
pub fn list_labels(&self) -> Result<Vec<String>> {
self.client.block_on(self.l().list_labels())
}
}