Files
uu-remote-linux/src/viewer_metrics.rs
T
VallierDevandClaude Opus 5.5 502635b156 Initial import of uu-remote-linux
Unofficial Linux host for NetEase UU Remote: X11 (production-tested on
GNOME/Ubuntu 24.04), experimental Wayland (Hyprland) and portal
(GNOME/KDE) backends; video, input, clipboard, file transfer, terminal,
sound, quality/fps/resolution settings, lock/unlock and system actions.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-14 23:53:16 +08:00

73 lines
4.6 KiB
Rust

//! Bounded viewer telemetry extraction. Payloads and nonnumeric values never log.
use base64::Engine;
use std::io::Read;
use serde_json::Value;
const LIMIT:usize=256*1024;
fn permitted(key:&str)->bool{
["avg_received_fps","avg_decode_fps","avg_render_fps","avg_assembly_ms_interval","avg_current_delay_ms_interval","avg_decode_ms_interval","avg_delay_ms_interval","avg_jitter_buffer_ms_interval","avg_processing_delay_interval","avg_render_delay_ms_interval","avg_target_delay_ms_interval","received_framerate","actual_received_framerate","decode_framerate","render_framerate","actual_framerate",
"current_delay","average_delay","max_delay","current_delay_ms_interval","target_delay_ms_interval",
"jitter_buffer_ms_interval","render_delay_ms_interval","assembly_ms_interval","decode_ms_interval",
"processing_delay_interval","sending_delay_interval","frames_received","frames_decoded","frames_actual_rendered",
"packets_received","packets_lost","packet_loss_rate","current_packet_loss_rate",
"frame_capture_delay_ms_interval","frame_encode_delay_ms_interval","frame_pacer_delay_ms_interval",
"frame_transport_delay_ms_interval","frame_decode_delay_ms_interval","frame_e2e_delay_ms_interval"].contains(&key)
}
fn unpack(text:&str)->Option<Value>{
if text.len()>LIMIT{return None;}
if let Ok(value)=serde_json::from_str(text){return Some(value);}
let bytes=base64::engine::general_purpose::STANDARD.decode(text).ok()?;
let mut output=Vec::new();
if bytes.starts_with(&[31,139]){
flate2::read::GzDecoder::new(&bytes[..]).take(LIMIT as u64+1).read_to_end(&mut output).ok()?;
}else if bytes.first()==Some(&0x78){
flate2::read::ZlibDecoder::new(&bytes[..]).take(LIMIT as u64+1).read_to_end(&mut output).ok()?;
}else{output=bytes;}
if output.len()>LIMIT{return None;}serde_json::from_slice(&output).ok()
}
pub fn collect(event:&Value)->Vec<(String,f64)>{
fn walk(v:&Value,path:&str,selected:bool,depth:usize,budget:&mut usize,out:&mut Vec<(String,f64)>){
if depth>12||*budget==0||out.len()>=128{return;}*budget-=1;
match v{
Value::Number(n) if selected=>{if let Some(n)=n.as_f64(){out.push((path.into(),n));}},
Value::Object(map)=>for(k,v)in map{
let allowed=permitted(k);
// After selecting a metric, only numeric aggregation keys are retained.
let aggregation=selected&&["min","max","avg","mean","sum","count","value","current","total"].contains(&k.as_str());
let next=if allowed||aggregation{format!("{path}.{k}")}else{path.into()};
walk(v,&next,allowed||aggregation,depth+1,budget,out);
},
Value::Array(a)=>for v in a{walk(v,path,selected,depth+1,budget,out);},
Value::String(text)=>{
if selected{if let Ok(number)=text.parse::<f64>(){if number.is_finite(){out.push((path.into(),number));return;}}}
if let Some(unpacked)=unpack(text){walk(&unpacked,path,selected,depth+1,budget,out);}
},_=>{}
}
}
let mut output=Vec::new();walk(event,"stats",false,0,&mut 8192,&mut output);output
}
pub fn safe_shape(event:&Value)->Vec<(String,&'static str)>{
fn walk(v:&Value,path:&str,depth:usize,out:&mut Vec<(String,&'static str)>){
if depth>3||out.len()>=24{return;}
let kind=match v{Value::Object(_)=>"object",Value::Array(_)=>"array",Value::String(_)=>"string",Value::Number(_)=>"number",Value::Bool(_)=>"bool",Value::Null=>"null"};
out.push((path.into(),kind));
if let Value::Object(map)=v{for(k,v)in map{
if k.len()<=48&&k.bytes().all(|b|b.is_ascii_alphanumeric()||b==b'_'){walk(v,&format!("{path}.{k}"),depth+1,out);}
}}
}
let mut output=Vec::new();walk(event,"event",0,&mut output);output
}
#[cfg(test)]mod tests{
use super::*;
#[test]fn extracts_compressed_metrics_but_no_private_values(){
use std::io::Write;
let text=r#"{"token":"secret","current_delay_ms_interval":{"avg":17},"render_framerate":60}"#;
let mut z=flate2::write::GzEncoder::new(Vec::new(),flate2::Compression::default());z.write_all(text.as_bytes()).unwrap();
let encoded=base64::engine::general_purpose::STANDARD.encode(z.finish().unwrap());
assert_eq!(collect(&serde_json::json!({"data":encoded})),vec![("stats.current_delay_ms_interval.avg".into(),17.),("stats.render_framerate".into(),60.)]);
}
#[test]fn limits_depth_and_preserves_numeric_strings(){
assert_eq!(collect(&serde_json::json!({"render_framerate":"59.9","cookie":12})),vec![("stats.render_framerate".into(),59.9)]);
assert!(unpack(&"A".repeat(LIMIT+1)).is_none());
}
}