Imported Upstream version 1.0.0upstream/1.0.0

1 files changed, 2009 insertions, 0 deletions

diff --git a/src/rrd2json.c b/src/rrd2json.c
new file mode 100755
index 000000000..ad453cb68
--- /dev/null
+++ b/src/rrd2json.c
@@ -0,0 +1,2009 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "log.h"
+#include "common.h"
+#include "rrd2json.h"
+
+#define HOSTNAME_MAX 1024
+char *hostname = "unknown";
+
+void rrd_stats_api_v1_chart(RRDSET *st, BUFFER *wb)
+{
+	pthread_rwlock_rdlock(&st->rwlock);
+
+	buffer_sprintf(wb,
+		"\t\t{\n"
+		"\t\t\t\"id\": \"%s\",\n"
+		"\t\t\t\"name\": \"%s\",\n"
+		"\t\t\t\"type\": \"%s\",\n"
+		"\t\t\t\"family\": \"%s\",\n"
+		"\t\t\t\"context\": \"%s\",\n"
+		"\t\t\t\"title\": \"%s\",\n"
+		"\t\t\t\"priority\": %ld,\n"
+		"\t\t\t\"enabled\": %s,\n"
+		"\t\t\t\"units\": \"%s\",\n"
+		"\t\t\t\"data_url\": \"/api/v1/data?chart=%s\",\n"
+		"\t\t\t\"chart_type\": \"%s\",\n"
+		"\t\t\t\"duration\": %ld,\n"
+		"\t\t\t\"first_entry\": %lu,\n"
+		"\t\t\t\"last_entry\": %lu,\n"
+		"\t\t\t\"update_every\": %d,\n"
+		"\t\t\t\"dimensions\": {\n"
+		, st->id
+		, st->name
+		, st->type
+		, st->family
+		, st->context
+		, st->title
+		, st->priority
+		, st->enabled?"true":"false"
+		, st->units
+		, st->name
+		, rrdset_type_name(st->chart_type)
+		, st->entries * st->update_every
+		, rrdset_first_entry_t(st)
+		, rrdset_last_entry_t(st)
+		, st->update_every
+		);
+
+	unsigned long memory = st->memsize;
+
+	int c = 0;
+	RRDDIM *rd;
+	for(rd = st->dimensions; rd ; rd = rd->next) {
+		if(rd->flags & RRDDIM_FLAG_HIDDEN) continue;
+
+		memory += rd->memsize;
+
+		buffer_sprintf(wb,
+			"%s"
+			"\t\t\t\t\"%s\": { \"name\": \"%s\" }"
+			, c?",\n":""
+			, rd->id
+			, rd->name
+			);
+
+		c++;
+	}
+
+	buffer_sprintf(wb,
+		"\n\t\t\t}\n"
+		"\t\t}"
+		);
+
+	pthread_rwlock_unlock(&st->rwlock);
+}
+
+void rrd_stats_api_v1_charts(BUFFER *wb)
+{
+	long c;
+	RRDSET *st;
+
+	buffer_sprintf(wb, "{\n"
+		   "\t\"hostname\": \"%s\""
+		",\n\t\"update_every\": %d"
+		",\n\t\"history\": %d"
+		",\n\t\"charts\": {"
+		, hostname
+		, rrd_update_every
+		, rrd_default_history_entries
+		);
+
+	pthread_rwlock_rdlock(&rrdset_root_rwlock);
+	for(st = rrdset_root, c = 0; st ; st = st->next) {
+		if(st->enabled) {
+			if(c) buffer_strcat(wb, ",");
+			buffer_strcat(wb, "\n\t\t\"");
+			buffer_strcat(wb, st->id);
+			buffer_strcat(wb, "\": ");
+			rrd_stats_api_v1_chart(st, wb);
+			c++;
+		}
+	}
+	pthread_rwlock_unlock(&rrdset_root_rwlock);
+
+	buffer_strcat(wb, "\n\t}\n}\n");
+}
+
+
+unsigned long rrd_stats_one_json(RRDSET *st, char *options, BUFFER *wb)
+{
+	time_t now = time(NULL);
+
+	pthread_rwlock_rdlock(&st->rwlock);
+
+	buffer_sprintf(wb,
+		"\t\t{\n"
+		"\t\t\t\"id\": \"%s\",\n"
+		"\t\t\t\"name\": \"%s\",\n"
+		"\t\t\t\"type\": \"%s\",\n"
+		"\t\t\t\"family\": \"%s\",\n"
+		"\t\t\t\"context\": \"%s\",\n"
+		"\t\t\t\"title\": \"%s\",\n"
+		"\t\t\t\"priority\": %ld,\n"
+		"\t\t\t\"enabled\": %d,\n"
+		"\t\t\t\"units\": \"%s\",\n"
+		"\t\t\t\"url\": \"/data/%s/%s\",\n"
+		"\t\t\t\"chart_type\": \"%s\",\n"
+		"\t\t\t\"counter\": %ld,\n"
+		"\t\t\t\"entries\": %ld,\n"
+		"\t\t\t\"first_entry_t\": %lu,\n"
+		"\t\t\t\"last_entry\": %ld,\n"
+		"\t\t\t\"last_entry_t\": %lu,\n"
+		"\t\t\t\"last_entry_secs_ago\": %lu,\n"
+		"\t\t\t\"update_every\": %d,\n"
+		"\t\t\t\"isdetail\": %d,\n"
+		"\t\t\t\"usec_since_last_update\": %llu,\n"
+		"\t\t\t\"collected_total\": " TOTAL_NUMBER_FORMAT ",\n"
+		"\t\t\t\"last_collected_total\": " TOTAL_NUMBER_FORMAT ",\n"
+		"\t\t\t\"dimensions\": [\n"
+		, st->id
+		, st->name
+		, st->type
+		, st->family
+		, st->context
+		, st->title
+		, st->priority
+		, st->enabled
+		, st->units
+		, st->name, options?options:""
+		, rrdset_type_name(st->chart_type)
+		, st->counter
+		, st->entries
+		, rrdset_first_entry_t(st)
+		, rrdset_last_slot(st)
+		, rrdset_last_entry_t(st)
+		, (now < rrdset_last_entry_t(st)) ? (time_t)0 : now - rrdset_last_entry_t(st)
+		, st->update_every
+		, st->isdetail
+		, st->usec_since_last_update
+		, st->collected_total
+		, st->last_collected_total
+		);
+
+	unsigned long memory = st->memsize;
+
+	RRDDIM *rd;
+	for(rd = st->dimensions; rd ; rd = rd->next) {
+
+		memory += rd->memsize;
+
+		buffer_sprintf(wb,
+			"\t\t\t\t{\n"
+			"\t\t\t\t\t\"id\": \"%s\",\n"
+			"\t\t\t\t\t\"name\": \"%s\",\n"
+			"\t\t\t\t\t\"entries\": %ld,\n"
+			"\t\t\t\t\t\"isHidden\": %d,\n"
+			"\t\t\t\t\t\"algorithm\": \"%s\",\n"
+			"\t\t\t\t\t\"multiplier\": %ld,\n"
+			"\t\t\t\t\t\"divisor\": %ld,\n"
+			"\t\t\t\t\t\"last_entry_t\": %lu,\n"
+			"\t\t\t\t\t\"collected_value\": " COLLECTED_NUMBER_FORMAT ",\n"
+			"\t\t\t\t\t\"calculated_value\": " CALCULATED_NUMBER_FORMAT ",\n"
+			"\t\t\t\t\t\"last_collected_value\": " COLLECTED_NUMBER_FORMAT ",\n"
+			"\t\t\t\t\t\"last_calculated_value\": " CALCULATED_NUMBER_FORMAT ",\n"
+			"\t\t\t\t\t\"memory\": %lu\n"
+			"\t\t\t\t}%s\n"
+			, rd->id
+			, rd->name
+			, rd->entries
+			, (rd->flags & RRDDIM_FLAG_HIDDEN)?1:0
+			, rrddim_algorithm_name(rd->algorithm)
+			, rd->multiplier
+			, rd->divisor
+			, rd->last_collected_time.tv_sec
+			, rd->collected_value
+			, rd->calculated_value
+			, rd->last_collected_value
+			, rd->last_calculated_value
+			, rd->memsize
+			, rd->next?",":""
+			);
+	}
+
+	buffer_sprintf(wb,
+		"\t\t\t],\n"
+		"\t\t\t\"memory\" : %lu\n"
+		"\t\t}"
+		, memory
+		);
+
+	pthread_rwlock_unlock(&st->rwlock);
+	return memory;
+}
+
+#define RRD_GRAPH_JSON_HEADER "{\n\t\"charts\": [\n"
+#define RRD_GRAPH_JSON_FOOTER "\n\t]\n}\n"
+
+void rrd_stats_graph_json(RRDSET *st, char *options, BUFFER *wb)
+{
+	buffer_strcat(wb, RRD_GRAPH_JSON_HEADER);
+	rrd_stats_one_json(st, options, wb);
+	buffer_strcat(wb, RRD_GRAPH_JSON_FOOTER);
+}
+
+void rrd_stats_all_json(BUFFER *wb)
+{
+	unsigned long memory = 0;
+	long c;
+	RRDSET *st;
+
+	buffer_strcat(wb, RRD_GRAPH_JSON_HEADER);
+
+	pthread_rwlock_rdlock(&rrdset_root_rwlock);
+	for(st = rrdset_root, c = 0; st ; st = st->next) {
+		if(st->enabled) {
+			if(c) buffer_strcat(wb, ",\n");
+			memory += rrd_stats_one_json(st, NULL, wb);
+			c++;
+		}
+	}
+	pthread_rwlock_unlock(&rrdset_root_rwlock);
+
+	buffer_sprintf(wb, "\n\t],\n"
+		"\t\"hostname\": \"%s\",\n"
+		"\t\"update_every\": %d,\n"
+		"\t\"history\": %d,\n"
+		"\t\"memory\": %lu\n"
+		"}\n"
+		, hostname
+		, rrd_update_every
+		, rrd_default_history_entries
+		, memory
+		);
+}
+
+
+
+// ----------------------------------------------------------------------------
+
+// RRDR dimension options
+#define RRDR_EMPTY  	0x01 // the dimension contains / the value is empty (null)
+#define RRDR_RESET  	0x02 // the dimension contains / the value is reset
+#define RRDR_HIDDEN 	0x04 // the dimension contains / the value is hidden
+#define RRDR_NONZERO 	0x08 // the dimension contains / the value is non-zero
+
+// RRDR result options
+#define RRDR_RESULT_OPTION_ABSOLUTE 0x00000001
+#define RRDR_RESULT_OPTION_RELATIVE 0x00000002
+
+typedef struct rrdresult {
+	RRDSET *st;			// the chart this result refers to
+
+	uint32_t result_options;	// RRDR_RESULT_OPTION_*
+
+	int d;					// the number of dimensions
+	long n;					// the number of values in the arrays
+	long rows;			    // the number of rows used
+
+	uint8_t *od;			// the options for the dimensions
+
+	time_t *t;				// array of n timestamps
+	calculated_number *v;	// array n x d values
+	uint8_t *o;				// array n x d options
+
+	long c;					// current line ( -1 ~ n ), ( -1 = none, use rrdr_rows() to get number of rows )
+
+	long group;				// how many collected values were grouped for each row
+	long update_every;		// what is the suggested update frequency in seconds
+
+	calculated_number min;
+	calculated_number max;
+
+	time_t before;
+	time_t after;
+
+	int has_st_lock;		// if st is read locked by us
+} RRDR;
+
+#define rrdr_rows(r) ((r)->rows)
+
+/*
+static void rrdr_dump(RRDR *r)
+{
+	long c, i;
+	RRDDIM *d;
+
+	fprintf(stderr, "\nCHART %s (%s)\n", r->st->id, r->st->name);
+
+	for(c = 0, d = r->st->dimensions; d ;c++, d = d->next) {
+		fprintf(stderr, "DIMENSION %s (%s), %s%s%s%s\n"
+				, d->id
+				, d->name
+				, (r->od[c] & RRDR_EMPTY)?"EMPTY ":""
+				, (r->od[c] & RRDR_RESET)?"RESET ":""
+				, (r->od[c] & RRDR_HIDDEN)?"HIDDEN ":""
+				, (r->od[c] & RRDR_NONZERO)?"NONZERO ":""
+				);
+	}
+
+	if(r->rows <= 0) {
+		fprintf(stderr, "RRDR does not have any values in it.\n");
+		return;
+	}
+
+	fprintf(stderr, "RRDR includes %d values in it:\n", r->rows);
+
+	// for each line in the array
+	for(i = 0; i < r->rows ;i++) {
+		calculated_number *cn = &r->v[ i * r->d ];
+		uint8_t *co = &r->o[ i * r->d ];
+
+		// print the id and the timestamp of the line
+		fprintf(stderr, "%ld %ld ", i + 1, r->t[i]);
+
+		// for each dimension
+		for(c = 0, d = r->st->dimensions; d ;c++, d = d->next) {
+			if(unlikely(r->od[c] & RRDR_HIDDEN)) continue;
+			if(unlikely(!(r->od[c] & RRDR_NONZERO))) continue;
+
+			if(co[c] & RRDR_EMPTY)
+				fprintf(stderr, "null ");
+			else
+				fprintf(stderr, CALCULATED_NUMBER_FORMAT " %s%s%s%s "
+					, cn[c]
+					, (co[c] & RRDR_EMPTY)?"E":" "
+					, (co[c] & RRDR_RESET)?"R":" "
+					, (co[c] & RRDR_HIDDEN)?"H":" "
+					, (co[c] & RRDR_NONZERO)?"N":" "
+					);
+		}
+
+		fprintf(stderr, "\n");
+	}
+}
+*/
+
+void rrdr_disable_not_selected_dimensions(RRDR *r, const char *dims)
+{
+	char b[strlen(dims) + 1];
+	char *o = b, *tok;
+	strcpy(o, dims);
+
+	long c;
+	RRDDIM *d;
+
+	// disable all of them
+	for(c = 0, d = r->st->dimensions; d ;c++, d = d->next)
+		r->od[c] |= RRDR_HIDDEN;
+
+	while(o && *o && (tok = mystrsep(&o, ", |"))) {
+		if(!*tok) continue;
+
+		// find it and enable it
+		for(c = 0, d = r->st->dimensions; d ;c++, d = d->next) {
+			if(!strcmp(d->name, tok)) {
+				r->od[c] &= ~RRDR_HIDDEN;
+
+				// since the user needs this dimension
+				// make it appear as NONZERO, to return it
+				// even if the dimension has only zeros
+				r->od[c] |= RRDR_NONZERO;
+			}
+		}
+	}
+}
+
+void rrdr_buffer_print_format(BUFFER *wb, uint32_t format)
+{
+	switch(format) {
+	case DATASOURCE_JSON:
+		buffer_strcat(wb, DATASOURCE_FORMAT_JSON);
+		break;
+
+	case DATASOURCE_DATATABLE_JSON:
+		buffer_strcat(wb, DATASOURCE_FORMAT_DATATABLE_JSON);
+		break;
+
+	case DATASOURCE_DATATABLE_JSONP:
+		buffer_strcat(wb, DATASOURCE_FORMAT_DATATABLE_JSONP);
+		break;
+
+	case DATASOURCE_JSONP:
+		buffer_strcat(wb, DATASOURCE_FORMAT_JSONP);
+		break;
+
+	case DATASOURCE_SSV:
+		buffer_strcat(wb, DATASOURCE_FORMAT_SSV);
+		break;
+
+	case DATASOURCE_CSV:
+		buffer_strcat(wb, DATASOURCE_FORMAT_CSV);
+		break;
+
+	case DATASOURCE_TSV:
+		buffer_strcat(wb, DATASOURCE_FORMAT_TSV);
+		break;
+
+	case DATASOURCE_HTML:
+		buffer_strcat(wb, DATASOURCE_FORMAT_HTML);
+		break;
+
+	case DATASOURCE_JS_ARRAY:
+		buffer_strcat(wb, DATASOURCE_FORMAT_JS_ARRAY);
+		break;
+
+	case DATASOURCE_SSV_COMMA:
+		buffer_strcat(wb, DATASOURCE_FORMAT_SSV_COMMA);
+		break;
+
+	default:
+		buffer_strcat(wb, "unknown");
+		break;
+	}
+}
+
+uint32_t rrdr_check_options(RRDR *r, uint32_t options, const char *dims)
+{
+	if(options & RRDR_OPTION_NONZERO) {
+		long i;
+
+		if(dims && *dims) {
+			// the caller wants specific dimensions
+			// disable NONZERO option
+			// to make sure we don't accidentally prevent
+			// the specific dimensions from being returned
+			i = 0;
+		}
+		else {
+			// find how many dimensions are not zero
+			long c;
+			RRDDIM *rd;
+			for(c = 0, i = 0, rd = r->st->dimensions; rd && c < r->d ; c++, rd = rd->next) {
+				if(unlikely(r->od[c] & RRDR_HIDDEN)) continue;
+				if(unlikely(!(r->od[c] & RRDR_NONZERO))) continue;
+				i++;
+			}
+		}
+
+		// if with nonzero we get i = 0 (no dimensions will be returned)
+		// disable nonzero to show all dimensions
+		if(!i) options &= ~RRDR_OPTION_NONZERO;
+	}
+
+	return options;
+}
+
+void rrdr_json_wrapper_begin(RRDR *r, BUFFER *wb, uint32_t format, uint32_t options, int string_value)
+{
+	long rows = rrdr_rows(r);
+	long c, i;
+	RRDDIM *rd;
+
+	//info("JSONWRAPPER(): %s: BEGIN", r->st->id);
+	char kq[2] = "",					// key quote
+		sq[2] = "";						// string quote
+
+	if( options & RRDR_OPTION_GOOGLE_JSON ) {
+		kq[0] = '\0';
+		sq[0] = '\'';
+	}
+	else {
+		kq[0] = '"';
+		sq[0] = '"';
+	}
+
+	buffer_sprintf(wb, "{\n"
+			"	%sapi%s: 1,\n"
+			"	%sid%s: %s%s%s,\n"
+			"	%sname%s: %s%s%s,\n"
+			"	%sview_update_every%s: %d,\n"
+			"	%supdate_every%s: %d,\n"
+			"	%sfirst_entry%s: %u,\n"
+			"	%slast_entry%s: %u,\n"
+			"	%sbefore%s: %u,\n"
+			"	%safter%s: %u,\n"
+			"	%sdimension_names%s: ["
+			, kq, kq
+			, kq, kq, sq, r->st->id, sq
+			, kq, kq, sq, r->st->name, sq
+			, kq, kq, r->update_every
+			, kq, kq, r->st->update_every
+			, kq, kq, rrdset_first_entry_t(r->st)
+			, kq, kq, rrdset_last_entry_t(r->st)
+			, kq, kq, r->before
+			, kq, kq, r->after
+			, kq, kq);
+
+	for(c = 0, i = 0, rd = r->st->dimensions; rd && c < r->d ;c++, rd = rd->next) {
+		if(unlikely(r->od[c] & RRDR_HIDDEN)) continue;
+		if(unlikely((options & RRDR_OPTION_NONZERO) && !(r->od[c] & RRDR_NONZERO))) continue;
+
+		if(i) buffer_strcat(wb, ", ");
+		buffer_strcat(wb, sq);
+		buffer_strcat(wb, rd->name);
+		buffer_strcat(wb, sq);
+		i++;
+	}
+	if(!i) {
+#ifdef NETDATA_INTERNAL_CHECKS
+		error("RRDR is empty for %s (RRDR has %d dimensions, options is 0x%08x)", r->st->id, r->d, options);
+#endif
+		rows = 0;
+		buffer_strcat(wb, sq);
+		buffer_strcat(wb, "no data");
+		buffer_strcat(wb, sq);
+	}
+
+	buffer_sprintf(wb, "],\n"
+			"	%sdimension_ids%s: ["
+			, kq, kq);
+
+	for(c = 0, i = 0, rd = r->st->dimensions; rd && c < r->d ;c++, rd = rd->next) {
+		if(unlikely(r->od[c] & RRDR_HIDDEN)) continue;
+		if(unlikely((options & RRDR_OPTION_NONZERO) && !(r->od[c] & RRDR_NONZERO))) continue;
+
+		if(i) buffer_strcat(wb, ", ");
+		buffer_strcat(wb, sq);
+		buffer_strcat(wb, rd->id);
+		buffer_strcat(wb, sq);
+		i++;
+	}
+	if(!i) {
+		rows = 0;
+		buffer_strcat(wb, sq);
+		buffer_strcat(wb, "no data");
+		buffer_strcat(wb, sq);
+	}
+
+	buffer_sprintf(wb, "],\n"
+			"	%slatest_values%s: ["
+			, kq, kq);
+
+	for(c = 0, i = 0, rd = r->st->dimensions; rd && c < r->d ;c++, rd = rd->next) {
+		if(unlikely(r->od[c] & RRDR_HIDDEN)) continue;
+		if(unlikely((options & RRDR_OPTION_NONZERO) && !(r->od[c] & RRDR_NONZERO))) continue;
+
+		if(i) buffer_strcat(wb, ", ");
+		i++;
+
+		storage_number n = rd->values[rrdset_last_slot(r->st)];
+
+		if(!does_storage_number_exist(n))
+			buffer_strcat(wb, "null");
+		else
+			buffer_rrd_value(wb, unpack_storage_number(n));
+	}
+	if(!i) {
+		rows = 0;
+		buffer_strcat(wb, "null");
+	}
+
+	buffer_sprintf(wb, "],\n"
+			"	%sview_latest_values%s: ["
+			, kq, kq);
+
+	i = 0;
+	if(rows) {
+		for(c = 0, i = 0, rd = r->st->dimensions; rd && c < r->d ;c++, rd = rd->next) {
+			if(unlikely(r->od[c] & RRDR_HIDDEN)) continue;
+			if(unlikely((options & RRDR_OPTION_NONZERO) && !(r->od[c] & RRDR_NONZERO))) continue;
+
+			if(i) buffer_strcat(wb, ", ");
+			i++;
+
+			calculated_number *cn = &r->v[ (0) * r->d ];
+			uint8_t *co = &r->o[ (0) * r->d ];
+
+			if(co[c] & RRDR_EMPTY)
+				buffer_strcat(wb, "null");
+			else
+				buffer_rrd_value(wb, cn[c]);
+		}
+	}
+	if(!i) {
+		rows = 0;
+		buffer_strcat(wb, "null");
+	}
+
+	buffer_sprintf(wb, "],\n"
+			"	%sdimensions%s: %d,\n"
+			"	%spoints%s: %d,\n"
+			"	%sformat%s: %s"
+			, kq, kq, i
+			, kq, kq, rows
+			, kq, kq, sq
+			);
+
+	rrdr_buffer_print_format(wb, format);
+
+	buffer_sprintf(wb, "%s,\n"
+			"	%sresult%s: "
+			, sq
+			, kq, kq
+			);
+
+	if(string_value) buffer_strcat(wb, sq);
+	//info("JSONWRAPPER(): %s: END", r->st->id);
+}
+
+void rrdr_json_wrapper_end(RRDR *r, BUFFER *wb, uint32_t format, uint32_t options, int string_value)
+{
+	if(r) {;}
+	if(format) {;}
+
+	char kq[2] = "",					// key quote
+		sq[2] = "";						// string quote
+
+	if( options & RRDR_OPTION_GOOGLE_JSON ) {
+		kq[0] = '\0';
+		sq[0] = '\'';
+	}
+	else {
+		kq[0] = '"';
+		sq[0] = '"';
+	}
+
+	if(string_value) buffer_strcat(wb, sq);
+
+	buffer_sprintf(wb, ",\n	%smin%s: ", kq, kq);
+	buffer_rrd_value(wb, r->min);
+	buffer_sprintf(wb, ",\n	%smax%s: ", kq, kq);
+	buffer_rrd_value(wb, r->max);
+	buffer_strcat(wb, "\n}\n");
+}
+
+#define JSON_DATES_JS 1
+#define JSON_DATES_TIMESTAMP 2
+
+static void rrdr2json(RRDR *r, BUFFER *wb, uint32_t options, int datatable)
+{
+	//info("RRD2JSON(): %s: BEGIN", r->st->id);
+	int row_annotations = 0, dates, dates_with_new = 0;
+	char kq[2] = "",					// key quote
+		sq[2] = "",						// string quote
+		pre_label[101] = "",			// before each label
+		post_label[101] = "",			// after each label
+		pre_date[101] = "",				// the beginning of line, to the date
+		post_date[101] = "",			// closing the date
+		pre_value[101] = "",			// before each value
+		post_value[101] = "",			// after each value
+		post_line[101] = "",			// at the end of each row
+		normal_annotation[201] = "",	// default row annotation
+		overflow_annotation[201] = "",	// overflow row annotation
+		data_begin[101] = "",			// between labels and values
+		finish[101] = "";				// at the end of everything
+
+	if(datatable) {
+		dates = JSON_DATES_JS;
+		if( options & RRDR_OPTION_GOOGLE_JSON ) {
+			kq[0] = '\0';
+			sq[0] = '\'';
+		}
+		else {
+			kq[0] = '"';
+			sq[0] = '"';
+		}
+		row_annotations = 1;
+		snprintf(pre_date,   100, "		{%sc%s:[{%sv%s:%s", kq, kq, kq, kq, sq);
+		snprintf(post_date,  100, "%s}", sq);
+		snprintf(pre_label,  100, ",\n		{%sid%s:%s%s,%slabel%s:%s", kq, kq, sq, sq, kq, kq, sq);
+		snprintf(post_label, 100, "%s,%spattern%s:%s%s,%stype%s:%snumber%s}", sq, kq, kq, sq, sq, kq, kq, sq, sq);
+		snprintf(pre_value,  100, ",{%sv%s:", kq, kq);
+		snprintf(post_value, 100, "}");
+		snprintf(post_line,  100, "]}");
+		snprintf(data_begin, 100, "\n	],\n	%srows%s:\n	[\n", kq, kq);
+		snprintf(finish,     100, "\n	]\n}");
+
+		snprintf(overflow_annotation, 200, ",{%sv%s:%sRESET OR OVERFLOW%s},{%sv%s:%sThe counters have been wrapped.%s}", kq, kq, sq, sq, kq, kq, sq, sq);
+		snprintf(normal_annotation,   200, ",{%sv%s:null},{%sv%s:null}", kq, kq, kq, kq);
+
+		buffer_sprintf(wb, "{\n	%scols%s:\n	[\n", kq, kq, kq, kq);
+		buffer_sprintf(wb, "		{%sid%s:%s%s,%slabel%s:%stime%s,%spattern%s:%s%s,%stype%s:%sdatetime%s},\n", kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, sq, sq);
+		buffer_sprintf(wb, "		{%sid%s:%s%s,%slabel%s:%s%s,%spattern%s:%s%s,%stype%s:%sstring%s,%sp%s:{%srole%s:%sannotation%s}},\n", kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, kq, kq, sq, sq);
+		buffer_sprintf(wb, "		{%sid%s:%s%s,%slabel%s:%s%s,%spattern%s:%s%s,%stype%s:%sstring%s,%sp%s:{%srole%s:%sannotationText%s}}", kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, kq, kq, sq, sq);
+
+		// remove the valueobjects flag
+		// google wants its own keys
+		if(options & RRDR_OPTION_OBJECTSROWS)
+			options &= ~RRDR_OPTION_OBJECTSROWS;
+	}
+	else {
+		kq[0] = '"';
+		sq[0] = '"';
+		if((options & RRDR_OPTION_SECONDS) || (options & RRDR_OPTION_MILLISECONDS)) {
+			dates = JSON_DATES_TIMESTAMP;
+			dates_with_new = 0;
+		}
+		else {
+			dates = JSON_DATES_JS;
+			dates_with_new = 1;
+		}
+		if( options & RRDR_OPTION_OBJECTSROWS )
+			snprintf(pre_date,   100, "		{ ");
+		else
+			snprintf(pre_date,   100, "		[ ");
+		snprintf(pre_label,  100, ", \"");
+		snprintf(post_label, 100, "\"");
+		snprintf(pre_value,  100, ", ");
+		if( options & RRDR_OPTION_OBJECTSROWS )
+			snprintf(post_line,  100, "}");
+		else
+			snprintf(post_line,  100, "]");
+		snprintf(data_begin, 100, "],\n	%sdata%s:\n	[\n", kq, kq);
+		snprintf(finish,     100, "\n	]\n}");
+
+		buffer_sprintf(wb, "{\n	%slabels%s: [", kq, kq);
+		buffer_sprintf(wb, "%stime%s", sq, sq);
+	}
+
+	// -------------------------------------------------------------------------
+	// print the JSON header
+
+	long c, i;
+	RRDDIM *rd;
+
+	// print the header lines
+	for(c = 0, i = 0, rd = r->st->dimensions; rd && c < r->d ;c++, rd = rd->next) {
+		if(unlikely(r->od[c] & RRDR_HIDDEN)) continue;
+		if(unlikely((options & RRDR_OPTION_NONZERO) && !(r->od[c] & RRDR_NONZERO))) continue;
+
+		buffer_strcat(wb, pre_label);
+		buffer_strcat(wb, rd->name);
+		buffer_strcat(wb, post_label);
+		i++;
+	}
+	if(!i) {
+		buffer_strcat(wb, pre_label);
+		buffer_strcat(wb, "no data");
+		buffer_strcat(wb, post_label);
+	}
+
+	// print the begin of row data
+	buffer_strcat(wb, data_begin);
+
+	// if all dimensions are hidden, print a null
+	if(!i) {
+		buffer_strcat(wb, finish);
+		return;
+	}
+
+	long start = 0, end = rrdr_rows(r), step = 1;
+	if((options & RRDR_OPTION_REVERSED)) {
+		start = rrdr_rows(r) - 1;
+		end = -1;
+		step = -1;
+	}
+
+	// for each line in the array
+	calculated_number total = 1;
+	for(i = start; i != end ;i += step) {
+		calculated_number *cn = &r->v[ i * r->d ];
+		uint8_t *co = &r->o[ i * r->d ];
+
+		time_t now = r->t[i];
+
+		if(dates == JSON_DATES_JS) {
+			// generate the local date time
+			struct tm tmbuf, *tm = localtime_r(&now, &tmbuf);
+			if(!tm) { error("localtime_r() failed."); continue; }
+
+			if(likely(i != start)) buffer_strcat(wb, ",\n");
+			buffer_strcat(wb, pre_date);
+
+			if( options & RRDR_OPTION_OBJECTSROWS )
+				buffer_sprintf(wb, "%stime%s: ", kq, kq);
+
+			if(dates_with_new)
+				buffer_strcat(wb, "new ");
+
+			buffer_jsdate(wb, tm->tm_year + 1900, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
+
+			buffer_strcat(wb, post_date);
+
+			if(row_annotations) {
+				// google supports one annotation per row
+				int annotation_found = 0;
+				for(c = 0, rd = r->st->dimensions; rd ;c++, rd = rd->next) {
+					if(co[c] & RRDR_RESET) {
+						buffer_strcat(wb, overflow_annotation);
+						annotation_found = 1;
+						break;
+					}
+				}
+				if(!annotation_found)
+					buffer_strcat(wb, normal_annotation);
+			}
+		}
+		else {
+			// print the timestamp of the line
+			if(likely(i != start)) buffer_strcat(wb, ",\n");
+			buffer_strcat(wb, pre_date);
+
+			if( options & RRDR_OPTION_OBJECTSROWS )
+				buffer_sprintf(wb, "%stime%s: ", kq, kq);
+
+			buffer_rrd_value(wb, (calculated_number)r->t[i]);
+			// in ms
+			if(options & RRDR_OPTION_MILLISECONDS) buffer_strcat(wb, "000");
+
+			buffer_strcat(wb, post_date);
+		}
+
+		if(unlikely(options & RRDR_OPTION_PERCENTAGE)) {
+			total = 0;
+			for(c = 0, rd = r->st->dimensions; rd && c < r->d ;c++, rd = rd->next) {
+				calculated_number n = cn[c];
+
+				if(likely((options & RRDR_OPTION_ABSOLUTE) && n < 0))
+					n = -n;
+
+				total += n;
+			}
+			// prevent a division by zero
+			if(total == 0) total = 1;
+		}
+
+		// for each dimension
+		for(c = 0, rd = r->st->dimensions; rd && c < r->d ;c++, rd = rd->next) {
+			if(unlikely(r->od[c] & RRDR_HIDDEN)) continue;
+			if(unlikely((options & RRDR_OPTION_NONZERO) && !(r->od[c] & RRDR_NONZERO))) continue;
+
+			calculated_number n = cn[c];
+
+			buffer_strcat(wb, pre_value);
+
+			if( options & RRDR_OPTION_OBJECTSROWS )
+				buffer_sprintf(wb, "%s%s%s: ", kq, rd->name, kq);
+
+			if(co[c] & RRDR_EMPTY) {
+				if(options & RRDR_OPTION_NULL2ZERO)
+					buffer_strcat(wb, "0");
+				else
+					buffer_strcat(wb, "null");
+			}
+			else {
+				if(unlikely((options & RRDR_OPTION_ABSOLUTE) && n < 0))
+					n = -n;
+
+				if(unlikely(options & RRDR_OPTION_PERCENTAGE))
+					n = n * 100 / total;
+
+				buffer_rrd_value(wb, n);
+			}
+
+			buffer_strcat(wb, post_value);
+		}
+
+		buffer_strcat(wb, post_line);
+	}
+
+	buffer_strcat(wb, finish);
+	//info("RRD2JSON(): %s: END", r->st->id);
+}
+
+static void rrdr2csv(RRDR *r, BUFFER *wb, uint32_t options, const char *startline, const char *separator, const char *endline, const char *betweenlines)
+{
+	//info("RRD2CSV(): %s: BEGIN", r->st->id);
+	long c, i;
+	RRDDIM *d;
+
+	// print the csv header
+	for(c = 0, i = 0, d = r->st->dimensions; d && c < r->d ;c++, d = d->next) {
+		if(unlikely(r->od[c] & RRDR_HIDDEN)) continue;
+		if(unlikely((options & RRDR_OPTION_NONZERO) && !(r->od[c] & RRDR_NONZERO))) continue;
+
+		if(!i) {
+			buffer_strcat(wb, startline);
+			if(options & RRDR_OPTION_LABEL_QUOTES) buffer_strcat(wb, "\"");
+			buffer_strcat(wb, "time");
+			if(options & RRDR_OPTION_LABEL_QUOTES) buffer_strcat(wb, "\"");
+		}
+		buffer_strcat(wb, separator);
+		if(options & RRDR_OPTION_LABEL_QUOTES) buffer_strcat(wb, "\"");
+		buffer_strcat(wb, d->name);
+		if(options & RRDR_OPTION_LABEL_QUOTES) buffer_strcat(wb, "\"");
+		i++;
+	}
+	buffer_strcat(wb, endline);
+
+	if(!i) {
+		// no dimensions present
+		return;
+	}
+
+	long start = 0, end = rrdr_rows(r), step = 1;
+	if((options & RRDR_OPTION_REVERSED)) {
+		start = rrdr_rows(r) - 1;
+		end = -1;
+		step = -1;
+	}
+
+	// for each line in the array
+	calculated_number total = 1;
+	for(i = start; i != end ;i += step) {
+		calculated_number *cn = &r->v[ i * r->d ];
+		uint8_t *co = &r->o[ i * r->d ];
+
+		buffer_strcat(wb, betweenlines);
+		buffer_strcat(wb, startline);
+
+		time_t now = r->t[i];
+
+		if((options & RRDR_OPTION_SECONDS) || (options & RRDR_OPTION_MILLISECONDS)) {
+			// print the timestamp of the line
+			buffer_rrd_value(wb, (calculated_number)now);
+			// in ms
+			if(options & RRDR_OPTION_MILLISECONDS) buffer_strcat(wb, "000");
+		}
+		else {
+			// generate the local date time
+			struct tm tmbuf, *tm = localtime_r(&now, &tmbuf);
+			if(!tm) { error("localtime() failed."); continue; }
+			buffer_date(wb, tm->tm_year + 1900, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
+		}
+
+		if(unlikely(options & RRDR_OPTION_PERCENTAGE)) {
+			total = 0;
+			for(c = 0, d = r->st->dimensions; d && c < r->d ;c++, d = d->next) {
+				calculated_number n = cn[c];
+
+				if(likely((options & RRDR_OPTION_ABSOLUTE) && n < 0))
+					n = -n;
+
+				total += n;
+			}
+			// prevent a division by zero
+			if(total == 0) total = 1;
+		}
+
+		// for each dimension
+		for(c = 0, d = r->st->dimensions; d && c < r->d ;c++, d = d->next) {
+			if(unlikely(r->od[c] & RRDR_HIDDEN)) continue;
+			if(unlikely((options & RRDR_OPTION_NONZERO) && !(r->od[c] & RRDR_NONZERO))) continue;
+
+			buffer_strcat(wb, separator);
+
+			calculated_number n = cn[c];
+
+			if(co[c] & RRDR_EMPTY) {
+				if(options & RRDR_OPTION_NULL2ZERO)
+					buffer_strcat(wb, "0");
+				else
+					buffer_strcat(wb, "null");
+			}
+			else {
+				if(unlikely((options & RRDR_OPTION_ABSOLUTE) && n < 0))
+					n = -n;
+
+				if(unlikely(options & RRDR_OPTION_PERCENTAGE))
+					n = n * 100 / total;
+
+				buffer_rrd_value(wb, n);
+			}
+		}
+
+		buffer_strcat(wb, endline);
+	}
+	//info("RRD2CSV(): %s: END", r->st->id);
+}
+
+static void rrdr2ssv(RRDR *r, BUFFER *wb, uint32_t options, const char *prefix, const char *separator, const char *suffix)
+{
+	//info("RRD2SSV(): %s: BEGIN", r->st->id);
+	long c, i;
+	RRDDIM *d;
+
+	buffer_strcat(wb, prefix);
+	long start = 0, end = rrdr_rows(r), step = 1;
+	if((options & RRDR_OPTION_REVERSED)) {
+		start = rrdr_rows(r) - 1;
+		end = -1;
+		step = -1;
+	}
+
+	// for each line in the array
+	calculated_number total = 1;
+	for(i = start; i != end ;i += step) {
+
+		calculated_number *cn = &r->v[ i * r->d ];
+		uint8_t *co = &r->o[ i * r->d ];
+
+		calculated_number sum = 0, min = 0, max = 0, v;
+		int all_null = 1, init = 1;
+
+		if(unlikely(options & RRDR_OPTION_PERCENTAGE)) {
+			total = 0;
+			for(c = 0, d = r->st->dimensions; d && c < r->d ;c++, d = d->next) {
+				calculated_number n = cn[c];
+
+				if(likely((options & RRDR_OPTION_ABSOLUTE) && n < 0))
+					n = -n;
+
+				total += n;
+			}
+			// prevent a division by zero
+			if(total == 0) total = 1;
+		}
+
+		// for each dimension
+		for(c = 0, d = r->st->dimensions; d && c < r->d ;c++, d = d->next) {
+			if(unlikely(r->od[c] & RRDR_HIDDEN)) continue;
+			if(unlikely((options & RRDR_OPTION_NONZERO) && !(r->od[c] & RRDR_NONZERO))) continue;
+
+			calculated_number n = cn[c];
+
+			if(likely((options & RRDR_OPTION_ABSOLUTE) && n < 0))
+				n = -n;
+
+			if(unlikely(options & RRDR_OPTION_PERCENTAGE))
+				n = n * 100 / total;
+
+			if(unlikely(init)) {
+				if(n > 0) {
+					min = 0;
+					max = n;
+				}
+				else {
+					min = n;
+					max = 0;
+				}
+				init = 0;
+			}
+
+			if(likely(!(co[c] & RRDR_EMPTY))) {
+				all_null = 0;
+				sum += n;
+			}
+
+			if(n < min) min = n;
+			if(n > max) max = n;
+		}
+
+		if(likely(i != start))
+			buffer_strcat(wb, separator);
+
+		if(all_null) {
+			if(options & RRDR_OPTION_NULL2ZERO)
+				buffer_strcat(wb, "0");
+			else
+				buffer_strcat(wb, "null");
+		}
+		else {
+			if(options & RRDR_OPTION_MIN2MAX)
+				v = max - min;
+			else
+				v = sum;
+
+			if(likely(i != start)) {
+				if(r->min > v) r->min = v;
+				if(r->max < v) r->max = v;
+			}
+			else {
+				r->min = v;
+				r->max = v;
+			}
+
+			buffer_rrd_value(wb, v);
+		}
+	}
+	buffer_strcat(wb, suffix);
+	//info("RRD2SSV(): %s: END", r->st->id);
+}
+
+inline static calculated_number *rrdr_line_values(RRDR *r)
+{
+	return &r->v[ r->c * r->d ];
+}
+
+inline static uint8_t *rrdr_line_options(RRDR *r)
+{
+	return &r->o[ r->c * r->d ];
+}
+
+inline static int rrdr_line_init(RRDR *r, time_t t)
+{
+	r->c++;
+
+	if(unlikely(r->c >= r->n)) {
+		error("requested to step above RRDR size for chart %s", r->st->name);
+		r->c = r->n - 1;
+	}
+
+	// save the time
+	r->t[r->c] = t;
+
+	return 1;
+}
+
+inline static void rrdr_lock_rrdset(RRDR *r) {
+	if(unlikely(!r)) {
+		error("NULL value given!");
+		return;
+	}
+
+	pthread_rwlock_rdlock(&r->st->rwlock);
+	r->has_st_lock = 1;
+}
+
+inline static void rrdr_unlock_rrdset(RRDR *r) {
+	if(unlikely(!r)) {
+		error("NULL value given!");
+		return;
+	}
+
+	if(likely(r->has_st_lock)) {
+		pthread_rwlock_unlock(&r->st->rwlock);
+		r->has_st_lock = 0;
+	}
+}
+
+inline static void rrdr_free(RRDR *r)
+{
+	if(unlikely(!r)) {
+		error("NULL value given!");
+		return;
+	}
+
+	rrdr_unlock_rrdset(r);
+	if(likely(r->t)) free(r->t);
+	if(likely(r->v)) free(r->v);
+	if(likely(r->o)) free(r->o);
+	if(likely(r->od)) free(r->od);
+	free(r);
+}
+
+inline void rrdr_done(RRDR *r)
+{
+	r->rows = r->c + 1;
+	r->c = 0;
+}
+
+static RRDR *rrdr_create(RRDSET *st, long n)
+{
+	if(unlikely(!st)) {
+		error("NULL value given!");
+		return NULL;
+	}
+
+	RRDR *r = calloc(1, sizeof(RRDR));
+	if(unlikely(!r)) goto cleanup;
+
+	r->st = st;
+
+	rrdr_lock_rrdset(r);
+
+	RRDDIM *rd;
+	for(rd = st->dimensions ; rd ; rd = rd->next) r->d++;
+
+	r->n = n;
+
+	r->t = malloc(n * sizeof(time_t));
+	if(unlikely(!r->t)) goto cleanup;
+
+	r->v = malloc(n * r->d * sizeof(calculated_number));
+	if(unlikely(!r->v)) goto cleanup;
+
+	r->o = malloc(n * r->d * sizeof(uint8_t));
+	if(unlikely(!r->o)) goto cleanup;
+
+	r->od = malloc(r->d * sizeof(uint8_t));
+	if(unlikely(!r->od)) goto cleanup;
+
+	// set the hidden flag on hidden dimensions
+	int c;
+	for(c = 0, rd = st->dimensions ; rd ; c++, rd = rd->next) {
+		if(unlikely(rd->flags & RRDDIM_FLAG_HIDDEN)) r->od[c] = RRDR_HIDDEN;
+		else r->od[c] = 0;
+	}
+
+	r->c = -1;
+
+	r->group = 1;
+	r->update_every = 1;
+
+	return r;
+
+cleanup:
+	error("Cannot allocate RRDR memory for %d entries", n);
+	if(likely(r)) rrdr_free(r);
+	return NULL;
+}
+
+RRDR *rrd2rrdr(RRDSET *st, long points, long long after, long long before, int group_method)
+{
+	int debug = st->debug;
+	int absolute_period_requested = -1;
+
+	time_t first_entry_t = rrdset_first_entry_t(st);
+	time_t last_entry_t = rrdset_last_entry_t(st);
+
+	if(before == 0 && after == 0) {
+		before = last_entry_t;
+		after = first_entry_t;
+		absolute_period_requested = 0;
+	}
+
+	// allow relative for before and after
+	if(before <= st->update_every * st->entries) {
+		before = last_entry_t + before;
+		absolute_period_requested = 0;
+	}
+
+	if(after <= st->update_every * st->entries) {
+		after = last_entry_t + after;
+		absolute_period_requested = 0;
+	}
+
+	if(absolute_period_requested == -1)
+		absolute_period_requested = 1;
+
+	// make sure they are within our timeframe
+	if(before > last_entry_t) before = last_entry_t;
+	if(before < first_entry_t) before = first_entry_t;
+
+	if(after > last_entry_t) after = last_entry_t;
+	if(after < first_entry_t) after = first_entry_t;
+
+	// check if they are upside down
+	if(after > before) {
+		time_t tmp = before;
+		before = after;
+		after = tmp;
+	}
+
+	// the duration of the chart
+	time_t duration = before - after;
+	long available_points = duration / st->update_every;
+
+	if(duration <= 0 || available_points <= 0)
+		return rrdr_create(st, 1);
+
+	// check the wanted points
+	if(points < 0) points = -points;
+	if(points > available_points) points = available_points;
+	if(points == 0) points = available_points;
+
+	// calculate proper grouping of source data
+	long group = available_points / points;
+	if(group <= 0) group = 1;
+
+	// round group to the closest integer
+	if(available_points % points > points / 2) group++;
+
+	time_t after_new = after - (after % (group * st->update_every));
+	time_t before_new = before - (before % (group * st->update_every));
+	long points_new = (before_new - after_new) / st->update_every / group;
+
+	// find the starting and ending slots in our round robin db
+	long    start_at_slot = rrdset_time2slot(st, before_new),
+			stop_at_slot = rrdset_time2slot(st, after_new);
+
+#ifdef NETDATA_INTERNAL_CHECKS
+	if(after_new < first_entry_t) {
+		error("after_new %u is too small, minimum %u", after_new, first_entry_t);
+	}
+	if(after_new > last_entry_t) {
+		error("after_new %u is too big, maximum %u", after_new, last_entry_t);
+	}
+	if(before_new < first_entry_t) {
+		error("before_new %u is too small, minimum %u", before_new, first_entry_t);
+	}
+	if(before_new > last_entry_t) {
+		error("before_new %u is too big, maximum %u", before_new, last_entry_t);
+	}
+	if(start_at_slot < 0 || start_at_slot >= st->entries) {
+		error("start_at_slot is invalid %ld, expected %ld to %ld", start_at_slot, 0, st->entries - 1);
+	}
+	if(stop_at_slot < 0 || stop_at_slot >= st->entries) {
+		error("stop_at_slot is invalid %ld, expected %ld to %ld", stop_at_slot, 0, st->entries - 1);
+	}
+	if(points_new > (before_new - after_new) / group / st->update_every + 1) {
+		error("points_new %ld is more than points %ld", points_new, (before_new - after_new) / group / st->update_every + 1);
+	}
+#endif
+
+	//info("RRD2RRDR(): %s: wanted %ld points, got %ld - group=%ld, wanted duration=%u, got %u - wanted %ld - %ld, got %ld - %ld", st->id, points, points_new, group, before - after, before_new - after_new, after, before, after_new, before_new);
+
+	after = after_new;
+	before = before_new;
+	duration = before - after;
+	points = points_new;
+
+	// Now we have:
+	// before = the end time of the calculation
+	// after = the start time of the calculation
+	// duration = the duration of the calculation
+	// group = the number of source points to aggregate / group together
+	// method = the method of grouping source points
+	// points = the number of points to generate
+
+
+	// -------------------------------------------------------------------------
+	// initialize our result set
+
+	RRDR *r = rrdr_create(st, points);
+	if(!r) {
+#ifdef NETDATA_INTERNAL_CHECKS
+		error("Cannot create RRDR for %s, after=%u, before=%u, duration=%u, points=%d", st->id, after, before, duration, points);
+#endif
+		return NULL;
+	}
+	if(!r->d) {
+#ifdef NETDATA_INTERNAL_CHECKS
+		error("Returning empty RRDR (no dimensions in RRDSET) for %s, after=%u, before=%u, duration=%u, points=%d", st->id, after, before, duration, points);
+#endif
+		return r;
+	}
+
+	if(absolute_period_requested == 1)
+		r->result_options |= RRDR_RESULT_OPTION_ABSOLUTE;
+	else
+		r->result_options |= RRDR_RESULT_OPTION_RELATIVE;
+
+	// find how many dimensions we have
+	long dimensions = r->d;
+
+
+	// -------------------------------------------------------------------------
+	// checks for debugging
+
+	if(debug) debug(D_RRD_STATS, "INFO %s first_t: %lu, last_t: %lu, all_duration: %lu, after: %lu, before: %lu, duration: %lu, points: %ld, group: %ld"
+			, st->id
+			, first_entry_t
+			, last_entry_t
+			, last_entry_t - first_entry_t
+			, after
+			, before
+			, duration
+			, points
+			, group
+			);
+
+
+	// -------------------------------------------------------------------------
+	// temp arrays for keeping values per dimension
+
+	calculated_number 	group_values[dimensions]; // keep sums when grouping
+	long 				group_counts[dimensions]; // keep the number of values added to group_values
+	uint8_t 			group_options[dimensions];
+	uint8_t				found_non_zero[dimensions];
+
+
+	// initialize them
+	RRDDIM *rd;
+	long c;
+	for( rd = st->dimensions, c = 0 ; rd && c < dimensions ; rd = rd->next, c++) {
+		group_values[c] = 0;
+		group_counts[c] = 0;
+		group_options[c] = 0;
+		found_non_zero[c] = 0;
+	}
+
+
+	// -------------------------------------------------------------------------
+	// the main loop
+
+	time_t 	now = rrdset_slot2time(st, start_at_slot),
+			dt = st->update_every,
+			group_start_t = 0;
+
+	if(unlikely(debug)) debug(D_RRD_STATS, "BEGIN %s after_t: %lu (stop_at_t: %ld), before_t: %lu (start_at_t: %ld), start_t(now): %lu, current_entry: %ld, entries: %ld"
+			, st->id
+			, after
+			, stop_at_slot
+			, before
+			, start_at_slot
+			, now
+			, st->current_entry
+			, st->entries
+			);
+
+	r->group = group;
+	r->update_every = group * st->update_every;
+	r->before = now;
+	r->after = now;
+
+	//info("RRD2RRDR(): %s: STARTING", st->id);
+
+	long slot = start_at_slot, counter = 0, stop_now = 0, added = 0, group_count = 0, add_this = 0;
+	for(; !stop_now ; now -= dt, slot--, counter++) {
+		if(unlikely(slot < 0)) slot = st->entries - 1;
+		if(unlikely(slot == stop_at_slot)) stop_now = counter;
+
+		if(unlikely(debug)) debug(D_RRD_STATS, "ROW %s slot: %ld, entries_counter: %ld, group_count: %ld, added: %ld, now: %lu, %s %s"
+				, st->id
+				, slot
+				, counter
+				, group_count + 1
+				, added
+				, now
+				, (group_count + 1 == group)?"PRINT":"  -  "
+				, (now >= after && now <= before)?"RANGE":"  -  "
+				);
+
+		// make sure we return data in the proper time range
+		if(unlikely(now > before)) continue;
+		if(unlikely(now < after)) break;
+
+		if(unlikely(group_count == 0)) {
+			group_start_t = now;
+		}
+		group_count++;
+
+		if(unlikely(group_count == group)) {
+			if(unlikely(added >= points)) break;
+			add_this = 1;
+		}
+
+		// do the calculations
+		for(rd = st->dimensions, c = 0 ; rd && c < dimensions ; rd = rd->next, c++) {
+			storage_number n = rd->values[slot];
+			if(unlikely(!does_storage_number_exist(n))) continue;
+
+			group_counts[c]++;
+
+			calculated_number value = unpack_storage_number(n);
+			if(likely(value != 0.0)) {
+				group_options[c] |= RRDR_NONZERO;
+				found_non_zero[c] = 1;
+			}
+
+			if(unlikely(did_storage_number_reset(n)))
+				group_options[c] |= RRDR_RESET;
+
+			switch(group_method) {
+				case GROUP_MAX:
+					if(unlikely(abs(value) > abs(group_values[c])))
+						group_values[c] = value;
+					break;
+
+				default:
+				case GROUP_SUM:
+				case GROUP_AVERAGE:
+					group_values[c] += value;
+					break;
+			}
+		}
+
+		// added it
+		if(unlikely(add_this)) {
+			if(unlikely(!rrdr_line_init(r, group_start_t))) break;
+
+			r->after = now;
+
+			calculated_number *cn = rrdr_line_values(r);
+			uint8_t *co = rrdr_line_options(r);
+
+			for(rd = st->dimensions, c = 0 ; rd && c < dimensions ; rd = rd->next, c++) {
+
+				// update the dimension options
+				if(likely(found_non_zero[c])) r->od[c] |= RRDR_NONZERO;
+
+				// store the specific point options
+				co[c] = group_options[c];
+
+				// store the value
+				if(unlikely(group_counts[c] == 0)) {
+					cn[c] = 0.0;
+					co[c] |= RRDR_EMPTY;
+				}
+				else if(unlikely(group_method == GROUP_AVERAGE)) {
+					cn[c] = group_values[c] / group_counts[c];
+				}
+				else {
+					cn[c] = group_values[c];
+				}
+
+				if(cn[c] < r->min) r->min = cn[c];
+				if(cn[c] > r->max) r->max = cn[c];
+
+				// reset them for the next loop
+				group_values[c] = 0;
+				group_counts[c] = 0;
+				group_options[c] = 0;
+			}
+
+			added++;
+			group_count = 0;
+			add_this = 0;
+		}
+	}
+
+	rrdr_done(r);
+	//info("RRD2RRDR(): %s: END %ld loops made, %ld points generated", st->id, counter, rrdr_rows(r));
+	//error("SHIFT: %s: wanted %ld points, got %ld", st->id, points, rrdr_rows(r));
+	return r;
+}
+
+int rrd2format(RRDSET *st, BUFFER *wb, BUFFER *dimensions, uint32_t format, long points, long long after, long long before, int group_method, uint32_t options, time_t *latest_timestamp)
+{
+	RRDR *r = rrd2rrdr(st, points, after, before, group_method);
+	if(!r) {
+		buffer_strcat(wb, "Cannot generate output with these parameters on this chart.");
+		return 500;
+	}
+
+	if(r->result_options & RRDR_RESULT_OPTION_RELATIVE)
+		wb->options |= WB_CONTENT_NO_CACHEABLE;
+	else if(r->result_options & RRDR_RESULT_OPTION_ABSOLUTE)
+		wb->options |= WB_CONTENT_CACHEABLE;
+
+	options = rrdr_check_options(r, options, (dimensions)?buffer_tostring(dimensions):NULL);
+
+	if(dimensions)
+		rrdr_disable_not_selected_dimensions(r, buffer_tostring(dimensions));
+
+	if(latest_timestamp && rrdr_rows(r) > 0)
+		*latest_timestamp = r->before;
+
+	switch(format) {
+	case DATASOURCE_SSV:
+		if(options & RRDR_OPTION_JSON_WRAP) {
+			wb->contenttype = CT_APPLICATION_JSON;
+			rrdr_json_wrapper_begin(r, wb, format, options, 1);
+			rrdr2ssv(r, wb, options, "", " ", "");
+			rrdr_json_wrapper_end(r, wb, format, options, 1);
+		}
+		else {
+			wb->contenttype = CT_TEXT_PLAIN;
+			rrdr2ssv(r, wb, options, "", " ", "");
+		}
+		break;
+
+	case DATASOURCE_SSV_COMMA:
+		if(options & RRDR_OPTION_JSON_WRAP) {
+			wb->contenttype = CT_APPLICATION_JSON;
+			rrdr_json_wrapper_begin(r, wb, format, options, 1);
+			rrdr2ssv(r, wb, options, "", ",", "");
+			rrdr_json_wrapper_end(r, wb, format, options, 1);
+		}
+		else {
+			wb->contenttype = CT_TEXT_PLAIN;
+			rrdr2ssv(r, wb, options, "", ",", "");
+		}
+		break;
+
+	case DATASOURCE_JS_ARRAY:
+		if(options & RRDR_OPTION_JSON_WRAP) {
+			wb->contenttype = CT_APPLICATION_JSON;
+			rrdr_json_wrapper_begin(r, wb, format, options, 0);
+			rrdr2ssv(r, wb, options, "[", ",", "]");
+			rrdr_json_wrapper_end(r, wb, format, options, 0);
+		}
+		else {
+			wb->contenttype = CT_APPLICATION_JSON;
+			rrdr2ssv(r, wb, options, "[", ",", "]");
+		}
+		break;
+
+	case DATASOURCE_CSV:
+		if(options & RRDR_OPTION_JSON_WRAP) {
+			wb->contenttype = CT_APPLICATION_JSON;
+			rrdr_json_wrapper_begin(r, wb, format, options, 1);
+			rrdr2csv(r, wb, options, "", ",", "\\n", "");
+			rrdr_json_wrapper_end(r, wb, format, options, 1);
+		}
+		else {
+			wb->contenttype = CT_TEXT_PLAIN;
+			rrdr2csv(r, wb, options, "", ",", "\r\n", "");
+		}
+		break;
+
+	case DATASOURCE_CSV_JSON_ARRAY:
+		wb->contenttype = CT_APPLICATION_JSON;
+		if(options & RRDR_OPTION_JSON_WRAP) {
+			rrdr_json_wrapper_begin(r, wb, format, options, 0);
+			buffer_strcat(wb, "[\n");
+			rrdr2csv(r, wb, options + RRDR_OPTION_LABEL_QUOTES, "[", ",", "]", ",\n");
+			buffer_strcat(wb, "\n]");
+			rrdr_json_wrapper_end(r, wb, format, options, 0);
+		}
+		else {
+			wb->contenttype = CT_TEXT_PLAIN;
+			buffer_strcat(wb, "[\n");
+			rrdr2csv(r, wb, options + RRDR_OPTION_LABEL_QUOTES, "[", ",", "]", ",\n");
+			buffer_strcat(wb, "\n]");
+		}
+		break;
+
+	case DATASOURCE_TSV:
+		if(options & RRDR_OPTION_JSON_WRAP) {
+			wb->contenttype = CT_APPLICATION_JSON;
+			rrdr_json_wrapper_begin(r, wb, format, options, 1);
+			rrdr2csv(r, wb, options, "", "\t", "\\n", "");
+			rrdr_json_wrapper_end(r, wb, format, options, 1);
+		}
+		else {
+			wb->contenttype = CT_TEXT_PLAIN;
+			rrdr2csv(r, wb, options, "", "\t", "\r\n", "");
+		}
+		break;
+
+	case DATASOURCE_HTML:
+		if(options & RRDR_OPTION_JSON_WRAP) {
+			wb->contenttype = CT_APPLICATION_JSON;
+			rrdr_json_wrapper_begin(r, wb, format, options, 1);
+			buffer_strcat(wb, "<html>\\n<center>\\n<table border=\\\"0\\\" cellpadding=\\\"5\\\" cellspacing=\\\"5\\\">\\n");
+			rrdr2csv(r, wb, options, "<tr><td>", "</td><td>", "</td></tr>\\n", "");
+			buffer_strcat(wb, "</table>\\n</center>\\n</html>\\n");
+			rrdr_json_wrapper_end(r, wb, format, options, 1);
+		}
+		else {
+			wb->contenttype = CT_TEXT_HTML;
+			buffer_strcat(wb, "<html>\n<center>\n<table border=\"0\" cellpadding=\"5\" cellspacing=\"5\">\n");
+			rrdr2csv(r, wb, options, "<tr><td>", "</td><td>", "</td></tr>\n", "");
+			buffer_strcat(wb, "</table>\n</center>\n</html>\n");
+		}
+		break;
+
+	case DATASOURCE_DATATABLE_JSONP:
+		wb->contenttype = CT_APPLICATION_X_JAVASCRIPT;
+
+		if(options & RRDR_OPTION_JSON_WRAP)
+			rrdr_json_wrapper_begin(r, wb, format, options, 0);
+
+		rrdr2json(r, wb, options, 1);
+
+		if(options & RRDR_OPTION_JSON_WRAP)
+			rrdr_json_wrapper_end(r, wb, format, options, 0);
+		break;
+
+	case DATASOURCE_DATATABLE_JSON:
+		wb->contenttype = CT_APPLICATION_JSON;
+
+		if(options & RRDR_OPTION_JSON_WRAP)
+			rrdr_json_wrapper_begin(r, wb, format, options, 0);
+
+		rrdr2json(r, wb, options, 1);
+
+		if(options & RRDR_OPTION_JSON_WRAP)
+			rrdr_json_wrapper_end(r, wb, format, options, 0);
+		break;
+
+	case DATASOURCE_JSONP:
+		wb->contenttype = CT_APPLICATION_X_JAVASCRIPT;
+		if(options & RRDR_OPTION_JSON_WRAP)
+			rrdr_json_wrapper_begin(r, wb, format, options, 0);
+
+		rrdr2json(r, wb, options, 0);
+
+		if(options & RRDR_OPTION_JSON_WRAP)
+			rrdr_json_wrapper_end(r, wb, format, options, 0);
+		break;
+
+	case DATASOURCE_JSON:
+	default:
+		wb->contenttype = CT_APPLICATION_JSON;
+
+		if(options & RRDR_OPTION_JSON_WRAP)
+			rrdr_json_wrapper_begin(r, wb, format, options, 0);
+
+		rrdr2json(r, wb, options, 0);
+
+		if(options & RRDR_OPTION_JSON_WRAP)
+			rrdr_json_wrapper_end(r, wb, format, options, 0);
+		break;
+	}
+
+	rrdr_free(r);
+	return 200;
+}
+
+time_t rrd_stats_json(int type, RRDSET *st, BUFFER *wb, long points, long group, int group_method, time_t after, time_t before, int only_non_zero)
+{
+	int c;
+	pthread_rwlock_rdlock(&st->rwlock);
+
+
+	// -------------------------------------------------------------------------
+	// switch from JSON to google JSON
+
+	char kq[2] = "\"";
+	char sq[2] = "\"";
+	switch(type) {
+		case DATASOURCE_DATATABLE_JSON:
+		case DATASOURCE_DATATABLE_JSONP:
+			kq[0] = '\0';
+			sq[0] = '\'';
+			break;
+
+		case DATASOURCE_JSON:
+		default:
+			break;
+	}
+
+
+	// -------------------------------------------------------------------------
+	// validate the parameters
+
+	if(points < 1) points = 1;
+	if(group < 1) group = 1;
+
+	if(before == 0 || before > rrdset_last_entry_t(st)) before = rrdset_last_entry_t(st);
+	if(after  == 0 || after < rrdset_first_entry_t(st)) after = rrdset_first_entry_t(st);
+
+	// ---
+
+	// our return value (the last timestamp printed)
+	// this is required to detect re-transmit in google JSONP
+	time_t last_timestamp = 0;
+
+
+	// -------------------------------------------------------------------------
+	// find how many dimensions we have
+
+	int dimensions = 0;
+	RRDDIM *rd;
+	for( rd = st->dimensions ; rd ; rd = rd->next) dimensions++;
+	if(!dimensions) {
+		pthread_rwlock_unlock(&st->rwlock);
+		buffer_strcat(wb, "No dimensions yet.");
+		return 0;
+	}
+
+
+	// -------------------------------------------------------------------------
+	// prepare various strings, to speed up the loop
+
+	char overflow_annotation[201]; snprintf(overflow_annotation, 200, ",{%sv%s:%sRESET OR OVERFLOW%s},{%sv%s:%sThe counters have been wrapped.%s}", kq, kq, sq, sq, kq, kq, sq, sq);
+	char normal_annotation[201];   snprintf(normal_annotation,   200, ",{%sv%s:null},{%sv%s:null}", kq, kq, kq, kq);
+	char pre_date[51];             snprintf(pre_date,             50, "		{%sc%s:[{%sv%s:%s", kq, kq, kq, kq, sq);
+	char post_date[21];            snprintf(post_date,            20, "%s}", sq);
+	char pre_value[21];            snprintf(pre_value,            20, ",{%sv%s:", kq, kq);
+	char post_value[21];           snprintf(post_value,           20, "}");
+
+
+	// -------------------------------------------------------------------------
+	// checks for debugging
+
+	if(st->debug) {
+		debug(D_RRD_STATS, "%s first_entry_t = %lu, last_entry_t = %lu, duration = %lu, after = %lu, before = %lu, duration = %lu, entries_to_show = %lu, group = %lu"
+			, st->id
+			, rrdset_first_entry_t(st)
+			, rrdset_last_entry_t(st)
+			, rrdset_last_entry_t(st) - rrdset_first_entry_t(st)
+			, after
+			, before
+			, before - after
+			, points
+			, group
+			);
+
+		if(before < after)
+			debug(D_RRD_STATS, "WARNING: %s The newest value in the database (%lu) is earlier than the oldest (%lu)", st->name, before, after);
+
+		if((before - after) > st->entries * st->update_every)
+			debug(D_RRD_STATS, "WARNING: %s The time difference between the oldest and the newest entries (%lu) is higher than the capacity of the database (%lu)", st->name, before - after, st->entries * st->update_every);
+	}
+
+
+	// -------------------------------------------------------------------------
+	// temp arrays for keeping values per dimension
+
+	calculated_number group_values[dimensions]; // keep sums when grouping
+	int               print_hidden[dimensions]; // keep hidden flags
+	int               found_non_zero[dimensions];
+	int               found_non_existing[dimensions];
+
+	// initialize them
+	for( rd = st->dimensions, c = 0 ; rd && c < dimensions ; rd = rd->next, c++) {
+		group_values[c] = 0;
+		print_hidden[c] = (rd->flags & RRDDIM_FLAG_HIDDEN)?1:0;
+		found_non_zero[c] = 0;
+		found_non_existing[c] = 0;
+	}
+
+
+	// error("OLD: points=%d after=%d before=%d group=%d, duration=%d", entries_to_show, before - (st->update_every * group * entries_to_show), before, group, before - after + 1);
+	// rrd2array(st, entries_to_show, before - (st->update_every * group * entries_to_show), before, group_method, only_non_zero);
+	// rrd2rrdr(st, entries_to_show, before - (st->update_every * group * entries_to_show), before, group_method);
+
+	// -------------------------------------------------------------------------
+	// remove dimensions that contain only zeros
+
+	int max_loop = 1;
+	if(only_non_zero) max_loop = 2;
+
+	for(; max_loop ; max_loop--) {
+
+		// -------------------------------------------------------------------------
+		// print the JSON header
+
+		buffer_sprintf(wb, "{\n	%scols%s:\n	[\n", kq, kq);
+		buffer_sprintf(wb, "		{%sid%s:%s%s,%slabel%s:%stime%s,%spattern%s:%s%s,%stype%s:%sdatetime%s},\n", kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, sq, sq);
+		buffer_sprintf(wb, "		{%sid%s:%s%s,%slabel%s:%s%s,%spattern%s:%s%s,%stype%s:%sstring%s,%sp%s:{%srole%s:%sannotation%s}},\n", kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, kq, kq, sq, sq);
+		buffer_sprintf(wb, "		{%sid%s:%s%s,%slabel%s:%s%s,%spattern%s:%s%s,%stype%s:%sstring%s,%sp%s:{%srole%s:%sannotationText%s}}", kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, sq, sq, kq, kq, kq, kq, sq, sq);
+
+		// print the header for each dimension
+		// and update the print_hidden array for the dimensions that should be hidden
+		int pc = 0;
+		for( rd = st->dimensions, c = 0 ; rd && c < dimensions ; rd = rd->next, c++) {
+			if(!print_hidden[c]) {
+				pc++;
+				buffer_sprintf(wb, ",\n		{%sid%s:%s%s,%slabel%s:%s%s%s,%spattern%s:%s%s,%stype%s:%snumber%s}", kq, kq, sq, sq, kq, kq, sq, rd->name, sq, kq, kq, sq, sq, kq, kq, sq, sq);
+			}
+		}
+		if(!pc) {
+			buffer_sprintf(wb, ",\n		{%sid%s:%s%s,%slabel%s:%s%s%s,%spattern%s:%s%s,%stype%s:%snumber%s}", kq, kq, sq, sq, kq, kq, sq, "no data", sq, kq, kq, sq, sq, kq, kq, sq, sq);
+		}
+
+		// print the begin of row data
+		buffer_sprintf(wb, "\n	],\n	%srows%s:\n	[\n", kq, kq);
+
+
+		// -------------------------------------------------------------------------
+		// the main loop
+
+		int annotate_reset = 0;
+		int annotation_count = 0;
+
+		long 	t = rrdset_time2slot(st, before),
+				stop_at_t = rrdset_time2slot(st, after),
+				stop_now = 0;
+
+		t -= t % group;
+
+		time_t 	now = rrdset_slot2time(st, t),
+				dt = st->update_every;
+
+		long count = 0, printed = 0, group_count = 0;
+		last_timestamp = 0;
+
+		if(st->debug) debug(D_RRD_STATS, "%s: REQUEST after:%lu before:%lu, points:%d, group:%d, CHART cur:%ld first: %lu last:%lu, CALC start_t:%ld, stop_t:%ld"
+					, st->id
+					, after
+					, before
+					, points
+					, group
+					, st->current_entry
+					, rrdset_first_entry_t(st)
+					, rrdset_last_entry_t(st)
+					, t
+					, stop_at_t
+					);
+
+		long counter = 0;
+		for(; !stop_now ; now -= dt, t--, counter++) {
+			if(t < 0) t = st->entries - 1;
+			if(t == stop_at_t) stop_now = counter;
+
+			int print_this = 0;
+
+			if(st->debug) debug(D_RRD_STATS, "%s t = %ld, count = %ld, group_count = %ld, printed = %ld, now = %lu, %s %s"
+					, st->id
+					, t
+					, count + 1
+					, group_count + 1
+					, printed
+					, now
+					, (group_count + 1 == group)?"PRINT":"  -  "
+					, (now >= after && now <= before)?"RANGE":"  -  "
+					);
+
+
+			// make sure we return data in the proper time range
+			if(now > before) continue;
+			if(now < after) break;
+
+			//if(rrdset_slot2time(st, t) != now)
+			//	error("%s: slot=%ld, now=%ld, slot2time=%ld, diff=%ld, last_entry_t=%ld, rrdset_last_slot=%ld", st->id, t, now, rrdset_slot2time(st,t), now - rrdset_slot2time(st,t), rrdset_last_entry_t(st), rrdset_last_slot(st));
+
+			count++;
+			group_count++;
+
+			// check if we have to print this now
+			if(group_count == group) {
+				if(printed >= points) {
+					// debug(D_RRD_STATS, "Already printed all rows. Stopping.");
+					break;
+				}
+
+				// generate the local date time
+				struct tm tmbuf, *tm = localtime_r(&now, &tmbuf);
+				if(!tm) { error("localtime() failed."); continue; }
+				if(now > last_timestamp) last_timestamp = now;
+
+				if(printed) buffer_strcat(wb, "]},\n");
+				buffer_strcat(wb, pre_date);
+				buffer_jsdate(wb, tm->tm_year + 1900, tm->tm_mon, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
+				buffer_strcat(wb, post_date);
+
+				print_this = 1;
+			}
+
+			// do the calculations
+			for(rd = st->dimensions, c = 0 ; rd && c < dimensions ; rd = rd->next, c++) {
+				storage_number n = rd->values[t];
+				calculated_number value = unpack_storage_number(n);
+
+				if(!does_storage_number_exist(n)) {
+					value = 0.0;
+					found_non_existing[c]++;
+				}
+				if(did_storage_number_reset(n)) annotate_reset = 1;
+
+				switch(group_method) {
+					case GROUP_MAX:
+						if(abs(value) > abs(group_values[c])) group_values[c] = value;
+						break;
+
+					case GROUP_SUM:
+						group_values[c] += value;
+						break;
+
+					default:
+					case GROUP_AVERAGE:
+						group_values[c] += value;
+						if(print_this) group_values[c] /= ( group_count - found_non_existing[c] );
+						break;
+				}
+			}
+
+			if(print_this) {
+				if(annotate_reset) {
+					annotation_count++;
+					buffer_strcat(wb, overflow_annotation);
+					annotate_reset = 0;
+				}
+				else
+					buffer_strcat(wb, normal_annotation);
+
+				pc = 0;
+				for(c = 0 ; c < dimensions ; c++) {
+					if(found_non_existing[c] == group_count) {
+						// all entries are non-existing
+						pc++;
+						buffer_strcat(wb, pre_value);
+						buffer_strcat(wb, "null");
+						buffer_strcat(wb, post_value);
+					}
+					else if(!print_hidden[c]) {
+						pc++;
+						buffer_strcat(wb, pre_value);
+						buffer_rrd_value(wb, group_values[c]);
+						buffer_strcat(wb, post_value);
+
+						if(group_values[c]) found_non_zero[c]++;
+					}
+
+					// reset them for the next loop
+					group_values[c] = 0;
+					found_non_existing[c] = 0;
+				}
+
+				// if all dimensions are hidden, print a null
+				if(!pc) {
+					buffer_strcat(wb, pre_value);
+					buffer_strcat(wb, "null");
+					buffer_strcat(wb, post_value);
+				}
+
+				printed++;
+				group_count = 0;
+			}
+		}
+
+		if(printed) buffer_strcat(wb, "]}");
+		buffer_strcat(wb, "\n	]\n}\n");
+
+		if(only_non_zero && max_loop > 1) {
+			int changed = 0;
+			for(rd = st->dimensions, c = 0 ; rd && c < dimensions ; rd = rd->next, c++) {
+				group_values[c] = 0;
+				found_non_existing[c] = 0;
+
+				if(!print_hidden[c] && !found_non_zero[c]) {
+					changed = 1;
+					print_hidden[c] = 1;
+				}
+			}
+
+			if(changed) buffer_flush(wb);
+			else break;
+		}
+		else break;
+
+	} // max_loop
+
+	debug(D_RRD_STATS, "RRD_STATS_JSON: %s total %ld bytes", st->name, wb->len);
+
+	pthread_rwlock_unlock(&st->rwlock);
+	return last_timestamp;
+}