Skip to content

Commit

Permalink
Add usergroup label to prometheus metrics
Browse files Browse the repository at this point in the history
  • Loading branch information
Adel Lahlou committed Mar 20, 2024
1 parent ed86f80 commit 9e59fea
Show file tree
Hide file tree
Showing 5 changed files with 110 additions and 69 deletions.
148 changes: 82 additions & 66 deletions src/apps/relay/prom_server.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -50,14 +50,22 @@ void start_prometheus_server(void) {
}
prom_collector_registry_default_init();

const char *label[] = {"realm", NULL};
// Signal change to add group label to metrics
const char *label[] = {"realm", NULL, NULL};
size_t nlabels = 1;

if (turn_params.prometheus_username_labels) {
label[1] = "user";
nlabels++;
}

// Signal change to add group label to metrics
if (turn_params.prometheus_usergroup_labels) {
label[nlabels] = "group";
nlabels++;
}
const char *traffic_label[] = {"group"};

// Create STUN counters
stun_binding_request = prom_collector_registry_must_register_metric(
prom_counter_new("stun_binding_request", "Incoming STUN Binding requests", 0, NULL));
Expand Down Expand Up @@ -88,23 +96,23 @@ void start_prometheus_server(void) {

// Create total finished traffic counter metrics
turn_total_traffic_rcvp = prom_collector_registry_must_register_metric(
prom_counter_new("turn_total_traffic_rcvp", "Represents total finished sessions received packets", 0, NULL));
prom_counter_new("turn_total_traffic_rcvp", "Represents total finished sessions received packets", 1, traffic_label));
turn_total_traffic_rcvb = prom_collector_registry_must_register_metric(
prom_counter_new("turn_total_traffic_rcvb", "Represents total finished sessions received bytes", 0, NULL));
prom_counter_new("turn_total_traffic_rcvb", "Represents total finished sessions received bytes", 1, traffic_label));
turn_total_traffic_sentp = prom_collector_registry_must_register_metric(
prom_counter_new("turn_total_traffic_sentp", "Represents total finished sessions sent packets", 0, NULL));
prom_counter_new("turn_total_traffic_sentp", "Represents total finished sessions sent packets", 1, traffic_label));
turn_total_traffic_sentb = prom_collector_registry_must_register_metric(
prom_counter_new("turn_total_traffic_sentb", "Represents total finished sessions sent bytes", 0, NULL));
prom_counter_new("turn_total_traffic_sentb", "Represents total finished sessions sent bytes", 1, traffic_label));

// Create total finished sessions traffic for peers counter metrics
turn_total_traffic_peer_rcvp = prom_collector_registry_must_register_metric(prom_counter_new(
"turn_total_traffic_peer_rcvp", "Represents total finished sessions peer received packets", 0, NULL));
"turn_total_traffic_peer_rcvp", "Represents total finished sessions peer received packets", 1, traffic_label));
turn_total_traffic_peer_rcvb = prom_collector_registry_must_register_metric(prom_counter_new(
"turn_total_traffic_peer_rcvb", "Represents total finished sessions peer received bytes", 0, NULL));
"turn_total_traffic_peer_rcvb", "Represents total finished sessions peer received bytes", 1, traffic_label));
turn_total_traffic_peer_sentp = prom_collector_registry_must_register_metric(prom_counter_new(
"turn_total_traffic_peer_sentp", "Represents total finished sessions peer sent packets", 0, NULL));
"turn_total_traffic_peer_sentp", "Represents total finished sessions peer sent packets", 1, traffic_label));
turn_total_traffic_peer_sentb = prom_collector_registry_must_register_metric(
prom_counter_new("turn_total_traffic_peer_sentb", "Represents total finished sessions peer sent bytes", 0, NULL));
prom_counter_new("turn_total_traffic_peer_sentb", "Represents total finished sessions peer sent bytes", 1, traffic_label));

// Create total completed session counter metric
const char *total_sessions_labels[] = {"duration", "sent_rate"};
Expand All @@ -120,56 +128,58 @@ void start_prometheus_server(void) {
// Create round trip time pseudo-histogram metrics
// values must be kept in sync with observation function below

const char *rtt_labels[] = {"group"};
const size_t nRtt_Labels = 1;
turn_rtt_client[0] = prom_collector_registry_must_register_metric(prom_counter_new(
"turn_rtt_client_le_25ms", "Represents measured round trip time of client with channel", 0, NULL));
"turn_rtt_client_le_25ms", "Represents measured round trip time of client with channel", nRtt_labels, rtt_labels));
turn_rtt_client[1] = prom_collector_registry_must_register_metric(prom_counter_new(
"turn_rtt_client_le_50ms", "Represents measured round trip time of client with channel", 0, NULL));
"turn_rtt_client_le_50ms", "Represents measured round trip time of client with channel",nRtt_labels, rtt_labels));
turn_rtt_client[2] = prom_collector_registry_must_register_metric(prom_counter_new(
"turn_rtt_client_le_100ms", "Represents measured round trip time of client with channel", 0, NULL));
"turn_rtt_client_le_100ms", "Represents measured round trip time of client with channel", nRtt_labels, rtt_labels));
turn_rtt_client[3] = prom_collector_registry_must_register_metric(prom_counter_new(
"turn_rtt_client_le_200ms", "Represents measured round trip time of client with channel", 0, NULL));
"turn_rtt_client_le_200ms", "Represents measured round trip time of client with channel", nRtt_labels, rtt_labels));
turn_rtt_client[4] = prom_collector_registry_must_register_metric(prom_counter_new(
"turn_rtt_client_le_400ms", "Represents measured round trip time of client with channel", 0, NULL));
"turn_rtt_client_le_400ms", "Represents measured round trip time of client with channel", nRtt_labels, rtt_labels));
turn_rtt_client[5] = prom_collector_registry_must_register_metric(prom_counter_new(
"turn_rtt_client_le_800ms", "Represents measured round trip time of client with channel", 0, NULL));
"turn_rtt_client_le_800ms", "Represents measured round trip time of client with channel", nRtt_labels, rtt_labels));
turn_rtt_client[6] = prom_collector_registry_must_register_metric(prom_counter_new(
"turn_rtt_client_le_1500ms", "Represents measured round trip time of client with channel", 0, NULL));
"turn_rtt_client_le_1500ms", "Represents measured round trip time of client with channel", nRtt_labels, rtt_labels));
turn_rtt_client[7] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_client_more", "Represents measured round trip time of client with channel", 0, NULL));
prom_counter_new("turn_rtt_client_more", "Represents measured round trip time of client with channel", nRtt_labels, rtt_labels));

turn_rtt_peer[0] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_peer_le_25ms", "Represents measured round trip time of peer with channel", 0, NULL));
prom_counter_new("turn_rtt_peer_le_25ms", "Represents measured round trip time of peer with channel", nRtt_labels, rtt_labels));
turn_rtt_peer[1] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_peer_le_50ms", "Represents measured round trip time of peer with channel", 0, NULL));
prom_counter_new("turn_rtt_peer_le_50ms", "Represents measured round trip time of peer with channel", nRtt_labels, rtt_labels));
turn_rtt_peer[2] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_peer_le_100ms", "Represents measured round trip time of peer with channel", 0, NULL));
prom_counter_new("turn_rtt_peer_le_100ms", "Represents measured round trip time of peer with channel", nRtt_labels, rtt_labels));
turn_rtt_peer[3] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_peer_le_200ms", "Represents measured round trip time of peer with channel", 0, NULL));
prom_counter_new("turn_rtt_peer_le_200ms", "Represents measured round trip time of peer with channel", nRtt_labels, rtt_labels));
turn_rtt_peer[4] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_peer_le_400ms", "Represents measured round trip time of peer with channel", 0, NULL));
prom_counter_new("turn_rtt_peer_le_400ms", "Represents measured round trip time of peer with channel", nRtt_labels, rtt_labels));
turn_rtt_peer[5] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_peer_le_800ms", "Represents measured round trip time of peer with channel", 0, NULL));
prom_counter_new("turn_rtt_peer_le_800ms", "Represents measured round trip time of peer with channel", nRtt_labels, rtt_labels));
turn_rtt_peer[6] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_peer_le_1500ms", "Represents measured round trip time of peer with channel", 0, NULL));
prom_counter_new("turn_rtt_peer_le_1500ms", "Represents measured round trip time of peer with channel", nRtt_labels, rtt_labels));
turn_rtt_peer[7] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_peer_more", "Represents measured round trip time of peer with channel", 0, NULL));
prom_counter_new("turn_rtt_peer_more", "Represents measured round trip time of peer with channel", nRtt_labels, rtt_labels));

turn_rtt_combined[0] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_combined_le_25ms", "Represents combined round trip time of channel", 0, NULL));
prom_counter_new("turn_rtt_combined_le_25ms", "Represents combined round trip time of channel", nRtt_labels, rtt_labels));
turn_rtt_combined[1] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_combined_le_50ms", "Represents combined round trip time of channel", 0, NULL));
prom_counter_new("turn_rtt_combined_le_50ms", "Represents combined round trip time of channel", nRtt_labels, rtt_labels));
turn_rtt_combined[2] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_combined_le_100ms", "Represents combined round trip time of channel", 0, NULL));
prom_counter_new("turn_rtt_combined_le_100ms", "Represents combined round trip time of channel", nRtt_labels, rtt_labels));
turn_rtt_combined[3] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_combined_le_200ms", "Represents combined round trip time of channel", 0, NULL));
prom_counter_new("turn_rtt_combined_le_200ms", "Represents combined round trip time of channel", nRtt_labels, rtt_labels));
turn_rtt_combined[4] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_combined_le_400ms", "Represents combined round trip time of channel", 0, NULL));
prom_counter_new("turn_rtt_combined_le_400ms", "Represents combined round trip time of channel", nRtt_labels, rtt_labels));
turn_rtt_combined[5] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_combined_le_800ms", "Represents combined round trip time of channel", 0, NULL));
prom_counter_new("turn_rtt_combined_le_800ms", "Represents combined round trip time of channel", nRtt_labels, rtt_labels));
turn_rtt_combined[6] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_combined_le_1500ms", "Represents combined round trip time of channel", 0, NULL));
prom_counter_new("turn_rtt_combined_le_1500ms", "Represents combined round trip time of channel", nRtt_labels, rtt_labels));
turn_rtt_combined[7] = prom_collector_registry_must_register_metric(
prom_counter_new("turn_rtt_combined_more", "Represents combined round trip time of channel", 0, NULL));
prom_counter_new("turn_rtt_combined_more", "Represents combined round trip time of channel", nRtt_labels, rtt_labels));

turn_with_no_ping_rcvp = prom_collector_registry_must_register_metric(prom_counter_new(
"turn_with_no_ping_rcvp", "Count of packets received for TURN where no ICE ping has been observed", 0, NULL));
Expand Down Expand Up @@ -211,34 +221,37 @@ void start_prometheus_server(void) {

// Signal change to add metrics
void prom_set_finished_traffic(const char *realm, const char *user, unsigned long rsvp, unsigned long rsvb,
unsigned long sentp, unsigned long sentb, unsigned long without_pingp, bool peer) {
unsigned long sentp, unsigned long sentb, unsigned long without_pingp, bool peer, char* group)) {
if (turn_params.prometheus == 1) {

const char *label[] = {realm, NULL};
// Signal change to add group label to metrics
const char *user_label[] = {realm, group, group};
if (turn_params.prometheus_username_labels) {
label[1] = user;
}
const char *traffic_label[] = {group};
// end signal change

if (peer) {
prom_counter_add(turn_traffic_peer_rcvp, rsvp, label);
prom_counter_add(turn_traffic_peer_rcvb, rsvb, label);
prom_counter_add(turn_traffic_peer_sentp, sentp, label);
prom_counter_add(turn_traffic_peer_sentb, sentb, label);

prom_counter_add(turn_total_traffic_peer_rcvp, rsvp, NULL);
prom_counter_add(turn_total_traffic_peer_rcvb, rsvb, NULL);
prom_counter_add(turn_total_traffic_peer_sentp, sentp, NULL);
prom_counter_add(turn_total_traffic_peer_sentb, sentb, NULL);
prom_counter_add(turn_traffic_peer_rcvp, rsvp, user_label);
prom_counter_add(turn_traffic_peer_rcvb, rsvb, user_label);
prom_counter_add(turn_traffic_peer_sentp, sentp, user_label);
prom_counter_add(turn_traffic_peer_sentb, sentb, user_label);

prom_counter_add(turn_total_traffic_peer_rcvp, rsvp, traffic_label);
prom_counter_add(turn_total_traffic_peer_rcvb, rsvb, traffic_label);
prom_counter_add(turn_total_traffic_peer_sentp, sentp, traffic_label);
prom_counter_add(turn_total_traffic_peer_sentb, sentb, traffic_label);
} else {
prom_counter_add(turn_traffic_rcvp, rsvp, label);
prom_counter_add(turn_traffic_rcvb, rsvb, label);
prom_counter_add(turn_traffic_sentp, sentp, label);
prom_counter_add(turn_traffic_sentb, sentb, label);

prom_counter_add(turn_total_traffic_rcvp, rsvp, NULL);
prom_counter_add(turn_total_traffic_rcvb, rsvb, NULL);
prom_counter_add(turn_total_traffic_sentp, sentp, NULL);
prom_counter_add(turn_total_traffic_sentb, sentb, NULL);
prom_counter_add(turn_traffic_rcvp, rsvp, user_label);
prom_counter_add(turn_traffic_rcvb, rsvb, user_label);
prom_counter_add(turn_traffic_sentp, sentp, user_label);
prom_counter_add(turn_traffic_sentb, sentb, user_label);

prom_counter_add(turn_total_traffic_rcvp, rsvp, traffic_label);
prom_counter_add(turn_total_traffic_rcvb, rsvb, traffic_label);
prom_counter_add(turn_total_traffic_sentp, sentp, traffic_label);
prom_counter_add(turn_total_traffic_sentb, sentb, traffic_label);
}
// Signal change to add metrics
if (without_pingp) {
Expand Down Expand Up @@ -297,47 +310,50 @@ int is_ipv6_enabled(void) {
return ret;
}

// Signal change to add metrics
void prom_observe_rtt(prom_counter_t *counter[8], int microseconds) {
// Signal change to add rtt metrics
void prom_observe_rtt(prom_counter_t *counter[8], int microseconds, label *char[]) {
if (microseconds <= 25000) {
prom_counter_add(counter[0], 1, NULL);
prom_counter_add(counter[0], 1, label);
}
if (microseconds <= 50000) {
prom_counter_add(counter[1], 1, NULL);
prom_counter_add(counter[1], 1, label);
}
if (microseconds <= 100000) {
prom_counter_add(counter[2], 1, NULL);
prom_counter_add(counter[2], 1, label);
}
if (microseconds <= 200000) {
prom_counter_add(counter[3], 1, NULL);
prom_counter_add(counter[3], 1, label);
}
if (microseconds <= 400000) {
prom_counter_add(counter[4], 1, NULL);
prom_counter_add(counter[4], 1, label);
}
if (microseconds <= 800000) {
prom_counter_add(counter[5], 1, NULL);
prom_counter_add(counter[5], 1, label);
}
if (microseconds <= 1500000) {
prom_counter_add(counter[6], 1, NULL);
prom_counter_add(counter[6], 1, label);
}
prom_counter_add(counter[7], 1, NULL);
prom_counter_add(counter[7], 1, label);
}

void prom_observe_rtt_client(int microseconds) {
if (turn_params.prometheus == 1) {
prom_observe_rtt(turn_rtt_client, microseconds);
char *label[] = {};
prom_observe_rtt(turn_rtt_client, microseconds, label);
}
}

void prom_observe_rtt_peer(int microseconds) {
if (turn_params.prometheus == 1) {
prom_observe_rtt(turn_rtt_peer, microseconds);
char *label[] = {};
prom_observe_rtt(turn_rtt_peer, microseconds, label);
}
}

void prom_observe_rtt_combined(int microseconds) {
if (turn_params.prometheus == 1) {
prom_observe_rtt(turn_rtt_combined, microseconds);
char *label[] = {};
prom_observe_rtt(turn_rtt_combined, microseconds, label);
}
}

Expand Down
6 changes: 3 additions & 3 deletions src/apps/relay/prom_server.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -82,9 +82,9 @@ void prom_inc_stun_binding_error(void);

// Signal change to add metrics
void prom_observe_rtt(prom_counter_t *counter[8], int microseconds);
void prom_observe_rtt_client(int microseconds);
void prom_observe_rtt_peer(int microseconds);
void prom_observe_rtt_combined(int microseconds);
void prom_observe_rtt_client(int microseconds, char *username);
void prom_observe_rtt_peer(int microseconds, char *username);
void prom_observe_rtt_combined(int microseconds, char *username);

#else

Expand Down
2 changes: 2 additions & 0 deletions src/client/ns_turn_msg_defs.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -46,6 +46,8 @@
#define STUN_MAX_SERVER_NAME_SIZE (1025)
#define STUN_MAX_PWD_SIZE (256)
#define AUTH_SECRET_SIZE STUN_MAX_PWD_SIZE
// Signal change to add group metric label
#define MAX_USERGROUP_SIZE (16)

#define STUN_MAGIC_COOKIE (0x2112A442)

Expand Down
18 changes: 18 additions & 0 deletions src/server/ns_turn_server.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -177,6 +177,8 @@ static int inc_quota(ts_ur_super_session *ss, uint8_t *username) {
} else {

STRCPY(ss->username, username);
// Signal change to add group label to metrics
set_usergroup(ss);

ss->quota_used = 1;
}
Expand Down Expand Up @@ -351,6 +353,13 @@ static int good_peer_addr(turn_turnserver *server, const char *realm, ioa_addr *

allocation *get_allocation_ss(ts_ur_super_session *ss) { return &(ss->alloc); }

void set_usergroup(ts_ur_super_session *ss) {
char * group = strrchr(username, '#');
if group != NULL {
strlcpy(usergroup, group, usergroup_size);
}
}

static inline relay_endpoint_session *get_relay_session_ss(ts_ur_super_session *ss, int family) {
return get_relay_session(&(ss->alloc), family);
}
Expand Down Expand Up @@ -431,6 +440,8 @@ static int turn_session_info_foreachcb(ur_map_key_type key, ur_map_value_type va
return 0;
}

// Si

int turn_session_info_copy_from(struct turn_session_info *tsi, ts_ur_super_session *ss) {
int ret = -1;

Expand Down Expand Up @@ -1442,6 +1453,8 @@ static void copy_auth_parameters(ts_ur_super_session *orig_ss, ts_ur_super_sessi
ss->nonce_expiration_time = orig_ss->nonce_expiration_time;
memcpy(&(ss->realm_options), &(orig_ss->realm_options), sizeof(ss->realm_options));
memcpy(ss->username, orig_ss->username, sizeof(ss->username));
// Signal change to add group label to metrics
memcpy(ss->usergroup, orig_ss->usergroup, sizeof(ss->usergroup));
ss->hmackey_set = orig_ss->hmackey_set;
memcpy(ss->hmackey, orig_ss->hmackey, sizeof(ss->hmackey));
ss->oauth = orig_ss->oauth;
Expand Down Expand Up @@ -2931,6 +2944,7 @@ static int inspect_binds(turn_turnserver *server, ioa_net_data *in_buffer, turn_

#if !defined(TURN_NO_PROMETHEUS)
if (is_channel) {
char *[]label = {};
if (from_client) {
prom_observe_rtt_client(diffus);
} else {
Expand Down Expand Up @@ -3451,6 +3465,8 @@ static int check_stun_auth(turn_turnserver *server, ts_ur_super_session *ss, stu
if (ss->oauth) {
ss->hmackey_set = 0;
STRCPY(ss->username, usname);
// Signal change to add group label to metrics
set_usergroup(ss);
} else {
if (method == STUN_METHOD_ALLOCATE) {
*err_code = 437;
Expand All @@ -3463,6 +3479,8 @@ static int check_stun_auth(turn_turnserver *server, ts_ur_super_session *ss, stu
}
} else {
STRCPY(ss->username, usname);
// Signal change to add group label to metrics
set_usergroup(ss);
}

{
Expand Down
Loading

0 comments on commit 9e59fea

Please sign in to comment.