TT#101150 split out "gauge" style stats

Change-Id: I52617a083bbbd41342b6413d8cacc5235cec51d9

daemon/call.c

@@ -64,9 +64,10 @@ struct xmlrpc_helper {
 
 
 /* XXX rework these */
-struct global_stats rtpe_statsps;
-struct global_stats rtpe_stats;
-struct global_stats rtpe_stats_cumulative;
+struct global_stats_counter rtpe_statsps;
+struct global_stats_counter rtpe_stats_cumulative;
+struct global_stats_counter rtpe_stats;
+struct global_stats_gauge rtpe_stats_gauge;
 
 rwlock_t rtpe_callhash_lock;
 GHashTable *rtpe_callhash;
@@ -533,7 +534,7 @@ void call_timer(void *ptr) {
 	GList *i, *l;
 	struct rtpengine_list_entry *ke;
 	struct packet_stream *ps;
-	struct global_stats tmpstats;
+	struct global_stats_counter tmpstats;
 	int j, update;
 	struct stream_fd *sfd;
 	struct rtp_stats *rs;
@@ -588,7 +589,7 @@ void call_timer(void *ptr) {
 	update_requests_per_second_stats(&rtpe_totalstats_interval.deletes_ps,	deletes / run_diff);
 
 	// stats derived while iterating calls
-	atomic64_set(&rtpe_stats.transcoded_media, hlp.transcoded_media);
+	atomic64_set(&rtpe_stats_gauge.transcoded_media, hlp.transcoded_media);
 
 	i = kernel_list();
 	while (i) {

daemon/call_interfaces.c

@@ -1232,7 +1232,7 @@ static enum load_limit_reasons call_offer_session_limit(void) {
 	if (rtpe_config.max_sessions>=0) {
 		rwlock_lock_r(&rtpe_callhash_lock);
 		if (g_hash_table_size(rtpe_callhash) -
-				atomic64_get(&rtpe_stats.foreign_sessions) >= rtpe_config.max_sessions)
+				atomic64_get(&rtpe_stats_gauge.foreign_sessions) >= rtpe_config.max_sessions)
 		{
 			/* foreign calls can't get rejected
 			 * total_rejected_sess applies only to "own" sessions */

daemon/cli.c

@@ -434,14 +434,14 @@ static void cli_incoming_list_totals(str *instr, struct cli_writer *cw) {
 
 static void cli_incoming_list_numsessions(str *instr, struct cli_writer *cw) {
        rwlock_lock_r(&rtpe_callhash_lock);
-       cw->cw_printf(cw, "Current sessions own: "UINT64F"\n", g_hash_table_size(rtpe_callhash) - atomic64_get(&rtpe_stats.foreign_sessions));
-       cw->cw_printf(cw, "Current sessions foreign: "UINT64F"\n", atomic64_get(&rtpe_stats.foreign_sessions));
+       cw->cw_printf(cw, "Current sessions own: "UINT64F"\n", g_hash_table_size(rtpe_callhash) - atomic64_get(&rtpe_stats_gauge.foreign_sessions));
+       cw->cw_printf(cw, "Current sessions foreign: "UINT64F"\n", atomic64_get(&rtpe_stats_gauge.foreign_sessions));
        cw->cw_printf(cw, "Current sessions total: %i\n", g_hash_table_size(rtpe_callhash));
        rwlock_unlock_r(&rtpe_callhash_lock);
-       cw->cw_printf(cw, "Current transcoded media: "UINT64F"\n", atomic64_get(&rtpe_stats.transcoded_media));
-       cw->cw_printf(cw, "Current sessions ipv4 only media: %li\n", atomic64_get(&rtpe_stats.ipv4_sessions));
-       cw->cw_printf(cw, "Current sessions ipv6 only media: %li\n", atomic64_get(&rtpe_stats.ipv6_sessions));
-       cw->cw_printf(cw, "Current sessions ip mixed  media: %li\n", atomic64_get(&rtpe_stats.mixed_sessions));
+       cw->cw_printf(cw, "Current transcoded media: "UINT64F"\n", atomic64_get(&rtpe_stats_gauge.transcoded_media));
+       cw->cw_printf(cw, "Current sessions ipv4 only media: %li\n", atomic64_get(&rtpe_stats_gauge.ipv4_sessions));
+       cw->cw_printf(cw, "Current sessions ipv6 only media: %li\n", atomic64_get(&rtpe_stats_gauge.ipv6_sessions));
+       cw->cw_printf(cw, "Current sessions ip mixed  media: %li\n", atomic64_get(&rtpe_stats_gauge.mixed_sessions));
 }
 
 static void cli_incoming_list_maxsessions(str *instr, struct cli_writer *cw) {

daemon/graphite.c

@@ -144,7 +144,7 @@ GString *print_graphite_data(struct totalstats *sent_data) {
 	ts->managed_sess_max = rtpe_totalstats_interval.managed_sess_max;
 	ts->managed_sess_min = rtpe_totalstats_interval.managed_sess_min;
         ts->total_sessions = g_hash_table_size(rtpe_callhash);
-        ts->foreign_sessions = atomic64_get(&rtpe_stats.foreign_sessions);
+        ts->foreign_sessions = atomic64_get(&rtpe_stats_gauge.foreign_sessions);
 	ts->own_sessions = ts->total_sessions - ts->foreign_sessions;
 	rtpe_totalstats_interval.managed_sess_max = ts->own_sessions;;
 	rtpe_totalstats_interval.managed_sess_min = ts->own_sessions;
@@ -188,10 +188,10 @@ GString *print_graphite_data(struct totalstats *sent_data) {
 	GPF("current_sessions_total "UINT64F, ts->total_sessions);
 	GPF("current_sessions_own "UINT64F, ts->own_sessions);
 	GPF("current_sessions_foreign "UINT64F, ts->foreign_sessions);
-	GPF("current_transcoded_media "UINT64F, atomic64_get(&rtpe_stats.transcoded_media));
-	GPF("current_sessions_ipv4 "UINT64F, atomic64_get(&rtpe_stats.ipv4_sessions));
-	GPF("current_sessions_ipv6 "UINT64F, atomic64_get(&rtpe_stats.ipv6_sessions));
-	GPF("current_sessions_mixed "UINT64F, atomic64_get(&rtpe_stats.mixed_sessions));
+	GPF("current_transcoded_media "UINT64F, atomic64_get(&rtpe_stats_gauge.transcoded_media));
+	GPF("current_sessions_ipv4 "UINT64F, atomic64_get(&rtpe_stats_gauge.ipv4_sessions));
+	GPF("current_sessions_ipv6 "UINT64F, atomic64_get(&rtpe_stats_gauge.ipv6_sessions));
+	GPF("current_sessions_mixed "UINT64F, atomic64_get(&rtpe_stats_gauge.mixed_sessions));
 	GPF("nopacket_relayed_sess "UINT64F, atomic64_get_na(&ts->total_nopacket_relayed_sess));
 	GPF("oneway_stream_sess "UINT64F, atomic64_get_na(&ts->total_oneway_stream_sess));
 	GPF("regular_term_sess "UINT64F, atomic64_get_na(&ts->total_regular_term_sess));

daemon/statistics.c

@@ -113,15 +113,15 @@ void statistics_update_ip46_inc_dec(struct call* c, int op) {
 	if (c->is_ipv4_media_offer && !c->is_ipv6_media_offer) {
 		// answer is ipv4 only
 		if (c->is_ipv4_media_answer && !c->is_ipv6_media_answer) {
-			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats.ipv4_sessions) : atomic64_dec(&rtpe_stats.ipv4_sessions);
+			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats_gauge.ipv4_sessions) : atomic64_dec(&rtpe_stats_gauge.ipv4_sessions);
 
 		// answer is ipv6 only
 		} else if (!c->is_ipv4_media_answer && c->is_ipv6_media_answer) {
-			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats.mixed_sessions) : atomic64_dec(&rtpe_stats.mixed_sessions);
+			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats_gauge.mixed_sessions) : atomic64_dec(&rtpe_stats_gauge.mixed_sessions);
 
 		// answer is both ipv4 and ipv6
 		} else if (c->is_ipv4_media_answer && c->is_ipv6_media_answer) {
-			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats.ipv4_sessions) : atomic64_dec(&rtpe_stats.ipv4_sessions);
+			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats_gauge.ipv4_sessions) : atomic64_dec(&rtpe_stats_gauge.ipv4_sessions);
 
 		// answer is neither ipv4 nor ipv6
 		} else {
@@ -132,15 +132,15 @@ void statistics_update_ip46_inc_dec(struct call* c, int op) {
 	} else if (!c->is_ipv4_media_offer && c->is_ipv6_media_offer) {
 		// answer is ipv4 only
 		if (c->is_ipv4_media_answer && !c->is_ipv6_media_answer) {
-			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats.mixed_sessions) : atomic64_dec(&rtpe_stats.mixed_sessions);
+			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats_gauge.mixed_sessions) : atomic64_dec(&rtpe_stats_gauge.mixed_sessions);
 
 		// answer is ipv6 only
 		} else if (!c->is_ipv4_media_answer && c->is_ipv6_media_answer) {
-			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats.ipv6_sessions) : atomic64_dec(&rtpe_stats.ipv6_sessions);
+			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats_gauge.ipv6_sessions) : atomic64_dec(&rtpe_stats_gauge.ipv6_sessions);
 
 		// answer is both ipv4 and ipv6
 		} else if (c->is_ipv4_media_answer && c->is_ipv6_media_answer) {
-			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats.ipv6_sessions) : atomic64_dec(&rtpe_stats.ipv6_sessions);
+			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats_gauge.ipv6_sessions) : atomic64_dec(&rtpe_stats_gauge.ipv6_sessions);
 
 		// answer is neither ipv4 nor ipv6
 		} else {
@@ -151,15 +151,15 @@ void statistics_update_ip46_inc_dec(struct call* c, int op) {
 	} else if (c->is_ipv4_media_offer && c->is_ipv6_media_offer) {
 		// answer is ipv4 only
 		if (c->is_ipv4_media_answer && !c->is_ipv6_media_answer) {
-			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats.ipv4_sessions) : atomic64_dec(&rtpe_stats.ipv4_sessions);
+			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats_gauge.ipv4_sessions) : atomic64_dec(&rtpe_stats_gauge.ipv4_sessions);
 
 		// answer is ipv6 only
 		} else if (!c->is_ipv4_media_answer && c->is_ipv6_media_answer) {
-			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats.ipv6_sessions) : atomic64_dec(&rtpe_stats.ipv6_sessions);
+			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats_gauge.ipv6_sessions) : atomic64_dec(&rtpe_stats_gauge.ipv6_sessions);
 
 		// answer is both ipv4 and ipv6
 		} else if (c->is_ipv4_media_answer && c->is_ipv6_media_answer) {
-			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats.mixed_sessions) : atomic64_dec(&rtpe_stats.mixed_sessions);
+			(op == CMC_INCREMENT) ? atomic64_inc(&rtpe_stats_gauge.mixed_sessions) : atomic64_dec(&rtpe_stats_gauge.mixed_sessions);
 
 		// answer is neither ipv4 nor ipv6
 		} else {
@@ -177,13 +177,13 @@ void statistics_update_ip46_inc_dec(struct call* c, int op) {
 
 void statistics_update_foreignown_dec(struct call* c) {
 	if (IS_FOREIGN_CALL(c)) {
-		atomic64_dec(&rtpe_stats.foreign_sessions);
+		atomic64_dec(&rtpe_stats_gauge.foreign_sessions);
 	}
 
 	if(IS_OWN_CALL(c)) 	{
 		mutex_lock(&rtpe_totalstats_interval.managed_sess_lock);
 		rtpe_totalstats_interval.managed_sess_min = MIN(rtpe_totalstats_interval.managed_sess_min,
-				g_hash_table_size(rtpe_callhash) - atomic64_get(&rtpe_stats.foreign_sessions));
+				g_hash_table_size(rtpe_callhash) - atomic64_get(&rtpe_stats_gauge.foreign_sessions));
 		mutex_unlock(&rtpe_totalstats_interval.managed_sess_lock);
 	}
 
@@ -195,11 +195,11 @@ void statistics_update_foreignown_inc(struct call* c) {
 		rtpe_totalstats_interval.managed_sess_max = MAX(
 				rtpe_totalstats_interval.managed_sess_max,
 				g_hash_table_size(rtpe_callhash)
-						- atomic64_get(&rtpe_stats.foreign_sessions));
+						- atomic64_get(&rtpe_stats_gauge.foreign_sessions));
 		mutex_unlock(&rtpe_totalstats_interval.managed_sess_lock);
 	}
 	else if (IS_FOREIGN_CALL(c)) { /* foreign call*/
-		atomic64_inc(&rtpe_stats.foreign_sessions);
+		atomic64_inc(&rtpe_stats_gauge.foreign_sessions);
 		atomic64_inc(&rtpe_totalstats.total_foreign_sessions);
 	}
 
@@ -464,15 +464,15 @@ GQueue *statistics_gather_metrics(void) {
 	cur_sessions = g_hash_table_size(rtpe_callhash);
 	rwlock_unlock_r(&rtpe_callhash_lock);
 
-	METRIC("sessionsown", "Owned sessions", UINT64F, UINT64F, cur_sessions - atomic64_get(&rtpe_stats.foreign_sessions));
+	METRIC("sessionsown", "Owned sessions", UINT64F, UINT64F, cur_sessions - atomic64_get(&rtpe_stats_gauge.foreign_sessions));
 	PROM("sessions", "gauge");
 	PROMLAB("type=\"own\"");
-	METRIC("sessionsforeign", "Foreign sessions", UINT64F, UINT64F, atomic64_get(&rtpe_stats.foreign_sessions));
+	METRIC("sessionsforeign", "Foreign sessions", UINT64F, UINT64F, atomic64_get(&rtpe_stats_gauge.foreign_sessions));
 	PROM("sessions", "gauge");
 	PROMLAB("type=\"foreign\"");
 
 	METRIC("sessionstotal", "Total sessions", UINT64F, UINT64F, cur_sessions);
-	METRIC("transcodedmedia", "Transcoded media", UINT64F, UINT64F, atomic64_get(&rtpe_stats.transcoded_media));
+	METRIC("transcodedmedia", "Transcoded media", UINT64F, UINT64F, atomic64_get(&rtpe_stats_gauge.transcoded_media));
 	PROM("transcoded_media", "gauge");
 
 	METRIC("packetrate", "Packets per second", UINT64F, UINT64F, atomic64_get(&rtpe_stats.packets));

include/call.h

@@ -541,9 +541,10 @@ extern rwlock_t rtpe_callhash_lock;
 extern GHashTable *rtpe_callhash;
 extern struct call_iterator_list rtpe_call_iterators[NUM_CALL_ITERATORS];
 
-extern struct global_stats rtpe_statsps;	/* per second stats, running timer */
-extern struct global_stats rtpe_stats_cumulative;	// total, cumulative
-extern struct global_stats rtpe_stats;		/* copied from statsps once a second */
+extern struct global_stats_counter rtpe_statsps;	/* per second stats, running timer */
+extern struct global_stats_counter rtpe_stats_cumulative;	// total, cumulative
+extern struct global_stats_counter rtpe_stats;		/* copied from statsps once a second */
+extern struct global_stats_gauge rtpe_stats_gauge;
 
 #define RTPE_STATS_ADD(field, num) \
 	do { \

include/statistics.h

@@ -19,18 +19,23 @@ struct stream_stats {
 #endif
 };
 
-struct global_stats {
+// "gauge" style stats
+struct global_stats_gauge {
+	atomic64			foreign_sessions; // unresponsible via redis notification
+	atomic64			transcoded_media;
+	atomic64			ipv4_sessions;
+	atomic64			ipv6_sessions;
+	atomic64			mixed_sessions;
+};
+
+// "counter" style stats that are incremental and are kept cumulative or per-interval
+struct global_stats_counter {
 	atomic64			packets;
 	atomic64			bytes;
 	atomic64			errors;
-	atomic64			foreign_sessions; // unresponsible via redis notification
 	atomic64			offers;
 	atomic64			answers;
 	atomic64			deletes;
-	atomic64			transcoded_media;
-	atomic64			ipv4_sessions;
-	atomic64			ipv6_sessions;
-	atomic64			mixed_sessions;
 };