@emartech/aggregate-metric-logger 2.1.3 → 2.2.0

package/.eslintrc.js

@@ -11,7 +11,8 @@ module.exports = {
   },
   extends: ['eslint:recommended', 'plugin:jest/recommended', 'emarsys'],
   rules: {
-    'curly': ['error', 'multi-line']
+    curly: ['error', 'multi-line'],
+    'operator-linebreak': ['error', 'after', { overrides: { '?': 'before', ':': 'before' } }]
   },
   overrides: [
     {

package/README.md

@@ -11,7 +11,7 @@ To change the default `aggregate-metric-logger` namespace used for logs, set
 
 ## Setup to send metrics to GCP monitoring
 
-(currently only the `metricLogger.count` method sends metrics to GCP)
+(currently only the `metricLogger.count`, `metricLogger.measureGcp` method sends metrics to GCP)
 
 Set `METRIC_LOGGER_ENABLED` just us for LaaS based metrics.
 

package/package.json

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

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

@@ -0,0 +1,51 @@
+'use strict';
+
+const stringify = require('json-stable-stringify');
+const { publishTimeSeries } = require('../gcp-time-series-publisher/gcp-time-series-publisher');
+const { buildTimeSeries } = require('../gcp-time-series-builder/gcp-time-series-builder');
+const { createCounter } = require('../metric-types/counter/counter');
+const { createDistribution } = require('../metric-types/distribution/distribution');
+
+let metrics = {};
+let initialized = false;
+let timeoutId = null;
+
+exports.count = (metricName, labels = {}, value = 1) =>
+  addToMetric(metricName, labels, 'counter', value);
+
+exports.measure = (metricName, labels = {}, value = 1) =>
+  addToMetric(metricName, labels, 'distribution', value);
+
+const addToMetric = (metricName, labels = {}, type, value) => {
+  if (process.env.METRIC_LOGGER_ENABLED !== 'true') return;
+
+  if (!initialized) {
+    initialized = true;
+    setupNextFlush();
+  }
+  const key = `${metricName}_${stringify(labels)}`;
+  if (!metrics[key]) {
+    const value = type === 'counter' ? createCounter() : createDistribution();
+    metrics[key] = { name: metricName, labels, value };
+  }
+  metrics[key].value.add(value);
+};
+
+exports.reset = () => {
+  metrics = {};
+  initialized = false;
+  clearTimeout(timeoutId);
+};
+
+const setupNextFlush = () => {
+  timeoutId = setTimeout(flush, 60 * 1000);
+};
+
+const flush = async () => {
+  const timeSeries = buildTimeSeries(metrics);
+  for (const [, metric] of Object.entries(metrics)) {
+    metric.value.advanceTimer();
+  }
+  await publishTimeSeries(timeSeries);
+  setupNextFlush();
+};

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

@@ -0,0 +1,230 @@
+'use strict';
+
+const gcpMetricCollector = require('./gcp-metric-collector');
+const {
+  stubCreateTimeSeries,
+  getPublishedMetrics,
+  flushPromises,
+  stubCreateTimeSeriesWithCallbackDuringPublish
+} = require('../../test-helpers/test-helpers');
+
+beforeEach(() => {
+  jest.useFakeTimers();
+  gcpMetricCollector.reset();
+});
+afterEach(() => {
+  jest.useRealTimers();
+  gcpMetricCollector.reset();
+});
+
+describe('gcpMetricCollector', () => {
+  describe('count', () => {
+    it('should send metric for a single measurement in next flush period', () => {
+      jest.useFakeTimers().setSystemTime(new Date(20000));
+      stubCreateTimeSeries();
+
+      gcpMetricCollector.count('jolo', { kacsa: 'A' }, 88);
+
+      expect(getPublishedMetrics()).toEqual([]);
+
+      jest.advanceTimersByTime(60 * 1000 + 1);
+
+      expect(getPublishedMetrics()).toEqual([
+        [
+          {
+            name: 'jolo',
+            labels: { kacsa: 'A' },
+            value: { int64Value: '88' },
+            startTime: 20000,
+            endTime: 80000,
+            metricKind: 'CUMULATIVE',
+            valueType: 'int64Value'
+          }
+        ]
+      ]);
+    });
+
+    it('should sum up counts that happened and publish the sum, send a metric for each label combo', () => {
+      stubCreateTimeSeries();
+
+      gcpMetricCollector.count('jolo', { a: 1 });
+      gcpMetricCollector.count('jolo');
+      gcpMetricCollector.count('yolo');
+      gcpMetricCollector.count('yolo');
+      gcpMetricCollector.count('jolo');
+
+      expect(getPublishedMetrics()).toEqual([]);
+
+      jest.advanceTimersByTime(60 * 1000 + 1);
+
+      expect(getPublishedMetrics()).toMatchObject([
+        [
+          { name: 'jolo', labels: { a: 1 }, value: { int64Value: '1' } },
+          { name: 'jolo', labels: {}, value: { int64Value: '2' } },
+          { name: 'yolo', labels: {}, value: { int64Value: '2' } }
+        ]
+      ]);
+    });
+
+    it('should not reset counts after sending metrics, but keep increasing them', async () => {
+      stubCreateTimeSeries();
+
+      gcpMetricCollector.count('jolo');
+      gcpMetricCollector.count('jolo');
+
+      jest.advanceTimersByTime(60 * 1000 + 1);
+      await flushPromises();
+      expect(getPublishedMetrics()).toMatchObject([
+        [{ name: 'jolo', labels: {}, value: { int64Value: '2' } }]
+      ]);
+
+      gcpMetricCollector.count('jolo');
+      jest.advanceTimersByTime(60 * 1000 + 1);
+      await flushPromises();
+
+      expect(getPublishedMetrics()).toMatchObject([
+        [{ name: 'jolo', labels: {}, value: { int64Value: '2' } }],
+        [{ name: 'jolo', labels: {}, value: { int64Value: '3' } }]
+      ]);
+    });
+
+    it('should not publish metrics if metric logger is not enabled', async () => {
+      process.env.METRIC_LOGGER_ENABLED = 'false';
+      stubCreateTimeSeries();
+
+      gcpMetricCollector.count('jolo', { kacsa: 'A' }, 88);
+      jest.advanceTimersByTime(60 * 1000 + 1);
+
+      expect(getPublishedMetrics()).toEqual([]);
+    });
+  });
+
+  describe('measure', () => {
+    it('should send metric for a single measurement in next flush period', () => {
+      jest.useFakeTimers().setSystemTime(new Date(20000));
+      stubCreateTimeSeries();
+
+      gcpMetricCollector.measure('jolo', { kacsa: 'A' }, 7);
+
+      expect(getPublishedMetrics()).toEqual([]);
+
+      jest.advanceTimersByTime(60 * 1000);
+
+      expect(getPublishedMetrics()).toEqual([
+        [
+          {
+            name: 'jolo',
+            labels: { kacsa: 'A' },
+            startTime: 80000,
+            endTime: 80000,
+            value: {
+              distributionValue: {
+                count: 1,
+                mean: 7,
+                sumOfSquaredDeviation: 0,
+                bucketOptions: {
+                  exponentialBuckets: { numFiniteBuckets: 20, growthFactor: 2, scale: 1 }
+                },
+                bucketCounts: [0, 0, 0, 1, ...Array(18).fill(0)]
+              }
+            },
+            metricKind: 'GAUGE',
+            valueType: 'DISTRIBUTION'
+          }
+        ]
+      ]);
+    });
+
+    it('should calculate mean and sum of squared deviation', async () => {
+      stubCreateTimeSeries();
+
+      gcpMetricCollector.measure('jolo', { kacsa: 'A' }, 7);
+      gcpMetricCollector.measure('jolo', { kacsa: 'A' }, 12);
+
+      jest.advanceTimersByTime(60 * 1000 + 1);
+      await flushPromises();
+      expect(getPublishedMetrics()).toMatchObject([
+        [
+          {
+            value: {
+              distributionValue: {
+                count: 2,
+                mean: 9.5,
+                sumOfSquaredDeviation: 12.5,
+                bucketCounts: [0, 0, 0, 1, 1, ...Array(17).fill(0)]
+              }
+            }
+          }
+        ]
+      ]);
+    });
+
+    it('should reset distribution value after sending metrics', async () => {
+      stubCreateTimeSeries();
+
+      gcpMetricCollector.measure('jolo', { kacsa: 'A' }, 7);
+      gcpMetricCollector.measure('jolo', { kacsa: 'A' }, 12);
+
+      jest.advanceTimersByTime(60 * 1000 + 1);
+      await flushPromises();
+
+      gcpMetricCollector.measure('jolo', { kacsa: 'A' }, 5);
+
+      jest.advanceTimersByTime(60 * 1000 + 1);
+      await flushPromises();
+
+      expect(getPublishedMetrics()).toMatchObject([
+        [{}],
+        [
+          {
+            value: {
+              distributionValue: {
+                count: 1,
+                mean: 5,
+                sumOfSquaredDeviation: 0,
+                bucketCounts: [0, 0, 0, 1, ...Array(18).fill(0)]
+              }
+            }
+          }
+        ]
+      ]);
+    });
+
+    it('should not remove metrics data during publishing', async () => {
+      stubCreateTimeSeriesWithCallbackDuringPublish(() => gcpMetricCollector.measure('jolo', { kacsa: 'A' }, 5));
+
+      gcpMetricCollector.measure('jolo', { kacsa: 'A' }, 7);
+
+      jest.advanceTimersByTime(60 * 1000 + 1);
+      await flushPromises();
+      jest.advanceTimersByTime(60 * 1000 + 1);
+      await flushPromises();
+
+      expect(getPublishedMetrics()).toMatchObject([
+        [{}],
+        [
+          {
+            value: {
+              distributionValue: {
+                count: 1,
+                mean: 5,
+                sumOfSquaredDeviation: 0,
+                bucketCounts: [0, 0, 0, 1, ...Array(18).fill(0)]
+              }
+            }
+          }
+        ]
+      ]);
+    });
+
+    it('should not publish metrics if metric logger is not enabled', async () => {
+      process.env.METRIC_LOGGER_ENABLED = 'false';
+      stubCreateTimeSeries();
+
+      gcpMetricCollector.measure('jolo', { kacsa: 'A' }, 88);
+      jest.advanceTimersByTime(60 * 1000 + 1);
+
+      expect(getPublishedMetrics()).toEqual([]);
+    });
+  });
+});

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

@@ -0,0 +1,27 @@
+'use strict';
+
+exports.buildTimeSeries = metrics =>
+  Object.values(metrics).map(metric => {
+    const state = metric.value.getState();
+    return {
+      metric: {
+        type: `custom.googleapis.com/${metric.name}`,
+        labels: { ...metric.labels, hostname: process.env.HOSTNAME }
+      },
+      resource: {
+        type: 'global',
+        labels: { project_id: process.env.GCP_PROJECT_ID }
+      },
+      points: [
+        {
+          interval: {
+            startTime: { seconds: state.startTime / 1000 },
+            endTime: { seconds: state.endTime / 1000 }
+          },
+          value: state.value
+        }
+      ],
+      metricKind: state.metricKind,
+      valueType: state.valueType
+    };
+  });

package/src/gcp-time-series-builder/gcp-time-series-builder.spec.js

@@ -0,0 +1,103 @@
+'use strict';
+
+const { buildTimeSeries } = require('./gcp-time-series-builder');
+
+jest.mock('@google-cloud/monitoring');
+
+const dummyMetric = ({
+  name = 'kacs',
+  labels = { a: 1 },
+  count = 14,
+  startTime = 15000,
+  endTime = 80000,
+  metricKind = 'CUMULATIVE',
+  valueType = 'int64Value'
+}) => ({
+  name,
+  labels,
+  value: {
+    getState: () => ({
+      value: { int64Value: `${count}` },
+      startTime,
+      endTime,
+      valueType,
+      metricKind
+    })
+  }
+});
+
+describe('gcpTimeSeriesBuilder', () => {
+  describe('buildTimeSeries', () => {
+    it('should create time series from metric', async () => {
+      const metrics = {
+        key1: dummyMetric({ name: 'kacs', labels: { a: 1 }, count: 14 })
+      };
+
+      expect(buildTimeSeries(metrics)).toEqual([
+        {
+          metric: {
+            labels: {
+              a: 1,
+              hostname: 'local-machine'
+            },
+            type: 'custom.googleapis.com/kacs'
+          },
+          metricKind: 'CUMULATIVE',
+          points: [
+            {
+              interval: {
+                endTime: {
+                  seconds: 80
+                },
+                startTime: {
+                  seconds: 15
+                }
+              },
+              value: {
+                int64Value: '14'
+              }
+            }
+          ],
+          resource: {
+            labels: {
+              project_id: 'dummy-project'
+            },
+            type: 'global'
+          },
+          valueType: 'int64Value'
+        }
+      ]);
+    });
+
+    it('should create time series from all the metrics', async () => {
+      const metrics = {
+        key1: dummyMetric({ name: 'kacs', labels: { a: 1 }, count: 14 }),
+        key2: dummyMetric({ name: 'kacs', labels: { a: 2 }, count: 88 }),
+        key3: dummyMetric({ name: 'lacs', labels: {}, count: 1 })
+      };
+
+      expect(buildTimeSeries(metrics)).toMatchObject([
+        {
+          points: [{ value: { int64Value: '14' } }],
+          metric: {
+            type: 'custom.googleapis.com/kacs',
+            labels: { a: 1 }
+          }
+        },
+        {
+          points: [{ value: { int64Value: '88' } }],
+          metric: {
+            type: 'custom.googleapis.com/kacs',
+            labels: { a: 2 }
+          }
+        },
+        {
+          points: [{ value: { int64Value: '1' } }],
+          metric: {
+            type: 'custom.googleapis.com/lacs'
+          }
+        }
+      ]);
+    });
+  });
+});

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

@@ -0,0 +1,26 @@
+'use strict';
+
+const logger = require('@emartech/json-logger')('aggregate-metric-logger');
+const monitoring = require('@google-cloud/monitoring');
+
+exports.publishTimeSeries = async timeSeries => {
+  try {
+    const client = getMonitoringClient();
+    await client.createTimeSeries({
+      name: client.projectPath(process.env.GCP_PROJECT_ID),
+      timeSeries
+    });
+  } catch (error) {
+    logger.warnFromError('pushing-metrics-failed', error, { do_not_alert: true });
+  }
+};
+
+let monitoringClientInstance = null;
+const getMonitoringClient = () => {
+  if (!monitoringClientInstance) {
+    monitoringClientInstance = new monitoring.MetricServiceClient({
+      projectId: process.env.GCP_PROJECT_ID
+    });
+  }
+  return monitoringClientInstance;
+};

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

@@ -0,0 +1,25 @@
+'use strict';
+
+const { MetricServiceClient } = require('@google-cloud/monitoring');
+const { publishTimeSeries } = require('./gcp-time-series-publisher');
+const { stubCreateTimeSeries } = require('../../test-helpers/test-helpers');
+
+jest.mock('@google-cloud/monitoring');
+
+describe('gcpMetricPublisher', () => {
+  describe('publishTimeSeries', () => {
+    it('should push a metrics to gcp in the correct format', async () => {
+      stubCreateTimeSeries();
+      process.env.HOSTNAME = 'test-host';
+      process.env.GCP_PROJECT_ID = 'test-project';
+      const timeSeries = [1, 2];
+
+      await publishTimeSeries(timeSeries);
+
+      expect(MetricServiceClient.prototype.createTimeSeries).toHaveBeenCalledWith({
+        name: 'projects/test-project',
+        timeSeries
+      });
+    });
+  });
+});

package/src/index.js

@@ -1,7 +1,7 @@
 'use strict';
 
-const metricLoggerFactory = require('./metric-logger');
-const gcpMetricCollector = require('./gcp-metric-collector');
+const metricLoggerFactory = require('./laas-metric-logger/laas-metric-logger');
+const gcpMetricCollector = require('./gcp-metric-collector/gcp-metric-collector');
 
 const enabled = process.env.METRIC_LOGGER_ENABLED === 'true';
 
@@ -24,5 +24,6 @@ exposedFactoryInstanceHybrid.stop = exposedInstance.stop;
 exposedFactoryInstanceHybrid.cancel = exposedInstance.cancel;
 
 exposedFactoryInstanceHybrid.count = gcpMetricCollector.count;
+exposedFactoryInstanceHybrid.measureGcp = gcpMetricCollector.measure;
 
 module.exports = exposedFactoryInstanceHybrid;

package/src/{metric-logger.spec.js → laas-metric-logger/laas-metric-logger.spec.js}

@@ -1,8 +1,8 @@
 'use strict';
 
-const metricLoggerFactory = require('./metric-logger');
 const Logger = require('@emartech/json-logger').Logger;
 const fakeTimers = require('@sinonjs/fake-timers');
+const metricLoggerFactory = require('./laas-metric-logger');
 
 let metricLogger;
 let clock;

package/src/metric-types/counter/counter.js

@@ -0,0 +1,18 @@
+'use strict';
+
+exports.createCounter = () => {
+  let count = 0;
+  const startTime = Date.now();
+
+  return {
+    getState: () => ({
+      startTime,
+      endTime: Date.now(),
+      metricKind: 'CUMULATIVE',
+      valueType: 'int64Value',
+      value: { int64Value: `${count}` }
+    }),
+    add: value => (count += value),
+    advanceTimer: () => {}
+  };
+};

package/src/metric-types/counter/counter.spec.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const { createCounter } = require('./counter');
+
+describe('count', () => {
+  it('should return an empty counter if no values were added', () => {
+    jest.useFakeTimers().setSystemTime(new Date(880));
+    const counter = createCounter();
+
+    expect(counter.getState()).toEqual({
+      startTime: 880,
+      endTime: 880,
+      metricKind: 'CUMULATIVE',
+      valueType: 'int64Value',
+      value: { int64Value: '0' }
+    });
+  });
+
+  it('should increment counter when a value is added', () => {
+    const counter = createCounter();
+
+    counter.add(2);
+    counter.add(5);
+
+    expect(counter.getState()).toMatchObject({ value: { int64Value: '7' } });
+  });
+
+  it('should not reset the current count on advanceTimer call', () => {
+    jest.useFakeTimers().setSystemTime(new Date(880));
+    const counter = createCounter();
+
+    jest.advanceTimersByTime(20);
+    counter.add(2);
+    counter.advanceTimer();
+    counter.add(1);
+
+    expect(counter.getState()).toMatchObject({
+      value: { int64Value: '3' },
+      startTime: 880,
+      endTime: 900
+    });
+  });
+
+  it('should return current time as endTime', () => {
+    jest.useFakeTimers().setSystemTime(new Date(880));
+    const counter = createCounter();
+
+    jest.advanceTimersByTime(20);
+
+    expect(counter.getState()).toMatchObject({ endTime: 900 });
+  });
+});

package/src/metric-types/distribution/distribution.js

@@ -0,0 +1,49 @@
+'use strict';
+
+// exponential bucket rules: https://cloud.google.com/monitoring/api/ref_v3/rest/v3/TypedValue#exponential
+
+exports.createDistribution = ({ scale = 1, growthFactor = 2, numFiniteBuckets = 20 } = {}) => {
+  const bucketUpperBounds = Array(numFiniteBuckets + 2)
+    .fill(null)
+    .map((value, index, array) =>
+      index === array.length - 1 ? Infinity : scale * growthFactor ** index
+    );
+  const createInitialState = () => ({
+    count: 0,
+    mean: 0,
+    sumOfSquaredDeviation: 0,
+    bucketCounts: bucketUpperBounds.map(() => 0)
+  });
+  let state = createInitialState();
+
+  return {
+    add: value => {
+      state.count += 1;
+      const previousMean = state.mean;
+      state.mean = state.mean + (value - state.mean) / state.count;
+      // calculation from https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm
+      state.sumOfSquaredDeviation =
+        state.sumOfSquaredDeviation + (value - previousMean) * (value - state.mean);
+
+      const index = bucketUpperBounds.findIndex(bound => value < bound);
+      state.bucketCounts[index] += 1;
+    },
+    getState: () => ({
+      endTime: Date.now(),
+      startTime: Date.now(),
+      metricKind: 'GAUGE',
+      valueType: 'DISTRIBUTION',
+      value: {
+        distributionValue: {
+          ...state,
+          bucketOptions: {
+            exponentialBuckets: { numFiniteBuckets, growthFactor, scale }
+          }
+        }
+      }
+    }),
+    advanceTimer: () => {
+      state = createInitialState();
+    }
+  };
+};

package/src/metric-types/distribution/distribution.spec.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const { sum } = require('lodash');
+const { createDistribution } = require('./distribution');
+
+describe('distribution', () => {
+  it('should return an empty distribution if no values were added', () => {
+    jest.useFakeTimers().setSystemTime(new Date(15000));
+    const distribution = createDistribution({ scale: 1, growFactor: 2, numFiniteBuckets: 2 });
+
+    expect(distribution.getState()).toEqual({
+      startTime: 15000,
+      endTime: 15000,
+      metricKind: 'GAUGE',
+      valueType: 'DISTRIBUTION',
+      value: {
+        distributionValue: {
+          count: 0,
+          mean: 0,
+          sumOfSquaredDeviation: 0,
+          bucketOptions: { exponentialBuckets: { numFiniteBuckets: 2, growthFactor: 2, scale: 1 } },
+          bucketCounts: [0, 0, 0, 0]
+        }
+      }
+    });
+  });
+
+  it('should calculate the counter of all added values', () => {
+    const distribution = createDistribution();
+
+    distribution.add(2);
+    distribution.add(3);
+    distribution.add(16);
+
+    expect(distribution.getState().value.distributionValue).toMatchObject({ count: 3 });
+  });
+
+  it('should calculate the mean of all added values', () => {
+    const distribution = createDistribution();
+
+    distribution.add(2);
+    distribution.add(3);
+    distribution.add(16);
+
+    expect(distribution.getState().value.distributionValue).toMatchObject({ mean: 7 });
+  });
+
+  it('should calculate the sum of square deviation', () => {
+    const distribution = createDistribution({ numFiniteBuckets: 2 });
+
+    const values = [2, 3, 16];
+    const mean = sum(values) / values.length;
+    const sumOfSquaredDeviation = sum(values.map(value => (value - mean) ** 2));
+
+    values.forEach(value => distribution.add(value));
+
+    expect(distribution.getState().value.distributionValue).toMatchObject({
+      sumOfSquaredDeviation
+    });
+  });
+
+  describe('calculating bucketCounts', () => {
+    it('should add a negative number to the underflow bucket', () => {
+      const distribution = createDistribution({ numFiniteBuckets: 2 });
+
+      distribution.add(-12);
+      distribution.add(-12);
+
+      expect(distribution.getState().value.distributionValue).toMatchObject({
+        bucketCounts: [2, 0, 0, 0]
+      });
+    });
+
+    it('should increment the correct bucket when a value is added', () => {
+      const distribution = createDistribution({
+        scale: 1,
+        growFactor: 2,
+        numFiniteBuckets: 2
+      });
+
+      distribution.add(0.15);
+      distribution.add(1.2);
+      distribution.add(1.45);
+      distribution.add(3);
+
+      expect(distribution.getState().value.distributionValue).toMatchObject({
+        bucketCounts: [1, 2, 1, 0]
+      });
+    });
+
+    it('should correctly make the upper bound exclusive, the lower bound inclusive', () => {
+      const distribution = createDistribution({
+        scale: 1,
+        growFactor: 2,
+        numFiniteBuckets: 2
+      });
+
+      distribution.add(4);
+
+      expect(distribution.getState().value.distributionValue).toMatchObject({
+        bucketCounts: [0, 0, 0, 1]
+      });
+    });
+
+    it('should add overly huge value to the overflow bucket', () => {
+      const distribution = createDistribution({
+        scale: 1,
+        growFactor: 2,
+        numFiniteBuckets: 2
+      });
+
+      distribution.add(168);
+
+      expect(distribution.getState().value.distributionValue).toMatchObject({
+        bucketCounts: [0, 0, 0, 1]
+      });
+    });
+
+    it('should reset internal stats after advanceTimer call and start from initial values for next round', () => {
+      const distribution = createDistribution({
+        scale: 1,
+        growFactor: 2,
+        numFiniteBuckets: 2
+      });
+
+      distribution.add(1);
+      distribution.advanceTimer();
+
+      expect(distribution.getState().value.distributionValue).toMatchObject({
+        count: 0,
+        mean: 0,
+        sumOfSquaredDeviation: 0,
+        bucketCounts: [0, 0, 0, 0]
+      });
+    });
+  });
+});

package/test-helpers/test-helpers.js

@@ -1,7 +1,17 @@
 'use strict';
 
 const { MetricServiceClient } = require('@google-cloud/monitoring');
-const { omit } = require('lodash');
+const { omit, pick } = require('lodash');
+
+exports.stubCreateTimeSeriesWithCallbackDuringPublish = (createMetric) => {
+  jest.spyOn(MetricServiceClient.prototype, 'createTimeSeries').mockImplementation(
+    () =>
+      new Promise(resolve => {
+        createMetric();
+        resolve();
+      })
+  );
+};
 
 exports.stubCreateTimeSeries = () => {
   jest.spyOn(MetricServiceClient.prototype, 'createTimeSeries').mockResolvedValue();
@@ -14,9 +24,12 @@ exports.getPublishedMetrics = () => {
 
   return mock.calls.map(call =>
     call[0].timeSeries.map(series => ({
+      ...pick(series, ['metricKind', 'valueType']),
       name: series.metric.type.replace('custom.googleapis.com/', ''),
       labels: omit(series.metric.labels, 'hostname'),
-      count: Number(series.points[0].value.int64Value)
+      startTime: series.points[0].interval.startTime.seconds * 1000,
+      endTime: series.points[0].interval.endTime.seconds * 1000,
+      value: series.points[0].value
     }))
   );
 };

package/src/gcp-metric-collector.js

@@ -1,41 +0,0 @@
-'use strict';
-
-const stringify = require('json-stable-stringify');
-const { publishCountMetrics } = require('./gcp-metric-publisher');
-
-let metrics = {};
-let initialized = false;
-let startTime = null;
-let timeoutId = null;
-
-exports.count = (metricName, labels = {}, value = 1) => {
-  if (process.env.METRIC_LOGGER_ENABLED !== 'true') return;
-
-  if (!initialized) {
-    initialized = true;
-    startTime = Date.now();
-    setupNextFlush();
-  }
-  const key = `${metricName}_${stringify(labels)}`;
-  if (!metrics[key]) {
-    metrics[key] = { name: metricName, labels, count: value };
-  } else {
-    metrics[key].count += value;
-  }
-};
-
-exports.reset = () => {
-  metrics = {};
-  initialized = false;
-  startTime = null;
-  clearTimeout(timeoutId);
-};
-
-const setupNextFlush = () => {
-  timeoutId = setTimeout(flush, 60 * 1000);
-};
-
-const flush = async () => {
-  await publishCountMetrics(metrics, startTime);
-  setupNextFlush();
-};

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

@@ -1,89 +0,0 @@
-'use strict';
-
-const gcpMetricCollector = require('./gcp-metric-collector');
-const {
-  stubCreateTimeSeries,
-  getPublishedMetrics,
-  flushPromises
-} = require('../test-helpers/test-helpers');
-
-beforeEach(() => {
-  jest.useFakeTimers();
-  gcpMetricCollector.reset();
-});
-afterEach(() => {
-  jest.useRealTimers();
-  gcpMetricCollector.reset();
-});
-
-describe('gcpMetricCollector', () => {
-  describe('count', () => {
-    it('should send metric for a single measurement in next flush period', () => {
-      stubCreateTimeSeries();
-
-      gcpMetricCollector.count('jolo', { 'kacsa': 'A' }, 88);
-
-      expect(getPublishedMetrics()).toEqual([]);
-
-      jest.advanceTimersByTime(60 * 1000 + 1);
-
-      expect(getPublishedMetrics()).toEqual([
-        [{ name: 'jolo', labels: { kacsa: 'A' }, count: 88 }]
-      ]);
-    });
-
-    it('should sum up counts that happened and publish the sum, send a metric for each label combo', () => {
-      stubCreateTimeSeries();
-
-      gcpMetricCollector.count('jolo', { a: 1 });
-      gcpMetricCollector.count('jolo');
-      gcpMetricCollector.count('yolo');
-      gcpMetricCollector.count('yolo');
-      gcpMetricCollector.count('jolo');
-
-      expect(getPublishedMetrics()).toEqual([]);
-
-      jest.advanceTimersByTime(60 * 1000 + 1);
-
-      expect(getPublishedMetrics()).toEqual([
-        [
-          { name: 'jolo', labels: { a: 1 }, count: 1 },
-          { name: 'jolo', labels: {}, count: 2 },
-          { name: 'yolo', labels: {}, count: 2 }
-        ]
-      ]);
-    });
-
-    it('should not reset counts after sending metrics, but keep increasing them', async () => {
-      stubCreateTimeSeries();
-
-      gcpMetricCollector.count('jolo');
-      gcpMetricCollector.count('jolo');
-
-      jest.advanceTimersByTime(60 * 1000 + 1);
-      await flushPromises();
-      expect(getPublishedMetrics()).toEqual([
-        [{ name: 'jolo', labels: {}, count: 2 }]
-      ]);
-
-      gcpMetricCollector.count('jolo');
-      jest.advanceTimersByTime(60 * 1000 + 1);
-      await flushPromises();
-
-      expect(getPublishedMetrics()).toEqual([
-        [{ name: 'jolo', labels: {}, count: 2 }],
-        [{ name: 'jolo', labels: {}, count: 3 }]
-      ]);
-    });
-
-    it('should not publish metrics if metric logger is not enabled', async () => {
-      process.env.METRIC_LOGGER_ENABLED = 'false';
-      stubCreateTimeSeries();
-
-      gcpMetricCollector.count('jolo', { 'kacsa': 'A' }, 88);
-      jest.advanceTimersByTime(60 * 1000 + 1);
-
-      expect(getPublishedMetrics()).toEqual([]);
-    });
-  });
-});

package/src/gcp-metric-publisher.js

@@ -1,48 +0,0 @@
-'use strict';
-
-const logger = require('@emartech/json-logger')('aggregate-metric-logger');
-const monitoring = require('@google-cloud/monitoring');
-
-exports.publishCountMetrics = async (metrics, startTime) => {
-  const timeSeries = Object.values(metrics).map(metric => ({
-    metric: {
-      type: `custom.googleapis.com/${metric.name}`,
-      labels: { ...metric.labels, hostname: process.env.HOSTNAME }
-    },
-    resource: {
-      type: 'global',
-      labels: { project_id: process.env.GCP_PROJECT_ID }
-    },
-    points: [
-      {
-        interval: {
-          startTime: { seconds: startTime / 1000 },
-          endTime: { seconds: Date.now() / 1000 }
-        },
-        value: { int64Value: `${metric.count}` }
-      }
-    ],
-    metricKind: 'CUMULATIVE',
-    valueType: 'int64Value'
-  }));
-  try {
-    const client = getMonitoringClient();
-    await client.createTimeSeries({
-      name: client.projectPath(process.env.GCP_PROJECT_ID),
-      timeSeries
-    });
-  } catch (error) {
-    logger.warnFromError('pushing-metrics-failed', error, { do_not_alert: true });
-  }
-};
-
-let monitoringClientInstance = null;
-const getMonitoringClient = () => {
-  if (!monitoringClientInstance) {
-    monitoringClientInstance = new monitoring.MetricServiceClient({
-      projectId: process.env.GCP_PROJECT_ID,
-      credentials: JSON.parse(process.env.GCP_CREDENTIALS || '{}')
-    });
-  }
-  return monitoringClientInstance;
-};

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

@@ -1,68 +0,0 @@
-'use strict';
-
-const { MetricServiceClient } = require('@google-cloud/monitoring');
-const { publishCountMetrics } = require('./gcp-metric-publisher');
-const { stubCreateTimeSeries, getPublishedMetrics } = require('../test-helpers/test-helpers');
-
-jest.mock('@google-cloud/monitoring');
-
-describe('gcpMetricPublisher', () => {
-  describe('publishCountMetrics', () => {
-    it('should push a metrics to gcp in the correct format', async () => {
-      stubCreateTimeSeries();
-      jest.useFakeTimers().setSystemTime(new Date(80000));
-      process.env.HOSTNAME = 'test-host';
-      process.env.GCP_PROJECT_ID = 'test-project';
-      const metrics = {
-        key1: { name: 'kacs', labels: { a: 1 }, count: 14 }
-      };
-      const startTime = 15000;
-
-      await publishCountMetrics(metrics, startTime);
-
-      expect(MetricServiceClient.prototype.createTimeSeries).toHaveBeenCalledWith({
-        name: 'projects/test-project',
-        timeSeries: [
-          {
-            metric: {
-              type: 'custom.googleapis.com/kacs',
-              labels: { a: 1, hostname: 'test-host' }
-            },
-            resource: { type: 'global', labels: { project_id: 'test-project' } },
-            points: [
-              {
-                interval: {
-                  startTime: { seconds: 15 },
-                  endTime: { seconds: 80 }
-                },
-                value: { int64Value: '14' }
-              }
-            ],
-            metricKind: 'CUMULATIVE',
-            valueType: 'int64Value'
-          }
-        ]
-      });
-    });
-
-    it('should publish multile metrics with the same api call', async () => {
-      stubCreateTimeSeries();
-      const metrics = {
-        key1: { name: 'kacs', labels: { a: 1 }, count: 14 },
-        key2: { name: 'kacs', labels: { a: 2 }, count: 88 },
-        key3: { name: 'lacs', labels: {}, count: 1 }
-      };
-      const startTime = 15000;
-
-      await publishCountMetrics(metrics, startTime);
-
-      expect(getPublishedMetrics()).toEqual([
-        [
-          { name: 'kacs', labels: { a: 1 }, count: 14 },
-          { name: 'kacs', labels: { a: 2 }, count: 88 },
-          { name: 'lacs', labels: {}, count: 1 }
-        ]
-      ]);
-    });
-  });
-});