signalapp/Signal-Calling-Service
signalapp/Signal-Calling-Service
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup metrics

Browse Source
This commit is contained in:
Richard Russo 2025-10-14 13:07:44 -07:00 committed by GitHub
parent 255605c57d
commit 12ec741192
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 2 additions and 237 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
backend/src/metrics_server.rs
View File

@ -208,12 +208,6 @@ impl DatadogPipeline<'_> {
};
for (value, frequency) in histogram_report.histogram.iter() {
self.timer_at_rate_with_tags(
name,
*value as f64 * factor,
1f64 / (*frequency as f64),
tags,
);
self.distribution_at_rate(
name,
*value as f64 * factor,

9
backend/src/packet_server.rs
View File

@ -201,10 +201,6 @@ fn handle_packet_connected(
sender_address
);
sampling_histogram!("calling.udp_server.incoming_packet.size_bytes", || {
incoming_packet.len()
});
let result = sfu.handle_packet_connected(connection, sender_address, incoming_packet);
match result {
@ -267,11 +263,6 @@ fn handle_packet_unconnected(
sender_address
);
sampling_histogram!(
"calling.udp_server.incoming_packet.unconnected.size_bytes",
|| { incoming_packet.len() }
);
match sfu.handle_packet_unconnected(sender_address, incoming_packet) {
Err(err) => {
// Check for certain errors that can arise in normal conditions

2
backend/src/rtp.rs
View File

@ -254,7 +254,7 @@ impl Endpoint {
header.ssrc,
delta
);
sampling_histogram!("calling.srtp.seqnum_drop.old", || delta.try_into().unwrap());
event!("calling.srtp.seqnum_drop.old");
return None;
}
SequenceNumberReuse::NotUsedBefore => {

6
backend/src/sfu.rs
View File

@ -404,7 +404,6 @@ impl Sfu {
let mut calls_persisting_approved_users = ValueMap::with_capacity(CALL_TAG_VALUES.len());
let mut call_size = HistogramMap::with_capacity(CALL_TAG_VALUES.len());
let mut call_size_squared = HistogramMap::with_capacity(CALL_TAG_VALUES.len());
let mut call_age_minutes = HistogramMap::with_capacity(CALL_TAG_VALUES.len());
let mut call_size_above_one = HistogramMap::with_capacity(CALL_TAG_VALUES.len());
let mut call_size_squared_above_one = HistogramMap::with_capacity(CALL_TAG_VALUES.len());
@ -428,10 +427,6 @@ impl Sfu {
.or_default()
.add_assign(clients as f32);
call_size.entry(tags).or_default().push(clients);
call_size_squared
.entry(tags)
.or_default()
.push(clients_squared);
call_age_minutes
.entry(tags)
.or_default()
@ -464,7 +459,6 @@ impl Sfu {
}
}
histograms.insert("calling.sfu.call_size", call_size);
histograms.insert("calling.sfu.call_size.squared", call_size_squared);
histograms.insert("calling.sfu.call_age_minutes", call_age_minutes);
histograms.insert("calling.sfu.call_size.above_one", call_size_above_one);
histograms.insert(

60
frontend/src/api.rs
View File

@ -128,73 +128,14 @@ async fn metrics(
// Get the method, path, user_agent, and frontend here to avoid cloning the whole
// request before next.run() consumes it.
let method = req.method().clone();
let method_str = req.method().as_str().to_lowercase();
let path = get_request_path(&req).to_owned();
let user_agent = get_user_agent(&req)?.to_string();
let call_type = guess_call_type(&req);
let tag = if path == "/v1/call-link" || path.starts_with("/v1/call-link/") {
"call_links.v1"
} else if path.starts_with("/v2/") {
"v2"
} else {
"unknown"
};
let response = next.run(req).await;
let latency = start.elapsed();
let mut api_metrics = frontend.api_metrics.lock();
let _ = api_metrics
.counts
.entry(format!("calling.frontend.api.{}.{}", tag, method_str))
.or_default()
.entry(None)
.and_modify(|value| *value = value.saturating_add(1))
.or_insert(1);
let _ = api_metrics
.counts
.entry(format!(
"calling.frontend.api.{}.{}.{}",
tag,
method_str,
response.status().as_str()
))
.or_default()
.entry(None)
.and_modify(|value| *value = value.saturating_add(1))
.or_insert(1);
if method_str == "put" {
// We only collect user_agent metrics for PUT (i.e. join).
let _ = api_metrics
.counts
.entry(format!(
"calling.frontend.api.{}.{}.user_agent.{}",
tag,
method_str,
user_agent_event_string(&user_agent)
))
.or_default()
.entry(None)
.and_modify(|value| *value = value.saturating_add(1))
.or_insert(1);
}
api_metrics
.latencies
.entry(format!(
"calling.frontend.api.{}.{}.latency",
tag, method_str
))
.or_default()
.entry(None)
.or_default()
.push(latency.as_micros() as u64);
let mut tags = vec![
format!("http_path:{path}"),
KnownTags::<Method>::tag_from(&method),
@ -206,6 +147,7 @@ async fn metrics(
}
let tags = Some(tags);
let mut api_metrics = frontend.api_metrics.lock();
api_metrics
.latencies
.entry("calling.frontend.api.latency".to_owned())

6
frontend/src/metrics_server.rs
View File

@ -184,12 +184,6 @@ impl DatadogPipeline<'_> {
};
for (value, frequency) in histogram_report.histogram.iter() {
self.timer_at_rate_with_tags(
name,
*value as f64 * factor,
1f64 / (*frequency as f64),
tags.as_ref(),
);
self.distribution_at_rate(
name,
*value as f64 * factor,

150
metrics/src/datadog_statsd.rs
View File

@ -231,40 +231,6 @@ impl<E: EventSink> Client<E> {
self.send(data);
}
/// Send a timer value.
pub fn timer(&mut self, metric: &str, milliseconds: f64) {
self.timer_with_tags::<&str>(metric, milliseconds, None);
}
/// Send a timer value.
pub fn timer_with_tags<T: AsRef<str>>(
&mut self,
metric: &str,
milliseconds: f64,
tags: TagsRef<T>,
) {
let data = self.prepare_with_tags(format!("{}:{}|ms", metric, milliseconds), tags);
self.send(data);
}
/// Send a timer value at a specified sample rate in 0..1 range.
pub fn timer_at_rate(&mut self, metric: &str, milliseconds: f64, rate: f64) {
self.timer_at_rate_with_tags::<&str>(metric, milliseconds, rate, None);
}
/// Send a timer value at a specified sample rate in 0..1 range.
pub fn timer_at_rate_with_tags<T: AsRef<str>>(
&mut self,
metric: &str,
milliseconds: f64,
rate: f64,
tags: TagsRef<T>,
) {
let data =
self.prepare_with_tags(format!("{}:{}|ms|@{}", metric, milliseconds, rate), tags);
self.send(data);
}
fn prepare<T: AsRef<str>>(&self, data: T) -> String {
if self.prefix.is_empty() {
data.as_ref().to_string()
@ -314,34 +280,6 @@ impl<E: EventSink> Client<E> {
}
}
/// Send a histogram value.
pub fn histogram(&mut self, metric: &str, value: f64) {
self.histogram_with_tags::<&str>(metric, value, None);
}
/// Send a histogram value.
pub fn histogram_with_tags<T: AsRef<str>>(
&mut self,
metric: &str,
value: f64,
tags: TagsRef<T>,
) {
let data = self.prepare_with_tags(format!("{}:{}|h", metric, value), tags);
self.send(data);
}
/// Send a histogram value at a specified sample rate in 0..1 range.
pub fn histogram_at_rate<T: AsRef<str>>(
&mut self,
metric: &str,
value: f64,
rate: f64,
tags: TagsRef<T>,
) {
let data = self.prepare_with_tags(format!("{}:{}|h|@{}", metric, value, rate), tags);
self.send(data);
}
/// Send a distribution value.
pub fn distribution(&mut self, metric: &str, value: f64) {
self.distribution_with_tags::<&str>(metric, value, None);
@ -557,82 +495,6 @@ mod test {
server.expect_no_more_packets();
}
#[test]
fn sending_timer() {
let mut server = MockServer::new();
let mut client = Client::new(server.new_port(), "myapp", None);
client.timer("metric", 21.39);
assert_eq!("myapp.metric:21.39|ms", server.read_packet());
server.expect_no_more_packets();
}
#[test]
fn sending_timer_at_rate() {
let mut server = MockServer::new();
let mut client = Client::new(server.new_port(), "myapp", None);
client.timer_at_rate("metric", 21.39, 0.123);
assert_eq!("myapp.metric:21.39|ms|@0.123", server.read_packet());
server.expect_no_more_packets();
}
#[test]
fn sending_histogram() {
let mut server = MockServer::new();
let mut client = Client::new(server.new_port(), "myapp", None);
// without tags
client.histogram("metric", 9.1);
assert_eq!("myapp.metric:9.1|h", server.read_packet());
server.expect_no_more_packets();
// with tags
client.histogram_at_rate("metric", 9.1, 0.2, Some(&vec!["tag1", "tag2:test"]));
assert_eq!(
"myapp.metric:9.1|h|@0.2|#tag1,tag2:test",
server.read_packet()
);
server.expect_no_more_packets();
}
#[test]
fn sending_histogram_with_constant_tags() {
let mut server = MockServer::new();
let mut client = Client::new(
server.new_port(),
"myapp",
Some(vec!["tag1common", "tag2common:test"]),
);
// without tags
client.histogram("metric", 9.1);
assert_eq!(
"myapp.metric:9.1|h|#tag1common,tag2common:test",
server.read_packet()
);
server.expect_no_more_packets();
// with tags
let tags = Some(vec!["tag1", "tag2:test"]);
client.histogram_with_tags("metric", 9.1, tags.as_ref());
assert_eq!(
"myapp.metric:9.1|h|#tag1common,tag2common:test,tag1,tag2:test",
server.read_packet()
);
server.expect_no_more_packets();
// repeat
client.histogram_at_rate("metric", 19.12, 0.2, tags.as_ref());
assert_eq!(
"myapp.metric:19.12|h|@0.2|#tag1common,tag2common:test,tag1,tag2:test",
server.read_packet()
);
server.expect_no_more_packets();
}
#[test]
fn sending_distribution() {
let mut server = MockServer::new();
@ -701,18 +563,6 @@ mod test {
server.expect_no_more_packets();
}
#[test]
fn pipeline_sending_histogram() {
let mut server = MockServer::new();
let mut client = Client::new(server.new_port(), "myapp", None);
let mut pipeline = client.pipeline();
pipeline.histogram("metric", 9.1);
drop(pipeline);
assert_eq!("myapp.metric:9.1|h", server.read_packet());
server.expect_no_more_packets();
}
#[test]
fn pipeline_sending_multiple_data() {
let mut server = MockServer::new();