use std::collections::HashMap;
use std::future::Future;
use std::sync::Arc;
use serde::Serialize;
use crate::fingerprint::generate_fingerprint;
use crate::queue::OfflineQueue;
use crate::rate_limiter::RateLimiter;
use crate::sanitizer::Sanitizer;
use crate::scope::ScopeManager;
use crate::time::now_millis;
use crate::transport::send_error_report;
use crate::types::{
ErrorContext, ErrorReport, ExceptionDetails, NewBreadcrumb, Options, RequestContext, SdkInfo,
ServerContext, Severity, UserContext,
};
pub struct Client {
pub(crate) options: Options,
pub(crate) http: reqwest::Client,
scope: ScopeManager,
pub(crate) sanitizer: Sanitizer,
rate_limiter: RateLimiter,
queue: OfflineQueue,
}
impl Client {
pub fn new(options: Options) -> Arc<Self> {
let sanitizer = Sanitizer::new(&options.sensitive_keys);
let rate_limiter = RateLimiter::new(options.max_errors_per_minute);
let queue = OfflineQueue::new(options.max_queue_size);
let scope = ScopeManager::new(options.max_breadcrumbs);
let http = reqwest::Client::new();
Arc::new(Self {
options,
http,
scope,
sanitizer,
rate_limiter,
queue,
})
}
pub async fn run_in_scope<F, Fut, T>(&self, f: F) -> T
where
F: FnOnce() -> Fut,
Fut: Future<Output = T>,
{
self.scope.run(f).await
}
pub fn add_breadcrumb(&self, breadcrumb: NewBreadcrumb) {
self.scope.add_breadcrumb(breadcrumb);
}
pub fn set_user_context(&self, user: UserContext) {
self.scope.set_user_context(user);
}
pub fn set_custom_context(&self, key: impl Into<String>, value: impl Serialize) {
match serde_json::to_value(value) {
Ok(json) => self.scope.set_custom_context(key, json),
Err(err) => {
if self.options.log_to_console {
eprintln!("[Oluso] Failed to serialize custom context: {err}");
}
}
}
}
pub async fn capture_error<E: std::error::Error>(&self, err: &E) {
let error_type = type_short_name::<E>();
self.capture_with_exception(
&error_type,
err.to_string(),
None,
None,
None,
exception_details(&error_type, err),
)
.await;
}
pub async fn capture_dyn_error(&self, error_type: &str, err: &dyn std::error::Error) {
self.capture_with_exception(
error_type,
err.to_string(),
None,
None,
None,
exception_details(error_type, err),
)
.await;
}
pub async fn capture_error_with_request<E: std::error::Error>(
&self,
err: &E,
request: RequestContext,
) {
let error_type = type_short_name::<E>();
self.capture_with_exception(
&error_type,
err.to_string(),
None,
None,
Some(request),
exception_details(&error_type, err),
)
.await;
}
pub async fn capture_message(&self, message: impl Into<String>, severity: Severity) {
self.capture("Message", message.into(), None, Some(severity), None)
.await;
}
pub async fn capture(
&self,
error_type: &str,
message: impl Into<String>,
stack_trace: Option<String>,
severity: Option<Severity>,
request: Option<RequestContext>,
) {
let message = message.into();
let exception = ExceptionDetails {
r#type: error_type.to_string(),
message: truncate(&message, 4000),
stack_trace: stack_trace.as_deref().map(|s| truncate(s, 16000)),
attributes: HashMap::new(),
causes: Vec::new(),
};
self.capture_with_exception(
error_type,
message,
stack_trace,
severity,
request,
exception,
)
.await;
}
async fn capture_with_exception(
&self,
error_type: &str,
message: String,
stack_trace: Option<String>,
severity: Option<Severity>,
request: Option<RequestContext>,
exception: ExceptionDetails,
) {
if let Some(should_report) = &self.options.should_report {
if !should_report(&message) {
return;
}
}
if !self.rate_limiter.can_send() {
if self.options.log_to_console {
eprintln!("[Oluso] Rate limit exceeded, error not reported");
}
return;
}
if self.options.log_to_console {
eprintln!("[Oluso] {error_type}: {message}");
}
let (breadcrumbs, user, custom) = self.scope.snapshot();
let context = ErrorContext {
request: request.map(|r| self.sanitize_request(r)),
user,
server: server_context(),
custom,
breadcrumbs,
};
let fingerprint = match &self.options.fingerprint {
Some(f) => f(&message, &context),
None => generate_fingerprint(error_type, &message, stack_trace.as_deref()),
};
let report = ErrorReport {
schema_version: 2,
title: generate_error_title(&message, error_type),
message,
stack_trace,
environment: self.options.environment.clone(),
severity: severity.unwrap_or(self.options.default_severity),
tags: self.options.tags.clone(),
fingerprint,
context,
timestamp: now_millis(),
exception,
sdk: SdkInfo {
name: "oluso-rust".to_string(),
version: env!("CARGO_PKG_VERSION").to_string(),
language: "rust".to_string(),
},
};
self.send_report(report).await;
}
pub async fn flush(&self) {
self.queue
.process(|report| async move {
send_error_report(
&self.http,
&self.options.endpoint,
&self.options.api_key,
self.options.timeout,
&report,
)
.await
})
.await;
}
pub fn install_panic_hook(self: &Arc<Self>) {
let client = Arc::clone(self);
let previous = std::panic::take_hook();
std::panic::set_hook(Box::new(move |info| {
previous(info);
let message = panic_message(info);
let location = info
.location()
.map(|l| format!("panicked at {}:{}:{}", l.file(), l.line(), l.column()));
let backtrace = std::backtrace::Backtrace::force_capture().to_string();
let stack_trace = Some(match location {
Some(loc) => format!("{loc}\n{backtrace}"),
None => backtrace,
});
let client = Arc::clone(&client);
match tokio::runtime::Handle::try_current() {
Ok(handle) => {
handle.spawn(async move {
client
.capture(
"panic",
message,
stack_trace,
Some(Severity::Critical),
None,
)
.await;
});
}
Err(_) => {
if client.options.log_to_console {
eprintln!(
"[Oluso] Panic occurred outside a Tokio runtime; unable to report it: {message}"
);
}
}
}
}));
}
fn sanitize_request(&self, request: RequestContext) -> RequestContext {
RequestContext {
url: request.url,
method: request.method,
headers: request
.headers
.map(|headers| self.sanitizer.sanitize_string_map(&headers)),
query: request
.query
.map(|query| self.sanitizer.sanitize_string_map(&query)),
body: request
.body
.map(|body| self.sanitizer.sanitize_value(&body)),
}
}
async fn send_report(&self, report: ErrorReport) {
let result = send_error_report(
&self.http,
&self.options.endpoint,
&self.options.api_key,
self.options.timeout,
&report,
)
.await;
match result {
Ok(()) => {
if self.options.enable_offline_queue && !self.queue.is_empty().await {
self.queue
.process(|queued| async move {
send_error_report(
&self.http,
&self.options.endpoint,
&self.options.api_key,
self.options.timeout,
&queued,
)
.await
})
.await;
}
}
Err(err) => {
if self.options.log_to_console {
eprintln!("[Oluso] {err}");
}
if self.options.enable_offline_queue {
self.queue.enqueue(report).await;
}
}
}
}
}
fn truncate(value: &str, max: usize) -> String {
if value.chars().count() <= max {
return value.to_string();
}
format!(
"{}... [truncated]",
value.chars().take(max).collect::<String>()
)
}
fn exception_details(error_type: &str, err: &dyn std::error::Error) -> ExceptionDetails {
let mut root = ExceptionDetails {
r#type: error_type.to_string(),
message: truncate(&err.to_string(), 4000),
stack_trace: Some(truncate(&format!("{err:?}"), 16000)),
attributes: HashMap::new(),
causes: Vec::new(),
};
let mut cursor = err.source();
let mut chain = Vec::new();
for _ in 0..5 {
let Some(cause) = cursor else { break };
chain.push(ExceptionDetails {
r#type: std::any::type_name_of_val(cause).to_string(),
message: truncate(&cause.to_string(), 4000),
stack_trace: Some(truncate(&format!("{cause:?}"), 16000)),
attributes: HashMap::new(),
causes: Vec::new(),
});
cursor = cause.source();
}
root.causes = chain;
root
}
fn type_short_name<E: ?Sized>() -> String {
let full = std::any::type_name::<E>();
full.rsplit("::").next().unwrap_or(full).to_string()
}
fn generate_error_title(message: &str, error_type: &str) -> String {
let first_line = message.lines().next().unwrap_or("").trim();
if first_line.is_empty() {
return format!("{error_type} Error");
}
if first_line.chars().count() <= 100 {
first_line.to_string()
} else {
let truncated: String = first_line.chars().take(97).collect();
format!("{truncated}...")
}
}
fn server_context() -> ServerContext {
ServerContext {
hostname: gethostname::gethostname().to_string_lossy().to_string(),
os: std::env::consts::OS.to_string(),
arch: std::env::consts::ARCH.to_string(),
pid: std::process::id(),
}
}
fn panic_message(info: &std::panic::PanicHookInfo<'_>) -> String {
if let Some(s) = info.payload().downcast_ref::<&str>() {
s.to_string()
} else if let Some(s) = info.payload().downcast_ref::<String>() {
s.clone()
} else {
"unknown panic payload".to_string()
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn generates_a_short_title_from_the_first_message_line() {
assert_eq!(generate_error_title("boom\nwith detail", "Error"), "boom");
}
#[test]
fn truncates_long_titles_at_100_characters() {
let long = "x".repeat(150);
let title = generate_error_title(&long, "Error");
assert_eq!(title.chars().count(), 100);
assert!(title.ends_with("..."));
}
#[test]
fn falls_back_to_the_error_type_when_the_message_is_empty() {
assert_eq!(
generate_error_title("", "TimeoutError"),
"TimeoutError Error"
);
}
#[test]
fn type_short_name_strips_the_module_path() {
assert_eq!(type_short_name::<std::io::Error>(), "Error");
}
}