src/write_stackdriver.c

   1 /**
   2  * collectd - src/write_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 "configfile.h"
  26 #include "plugin.h"
  27 #include "utils/common/common.h"
  28 #include "utils/format_stackdriver/format_stackdriver.h"
  29 #include "utils/gce/gce.h"
  30 #include "utils/oauth/oauth.h"
  31
  32 #include <curl/curl.h>
  33 #include <pthread.h>
  34 #include <yajl/yajl_tree.h>
  35
  36 /*
  37  * Private variables
  38  */
  39 #ifndef GCM_API_URL
  40 #define GCM_API_URL "https://monitoring.googleapis.com/v3"
  41 #endif
  42
  43 #ifndef MONITORING_SCOPE
  44 #define MONITORING_SCOPE "https://www.googleapis.com/auth/monitoring"
  45 #endif
  46
  47 struct wg_callback_s {
  48   /* config */
  49   char *email;
  50   char *project;
  51   char *url;
  52   sd_resource_t *resource;
  53
  54   /* runtime */
  55   oauth_t *auth;
  56   sd_output_t *formatter;
  57   CURL *curl;
  58   char curl_errbuf[CURL_ERROR_SIZE];
  59   /* used by flush */
  60   size_t timeseries_count;
  61   cdtime_t send_buffer_init_time;
  62
  63   pthread_mutex_t lock;
  64 };
  65 typedef struct wg_callback_s wg_callback_t;
  66
  67 struct wg_memory_s {
  68   char *memory;
  69   size_t size;
  70 };
  71 typedef struct wg_memory_s wg_memory_t;
  72
  73 static size_t wg_write_memory_cb(void *contents, size_t size,
  74                                  size_t nmemb, /* {{{ */
  75                                  void *userp) {
  76   size_t realsize = size * nmemb;
  77   wg_memory_t *mem = (wg_memory_t *)userp;
  78
  79   if (0x7FFFFFF0 < mem->size || 0x7FFFFFF0 - mem->size < realsize) {
  80     ERROR("integer overflow");
  81     return 0;
  82   }
  83
  84   mem->memory = (char *)realloc((void *)mem->memory, mem->size + realsize + 1);
  85   if (mem->memory == NULL) {
  86     /* out of memory! */
  87     ERROR("wg_write_memory_cb: not enough memory (realloc returned NULL)");
  88     return 0;
  89   }
  90
  91   memcpy(&(mem->memory[mem->size]), contents, realsize);
  92   mem->size += realsize;
  93   mem->memory[mem->size] = 0;
  94   return realsize;
  95 } /* }}} size_t wg_write_memory_cb */
  96
  97 static char *wg_get_authorization_header(wg_callback_t *cb) { /* {{{ */
  98   int status = 0;
  99   char access_token[256];
 100   char authorization_header[256];
 101
 102   assert((cb->auth != NULL) || gce_check());
 103   if (cb->auth != NULL)
 104     status = oauth_access_token(cb->auth, access_token, sizeof(access_token));
 105   else
 106     status = gce_access_token(cb->email, access_token, sizeof(access_token));
 107   if (status != 0) {
 108     ERROR("write_stackdriver plugin: Failed to get access token");
 109     return NULL;
 110   }
 111
 112   status = ssnprintf(authorization_header, sizeof(authorization_header),
 113                      "Authorization: Bearer %s", access_token);
 114   if ((status < 1) || ((size_t)status >= sizeof(authorization_header)))
 115     return NULL;
 116
 117   return strdup(authorization_header);
 118 } /* }}} char *wg_get_authorization_header */
 119
 120 typedef struct {
 121   int code;
 122   char *message;
 123 } api_error_t;
 124
 125 static api_error_t *parse_api_error(char const *body) {
 126   char errbuf[1024];
 127   yajl_val root = yajl_tree_parse(body, errbuf, sizeof(errbuf));
 128   if (root == NULL) {
 129     ERROR("write_stackdriver plugin: yajl_tree_parse failed: %s", errbuf);
 130     return NULL;
 131   }
 132
 133   api_error_t *err = calloc(1, sizeof(*err));
 134   if (err == NULL) {
 135     ERROR("write_stackdriver plugin: calloc failed");
 136     yajl_tree_free(root);
 137     return NULL;
 138   }
 139
 140   yajl_val code = yajl_tree_get(root, (char const *[]){"error", "code", NULL},
 141                                 yajl_t_number);
 142   if (YAJL_IS_INTEGER(code)) {
 143     err->code = YAJL_GET_INTEGER(code);
 144   }
 145
 146   yajl_val message = yajl_tree_get(
 147       root, (char const *[]){"error", "message", NULL}, yajl_t_string);
 148   if (YAJL_IS_STRING(message)) {
 149     char const *m = YAJL_GET_STRING(message);
 150     if (m != NULL) {
 151       err->message = strdup(m);
 152     }
 153   }
 154
 155   return err;
 156 }
 157
 158 static char *api_error_string(api_error_t *err, char *buffer,
 159                               size_t buffer_size) {
 160   if (err == NULL) {
 161     strncpy(buffer, "Unknown error (API error is NULL)", buffer_size);
 162   } else if (err->message == NULL) {
 163     ssnprintf(buffer, buffer_size, "API error %d", err->code);
 164   } else {
 165     ssnprintf(buffer, buffer_size, "API error %d: %s", err->code, err->message);
 166   }
 167
 168   return buffer;
 169 }
 170 #define API_ERROR_STRING(err) api_error_string(err, (char[1024]){""}, 1024)
 171
 172 // do_post does a HTTP POST request, assuming a JSON payload and using OAuth
 173 // authentication. Returns -1 on error and the HTTP status code otherwise.
 174 // ret_content, if not NULL, will contain the server's response.
 175 // If ret_content is provided and the server responds with a 4xx or 5xx error,
 176 // an appropriate message will be logged.
 177 static int do_post(wg_callback_t *cb, char const *url, void const *payload,
 178                    wg_memory_t *ret_content) {
 179   if (cb->curl == NULL) {
 180     cb->curl = curl_easy_init();
 181     if (cb->curl == NULL) {
 182       ERROR("write_stackdriver plugin: curl_easy_init() failed");
 183       return -1;
 184     }
 185
 186     curl_easy_setopt(cb->curl, CURLOPT_ERRORBUFFER, cb->curl_errbuf);
 187     curl_easy_setopt(cb->curl, CURLOPT_NOSIGNAL, 1L);
 188   }
 189
 190   curl_easy_setopt(cb->curl, CURLOPT_POST, 1L);
 191   curl_easy_setopt(cb->curl, CURLOPT_URL, url);
 192
 193   long timeout_ms = 2 * CDTIME_T_TO_MS(plugin_get_interval());
 194   if (timeout_ms < 10000) {
 195     timeout_ms = 10000;
 196   }
 197   curl_easy_setopt(cb->curl, CURLOPT_TIMEOUT_MS, timeout_ms);
 198
 199   /* header */
 200   char *auth_header = wg_get_authorization_header(cb);
 201   if (auth_header == NULL) {
 202     ERROR("write_stackdriver plugin: getting access token failed with");
 203     return -1;
 204   }
 205
 206   struct curl_slist *headers =
 207       curl_slist_append(NULL, "Content-Type: application/json");
 208   headers = curl_slist_append(headers, auth_header);
 209   curl_easy_setopt(cb->curl, CURLOPT_HTTPHEADER, headers);
 210
 211   curl_easy_setopt(cb->curl, CURLOPT_POSTFIELDS, payload);
 212
 213   curl_easy_setopt(cb->curl, CURLOPT_WRITEFUNCTION,
 214                    ret_content ? wg_write_memory_cb : NULL);
 215   curl_easy_setopt(cb->curl, CURLOPT_WRITEDATA, ret_content);
 216
 217   int status = curl_easy_perform(cb->curl);
 218
 219   /* clean up that has to happen in any case */
 220   curl_slist_free_all(headers);
 221   sfree(auth_header);
 222   curl_easy_setopt(cb->curl, CURLOPT_HTTPHEADER, NULL);
 223   curl_easy_setopt(cb->curl, CURLOPT_WRITEFUNCTION, NULL);
 224   curl_easy_setopt(cb->curl, CURLOPT_WRITEDATA, NULL);
 225
 226   if (status != CURLE_OK) {
 227     ERROR("write_stackdriver plugin: POST %s failed: %s", url, cb->curl_errbuf);
 228     if (ret_content != NULL) {
 229       sfree(ret_content->memory);
 230       ret_content->size = 0;
 231     }
 232     return -1;
 233   }
 234
 235   long http_code = 0;
 236   curl_easy_getinfo(cb->curl, CURLINFO_RESPONSE_CODE, &http_code);
 237
 238   if (ret_content != NULL) {
 239     if ((http_code >= 400) && (http_code < 500)) {
 240       ERROR("write_stackdriver plugin: POST %s: %s", url,
 241             API_ERROR_STRING(parse_api_error(ret_content->memory)));
 242     } else if (http_code >= 500) {
 243       WARNING("write_stackdriver plugin: POST %s: %s", url,
 244               ret_content->memory);
 245     }
 246   }
 247
 248   return (int)http_code;
 249 } /* int do_post */
 250
 251 static int wg_call_metricdescriptor_create(wg_callback_t *cb,
 252                                            char const *payload) {
 253   char url[1024];
 254   ssnprintf(url, sizeof(url), "%s/projects/%s/metricDescriptors", cb->url,
 255             cb->project);
 256   wg_memory_t response = {0};
 257
 258   int status = do_post(cb, url, payload, &response);
 259   if (status == -1) {
 260     ERROR("write_stackdriver plugin: POST %s failed", url);
 261     return -1;
 262   }
 263   sfree(response.memory);
 264
 265   if (status != 200) {
 266     ERROR("write_stackdriver plugin: POST %s: unexpected response code: got "
 267           "%d, want 200",
 268           url, status);
 269     return -1;
 270   }
 271   return 0;
 272 } /* int wg_call_metricdescriptor_create */
 273
 274 static int wg_call_timeseries_write(wg_callback_t *cb, char const *payload) {
 275   char url[1024];
 276   ssnprintf(url, sizeof(url), "%s/projects/%s/timeSeries", cb->url,
 277             cb->project);
 278   wg_memory_t response = {0};
 279
 280   int status = do_post(cb, url, payload, &response);
 281   if (status == -1) {
 282     ERROR("write_stackdriver plugin: POST %s failed", url);
 283     return -1;
 284   }
 285   sfree(response.memory);
 286
 287   if (status != 200) {
 288     ERROR("write_stackdriver plugin: POST %s: unexpected response code: got "
 289           "%d, want 200",
 290           url, status);
 291     return -1;
 292   }
 293   return 0;
 294 } /* int wg_call_timeseries_write */
 295
 296 static void wg_reset_buffer(wg_callback_t *cb) /* {{{ */
 297 {
 298   cb->timeseries_count = 0;
 299   cb->send_buffer_init_time = cdtime();
 300 } /* }}} wg_reset_buffer */
 301
 302 static int wg_callback_init(wg_callback_t *cb) /* {{{ */
 303 {
 304   if (cb->curl != NULL)
 305     return 0;
 306
 307   cb->formatter = sd_output_create(cb->resource);
 308   if (cb->formatter == NULL) {
 309     ERROR("write_stackdriver plugin: sd_output_create failed.");
 310     return -1;
 311   }
 312
 313   cb->curl = curl_easy_init();
 314   if (cb->curl == NULL) {
 315     ERROR("write_stackdriver plugin: curl_easy_init failed.");
 316     return -1;
 317   }
 318
 319   curl_easy_setopt(cb->curl, CURLOPT_NOSIGNAL, 1L);
 320   curl_easy_setopt(cb->curl, CURLOPT_USERAGENT,
 321                    PACKAGE_NAME "/" PACKAGE_VERSION);
 322   curl_easy_setopt(cb->curl, CURLOPT_ERRORBUFFER, cb->curl_errbuf);
 323   wg_reset_buffer(cb);
 324
 325   return 0;
 326 } /* }}} int wg_callback_init */
 327
 328 static int wg_flush_nolock(cdtime_t timeout, wg_callback_t *cb) /* {{{ */
 329 {
 330   if (cb->timeseries_count == 0) {
 331     cb->send_buffer_init_time = cdtime();
 332     return 0;
 333   }
 334
 335   /* timeout == 0  => flush unconditionally */
 336   if (timeout > 0) {
 337     cdtime_t now = cdtime();
 338
 339     if ((cb->send_buffer_init_time + timeout) > now)
 340       return 0;
 341   }
 342
 343   char *payload = sd_output_reset(cb->formatter);
 344   int status = wg_call_timeseries_write(cb, payload);
 345   wg_reset_buffer(cb);
 346   return status;
 347 } /* }}} wg_flush_nolock */
 348
 349 static int wg_flush(cdtime_t timeout, /* {{{ */
 350                     const char *identifier __attribute__((unused)),
 351                     user_data_t *user_data) {
 352   wg_callback_t *cb;
 353   int status;
 354
 355   if (user_data == NULL)
 356     return -EINVAL;
 357
 358   cb = user_data->data;
 359
 360   pthread_mutex_lock(&cb->lock);
 361
 362   if (cb->curl == NULL) {
 363     status = wg_callback_init(cb);
 364     if (status != 0) {
 365       ERROR("write_stackdriver plugin: wg_callback_init failed.");
 366       pthread_mutex_unlock(&cb->lock);
 367       return -1;
 368     }
 369   }
 370
 371   status = wg_flush_nolock(timeout, cb);
 372   pthread_mutex_unlock(&cb->lock);
 373
 374   return status;
 375 } /* }}} int wg_flush */
 376
 377 static void wg_callback_free(void *data) /* {{{ */
 378 {
 379   wg_callback_t *cb = data;
 380   if (cb == NULL)
 381     return;
 382
 383   sd_output_destroy(cb->formatter);
 384   cb->formatter = NULL;
 385
 386   sfree(cb->email);
 387   sfree(cb->project);
 388   sfree(cb->url);
 389
 390   oauth_destroy(cb->auth);
 391   if (cb->curl) {
 392     curl_easy_cleanup(cb->curl);
 393   }
 394
 395   sfree(cb);
 396 } /* }}} void wg_callback_free */
 397
 398 static int wg_metric_descriptors_create(wg_callback_t *cb, const data_set_t *ds,
 399                                         const value_list_t *vl) {
 400   /* {{{ */
 401   for (size_t i = 0; i < ds->ds_num; i++) {
 402     char buffer[4096];
 403
 404     int status = sd_format_metric_descriptor(buffer, sizeof(buffer), ds, vl, i);
 405     if (status != 0) {
 406       ERROR("write_stackdriver plugin: sd_format_metric_descriptor failed "
 407             "with status "
 408             "%d",
 409             status);
 410       return status;
 411     }
 412
 413     status = wg_call_metricdescriptor_create(cb, buffer);
 414     if (status != 0) {
 415       ERROR("write_stackdriver plugin: wg_call_metricdescriptor_create failed "
 416             "with "
 417             "status %d",
 418             status);
 419       return status;
 420     }
 421   }
 422
 423   return sd_output_register_metric(cb->formatter, ds, vl);
 424 } /* }}} int wg_metric_descriptors_create */
 425
 426 static int wg_write(const data_set_t *ds, const value_list_t *vl, /* {{{ */
 427                     user_data_t *user_data) {
 428   wg_callback_t *cb = user_data->data;
 429   if (cb == NULL)
 430     return EINVAL;
 431
 432   pthread_mutex_lock(&cb->lock);
 433
 434   if (cb->curl == NULL) {
 435     int status = wg_callback_init(cb);
 436     if (status != 0) {
 437       ERROR("write_stackdriver plugin: wg_callback_init failed.");
 438       pthread_mutex_unlock(&cb->lock);
 439       return status;
 440     }
 441   }
 442
 443   int status;
 444   while (42) {
 445     status = sd_output_add(cb->formatter, ds, vl);
 446     if (status == 0) { /* success */
 447       break;
 448     } else if (status == ENOBUFS) { /* success, flush */
 449       wg_flush_nolock(0, cb);
 450       status = 0;
 451       break;
 452     } else if (status == EEXIST) {
 453       /* metric already in the buffer; flush and retry */
 454       wg_flush_nolock(0, cb);
 455       continue;
 456     } else if (status == ENOENT) {
 457       /* new metric, create metric descriptor first */
 458       status = wg_metric_descriptors_create(cb, ds, vl);
 459       if (status != 0) {
 460         break;
 461       }
 462       continue;
 463     } else {
 464       break;
 465     }
 466   }
 467
 468   if (status == 0) {
 469     cb->timeseries_count++;
 470   }
 471
 472   pthread_mutex_unlock(&cb->lock);
 473   return status;
 474 } /* }}} int wg_write */
 475
 476 static void wg_check_scope(char const *email) /* {{{ */
 477 {
 478   char *scope = gce_scope(email);
 479   if (scope == NULL) {
 480     WARNING("write_stackdriver plugin: Unable to determine scope of this "
 481             "instance.");
 482     return;
 483   }
 484
 485   if (strstr(scope, MONITORING_SCOPE) == NULL) {
 486     size_t scope_len;
 487
 488     /* Strip trailing newline characers for printing. */
 489     scope_len = strlen(scope);
 490     while ((scope_len > 0) && (iscntrl((int)scope[scope_len - 1])))
 491       scope[--scope_len] = 0;
 492
 493     WARNING("write_stackdriver plugin: The determined scope of this instance "
 494             "(\"%s\") does not contain the monitoring scope (\"%s\"). You need "
 495             "to add this scope to the list of scopes passed to gcutil with "
 496             "--service_account_scopes when creating the instance. "
 497             "Alternatively, to use this plugin on an instance which does not "
 498             "have this scope, use a Service Account.",
 499             scope, MONITORING_SCOPE);
 500   }
 501
 502   sfree(scope);
 503 } /* }}} void wg_check_scope */
 504
 505 static int wg_config_resource(oconfig_item_t *ci, wg_callback_t *cb) /* {{{ */
 506 {
 507   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
 508     ERROR("write_stackdriver plugin: The \"%s\" option requires exactly one "
 509           "string "
 510           "argument.",
 511           ci->key);
 512     return EINVAL;
 513   }
 514   char *resource_type = ci->values[0].value.string;
 515
 516   if (cb->resource != NULL) {
 517     sd_resource_destroy(cb->resource);
 518   }
 519
 520   cb->resource = sd_resource_create(resource_type);
 521   if (cb->resource == NULL) {
 522     ERROR("write_stackdriver plugin: sd_resource_create(\"%s\") failed.",
 523           resource_type);
 524     return ENOMEM;
 525   }
 526
 527   for (int i = 0; i < ci->children_num; i++) {
 528     oconfig_item_t *child = ci->children + i;
 529
 530     if (strcasecmp("Label", child->key) == 0) {
 531       if ((child->values_num != 2) ||
 532           (child->values[0].type != OCONFIG_TYPE_STRING) ||
 533           (child->values[1].type != OCONFIG_TYPE_STRING)) {
 534         ERROR("write_stackdriver plugin: The \"Label\" option needs exactly "
 535               "two string arguments.");
 536         continue;
 537       }
 538
 539       sd_resource_add_label(cb->resource, child->values[0].value.string,
 540                             child->values[1].value.string);
 541     }
 542   }
 543
 544   return 0;
 545 } /* }}} int wg_config_resource */
 546
 547 static int wg_config(oconfig_item_t *ci) /* {{{ */
 548 {
 549   if (ci == NULL) {
 550     return EINVAL;
 551   }
 552
 553   wg_callback_t *cb = calloc(1, sizeof(*cb));
 554   if (cb == NULL) {
 555     ERROR("write_stackdriver plugin: calloc failed.");
 556     return ENOMEM;
 557   }
 558   cb->url = strdup(GCM_API_URL);
 559   pthread_mutex_init(&cb->lock, /* attr = */ NULL);
 560
 561   char *credential_file = NULL;
 562
 563   for (int i = 0; i < ci->children_num; i++) {
 564     oconfig_item_t *child = ci->children + i;
 565     if (strcasecmp("Project", child->key) == 0)
 566       cf_util_get_string(child, &cb->project);
 567     else if (strcasecmp("Email", child->key) == 0)
 568       cf_util_get_string(child, &cb->email);
 569     else if (strcasecmp("Url", child->key) == 0)
 570       cf_util_get_string(child, &cb->url);
 571     else if (strcasecmp("CredentialFile", child->key) == 0)
 572       cf_util_get_string(child, &credential_file);
 573     else if (strcasecmp("Resource", child->key) == 0)
 574       wg_config_resource(child, cb);
 575     else {
 576       ERROR("write_stackdriver plugin: Invalid configuration option: %s.",
 577             child->key);
 578       wg_callback_free(cb);
 579       return EINVAL;
 580     }
 581   }
 582
 583   /* Set up authentication */
 584   /* Option 1: Credentials file given => use service account */
 585   if (credential_file != NULL) {
 586     oauth_google_t cfg =
 587         oauth_create_google_file(credential_file, MONITORING_SCOPE);
 588     if (cfg.oauth == NULL) {
 589       ERROR("write_stackdriver plugin: oauth_create_google_file failed");
 590       wg_callback_free(cb);
 591       return EINVAL;
 592     }
 593     cb->auth = cfg.oauth;
 594
 595     if (cb->project == NULL) {
 596       cb->project = cfg.project_id;
 597       INFO("write_stackdriver plugin: Automatically detected project ID: "
 598            "\"%s\"",
 599            cb->project);
 600     } else {
 601       sfree(cfg.project_id);
 602     }
 603   }
 604   /* Option 2: Look for credentials in well-known places */
 605   if (cb->auth == NULL) {
 606     oauth_google_t cfg = oauth_create_google_default(MONITORING_SCOPE);
 607     cb->auth = cfg.oauth;
 608
 609     if (cb->project == NULL) {
 610       cb->project = cfg.project_id;
 611       INFO("write_stackdriver plugin: Automatically detected project ID: "
 612            "\"%s\"",
 613            cb->project);
 614     } else {
 615       sfree(cfg.project_id);
 616     }
 617   }
 618
 619   if ((cb->auth != NULL) && (cb->email != NULL)) {
 620     NOTICE("write_stackdriver plugin: A service account email was configured "
 621            "but is "
 622            "not used for authentication because %s used instead.",
 623            (credential_file != NULL) ? "a credential file was"
 624                                      : "application default credentials were");
 625   }
 626
 627   /* Option 3: Running on GCE => use metadata service */
 628   if ((cb->auth == NULL) && gce_check()) {
 629     wg_check_scope(cb->email);
 630   } else if (cb->auth == NULL) {
 631     ERROR("write_stackdriver plugin: Unable to determine credentials. Please "
 632           "either "
 633           "specify the \"Credentials\" option or set up Application Default "
 634           "Credentials.");
 635     wg_callback_free(cb);
 636     return EINVAL;
 637   }
 638
 639   if ((cb->project == NULL) && gce_check()) {
 640     cb->project = gce_project_id();
 641   }
 642   if (cb->project == NULL) {
 643     ERROR("write_stackdriver plugin: Unable to determine the project number. "
 644           "Please specify the \"Project\" option manually.");
 645     wg_callback_free(cb);
 646     return EINVAL;
 647   }
 648
 649   if ((cb->resource == NULL) && gce_check()) {
 650     /* TODO(octo): add error handling */
 651     cb->resource = sd_resource_create("gce_instance");
 652     sd_resource_add_label(cb->resource, "project_id", gce_project_id());
 653     sd_resource_add_label(cb->resource, "instance_id", gce_instance_id());
 654     sd_resource_add_label(cb->resource, "zone", gce_zone());
 655   }
 656   if (cb->resource == NULL) {
 657     /* TODO(octo): add error handling */
 658     cb->resource = sd_resource_create("global");
 659     sd_resource_add_label(cb->resource, "project_id", cb->project);
 660   }
 661
 662   DEBUG("write_stackdriver plugin: Registering write callback with URL %s",
 663         cb->url);
 664   assert((cb->auth != NULL) || gce_check());
 665
 666   user_data_t user_data = {
 667       .data = cb,
 668   };
 669   plugin_register_flush("write_stackdriver", wg_flush, &user_data);
 670
 671   user_data.free_func = wg_callback_free;
 672   plugin_register_write("write_stackdriver", wg_write, &user_data);
 673
 674   return 0;
 675 } /* }}} int wg_config */
 676
 677 static int wg_init(void) {
 678   /* {{{ */
 679   /* Call this while collectd is still single-threaded to avoid
 680    * initialization issues in libgcrypt. */
 681   curl_global_init(CURL_GLOBAL_SSL);
 682
 683   return 0;
 684 } /* }}} int wg_init */
 685
 686 void module_register(void) /* {{{ */
 687 {
 688   plugin_register_complex_config("write_stackdriver", wg_config);
 689   plugin_register_init("write_stackdriver", wg_init);
 690 } /* }}} void module_register */