logging: format timestamp value

stephenplusplus · stephenplusplus · commit 1c5075d70218 · 2016-05-02T11:47:02.000-04:00
diff --git a/lib/common/grpc-service.js b/lib/common/grpc-service.js
@@ -289,8 +289,22 @@ GrpcService.convertValue_ = function(value) {
     convertedValue = {
       booleanValue: value
     };
+  } else if (Buffer.isBuffer(value)) {
+    convertedValue = {
+      blobValue: value
+    };
   } else if (is.object(value)) {
     convertedValue = GrpcService.objToStruct_(value);
+  } else if (is.date(value)) {
+    var seconds = value.getTime() / 1000;
+    var secondsRounded = Math.floor(seconds);
+
+    convertedValue = {
+      timestampValue: {
+        seconds: secondsRounded,
+        nanos: Math.floor((seconds - secondsRounded) * 1e9)
+      }
+    };
   } else if (is.array(value)) {
     convertedValue = {
       listValue: value.map(GrpcService.convertValue_)
diff --git a/lib/logging/entry.js b/lib/logging/entry.js
@@ -101,9 +101,16 @@ function Entry(resource, data) {
  * @return {module:logging/entity}
  */
 Entry.fromApiResponse_ = function(entry) {
-  // Only one of these are populated.
-  var data = entry.protoPayload || entry.jsonPayload || entry.textPayload;
-  return extend(new Entry(entry.resource, data), entry);
+  var data = entry[entry.payload];
+  var serializedEntry = extend(new Entry(entry.resource, data), entry);
+
+  if (serializedEntry.timestamp) {
+    var ms = serializedEntry.timestamp.seconds * 1000;
+    ms += serializedEntry.timestamp.nanos / 1e6;
+    serializedEntry.timestamp = new Date(ms);
+  }
+
+  return serializedEntry;
 };
 
 /**
@@ -143,6 +150,16 @@ Entry.prototype.toJSON = function() {
     entry.textPayload = this.data;
   }
 
+  if (is.date(entry.timestamp)) {
+    var seconds = entry.timestamp.getTime() / 1000;
+    var secondsRounded = Math.floor(seconds);
+
+    entry.timestamp = {
+      seconds: secondsRounded,
+      nanos: Math.floor((seconds - secondsRounded) * 1e9)
+    };
+  }
+
   return entry;
 };
 
diff --git a/test/common/grpc-service.js b/test/common/grpc-service.js
@@ -554,19 +554,28 @@ describe('GrpcService', function() {
 
   describe('convertValue_', function() {
     it('should convert primitive values correctly', function() {
-      var convertedValues = extend(
-        GrpcService.convertValue_(null),
-        GrpcService.convertValue_(1),
-        GrpcService.convertValue_('Hi'),
-        GrpcService.convertValue_(true)
-      );
+      var buffer = new Buffer('Value');
 
-      assert.deepEqual(convertedValues, {
-        nullValue: null,
-        numberValue: 1,
-        stringValue: 'Hi',
+      assert.deepEqual(GrpcService.convertValue_(null), {
+        nullValue: null
+      });
+
+      assert.deepEqual(GrpcService.convertValue_(1), {
+        numberValue: 1
+      });
+
+      assert.deepEqual(GrpcService.convertValue_('Hi'), {
+        stringValue: 'Hi'
+      });
+
+      assert.deepEqual(GrpcService.convertValue_(true), {
         booleanValue: true
       });
+
+      assert.strictEqual(
+        GrpcService.convertValue_(buffer).blobValue.toString(),
+        'Value'
+      );
     });
 
     it('should convert objects', function() {
@@ -576,11 +585,26 @@ describe('GrpcService', function() {
         return value;
       };
 
-      var convertedValue = GrpcService.convertValue_({});
+      var convertedValue = GrpcService.convertValue_(value);
 
       assert.strictEqual(convertedValue, value);
     });
 
+    it('should convert dates', function() {
+      var value = new Date();
+      var seconds = value.getTime() / 1000;
+      var secondsRounded = Math.floor(seconds);
+
+      var convertedValue = GrpcService.convertValue_(value);
+
+      assert.deepEqual(convertedValue, {
+        timestampValue: {
+          seconds: secondsRounded,
+          nanos: Math.floor((seconds - secondsRounded) * 1e9)
+        }
+      });
+    });
+
     it('should convert arrays', function() {
       var convertedValue = GrpcService.convertValue_([1, 2, 3]);
 
@@ -593,8 +617,8 @@ describe('GrpcService', function() {
 
     it('should throw if a type is not recognized', function() {
       assert.throws(function() {
-        GrpcService.convertValue_(new Date());
-      }, 'Value of type Date not recognized.');
+        GrpcService.convertValue_();
+      }, 'Value of type undefined not recognized.');
     });
   });
 
diff --git a/test/logging/entry.js b/test/logging/entry.js
@@ -67,12 +67,21 @@ describe('Entry', function() {
 
   describe('fromApiResponse_', function() {
     var entry;
+    var date = new Date();
 
     beforeEach(function() {
+      var seconds = date.getTime() / 1000;
+      var secondsRounded = Math.floor(seconds);
+
       entry = Entry.fromApiResponse_({
         resource: RESOURCE,
+        payload: 'jsonPayload',
         jsonPayload: DATA,
-        extraProperty: true
+        extraProperty: true,
+        timestamp: {
+          seconds: secondsRounded,
+          nanos: Math.floor((seconds - secondsRounded) * 1e9)
+        }
       });
     });
 
@@ -81,11 +90,13 @@ describe('Entry', function() {
       assert.strictEqual(entry.resource, RESOURCE);
       assert.strictEqual(entry.data, DATA);
       assert.strictEqual(entry.extraProperty, true);
+      assert.deepEqual(entry.timestamp, date);
     });
 
     it('should extend the entry with proto data', function() {
       var entry = Entry.fromApiResponse_({
         resource: RESOURCE,
+        payload: 'protoPayload',
         protoPayload: DATA,
         extraProperty: true
       });
@@ -100,6 +111,7 @@ describe('Entry', function() {
     it('should extend the entry with text data', function() {
       var entry = Entry.fromApiResponse_({
         resource: RESOURCE,
+        payload: 'textPayload',
         textPayload: DATA,
         extraProperty: true
       });
@@ -181,5 +193,20 @@ describe('Entry', function() {
       var json = entry.toJSON();
       assert.strictEqual(json.textPayload, entry.data);
     });
+
+    it('should convert a date', function() {
+      var date = new Date();
+      entry.timestamp = date;
+
+      var json = entry.toJSON();
+
+      var seconds = date.getTime() / 1000;
+      var secondsRounded = Math.floor(seconds);
+
+      assert.deepEqual(json.timestamp, {
+        seconds: secondsRounded,
+        nanos: Math.floor((seconds - secondsRounded) * 1e9)
+      });
+    });
   });
 });
