PyFCGI/src/stats.c

#include "stats.h"

static pyfcgi_stats_t pyfcgi_stats;

int pyfcgi_stats_init()
{
	struct sigaction act;
	struct itimerspec timeout;

	memset(&pyfcgi_stats, 0, sizeof(pyfcgi_stats_t));

	if(timer_create(CLOCK_REALTIME, NULL, &(pyfcgi_stats.timerid)) < 0)
	{
		pyfcgi_log(LOG_ERR,
			"Unable to create timer for stats collecting : %s",
			strerror(errno));
		goto err;
	}

	act.sa_handler = pyfcgi_stats_collector;
	sigemptyset(&act.sa_mask);
	act.sa_flags = 0;
	act.sa_restorer = NULL;
	if(sigaction(SIGALRM, &act, &(pyfcgi_stats.oldact)) < 0)
	{
		pyfcgi_log(LOG_ERR,
			"Unable to register signal handler for stats collecting : %s",
			strerror(errno));
		goto err_deltimer;
	}

	timeout.it_value.tv_sec = 1;
	timeout.it_value.tv_nsec = 0;
	timeout.it_interval = timeout.it_value;
	if(timer_settime(pyfcgi_stats.timerid, 0, &timeout, NULL) < 0)
	{
		pyfcgi_log(LOG_ERR,
			"Unable to start timer for stats collecting : %s",
			strerror(errno));
		goto err_sigrestore;
	}
	return 0;

err_sigrestore:
	sigaction(SIGALRM, &(pyfcgi_stats.oldact), NULL);
err_deltimer:
	timer_delete(pyfcgi_stats.timerid);
err:
	memset(&pyfcgi_stats, 0, sizeof(pyfcgi_stats_t));
	return -1;
}

void pyfcgi_stats_collector(int signum)
{
	int ret;
	pyfcgi_stats_t *stats;

	stats = &pyfcgi_stats;

	stats->reqs[stats->cur_req] = 0;
	while( !(ret = sem_trywait(PyFCGI_SEM(SEM_WREQS).sem)) )
	{
		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_SZ;

	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 avgs[4];
	int last_rs, ret;

	do
	{
		ret = pyfcgi_stats_avg(pyfcgi_stats.reqs,
			&(pyfcgi_stats.cur_req), &last_rs, avgs);
	} while(ret < 0 && errno == EINTR);
	pyfcgi_stats_buffprintf("Requests stats :\n1s:%dr/s 1m:%.2fr/s 5m:%.2fr/s 10m:%.2fr/s 15m:%.2fr/s\n",
		last_rs, avgs[0], avgs[1], avgs[2], avgs[3]);
	return pyfcgi_stats.buff_ptr;
}

int pyfcgi_stats_avg(const int data[PYFCGI_STATS_SZ], int *idx_nxt, int *last,
	double avgs[4])
{
	double r15, r10, r5, r1, rtmp, dmax;
	unsigned long stmp; // stores a 60s req sum
	int i, cur, idx, first, idiv;
	int uptime, max;

	uptime = time(NULL) - PyFCGI_conf.context.uptime;
	max = (uptime > PYFCGI_STATS_SZ) ? PYFCGI_STATS_SZ:uptime;

	r15 = r10 = r5 = r1 = stmp = rtmp = 0;
	first = *idx_nxt;

	//Block interrupt/ALARM ??
	i = 0;
	do
	{
		if(first != *idx_nxt)
		{
			errno = EINTR;
			return -1;
		}
		idx = (*idx_nxt- i - 1);
		idx = (idx<0)?PYFCGI_STATS_SZ + idx:idx;
		idx %= PYFCGI_STATS_SZ;
		cur = data[idx];
		if((!i || i%60) && i < max-1)
		{
			stmp += cur;
			i++;
			continue;
		}
		rtmp = (long double)stmp / ((i%60)?i%60:60);
		if(i<=60) { r1 = rtmp; }
		else if(i%60) { rtmp = (double)rtmp / (60.0 / (i%60)); }
		if(i<=5*60) { r5 += rtmp; }
		if(i<=10*60) { r10 += rtmp; }
		if(i<=15*60) { r15 += rtmp; }
		stmp = cur;
		i++;
	}while(i<max);
	//Restore interrupt/ALARM ??
	*last = data[*idx_nxt-1];

	dmax = (max<=60)?1:(double)max/60;
	r5 /= (max >= 300)?5:dmax;
	r10 /= (max >= 600)?10:dmax;
	r15 /= (max >= 900)?15:dmax;
	avgs[0] = r1;
	avgs[1] = r5;
	avgs[2] = r10;
	avgs[3] = r15;

	return 0;
}

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;
}