Debian Codegraph @

src/utils/format_stackdriver/format_stackdriver.c

raw
1 /**
2 * collectd - src/utils_format_stackdriver.c
3 * ISC license
4 *
5 * Copyright (C) 2017 Florian Forster
6 *
7 * Permission to use, copy, modify, and/or distribute this software for any
8 * purpose with or without fee is hereby granted, provided that the above
9 * copyright notice and this permission notice appear in all copies.
10 *
11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 *
19 * Authors:
20 * Florian Forster <octo at collectd.org>
21 **/
22
23 #include "collectd.h"
24
25 #include "utils/format_stackdriver/format_stackdriver.h"
26
27 #include "plugin.h"
28 #include "utils/avltree/avltree.h"
29 #include "utils/common/common.h"
30 #include "utils_cache.h"
31 #include "utils_time.h"
32
33 #include <math.h>
34 #include <yajl/yajl_gen.h>
35 #include <yajl/yajl_parse.h>
36 #if HAVE_YAJL_YAJL_VERSION_H
37 #include <yajl/yajl_version.h>
38 #endif
39
40 struct sd_output_s {
41 sd_resource_t *res;
42 yajl_gen gen;
43 c_avl_tree_t *staged;
44 c_avl_tree_t *metric_descriptors;
45 };
46
47 struct sd_label_s {
48 char *key;
49 char *value;
50 };
51 typedef struct sd_label_s sd_label_t;
52
53 struct sd_resource_s {
54 char *type;
55
56 sd_label_t *labels;
57 size_t labels_num;
58 };
59
60 static int json_string(yajl_gen gen, char const *s) /* {{{ */
61 {
62 yajl_gen_status status =
63 yajl_gen_string(gen, (unsigned char const *)s, strlen(s));
64 if (status != yajl_gen_status_ok)
65 return (int)status;
66
67 return 0;
68 } /* }}} int json_string */
69
70 static int json_time(yajl_gen gen, cdtime_t t) {
71 char buffer[64];
72
73 size_t status = rfc3339(buffer, sizeof(buffer), t);
74 if (status != 0) {
75 return status;
76 }
77
78 return json_string(gen, buffer);
79 } /* }}} int json_time */
80
81 /* MonitoredResource
82 *
83 * {
84 * "type": "library.googleapis.com/book",
85 * "labels": {
86 * "/genre": "fiction",
87 * "/media": "paper"
88 * "/title": "The Old Man and the Sea"
89 * }
90 * }
91 */
92 static int format_gcm_resource(yajl_gen gen, sd_resource_t *res) /* {{{ */
93 {
94 yajl_gen_map_open(gen);
95
96 int status = json_string(gen, "type") || json_string(gen, res->type);
97 if (status != 0)
98 return status;
99
100 if (res->labels_num != 0) {
101 status = json_string(gen, "labels");
102 if (status != 0)
103 return status;
104
105 yajl_gen_map_open(gen);
106 for (size_t i = 0; i < res->labels_num; i++) {
107 status = json_string(gen, res->labels[i].key) ||
108 json_string(gen, res->labels[i].value);
109 if (status != 0)
110 return status;
111 }
112 yajl_gen_map_close(gen);
113 }
114
115 yajl_gen_map_close(gen);
116 return 0;
117 } /* }}} int format_gcm_resource */
118
119 /* TypedValue
120 *
121 * {
122 * // Union field, only one of the following:
123 * "int64Value": string,
124 * "doubleValue": number,
125 * }
126 */
127 static int format_typed_value(yajl_gen gen, int ds_type, value_t v,
128 int64_t start_value) {
129 char integer[32];
130
131 yajl_gen_map_open(gen);
132
133 switch (ds_type) {
134 case DS_TYPE_GAUGE: {
135 int status = json_string(gen, "doubleValue");
136 if (status != 0)
137 return status;
138
139 status = (int)yajl_gen_double(gen, (double)v.gauge);
140 if (status != yajl_gen_status_ok)
141 return status;
142
143 yajl_gen_map_close(gen);
144 return 0;
145 }
146 case DS_TYPE_DERIVE: {
147 derive_t diff = v.derive - (derive_t)start_value;
148 ssnprintf(integer, sizeof(integer), "%" PRIi64, diff);
149 break;
150 }
151 case DS_TYPE_COUNTER: {
152 counter_t diff = counter_diff((counter_t)start_value, v.counter);
153 ssnprintf(integer, sizeof(integer), "%llu", diff);
154 break;
155 }
156 case DS_TYPE_ABSOLUTE: {
157 ssnprintf(integer, sizeof(integer), "%" PRIu64, v.absolute);
158 break;
159 }
160 default: {
161 ERROR("format_typed_value: unknown value type %d.", ds_type);
162 return EINVAL;
163 }
164 }
165
166 int status = json_string(gen, "int64Value") || json_string(gen, integer);
167 if (status != 0) {
168 return status;
169 }
170
171 yajl_gen_map_close(gen);
172 return 0;
173 } /* }}} int format_typed_value */
174
175 /* MetricKind
176 *
177 * enum(
178 * "CUMULATIVE",
179 * "GAUGE"
180 * )
181 */
182 static int format_metric_kind(yajl_gen gen, int ds_type) {
183 switch (ds_type) {
184 case DS_TYPE_GAUGE:
185 case DS_TYPE_ABSOLUTE:
186 return json_string(gen, "GAUGE");
187 case DS_TYPE_COUNTER:
188 case DS_TYPE_DERIVE:
189 return json_string(gen, "CUMULATIVE");
190 default:
191 ERROR("format_metric_kind: unknown value type %d.", ds_type);
192 return EINVAL;
193 }
194 }
195
196 /* ValueType
197 *
198 * enum(
199 * "DOUBLE",
200 * "INT64"
201 * )
202 */
203 static int format_value_type(yajl_gen gen, int ds_type) {
204 return json_string(gen, (ds_type == DS_TYPE_GAUGE) ? "DOUBLE" : "INT64");
205 }
206
207 static int metric_type(char *buffer, size_t buffer_size, data_set_t const *ds,
208 value_list_t const *vl, int ds_index) {
209 /* {{{ */
210 char const *ds_name = ds->ds[ds_index].name;
211
212 #define GCM_PREFIX "custom.googleapis.com/collectd/"
213 if ((ds_index != 0) || strcmp("value", ds_name) != 0) {
214 ssnprintf(buffer, buffer_size, GCM_PREFIX "%s/%s_%s", vl->plugin, vl->type,
215 ds_name);
216 } else {
217 ssnprintf(buffer, buffer_size, GCM_PREFIX "%s/%s", vl->plugin, vl->type);
218 }
219
220 char const *whitelist = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
221 "abcdefghijklmnopqrstuvwxyz"
222 "0123456789_/";
223 char *ptr = buffer + strlen(GCM_PREFIX);
224 size_t ok_len;
225 while ((ok_len = strspn(ptr, whitelist)) != strlen(ptr)) {
226 ptr[ok_len] = '_';
227 ptr += ok_len;
228 }
229
230 return 0;
231 } /* }}} int metric_type */
232
233 /* The metric type, including its DNS name prefix. The type is not URL-encoded.
234 * All user-defined custom metric types have the DNS name custom.googleapis.com.
235 * Metric types should use a natural hierarchical grouping. */
236 static int format_metric_type(yajl_gen gen, data_set_t const *ds,
237 value_list_t const *vl, int ds_index) {
238 /* {{{ */
239 char buffer[4 * DATA_MAX_NAME_LEN];
240 metric_type(buffer, sizeof(buffer), ds, vl, ds_index);
241
242 return json_string(gen, buffer);
243 } /* }}} int format_metric_type */
244
245 /* TimeInterval
246 *
247 * {
248 * "endTime": string,
249 * "startTime": string,
250 * }
251 */
252 static int format_time_interval(yajl_gen gen, int ds_type,
253 value_list_t const *vl, cdtime_t start_time) {
254 /* {{{ */
255 yajl_gen_map_open(gen);
256
257 int status = json_string(gen, "endTime") || json_time(gen, vl->time);
258 if (status != 0)
259 return status;
260
261 if ((ds_type == DS_TYPE_DERIVE) || (ds_type == DS_TYPE_COUNTER)) {
262 int status = json_string(gen, "startTime") || json_time(gen, start_time);
263 if (status != 0)
264 return status;
265 }
266
267 yajl_gen_map_close(gen);
268 return 0;
269 } /* }}} int format_time_interval */
270
271 /* read_cumulative_state reads the start time and start value of cumulative
272 * (i.e. DERIVE or COUNTER) metrics from the cache. If a metric is seen for the
273 * first time, or when a DERIVE metric is reset, the start time is (re)set to
274 * vl->time. */
275 static int read_cumulative_state(data_set_t const *ds, value_list_t const *vl,
276 int ds_index, cdtime_t *ret_start_time,
277 int64_t *ret_start_value) {
278 int ds_type = ds->ds[ds_index].type;
279 if ((ds_type != DS_TYPE_DERIVE) && (ds_type != DS_TYPE_COUNTER)) {
280 return 0;
281 }
282
283 char start_value_key[DATA_MAX_NAME_LEN];
284 ssnprintf(start_value_key, sizeof(start_value_key),
285 "stackdriver:start_value[%d]", ds_index);
286
287 int status =
288 uc_meta_data_get_signed_int(vl, start_value_key, ret_start_value);
289 if ((status == 0) && ((ds_type != DS_TYPE_DERIVE) ||
290 (*ret_start_value <= vl->values[ds_index].derive))) {
291 return uc_meta_data_get_unsigned_int(vl, "stackdriver:start_time",
292 ret_start_time);
293 }
294
295 if (ds_type == DS_TYPE_DERIVE) {
296 *ret_start_value = vl->values[ds_index].derive;
297 } else {
298 *ret_start_value = (int64_t)vl->values[ds_index].counter;
299 }
300 *ret_start_time = vl->time;
301
302 status = uc_meta_data_add_signed_int(vl, start_value_key, *ret_start_value);
303 if (status != 0) {
304 return status;
305 }
306 return uc_meta_data_add_unsigned_int(vl, "stackdriver:start_time",
307 *ret_start_time);
308 } /* int read_cumulative_state */
309
310 /* Point
311 *
312 * {
313 * "interval": {
314 * object(TimeInterval)
315 * },
316 * "value": {
317 * object(TypedValue)
318 * },
319 * }
320 */
321 static int format_point(yajl_gen gen, data_set_t const *ds,
322 value_list_t const *vl, int ds_index,
323 cdtime_t start_time, int64_t start_value) {
324 /* {{{ */
325 yajl_gen_map_open(gen);
326
327 int ds_type = ds->ds[ds_index].type;
328
329 int status =
330 json_string(gen, "interval") ||
331 format_time_interval(gen, ds_type, vl, start_time) ||
332 json_string(gen, "value") ||
333 format_typed_value(gen, ds_type, vl->values[ds_index], start_value);
334 if (status != 0)
335 return status;
336
337 yajl_gen_map_close(gen);
338 return 0;
339 } /* }}} int format_point */
340
341 /* Metric
342 *
343 * {
344 * "type": string,
345 * "labels": {
346 * string: string,
347 * ...
348 * },
349 * }
350 */
351 static int format_metric(yajl_gen gen, data_set_t const *ds,
352 value_list_t const *vl, int ds_index) {
353 /* {{{ */
354 yajl_gen_map_open(gen);
355
356 int status = json_string(gen, "type") ||
357 format_metric_type(gen, ds, vl, ds_index) ||
358 json_string(gen, "labels");
359 if (status != 0) {
360 return status;
361 }
362
363 yajl_gen_map_open(gen);
364 status = json_string(gen, "host") || json_string(gen, vl->host) ||
365 json_string(gen, "plugin_instance") ||
366 json_string(gen, vl->plugin_instance) ||
367 json_string(gen, "type_instance") ||
368 json_string(gen, vl->type_instance);
369 if (status != 0) {
370 return status;
371 }
372 yajl_gen_map_close(gen);
373
374 yajl_gen_map_close(gen);
375 return 0;
376 } /* }}} int format_metric */
377
378 /* TimeSeries
379 *
380 * {
381 * "metric": {
382 * object(Metric)
383 * },
384 * "resource": {
385 * object(MonitoredResource)
386 * },
387 * "metricKind": enum(MetricKind),
388 * "valueType": enum(ValueType),
389 * "points": [
390 * {
391 * object(Point)
392 * }
393 * ],
394 * }
395 */
396 /* format_time_series formats a TimeSeries object. Returns EAGAIN when a
397 * cumulative metric is seen for the first time and cannot be sent to
398 * Stackdriver due to lack of state. */
399 static int format_time_series(yajl_gen gen, data_set_t const *ds,
400 value_list_t const *vl, int ds_index,
401 sd_resource_t *res) {
402 int ds_type = ds->ds[ds_index].type;
403
404 cdtime_t start_time = 0;
405 int64_t start_value = 0;
406 int status =
407 read_cumulative_state(ds, vl, ds_index, &start_time, &start_value);
408 if (status != 0) {
409 return status;
410 }
411 if (start_time == vl->time) {
412 /* for cumulative metrics, the interval must not be zero. */
413 return EAGAIN;
414 }
415 if (ds_type == DS_TYPE_GAUGE) {
416 double d = (double)vl->values[ds_index].gauge;
417 if (isnan(d) || isinf(d)) {
418 return EAGAIN;
419 }
420 }
421
422 yajl_gen_map_open(gen);
423
424 status = json_string(gen, "metric") || format_metric(gen, ds, vl, ds_index) ||
425 json_string(gen, "resource") || format_gcm_resource(gen, res) ||
426 json_string(gen, "metricKind") || format_metric_kind(gen, ds_type) ||
427 json_string(gen, "valueType") || format_value_type(gen, ds_type) ||
428 json_string(gen, "points");
429 if (status != 0)
430 return status;
431
432 yajl_gen_array_open(gen);
433
434 status = format_point(gen, ds, vl, ds_index, start_time, start_value);
435 if (status != 0)
436 return status;
437
438 yajl_gen_array_close(gen);
439 yajl_gen_map_close(gen);
440 return 0;
441 } /* }}} int format_time_series */
442
443 /* Request body
444 *
445 * {
446 * "timeSeries": [
447 * {
448 * object(TimeSeries)
449 * }
450 * ],
451 * }
452 */
453 static int sd_output_initialize(sd_output_t *out) /* {{{ */
454 {
455 yajl_gen_map_open(out->gen);
456
457 int status = json_string(out->gen, "timeSeries");
458 if (status != 0) {
459 return status;
460 }
461
462 yajl_gen_array_open(out->gen);
463 return 0;
464 } /* }}} int sd_output_initialize */
465
466 static int sd_output_finalize(sd_output_t *out) /* {{{ */
467 {
468 yajl_gen_array_close(out->gen);
469 yajl_gen_map_close(out->gen);
470
471 return 0;
472 } /* }}} int sd_output_finalize */
473
474 static void sd_output_reset_staged(sd_output_t *out) /* {{{ */
475 {
476 void *key = NULL;
477
478 while (c_avl_pick(out->staged, &key, &(void *){NULL}) == 0)
479 sfree(key);
480 } /* }}} void sd_output_reset_staged */
481
482 sd_output_t *sd_output_create(sd_resource_t *res) /* {{{ */
483 {
484 sd_output_t *out = calloc(1, sizeof(*out));
485 if (out == NULL)
486 return NULL;
487
488 out->res = res;
489
490 out->gen = yajl_gen_alloc(/* funcs = */ NULL);
491 if (out->gen == NULL) {
492 sd_output_destroy(out);
493 return NULL;
494 }
495
496 out->staged = c_avl_create((void *)strcmp);
497 if (out->staged == NULL) {
498 sd_output_destroy(out);
499 return NULL;
500 }
501
502 out->metric_descriptors = c_avl_create((void *)strcmp);
503 if (out->metric_descriptors == NULL) {
504 sd_output_destroy(out);
505 return NULL;
506 }
507
508 sd_output_initialize(out);
509
510 return out;
511 } /* }}} sd_output_t *sd_output_create */
512
513 void sd_output_destroy(sd_output_t *out) /* {{{ */
514 {
515 if (out == NULL)
516 return;
517
518 if (out->metric_descriptors != NULL) {
519 void *key = NULL;
520 while (c_avl_pick(out->metric_descriptors, &key, &(void *){NULL}) == 0) {
521 sfree(key);
522 }
523 c_avl_destroy(out->metric_descriptors);
524 out->metric_descriptors = NULL;
525 }
526
527 if (out->staged != NULL) {
528 sd_output_reset_staged(out);
529 c_avl_destroy(out->staged);
530 out->staged = NULL;
531 }
532
533 if (out->gen != NULL) {
534 yajl_gen_free(out->gen);
535 out->gen = NULL;
536 }
537
538 if (out->res != NULL) {
539 sd_resource_destroy(out->res);
540 out->res = NULL;
541 }
542
543 sfree(out);
544 } /* }}} void sd_output_destroy */
545
546 int sd_output_add(sd_output_t *out, data_set_t const *ds,
547 value_list_t const *vl) /* {{{ */
548 {
549 /* first, check that we have all appropriate metric descriptors. */
550 for (size_t i = 0; i < ds->ds_num; i++) {
551 char buffer[4 * DATA_MAX_NAME_LEN];
552 metric_type(buffer, sizeof(buffer), ds, vl, i);
553
554 if (c_avl_get(out->metric_descriptors, buffer, NULL) != 0) {
555 return ENOENT;
556 }
557 }
558
559 char key[6 * DATA_MAX_NAME_LEN];
560 int status = FORMAT_VL(key, sizeof(key), vl);
561 if (status != 0) {
562 ERROR("sd_output_add: FORMAT_VL failed with status %d.", status);
563 return status;
564 }
565
566 if (c_avl_get(out->staged, key, NULL) == 0) {
567 return EEXIST;
568 }
569
570 _Bool staged = 0;
571 for (size_t i = 0; i < ds->ds_num; i++) {
572 int status = format_time_series(out->gen, ds, vl, i, out->res);
573 if (status == EAGAIN) {
574 /* first instance of a cumulative metric or NaN value */
575 continue;
576 }
577 if (status != 0) {
578 ERROR("sd_output_add: format_time_series failed with status %d.", status);
579 return status;
580 }
581 staged = 1;
582 }
583
584 if (staged) {
585 c_avl_insert(out->staged, strdup(key), NULL);
586 }
587
588 size_t json_buffer_size = 0;
589 yajl_gen_get_buf(out->gen, &(unsigned char const *){NULL}, &json_buffer_size);
590 if (json_buffer_size > 65535)
591 return ENOBUFS;
592
593 return 0;
594 } /* }}} int sd_output_add */
595
596 int sd_output_register_metric(sd_output_t *out, data_set_t const *ds,
597 value_list_t const *vl) {
598 /* {{{ */
599 for (size_t i = 0; i < ds->ds_num; i++) {
600 char buffer[4 * DATA_MAX_NAME_LEN];
601 metric_type(buffer, sizeof(buffer), ds, vl, i);
602
603 char *key = strdup(buffer);
604 int status = c_avl_insert(out->metric_descriptors, key, NULL);
605 if (status != 0) {
606 sfree(key);
607 return status;
608 }
609 }
610
611 return 0;
612 } /* }}} int sd_output_register_metric */
613
614 char *sd_output_reset(sd_output_t *out) /* {{{ */
615 {
616 sd_output_finalize(out);
617
618 unsigned char const *json_buffer = NULL;
619 yajl_gen_get_buf(out->gen, &json_buffer, &(size_t){0});
620 char *ret = strdup((void const *)json_buffer);
621
622 sd_output_reset_staged(out);
623
624 yajl_gen_free(out->gen);
625 out->gen = yajl_gen_alloc(/* funcs = */ NULL);
626
627 sd_output_initialize(out);
628
629 return ret;
630 } /* }}} char *sd_output_reset */
631
632 sd_resource_t *sd_resource_create(char const *type) /* {{{ */
633 {
634 sd_resource_t *res = malloc(sizeof(*res));
635 if (res == NULL)
636 return NULL;
637 memset(res, 0, sizeof(*res));
638
639 res->type = strdup(type);
640 if (res->type == NULL) {
641 sfree(res);
642 return NULL;
643 }
644
645 res->labels = NULL;
646 res->labels_num = 0;
647
648 return res;
649 } /* }}} sd_resource_t *sd_resource_create */
650
651 void sd_resource_destroy(sd_resource_t *res) /* {{{ */
652 {
653 if (res == NULL)
654 return;
655
656 for (size_t i = 0; i < res->labels_num; i++) {
657 sfree(res->labels[i].key);
658 sfree(res->labels[i].value);
659 }
660 sfree(res->labels);
661 sfree(res->type);
662 sfree(res);
663 } /* }}} void sd_resource_destroy */
664
665 int sd_resource_add_label(sd_resource_t *res, char const *key,
666 char const *value) /* {{{ */
667 {
668 if ((res == NULL) || (key == NULL) || (value == NULL))
669 return EINVAL;
670
671 sd_label_t *l =
672 realloc(res->labels, sizeof(*res->labels) * (res->labels_num + 1));
673 if (l == NULL)
674 return ENOMEM;
675
676 res->labels = l;
677 l = res->labels + res->labels_num;
678
679 l->key = strdup(key);
680 l->value = strdup(value);
681 if ((l->key == NULL) || (l->value == NULL)) {
682 sfree(l->key);
683 sfree(l->value);
684 return ENOMEM;
685 }
686
687 res->labels_num++;
688 return 0;
689 } /* }}} int sd_resource_add_label */
690
691 /* LabelDescriptor
692 *
693 * {
694 * "key": string,
695 * "valueType": enum(ValueType),
696 * "description": string,
697 * }
698 */
699 static int format_label_descriptor(yajl_gen gen, char const *key) {
700 /* {{{ */
701 yajl_gen_map_open(gen);
702
703 int status = json_string(gen, "key") || json_string(gen, key) ||
704 json_string(gen, "valueType") || json_string(gen, "STRING");
705 if (status != 0) {
706 return status;
707 }
708
709 yajl_gen_map_close(gen);
710 return 0;
711 } /* }}} int format_label_descriptor */
712
713 /* MetricDescriptor
714 *
715 * {
716 * "name": string,
717 * "type": string,
718 * "labels": [
719 * {
720 * object(LabelDescriptor)
721 * }
722 * ],
723 * "metricKind": enum(MetricKind),
724 * "valueType": enum(ValueType),
725 * "unit": string,
726 * "description": string,
727 * "displayName": string,
728 * }
729 */
730 int sd_format_metric_descriptor(char *buffer, size_t buffer_size,
731 data_set_t const *ds, value_list_t const *vl,
732 int ds_index) {
733 /* {{{ */
734 yajl_gen gen = yajl_gen_alloc(/* funcs = */ NULL);
735 if (gen == NULL) {
736 return ENOMEM;
737 }
738
739 int ds_type = ds->ds[ds_index].type;
740
741 yajl_gen_map_open(gen);
742
743 int status =
744 json_string(gen, "type") || format_metric_type(gen, ds, vl, ds_index) ||
745 json_string(gen, "metricKind") || format_metric_kind(gen, ds_type) ||
746 json_string(gen, "valueType") || format_value_type(gen, ds_type) ||
747 json_string(gen, "labels");
748 if (status != 0) {
749 yajl_gen_free(gen);
750 return status;
751 }
752
753 char const *labels[] = {"host", "plugin_instance", "type_instance"};
754 yajl_gen_array_open(gen);
755
756 for (size_t i = 0; i < STATIC_ARRAY_SIZE(labels); i++) {
757 int status = format_label_descriptor(gen, labels[i]);
758 if (status != 0) {
759 yajl_gen_free(gen);
760 return status;
761 }
762 }
763
764 yajl_gen_array_close(gen);
765 yajl_gen_map_close(gen);
766
767 unsigned char const *tmp = NULL;
768 yajl_gen_get_buf(gen, &tmp, &(size_t){0});
769 sstrncpy(buffer, (void const *)tmp, buffer_size);
770
771 yajl_gen_free(gen);
772 return 0;
773 } /* }}} int sd_format_metric_descriptor */