sl: stats exported to K-style api

- S stats are available via K stats api
- more detailed stats per reply codes

modules_s/sl/sl.c

@@ -128,6 +128,10 @@ static int mod_init(void)
 		ERR("init_sl_stats failed\n");
 		return -1;
 	}
+	if (sl_register_kstats()<0) {
+		ERR("init k stats failed\n");
+		return -1;
+	}
 
 	     /* if SL loaded, filter ACKs on beginning */
 	if (register_script_cb( sl_filter_ACK, PRE_SCRIPT_CB|REQUEST_CB, 0 )<0) {

modules_s/sl/sl_funcs.c

@@ -243,7 +243,8 @@ int sl_filter_ACK(struct sip_msg *msg, unsigned int flags, void *bar )
 			calc_crc_suffix(msg, tag_suffix);
 			/* test whether to-tag equal now */
 			if (memcmp(tag_str->s,sl_tag.s,sl_tag.len)==0) {
-				DBG("DEBUG: sl_filter_ACK : local ACK found -> dropping it! \n" );
+				DBG("DEBUG: sl_filter_ACK : local ACK found -> dropping it!\n" );
+				update_sl_filtered_acks();
 				return 0;
 			}
 		}

modules_s/sl/sl_stats.c

@@ -27,6 +27,7 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include "../../sr_module.h"
 #include "../../mem/shm_mem.h"
 #include "../../globals.h"
 #include "../../config.h"
@@ -43,9 +44,12 @@ static void add_sl_stats( struct sl_stats *t, struct sl_stats *i)
 {
 	enum reply_type rt;
 
-	for (rt=0; rt<RT_END; rt++) 
+	for (rt=0; rt<RT_END; rt++) { 
 		t->err[rt]+=i->err[rt];
+		t->all_replies+=i->err[rt];
+	}
 	t->failures+=i->failures;
+	t->filtered_acks+=i->filtered_acks;
 }
 
 
@@ -142,6 +146,11 @@ void update_sl_failures( void )
 	(*sl_stats)[process_no].failures++;
 }
 
+void update_sl_filtered_acks( void )
+{
+	(*sl_stats)[process_no].filtered_acks++;
+}
+
 void update_sl_stats( int code ) 
 {
 
@@ -207,3 +216,268 @@ rpc_export_t sl_rpc[] = {
 	{"sl.stats", rpc_stats, rpc_stats_doc, 0},
 	{0, 0, 0, 0}
 };
+
+#ifdef STATISTICS
+
+/* k statistics */
+
+unsigned long sl_stats_RT_1xx(void);
+unsigned long sl_stats_RT_200(void);
+unsigned long sl_stats_RT_202(void);
+unsigned long sl_stats_RT_2xx(void);
+unsigned long sl_stats_RT_300(void);
+unsigned long sl_stats_RT_301(void);
+unsigned long sl_stats_RT_302(void);
+unsigned long sl_stats_RT_3xx(void);
+unsigned long sl_stats_RT_400(void);
+unsigned long sl_stats_RT_401(void);
+unsigned long sl_stats_RT_403(void);
+unsigned long sl_stats_RT_404(void);
+unsigned long sl_stats_RT_407(void);
+unsigned long sl_stats_RT_408(void);
+unsigned long sl_stats_RT_483(void);
+unsigned long sl_stats_RT_4xx(void);
+unsigned long sl_stats_RT_500(void);
+unsigned long sl_stats_RT_5xx(void);
+unsigned long sl_stats_RT_6xx(void);
+unsigned long sl_stats_RT_xxx(void);
+
+unsigned long sl_stats_sent_rpls(void);
+unsigned long sl_stats_sent_err_rpls(void);
+unsigned long sl_stats_rcv_acks(void);
+
+static stat_export_t mod_stats[] = {
+	{"1xx_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_1xx    },
+	{"200_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_200    },
+	{"202_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_202    },
+	{"2xx_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_2xx    },
+	{"300_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_300    },
+	{"301_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_301    },
+	{"302_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_302    },
+	{"3xx_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_3xx    },
+	{"400_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_400    },
+	{"401_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_401    },
+	{"403_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_403    },
+	{"404_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_404    },
+	{"407_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_407    },
+	{"408_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_408    },
+	{"483_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_483    },
+	{"4xx_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_4xx    },
+	{"500_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_500    },
+	{"5xx_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_5xx    },
+	{"6xx_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_6xx    },
+	{"xxx_replies" ,       STAT_IS_FUNC,
+		(stat_var**)sl_stats_RT_xxx    },
+
+	{"sent_replies" ,      STAT_IS_FUNC,
+		(stat_var**)sl_stats_sent_rpls      },
+	{"sent_err_replies" ,  STAT_IS_FUNC,
+		(stat_var**)sl_stats_sent_err_rpls  },
+	{"received_ACKs" ,     STAT_IS_FUNC,
+		(stat_var**)sl_stats_rcv_acks       },
+	{0,0,0}
+};
+
+
+static struct sl_stats _sl_stats_total;
+static ticks_t _sl_stats_tm = 0;
+
+static void sl_stats_update(void)
+{
+	int p;
+	int procs_no;
+	ticks_t t;
+
+	t = get_ticks();
+	if(t==_sl_stats_tm)
+		return;
+	_sl_stats_tm = t;
+
+	memset(&_sl_stats_total, 0, sizeof(struct sl_stats));
+	if (dont_fork) {
+		add_sl_stats(&_sl_stats_total, &(*sl_stats)[0]);
+	} else{
+		procs_no=get_max_procs();
+		for (p=0; p < procs_no; p++)
+			add_sl_stats(&_sl_stats_total, &(*sl_stats)[p]);
+	}
+}
+
+unsigned long sl_stats_tx_1xx_rpls(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_1xx];
+}
+
+unsigned long sl_stats_RT_1xx(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_1xx];
+}
+
+unsigned long sl_stats_RT_200(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_200];
+}
+
+unsigned long sl_stats_RT_202(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_202];
+}
+
+unsigned long sl_stats_RT_2xx(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_2xx];
+}
+
+unsigned long sl_stats_RT_300(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_300];
+}
+
+unsigned long sl_stats_RT_301(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_301];
+}
+
+unsigned long sl_stats_RT_302(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_302];
+}
+
+unsigned long sl_stats_RT_3xx(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_3xx];
+}
+
+unsigned long sl_stats_RT_400(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_400];
+}
+
+unsigned long sl_stats_RT_401(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_401];
+}
+
+unsigned long sl_stats_RT_403(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_403];
+}
+
+unsigned long sl_stats_RT_404(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_404];
+}
+
+unsigned long sl_stats_RT_407(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_407];
+}
+
+unsigned long sl_stats_RT_408(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_408];
+}
+
+unsigned long sl_stats_RT_483(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_483];
+}
+
+unsigned long sl_stats_RT_4xx(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_4xx];
+}
+
+unsigned long sl_stats_RT_500(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_500];
+}
+
+unsigned long sl_stats_RT_5xx(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_5xx];
+}
+
+unsigned long sl_stats_RT_6xx(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_6xx];
+}
+
+unsigned long sl_stats_RT_xxx(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.err[RT_xxx];
+}
+
+
+unsigned long sl_stats_sent_rpls(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.all_replies;
+}
+
+unsigned long sl_stats_sent_err_rpls(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.failures;
+}
+
+unsigned long sl_stats_rcv_acks(void)
+{
+	sl_stats_update();
+	return _sl_stats_total.filtered_acks;
+}
+
+#endif
+
+int sl_register_kstats(void)
+{
+#ifdef STATISTICS
+	/* register statistics */
+	if (register_module_stats("sl", mod_stats)!=0 ) {
+		LM_ERR("failed to register statistics\n");
+		return -1;
+	}
+#endif
+	return 0;
+}
+

modules_s/sl/sl_stats.h

@@ -34,7 +34,7 @@
 
 #include "../../rpc.h"
 
-enum reply_type { RT_200 = 0, RT_202, RT_2xx,
+enum reply_type { RT_1xx = 0,  RT_200, RT_202, RT_2xx,
 		  RT_300, RT_301, RT_302, RT_3xx,
 		  RT_400, RT_401, RT_403, RT_404, RT_407, 
 		  RT_408, RT_483, RT_4xx,
@@ -45,15 +45,20 @@ enum reply_type { RT_200 = 0, RT_202, RT_2xx,
 
 struct sl_stats {
 	unsigned long err[RT_END];
+	unsigned long all_replies;
 	unsigned long failures;
+	unsigned long filtered_acks;
 };
 
 int init_sl_stats(void);
 int init_sl_stats_child(void);
 void update_sl_stats( int code );
 void update_sl_failures( void );
+void update_sl_filtered_acks( void );
 void sl_stats_destroy();
 
 extern rpc_export_t sl_rpc[];
 
+int sl_register_kstats(void);
+
 #endif /* _SL_STATS_H */