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