src/nginx.c

   1 /**
   2  * collectd - src/nginx.c
   3  * Copyright (C) 2006-2010  Florian octo Forster
   4  * Copyright (C) 2008       Sebastian Harl
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  21  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  22  * DEALINGS IN THE SOFTWARE.
  23  *
  24  * Authors:
  25  *   Florian octo Forster <octo at collectd.org>
  26  *   Sebastian Harl <sh at tokkee.org>
  27  **/
  28
  29 #include "collectd.h"
  30
  31 #include "common.h"
  32 #include "plugin.h"
  33
  34 #include <curl/curl.h>
  35
  36 static char *url = NULL;
  37 static char *user = NULL;
  38 static char *pass = NULL;
  39 static char *verify_peer = NULL;
  40 static char *verify_host = NULL;
  41 static char *cacert = NULL;
  42 static char *timeout = NULL;
  43
  44 static CURL *curl = NULL;
  45
  46 static char nginx_buffer[16384];
  47 static size_t nginx_buffer_len = 0;
  48 static char nginx_curl_error[CURL_ERROR_SIZE];
  49
  50 static const char *config_keys[] = {
  51     "URL", "User", "Password", "VerifyPeer", "VerifyHost", "CACert", "Timeout"};
  52 static int config_keys_num = STATIC_ARRAY_SIZE(config_keys);
  53
  54 static size_t nginx_curl_callback(void *buf, size_t size, size_t nmemb,
  55                                   void __attribute__((unused)) * stream) {
  56   size_t len = size * nmemb;
  57
  58   /* Check if the data fits into the memory. If not, truncate it. */
  59   if ((nginx_buffer_len + len) >= sizeof(nginx_buffer)) {
  60     assert(sizeof(nginx_buffer) > nginx_buffer_len);
  61     len = (sizeof(nginx_buffer) - 1) - nginx_buffer_len;
  62   }
  63
  64   if (len == 0)
  65     return (len);
  66
  67   memcpy(&nginx_buffer[nginx_buffer_len], buf, len);
  68   nginx_buffer_len += len;
  69   nginx_buffer[nginx_buffer_len] = 0;
  70
  71   return (len);
  72 }
  73
  74 static int config_set(char **var, const char *value) {
  75   if (*var != NULL) {
  76     free(*var);
  77     *var = NULL;
  78   }
  79
  80   if ((*var = strdup(value)) == NULL)
  81     return (1);
  82   else
  83     return (0);
  84 }
  85
  86 static int config(const char *key, const char *value) {
  87   if (strcasecmp(key, "url") == 0)
  88     return (config_set(&url, value));
  89   else if (strcasecmp(key, "user") == 0)
  90     return (config_set(&user, value));
  91   else if (strcasecmp(key, "password") == 0)
  92     return (config_set(&pass, value));
  93   else if (strcasecmp(key, "verifypeer") == 0)
  94     return (config_set(&verify_peer, value));
  95   else if (strcasecmp(key, "verifyhost") == 0)
  96     return (config_set(&verify_host, value));
  97   else if (strcasecmp(key, "cacert") == 0)
  98     return (config_set(&cacert, value));
  99   else if (strcasecmp(key, "timeout") == 0)
 100     return (config_set(&timeout, value));
 101   else
 102     return (-1);
 103 } /* int config */
 104
 105 static int init(void) {
 106   if (curl != NULL)
 107     curl_easy_cleanup(curl);
 108
 109   if ((curl = curl_easy_init()) == NULL) {
 110     ERROR("nginx plugin: curl_easy_init failed.");
 111     return (-1);
 112   }
 113
 114   curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1L);
 115   curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, nginx_curl_callback);
 116   curl_easy_setopt(curl, CURLOPT_USERAGENT, COLLECTD_USERAGENT);
 117   curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, nginx_curl_error);
 118
 119   if (user != NULL) {
 120 #ifdef HAVE_CURLOPT_USERNAME
 121     curl_easy_setopt(curl, CURLOPT_USERNAME, user);
 122     curl_easy_setopt(curl, CURLOPT_PASSWORD, (pass == NULL) ? "" : pass);
 123 #else
 124     static char credentials[1024];
 125     int status = ssnprintf(credentials, sizeof(credentials), "%s:%s", user,
 126                            pass == NULL ? "" : pass);
 127     if ((status < 0) || ((size_t)status >= sizeof(credentials))) {
 128       ERROR("nginx plugin: Credentials would have been truncated.");
 129       return (-1);
 130     }
 131
 132     curl_easy_setopt(curl, CURLOPT_USERPWD, credentials);
 133 #endif
 134   }
 135
 136   if (url != NULL) {
 137     curl_easy_setopt(curl, CURLOPT_URL, url);
 138   }
 139
 140   curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
 141   curl_easy_setopt(curl, CURLOPT_MAXREDIRS, 50L);
 142
 143   if ((verify_peer == NULL) || IS_TRUE(verify_peer)) {
 144     curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);
 145   } else {
 146     curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0L);
 147   }
 148
 149   if ((verify_host == NULL) || IS_TRUE(verify_host)) {
 150     curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2L);
 151   } else {
 152     curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0L);
 153   }
 154
 155   if (cacert != NULL) {
 156     curl_easy_setopt(curl, CURLOPT_CAINFO, cacert);
 157   }
 158
 159 #ifdef HAVE_CURLOPT_TIMEOUT_MS
 160   if (timeout != NULL) {
 161     curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, atol(timeout));
 162   } else {
 163     curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS,
 164                      (long)CDTIME_T_TO_MS(plugin_get_interval()));
 165   }
 166 #endif
 167
 168   return (0);
 169 } /* void init */
 170
 171 static void submit(const char *type, const char *inst, long long value) {
 172   value_t values[1];
 173   value_list_t vl = VALUE_LIST_INIT;
 174
 175   if (strcmp(type, "nginx_connections") == 0)
 176     values[0].gauge = value;
 177   else if (strcmp(type, "nginx_requests") == 0)
 178     values[0].derive = value;
 179   else if (strcmp(type, "connections") == 0)
 180     values[0].derive = value;
 181   else
 182     return;
 183
 184   vl.values = values;
 185   vl.values_len = STATIC_ARRAY_SIZE(values);
 186   sstrncpy(vl.plugin, "nginx", sizeof(vl.plugin));
 187   sstrncpy(vl.type, type, sizeof(vl.type));
 188
 189   if (inst != NULL)
 190     sstrncpy(vl.type_instance, inst, sizeof(vl.type_instance));
 191
 192   plugin_dispatch_values(&vl);
 193 } /* void submit */
 194
 195 static int nginx_read(void) {
 196   char *ptr;
 197   char *lines[16];
 198   int lines_num = 0;
 199   char *saveptr;
 200
 201   char *fields[16];
 202   int fields_num;
 203
 204   if (curl == NULL)
 205     return (-1);
 206   if (url == NULL)
 207     return (-1);
 208
 209   nginx_buffer_len = 0;
 210   if (curl_easy_perform(curl) != CURLE_OK) {
 211     WARNING("nginx plugin: curl_easy_perform failed: %s", nginx_curl_error);
 212     return (-1);
 213   }
 214
 215   ptr = nginx_buffer;
 216   saveptr = NULL;
 217   while ((lines[lines_num] = strtok_r(ptr, "\n\r", &saveptr)) != NULL) {
 218     ptr = NULL;
 219     lines_num++;
 220
 221     if (lines_num >= 16)
 222       break;
 223   }
 224
 225   /*
 226    * Active connections: 291
 227    * server accepts handled requests
 228    *  101059015 100422216 347910649
 229    * Reading: 6 Writing: 179 Waiting: 106
 230    */
 231   for (int i = 0; i < lines_num; i++) {
 232     fields_num =
 233         strsplit(lines[i], fields, (sizeof(fields) / sizeof(fields[0])));
 234
 235     if (fields_num == 3) {
 236       if ((strcmp(fields[0], "Active") == 0) &&
 237           (strcmp(fields[1], "connections:") == 0)) {
 238         submit("nginx_connections", "active", atoll(fields[2]));
 239       } else if ((atoll(fields[0]) != 0) && (atoll(fields[1]) != 0) &&
 240                  (atoll(fields[2]) != 0)) {
 241         submit("connections", "accepted", atoll(fields[0]));
 242         /* TODO: The legacy metric "handled", which is the sum of "accepted" and
 243          * "failed", is reported for backwards compatibility only. Remove in the
 244          * next major version. */
 245         submit("connections", "handled", atoll(fields[1]));
 246         submit("connections", "failed", (atoll(fields[0]) - atoll(fields[1])));
 247         submit("nginx_requests", NULL, atoll(fields[2]));
 248       }
 249     } else if (fields_num == 6) {
 250       if ((strcmp(fields[0], "Reading:") == 0) &&
 251           (strcmp(fields[2], "Writing:") == 0) &&
 252           (strcmp(fields[4], "Waiting:") == 0)) {
 253         submit("nginx_connections", "reading", atoll(fields[1]));
 254         submit("nginx_connections", "writing", atoll(fields[3]));
 255         submit("nginx_connections", "waiting", atoll(fields[5]));
 256       }
 257     }
 258   }
 259
 260   nginx_buffer_len = 0;
 261
 262   return (0);
 263 } /* int nginx_read */
 264
 265 void module_register(void) {
 266   plugin_register_config("nginx", config, config_keys, config_keys_num);
 267   plugin_register_init("nginx", init);
 268   plugin_register_read("nginx", nginx_read);
 269 } /* void module_register */