Refactoring Prometheus

* Fix c++ support
* Simplify: Remove session id/allocation

ChangeLog

@@ -40,6 +40,11 @@ Version 4.5.2 'dan Eider':
 		* Fix: use-after-free vulnerability on write_to_peerchannel function
 	- Fix Issue #601 (by ycaibb)
 		* Fix: use-after-free vulnerability on write_client_connection function
+	- Little refactoring prometheus
+		* Fix c++ support
+		* Simplify (as agreed in Issue #666)
+			* Remove session id/allocation labels
+			* Remove per session metrics. We should later add more counters.
 
 24/06/2020 Oleg Moskalenko <[email protected]> Mihály Mészáros <[email protected]>
 Version 4.5.1.3 'dan Eider':

src/apps/relay/ns_ioalib_engine_impl.c

@@ -3721,16 +3721,6 @@ void turn_report_allocation_set(void *a, turn_time_t lifetime, int refresh)
 					send_message_to_redis(e->rch, "set", key, "%s lifetime=%lu", status, (unsigned long)lifetime);
 					send_message_to_redis(e->rch, "publish", key, "%s lifetime=%lu", status, (unsigned long)lifetime);
 				}
-#endif
-#if !defined(TURN_NO_PROMETHEUS)
-				{
-					// Set status on prometheus metric
-					if(ss->realm_options.name[0]) {
-						prom_set_status(ss->realm_options.name, (const char*)ss->username, (unsigned long long)ss->id, status, (unsigned long)lifetime);
-					} else {
-						prom_set_status(NULL, (const char*)ss->username, (unsigned long long)ss->id, status, (unsigned long)lifetime);
-					}
-				}
 #endif
 			}
 		}
@@ -3778,19 +3768,14 @@ void turn_report_allocation_delete(void *a)
 #if !defined(TURN_NO_PROMETHEUS)
 				{
 					if(ss->realm_options.name[0]){
-						// Set prometheus del metric and update status
-						prom_del_status(ss->realm_options.name, (const char*)ss->username, (unsigned long long)ss->id, (const char *)"deleted");
 
-						// Set prometheus total traffic metrics
-						prom_set_total_traffic(ss->realm_options.name, (const char*)ss->username, (unsigned long long)ss->id, (unsigned long)(ss->t_received_packets), (unsigned long)(ss->t_received_bytes), (unsigned long)(ss->t_sent_packets), (unsigned long)(ss->t_sent_bytes), true);
-						prom_set_total_traffic(ss->realm_options.name, (const char*)ss->username, (unsigned long long)ss->id, (unsigned long)(ss->t_peer_received_packets), (unsigned long)(ss->t_peer_received_bytes), (unsigned long)(ss->t_peer_sent_packets), (unsigned long)(ss->t_peer_sent_bytes), true);
+						// Set prometheus traffic metrics
+						prom_set_finished_traffic(ss->realm_options.name, (const char*)ss->username, (unsigned long)(ss->t_received_packets), (unsigned long)(ss->t_received_bytes), (unsigned long)(ss->t_sent_packets), (unsigned long)(ss->t_sent_bytes), false);
+						prom_set_finished_traffic(ss->realm_options.name, (const char*)ss->username, (unsigned long)(ss->t_peer_received_packets), (unsigned long)(ss->t_peer_received_bytes), (unsigned long)(ss->t_peer_sent_packets), (unsigned long)(ss->t_peer_sent_bytes), true);
 					} else {
-						// Set prometheus del metric and update status
-						prom_del_status(NULL, (const char*)ss->username, (unsigned long long)ss->id,  (const char *)"deleted");
-
-						// Set prometheus total traffic metrics
-						prom_set_total_traffic(NULL, (const char*)ss->username, (unsigned long long)ss->id, (unsigned long)(ss->t_received_packets), (unsigned long)(ss->t_received_bytes), (unsigned long)(ss->t_sent_packets), (unsigned long)(ss->t_sent_bytes), true);
-						prom_set_total_traffic(NULL, (const char*)ss->username, (unsigned long long)ss->id, (unsigned long)(ss->t_peer_received_packets), (unsigned long)(ss->t_peer_received_bytes), (unsigned long)(ss->t_peer_sent_packets), (unsigned long)(ss->t_peer_sent_bytes), true);
+						// Set prometheus traffic metrics
+						prom_set_finished_traffic(NULL, (const char*)ss->username, (unsigned long)(ss->t_received_packets), (unsigned long)(ss->t_received_bytes), (unsigned long)(ss->t_sent_packets), (unsigned long)(ss->t_sent_bytes), false);
+						prom_set_finished_traffic(NULL, (const char*)ss->username, (unsigned long)(ss->t_peer_received_packets), (unsigned long)(ss->t_peer_received_bytes), (unsigned long)(ss->t_peer_sent_packets), (unsigned long)(ss->t_peer_sent_bytes), true);
 					}
 				}
 #endif
@@ -3829,19 +3814,6 @@ void turn_report_session_usage(void *session, int force_invalid)
 					send_message_to_redis(e->rch, "publish", key, "rcvp=%lu, rcvb=%lu, sentp=%lu, sentb=%lu", (unsigned long)(ss->peer_received_packets), (unsigned long)(ss->peer_received_bytes), (unsigned long)(ss->peer_sent_packets), (unsigned long)(ss->peer_sent_bytes));
 				}
 #endif
-#if !defined(TURN_NO_PROMETHEUS)
-				{
-					// Set prometheus traffic metrics
-					if(ss->realm_options.name[0]){
-						prom_set_traffic(ss->realm_options.name, (const char *)ss->username, (unsigned long long)(ss->id), (unsigned long)(ss->received_packets), (unsigned long)(ss->received_bytes), (unsigned long)(ss->sent_packets), (unsigned long)(ss->sent_bytes), false);
-						prom_set_traffic(ss->realm_options.name, (const char *)ss->username, (unsigned long long)(ss->id), (unsigned long)(ss->peer_received_packets), (unsigned long)(ss->peer_received_bytes), (unsigned long)(ss->peer_sent_packets), (unsigned long)(ss->peer_sent_bytes), true);
-					} else {
-						prom_set_traffic(NULL, (const char *)ss->username, (unsigned long long)(ss->id), (unsigned long)(ss->received_packets), (unsigned long)(ss->received_bytes), (unsigned long)(ss->sent_packets), (unsigned long)(ss->sent_bytes), false);
-						prom_set_traffic(NULL, (const char *)ss->username, (unsigned long long)(ss->id), (unsigned long)(ss->peer_received_packets), (unsigned long)(ss->peer_received_bytes), (unsigned long)(ss->peer_sent_packets), (unsigned long)(ss->peer_sent_bytes), true);
-					}
-				}
-#endif
-
 				ss->t_received_packets += ss->received_packets;
 				ss->t_received_bytes += ss->received_bytes;
 				ss->t_sent_packets += ss->sent_packets;

src/apps/relay/prom_server.c

@@ -3,59 +3,59 @@
 #include "mainrelay.h"
 #include "prom_server.h"
 
-prom_gauge_t *turn_status;
 
-prom_gauge_t *turn_traffic_rcvp;
-prom_gauge_t *turn_traffic_rcvb;
-prom_gauge_t *turn_traffic_sentp;
-prom_gauge_t *turn_traffic_sentb;
+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_gauge_t *turn_total_traffic_rcvp;
-prom_gauge_t *turn_total_traffic_rcvb;
-prom_gauge_t *turn_total_traffic_sentp;
-prom_gauge_t *turn_total_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_gauge_t *turn_traffic_peer_rcvp;
-prom_gauge_t *turn_traffic_peer_rcvb;
-prom_gauge_t *turn_traffic_peer_sentp;
-prom_gauge_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_traffic_peer_rcvp;
-prom_gauge_t *turn_total_traffic_peer_rcvb;
-prom_gauge_t *turn_total_traffic_peer_sentp;
-prom_gauge_t *turn_total_traffic_peer_sentb;
 
 int start_prometheus_server(void){
   if (turn_params.prometheus == 0){
-    return 0;
+    return 1;
   }
   prom_collector_registry_default_init();
-  // Create status gauge metric
-  turn_status = prom_collector_registry_must_register_metric(prom_gauge_new("turn_status", "Represents status", 5, (const char *[]) {"realm", "user", "allocation", "status", "lifetime" }));
-
-  // Create traffic gauge metrics
-  turn_traffic_rcvp = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_rcvp", "Represents received packets", 3, (const char *[]) {"realm", "user", "allocation" }));
-  turn_traffic_rcvb = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_rcvb", "Represents received bytes", 3, (const char *[]) {"realm", "user", "allocation" }));
-  turn_traffic_sentp = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_sentp", "Represents sent packets", 3, (const char *[]) {"realm", "user", "allocation" }));
-  turn_traffic_sentb = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_sentb", "Represents sent bytes", 3, (const char *[]) {"realm", "user", "allocation" }));
-
-  // Create traffic for peers gauge metrics
-  turn_traffic_peer_rcvp = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_peer_rcvp", "Represents peer received packets", 3, (const char *[]) {"realm", "user", "allocation" }));
-  turn_traffic_peer_rcvb = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_peer_rcvb", "Represents peer received bytes", 3, (const char *[]) {"realm", "user", "allocation" }));
-  turn_traffic_peer_sentp = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_peer_sentp", "Represents peer sent packets", 3, (const char *[]) {"realm", "user", "allocation" }));
-  turn_traffic_peer_sentb = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_peer_sentb", "Represents peer sent bytes", 3, (const char *[]) {"realm", "user", "allocation" }));
-
-  // Create total traffic gauge metrics
-  turn_total_traffic_rcvp = prom_collector_registry_must_register_metric(prom_counter_new("turn_total_traffic_rcvp", "Represents total received packets", 3, (const char *[]) {"realm", "user", "allocation" }));
-  turn_total_traffic_rcvb = prom_collector_registry_must_register_metric(prom_counter_new("turn_total_traffic_rcvb", "Represents total received bytes", 3, (const char *[]) {"realm", "user", "allocation" }));
-  turn_total_traffic_sentp = prom_collector_registry_must_register_metric(prom_counter_new("turn_total_traffic_sentp", "Represents total sent packets", 3, (const char *[]) {"realm", "user", "allocation" }));
-  turn_total_traffic_sentb = prom_collector_registry_must_register_metric(prom_counter_new("turn_total_traffic_sentb", "Represents total sent bytes", 3, (const char *[]) {"realm", "user", "allocation" }));
-
-  // Create tota traffic for peers gauge metrics
-  turn_total_traffic_peer_rcvp = prom_collector_registry_must_register_metric(prom_counter_new("turn_total_traffic_peer_rcvp", "Represents total peer received packets", 3, (const char *[]) {"realm", "user", "allocation" }));
-  turn_total_traffic_peer_rcvb = prom_collector_registry_must_register_metric(prom_counter_new("turn_total_traffic_peer_rcvb", "Represents total peer received bytes", 3, (const char *[]) {"realm", "user", "allocation" }));
-  turn_total_traffic_peer_sentp = prom_collector_registry_must_register_metric(prom_counter_new("turn_total_traffic_peer_sentp", "Represents total peer sent packets", 3, (const char *[]) {"realm", "user", "allocation" }));
-  turn_total_traffic_peer_sentb = prom_collector_registry_must_register_metric(prom_counter_new("turn_total_traffic_peer_sentb", "Represents total peer sent bytes", 3, (const char *[]) {"realm", "user", "allocation" }));
+  
+  const char *label[] = {"realm", "user"};
+
+  // Create traffic counter metrics
+  turn_traffic_rcvp = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_rcvp", "Represents finsihed sessions received packets", 2, label));
+  turn_traffic_rcvb = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_rcvb", "Represents finsihed sessions received bytes", 2, label));
+  turn_traffic_sentp = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_sentp", "Represents finsihed sessions sent packets", 2, label));
+  turn_traffic_sentb = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_sentb", "Represents finsihed sessions sent bytes", 2, label));
+
+  // Create finsihed sessions traffic for peers counter metrics
+  turn_traffic_peer_rcvp = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_peer_rcvp", "Represents finsihed sessions peer received packets", 2, label));
+  turn_traffic_peer_rcvb = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_peer_rcvb", "Represents finsihed sessions peer received bytes", 2, label));
+  turn_traffic_peer_sentp = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_peer_sentp", "Represents finsihed sessions peer sent packets", 2, label));
+  turn_traffic_peer_sentb = prom_collector_registry_must_register_metric(prom_counter_new("turn_traffic_peer_sentb", "Represents finsihed sessions peer sent bytes", 2, 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 finsihed sessions received packets", 0, NULL));
+  turn_total_traffic_rcvb = prom_collector_registry_must_register_metric(prom_counter_new("turn_total_traffic_rcvb", "Represents total finsihed sessions received bytes", 0, NULL));
+  turn_total_traffic_sentp = prom_collector_registry_must_register_metric(prom_counter_new("turn_total_traffic_sentp", "Represents total finsihed sessions sent packets", 0, NULL));
+  turn_total_traffic_sentb = prom_collector_registry_must_register_metric(prom_counter_new("turn_total_traffic_sentb", "Represents total finsihed sessions sent bytes", 0, NULL));
+
+  // Create total finsihed 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 finsihed 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 finsihed 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 finsihed 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 finsihed sessions peer sent bytes", 0, NULL));
 
   promhttp_set_active_collector_registry(NULL);
 
@@ -67,61 +67,31 @@ int start_prometheus_server(void){
   return 0;
 }
 
-void prom_set_status(const char* realm, const char* user, unsigned long long allocation, const char* status, unsigned long lifetime){
+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){
-    char allocation_chars[1024];
-    char lifetime_chars[1024];
-
-    snprintf(allocation_chars, sizeof(allocation_chars), "%018llu", allocation);
-    snprintf(lifetime_chars, sizeof(lifetime_chars), "%lu", lifetime);
-
-    prom_gauge_add(turn_status, 1, (const char *[]) { realm , user, allocation_chars, status, lifetime_chars });
-  }
-}
-
-void prom_del_status(const char* realm, const char* user, unsigned long long allocation, const char* status){
-  if (turn_params.prometheus == 0){
-    char allocation_chars[1024];
-    snprintf(allocation_chars, sizeof(allocation_chars), "%018llu", allocation);
 
-    prom_gauge_sub(turn_status, 1, (const char *[]) { realm , user, allocation_chars, (char *)"new", (char *)"600" });
-    prom_gauge_add(turn_status, 1, (const char *[]) { realm , user, allocation_chars, status, NULL });
-  }
-}
-void prom_set_traffic(const char* realm, const char* user, unsigned long long allocation, unsigned long rsvp, unsigned long rsvb, unsigned long sentp, unsigned long sentb, bool peer){
-  if (turn_params.prometheus == 1){
-    char allocation_chars[1024];
-    snprintf(allocation_chars, sizeof(allocation_chars), "%018llu", allocation);
-
-    if (peer){
-      prom_counter_add(turn_traffic_peer_rcvp, rsvp, (const char *[]) { realm , user, allocation_chars });
-      prom_counter_add(turn_traffic_peer_rcvb, rsvb, (const char *[]) { realm , user, allocation_chars });
-      prom_counter_add(turn_traffic_peer_sentp, sentp, (const char *[]) { realm , user, allocation_chars });
-      prom_counter_add(turn_traffic_peer_sentb, sentb, (const char *[]) { realm , user, allocation_chars });
-    } else {
-      prom_counter_add(turn_traffic_rcvp, rsvp, (const char *[]) { realm , user, allocation_chars });
-      prom_counter_add(turn_traffic_rcvb, rsvb, (const char *[]) { realm , user, allocation_chars });
-      prom_counter_add(turn_traffic_sentp, sentp, (const char *[]) { realm , user, allocation_chars });
-      prom_counter_add(turn_traffic_sentb, sentb, (const char *[]) { realm , user, allocation_chars });
-    }
-  }
-}
-
-void prom_set_total_traffic(const char* realm, const char* user, unsigned long long allocation, unsigned long rsvp, unsigned long rsvb, unsigned long sentp, unsigned long sentb, bool peer){
-  if (turn_params.prometheus == 1){
-    char allocation_chars[1024];
-    snprintf(allocation_chars, sizeof(allocation_chars), "%018llu", allocation);
+    const char *label[] = {realm, user};
 
     if (peer){
-      prom_counter_add(turn_total_traffic_peer_rcvp, rsvp, (const char *[]) { realm , user, allocation_chars });
-      prom_counter_add(turn_total_traffic_peer_rcvb, rsvb, (const char *[]) { realm , user, allocation_chars });
-      prom_counter_add(turn_total_traffic_peer_sentp, sentp, (const char *[]) { realm , user, allocation_chars });
-      prom_counter_add(turn_total_traffic_peer_sentb, sentb, (const char *[]) { realm , user, allocation_chars });
+      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_total_traffic_rcvp, rsvp, (const char *[]) { realm , user, allocation_chars });
-      prom_counter_add(turn_total_traffic_rcvb, rsvb, (const char *[]) { realm , user, allocation_chars });
-      prom_counter_add(turn_total_traffic_sentp, sentp, (const char *[]) { realm , user, allocation_chars });
-      prom_counter_add(turn_total_traffic_sentb, sentb, (const char *[]) { realm , user, allocation_chars });
+      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);
     }
   }
 }

src/apps/relay/prom_server.h

@@ -10,33 +10,43 @@
 #include <unistd.h>
 #include <stdbool.h>
 
+#ifdef __cplusplus
+extern "C" {
+#endif
 #include <microhttpd.h>
 #include <prom.h>
 #include <promhttp.h>
+#ifdef __cplusplus
+}
+#endif /* __clplusplus */
 
 #define DEFAULT_PROM_SERVER_PORT (9641)
 
-extern prom_gauge_t *turn_status;
+extern prom_counter_t *turn_new_allocation;
+extern prom_counter_t *turn_refreshed_allocation;
+extern prom_counter_t *turn_deleted_allocation;
+
+extern prom_counter_t *turn_traffic_rcvp;
+extern prom_counter_t *turn_traffic_rcvb;
+extern prom_counter_t *turn_traffic_sentp;
+extern prom_counter_t *turn_traffic_sentb;
 
-extern prom_gauge_t *turn_traffic_rcvp;
-extern prom_gauge_t *turn_traffic_rcvb;
-extern prom_gauge_t *turn_traffic_sentp;
-extern prom_gauge_t *turn_traffic_sentb;
+extern prom_counter_t *turn_traffic_peer_rcvp;
+extern prom_counter_t *turn_traffic_peer_rcvb;
+extern prom_counter_t *turn_traffic_peer_sentp;
+extern prom_counter_t *turn_traffic_peer_sentb;
 
-extern prom_gauge_t *turn_total_traffic_rcvp;
-extern prom_gauge_t *turn_total_traffic_rcvb;
-extern prom_gauge_t *turn_total_traffic_sentp;
-extern prom_gauge_t *turn_total_traffic_sentb;
+extern prom_counter_t *turn_total_traffic_rcvp;
+extern prom_counter_t *turn_total_traffic_rcvb;
+extern prom_counter_t *turn_total_traffic_sentp;
+extern prom_counter_t *turn_total_traffic_sentb;
 
-extern prom_gauge_t *turn_traffic_peer_rcvp;
-extern prom_gauge_t *turn_traffic_peer_rcvb;
-extern prom_gauge_t *turn_traffic_peer_sentp;
-extern prom_gauge_t *turn_traffic_peer_sentb;
+extern prom_counter_t *turn_total_traffic_peer_rcvp;
+extern prom_counter_t *turn_total_traffic_peer_rcvb;
+extern prom_counter_t *turn_total_traffic_peer_sentp;
+extern prom_counter_t *turn_total_traffic_peer_sentb;
 
-extern prom_gauge_t *turn_total_traffic_peer_rcvp;
-extern prom_gauge_t *turn_total_traffic_peer_rcvb;
-extern prom_gauge_t *turn_total_traffic_peer_sentp;
-extern prom_gauge_t *turn_total_traffic_peer_sentb;
+#define TURN_ALLOC_STR_MAX_SIZE (20)
 
 #ifdef __cplusplus
 extern "C" {
@@ -45,10 +55,9 @@ extern "C" {
 
 int start_prometheus_server(void);
 
-void prom_set_status(const char* realm, const char* user, unsigned long long allocation, const char* status, unsigned long lifetime);
-void prom_del_status(const char* realm, const char* user, unsigned long long allocation, const char* status);
-void prom_set_traffic(const char* realm, const char* user, unsigned long long allocation, unsigned long rsvp, unsigned long rsvb, unsigned long sentp, unsigned long sentb, bool peer);
-void prom_set_total_traffic(const char* realm, const char* user, unsigned long long allocation, unsigned long rsvp, unsigned long rsvb, unsigned long sentp, unsigned long sentb, bool peer);
+void prom_set_status(int refresh);
+void prom_del_status();
+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);
 
 #endif /* TURN_NO_PROMETHEUS */