@emartech/aggregate-metric-logger 3.2.0 → 3.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emartech/aggregate-metric-logger",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "aggregate metrics in memory for logging",
   "main": "src/index.js",
   "scripts": {

package/src/gcp-metric-collector/gcp-metric-collector.js

@@ -16,6 +16,16 @@ exports.count = (metricName, labels = {}, value = 1) =>
 exports.measure = (metricName, labels = {}, value = 1) =>
   addToMetric(metricName, labels, 'distribution', value);
 
+exports.start = (metricName, labels = {}) => ({ metricName, labels, start: Date.now() });
+
+exports.stop = measurement =>
+  addToMetric(
+    measurement.metricName,
+    measurement.labels,
+    'distribution',
+    Date.now() - measurement.start
+  );
+
 const addToMetric = (metricName, labels = {}, type, value) => {
   if (process.env.METRIC_LOGGER_ENABLED !== 'true') return;
 

package/src/gcp-metric-collector/gcp-metric-collector.spec.js

@@ -239,4 +239,45 @@ describe('gcpMetricCollector', () => {
       expect(getPublishedMetrics()).toEqual([]);
     });
   });
+
+  describe('start', () => {
+    it('should return a measurement object with the given tag, params and start time', () => {
+      const fakeCurrentTimestamp = 2323434543;
+      jest.useFakeTimers().setSystemTime(new Date(fakeCurrentTimestamp));
+
+      const measurement = gcpMetricCollector.start('pulyka', { foo: 'bar' });
+
+      expect(measurement).toEqual({
+        metricName: 'pulyka',
+        labels: { foo: 'bar' },
+        start: fakeCurrentTimestamp
+      });
+    });
+  });
+
+  describe('stop', () => {
+    it('should send in time since start as a distribution measurement', () => {
+      jest.useFakeTimers().setSystemTime(new Date(20000));
+      stubCreateTimeSeries();
+
+      const measurement = gcpMetricCollector.start('elephant', { size: 23 });
+      jest.advanceTimersByTime(45);
+
+      gcpMetricCollector.stop(measurement);
+
+      jest.advanceTimersByTime(60 * 1000 + 1);
+      expect(getPublishedMetrics()).toMatchObject([
+        [
+          {
+            value: {
+              distributionValue: {
+                count: 1,
+                mean: 45
+              }
+            }
+          }
+        ]
+      ]);
+    });
+  });
 });

package/src/gcp-time-series-publisher/gcp-time-series-publisher.js

@@ -1,11 +1,11 @@
 'use strict';
 
-const { createLogger } = require('@emartech/json-logger');
+const logger = require('@emartech/json-logger').createLogger('aggregate-metric-logger');
 const monitoring = require('@google-cloud/monitoring');
 const { chunk } = require('lodash');
 const ms = require('ms');
+const { setTimeout } = require('timers/promises');
 
-const logger = createLogger('aggregate-metric-logger');
 const MAX_TIME_SERIES_COUNT = 200;
 
 exports.publishTimeSeries = async timeSeries => {
@@ -24,13 +24,11 @@ const createTimeSeries = async (client, timeSeries) => {
   try {
     await client.createTimeSeries({ name, timeSeries });
   } catch (error) {
-    await sleep(ms('10 sec'));
+    await setTimeout(ms('10 sec'));
     await client.createTimeSeries({ name, timeSeries });
   }
 };
 
-const sleep = async sleepTime => new Promise(resolve => setTimeout(resolve, sleepTime));
-
 let monitoringClientInstance = null;
 const getMonitoringClient = () => {
   if (!monitoringClientInstance) {

package/src/index.js

@@ -21,9 +21,10 @@ exposedFactoryInstanceHybrid.error = exposedInstance.error;
 exposedFactoryInstanceHybrid.fatal = exposedInstance.fatal;
 exposedFactoryInstanceHybrid.start = exposedInstance.start;
 exposedFactoryInstanceHybrid.stop = exposedInstance.stop;
-exposedFactoryInstanceHybrid.cancel = exposedInstance.cancel;
 
 exposedFactoryInstanceHybrid.count = gcpMetricCollector.count;
 exposedFactoryInstanceHybrid.measureGcp = gcpMetricCollector.measure;
+exposedFactoryInstanceHybrid.startGcp = gcpMetricCollector.start;
+exposedFactoryInstanceHybrid.stopGcp = gcpMetricCollector.stop;
 
 module.exports = exposedFactoryInstanceHybrid;