use chrono::Utc;
use khive_storage::event::{Event, EventFilter};
use serde::Deserialize;
use serde_json::{json, Value};
use crate::{micros_to_iso, KhiveRuntime, NamespaceToken, RuntimeError};
use super::grouping::EventCountsAccumulator;
use super::parsing::{
event_actor_read_scope, parse_event_kind, parse_handler_params, parse_rfc3339_micros,
};
pub(crate) const MAX_WINDOW_EVENTS: u32 = 50_000;
pub(crate) const EXHAUSTIVE_PAGE_SIZE: u32 = 10_000;
pub(crate) const MAX_EXHAUSTIVE_EVENTS: u64 = 40 * MAX_WINDOW_EVENTS as u64;
pub(crate) fn truncatable_total_key(base_key: &str, truncated: bool) -> String {
if truncated {
format!("{base_key}_page_scoped")
} else {
base_key.to_string()
}
}
impl KhiveRuntime {
pub async fn read_event_counts(
&self,
token: &NamespaceToken,
params: Value,
) -> Result<Value, RuntimeError> {
let allowance = khive_storage::request_read_timeout_from_env();
let deadline = khive_storage::effective_request_read_deadline(
khive_storage::RequestReadDeadline::after(allowance),
);
khive_storage::scope_request_read_deadline_at(deadline, async {
let operation = format!(
"brain.event_counts (operator read budget {}s; earlier caller deadline retained)",
allowance.as_secs()
);
if khive_storage::request_read_is_cancelled() {
return Err(RuntimeError::Storage(
khive_storage::StorageError::Timeout {
operation: operation.into(),
},
));
}
let result = self.read_event_counts_in_read_scope(token, params).await;
if result.is_ok() && khive_storage::request_read_is_cancelled() {
return Err(RuntimeError::Storage(
khive_storage::StorageError::Timeout {
operation: operation.into(),
},
));
}
result
})
.await
}
async fn read_event_counts_in_read_scope(
&self,
token: &NamespaceToken,
params: Value,
) -> Result<Value, RuntimeError> {
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct EventCountsParams {
actor: Option<String>,
all_actors: Option<bool>,
kind: Option<String>,
group_by: Option<super::grouping::EventCountGroupBy>,
since: Option<String>,
until: Option<String>,
exhaustive: Option<bool>,
}
let p: EventCountsParams =
parse_handler_params(params).map_err(RuntimeError::InvalidInput)?;
let actor_scope = event_actor_read_scope(
self,
token,
p.actor.as_deref(),
p.all_actors.unwrap_or(false),
)?;
let since_raw = p.since.as_deref().ok_or_else(|| {
RuntimeError::InvalidInput(
"missing `since`: required ISO-8601/RFC-3339 datetime; expected e.g. \
\"2026-07-01T00:00:00Z\""
.to_string(),
)
})?;
let display_tz = self.config().display_timezone;
let since_us = parse_rfc3339_micros("since", since_raw, false, display_tz)?;
let until_us = match p.until.as_deref() {
Some(u) => parse_rfc3339_micros("until", u, true, display_tz)?,
None => Utc::now().timestamp_micros(),
};
let kind_filter = p.kind.as_deref().map(parse_event_kind).transpose()?;
let scope_namespace = token.namespace().as_str().to_string();
let mut scope_other: Vec<String> = token
.visible_namespace_strs()
.iter()
.map(|n| n.to_string())
.filter(|n| n != &scope_namespace)
.collect();
scope_other.sort();
scope_other.dedup();
let store = self.events(token)?;
let base_filter = EventFilter {
actors: actor_scope.actors,
kinds: kind_filter.into_iter().collect(),
after: Some(since_us - 1),
before: Some(until_us),
..EventFilter::default()
};
let exhaustive = p.exhaustive.unwrap_or(false);
let mut counts =
EventCountsAccumulator::new(actor_scope.default_caller.as_deref(), p.group_by);
let (total, window_event_total, truncated) = if exhaustive {
fold_event_counts_window_exhaustive(
store.as_ref(),
&base_filter,
EXHAUSTIVE_PAGE_SIZE,
MAX_EXHAUSTIVE_EVENTS,
&mut counts,
)
.await?
} else {
let (items, window_event_total, truncated) = fetch_event_counts_window(
store.as_ref(),
&base_filter,
p.kind.is_none(),
MAX_WINDOW_EVENTS,
)
.await?;
for event in &items {
counts.observe(event);
}
(items.len() as u64, window_event_total, truncated)
};
let mut result = json!({
"since": micros_to_iso(since_us),
"until": micros_to_iso(until_us),
"actor": p.actor,
"kind": p.kind,
"truncated": truncated,
"window_event_total": window_event_total,
"exhaustive": exhaustive,
"scope": {
"namespace": scope_namespace,
"other_namespaces": scope_other,
},
});
result[truncatable_total_key("total", truncated)] = json!(total);
counts.add_to_result(&mut result, truncated);
Ok(result)
}
}
pub const TRANSPORT_PAGE_ROWS: u32 = crate::events_split::MAX_QUERY_EVENTS_PAGE_ROWS;
pub(super) fn event_counts_storage_error(error: khive_storage::StorageError) -> RuntimeError {
match error {
error @ (khive_storage::StorageError::Timeout { .. }
| khive_storage::StorageError::AdmissionTimeout { .. }) => RuntimeError::Storage(error),
other => RuntimeError::InvalidInput(other.to_string()),
}
}
pub(super) async fn grouped_window_total(
store: &dyn khive_storage::event::EventStore,
filter: &EventFilter,
) -> Result<u64, RuntimeError> {
Ok(store
.count_events_grouped(filter.clone(), khive_storage::event::EventGroupBy::Kind)
.await
.map_err(event_counts_storage_error)?
.values()
.copied()
.sum())
}
pub async fn fetch_event_counts_window(
store: &dyn khive_storage::event::EventStore,
base_filter: &EventFilter,
unfiltered: bool,
page_limit: u32,
) -> Result<(Vec<Event>, u64, bool), RuntimeError> {
if !unfiltered {
let window_event_total = grouped_window_total(store, base_filter).await?;
let items = collect_events_cursor_walk(
store,
base_filter,
TRANSPORT_PAGE_ROWS,
u64::from(page_limit),
)
.await?;
let truncated = window_event_total > items.len() as u64;
return Ok((items, window_event_total, truncated));
}
let non_audit_kinds: Vec<khive_types::EventKind> = khive_types::EventKind::ALL
.iter()
.copied()
.filter(|k| *k != khive_types::EventKind::Audit)
.collect();
let audit_filter = EventFilter {
kinds: vec![khive_types::EventKind::Audit],
..base_filter.clone()
};
let non_audit_filter = EventFilter {
kinds: non_audit_kinds,
..base_filter.clone()
};
let totals = store
.count_events_grouped(
EventFilter {
kinds: khive_types::EventKind::ALL.to_vec(),
..base_filter.clone()
},
khive_storage::event::EventGroupBy::Kind,
)
.await
.map_err(event_counts_storage_error)?;
let audit_total = totals
.get(khive_types::EventKind::Audit.name())
.copied()
.unwrap_or(0);
let non_audit_total: u64 = khive_types::EventKind::ALL
.iter()
.filter(|kind| **kind != khive_types::EventKind::Audit)
.map(|kind| totals.get(kind.name()).copied().unwrap_or(0))
.sum();
let audit_items = collect_events_cursor_walk(
store,
&audit_filter,
TRANSPORT_PAGE_ROWS,
u64::from(page_limit),
)
.await?;
let non_audit_items = collect_events_cursor_walk(
store,
&non_audit_filter,
TRANSPORT_PAGE_ROWS,
u64::from(page_limit),
)
.await?;
let truncated =
audit_total > audit_items.len() as u64 || non_audit_total > non_audit_items.len() as u64;
let window_event_total = audit_total + non_audit_total;
let mut items = audit_items;
items.extend(non_audit_items);
Ok((items, window_event_total, truncated))
}
pub(crate) async fn collect_events_cursor_walk(
store: &dyn khive_storage::event::EventStore,
base_filter: &EventFilter,
page_size: u32,
max_rows: u64,
) -> Result<Vec<Event>, RuntimeError> {
let mut items = Vec::new();
visit_events_cursor_walk(store, base_filter, page_size, max_rows, |event| {
items.push(event)
})
.await?;
Ok(items)
}
pub(crate) async fn visit_events_cursor_walk<F: FnMut(Event)>(
store: &dyn khive_storage::event::EventStore,
base_filter: &EventFilter,
page_size: u32,
max_rows: u64,
visit: F,
) -> Result<u64, RuntimeError> {
crate::visit_events_cursor_walk(store, base_filter, page_size, max_rows, visit)
.await
.map_err(|cause| match cause {
crate::EventCursorWalkError::Storage(error) => event_counts_storage_error(error),
crate::EventCursorWalkError::MissingBoundary => RuntimeError::Internal(
"event cursor walk saw duplicate rows before any boundary".to_string(),
),
crate::EventCursorWalkError::DenseTimestampTie {
page_limit: fetch_limit,
} => RuntimeError::InvalidInput(format!(
"brain.event_counts cannot page this window: more than {fetch_limit} \
events share one created_at microsecond, which exceeds the event \
transport's page cap; narrow `since`/`until` or add filters (`actor` \
or `kind`)"
)),
})
}
#[cfg(any(test, feature = "test-internals"))]
pub async fn fetch_event_counts_window_exhaustive(
store: &dyn khive_storage::event::EventStore,
base_filter: &EventFilter,
page_size: u32,
max_events: u64,
) -> Result<(Vec<Event>, u64, bool), RuntimeError> {
let mut items = Vec::new();
let (_, total, truncated) =
visit_event_counts_window_exhaustive(store, base_filter, page_size, max_events, |event| {
items.push(event)
})
.await?;
Ok((items, total, truncated))
}
pub(crate) async fn fold_event_counts_window_exhaustive(
store: &dyn khive_storage::event::EventStore,
base_filter: &EventFilter,
page_size: u32,
max_events: u64,
counts: &mut EventCountsAccumulator,
) -> Result<(u64, u64, bool), RuntimeError> {
visit_event_counts_window_exhaustive(store, base_filter, page_size, max_events, |event| {
counts.observe(&event)
})
.await
}
pub(super) async fn visit_event_counts_window_exhaustive<F: FnMut(Event)>(
store: &dyn khive_storage::event::EventStore,
base_filter: &EventFilter,
page_size: u32,
max_events: u64,
visit: F,
) -> Result<(u64, u64, bool), RuntimeError> {
let window_event_total = grouped_window_total(store, base_filter).await?;
if window_event_total > max_events {
return Err(RuntimeError::InvalidInput(format!(
"brain.event_counts window exceeds the exhaustive limit of {max_events} events \
({window_event_total} matched); narrow `since`/`until` or add filters (`actor` or \
`kind`)"
)));
}
let admitted =
visit_events_cursor_walk(store, base_filter, page_size, max_events, visit).await?;
let truncated = admitted < window_event_total;
Ok((admitted, window_event_total, truncated))
}
pub(crate) fn event_work_class(payload: &Value) -> Option<&str> {
payload
.get("work_class")
.and_then(Value::as_str)
.or_else(|| {
payload
.get("resource")
.and_then(|resource| resource.get("work_class"))
.and_then(Value::as_str)
})
}
pub(crate) fn event_cost_unit(payload: &Value) -> Option<i64> {
payload
.get("resource")
.and_then(|resource| resource.get("cost_unit"))
.and_then(Value::as_i64)
}