Files
javis_bot/app/src/dashboard.rs
javis-bot 371e87f553 fix(app): the dashboard keeps each run's events, each answer's own times, and only its session's captions
- Each start gets a new dashboard; stop ends the event feeding and waits for
  it before forgetting, so queued or earlier-run events never reach the
  screen.
- AnswerAsked carries the request's speech end and final times, so a second
  waiting question does not change the first answer's timing.
- Captions are shown only while Jarvis is in a voice channel.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-12 13:55:44 +09:00

307 lines
13 KiB
Rust

//! What the dashboard shows, built from the core's events (`app/src/admin.spec.md`, "Dashboard data").
//!
//! Pure: `on_event` takes the time, so every rule is tested with made-up events. Captions hold what
//! people said for the screen only; nothing here is logged or written.
use std::collections::{HashMap, VecDeque};
use std::time::Instant;
use serde::Serialize;
use serde_json::{json, Value};
use crate::conversation::Missed;
use crate::discord::CoreEvent;
pub const CAPTIONS_KEPT: usize = 30;
pub const ANSWERS_KEPT: usize = 20;
pub const MISSED_SHOWN: usize = 20;
#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct Caption {
pub speaker: String,
pub name: String,
pub text: String,
#[serde(rename = "final")]
pub is_final: bool,
#[serde(skip)]
utt: u32,
}
/// One voice answer's stages in milliseconds (None: that stage could not be seen, e.g. no answer text
/// before the sound).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct AnswerTiming {
/// Speech end to its final transcript.
pub final_ms: Option<u64>,
/// The answer asked to its text.
pub brain_ms: Option<u64>,
/// The text to the first sound of the answer.
pub voice_ms: Option<u64>,
/// Speech end to the first sound.
pub total_ms: Option<u64>,
}
struct Pending {
asked: Instant,
/// When the request's speech ended and when its final came.
heard: (Instant, Instant),
reply: Option<Instant>,
}
#[derive(Default)]
pub struct Dashboard {
bot_tag: Option<String>,
voice_channel: Option<u64>,
captions: VecDeque<Caption>,
pending: HashMap<String, Pending>,
answers: VecDeque<AnswerTiming>,
}
fn ms(from: Instant, to: Instant) -> u64 {
to.saturating_duration_since(from).as_millis() as u64
}
impl Dashboard {
pub fn on_event(&mut self, ev: &CoreEvent, now: Instant) {
match ev {
CoreEvent::Ready { tag, .. } => self.bot_tag = Some(tag.clone()),
CoreEvent::Joined { channel_id, .. } => self.voice_channel = Some(*channel_id),
CoreEvent::Left { .. } => {
self.voice_channel = None;
self.captions.clear();
self.pending.clear();
}
// Captions belong to the voice session: a transcript arriving after Jarvis left is dropped.
CoreEvent::Partial(h, text) if self.voice_channel.is_some() =>
self.caption(h.speaker_id, &h.speaker_name, h.utt, text, false),
CoreEvent::Final(f) if self.voice_channel.is_some() => {
let h = &f.heard;
self.caption(h.speaker_id, &h.speaker_name, h.utt, &f.text, true);
}
// The request's own times: a second question waiting behind the first does not move them.
CoreEvent::AnswerAsked { id, ended_at, final_at, .. } => {
self.pending.insert(id.clone(), Pending { asked: now, heard: (*ended_at, *final_at), reply: None });
}
CoreEvent::ReplyText { id, .. } => {
if let Some(p) = self.pending.get_mut(id) {
p.reply = Some(now);
}
}
CoreEvent::SpeakStart(id) => {
if let Some(p) = self.pending.remove(id) {
let t = AnswerTiming {
final_ms: Some(ms(p.heard.0, p.heard.1)),
brain_ms: p.reply.map(|r| ms(p.asked, r)),
voice_ms: p.reply.map(|r| ms(r, now)),
total_ms: Some(ms(p.heard.0, now)),
};
if self.answers.len() == ANSWERS_KEPT {
self.answers.pop_front();
}
self.answers.push_back(t);
}
}
// An answer that ends without starting (failed, stopped) has nothing to time.
CoreEvent::SpeakEnd(e) => {
self.pending.remove(&e.id);
}
_ => {}
}
}
/// A partial replaces the same utterance's earlier caption; the final replaces the partial
/// (an empty final removes it).
fn caption(&mut self, speaker: u64, name: &str, utt: u32, text: &str, is_final: bool) {
let id = speaker.to_string();
let pos = self.captions.iter().position(|c| c.speaker == id && c.utt == utt && !c.is_final);
if let Some(i) = pos {
self.captions.remove(i);
}
if text.trim().is_empty() {
return;
}
if self.captions.len() == CAPTIONS_KEPT {
self.captions.pop_front();
}
self.captions.push_back(Caption { speaker: id, name: name.into(), text: text.into(), is_final, utt });
}
/// Forget what was said (the services stopped).
pub fn clear(&mut self) {
*self = Self::default();
}
pub fn captions(&self) -> Vec<Caption> {
self.captions.iter().cloned().collect()
}
pub fn answers(&self) -> Vec<AnswerTiming> {
self.answers.iter().copied().collect()
}
/// The median of each stage over the answers kept.
pub fn medians(&self) -> AnswerTiming {
fn median(mut v: Vec<u64>) -> Option<u64> {
v.sort_unstable();
(!v.is_empty()).then(|| v[v.len() / 2])
}
let pick = |f: fn(&AnswerTiming) -> Option<u64>| median(self.answers.iter().filter_map(f).collect());
AnswerTiming { final_ms: pick(|a| a.final_ms), brain_ms: pick(|a| a.brain_ms),
voice_ms: pick(|a| a.voice_ms), total_ms: pick(|a| a.total_ms) }
}
pub fn view(&self, missed: &[Missed], now: Instant) -> Value {
json!({
"discord": self.bot_tag,
"voiceChannel": self.voice_channel.map(|c| c.to_string()),
"captions": self.captions(),
"latency": {"answers": self.answers(), "median": self.medians()},
"missed": missed_view(missed, now),
})
}
}
/// Newest first, at most `MISSED_SHOWN`: who, why, how long ago and how long the request was.
pub fn missed_view(missed: &[Missed], now: Instant) -> Value {
Value::Array(missed.iter().rev().take(MISSED_SHOWN).map(|m| json!({
"speaker": m.speaker.to_string(),
"reason": m.reason,
"secondsAgo": now.saturating_duration_since(m.at).as_secs(),
"chars": m.chars,
})).collect())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::discord::{Heard, HeardFinal};
use crate::playback::PlaybackEnd;
use crate::policy::MissReason;
use std::time::Duration;
const A: u64 = 11;
fn heard(utt: u32) -> Heard {
Heard { speaker_id: A, speaker_name: "민수".into(), utt }
}
fn fin(utt: u32, text: &str, wait_ms: u64) -> CoreEvent {
CoreEvent::Final(HeardFinal { heard: heard(utt), text: text.into(), end_reason: "silence".into(),
audio_ms: 900, wait_ms, stt_ms: 200 })
}
fn at(t: Instant, ms: u64) -> Instant {
t + Duration::from_millis(ms)
}
fn joined() -> CoreEvent {
CoreEvent::Joined { guild_id: 1, channel_id: 5 }
}
fn left() -> CoreEvent {
CoreEvent::Left { guild_id: 1, channel_id: 5, reason: "command".into() }
}
fn asked(id: &str, t: Instant, ended: u64, final_at: u64) -> CoreEvent {
CoreEvent::AnswerAsked { id: id.into(), user: A, ended_at: at(t, ended), final_at: at(t, final_at) }
}
fn reply(id: &str) -> CoreEvent {
CoreEvent::ReplyText { id: id.into(), text: "네".into(), failed: false }
}
#[test]
fn a_partial_is_replaced_by_the_next_and_then_by_the_final() {
let (mut d, t) = (Dashboard::default(), Instant::now());
d.on_event(&joined(), t);
d.on_event(&CoreEvent::Partial(heard(1), "자비스 오늘".into()), t);
d.on_event(&CoreEvent::Partial(heard(1), "자비스 오늘 날씨".into()), t);
assert_eq!(d.captions().iter().map(|c| (c.text.as_str(), c.is_final)).collect::<Vec<_>>(),
vec![("자비스 오늘 날씨", false)]);
d.on_event(&fin(1, "자비스 오늘 날씨 어때?", 700), t);
d.on_event(&CoreEvent::Partial(heard(2), "그리고".into()), t);
assert_eq!(d.captions().iter().map(|c| (c.text.as_str(), c.is_final)).collect::<Vec<_>>(),
vec![("자비스 오늘 날씨 어때?", true), ("그리고", false)]);
// An empty final removes its partial.
d.on_event(&fin(2, "", 300), t);
assert_eq!(d.captions().len(), 1);
assert_eq!(d.captions()[0].name, "민수");
}
#[test]
fn captions_are_capped_and_cleared_when_jarvis_leaves_and_late_ones_stay_out() {
let (mut d, t) = (Dashboard::default(), Instant::now());
d.on_event(&joined(), t);
for i in 0..(CAPTIONS_KEPT as u32 + 5) {
d.on_event(&fin(i, &format!("말 {i}"), 100), t);
}
let caps = d.captions();
assert_eq!(caps.len(), CAPTIONS_KEPT);
assert_eq!(caps.last().unwrap().text, format!("말 {}", CAPTIONS_KEPT + 4));
d.on_event(&left(), t);
assert!(d.captions().is_empty());
// A transcript of the session that ended arrives after the leave: it does not come back.
d.on_event(&CoreEvent::Partial(heard(90), "늦게 온 말".into()), t);
d.on_event(&fin(90, "늦게 온 말", 100), t);
assert!(d.captions().is_empty());
assert_eq!(d.view(&[], t)["voiceChannel"], Value::Null);
}
#[test]
fn an_answer_is_timed_from_its_own_requests_speech_end_to_its_first_sound() {
let (mut d, t) = (Dashboard::default(), Instant::now());
d.on_event(&joined(), t);
d.on_event(&asked("r1", t, 300, 1000), at(t, 1010));
d.on_event(&reply("r1"), at(t, 1700));
d.on_event(&CoreEvent::SpeakStart("r1".into()), at(t, 1900));
assert_eq!(d.answers(), vec![AnswerTiming { final_ms: Some(700), brain_ms: Some(690), voice_ms: Some(200),
total_ms: Some(1600) }]);
// An answer stopped before it started is not timed; the earcon (another id) is not either.
d.on_event(&asked("r3", t, 2000, 2500), at(t, 3000));
d.on_event(&CoreEvent::SpeakStart("r2".into()), at(t, 3000));
d.on_event(&CoreEvent::SpeakEnd(PlaybackEnd { id: "r3".into(), played: 0, cancelled: true, failed: false }),
at(t, 3100));
d.on_event(&CoreEvent::SpeakStart("r3".into()), at(t, 3200));
assert_eq!(d.answers().len(), 1);
}
#[test]
fn a_second_question_waiting_does_not_change_the_first_answers_times() {
let (mut d, t) = (Dashboard::default(), Instant::now());
d.on_event(&joined(), t);
// First question ends at 0 (final at 700); the same person asks again, ending at 1000, while
// the first is still answered. The first answer starts sounding at 3700.
d.on_event(&fin(1, "첫 질문", 700), at(t, 700));
d.on_event(&asked("r1", t, 0, 700), at(t, 710));
d.on_event(&fin(2, "둘째 질문", 700), at(t, 1700));
d.on_event(&reply("r1"), at(t, 3500));
d.on_event(&CoreEvent::SpeakStart("r1".into()), at(t, 3700));
assert_eq!(d.answers()[0].total_ms, Some(3700));
assert_eq!(d.answers()[0].final_ms, Some(700));
}
#[test]
fn the_medians_cover_the_last_answers_kept() {
let (mut d, t) = (Dashboard::default(), Instant::now());
for (i, brain) in [500u64, 900, 700].into_iter().enumerate() {
let base = i as u64 * 10_000;
d.on_event(&asked(&format!("r{i}"), t, base + 400, base + 1000), at(t, base + 1000));
d.on_event(&reply(&format!("r{i}")), at(t, base + 1000 + brain));
d.on_event(&CoreEvent::SpeakStart(format!("r{i}")), at(t, base + 1000 + brain + 100));
}
let m = d.medians();
assert_eq!((m.final_ms, m.brain_ms, m.voice_ms, m.total_ms), (Some(600), Some(700), Some(100), Some(1400)));
for i in 0..ANSWERS_KEPT as u64 {
d.on_event(&asked(&format!("x{i}"), t, 100_000, 100_000), at(t, 100_000 + i));
d.on_event(&CoreEvent::SpeakStart(format!("x{i}")), at(t, 100_000 + i));
}
assert_eq!(d.answers().len(), ANSWERS_KEPT);
assert_eq!(d.medians().brain_ms, None, "no answer text seen for the answers kept");
}
#[test]
fn missed_requests_show_newest_first_without_text() {
let t = Instant::now();
let missed: Vec<Missed> = (0..25).map(|i| Missed { speaker: i, reason: MissReason::Busy,
at: t, chars: 7 }).collect();
let v = missed_view(&missed, at(t, 3000));
let a = v.as_array().unwrap();
assert_eq!(a.len(), MISSED_SHOWN);
assert_eq!(a[0], json!({"speaker": "24", "reason": "busy", "secondsAgo": 3, "chars": 7}));
}
}