#ifdef HAVE_CONFIG_H

#include <config.h>

#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

);

}

#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

#define RRDR_RESULT_OPTION_ABSOLUTE 0x00000001

#define RRDR_RESULT_OPTION_RELATIVE 0x00000002

typedef struct rrdresult {

} RRDR;

#define rrdr_rows(r) ((r)->rows)

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

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;

}