update metrics to latest format, specify histogram buckets

Author: digitalsadhu

lib/optimistic-bundler.js

@@ -9,21 +9,6 @@ const Storage = require('./storage');
 const schemas = require('../lib/schemas');
 const { hashContent } = require('./hasher');
 
-const PERSIST_TO_STORAGE_METRIC = {
-    name: 'asset_server_persist_to_storage_timer',
-    description: 'Time taken for a persist operation to storage',
-};
-
-const RETRIEVE_FROM_STORAGE_METRIC = {
-    name: 'asset_server_retrieve_from_storage_timer',
-    description: 'Time taken for a retrieve operation from storage',
-};
-
-const EXISTS_IN_STORAGE_METRIC = {
-    name: 'asset_server_exists_in_storage_timer',
-    description: 'Time taken for a check for existence operation from storage',
-};
-
 module.exports = class OptimisticBundler extends Bundler {
     constructor({ bundleInProcess, ...options }) {
         super({ bundleInProcess });
@@ -38,6 +23,63 @@ module.exports = class OptimisticBundler extends Bundler {
         this.log = abslog(options.logger);
         this.options = opts;
         this.overrides = {};
+
+        this.bundleSizeGaugeMetric = this.metrics.gauge({
+            name: 'asset_server_bundle_size_gauge',
+            description: 'Measures the size of bundles created',
+        });
+        this.bundlingTimerMetric = this.metrics.histogram({
+            name: 'asset_server_bundling_timer',
+            description: 'Time taken to bundle assets',
+            buckets: [1, 5, 10, 15, 20, 30, 60, 120],
+        });
+        this.retrieveFromStorageTimerMetric = this.metrics.histogram({
+            name: 'asset_server_retrieve_from_storage_timer',
+            description: 'Time taken for a retrieve operation from storage',
+            buckets: [1, 5, 10, 15, 20, 30, 60, 120],
+        });
+        this.existsInStorageTimerMetric = this.metrics.histogram({
+            name: 'asset_server_exists_in_storage_timer',
+            description:
+                'Time taken for a check for existence operation from storage',
+            buckets: [1, 5, 10, 15, 20, 30, 60, 120],
+        });
+        this.persistToStorageTimerMetric = this.metrics.histogram({
+            name: 'asset_server_persist_to_storage_timer',
+            description: 'Time taken for a persist operation to storage',
+            buckets: [1, 5, 10, 15, 20, 30, 60, 120],
+        });
+        this.publishAssetsTimerMetric = this.metrics.histogram({
+            name: 'asset_server_publish_assets_timer',
+            description:
+                'Time taken for a publish assets operation to complete',
+            buckets: [1, 5, 10, 15, 20, 30, 60, 120],
+        });
+        this.saveFeedTimerMetric = this.metrics.histogram({
+            name: 'asset_server_save_feed_timer',
+            description: 'Time taken for a feed to be saved to storage',
+            buckets: [1, 5, 10, 15, 20, 30, 60, 120],
+        });
+        this.fallbackBundleSizeGaugeMetric = this.metrics.gauge({
+            name: 'asset_server_fallback_bundle_size_gauge',
+            description: 'Measures the size of fallback bundles created',
+        });
+        this.saveFallbackBundleTimerMetric = this.metrics.histogram({
+            name: 'asset_server_save_fallback_bundle_timer',
+            description:
+                'Time taken for a fallback bundle to be bundled and saved',
+            buckets: [1, 5, 10, 15, 20, 30, 60, 120],
+        });
+        this.publishInstructionsTimerMetric = this.metrics.histogram({
+            name: 'asset_server_publish_instructions_timer',
+            description: 'Time taken for publishInstructions() to complete',
+            buckets: [1, 5, 10, 15, 20, 30, 60, 120],
+        });
+        this.rebundleInstructionsTimerMetric = this.metrics.histogram({
+            name: 'asset_server_rebundle_instructions_timer',
+            description: 'Time taken to rebundle all instructions for a tag',
+            buckets: [1, 5, 10, 15, 20, 30, 60, 120],
+        });
     }
 
     async assetsPublished(tags, hashes, type) {
@@ -55,85 +97,85 @@ module.exports = class OptimisticBundler extends Bundler {
     }
 
     async getTags(tags, type) {
-        const end = this.metrics.timer(RETRIEVE_FROM_STORAGE_METRIC);
+        const end = this.retrieveFromStorageTimerMetric.timer();
 
         const storageTags = await this.storage.getTags(tags, type);
 
-        end({ meta: { method: 'getTags' } });
+        end({ labels: { method: 'getTags' } });
 
         return storageTags;
     }
 
     async getFeed(hash) {
-        const end = this.metrics.timer(RETRIEVE_FROM_STORAGE_METRIC);
+        const end = this.retrieveFromStorageTimerMetric.timer();
 
         const feed = await this.storage.getFeed(hash);
 
-        end({ meta: { method: 'getFeed' } });
+        end({ labels: { method: 'getFeed' } });
 
         return feed;
     }
 
     async hasFeed(hash) {
-        const end = this.metrics.timer(EXISTS_IN_STORAGE_METRIC);
+        const end = this.existsInStorageTimerMetric.timer();
 
         const hasFeed = await this.storage.hasFeed(hash);
 
-        end({ meta: { method: 'hasFeed' } });
+        end({ labels: { method: 'hasFeed' } });
 
         return hasFeed;
     }
 
     async hasBundle(hash, type) {
-        const end = this.metrics.timer(EXISTS_IN_STORAGE_METRIC);
+        const end = this.existsInStorageTimerMetric.timer();
 
         const hasBundle = await this.storage.hasBundle(hash, type);
 
-        end({ meta: { method: 'hasBundle' } });
+        end({ labels: { method: 'hasBundle' } });
 
         return hasBundle;
     }
 
     async setBundle(hash, type, content) {
-        const end = this.metrics.timer(PERSIST_TO_STORAGE_METRIC);
+        const end = this.persistToStorageTimerMetric.timer();
 
         await this.storage.setBundle(hash, type, content);
 
-        end({ meta: { method: 'setBundle' } });
+        end({ labels: { method: 'setBundle' } });
     }
 
     async getInstructions(tag, type) {
-        const end = this.metrics.timer(RETRIEVE_FROM_STORAGE_METRIC);
+        const end = this.retrieveFromStorageTimerMetric.timer();
 
         const instructions = await this.storage.getInstructions(tag, type);
 
-        end({ meta: { method: 'getInstructions' } });
+        end({ labels: { method: 'getInstructions' } });
 
         return instructions;
     }
 
     async setInstruction(tag, type, instruction) {
-        const end = this.metrics.timer(PERSIST_TO_STORAGE_METRIC);
+        const end = this.persistToStorageTimerMetric.timer();
 
         await this.storage.setInstruction(tag, type, instruction);
 
-        end({ meta: { method: 'setInstruction' } });
+        end({ labels: { method: 'setInstruction' } });
     }
 
     async setFeed(feedHash, assetFeed) {
-        const end = this.metrics.timer(PERSIST_TO_STORAGE_METRIC);
+        const end = this.persistToStorageTimerMetric.timer();
 
         await this.storage.setFeed(feedHash, assetFeed);
 
-        end({ meta: { method: 'setFeed' } });
+        end({ labels: { method: 'setFeed' } });
     }
 
     async setTag(tag, assetType, feedHash) {
-        const end = this.metrics.timer(PERSIST_TO_STORAGE_METRIC);
+        const end = this.persistToStorageTimerMetric.timer();
 
         await this.storage.setTag(tag, assetType, feedHash);
 
-        end({ meta: { method: 'setTag' } });
+        end({ labels: { method: 'setTag' } });
     }
 
     async bundleExists(tags, hashes, type) {
@@ -164,11 +206,9 @@ module.exports = class OptimisticBundler extends Bundler {
     async bundle(tag, tags, hashes, type) {
         const feeds = await this.getFeeds(hashes);
 
-        const end = this.metrics.timer({
-            name: 'asset_server_bundling_timer',
-            description: 'Time taken to bundle assets',
-            meta: {
-                sources: tags,
+        const end = this.bundlingTimerMetric.timer({
+            labels: {
+                sources: JSON.stringify(tags),
                 assetType: type,
                 publisher: tag,
             },
@@ -182,12 +222,9 @@ module.exports = class OptimisticBundler extends Bundler {
 
         end();
 
-        this.metrics.metric({
-            name: 'asset_server_bundle_size_gauge',
-            description: 'Measures the size of bundles created',
-            value: Buffer.byteLength(content, 'utf8'),
-            meta: {
-                sources: tags,
+        this.bundleSizeGaugeMetric.set(Buffer.byteLength(content, 'utf8'), {
+            labels: {
+                sources: JSON.stringify(tags),
                 assetType: type,
                 publisher: tag,
             },
@@ -242,10 +279,8 @@ module.exports = class OptimisticBundler extends Bundler {
     }
 
     async rebundle(tag, type) {
-        const end = this.metrics.timer({
-            name: 'asset_server_rebundle_instructions_timer',
-            description: 'Time taken to rebundle all instructions for a tag',
-            meta: {
+        const end = this.rebundleInstructionsTimerMetric.timer({
+            labels: {
                 assetType: type,
                 publisher: tag,
             },
@@ -266,10 +301,8 @@ module.exports = class OptimisticBundler extends Bundler {
             `Invalid 'instruction' object given when attempting to publish instructions.`,
         );
 
-        const end = this.metrics.timer({
-            name: 'asset_server_publish_instructions_timer',
-            description: 'Time taken for publishInstructions() to complete',
-            meta: {
+        const end = this.publishAssetsTimerMetric.timer({
+            labels: {
                 assetType: type,
                 publisher: tag,
             },
@@ -291,11 +324,8 @@ module.exports = class OptimisticBundler extends Bundler {
     }
 
     async saveFallbackBundle(tag, hash, type, feed) {
-        const end = this.metrics.timer({
-            name: 'asset_server_save_fallback_bundle_timer',
-            description:
-                'Time taken for a fallback bundle to be bundled and saved',
-            meta: {
+        const end = this.saveFallbackBundleTimerMetric.timer({
+            labels: {
                 assetType: type,
                 publisher: tag,
             },
@@ -309,15 +339,15 @@ module.exports = class OptimisticBundler extends Bundler {
             const bundle = await super.bundleFeeds([feed], type);
             await this.setBundle(hash, type, bundle);
 
-            this.metrics.metric({
-                name: 'asset_server_fallback_bundle_size_gauge',
-                description: 'Measures the size of fallback bundles created',
-                value: Buffer.byteLength(bundle, 'utf8'),
-                meta: {
-                    assetType: type,
-                    publisher: tag,
+            this.fallbackBundleSizeGaugeMetric.set(
+                Buffer.byteLength(bundle, 'utf8'),
+                {
+                    labels: {
+                        assetType: type,
+                        publisher: tag,
+                    },
                 },
-            });
+            );
 
             this.log.info(
                 `${type} fallback bundle for tag "${tag}" published as "${hash}.${type}"`,
@@ -328,10 +358,8 @@ module.exports = class OptimisticBundler extends Bundler {
     }
 
     async saveFeed(tag, hash, type, feed) {
-        const end = this.metrics.timer({
-            name: 'asset_server_save_feed_timer',
-            description: 'Time taken for a feed to be saved to storage',
-            meta: {
+        const end = this.saveFeedTimerMetric.timer({
+            labels: {
                 assetType: type,
                 publisher: tag,
             },
@@ -358,11 +386,8 @@ module.exports = class OptimisticBundler extends Bundler {
             `Invalid 'assets' object given when attempting to publish assets.`,
         );
 
-        const end = this.metrics.timer({
-            name: 'asset_server_publish_assets_timer',
-            description:
-                'Time taken for a publish assets operation to complete',
-            meta: {
+        const end = this.publishAssetsTimerMetric.timer({
+            labels: {
                 assetType: type,
                 publisher: tag,
             },

test/main-optimistic.test.js

@@ -432,6 +432,6 @@ describe('publishing and bundling js feeds', () => {
             'Time taken for a check for existence operation from storage',
         );
         expect(obj.type).toEqual(5);
-        expect(obj.meta).toEqual({ method: 'hasFeed' });
+        expect(obj.meta.buckets).toEqual([1, 5, 10, 15, 20, 30, 60, 120]);
     });
 });

test/unit/optimistic.test.js

@@ -80,7 +80,8 @@ test('bundle()', async () => {
         'Time taken for a retrieve operation from storage',
     );
     expect(obj.type).toEqual(5);
-    expect(obj.meta).toEqual({ method: 'getFeed' });
+    expect(obj.labels).toEqual([{ name: 'method', value: 'getFeed' }]);
+    expect(obj.meta).toEqual({ buckets: [1, 5, 10, 15, 20, 30, 60, 120] });
 });
 
 test('bundleIfNeeded() - produces new bundle', async () => {
@@ -130,7 +131,8 @@ test('bundleIfNeeded() - produces metrics', async () => {
         'Time taken for a retrieve operation from storage',
     );
     expect(obj.type).toEqual(5);
-    expect(obj.meta).toEqual({ method: 'getTags' });
+    expect(obj.labels).toEqual([{ name: 'method', value: 'getTags' }]);
+    expect(obj.meta).toEqual({ buckets: [1, 5, 10, 15, 20, 30, 60, 120] });
 });
 
 test('bundleIfNeeded() - does not need to produce bundle', async () => {