d9108a4b54
I would like to get feedback on this and see if people is confortable with these clang rules. Right now is using the "llvm" style increasing the line length from 80 to 120 given that coturn is using long lines often. Co-authored-by: Pavel Punsky <eakraly@users.noreply.github.com>
168 lines
7.2 KiB
C
168 lines
7.2 KiB
C
#include "prom_server.h"
|
|
#include "mainrelay.h"
|
|
#include "ns_turn_utils.h"
|
|
|
|
#if !defined(TURN_NO_PROMETHEUS)
|
|
|
|
prom_counter_t *turn_traffic_rcvp;
|
|
prom_counter_t *turn_traffic_rcvb;
|
|
prom_counter_t *turn_traffic_sentp;
|
|
prom_counter_t *turn_traffic_sentb;
|
|
|
|
prom_counter_t *turn_traffic_peer_rcvp;
|
|
prom_counter_t *turn_traffic_peer_rcvb;
|
|
prom_counter_t *turn_traffic_peer_sentp;
|
|
prom_counter_t *turn_traffic_peer_sentb;
|
|
|
|
prom_counter_t *turn_total_traffic_rcvp;
|
|
prom_counter_t *turn_total_traffic_rcvb;
|
|
prom_counter_t *turn_total_traffic_sentp;
|
|
prom_counter_t *turn_total_traffic_sentb;
|
|
|
|
prom_counter_t *turn_total_traffic_peer_rcvp;
|
|
prom_counter_t *turn_total_traffic_peer_rcvb;
|
|
prom_counter_t *turn_total_traffic_peer_sentp;
|
|
prom_counter_t *turn_total_traffic_peer_sentb;
|
|
|
|
prom_gauge_t *turn_total_allocations;
|
|
|
|
void start_prometheus_server(void) {
|
|
if (turn_params.prometheus == 0) {
|
|
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "prometheus collector disabled, not started\n");
|
|
return;
|
|
}
|
|
prom_collector_registry_default_init();
|
|
|
|
const char *label[] = {"realm", NULL};
|
|
size_t nlabels = 1;
|
|
|
|
if (turn_params.prometheus_username_labels) {
|
|
label[1] = "user";
|
|
nlabels++;
|
|
}
|
|
|
|
// Create traffic counter metrics
|
|
turn_traffic_rcvp = prom_collector_registry_must_register_metric(
|
|
prom_counter_new("turn_traffic_rcvp", "Represents finished sessions received packets", nlabels, label));
|
|
turn_traffic_rcvb = prom_collector_registry_must_register_metric(
|
|
prom_counter_new("turn_traffic_rcvb", "Represents finished sessions received bytes", nlabels, label));
|
|
turn_traffic_sentp = prom_collector_registry_must_register_metric(
|
|
prom_counter_new("turn_traffic_sentp", "Represents finished sessions sent packets", nlabels, label));
|
|
turn_traffic_sentb = prom_collector_registry_must_register_metric(
|
|
prom_counter_new("turn_traffic_sentb", "Represents finished sessions sent bytes", nlabels, label));
|
|
|
|
// Create finished sessions traffic for peers counter metrics
|
|
turn_traffic_peer_rcvp = prom_collector_registry_must_register_metric(
|
|
prom_counter_new("turn_traffic_peer_rcvp", "Represents finished sessions peer received packets", nlabels, label));
|
|
turn_traffic_peer_rcvb = prom_collector_registry_must_register_metric(
|
|
prom_counter_new("turn_traffic_peer_rcvb", "Represents finished sessions peer received bytes", nlabels, label));
|
|
turn_traffic_peer_sentp = prom_collector_registry_must_register_metric(
|
|
prom_counter_new("turn_traffic_peer_sentp", "Represents finished sessions peer sent packets", nlabels, label));
|
|
turn_traffic_peer_sentb = prom_collector_registry_must_register_metric(
|
|
prom_counter_new("turn_traffic_peer_sentb", "Represents finished sessions peer sent bytes", nlabels, label));
|
|
|
|
// 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));
|
|
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));
|
|
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));
|
|
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));
|
|
|
|
// 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_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_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_sentb = prom_collector_registry_must_register_metric(
|
|
prom_counter_new("turn_total_traffic_peer_sentb", "Represents total finished sessions peer sent bytes", 0, NULL));
|
|
|
|
// Create total allocations number gauge metric
|
|
turn_total_allocations = prom_collector_registry_must_register_metric(
|
|
prom_gauge_new("turn_total_allocations", "Represents current allocations number", 1, (const char *[]){"type"}));
|
|
|
|
promhttp_set_active_collector_registry(NULL);
|
|
|
|
unsigned int flags = MHD_USE_DUAL_STACK
|
|
#if MHD_USE_ERROR_LOG
|
|
| MHD_USE_ERROR_LOG
|
|
#endif
|
|
;
|
|
if (MHD_is_feature_supported(MHD_FEATURE_EPOLL)) {
|
|
#if MHD_USE_EPOLL_INTERNAL_THREAD
|
|
flags |= MHD_USE_EPOLL_INTERNAL_THREAD;
|
|
#else
|
|
flags |= MHD_USE_SELECT_INTERNALLY; // ubuntu 16.04
|
|
#endif
|
|
} else {
|
|
flags |= MHD_USE_SELECT_INTERNALLY;
|
|
}
|
|
struct MHD_Daemon *daemon = promhttp_start_daemon(flags, turn_params.prometheus_port, NULL, NULL);
|
|
if (daemon == NULL) {
|
|
TURN_LOG_FUNC(TURN_LOG_LEVEL_ERROR, "could not start prometheus collector\n");
|
|
return;
|
|
}
|
|
|
|
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "prometheus collector started successfully\n");
|
|
|
|
return;
|
|
}
|
|
|
|
void prom_set_finished_traffic(const char *realm, const char *user, unsigned long rsvp, unsigned long rsvb,
|
|
unsigned long sentp, unsigned long sentb, bool peer) {
|
|
if (turn_params.prometheus == 1) {
|
|
|
|
const char *label[] = {realm, NULL};
|
|
if (turn_params.prometheus_username_labels) {
|
|
label[1] = user;
|
|
}
|
|
|
|
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);
|
|
} 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);
|
|
}
|
|
}
|
|
}
|
|
|
|
void prom_inc_allocation(SOCKET_TYPE type) {
|
|
if (turn_params.prometheus == 1) {
|
|
prom_gauge_inc(turn_total_allocations, (const char *[]){socket_type_name(type)});
|
|
}
|
|
}
|
|
|
|
void prom_dec_allocation(SOCKET_TYPE type) {
|
|
if (turn_params.prometheus == 1) {
|
|
prom_gauge_dec(turn_total_allocations, (const char *[]){socket_type_name(type)});
|
|
}
|
|
}
|
|
|
|
#else
|
|
|
|
void start_prometheus_server(void) {
|
|
TURN_LOG_FUNC(TURN_LOG_LEVEL_INFO, "turnserver compiled without prometheus support\n");
|
|
return;
|
|
}
|
|
|
|
#endif /* TURN_NO_PROMETHEUS */
|