use std::sync::atomic::{AtomicU64, Ordering};
use std::time::Duration;
use reqwest::header::{HeaderMap, HeaderValue, ACCEPT, CONTENT_TYPE};
use serde::{Deserialize, Serialize};
use serde_json::{json, Map, Value};
use crate::client::Client;
static RUN_COUNTER: AtomicU64 = AtomicU64::new(1);
#[derive(Debug, Clone)]
pub enum MonitorReference {
Id(String),
Name(String),
}
impl MonitorReference {
pub fn by_id(value: impl Into<String>) -> Self {
Self::Id(value.into())
}
pub fn by_name(value: impl Into<String>) -> Self {
Self::Name(value.into())
}
fn fields(&self) -> Result<Map<String, Value>, MonitorRequestError> {
let mut fields = Map::new();
match self {
Self::Id(id) if !id.trim().is_empty() => {
fields.insert("monitor_id".into(), Value::String(id.clone()));
}
Self::Name(name) if !name.trim().is_empty() => {
fields.insert("monitor".into(), Value::String(name.clone()));
}
_ => {
return Err(MonitorRequestError::Invalid(
"monitor reference is required".into(),
))
}
}
Ok(fields)
}
}
#[derive(Debug, Clone, Default)]
pub struct HeartbeatOptions {
pub status: Option<String>,
pub duration_ms: Option<u64>,
pub message: Option<String>,
pub context: Value,
pub timestamp: Option<u64>,
}
#[derive(Debug, Clone)]
pub struct AssertionOptions {
pub monitor: MonitorReference,
pub passed: bool,
pub kind: String,
pub expected: Value,
pub actual: Value,
pub duration_ms: Option<u64>,
pub message: Option<String>,
pub context: Value,
pub timestamp: Option<u64>,
}
impl AssertionOptions {
pub fn new(monitor: MonitorReference, passed: bool) -> Self {
Self {
monitor,
passed,
kind: "wrong".into(),
expected: Value::Null,
actual: Value::Null,
duration_ms: None,
message: None,
context: Value::Null,
timestamp: None,
}
}
}
#[derive(Debug, Clone, Default)]
pub struct WorkflowEventOptions {
pub duration_ms: Option<u64>,
pub message: Option<String>,
pub context: Value,
pub timestamp: Option<u64>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct MonitorReceipt {
#[serde(default = "default_true")]
pub accepted: bool,
#[serde(default)]
pub incident_id: Option<String>,
#[serde(default)]
pub status: Option<String>,
#[serde(flatten)]
pub response: Map<String, Value>,
}
fn default_true() -> bool {
true
}
#[derive(Debug)]
pub enum MonitorRequestError {
Invalid(String),
Serialize(serde_json::Error),
Request(reqwest::Error),
Status(u16),
}
impl MonitorRequestError {
pub fn status_code(&self) -> Option<u16> {
match self {
Self::Status(status) => Some(*status),
_ => None,
}
}
pub fn retryable(&self) -> bool {
match self {
Self::Request(_) => true,
Self::Status(status) => matches!(*status, 408 | 425 | 429) || *status >= 500,
Self::Invalid(_) | Self::Serialize(_) => false,
}
}
}
impl std::fmt::Display for MonitorRequestError {
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Invalid(message) => write!(formatter, "oluso: {message}"),
Self::Serialize(error) => write!(formatter, "oluso: serialize monitor event: {error}"),
Self::Request(error) => write!(formatter, "oluso: monitor request failed: {error}"),
Self::Status(status) => write!(
formatter,
"oluso: monitor request failed with status {status}"
),
}
}
}
impl std::error::Error for MonitorRequestError {}
impl Client {
pub async fn heartbeat(
&self,
url: &str,
options: HeartbeatOptions,
) -> Result<MonitorReceipt, MonitorRequestError> {
let parsed = reqwest::Url::parse(url).map_err(|_| {
MonitorRequestError::Invalid("heartbeat URL must be an absolute HTTPS URL".into())
})?;
if parsed.scheme() != "https" || parsed.host_str().is_none() {
return Err(MonitorRequestError::Invalid(
"heartbeat URL must be an absolute HTTPS URL".into(),
));
}
let payload = json!({
"status": options.status.unwrap_or_else(|| "success".into()),
"duration_ms": options.duration_ms,
"message": options.message,
"evidence": self.monitor_evidence(options.context),
"timestamp": options.timestamp.unwrap_or_else(crate::time::now_millis),
});
self.send_monitor_event(url, payload, false).await
}
pub async fn assert_outcome(
&self,
options: AssertionOptions,
) -> Result<MonitorReceipt, MonitorRequestError> {
let mut payload = options.monitor.fields()?;
payload.insert("kind".into(), Value::String(options.kind));
payload.insert("passed".into(), Value::Bool(options.passed));
payload.insert("expected".into(), self.monitor_evidence(options.expected));
payload.insert("actual".into(), self.monitor_evidence(options.actual));
insert_option(&mut payload, "duration_ms", options.duration_ms);
insert_option(&mut payload, "message", options.message);
payload.insert("context".into(), self.monitor_evidence(options.context));
payload.insert(
"timestamp".into(),
Value::Number(
options
.timestamp
.unwrap_or_else(crate::time::now_millis)
.into(),
),
);
self.send_monitor_event(&self.options.monitor_endpoint, Value::Object(payload), true)
.await
}
pub fn workflow(
&self,
monitor: MonitorReference,
run_id: Option<String>,
) -> MonitorWorkflow<'_> {
MonitorWorkflow {
client: self,
monitor,
run_id: run_id.unwrap_or_else(new_run_id),
last_state: None,
}
}
async fn workflow_event(
&self,
monitor: &MonitorReference,
run_id: &str,
state: &str,
status: &str,
options: WorkflowEventOptions,
) -> Result<MonitorReceipt, MonitorRequestError> {
if run_id.trim().is_empty() || state.trim().is_empty() {
return Err(MonitorRequestError::Invalid(
"workflow run ID and state are required".into(),
));
}
let mut payload = monitor.fields()?;
payload.insert("kind".into(), Value::String("workflow".into()));
payload.insert("run_id".into(), Value::String(run_id.into()));
payload.insert("state".into(), Value::String(state.into()));
payload.insert("status".into(), Value::String(status.into()));
insert_option(&mut payload, "duration_ms", options.duration_ms);
insert_option(&mut payload, "message", options.message);
payload.insert("context".into(), self.monitor_evidence(options.context));
payload.insert(
"timestamp".into(),
Value::Number(
options
.timestamp
.unwrap_or_else(crate::time::now_millis)
.into(),
),
);
self.send_monitor_event(&self.options.monitor_endpoint, Value::Object(payload), true)
.await
}
async fn send_monitor_event(
&self,
url: &str,
payload: Value,
authenticated: bool,
) -> Result<MonitorReceipt, MonitorRequestError> {
let mut last = None;
for attempt in 0..=self.options.monitor_retries {
let request = self.build_monitor_request(url, &payload, authenticated)?;
match self.http.execute(request).await {
Ok(response) if response.status().is_success() => {
let bytes = response
.bytes()
.await
.map_err(MonitorRequestError::Request)?;
if bytes.is_empty() {
return Ok(MonitorReceipt {
accepted: true,
incident_id: None,
status: None,
response: Map::new(),
});
}
return serde_json::from_slice(&bytes).map_err(MonitorRequestError::Serialize);
}
Ok(response) => {
last = Some(MonitorRequestError::Status(response.status().as_u16()))
}
Err(error) => last = Some(MonitorRequestError::Request(error)),
}
let error = last
.as_ref()
.expect("monitor request error is always assigned");
if !error.retryable() || attempt >= self.options.monitor_retries {
break;
}
tokio::time::sleep(Duration::from_millis(100 * (1u64 << attempt))).await;
}
Err(last.expect("monitor request loop always executes"))
}
fn build_monitor_request(
&self,
url: &str,
payload: &Value,
authenticated: bool,
) -> Result<reqwest::Request, MonitorRequestError> {
let body = serde_json::to_vec(payload).map_err(MonitorRequestError::Serialize)?;
let mut headers = HeaderMap::new();
headers.insert(CONTENT_TYPE, HeaderValue::from_static("application/json"));
headers.insert(ACCEPT, HeaderValue::from_static("application/json"));
if authenticated {
headers.insert(
"x-oluso-signature",
HeaderValue::from_str(&self.options.api_key).map_err(|_| {
MonitorRequestError::Invalid(
"API key contains invalid header characters".into(),
)
})?,
);
}
self.http
.post(url)
.headers(headers)
.timeout(self.options.timeout)
.body(body)
.build()
.map_err(MonitorRequestError::Request)
}
fn monitor_evidence(&self, value: Value) -> Value {
bound_evidence(self.sanitizer.sanitize_value(&value), 0)
}
}
pub struct MonitorWorkflow<'a> {
client: &'a Client,
monitor: MonitorReference,
pub run_id: String,
last_state: Option<String>,
}
impl MonitorWorkflow<'_> {
pub async fn checkpoint(
&mut self,
state: impl Into<String>,
options: WorkflowEventOptions,
) -> Result<MonitorReceipt, MonitorRequestError> {
let state = state.into();
self.last_state = Some(state.clone());
self.client
.workflow_event(&self.monitor, &self.run_id, &state, "running", options)
.await
}
pub async fn fail(
&mut self,
state: impl Into<String>,
options: WorkflowEventOptions,
) -> Result<MonitorReceipt, MonitorRequestError> {
let state = state.into();
self.last_state = Some(state.clone());
self.client
.workflow_event(&self.monitor, &self.run_id, &state, "failed", options)
.await
}
pub async fn complete(
&mut self,
state: Option<String>,
options: WorkflowEventOptions,
) -> Result<MonitorReceipt, MonitorRequestError> {
let state = state.or_else(|| self.last_state.clone()).ok_or_else(|| {
MonitorRequestError::Invalid(
"complete needs a state before the first checkpoint".into(),
)
})?;
self.last_state = Some(state.clone());
self.client
.workflow_event(&self.monitor, &self.run_id, &state, "completed", options)
.await
}
}
fn insert_option<T: Serialize>(payload: &mut Map<String, Value>, key: &str, value: Option<T>) {
if let Some(value) = value {
if let Ok(value) = serde_json::to_value(value) {
payload.insert(key.into(), value);
}
}
}
fn bound_evidence(value: Value, depth: usize) -> Value {
if depth >= 8 {
return Value::String("[Max Depth Reached]".into());
}
match value {
Value::String(value) if value.chars().count() > 4000 => Value::String(format!(
"{}... [truncated]",
value.chars().take(4000).collect::<String>()
)),
Value::Array(values) => Value::Array(
values
.into_iter()
.take(100)
.map(|value| bound_evidence(value, depth + 1))
.collect(),
),
Value::Object(values) => {
let truncated = values.len() > 100;
let mut out: Map<String, Value> = values
.into_iter()
.take(100)
.map(|(key, value)| (key, bound_evidence(value, depth + 1)))
.collect();
if truncated {
out.insert("_truncated".into(), Value::Bool(true));
}
Value::Object(out)
}
other => other,
}
}
fn new_run_id() -> String {
format!(
"run-{}-{}",
crate::time::now_millis(),
RUN_COUNTER.fetch_add(1, Ordering::Relaxed)
)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::types::Options;
#[test]
fn heartbeat_request_never_has_project_signature() {
let client = Client::new(Options::new("project-key"));
let request = client
.build_monitor_request("https://api.oluso.dev/heartbeat/secret", &json!({}), false)
.unwrap();
assert!(!request.headers().contains_key("x-oluso-signature"));
let authenticated = client
.build_monitor_request("https://api.oluso.dev/events", &json!({}), true)
.unwrap();
assert_eq!(authenticated.headers()["x-oluso-signature"], "project-key");
}
}