feat(logging): provide cluster_name on GKE resources (#2483)

Author: ofrobots

packages/logging/package.json

@@ -57,6 +57,7 @@
     "arrify": "^1.0.0",
     "eventid": "^0.1.0",
     "extend": "^3.0.0",
+    "gcp-metadata": "^0.2.0",
     "google-auto-auth": "^0.7.1",
     "google-gax": "^0.13.0",
     "google-proto-files": "^0.12.0",

packages/logging/src/metadata.js

@@ -20,6 +20,8 @@
 
 'use strict';
 
+var gcpMetadata = require('gcp-metadata');
+
 /**
  * The Metadata class attempts to contact the metadata service and determine,
  * based on request success and environment variables, what type of resource
@@ -95,15 +97,25 @@ Metadata.getGCEDescriptor = function(projectId) {
  * @private
  *
  * @param {string} projectId - The project ID.
+ * @param {function} callback - The callback function.
  * @return {object}
  */
-Metadata.getGKEDescriptor = function(projectId) {
-  return {
-    type: 'container',
-    labels: {
-      project_id: projectId,
+Metadata.getGKEDescriptor = function(projectId, callback) {
+  gcpMetadata.instance('attributes/clusterName', function(err, _, clusterName) {
+    if (err) {
+      callback(err);
+      return;
     }
-  };
+
+    callback(null, {
+      type: 'container',
+      labels: {
+        // TODO(ofrobots): it would be good to include the namespace_id as well.
+        cluster_name: clusterName,
+        project_id: projectId
+      }
+    });
+  });
 };
 
 /**
@@ -138,14 +150,17 @@ Metadata.prototype.getDefaultResource = function(callback) {
     }
 
     self.logging.auth.getEnvironment(function(err, env) {
+      if (env.IS_CONTAINER_ENGINE) {
+        Metadata.getGKEDescriptor(projectId, callback);
+        return;
+      }
+
       var defaultResource;
 
       if (env.IS_APP_ENGINE) {
         defaultResource = Metadata.getGAEDescriptor(projectId);
       } else if (env.IS_CLOUD_FUNCTION) {
         defaultResource = Metadata.getCloudFunctionDescriptor(projectId);
-      } else if (env.IS_CONTAINER_ENGINE) {
-        defaultResource = Metadata.getGKEDescriptor(projectId);
       } else if (env.IS_COMPUTE_ENGINE) {
         defaultResource = Metadata.getGCEDescriptor(projectId);
       } else {

packages/logging/test/metadata.js

@@ -18,11 +18,21 @@
 
 var assert = require('assert');
 var extend = require('extend');
-
-var Metadata = require('../src/metadata.js');
+var proxyquire = require('proxyquire');
+
+var instanceArgsOverride;
+var fakeGcpMetadata = {
+  instance: function(path, cb) {
+    setImmediate(function() {
+      var args = instanceArgsOverride || [null, null, 'fake-instance-value'];
+      cb.apply(fakeGcpMetadata, args);
+    });
+  }
+};
 
 describe('metadata', function() {
   var MetadataCached;
+  var Metadata;
   var metadata;
 
   var PROJECT_ID = 'project-id';
@@ -31,6 +41,10 @@ describe('metadata', function() {
   var ENV_CACHED = extend({}, process.env);
 
   before(function() {
+    Metadata = proxyquire('../src/metadata.js', {
+      'gcp-metadata': fakeGcpMetadata
+    });
+
     MetadataCached = extend({}, Metadata);
   });
 
@@ -40,6 +54,7 @@ describe('metadata', function() {
     };
     extend(Metadata, MetadataCached);
     metadata = new Metadata(LOGGING);
+    instanceArgsOverride = null;
   });
 
   afterEach(function() {
@@ -104,12 +119,31 @@ describe('metadata', function() {
   });
 
   describe('getGKEDescriptor', function() {
-    it('should return the correct descriptor', function() {
-      assert.deepEqual(Metadata.getGKEDescriptor(PROJECT_ID), {
-        type: 'container',
-        labels: {
-          project_id: PROJECT_ID
-        }
+    var CLUSTER_NAME = 'gke-cluster-name';
+
+    it('should return the correct descriptor', function(done) {
+      instanceArgsOverride = [null, null, CLUSTER_NAME];
+
+      Metadata.getGKEDescriptor(PROJECT_ID, function(err, descriptor) {
+        assert.ifError(err);
+        assert.deepEqual(descriptor, {
+          type: 'container',
+          labels: {
+            cluster_name: CLUSTER_NAME,
+            project_id: PROJECT_ID
+          }
+        });
+        done();
+      });
+    });
+
+    it('should return error on failure to acquire metadata', function(done) {
+      var FAKE_ERROR = new Error();
+      instanceArgsOverride = [ FAKE_ERROR ];
+
+      Metadata.getGKEDescriptor(PROJECT_ID, function(err) {
+        assert.strictEqual(err, FAKE_ERROR);
+        done();
       });
     });
   });
@@ -248,12 +282,8 @@ describe('metadata', function() {
 
       describe('container engine', function() {
         it('should return correct descriptor', function(done) {
-          var DESCRIPTOR = {};
-
-          Metadata.getGKEDescriptor = function(projectId) {
-            assert.strictEqual(projectId, RETURNED_PROJECT_ID);
-            return DESCRIPTOR;
-          };
+          var CLUSTER_NAME = 'overridden-value';
+          instanceArgsOverride = [null, null, CLUSTER_NAME];
 
           metadata.logging.auth.getEnvironment = function(callback) {
             callback(null, {
@@ -264,7 +294,13 @@ describe('metadata', function() {
 
           metadata.getDefaultResource(function(err, defaultResource) {
             assert.ifError(err);
-            assert.strictEqual(defaultResource, DESCRIPTOR);
+            assert.deepStrictEqual(defaultResource, {
+              type: 'container',
+              labels: {
+                cluster_name: CLUSTER_NAME,
+                project_id: RETURNED_PROJECT_ID
+              }
+            });
             done();
           });
         });