Add a stats format buffer & functions

include/stats.h

@@ -24,9 +24,12 @@
 
 #include <fcgiapp.h>
 
+#include <stdarg.h>
 #include <signal.h>
 #include <string.h>
 
+#define PYFCGI_STATS_REQS_SAMPLES (900)
+
 typedef struct pyfcgi_stats_s pyfcgi_stats_t;
 
 #include "conf.h"
@@ -35,7 +38,7 @@ typedef struct pyfcgi_stats_s pyfcgi_stats_t;
 struct pyfcgi_stats_s
 {
 	/**@brief Request per seconds on 15 minutes */
-	int reqs[900];
+	int reqs[PYFCGI_STATS_REQS_SAMPLES];
 	/**@brief Current request index */
 	int cur_req;
 
@@ -44,6 +47,11 @@ struct pyfcgi_stats_s
 
 	/**@brief Old SIGALRM handler */
 	struct sigaction oldact;
+
+	/**@brief Buffer to format the statistics before sending them */
+	char *buff;
+	size_t buff_ptr;
+	size_t buff_len;
 };
 
 /**@brief Starts collecting statistics
@@ -59,5 +67,23 @@ int pyfcgi_stats_init();
  */
 void pyfcgi_stats_collector(int);
 
+/**@brief Format all stats in a buffer
+ * @note uses the pyfcgi_stats.statsbuff buffer */
+size_t pyfcgi_stats_format();
+
+/**@brief Print in buffer using buff_ptr index
+ *@note exit on mem alloc failure
+ */
+void pyfcgi_stats_buffprintf(const char *fmt, ...);
+
+/**@brief Allocate the buffer with at least given space
+ * @param size_t sz the minimum buffer size
+ * @note allocation size is rounded
+ * @return 0 if OK else -1
+ */
+int pyfcgi_stats_reqbuff(size_t);
+
+const char *pyfcgi_stats_buff(const char **, size_t*);
+
 #endif
 

src/stats.c

@@ -62,9 +62,135 @@ void pyfcgi_stats_collector(int signum)
 	{
 		stats->reqs[stats->cur_req]++;
 	}
-	pyfcgi_log(LOG_DEBUG, "%d req/s", stats->reqs[stats->cur_req]);
+	pyfcgi_log(LOG_DEBUG, "s#%d %d req/s", pyfcgi_stats.cur_req,
+		pyfcgi_stats.reqs[stats->cur_req]);
 	stats->cur_req++;
+	stats->cur_req %= PYFCGI_STATS_REQS_SAMPLES;
 
 	return;
 }
 
+size_t pyfcgi_stats_format()
+{
+	char uptime[80], since[80];
+	char ds[18], hs[5], ms[5], ss[5];
+	unsigned long diff, d;
+	short s, m, h;
+	struct tm *tm;
+
+	tm = localtime(&PyFCGI_conf.context.uptime);
+	if(!strftime(since, 80, "%F %H:%M:%S%z", tm))
+	{
+		pyfcgi_log(LOG_WARNING, "Date too long !");
+		strcpy(since, "???");
+	}
+	diff = (unsigned long)difftime(time(NULL), PyFCGI_conf.context.uptime);
+	s = diff%60;
+	diff /= 60;
+	m = diff % 60;
+	diff /= 60;
+	h = diff % 24;
+	diff /=24;
+	d = diff;
+	if(d) { snprintf(ds, 18, "%02ldd ", d); }
+	else { ds[0] = '\0'; }
+	if(h || *ds) { snprintf(hs, 5, "%02dh ", h); }
+	else { hs[0] = '\0'; }
+	if(m || *hs) { snprintf(ms, 5, "%02dm ", m); }
+	else { ms[0] = '\0'; }
+	if(s || *ms) { snprintf(ss, 5, "%02ds ", s); }
+	else { ss[0] = '\0'; }
+	snprintf(uptime, 80, "%s%s%s%s", ds, hs, ms, ss);
+	
+
+	pyfcgi_stats.buff_ptr = 0;
+	pyfcgi_stats_buffprintf("%s\nUptime : %s since %s\n",
+		PACKAGE_STRING, uptime, since);
+
+	// Request counter stats formating
+	double r15, r10, r5, r1, rtmp;
+	unsigned long stmp; // stores a 60s req sum
+	int i, cur_req, cur_rs, idx;
+	r15 = r10 = r5 = r1 = stmp = 0;
+	cur_req = pyfcgi_stats.cur_req;
+	//Block interrupt/ALARM ??
+	for(i=0; i<PYFCGI_STATS_REQS_SAMPLES; i++)
+	{
+		if(cur_req != pyfcgi_stats.cur_req)
+		{
+			errno = EINTR;
+			return 0;
+		}
+		idx = (pyfcgi_stats.cur_req - i - 1);
+		idx = (idx<0)?PYFCGI_STATS_REQS_SAMPLES + idx:idx;
+		idx %= PYFCGI_STATS_REQS_SAMPLES;
+		cur_rs = pyfcgi_stats.reqs[idx];
+		if(!i || i%60)
+		{
+			stmp += cur_rs;
+			continue;
+		}
+		rtmp = (long double)stmp / 60;
+		if(i==60) { r1 = rtmp; }
+		if(i<5*60) { r5 += rtmp; }
+		if(i<10*60) { r10 += rtmp; }
+		if(i<15*60) { r15 += rtmp; }
+		stmp = cur_rs;
+	}
+	//Restore interrupt/ALARM ??
+	r5 /= 5;
+	r10 /= 10;
+	r15 /= 15;
+	pyfcgi_stats_buffprintf("Requests stats :\n1s:%dr/s 1m:%.2fr/s 5m:%.2fr/s 10m:%.2fr/s 15m:%.2fr/s\n",
+		pyfcgi_stats.reqs[pyfcgi_stats.cur_req-1], r1, r5, r10, r15);
+	return pyfcgi_stats.buff_ptr;
+}
+
+void pyfcgi_stats_buffprintf(const char *fmt, ...)
+{
+	va_list ap;
+	size_t fsz, left;
+	while(1)
+	{
+		left = pyfcgi_stats.buff_len - pyfcgi_stats.buff_ptr;
+		va_start(ap, fmt);
+		fsz = vsnprintf(pyfcgi_stats.buff + pyfcgi_stats.buff_ptr,
+			left, fmt, ap);
+		va_end(ap);
+		if(fsz >= left)
+		{
+			if(pyfcgi_stats_reqbuff(pyfcgi_stats.buff_ptr + fsz) < 0)
+			{
+				exit(PYFCGI_ERR);
+			}
+			continue;
+		}
+		pyfcgi_stats.buff_ptr += fsz;
+		break;
+	}
+}
+
+int pyfcgi_stats_reqbuff(size_t sz)
+{
+	void *tmp;
+
+	if(sz <= pyfcgi_stats.buff_len) { return 0; }
+
+	sz = ((sz>>11)+1)<<11;
+	if( !(tmp = realloc(pyfcgi_stats.buff, sz)) )
+	{
+		pyfcgi_log(LOG_ALERT, "Unable to reallocate stats buffer : %s",
+			strerror(errno));
+		return -1;
+	}
+	pyfcgi_stats.buff_len = sz;
+	pyfcgi_stats.buff = tmp;
+	return 0;
+}
+
+const char *pyfcgi_stats_buff(const char **buff, size_t* len)
+{
+	*buff = pyfcgi_stats.buff;
+	*len = pyfcgi_stats.buff_ptr;
+	return *buff;
+}