use crate::media::{AudioFrame, INTERNAL_SAMPLERATE, Samples, TrackId};
use anyhow::Result;
use bytes::{Bytes, BytesMut};
use futures::{SinkExt, StreamExt};
use serde::{Deserialize, Serialize};
use serde_json::json;
use serde_with::skip_serializing_none;
use std::{collections::HashMap, time::Duration};
use tokio::sync::broadcast;
use tokio_tungstenite::{
connect_async,
tungstenite::{
Message,
client::IntoClientRequest,
http::{HeaderName, HeaderValue},
},
};
use tokio_util::sync::CancellationToken;
use tracing::{info, warn};
pub const LEG_AGENT: u8 = 0;
pub const LEG_CALLER: u8 = 1;
pub const MONITOR_CHANNEL_CAPACITY: usize = 200;
#[skip_serializing_none]
#[derive(Debug, Deserialize, Serialize, Clone, Default)]
#[serde(rename_all = "camelCase")]
pub struct MonitorOption {
url: String,
buffer_size: Option<u32>,
ptime: Option<u32>,
headers: Option<HashMap<String, String>>,
}
impl MonitorOption {
pub fn new(
url: String,
buffer_size: Option<u32>,
ptime: Option<u32>,
headers: Option<HashMap<String, String>>,
) -> Self {
Self {
url,
buffer_size,
ptime,
headers,
}
}
pub fn url(&self) -> &str {
&self.url
}
pub fn buffer_size(&self) -> Option<u32> {
self.buffer_size
}
pub fn ptime(&self) -> Option<u32> {
self.ptime
}
pub fn headers(&self) -> Option<&HashMap<String, String>> {
self.headers.as_ref()
}
}
#[derive(Clone)]
pub struct MonitorHub {
sender: broadcast::Sender<Bytes>,
}
impl Default for MonitorHub {
fn default() -> Self {
Self::new()
}
}
impl MonitorHub {
pub fn new() -> Self {
let (sender, _) = broadcast::channel(MONITOR_CHANNEL_CAPACITY);
Self { sender }
}
pub fn subscribe(&self) -> broadcast::Receiver<Bytes> {
self.sender.subscribe()
}
pub(crate) fn publish(&self, data: Bytes) {
let _ = self.sender.send(data);
}
}
pub struct MonitorProcessor {
owner: TrackId,
leg: u8,
hub: MonitorHub,
}
impl MonitorProcessor {
pub fn new(owner: TrackId, leg: u8, hub: MonitorHub) -> Self {
Self { owner, leg, hub }
}
}
impl super::processor::Processor for MonitorProcessor {
fn process_frame(&mut self, frame: &mut AudioFrame) -> Result<()> {
if frame.track_id != self.owner {
return Ok(());
}
if let Samples::PCM { samples } = &frame.samples
&& !samples.is_empty()
{
let pcm = audio_codec::samples_to_bytes(samples);
let mut data = Vec::with_capacity(pcm.len() + 1);
data.push(self.leg);
data.extend_from_slice(&pcm);
self.hub.publish(Bytes::from(data));
}
Ok(())
}
}
pub fn monitor_start_metadata(
session_id: &str,
call_type: serde_json::Value,
started_at: String,
extras: serde_json::Value,
) -> serde_json::Value {
json!({
"event": "monitor_start",
"sessionId": session_id,
"callType": call_type,
"startedAt": started_at,
"format": "pcm16/mono",
"sampleRate": INTERNAL_SAMPLERATE,
"legs": [
{ "leg": LEG_AGENT, "direction": "agent", "sampleRate": INTERNAL_SAMPLERATE },
{ "leg": LEG_CALLER, "direction": "caller", "sampleRate": INTERNAL_SAMPLERATE },
],
"extras": extras,
})
}
pub async fn run_monitor_forwarder(
session_id: String,
option: MonitorOption,
metadata: serde_json::Value,
cancel_token: CancellationToken,
mut receiver: broadcast::Receiver<Bytes>,
) {
let mut url = match url::Url::parse(option.url()) {
Ok(url) => url,
Err(e) => {
warn!(session_id, url = %option.url(), error = %e, "monitor: invalid url, giving up");
return;
}
};
{
let mut query = url.query_pairs_mut();
query.append_pair("session_id", &session_id);
}
let mut request = match url.as_str().into_client_request() {
Ok(request) => request,
Err(e) => {
warn!(session_id, url = %url, error = %e, "monitor: invalid request, giving up");
return;
}
};
if let Some(headers) = option.headers() {
for (name, value) in headers {
let (name, value) = match (
HeaderName::from_bytes(name.as_bytes()),
HeaderValue::from_str(value),
) {
(Ok(name), Ok(value)) => (name, value),
(name_err, value_err) => {
warn!(
session_id,
header = %name,
name_error = ?name_err.err(),
value_error = ?value_err.err(),
"monitor: invalid header, giving up"
);
return;
}
};
request.headers_mut().insert(name, value);
}
}
info!(session_id, url = %url, "monitor: connecting");
let (ws, _) = match connect_async(request).await {
Ok(ok) => ok,
Err(e) => {
warn!(
session_id,
url = %url,
error = %e,
"monitor: connect failed, giving up for this call"
);
return;
}
};
let (mut ws_sink, mut ws_source) = ws.split();
crate::spawn(async move {
while let Some(msg) = ws_source.next().await {
if msg.is_err() {
break;
}
}
});
if let Err(e) = ws_sink.send(Message::Text(metadata.to_string().into())).await {
warn!(
session_id,
error = %e,
"monitor: failed to send metadata, giving up for this call"
);
return;
}
info!(session_id, url = %url, "monitor: connected");
let buffer_size = option.buffer_size().filter(|size| *size > 0).unwrap_or(0) as usize;
let ptime_ms = option.ptime().filter(|p| *p > 0).unwrap_or(0);
let mut ticker = tokio::time::interval(Duration::from_millis(ptime_ms.max(1) as u64));
ticker.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
let mut leg_buffers: HashMap<u8, BytesMut> = HashMap::new();
loop {
let mut outgoing: Vec<Bytes> = Vec::new();
tokio::select! {
biased;
_ = cancel_token.cancelled() => break,
_ = ticker.tick(), if ptime_ms > 0 => {
for (leg, buffer) in leg_buffers.iter_mut() {
if !buffer.is_empty() {
outgoing.push(tag_frame(*leg, std::mem::take(buffer)));
}
}
}
msg = receiver.recv() => match msg {
Ok(data) => {
if data.is_empty() {
continue;
}
let leg = data[0];
let buffer = leg_buffers.entry(leg).or_default();
buffer.extend_from_slice(&data[1..]);
if buffer_size > 0 {
while buffer.len() >= buffer_size {
outgoing.push(tag_frame(leg, buffer.split_to(buffer_size)));
}
} else if ptime_ms == 0 {
outgoing.push(tag_frame(leg, std::mem::take(buffer)));
}
}
Err(broadcast::error::RecvError::Lagged(dropped)) => {
warn!(session_id, dropped, "monitor: lagged, dropping frames");
continue;
}
Err(broadcast::error::RecvError::Closed) => break,
}
}
let mut failed = false;
for chunk in outgoing {
if let Err(e) = ws_sink.send(Message::Binary(chunk)).await {
warn!(
session_id,
error = %e,
"monitor: websocket send failed, giving up for this call"
);
failed = true;
break;
}
}
if failed {
break;
}
}
let _ = ws_sink.close().await;
info!(session_id, url = %url, "monitor forwarder stopped");
}
fn tag_frame(leg: u8, pcm: BytesMut) -> Bytes {
let mut out = BytesMut::with_capacity(pcm.len() + 1);
out.extend_from_slice(&[leg]);
out.extend_from_slice(&pcm);
out.freeze()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn monitor_option_parses_camel_case() {
let option: MonitorOption = serde_json::from_value(json!({
"url": "ws://server:9000/audio",
"bufferSize": 640,
"ptime": 100,
"headers": { "Authorization": "Bearer token", "X-Tenant-ID": "t1" }
}))
.unwrap();
assert_eq!(option.url(), "ws://server:9000/audio");
assert_eq!(option.buffer_size(), Some(640));
assert_eq!(option.ptime(), Some(100));
let headers = option.headers().unwrap();
assert_eq!(headers.get("Authorization").map(String::as_str), Some("Bearer token"));
assert_eq!(headers.get("X-Tenant-ID").map(String::as_str), Some("t1"));
}
#[test]
fn monitor_option_defaults_are_passthrough() {
let option: MonitorOption = serde_json::from_value(json!({ "url": "ws://x" })).unwrap();
assert_eq!(option.buffer_size(), None);
assert_eq!(option.ptime(), None);
assert_eq!(option.headers(), None);
}
#[test]
fn metadata_contains_session_and_legs() {
let metadata = monitor_start_metadata(
"s.1",
json!("sip"),
"2026-10-27T00:00:00Z".to_string(),
json!({ "k": "v" }),
);
assert_eq!(metadata["event"], "monitor_start");
assert_eq!(metadata["sessionId"], "s.1");
assert_eq!(metadata["callType"], "sip");
assert_eq!(metadata["sampleRate"], INTERNAL_SAMPLERATE);
assert_eq!(metadata["legs"][0]["leg"], LEG_AGENT);
assert_eq!(metadata["legs"][0]["direction"], "agent");
assert_eq!(metadata["legs"][1]["leg"], LEG_CALLER);
assert_eq!(metadata["legs"][1]["direction"], "caller");
assert_eq!(metadata["extras"]["k"], "v");
}
}