Merge pull request #2796 from elfiesmelfie/feat_ipmi_SEL_ignore_list
[collectd.git] / src / utils_format_json.c
1 /**
2  * collectd - src/utils_format_json.c
3  * Copyright (C) 2009-2015  Florian octo Forster
4  *
5  * Permission is hereby granted, free of charge, to any person obtaining a
6  * copy of this software and associated documentation files (the "Software"),
7  * to deal in the Software without restriction, including without limitation
8  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
9  * and/or sell copies of the Software, and to permit persons to whom the
10  * Software is furnished to do so, subject to the following conditions:
11  *
12  * The above copyright notice and this permission notice shall be included in
13  * all copies or substantial portions of the Software.
14  *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21  * DEALINGS IN THE SOFTWARE.
22  *
23  * Authors:
24  *   Florian octo Forster <octo at collectd.org>
25  **/
26
27 #include "collectd.h"
28
29 #include "utils_format_json.h"
30
31 #include "common.h"
32 #include "plugin.h"
33 #include "utils_cache.h"
34
35 #if HAVE_LIBYAJL
36 #include <yajl/yajl_common.h>
37 #include <yajl/yajl_gen.h>
38 #if HAVE_YAJL_YAJL_VERSION_H
39 #include <yajl/yajl_version.h>
40 #endif
41 #if defined(YAJL_MAJOR) && (YAJL_MAJOR > 1)
42 #define HAVE_YAJL_V2 1
43 #endif
44 #endif
45
46 static int json_escape_string(char *buffer, size_t buffer_size, /* {{{ */
47                               const char *string) {
48   size_t dst_pos;
49
50   if ((buffer == NULL) || (string == NULL))
51     return -EINVAL;
52
53   if (buffer_size < 3)
54     return -ENOMEM;
55
56   dst_pos = 0;
57
58 #define BUFFER_ADD(c)                                                          \
59   do {                                                                         \
60     if (dst_pos >= (buffer_size - 1)) {                                        \
61       buffer[buffer_size - 1] = 0;                                             \
62       return -ENOMEM;                                                          \
63     }                                                                          \
64     buffer[dst_pos] = (c);                                                     \
65     dst_pos++;                                                                 \
66   } while (0)
67
68   /* Escape special characters */
69   BUFFER_ADD('"');
70   for (size_t src_pos = 0; string[src_pos] != 0; src_pos++) {
71     if ((string[src_pos] == '"') || (string[src_pos] == '\\')) {
72       BUFFER_ADD('\\');
73       BUFFER_ADD(string[src_pos]);
74     } else if (string[src_pos] <= 0x001F)
75       BUFFER_ADD('?');
76     else
77       BUFFER_ADD(string[src_pos]);
78   } /* for */
79   BUFFER_ADD('"');
80   buffer[dst_pos] = 0;
81
82 #undef BUFFER_ADD
83
84   return 0;
85 } /* }}} int json_escape_string */
86
87 static int values_to_json(char *buffer, size_t buffer_size, /* {{{ */
88                           const data_set_t *ds, const value_list_t *vl,
89                           int store_rates) {
90   size_t offset = 0;
91   gauge_t *rates = NULL;
92
93   memset(buffer, 0, buffer_size);
94
95 #define BUFFER_ADD(...)                                                        \
96   do {                                                                         \
97     int status;                                                                \
98     status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__);     \
99     if (status < 1) {                                                          \
100       sfree(rates);                                                            \
101       return -1;                                                               \
102     } else if (((size_t)status) >= (buffer_size - offset)) {                   \
103       sfree(rates);                                                            \
104       return -ENOMEM;                                                          \
105     } else                                                                     \
106       offset += ((size_t)status);                                              \
107   } while (0)
108
109   BUFFER_ADD("[");
110   for (size_t i = 0; i < ds->ds_num; i++) {
111     if (i > 0)
112       BUFFER_ADD(",");
113
114     if (ds->ds[i].type == DS_TYPE_GAUGE) {
115       if (isfinite(vl->values[i].gauge))
116         BUFFER_ADD(JSON_GAUGE_FORMAT, vl->values[i].gauge);
117       else
118         BUFFER_ADD("null");
119     } else if (store_rates) {
120       if (rates == NULL)
121         rates = uc_get_rate(ds, vl);
122       if (rates == NULL) {
123         WARNING("utils_format_json: uc_get_rate failed.");
124         sfree(rates);
125         return -1;
126       }
127
128       if (isfinite(rates[i]))
129         BUFFER_ADD(JSON_GAUGE_FORMAT, rates[i]);
130       else
131         BUFFER_ADD("null");
132     } else if (ds->ds[i].type == DS_TYPE_COUNTER)
133       BUFFER_ADD("%" PRIu64, (uint64_t)vl->values[i].counter);
134     else if (ds->ds[i].type == DS_TYPE_DERIVE)
135       BUFFER_ADD("%" PRIi64, vl->values[i].derive);
136     else if (ds->ds[i].type == DS_TYPE_ABSOLUTE)
137       BUFFER_ADD("%" PRIu64, vl->values[i].absolute);
138     else {
139       ERROR("format_json: Unknown data source type: %i", ds->ds[i].type);
140       sfree(rates);
141       return -1;
142     }
143   } /* for ds->ds_num */
144   BUFFER_ADD("]");
145
146 #undef BUFFER_ADD
147
148   DEBUG("format_json: values_to_json: buffer = %s;", buffer);
149   sfree(rates);
150   return 0;
151 } /* }}} int values_to_json */
152
153 static int dstypes_to_json(char *buffer, size_t buffer_size, /* {{{ */
154                            const data_set_t *ds) {
155   size_t offset = 0;
156
157   memset(buffer, 0, buffer_size);
158
159 #define BUFFER_ADD(...)                                                        \
160   do {                                                                         \
161     int status;                                                                \
162     status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__);     \
163     if (status < 1)                                                            \
164       return -1;                                                               \
165     else if (((size_t)status) >= (buffer_size - offset))                       \
166       return -ENOMEM;                                                          \
167     else                                                                       \
168       offset += ((size_t)status);                                              \
169   } while (0)
170
171   BUFFER_ADD("[");
172   for (size_t i = 0; i < ds->ds_num; i++) {
173     if (i > 0)
174       BUFFER_ADD(",");
175
176     BUFFER_ADD("\"%s\"", DS_TYPE_TO_STRING(ds->ds[i].type));
177   } /* for ds->ds_num */
178   BUFFER_ADD("]");
179
180 #undef BUFFER_ADD
181
182   DEBUG("format_json: dstypes_to_json: buffer = %s;", buffer);
183
184   return 0;
185 } /* }}} int dstypes_to_json */
186
187 static int dsnames_to_json(char *buffer, size_t buffer_size, /* {{{ */
188                            const data_set_t *ds) {
189   size_t offset = 0;
190
191   memset(buffer, 0, buffer_size);
192
193 #define BUFFER_ADD(...)                                                        \
194   do {                                                                         \
195     int status;                                                                \
196     status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__);     \
197     if (status < 1)                                                            \
198       return -1;                                                               \
199     else if (((size_t)status) >= (buffer_size - offset))                       \
200       return -ENOMEM;                                                          \
201     else                                                                       \
202       offset += ((size_t)status);                                              \
203   } while (0)
204
205   BUFFER_ADD("[");
206   for (size_t i = 0; i < ds->ds_num; i++) {
207     if (i > 0)
208       BUFFER_ADD(",");
209
210     BUFFER_ADD("\"%s\"", ds->ds[i].name);
211   } /* for ds->ds_num */
212   BUFFER_ADD("]");
213
214 #undef BUFFER_ADD
215
216   DEBUG("format_json: dsnames_to_json: buffer = %s;", buffer);
217
218   return 0;
219 } /* }}} int dsnames_to_json */
220
221 static int meta_data_keys_to_json(char *buffer, size_t buffer_size, /* {{{ */
222                                   meta_data_t *meta, char **keys,
223                                   size_t keys_num) {
224   size_t offset = 0;
225   int status;
226
227   buffer[0] = 0;
228
229 #define BUFFER_ADD(...)                                                        \
230   do {                                                                         \
231     status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__);     \
232     if (status < 1)                                                            \
233       return -1;                                                               \
234     else if (((size_t)status) >= (buffer_size - offset))                       \
235       return -ENOMEM;                                                          \
236     else                                                                       \
237       offset += ((size_t)status);                                              \
238   } while (0)
239
240   for (size_t i = 0; i < keys_num; ++i) {
241     int type;
242     char *key = keys[i];
243
244     type = meta_data_type(meta, key);
245     if (type == MD_TYPE_STRING) {
246       char *value = NULL;
247       if (meta_data_get_string(meta, key, &value) == 0) {
248         char temp[512] = "";
249
250         status = json_escape_string(temp, sizeof(temp), value);
251         sfree(value);
252         if (status != 0)
253           return status;
254
255         BUFFER_ADD(",\"%s\":%s", key, temp);
256       }
257     } else if (type == MD_TYPE_SIGNED_INT) {
258       int64_t value = 0;
259       if (meta_data_get_signed_int(meta, key, &value) == 0)
260         BUFFER_ADD(",\"%s\":%" PRIi64, key, value);
261     } else if (type == MD_TYPE_UNSIGNED_INT) {
262       uint64_t value = 0;
263       if (meta_data_get_unsigned_int(meta, key, &value) == 0)
264         BUFFER_ADD(",\"%s\":%" PRIu64, key, value);
265     } else if (type == MD_TYPE_DOUBLE) {
266       double value = 0.0;
267       if (meta_data_get_double(meta, key, &value) == 0)
268         BUFFER_ADD(",\"%s\":%f", key, value);
269     } else if (type == MD_TYPE_BOOLEAN) {
270       bool value = false;
271       if (meta_data_get_boolean(meta, key, &value) == 0)
272         BUFFER_ADD(",\"%s\":%s", key, value ? "true" : "false");
273     }
274   } /* for (keys) */
275
276   if (offset == 0)
277     return ENOENT;
278
279   buffer[0] = '{'; /* replace leading ',' */
280   BUFFER_ADD("}");
281
282 #undef BUFFER_ADD
283
284   return 0;
285 } /* }}} int meta_data_keys_to_json */
286
287 static int meta_data_to_json(char *buffer, size_t buffer_size, /* {{{ */
288                              meta_data_t *meta) {
289   char **keys = NULL;
290   size_t keys_num;
291   int status;
292
293   if ((buffer == NULL) || (buffer_size == 0) || (meta == NULL))
294     return EINVAL;
295
296   status = meta_data_toc(meta, &keys);
297   if (status <= 0)
298     return status;
299   keys_num = (size_t)status;
300
301   status = meta_data_keys_to_json(buffer, buffer_size, meta, keys, keys_num);
302
303   for (size_t i = 0; i < keys_num; ++i)
304     sfree(keys[i]);
305   sfree(keys);
306
307   return status;
308 } /* }}} int meta_data_to_json */
309
310 static int value_list_to_json(char *buffer, size_t buffer_size, /* {{{ */
311                               const data_set_t *ds, const value_list_t *vl,
312                               int store_rates) {
313   char temp[512];
314   size_t offset = 0;
315   int status;
316
317   memset(buffer, 0, buffer_size);
318
319 #define BUFFER_ADD(...)                                                        \
320   do {                                                                         \
321     status = snprintf(buffer + offset, buffer_size - offset, __VA_ARGS__);     \
322     if (status < 1)                                                            \
323       return -1;                                                               \
324     else if (((size_t)status) >= (buffer_size - offset))                       \
325       return -ENOMEM;                                                          \
326     else                                                                       \
327       offset += ((size_t)status);                                              \
328   } while (0)
329
330   /* All value lists have a leading comma. The first one will be replaced with
331    * a square bracket in `format_json_finalize'. */
332   BUFFER_ADD(",{");
333
334   status = values_to_json(temp, sizeof(temp), ds, vl, store_rates);
335   if (status != 0)
336     return status;
337   BUFFER_ADD("\"values\":%s", temp);
338
339   status = dstypes_to_json(temp, sizeof(temp), ds);
340   if (status != 0)
341     return status;
342   BUFFER_ADD(",\"dstypes\":%s", temp);
343
344   status = dsnames_to_json(temp, sizeof(temp), ds);
345   if (status != 0)
346     return status;
347   BUFFER_ADD(",\"dsnames\":%s", temp);
348
349   BUFFER_ADD(",\"time\":%.3f", CDTIME_T_TO_DOUBLE(vl->time));
350   BUFFER_ADD(",\"interval\":%.3f", CDTIME_T_TO_DOUBLE(vl->interval));
351
352 #define BUFFER_ADD_KEYVAL(key, value)                                          \
353   do {                                                                         \
354     status = json_escape_string(temp, sizeof(temp), (value));                  \
355     if (status != 0)                                                           \
356       return status;                                                           \
357     BUFFER_ADD(",\"%s\":%s", (key), temp);                                     \
358   } while (0)
359
360   BUFFER_ADD_KEYVAL("host", vl->host);
361   BUFFER_ADD_KEYVAL("plugin", vl->plugin);
362   BUFFER_ADD_KEYVAL("plugin_instance", vl->plugin_instance);
363   BUFFER_ADD_KEYVAL("type", vl->type);
364   BUFFER_ADD_KEYVAL("type_instance", vl->type_instance);
365
366   if (vl->meta != NULL) {
367     char meta_buffer[buffer_size];
368     memset(meta_buffer, 0, sizeof(meta_buffer));
369     status = meta_data_to_json(meta_buffer, sizeof(meta_buffer), vl->meta);
370     if (status != 0)
371       return status;
372
373     BUFFER_ADD(",\"meta\":%s", meta_buffer);
374   } /* if (vl->meta != NULL) */
375
376   BUFFER_ADD("}");
377
378 #undef BUFFER_ADD_KEYVAL
379 #undef BUFFER_ADD
380
381   DEBUG("format_json: value_list_to_json: buffer = %s;", buffer);
382
383   return 0;
384 } /* }}} int value_list_to_json */
385
386 static int format_json_value_list_nocheck(char *buffer, /* {{{ */
387                                           size_t *ret_buffer_fill,
388                                           size_t *ret_buffer_free,
389                                           const data_set_t *ds,
390                                           const value_list_t *vl,
391                                           int store_rates, size_t temp_size) {
392   char temp[temp_size];
393   int status;
394
395   status = value_list_to_json(temp, sizeof(temp), ds, vl, store_rates);
396   if (status != 0)
397     return status;
398   temp_size = strlen(temp);
399
400   memcpy(buffer + (*ret_buffer_fill), temp, temp_size + 1);
401   (*ret_buffer_fill) += temp_size;
402   (*ret_buffer_free) -= temp_size;
403
404   return 0;
405 } /* }}} int format_json_value_list_nocheck */
406
407 int format_json_initialize(char *buffer, /* {{{ */
408                            size_t *ret_buffer_fill, size_t *ret_buffer_free) {
409   size_t buffer_fill;
410   size_t buffer_free;
411
412   if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
413       (ret_buffer_free == NULL))
414     return -EINVAL;
415
416   buffer_fill = *ret_buffer_fill;
417   buffer_free = *ret_buffer_free;
418
419   buffer_free = buffer_fill + buffer_free;
420   buffer_fill = 0;
421
422   if (buffer_free < 3)
423     return -ENOMEM;
424
425   memset(buffer, 0, buffer_free);
426   *ret_buffer_fill = buffer_fill;
427   *ret_buffer_free = buffer_free;
428
429   return 0;
430 } /* }}} int format_json_initialize */
431
432 int format_json_finalize(char *buffer, /* {{{ */
433                          size_t *ret_buffer_fill, size_t *ret_buffer_free) {
434   size_t pos;
435
436   if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
437       (ret_buffer_free == NULL))
438     return -EINVAL;
439
440   if (*ret_buffer_free < 2)
441     return -ENOMEM;
442
443   /* Replace the leading comma added in `value_list_to_json' with a square
444    * bracket. */
445   if (buffer[0] != ',')
446     return -EINVAL;
447   buffer[0] = '[';
448
449   pos = *ret_buffer_fill;
450   buffer[pos] = ']';
451   buffer[pos + 1] = 0;
452
453   (*ret_buffer_fill)++;
454   (*ret_buffer_free)--;
455
456   return 0;
457 } /* }}} int format_json_finalize */
458
459 int format_json_value_list(char *buffer, /* {{{ */
460                            size_t *ret_buffer_fill, size_t *ret_buffer_free,
461                            const data_set_t *ds, const value_list_t *vl,
462                            int store_rates) {
463   if ((buffer == NULL) || (ret_buffer_fill == NULL) ||
464       (ret_buffer_free == NULL) || (ds == NULL) || (vl == NULL))
465     return -EINVAL;
466
467   if (*ret_buffer_free < 3)
468     return -ENOMEM;
469
470   return format_json_value_list_nocheck(buffer, ret_buffer_fill,
471                                         ret_buffer_free, ds, vl, store_rates,
472                                         (*ret_buffer_free) - 2);
473 } /* }}} int format_json_value_list */
474
475 #if HAVE_LIBYAJL
476 static int json_add_string(yajl_gen g, char const *str) /* {{{ */
477 {
478   if (str == NULL)
479     return (int)yajl_gen_null(g);
480
481   return (int)yajl_gen_string(g, (const unsigned char *)str,
482                               (unsigned int)strlen(str));
483 } /* }}} int json_add_string */
484
485 #define JSON_ADD(g, str)                                                       \
486   do {                                                                         \
487     yajl_gen_status status = json_add_string(g, str);                          \
488     if (status != yajl_gen_status_ok) {                                        \
489       return -1;                                                               \
490     }                                                                          \
491   } while (0)
492
493 #define JSON_ADDF(g, format, ...)                                              \
494   do {                                                                         \
495     char *str = ssnprintf_alloc(format, __VA_ARGS__);                          \
496     yajl_gen_status status = json_add_string(g, str);                          \
497     free(str);                                                                 \
498     if (status != yajl_gen_status_ok) {                                        \
499       return -1;                                                               \
500     }                                                                          \
501   } while (0)
502
503 #define CHECK_SUCCESS(cmd)                                                     \
504   do {                                                                         \
505     yajl_gen_status s = (cmd);                                                 \
506     if (s != yajl_gen_status_ok) {                                             \
507       return (int)s;                                                           \
508     }                                                                          \
509   } while (0)
510
511 static int format_json_meta(yajl_gen g, notification_meta_t *meta) /* {{{ */
512 {
513   if (meta == NULL)
514     return 0;
515
516   JSON_ADD(g, meta->name);
517   switch (meta->type) {
518   case NM_TYPE_STRING:
519     JSON_ADD(g, meta->nm_value.nm_string);
520     break;
521   case NM_TYPE_SIGNED_INT:
522     JSON_ADDF(g, "%" PRIi64, meta->nm_value.nm_signed_int);
523     break;
524   case NM_TYPE_UNSIGNED_INT:
525     JSON_ADDF(g, "%" PRIu64, meta->nm_value.nm_unsigned_int);
526     break;
527   case NM_TYPE_DOUBLE:
528     JSON_ADDF(g, JSON_GAUGE_FORMAT, meta->nm_value.nm_double);
529     break;
530   case NM_TYPE_BOOLEAN:
531     JSON_ADD(g, meta->nm_value.nm_boolean ? "true" : "false");
532     break;
533   default:
534     ERROR("format_json_meta: unknown meta data type %d (name \"%s\")",
535           meta->type, meta->name);
536     CHECK_SUCCESS(yajl_gen_null(g));
537   }
538
539   return format_json_meta(g, meta->next);
540 } /* }}} int format_json_meta */
541
542 static int format_time(yajl_gen g, cdtime_t t) /* {{{ */
543 {
544   char buffer[RFC3339NANO_SIZE] = "";
545
546   if (rfc3339nano(buffer, sizeof(buffer), t) != 0)
547     return -1;
548
549   JSON_ADD(g, buffer);
550   return 0;
551 } /* }}} int format_time */
552
553 static int format_alert(yajl_gen g, notification_t const *n) /* {{{ */
554 {
555   CHECK_SUCCESS(yajl_gen_array_open(g)); /* BEGIN array */
556   CHECK_SUCCESS(yajl_gen_map_open(g));   /* BEGIN alert */
557
558   /*
559    * labels
560    */
561   JSON_ADD(g, "labels");
562   CHECK_SUCCESS(yajl_gen_map_open(g)); /* BEGIN labels */
563
564   JSON_ADD(g, "alertname");
565   if (strncmp(n->plugin, n->type, strlen(n->plugin)) == 0)
566     JSON_ADDF(g, "collectd_%s", n->type);
567   else
568     JSON_ADDF(g, "collectd_%s_%s", n->plugin, n->type);
569
570   JSON_ADD(g, "instance");
571   JSON_ADD(g, n->host);
572
573   /* mangling of plugin instance and type instance into labels is copied from
574    * the Prometheus collectd exporter. */
575   if (strlen(n->plugin_instance) > 0) {
576     JSON_ADD(g, n->plugin);
577     JSON_ADD(g, n->plugin_instance);
578   }
579   if (strlen(n->type_instance) > 0) {
580     if (strlen(n->plugin_instance) > 0)
581       JSON_ADD(g, "type");
582     else
583       JSON_ADD(g, n->plugin);
584     JSON_ADD(g, n->type_instance);
585   }
586
587   JSON_ADD(g, "severity");
588   JSON_ADD(g,
589            (n->severity == NOTIF_FAILURE)
590                ? "FAILURE"
591                : (n->severity == NOTIF_WARNING)
592                      ? "WARNING"
593                      : (n->severity == NOTIF_OKAY) ? "OKAY" : "UNKNOWN");
594
595   JSON_ADD(g, "service");
596   JSON_ADD(g, "collectd");
597
598   CHECK_SUCCESS(yajl_gen_map_close(g)); /* END labels */
599
600   /*
601    * annotations
602    */
603   JSON_ADD(g, "annotations");
604   CHECK_SUCCESS(yajl_gen_map_open(g)); /* BEGIN annotations */
605
606   JSON_ADD(g, "summary");
607   JSON_ADD(g, n->message);
608
609   if (format_json_meta(g, n->meta) != 0) {
610     return -1;
611   }
612
613   CHECK_SUCCESS(yajl_gen_map_close(g)); /* END annotations */
614
615   JSON_ADD(g, "startsAt");
616   if (format_time(g, n->time) != 0) {
617     return -1;
618   }
619
620   CHECK_SUCCESS(yajl_gen_map_close(g));   /* END alert */
621   CHECK_SUCCESS(yajl_gen_array_close(g)); /* END array */
622
623   return 0;
624 } /* }}} format_alert */
625
626 /*
627  * Format (prometheus/alertmanager v1):
628  *
629  * [{
630  *   "labels": {
631  *     "alertname": "collectd_cpu",
632  *     "instance":  "host.example.com",
633  *     "severity":  "FAILURE",
634  *     "service":   "collectd",
635  *     "cpu":       "0",
636  *     "type":      "wait"
637  *   },
638  *   "annotations": {
639  *     "summary": "...",
640  *     // meta
641  *   },
642  *   "startsAt": <rfc3339 time>,
643  *   "endsAt": <rfc3339 time>, // not used
644  * }]
645  */
646 int format_json_notification(char *buffer, size_t buffer_size, /* {{{ */
647                              notification_t const *n) {
648   yajl_gen g;
649   unsigned char const *out;
650 #if HAVE_YAJL_V2
651   size_t unused_out_len;
652 #else
653   unsigned int unused_out_len;
654 #endif
655
656   if ((buffer == NULL) || (n == NULL))
657     return EINVAL;
658
659 #if HAVE_YAJL_V2
660   g = yajl_gen_alloc(NULL);
661   if (g == NULL)
662     return -1;
663 #if COLLECT_DEBUG
664   yajl_gen_config(g, yajl_gen_beautify, 1);
665   yajl_gen_config(g, yajl_gen_validate_utf8, 1);
666 #endif
667
668 #else /* !HAVE_YAJL_V2 */
669   yajl_gen_config conf = {0};
670 #if COLLECT_DEBUG
671   conf.beautify = 1;
672   conf.indentString = "  ";
673 #endif
674   g = yajl_gen_alloc(&conf, NULL);
675   if (g == NULL)
676     return -1;
677 #endif
678
679   if (format_alert(g, n) != 0) {
680     yajl_gen_clear(g);
681     yajl_gen_free(g);
682     return -1;
683   }
684
685   /* copy to output buffer */
686   if (yajl_gen_get_buf(g, &out, &unused_out_len) != yajl_gen_status_ok) {
687     yajl_gen_clear(g);
688     yajl_gen_free(g);
689     return -1;
690   }
691   sstrncpy(buffer, (void *)out, buffer_size);
692
693   yajl_gen_clear(g);
694   yajl_gen_free(g);
695   return 0;
696 } /* }}} format_json_notification */
697 #else
698 int format_json_notification(char *buffer, size_t buffer_size, /* {{{ */
699                              notification_t const *n) {
700   ERROR("format_json_notification: Not available (requires libyajl).");
701   return ENOTSUP;
702 } /* }}} int format_json_notification */
703 #endif