usr.sbin/prometheus_sysctl_exporter/prometheus_sysctl_exporter.c

   1 /*-
   2  * Copyright (c) 2016-2017 Nuxi, https://nuxi.nl/
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  */
  25
  26 #include <sys/cdefs.h>
  27 __FBSDID("$FreeBSD$");
  28
  29 #include <sys/param.h>
  30 #include <sys/resource.h>
  31 #include <sys/socket.h>
  32 #include <sys/sysctl.h>
  33
  34 #include <assert.h>
  35 #include <ctype.h>
  36 #include <err.h>
  37 #include <errno.h>
  38 #include <math.h>
  39 #include <stdbool.h>
  40 #include <stdint.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <unistd.h>
  45 #include <zlib.h>
  46
  47 /*
  48  * Cursor for iterating over all of the system's sysctl OIDs.
  49  */
  50 struct oid {
  51         int     id[CTL_MAXNAME];
  52         size_t  len;
  53 };
  54
  55 /* Initializes the cursor to point to start of the tree. */
  56 static void
  57 oid_get_root(struct oid *o)
  58 {
  59
  60         o->id[0] = 1;
  61         o->len = 1;
  62 }
  63
  64 /* Obtains the OID for a sysctl by name. */
  65 static void
  66 oid_get_by_name(struct oid *o, const char *name)
  67 {
  68
  69         o->len = nitems(o->id);
  70         if (sysctlnametomib(name, o->id, &o->len) != 0)
  71                 err(1, "sysctl(%s)", name);
  72 }
  73
  74 /* Returns whether an OID is placed below another OID. */
  75 static bool
  76 oid_is_beneath(struct oid *oa, struct oid *ob)
  77 {
  78
  79         return (oa->len >= ob->len &&
  80             memcmp(oa->id, ob->id, ob->len * sizeof(oa->id[0])) == 0);
  81 }
  82
  83 /* Advances the cursor to the next OID. */
  84 static bool
  85 oid_get_next(const struct oid *cur, struct oid *next)
  86 {
  87         int lookup[CTL_MAXNAME + 2];
  88         size_t nextsize;
  89
  90         lookup[0] = 0;
  91         lookup[1] = 2;
  92         memcpy(lookup + 2, cur->id, cur->len * sizeof(lookup[0]));
  93         nextsize = sizeof(next->id);
  94         if (sysctl(lookup, 2 + cur->len, &next->id, &nextsize, 0, 0) != 0) {
  95                 if (errno == ENOENT)
  96                         return (false);
  97                 err(1, "sysctl(next)");
  98         }
  99         next->len = nextsize / sizeof(next->id[0]);
 100         return (true);
 101 }
 102
 103 /*
 104  * OID formatting metadata.
 105  */
 106 struct oidformat {
 107         unsigned int    kind;
 108         char            format[BUFSIZ];
 109 };
 110
 111 /* Returns whether the OID represents a temperature value. */
 112 static bool
 113 oidformat_is_temperature(const struct oidformat *of)
 114 {
 115
 116         return (of->format[0] == 'I' && of->format[1] == 'K');
 117 }
 118
 119 /* Returns whether the OID represents a timeval structure. */
 120 static bool
 121 oidformat_is_timeval(const struct oidformat *of)
 122 {
 123
 124         return (strcmp(of->format, "S,timeval") == 0);
 125 }
 126
 127 /* Fetches the formatting metadata for an OID. */
 128 static bool
 129 oid_get_format(const struct oid *o, struct oidformat *of)
 130 {
 131         int lookup[CTL_MAXNAME + 2];
 132         size_t oflen;
 133
 134         lookup[0] = 0;
 135         lookup[1] = 4;
 136         memcpy(lookup + 2, o->id, o->len * sizeof(lookup[0]));
 137         oflen = sizeof(*of);
 138         if (sysctl(lookup, 2 + o->len, of, &oflen, 0, 0) != 0) {
 139                 if (errno == ENOENT)
 140                         return (false);
 141                 err(1, "sysctl(oidfmt)");
 142         }
 143         return (true);
 144 }
 145
 146 /*
 147  * Container for holding the value of an OID.
 148  */
 149 struct oidvalue {
 150         enum { SIGNED, UNSIGNED, FLOAT } type;
 151         union {
 152                 intmax_t        s;
 153                 uintmax_t       u;
 154                 double          f;
 155         } value;
 156 };
 157
 158 /* Extracts the value of an OID, converting it to a floating-point number. */
 159 static double
 160 oidvalue_get_float(const struct oidvalue *ov)
 161 {
 162
 163         switch (ov->type) {
 164         case SIGNED:
 165                 return (ov->value.s);
 166         case UNSIGNED:
 167                 return (ov->value.u);
 168         case FLOAT:
 169                 return (ov->value.f);
 170         default:
 171                 assert(0 && "Unknown value type");
 172         }
 173 }
 174
 175 /* Sets the value of an OID as a signed integer. */
 176 static void
 177 oidvalue_set_signed(struct oidvalue *ov, intmax_t s)
 178 {
 179
 180         ov->type = SIGNED;
 181         ov->value.s = s;
 182 }
 183
 184 /* Sets the value of an OID as an unsigned integer. */
 185 static void
 186 oidvalue_set_unsigned(struct oidvalue *ov, uintmax_t u)
 187 {
 188
 189         ov->type = UNSIGNED;
 190         ov->value.u = u;
 191 }
 192
 193 /* Sets the value of an OID as a floating-point number. */
 194 static void
 195 oidvalue_set_float(struct oidvalue *ov, double f)
 196 {
 197
 198         ov->type = FLOAT;
 199         ov->value.f = f;
 200 }
 201
 202 /* Prints the value of an OID to a file stream. */
 203 static void
 204 oidvalue_print(const struct oidvalue *ov, FILE *fp)
 205 {
 206
 207         switch (ov->type) {
 208         case SIGNED:
 209                 fprintf(fp, "%jd", ov->value.s);
 210                 break;
 211         case UNSIGNED:
 212                 fprintf(fp, "%ju", ov->value.u);
 213                 break;
 214         case FLOAT:
 215                 switch (fpclassify(ov->value.f)) {
 216                 case FP_INFINITE:
 217                         if (signbit(ov->value.f))
 218                                 fprintf(fp, "-Inf");
 219                         else
 220                                 fprintf(fp, "+Inf");
 221                         break;
 222                 case FP_NAN:
 223                         fprintf(fp, "Nan");
 224                         break;
 225                 default:
 226                         fprintf(fp, "%.6f", ov->value.f);
 227                         break;
 228                 }
 229                 break;
 230         }
 231 }
 232
 233 /* Fetches the value of an OID. */
 234 static bool
 235 oid_get_value(const struct oid *o, const struct oidformat *of,
 236     struct oidvalue *ov)
 237 {
 238
 239         switch (of->kind & CTLTYPE) {
 240 #define GET_VALUE(ctltype, type) \
 241         case (ctltype): {                                               \
 242                 type value;                                             \
 243                 size_t valuesize;                                       \
 244                                                                         \
 245                 valuesize = sizeof(value);                              \
 246                 if (sysctl(o->id, o->len, &value, &valuesize, 0, 0) != 0) \
 247                         return (false);                                 \
 248                 if ((type)-1 > 0)                                       \
 249                         oidvalue_set_unsigned(ov, value);               \
 250                 else                                                    \
 251                         oidvalue_set_signed(ov, value);                 \
 252                 break;                                                  \
 253         }
 254         GET_VALUE(CTLTYPE_INT, int);
 255         GET_VALUE(CTLTYPE_UINT, unsigned int);
 256         GET_VALUE(CTLTYPE_LONG, long);
 257         GET_VALUE(CTLTYPE_ULONG, unsigned long);
 258         GET_VALUE(CTLTYPE_S8, int8_t);
 259         GET_VALUE(CTLTYPE_U8, uint8_t);
 260         GET_VALUE(CTLTYPE_S16, int16_t);
 261         GET_VALUE(CTLTYPE_U16, uint16_t);
 262         GET_VALUE(CTLTYPE_S32, int32_t);
 263         GET_VALUE(CTLTYPE_U32, uint32_t);
 264         GET_VALUE(CTLTYPE_S64, int64_t);
 265         GET_VALUE(CTLTYPE_U64, uint64_t);
 266 #undef GET_VALUE
 267         case CTLTYPE_OPAQUE:
 268                 if (oidformat_is_timeval(of)) {
 269                         struct timeval tv;
 270                         size_t tvsize;
 271
 272                         tvsize = sizeof(tv);
 273                         if (sysctl(o->id, o->len, &tv, &tvsize, 0, 0) != 0)
 274                                 return (false);
 275                         oidvalue_set_float(ov,
 276                             (double)tv.tv_sec + (double)tv.tv_usec / 1000000);
 277                         return (true);
 278                 } else if (strcmp(of->format, "S,loadavg") == 0) {
 279                         struct loadavg la;
 280                         size_t lasize;
 281
 282                         /*
 283                          * Only return the one minute load average, as
 284                          * the others can be inferred using avg_over_time().
 285                          */
 286                         lasize = sizeof(la);
 287                         if (sysctl(o->id, o->len, &la, &lasize, 0, 0) != 0)
 288                                 return (false);
 289                         oidvalue_set_float(ov,
 290                             (double)la.ldavg[0] / (double)la.fscale);
 291                         return (true);
 292                 }
 293                 return (false);
 294         default:
 295                 return (false);
 296         }
 297
 298         /* Convert temperatures from decikelvin to degrees Celcius. */
 299         if (oidformat_is_temperature(of)) {
 300                 double v;
 301                 int e;
 302
 303                 v = oidvalue_get_float(ov);
 304                 if (v < 0) {
 305                         oidvalue_set_float(ov, NAN);
 306                 } else {
 307                         e = of->format[2] >= '0' && of->format[2] <= '9' ?
 308                             of->format[2] - '0' : 1;
 309                         oidvalue_set_float(ov, v / pow(10, e) - 273.15);
 310                 }
 311         }
 312         return (true);
 313 }
 314
 315 /*
 316  * The full name of an OID, stored as a series of components.
 317  */
 318 struct oidname {
 319         struct oid      oid;
 320         char            names[BUFSIZ];
 321         char            labels[BUFSIZ];
 322 };
 323
 324 /*
 325  * Initializes the OID name object with an empty value.
 326  */
 327 static void
 328 oidname_init(struct oidname *on)
 329 {
 330
 331         on->oid.len = 0;
 332 }
 333
 334 /* Fetches the name and labels of an OID, reusing the previous results. */
 335 static void
 336 oid_get_name(const struct oid *o, struct oidname *on)
 337 {
 338         int lookup[CTL_MAXNAME + 2];
 339         char *c, *label;
 340         size_t i, len;
 341
 342         /* Fetch the name and split it up in separate components. */
 343         lookup[0] = 0;
 344         lookup[1] = 1;
 345         memcpy(lookup + 2, o->id, o->len * sizeof(lookup[0]));
 346         len = sizeof(on->names);
 347         if (sysctl(lookup, 2 + o->len, on->names, &len, 0, 0) != 0)
 348                 err(1, "sysctl(name)");
 349         for (c = strchr(on->names, '.'); c != NULL; c = strchr(c + 1, '.'))
 350                 *c = '\0';
 351
 352         /* No need to fetch labels for components that we already have. */
 353         label = on->labels;
 354         for (i = 0; i < o->len && i < on->oid.len && o->id[i] == on->oid.id[i];
 355             ++i)
 356                 label += strlen(label) + 1;
 357
 358         /* Fetch the remaining labels. */
 359         lookup[1] = 6;
 360         for (; i < o->len; ++i) {
 361                 len = on->labels + sizeof(on->labels) - label;
 362                 if (sysctl(lookup, 2 + i + 1, label, &len, 0, 0) == 0) {
 363                         label += len;
 364                 } else if (errno == ENOENT) {
 365                         *label++ = '\0';
 366                 } else {
 367                         err(1, "sysctl(oidlabel)");
 368                 }
 369         }
 370         on->oid = *o;
 371 }
 372
 373 /* Prints the name and labels of an OID to a file stream. */
 374 static void
 375 oidname_print(const struct oidname *on, const struct oidformat *of,
 376     FILE *fp)
 377 {
 378         const char *name, *label;
 379         size_t i;
 380         char separator;
 381
 382         /* Print the name of the metric. */
 383         fprintf(fp, "sysctl");
 384         name = on->names;
 385         label = on->labels;
 386         for (i = 0; i < on->oid.len; ++i) {
 387                 if (*label == '\0') {
 388                         fputc('_', fp);
 389                         while (*name != '\0') {
 390                                 /* Map unsupported characters to underscores. */
 391                                 fputc(isalnum(*name) ? *name : '_', fp);
 392                                 ++name;
 393                         }
 394                 }
 395                 name += strlen(name) + 1;
 396                 label += strlen(label) + 1;
 397         }
 398         if (oidformat_is_temperature(of))
 399                 fprintf(fp, "_celcius");
 400         else if (oidformat_is_timeval(of))
 401                 fprintf(fp, "_seconds");
 402
 403         /* Print the labels of the metric. */
 404         name = on->names;
 405         label = on->labels;
 406         separator = '{';
 407         for (i = 0; i < on->oid.len; ++i) {
 408                 if (*label != '\0') {
 409                         assert(label[strspn(label,
 410                             "abcdefghijklmnopqrstuvwxyz"
 411                             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 412                             "0123456789_")] == '\0');
 413                         fprintf(fp, "%c%s=\"", separator, label);
 414                         while (*name != '\0') {
 415                                 /* Escape backslashes and double quotes. */
 416                                 if (*name == '\\' || *name == '"')
 417                                         fputc('\\', fp);
 418                                 fputc(*name++, fp);
 419                         }
 420                         fputc('"', fp);
 421                         separator = ',';
 422                 }
 423                 name += strlen(name) + 1;
 424                 label += strlen(label) + 1;
 425         }
 426         if (separator != '{')
 427                 fputc('}', fp);
 428 }
 429
 430 /* Returns whether the OID name has any labels associated to it. */
 431 static bool
 432 oidname_has_labels(const struct oidname *on)
 433 {
 434         size_t i;
 435
 436         for (i = 0; i < on->oid.len; ++i)
 437                 if (on->labels[i] != 0)
 438                         return (true);
 439         return (false);
 440 }
 441
 442 /*
 443  * The description of an OID.
 444  */
 445 struct oiddescription {
 446         char description[BUFSIZ];
 447 };
 448
 449 /*
 450  * Fetches the description of an OID.
 451  */
 452 static bool
 453 oid_get_description(const struct oid *o, struct oiddescription *od)
 454 {
 455         int lookup[CTL_MAXNAME + 2];
 456         char *newline;
 457         size_t odlen;
 458
 459         lookup[0] = 0;
 460         lookup[1] = 5;
 461         memcpy(lookup + 2, o->id, o->len * sizeof(lookup[0]));
 462         odlen = sizeof(od->description);
 463         if (sysctl(lookup, 2 + o->len, &od->description, &odlen, 0, 0) != 0) {
 464                 if (errno == ENOENT)
 465                         return (false);
 466                 err(1, "sysctl(oiddescr)");
 467         }
 468
 469         newline = strchr(od->description, '\n');
 470         if (newline != NULL)
 471                 *newline = '\0';
 472
 473         return (*od->description != '\0');
 474 }
 475
 476 /* Prints the description of an OID to a file stream. */
 477 static void
 478 oiddescription_print(const struct oiddescription *od, FILE *fp)
 479 {
 480
 481         fprintf(fp, "%s", od->description);
 482 }
 483
 484 static void
 485 oid_print(const struct oid *o, struct oidname *on, bool print_description,
 486     FILE *fp)
 487 {
 488         struct oidformat of;
 489         struct oidvalue ov;
 490         struct oiddescription od;
 491
 492         if (!oid_get_format(o, &of) || !oid_get_value(o, &of, &ov))
 493                 return;
 494         oid_get_name(o, on);
 495
 496         /*
 497          * Print the line with the description. Prometheus expects a
 498          * single unique description for every metric, which cannot be
 499          * guaranteed by sysctl if labels are present. Omit the
 500          * description if labels are present.
 501          */
 502         if (print_description && !oidname_has_labels(on) &&
 503             oid_get_description(o, &od)) {
 504                 fprintf(fp, "# HELP ");
 505                 oidname_print(on, &of, fp);
 506                 fputc(' ', fp);
 507                 oiddescription_print(&od, fp);
 508                 fputc('\n', fp);
 509         }
 510
 511         /* Print the line with the value. */
 512         oidname_print(on, &of, fp);
 513         fputc(' ', fp);
 514         oidvalue_print(&ov, fp);
 515         fputc('\n', fp);
 516 }
 517
 518 /* Gzip compresses a buffer of memory. */
 519 static bool
 520 buf_gzip(const char *in, size_t inlen, char *out, size_t *outlen)
 521 {
 522         z_stream stream = {
 523             .next_in    = __DECONST(unsigned char *, in),
 524             .avail_in   = inlen,
 525             .next_out   = (unsigned char *)out,
 526             .avail_out  = *outlen,
 527         };
 528
 529         if (deflateInit2(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED,
 530             MAX_WBITS + 16, 8, Z_DEFAULT_STRATEGY) != Z_OK ||
 531             deflate(&stream, Z_FINISH) != Z_STREAM_END) {
 532                 return (false);
 533         }
 534         *outlen = stream.total_out;
 535         return (deflateEnd(&stream) == Z_OK);
 536 }
 537
 538 static void
 539 usage(void)
 540 {
 541
 542         fprintf(stderr,
 543             "usage: prometheus_sysctl_exporter [-dgh] [prefix ...]\n");
 544         exit(1);
 545 }
 546
 547 int
 548 main(int argc, char *argv[])
 549 {
 550         struct oidname on;
 551         char *http_buf;
 552         FILE *fp;
 553         size_t http_buflen;
 554         int ch;
 555         bool gzip_mode, http_mode, print_descriptions;
 556
 557         /* Parse command line flags. */
 558         gzip_mode = http_mode = print_descriptions = false;
 559         while ((ch = getopt(argc, argv, "dgh")) != -1) {
 560                 switch (ch) {
 561                 case 'd':
 562                         print_descriptions = true;
 563                         break;
 564                 case 'g':
 565                         gzip_mode = true;
 566                         break;
 567                 case 'h':
 568                         http_mode = true;
 569                         break;
 570                 default:
 571                         usage();
 572                 }
 573         }
 574         argc -= optind;
 575         argv += optind;
 576
 577         /* HTTP output: cache metrics in buffer. */
 578         if (http_mode) {
 579                 fp = open_memstream(&http_buf, &http_buflen);
 580                 if (fp == NULL)
 581                         err(1, "open_memstream");
 582         } else {
 583                 fp = stdout;
 584         }
 585
 586         oidname_init(&on);
 587         if (argc == 0) {
 588                 struct oid o;
 589
 590                 /* Print all OIDs. */
 591                 oid_get_root(&o);
 592                 do {
 593                         oid_print(&o, &on, print_descriptions, fp);
 594                 } while (oid_get_next(&o, &o));
 595         } else {
 596                 int i;
 597
 598                 /* Print only trees provided as arguments. */
 599                 for (i = 0; i < argc; ++i) {
 600                         struct oid o, root;
 601
 602                         oid_get_by_name(&root, argv[i]);
 603                         o = root;
 604                         do {
 605                                 oid_print(&o, &on, print_descriptions, fp);
 606                         } while (oid_get_next(&o, &o) &&
 607                             oid_is_beneath(&o, &root));
 608                 }
 609         }
 610
 611         if (http_mode) {
 612                 const char *content_encoding = "";
 613
 614                 if (ferror(fp) || fclose(fp) != 0)
 615                         err(1, "Cannot generate output");
 616
 617                 /* Gzip compress the output. */
 618                 if (gzip_mode) {
 619                         char *buf;
 620                         size_t buflen;
 621
 622                         buflen = http_buflen;
 623                         buf = malloc(buflen);
 624                         if (buf == NULL)
 625                                 err(1, "Cannot allocate compression buffer");
 626                         if (buf_gzip(http_buf, http_buflen, buf, &buflen)) {
 627                                 content_encoding = "Content-Encoding: gzip\r\n";
 628                                 free(http_buf);
 629                                 http_buf = buf;
 630                                 http_buflen = buflen;
 631                         } else {
 632                                 free(buf);
 633                         }
 634                 }
 635
 636                 /* Print HTTP header and metrics. */
 637                 dprintf(STDOUT_FILENO,
 638                     "HTTP/1.1 200 OK\r\n"
 639                     "Connection: close\r\n"
 640                     "%s"
 641                     "Content-Length: %zu\r\n"
 642                     "Content-Type: text/plain; version=0.0.4\r\n"
 643                     "\r\n",
 644                     content_encoding, http_buflen);
 645                 write(STDOUT_FILENO, http_buf, http_buflen);
 646                 free(http_buf);
 647
 648                 /* Drain output. */
 649                 if (shutdown(STDIN_FILENO, SHUT_WR) == 0) {
 650                         char buf[1024];
 651
 652                         while (read(STDIN_FILENO, buf, sizeof(buf)) > 0) {
 653                         }
 654                 }
 655         }
 656         return (0);
 657 }