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 "common.h"
  26 #include "configfile.h"
  27 #include "plugin.h"
  28 #include "utils_format_stackdriver.h"
  29 #include "utils_gce.h"
  30 #include "utils_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 = snprintf(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     snprintf(buffer, buffer_size, "API error %d", err->code);
 164   } else {
 165     snprintf(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     sfree(ret_content->memory);
 229     ret_content->size = 0;
 230     return -1;
 231   }
 232
 233   long http_code = 0;
 234   curl_easy_getinfo(cb->curl, CURLINFO_RESPONSE_CODE, &http_code);
 235
 236   if (ret_content != NULL) {
 237     if ((status >= 400) && (status < 500)) {
 238       ERROR("write_stackdriver plugin: POST %s: %s", url,
 239             API_ERROR_STRING(parse_api_error(ret_content->memory)));
 240     } else if (status >= 500) {
 241       WARNING("write_stackdriver plugin: POST %s: %s", url,
 242               ret_content->memory);
 243     }
 244   }
 245
 246   return (int)http_code;
 247 } /* int do_post */
 248
 249 static int wg_call_metricdescriptor_create(wg_callback_t *cb,
 250                                            char const *payload) {
 251   char url[1024];
 252   snprintf(url, sizeof(url), "%s/projects/%s/metricDescriptors", cb->url,
 253            cb->project);
 254   wg_memory_t response = {0};
 255
 256   int status = do_post(cb, url, payload, &response);
 257   if (status == -1) {
 258     ERROR("write_stackdriver plugin: POST %s failed", url);
 259     return -1;
 260   }
 261   sfree(response.memory);
 262
 263   if (status != 200) {
 264     ERROR("write_stackdriver plugin: POST %s: unexpected response code: got "
 265           "%d, want 200",
 266           url, status);
 267     return -1;
 268   }
 269   return 0;
 270 } /* int wg_call_metricdescriptor_create */
 271
 272 static int wg_call_timeseries_write(wg_callback_t *cb, char const *payload) {
 273   char url[1024];
 274   snprintf(url, sizeof(url), "%s/projects/%s/timeSeries", cb->url, cb->project);
 275   wg_memory_t response = {0};
 276
 277   int status = do_post(cb, url, payload, &response);
 278   if (status == -1) {
 279     ERROR("write_stackdriver plugin: POST %s failed", url);
 280     return -1;
 281   }
 282   sfree(response.memory);
 283
 284   if (status != 200) {
 285     ERROR("write_stackdriver plugin: POST %s: unexpected response code: got "
 286           "%d, want 200",
 287           url, status);
 288     return -1;
 289   }
 290   return 0;
 291 } /* int wg_call_timeseries_write */
 292
 293 static void wg_reset_buffer(wg_callback_t *cb) /* {{{ */
 294 {
 295   cb->timeseries_count = 0;
 296   cb->send_buffer_init_time = cdtime();
 297 } /* }}} wg_reset_buffer */
 298
 299 static int wg_callback_init(wg_callback_t *cb) /* {{{ */
 300 {
 301   if (cb->curl != NULL)
 302     return 0;
 303
 304   cb->formatter = sd_output_create(cb->resource);
 305   if (cb->formatter == NULL) {
 306     ERROR("write_stackdriver plugin: sd_output_create failed.");
 307     return -1;
 308   }
 309
 310   cb->curl = curl_easy_init();
 311   if (cb->curl == NULL) {
 312     ERROR("write_stackdriver plugin: curl_easy_init failed.");
 313     return -1;
 314   }
 315
 316   curl_easy_setopt(cb->curl, CURLOPT_NOSIGNAL, 1L);
 317   curl_easy_setopt(cb->curl, CURLOPT_USERAGENT,
 318                    PACKAGE_NAME "/" PACKAGE_VERSION);
 319   curl_easy_setopt(cb->curl, CURLOPT_ERRORBUFFER, cb->curl_errbuf);
 320   wg_reset_buffer(cb);
 321
 322   return 0;
 323 } /* }}} int wg_callback_init */
 324
 325 static int wg_flush_nolock(cdtime_t timeout, wg_callback_t *cb) /* {{{ */
 326 {
 327   if (cb->timeseries_count == 0) {
 328     cb->send_buffer_init_time = cdtime();
 329     return 0;
 330   }
 331
 332   /* timeout == 0  => flush unconditionally */
 333   if (timeout > 0) {
 334     cdtime_t now = cdtime();
 335
 336     if ((cb->send_buffer_init_time + timeout) > now)
 337       return 0;
 338   }
 339
 340   char *payload = sd_output_reset(cb->formatter);
 341   int status = wg_call_timeseries_write(cb, payload);
 342   if (status != 0) {
 343     ERROR("write_stackdriver plugin: Sending buffer failed with status %d.",
 344           status);
 345   }
 346
 347   wg_reset_buffer(cb);
 348   return status;
 349 } /* }}} wg_flush_nolock */
 350
 351 static int wg_flush(cdtime_t timeout, /* {{{ */
 352                     const char *identifier __attribute__((unused)),
 353                     user_data_t *user_data) {
 354   wg_callback_t *cb;
 355   int status;
 356
 357   if (user_data == NULL)
 358     return -EINVAL;
 359
 360   cb = user_data->data;
 361
 362   pthread_mutex_lock(&cb->lock);
 363
 364   if (cb->curl == NULL) {
 365     status = wg_callback_init(cb);
 366     if (status != 0) {
 367       ERROR("write_stackdriver plugin: wg_callback_init failed.");
 368       pthread_mutex_unlock(&cb->lock);
 369       return -1;
 370     }
 371   }
 372
 373   status = wg_flush_nolock(timeout, cb);
 374   pthread_mutex_unlock(&cb->lock);
 375
 376   return status;
 377 } /* }}} int wg_flush */
 378
 379 static void wg_callback_free(void *data) /* {{{ */
 380 {
 381   wg_callback_t *cb = data;
 382   if (cb == NULL)
 383     return;
 384
 385   sd_output_destroy(cb->formatter);
 386   cb->formatter = NULL;
 387
 388   sfree(cb->email);
 389   sfree(cb->project);
 390   sfree(cb->url);
 391
 392   oauth_destroy(cb->auth);
 393   if (cb->curl) {
 394     curl_easy_cleanup(cb->curl);
 395   }
 396
 397   sfree(cb);
 398 } /* }}} void wg_callback_free */
 399
 400 static int wg_metric_descriptors_create(wg_callback_t *cb, const data_set_t *ds,
 401                                         const value_list_t *vl) {
 402   /* {{{ */
 403   for (size_t i = 0; i < ds->ds_num; i++) {
 404     char buffer[4096];
 405
 406     int status = sd_format_metric_descriptor(buffer, sizeof(buffer), ds, vl, i);
 407     if (status != 0) {
 408       ERROR("write_stackdriver plugin: sd_format_metric_descriptor failed "
 409             "with status "
 410             "%d",
 411             status);
 412       return status;
 413     }
 414
 415     status = wg_call_metricdescriptor_create(cb, buffer);
 416     if (status != 0) {
 417       ERROR("write_stackdriver plugin: wg_call_metricdescriptor_create failed "
 418             "with "
 419             "status %d",
 420             status);
 421       return status;
 422     }
 423   }
 424
 425   return sd_output_register_metric(cb->formatter, ds, vl);
 426 } /* }}} int wg_metric_descriptors_create */
 427
 428 static int wg_write(const data_set_t *ds, const value_list_t *vl, /* {{{ */
 429                     user_data_t *user_data) {
 430   wg_callback_t *cb = user_data->data;
 431   if (cb == NULL)
 432     return EINVAL;
 433
 434   pthread_mutex_lock(&cb->lock);
 435
 436   if (cb->curl == NULL) {
 437     int status = wg_callback_init(cb);
 438     if (status != 0) {
 439       ERROR("write_stackdriver plugin: wg_callback_init failed.");
 440       pthread_mutex_unlock(&cb->lock);
 441       return status;
 442     }
 443   }
 444
 445   int status;
 446   while (42) {
 447     status = sd_output_add(cb->formatter, ds, vl);
 448     if (status == 0) { /* success */
 449       break;
 450     } else if (status == ENOBUFS) { /* success, flush */
 451       wg_flush_nolock(0, cb);
 452       status = 0;
 453       break;
 454     } else if (status == EEXIST) {
 455       /* metric already in the buffer; flush and retry */
 456       wg_flush_nolock(0, cb);
 457       continue;
 458     } else if (status == ENOENT) {
 459       /* new metric, create metric descriptor first */
 460       status = wg_metric_descriptors_create(cb, ds, vl);
 461       if (status != 0) {
 462         break;
 463       }
 464       continue;
 465     } else {
 466       break;
 467     }
 468   }
 469
 470   if (status == 0) {
 471     cb->timeseries_count++;
 472   }
 473
 474   pthread_mutex_unlock(&cb->lock);
 475   return status;
 476 } /* }}} int wg_write */
 477
 478 static void wg_check_scope(char const *email) /* {{{ */
 479 {
 480   char *scope = gce_scope(email);
 481   if (scope == NULL) {
 482     WARNING("write_stackdriver plugin: Unable to determine scope of this "
 483             "instance.");
 484     return;
 485   }
 486
 487   if (strstr(scope, MONITORING_SCOPE) == NULL) {
 488     size_t scope_len;
 489
 490     /* Strip trailing newline characers for printing. */
 491     scope_len = strlen(scope);
 492     while ((scope_len > 0) && (iscntrl((int)scope[scope_len - 1])))
 493       scope[--scope_len] = 0;
 494
 495     WARNING("write_stackdriver plugin: The determined scope of this instance "
 496             "(\"%s\") does not contain the monitoring scope (\"%s\"). You need "
 497             "to add this scope to the list of scopes passed to gcutil with "
 498             "--service_account_scopes when creating the instance. "
 499             "Alternatively, to use this plugin on an instance which does not "
 500             "have this scope, use a Service Account.",
 501             scope, MONITORING_SCOPE);
 502   }
 503
 504   sfree(scope);
 505 } /* }}} void wg_check_scope */
 506
 507 static int wg_config_resource(oconfig_item_t *ci, wg_callback_t *cb) /* {{{ */
 508 {
 509   if ((ci->values_num != 1) || (ci->values[0].type != OCONFIG_TYPE_STRING)) {
 510     ERROR("write_stackdriver plugin: The \"%s\" option requires exactly one "
 511           "string "
 512           "argument.",
 513           ci->key);
 514     return EINVAL;
 515   }
 516   char *resource_type = ci->values[0].value.string;
 517
 518   if (cb->resource != NULL) {
 519     sd_resource_destroy(cb->resource);
 520   }
 521
 522   cb->resource = sd_resource_create(resource_type);
 523   if (cb->resource == NULL) {
 524     ERROR("write_stackdriver plugin: sd_resource_create(\"%s\") failed.",
 525           resource_type);
 526     return ENOMEM;
 527   }
 528
 529   for (int i = 0; i < ci->children_num; i++) {
 530     oconfig_item_t *child = ci->children + i;
 531
 532     if (strcasecmp("Label", child->key) == 0) {
 533       if ((child->values_num != 2) ||
 534           (child->values[0].type != OCONFIG_TYPE_STRING) ||
 535           (child->values[1].type != OCONFIG_TYPE_STRING)) {
 536         ERROR("write_stackdriver plugin: The \"Label\" option needs exactly "
 537               "two string arguments.");
 538         continue;
 539       }
 540
 541       sd_resource_add_label(cb->resource, child->values[0].value.string,
 542                             child->values[1].value.string);
 543     }
 544   }
 545
 546   return 0;
 547 } /* }}} int wg_config_resource */
 548
 549 static int wg_config(oconfig_item_t *ci) /* {{{ */
 550 {
 551   if (ci == NULL) {
 552     return EINVAL;
 553   }
 554
 555   wg_callback_t *cb = calloc(1, sizeof(*cb));
 556   if (cb == NULL) {
 557     ERROR("write_stackdriver plugin: calloc failed.");
 558     return ENOMEM;
 559   }
 560   cb->url = strdup(GCM_API_URL);
 561   pthread_mutex_init(&cb->lock, /* attr = */ NULL);
 562
 563   char *credential_file = NULL;
 564
 565   for (int i = 0; i < ci->children_num; i++) {
 566     oconfig_item_t *child = ci->children + i;
 567     if (strcasecmp("Project", child->key) == 0)
 568       cf_util_get_string(child, &cb->project);
 569     else if (strcasecmp("Email", child->key) == 0)
 570       cf_util_get_string(child, &cb->email);
 571     else if (strcasecmp("Url", child->key) == 0)
 572       cf_util_get_string(child, &cb->url);
 573     else if (strcasecmp("CredentialFile", child->key) == 0)
 574       cf_util_get_string(child, &credential_file);
 575     else if (strcasecmp("Resource", child->key) == 0)
 576       wg_config_resource(child, cb);
 577     else {
 578       ERROR("write_stackdriver plugin: Invalid configuration option: %s.",
 579             child->key);
 580       wg_callback_free(cb);
 581       return EINVAL;
 582     }
 583   }
 584
 585   /* Set up authentication */
 586   /* Option 1: Credentials file given => use service account */
 587   if (credential_file != NULL) {
 588     oauth_google_t cfg =
 589         oauth_create_google_file(credential_file, MONITORING_SCOPE);
 590     if (cfg.oauth == NULL) {
 591       ERROR("write_stackdriver plugin: oauth_create_google_file failed");
 592       wg_callback_free(cb);
 593       return EINVAL;
 594     }
 595     cb->auth = cfg.oauth;
 596
 597     if (cb->project == NULL) {
 598       cb->project = cfg.project_id;
 599       INFO("write_stackdriver plugin: Automatically detected project ID: "
 600            "\"%s\"",
 601            cb->project);
 602     } else {
 603       sfree(cfg.project_id);
 604     }
 605   }
 606   /* Option 2: Look for credentials in well-known places */
 607   if (cb->auth == NULL) {
 608     oauth_google_t cfg = oauth_create_google_default(MONITORING_SCOPE);
 609     cb->auth = cfg.oauth;
 610
 611     if (cb->project == NULL) {
 612       cb->project = cfg.project_id;
 613       INFO("write_stackdriver plugin: Automatically detected project ID: "
 614            "\"%s\"",
 615            cb->project);
 616     } else {
 617       sfree(cfg.project_id);
 618     }
 619   }
 620
 621   if ((cb->auth != NULL) && (cb->email != NULL)) {
 622     NOTICE("write_stackdriver plugin: A service account email was configured "
 623            "but is "
 624            "not used for authentication because %s used instead.",
 625            (credential_file != NULL) ? "a credential file was"
 626                                      : "application default credentials were");
 627   }
 628
 629   /* Option 3: Running on GCE => use metadata service */
 630   if ((cb->auth == NULL) && gce_check()) {
 631     wg_check_scope(cb->email);
 632   } else if (cb->auth == NULL) {
 633     ERROR("write_stackdriver plugin: Unable to determine credentials. Please "
 634           "either "
 635           "specify the \"Credentials\" option or set up Application Default "
 636           "Credentials.");
 637     wg_callback_free(cb);
 638     return EINVAL;
 639   }
 640
 641   if ((cb->project == NULL) && gce_check()) {
 642     cb->project = gce_project_id();
 643   }
 644   if (cb->project == NULL) {
 645     ERROR("write_stackdriver plugin: Unable to determine the project number. "
 646           "Please specify the \"Project\" option manually.");
 647     wg_callback_free(cb);
 648     return EINVAL;
 649   }
 650
 651   if ((cb->resource == NULL) && gce_check()) {
 652     /* TODO(octo): add error handling */
 653     cb->resource = sd_resource_create("gce_instance");
 654     sd_resource_add_label(cb->resource, "project_id", gce_project_id());
 655     sd_resource_add_label(cb->resource, "instance_id", gce_instance_id());
 656     sd_resource_add_label(cb->resource, "zone", gce_zone());
 657   }
 658   if (cb->resource == NULL) {
 659     /* TODO(octo): add error handling */
 660     cb->resource = sd_resource_create("global");
 661     sd_resource_add_label(cb->resource, "project_id", cb->project);
 662   }
 663
 664   DEBUG("write_stackdriver plugin: Registering write callback with URL %s",
 665         cb->url);
 666   assert((cb->auth != NULL) || gce_check());
 667
 668   user_data_t user_data = {
 669       .data = cb,
 670   };
 671   plugin_register_flush("write_stackdriver", wg_flush, &user_data);
 672
 673   user_data.free_func = wg_callback_free;
 674   plugin_register_write("write_stackdriver", wg_write, &user_data);
 675
 676   return 0;
 677 } /* }}} int wg_config */
 678
 679 static int wg_init(void) {
 680   /* {{{ */
 681   /* Call this while collectd is still single-threaded to avoid
 682    * initialization issues in libgcrypt. */
 683   curl_global_init(CURL_GLOBAL_SSL);
 684
 685   return 0;
 686 } /* }}} int wg_init */
 687
 688 void module_register(void) /* {{{ */
 689 {
 690   plugin_register_complex_config("write_stackdriver", wg_config);
 691   plugin_register_init("write_stackdriver", wg_init);
 692 } /* }}} void module_register */