@promster/metrics 4.1.13 → 6.0.2

package/CHANGELOG.md

@@ -1,5 +1,58 @@
 # @promster/metrics
 
+## 6.0.2
+
+### Patch Changes
+
+- [#620](https://github.com/tdeekens/promster/pull/620) [`ec2a8f8`](https://github.com/tdeekens/promster/commit/ec2a8f83a94bbe63360cf7027eeba92895315a19) Thanks [@tdeekens](https://github.com/tdeekens)! - refactor: improve typings (not exposed part)
+
+* [#618](https://github.com/tdeekens/promster/pull/618) [`bbab9ca`](https://github.com/tdeekens/promster/commit/bbab9cad6a3484e4894d159267d62e54e202812a) Thanks [@tdeekens](https://github.com/tdeekens)! - chore: update deps
+
+## 6.0.1
+
+### Patch Changes
+
+- [#601](https://github.com/tdeekens/promster/pull/601) [`17a24dc`](https://github.com/tdeekens/promster/commit/17a24dc0d735478001524c853b9f54f862153852) Thanks [@tdeekens](https://github.com/tdeekens)! - Update dependencies and apply eslint rule suggestions.
+
+## 6.0.0
+
+### Major Changes
+
+- [`daf8605`](https://github.com/tdeekens/promster/commit/daf86055e64cb420c83dbc7abbcd5024d449c53f) [#557](https://github.com/tdeekens/promster/pull/557) Thanks [@tdeekens](https://github.com/tdeekens)! - # Breaking Changes
+
+  This requires your to update your peer dependency of `prom-client` to v13.
+
+  The new version of `prom-client` has additional small breaking changes `promster` has to incorporate which can leak into your application.
+
+  If you do not use our `@promster/server` package and have a `res.send(register.metrics())` you have to change it to `res.send(await register.metrics())`.
+
+  You can find more on the `prom-client` changes [here](https://github.com/siimon/prom-client/blob/master/CHANGELOG.md).
+
+## 5.0.0
+
+### Major Changes
+
+- [`0eb64ca`](https://github.com/tdeekens/promster/commit/0eb64cac9a4a51dab1a556f46c97a2a5542bcc88) [#529](https://github.com/tdeekens/promster/pull/529) Thanks [@tdeekens](https://github.com/tdeekens)! - # Introduction
+
+  refactor: to use preconstruct for building
+
+  Prior TypeScript was used to build bundles. In all this should not affect consumers of this library. Under the hood preconstruct uses rollup and babel which is now instructed to build for Node.js v12 using the preset-env preset.
+
+  # Breaking Change
+
+  This release can _potentially_ be breaking for you. We want to respect semantic versioning and follow it strictly.
+
+  While migrating to preconstruct the `version` exports had to be removed as preconstruct's rollup will not resolve them. If you relied on this value you should either load the `package.json` of each module yourself or drop the usage.
+
+  ```diff
+  - const { version } = require('@promster/server');
+  + const { version } = require('@promster/server/package.json');
+  ```
+
+### Patch Changes
+
+- [`bdf75de`](https://github.com/tdeekens/promster/commit/bdf75dec8d0ce6be65ecccf5963f348e1a0a96b3) [#531](https://github.com/tdeekens/promster/pull/531) Thanks [@tdeekens](https://github.com/tdeekens)! - fix: update dependencies
+
 ## 4.1.13
 
 ### Patch Changes

package/dist/{modules → declarations/src}/client/client.d.ts

@@ -1,4 +1,4 @@
-import * as Prometheus from 'prom-client';
-declare const defaultRegister: Prometheus.Registry;
-declare const configure: any;
-export { Prometheus, defaultRegister, configure };
+import * as Prometheus from 'prom-client';
+declare const defaultRegister: Prometheus.Registry;
+declare const configure: any;
+export { Prometheus, defaultRegister, configure };

package/dist/{modules → declarations/src}/client/index.d.ts

@@ -1,2 +1,2 @@
-import { Prometheus, defaultRegister, configure } from './client';
-export { Prometheus, defaultRegister, configure };
+import { Prometheus, defaultRegister, configure } from './client';
+export { Prometheus, defaultRegister, configure };

package/dist/{modules → declarations/src}/create-gc-observer/create-gc-observer.d.ts

@@ -1,2 +1,2 @@
-declare const createGcObserver: any;
-export { createGcObserver };
+declare const createGcObserver: any;
+export { createGcObserver };

package/dist/{modules → declarations/src}/create-gc-observer/index.d.ts

@@ -1,2 +1,2 @@
-import { createGcObserver } from './create-gc-observer';
-export { createGcObserver };
+import { createGcObserver } from './create-gc-observer';
+export { createGcObserver };

package/dist/{modules → declarations/src}/create-metric-types/create-metric-types.d.ts

@@ -1,25 +1,25 @@
-import type { DeepRequired } from 'ts-essentials';
-import type { TPromsterOptions } from '@promster/types';
-declare type TOptions = DeepRequired<TPromsterOptions>;
-declare const createMetricTypes: {
-    (options: TOptions): any;
-    defaultOptions: {
-        getLabelValues: () => {};
-        labels: never[];
-        accuracies: string[];
-        metricPrefix: string;
-        metricTypes: string[];
-        metricNames: {
-            up: string[];
-            countOfGcs: string[];
-            durationOfGc: string[];
-            reclaimedInGc: string[];
-            httpRequestsTotal: string[];
-            httpRequestDurationPerPercentileInMilliseconds: string[];
-            httpRequestDurationPerPercentileInSeconds: string[];
-            httpRequestDurationInSeconds: string[];
-            httpRequestDurationInMilliseconds: string[];
-        };
-    };
-};
-export { createMetricTypes };
+import type { DeepRequired } from 'ts-essentials';
+import type { TPromsterOptions } from '@promster/types';
+declare type TOptions = DeepRequired<TPromsterOptions>;
+declare const createMetricTypes: {
+    (options: TOptions): any;
+    defaultOptions: {
+        getLabelValues: () => {};
+        labels: never[];
+        accuracies: string[];
+        metricPrefix: string;
+        metricTypes: string[];
+        metricNames: {
+            up: string[];
+            countOfGcs: string[];
+            durationOfGc: string[];
+            reclaimedInGc: string[];
+            httpRequestsTotal: string[];
+            httpRequestDurationPerPercentileInMilliseconds: string[];
+            httpRequestDurationPerPercentileInSeconds: string[];
+            httpRequestDurationInSeconds: string[];
+            httpRequestDurationInMilliseconds: string[];
+        };
+    };
+};
+export { createMetricTypes };

package/dist/{modules → declarations/src}/create-metric-types/index.d.ts

@@ -1,2 +1,2 @@
-import { createMetricTypes } from './create-metric-types';
-export { createMetricTypes };
+import { createMetricTypes } from './create-metric-types';
+export { createMetricTypes };

package/dist/{modules → declarations/src}/create-request-recorder/create-request-recorder.d.ts

@@ -1,23 +1,23 @@
-import type { TLabelValues, TMetricTypes } from '@promster/types';
-declare type TRecorderAccuracy = 'ms' | 's';
-declare type TRecorderMetricType = 'httpRequestsTotal' | 'httpRequestsHistogram' | 'httpRequestsSummary';
-declare type TRequestRecorderOptions = {
-    accuracies: TRecorderAccuracy[];
-    metricTypes: TRecorderMetricType[];
-    skip: () => boolean;
-};
-declare type TRecordingOptions = {
-    labels: TLabelValues;
-};
-declare type TRequestTiming = [number, number];
-export declare type TRequestRecorder = (start: TRequestTiming, recordingOptions: TRecordingOptions) => void;
-declare const sortLabels: (unsortedLabels: TLabelValues) => TLabelValues;
-declare const endMeasurmentFrom: (start: TRequestTiming) => {
-    durationMs: number;
-    durationS: number;
-};
-declare const createRequestRecorder: {
-    (metricTypes: TMetricTypes, options?: Partial<TRequestRecorderOptions>): TRequestRecorder;
-    defaultOptions: TRequestRecorderOptions;
-};
-export { createRequestRecorder, sortLabels, endMeasurmentFrom };
+import type { TLabelValues, TMetricTypes } from '@promster/types';
+declare type TRecorderAccuracy = 'ms' | 's';
+declare type TRecorderMetricType = 'httpRequestsTotal' | 'httpRequestsHistogram' | 'httpRequestsSummary';
+declare type TRequestRecorderOptions = {
+    accuracies: TRecorderAccuracy[];
+    metricTypes: TRecorderMetricType[];
+    skip: () => boolean;
+};
+declare type TRecordingOptions = {
+    labels: TLabelValues;
+};
+declare type TRequestTiming = [number, number];
+export declare type TRequestRecorder = (start: TRequestTiming, recordingOptions: TRecordingOptions) => void;
+declare const sortLabels: (unsortedLabels: TLabelValues) => TLabelValues;
+declare const endMeasurmentFrom: (start: TRequestTiming) => {
+    durationMs: number;
+    durationS: number;
+};
+declare const createRequestRecorder: {
+    (metricTypes: TMetricTypes, options?: Partial<TRequestRecorderOptions>): TRequestRecorder;
+    defaultOptions: TRequestRecorderOptions;
+};
+export { createRequestRecorder, sortLabels, endMeasurmentFrom };

package/dist/{modules → declarations/src}/create-request-recorder/index.d.ts

@@ -1,3 +1,3 @@
-import { createRequestRecorder } from './create-request-recorder';
-export type { TRequestRecorder } from './create-request-recorder';
-export { createRequestRecorder };
+import { createRequestRecorder } from './create-request-recorder';
+export type { TRequestRecorder } from './create-request-recorder';
+export { createRequestRecorder };

package/dist/{modules → declarations/src}/index.d.ts

@@ -1,10 +1,9 @@
-import { version } from '../package.json';
-import { Prometheus, defaultRegister } from './client';
-import { createMetricTypes } from './create-metric-types';
-import { getSummary, getContentType } from './summary';
-import { createRequestRecorder } from './create-request-recorder';
-import { createGcObserver } from './create-gc-observer';
-import { defaultNormalizers, normalizeStatusCode, normalizePath, normalizeMethod } from './normalizers';
-import { isRunningInKubernetes } from './kubernetes';
-export type { TRequestRecorder } from './create-request-recorder';
-export { version, Prometheus, defaultRegister, createMetricTypes, getSummary, getContentType, createRequestRecorder, createGcObserver, defaultNormalizers, normalizeStatusCode, normalizePath, normalizeMethod, isRunningInKubernetes, };
+import { Prometheus, defaultRegister } from './client';
+import { createMetricTypes } from './create-metric-types';
+import { getSummary, getContentType } from './summary';
+import { createRequestRecorder } from './create-request-recorder';
+import { createGcObserver } from './create-gc-observer';
+import { defaultNormalizers, normalizeStatusCode, normalizePath, normalizeMethod } from './normalizers';
+import { isRunningInKubernetes } from './kubernetes';
+export type { TRequestRecorder } from './create-request-recorder';
+export { Prometheus, defaultRegister, createMetricTypes, getSummary, getContentType, createRequestRecorder, createGcObserver, defaultNormalizers, normalizeStatusCode, normalizePath, normalizeMethod, isRunningInKubernetes, };

package/dist/{modules → declarations/src}/kubernetes/index.d.ts

@@ -1,2 +1,2 @@
-import { isRunningInKubernetes } from './kubernetes';
-export { isRunningInKubernetes };
+import { isRunningInKubernetes } from './kubernetes';
+export { isRunningInKubernetes };

package/dist/{modules → declarations/src}/kubernetes/kubernetes.d.ts

@@ -1,2 +1,2 @@
-declare const isRunningInKubernetes: () => boolean;
-export { isRunningInKubernetes };
+declare const isRunningInKubernetes: () => boolean;
+export { isRunningInKubernetes };

package/dist/{modules → declarations/src}/normalizers/index.d.ts

@@ -1,9 +1,9 @@
-import { normalizeStatusCode } from './status-code';
-import { normalizePath } from './path';
-import { normalizeMethod } from './method';
-declare const defaultNormalizers: {
-    normalizeStatusCode: (statusCode: number) => number;
-    normalizePath: (path: string) => string;
-    normalizeMethod: (method: string) => string;
-};
-export { normalizeStatusCode, normalizePath, normalizeMethod, defaultNormalizers, };
+import { normalizeStatusCode } from './status-code';
+import { normalizePath } from './path';
+import { normalizeMethod } from './method';
+declare const defaultNormalizers: {
+    normalizeStatusCode: (statusCode: number) => number;
+    normalizePath: (path: string) => string;
+    normalizeMethod: (method: string) => string;
+};
+export { normalizeStatusCode, normalizePath, normalizeMethod, defaultNormalizers, };

package/dist/{modules → declarations/src}/normalizers/method/index.d.ts

@@ -1,2 +1,2 @@
-import { normalizeMethod } from './method';
-export { normalizeMethod };
+import { normalizeMethod } from './method';
+export { normalizeMethod };

package/dist/{modules → declarations/src}/normalizers/method/method.d.ts

@@ -1,2 +1,2 @@
-declare const normalizeMethod: (method: string) => string;
-export { normalizeMethod };
+declare const normalizeMethod: (method: string) => string;
+export { normalizeMethod };

package/dist/{modules → declarations/src}/normalizers/path/index.d.ts

@@ -1,2 +1,2 @@
-import { normalizePath } from './path';
-export { normalizePath };
+import { normalizePath } from './path';
+export { normalizePath };

package/dist/{modules → declarations/src}/normalizers/path/path.d.ts

@@ -1,2 +1,2 @@
-declare const normalizePath: (path: string) => string;
-export { normalizePath };
+declare const normalizePath: (path: string) => string;
+export { normalizePath };

package/dist/{modules → declarations/src}/normalizers/status-code/index.d.ts

@@ -1,2 +1,2 @@
-import { normalizeStatusCode } from './status-code';
-export { normalizeStatusCode };
+import { normalizeStatusCode } from './status-code';
+export { normalizeStatusCode };

package/dist/{modules → declarations/src}/normalizers/status-code/status-code.d.ts

@@ -1,2 +1,2 @@
-declare const normalizeStatusCode: (statusCode: number) => number;
-export { normalizeStatusCode };
+declare const normalizeStatusCode: (statusCode: number) => number;
+export { normalizeStatusCode };

package/dist/{modules → declarations/src}/summary/index.d.ts

@@ -1,2 +1,2 @@
-import { getSummary, getContentType } from './summary';
-export { getSummary, getContentType };
+import { getSummary, getContentType } from './summary';
+export { getSummary, getContentType };

package/dist/{modules → declarations/src}/summary/summary.d.ts

@@ -1,3 +1,3 @@
-declare const getSummary: () => string;
-declare const getContentType: () => string;
-export { getSummary, getContentType };
+declare const getSummary: () => Promise<string>;
+declare const getContentType: () => string;
+export { getSummary, getContentType };

package/dist/promster-metrics.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./declarations/src/index";

package/dist/promster-metrics.cjs.dev.js

@@ -0,0 +1,315 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var once = require('lodash.once');
+var Prometheus = require('prom-client');
+var merge = require('merge-options');
+var requireOptional = require('optional');
+var url = require('url');
+var UrlValueParser = require('url-value-parser');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () {
+            return e[k];
+          }
+        });
+      }
+    });
+  }
+  n['default'] = e;
+  return Object.freeze(n);
+}
+
+var once__default = /*#__PURE__*/_interopDefault(once);
+var Prometheus__namespace = /*#__PURE__*/_interopNamespace(Prometheus);
+var merge__default = /*#__PURE__*/_interopDefault(merge);
+var requireOptional__default = /*#__PURE__*/_interopDefault(requireOptional);
+var url__default = /*#__PURE__*/_interopDefault(url);
+var UrlValueParser__default = /*#__PURE__*/_interopDefault(UrlValueParser);
+
+const isRunningInKubernetes = () => Boolean(process.env.KUBERNETES_SERVICE_HOST);
+
+//   This is the `globalRegistry` provided by the `prom-client`
+//   We could create multiple registries with `new Prometheus.registry()`.
+
+const defaultRegister = Prometheus__namespace.register;
+const configure = once__default['default'](options => {
+  const shouldSkipMetricsByEnvironment = options.detectKubernetes === true && !isRunningInKubernetes();
+
+  if (!shouldSkipMetricsByEnvironment) {
+    Prometheus__namespace.collectDefaultMetrics(options);
+  }
+});
+
+const defaultHttpRequestDurationPercentilesInMillieconds = [0.5, 0.9, 0.95, 0.98, 0.99];
+const defaultHttpRequestDurationInMilliseconds = [50, 100, 300, 500, 800, 1000, 1500, 2000, 3000, 5000, 10000];
+const defaultHttpRequestDurationPercentileInSeconds = [0.5, 0.9, 0.95, 0.98, 0.99];
+const defaultHttpRequestDurationInSeconds = [0.05, 0.1, 0.3, 0.5, 0.8, 1, 1.5, 2, 3, 10];
+const defaultRequestLabels = ['path', 'status_code', 'method'];
+const defaultGcLabels = ['gc_type'];
+
+const asArray = maybeArray => Array.isArray(maybeArray) ? maybeArray : [maybeArray];
+
+const shouldObserveMetricsInSeconds = options => options.accuracies.includes('s');
+
+const shouldObserveMetricsInMilliseconds = options => options.accuracies.includes('ms');
+
+const shouldObserveHttpRequestsAsSummary = options => options.metricTypes.includes('httpRequestsSummary');
+
+const shouldObserveHttpRequestsAsHistogram = options => options.metricTypes.includes('httpRequestsHistogram');
+
+const shouldObserveHttpRequestsAsCounter = options => options.metricTypes.includes('httpRequestsTotal');
+
+const defaultOptions$1 = {
+  getLabelValues: () => ({}),
+  labels: [],
+  accuracies: ['s'],
+  metricPrefix: '',
+  metricTypes: ['httpRequestsTotal', 'httpRequestsHistogram'],
+  metricNames: {
+    up: ['up'],
+    countOfGcs: ['nodejs_gc_runs_total'],
+    durationOfGc: ['nodejs_gc_pause_seconds_total'],
+    reclaimedInGc: ['nodejs_gc_reclaimed_bytes_total'],
+    httpRequestsTotal: ['http_requests_total'],
+    httpRequestDurationPerPercentileInMilliseconds: ['http_request_duration_per_percentile_milliseconds'],
+    httpRequestDurationPerPercentileInSeconds: ['http_request_duration_per_percentile_seconds'],
+    httpRequestDurationInSeconds: ['http_request_duration_seconds'],
+    httpRequestDurationInMilliseconds: ['http_request_duration_milliseconds']
+  }
+};
+
+const getDefaultMetrics = options => ({
+  up: asArray(options.metricNames.up).map(nameOfUpMetric => new Prometheus__namespace.Gauge({
+    name: `${options.metricPrefix}${nameOfUpMetric}`,
+    help: '1 = up, 0 = not up'
+  })),
+  countOfGcs: asArray(options.metricNames.countOfGcs).map(nameOfCounfOfGcsMetric => new Prometheus__namespace.Counter({
+    name: `${options.metricPrefix}${nameOfCounfOfGcsMetric}`,
+    help: 'Count of total garbage collections.',
+    labelNames: defaultGcLabels
+  })),
+  durationOfGc: asArray(options.metricNames.durationOfGc).map(nameOfDurationOfGcMetric => new Prometheus__namespace.Counter({
+    name: `${options.metricPrefix}${nameOfDurationOfGcMetric}`,
+    help: 'Time spent in GC Pause in seconds.',
+    labelNames: defaultGcLabels
+  })),
+  reclaimedInGc: asArray(options.metricNames.reclaimedInGc).map(nameOfReclaimedInGcMetric => new Prometheus__namespace.Counter({
+    name: `${options.metricPrefix}${nameOfReclaimedInGcMetric}`,
+    help: 'Total number of bytes reclaimed by GC.',
+    labelNames: defaultGcLabels
+  }))
+});
+
+const getHttpRequestLatencyMetricsInMilliseconds = options => ({
+  httpRequestDurationPerPercentileInMilliseconds: shouldObserveHttpRequestsAsSummary(options) && asArray(options.metricNames.httpRequestDurationPerPercentileInMilliseconds).map(nameOfHttpRequestDurationPerPercentileInMillisecondsMetric => new Prometheus__namespace.Summary({
+    name: `${options.metricPrefix}${nameOfHttpRequestDurationPerPercentileInMillisecondsMetric}`,
+    help: 'The HTTP request latencies in milliseconds.',
+    labelNames: defaultRequestLabels.concat(options.labels).sort(),
+    percentiles: options.percentiles || defaultHttpRequestDurationPercentilesInMillieconds
+  })),
+  httpRequestDurationInMilliseconds: shouldObserveHttpRequestsAsHistogram(options) && asArray(options.metricNames.httpRequestDurationInMilliseconds).map(nameOfHttpRequestDurationInMillisecondsMetric => new Prometheus__namespace.Histogram({
+    name: `${options.metricPrefix}${nameOfHttpRequestDurationInMillisecondsMetric}`,
+    help: 'The HTTP request latencies in milliseconds.',
+    labelNames: defaultRequestLabels.concat(options.labels).sort(),
+    buckets: options.buckets || defaultHttpRequestDurationInMilliseconds
+  }))
+});
+
+const getHttpRequestLatencyMetricsInSeconds = options => ({
+  httpRequestDurationPerPercentileInSeconds: shouldObserveHttpRequestsAsSummary(options) && asArray(options.metricNames.httpRequestDurationPerPercentileInSeconds).map(nameOfHttpRequestDurationPerPercentileInSeconds => new Prometheus__namespace.Summary({
+    name: `${options.metricPrefix}${nameOfHttpRequestDurationPerPercentileInSeconds}`,
+    help: 'The HTTP request latencies in seconds.',
+    labelNames: defaultRequestLabels.concat(options.labels).sort(),
+    percentiles: options.percentiles || defaultHttpRequestDurationPercentileInSeconds
+  })),
+  httpRequestDurationInSeconds: shouldObserveHttpRequestsAsHistogram(options) && asArray(options.metricNames.httpRequestDurationInSeconds).map(nameOfHttpRequestDurationInSecondsMetric => new Prometheus__namespace.Histogram({
+    name: `${options.metricPrefix}${nameOfHttpRequestDurationInSecondsMetric}`,
+    help: 'The HTTP request latencies in seconds.',
+    labelNames: defaultRequestLabels.concat(options.labels).sort(),
+    buckets: options.buckets || defaultHttpRequestDurationInSeconds
+  }))
+});
+
+const getHttpRequestCounterMetric = options => ({
+  httpRequestsTotal: shouldObserveHttpRequestsAsCounter(options) && asArray(options.metricNames.httpRequestsTotal).map(nameOfHttpRequestsTotalMetric => new Prometheus__namespace.Counter({
+    name: `${options.metricPrefix}${nameOfHttpRequestsTotalMetric}`,
+    help: 'The total HTTP requests.',
+    labelNames: defaultRequestLabels.concat(options.labels).sort()
+  }))
+});
+
+const createMetricTypes = options => {
+  const defaultedOptions = merge__default['default'](defaultOptions$1, options);
+  configure({
+    prefix: defaultedOptions.metricPrefix
+  });
+  const defaultMetrics = getDefaultMetrics(defaultedOptions);
+  const httpRequestLatencyMetricsInMilliseconds = shouldObserveMetricsInMilliseconds(defaultedOptions) && getHttpRequestLatencyMetricsInMilliseconds(defaultedOptions);
+  const httpRequestLatencyMetricsInSeconds = shouldObserveMetricsInSeconds(defaultedOptions) && getHttpRequestLatencyMetricsInSeconds(defaultedOptions);
+  const httpRequestCounterMetric = getHttpRequestCounterMetric(defaultedOptions);
+  return Object.assign({}, defaultMetrics, httpRequestLatencyMetricsInMilliseconds, httpRequestLatencyMetricsInSeconds, httpRequestCounterMetric);
+};
+
+createMetricTypes.defaultOptions = defaultOptions$1;
+
+const getSummary = async () => defaultRegister.metrics();
+
+const getContentType = () => defaultRegister.contentType;
+
+const NS_PER_SEC = 1e9;
+const NS_PER_MS = 1e6;
+
+const sortLabels = unsortedLabels => {
+  return Object.keys(unsortedLabels).sort((a, b) => {
+    if (a < b) {
+      return -1;
+    }
+
+    if (a > b) {
+      return 1;
+    }
+
+    return 0;
+  }).reduce((sortedLabels, labelName) => {
+    sortedLabels[labelName] = unsortedLabels[labelName];
+    return sortedLabels;
+  }, {});
+};
+
+const endMeasurmentFrom = start => {
+  const [seconds, nanoseconds] = process.hrtime(start);
+  return {
+    durationMs: Math.round((seconds * NS_PER_SEC + nanoseconds) / NS_PER_MS),
+    durationS: (seconds * NS_PER_SEC + nanoseconds) / NS_PER_SEC
+  };
+};
+
+const shouldObserveMetricType = metricType => options => options.metricTypes.includes(metricType);
+
+const shouldObserveMetricAccuracy = accuracy => options => options.accuracies.includes(accuracy);
+
+const defaultOptions = {
+  accuracies: ['s'],
+  metricTypes: ['httpRequestsTotal', 'httpRequestsHistogram'],
+  skip: () => false
+};
+
+const createRequestRecorder = (metricTypes, options = defaultOptions) => {
+  const defaultedRecorderOptions = merge__default['default'](defaultOptions, options);
+  const shouldSkipMetricsByEnvironment = defaultedRecorderOptions.detectKubernetes && !isRunningInKubernetes();
+  const shouldObserveInSeconds = shouldObserveMetricAccuracy('s')(defaultedRecorderOptions);
+  const shouldObserveInMilliseconds = shouldObserveMetricAccuracy('ms')(defaultedRecorderOptions);
+  const shouldObserveInSummary = shouldObserveMetricType('httpRequestsSummary')(defaultedRecorderOptions);
+  const shouldObserveInHistogram = shouldObserveMetricType('httpRequestsHistogram')(defaultedRecorderOptions);
+  const shouldObserveInCounter = shouldObserveMetricType('httpRequestsTotal')(defaultedRecorderOptions);
+  return (start, recordingOptions) => {
+    const {
+      durationMs,
+      durationS
+    } = endMeasurmentFrom(start);
+    const labels = sortLabels(recordingOptions.labels);
+
+    if (shouldObserveInMilliseconds && shouldObserveInHistogram && !shouldSkipMetricsByEnvironment) {
+      metricTypes.httpRequestDurationInMilliseconds.forEach(httpRequestDurationInMillisecondsMetricType => {
+        httpRequestDurationInMillisecondsMetricType.observe(labels, durationMs);
+      });
+    }
+
+    if (shouldObserveInMilliseconds && shouldObserveInSummary && !shouldSkipMetricsByEnvironment) {
+      metricTypes.httpRequestDurationPerPercentileInMilliseconds.forEach(httpRequestDurationPerPercentileInMillisecondsMetricType => {
+        httpRequestDurationPerPercentileInMillisecondsMetricType.observe(labels, durationMs);
+      });
+    }
+
+    if (shouldObserveInSeconds && shouldObserveInHistogram && !shouldSkipMetricsByEnvironment) {
+      metricTypes.httpRequestDurationInSeconds.forEach(httpRequestDurationInSecondsMetricType => {
+        httpRequestDurationInSecondsMetricType.observe(labels, durationS);
+      });
+    }
+
+    if (shouldObserveInSeconds && shouldObserveInSummary && !shouldSkipMetricsByEnvironment) {
+      metricTypes.httpRequestDurationPerPercentileInSeconds.forEach(httpRequestDurationPerPercentileInSecondsMetricType => {
+        httpRequestDurationPerPercentileInSecondsMetricType.observe(labels, durationS);
+      });
+    }
+
+    if (shouldObserveInCounter && !shouldSkipMetricsByEnvironment) {
+      metricTypes.httpRequestsTotal.forEach(httpRequestsTotalMetricType => {
+        httpRequestsTotalMetricType.inc(labels);
+      });
+    }
+  };
+};
+
+createRequestRecorder.defaultOptions = defaultOptions;
+
+const gc = requireOptional__default['default']('gc-stats');
+const gcTypes = {
+  0: 'unknown',
+  1: 'scavenge',
+  2: 'mark_sweep_compact',
+  3: 'scavenge_and_mark_sweep_compact',
+  4: 'incremental_marking',
+  8: 'weak_phantom',
+  15: 'all'
+};
+const createGcObserver = once__default['default'](metricTypes => () => {
+  if (typeof gc !== 'function') {
+    return;
+  }
+
+  gc().on('stats', stats => {
+    const gcType = gcTypes[stats.gctype];
+    metricTypes.countOfGcs.forEach(countOfGcMetricType => {
+      countOfGcMetricType.labels(gcType).inc();
+    });
+    metricTypes.durationOfGc.forEach(durationOfGcMetricType => {
+      durationOfGcMetricType.labels(gcType).inc(stats.pause / 1e9);
+    });
+
+    if (stats.diff.usedHeapSize < 0) {
+      metricTypes.reclaimedInGc.forEach(reclaimedInGcMetricType => {
+        reclaimedInGcMetricType.labels(gcType).inc(stats.diff.usedHeapSize * -1);
+      });
+    }
+  });
+});
+
+const normalizeStatusCode = statusCode => statusCode;
+
+const urlValueParser = new UrlValueParser__default['default']();
+
+const normalizePath = path => urlValueParser.replacePathValues(url__default['default'].parse(path).pathname);
+
+const normalizeMethod = method => method.toLowerCase();
+
+const defaultNormalizers = {
+  normalizeStatusCode,
+  normalizePath,
+  normalizeMethod
+};
+
+exports.Prometheus = Prometheus__namespace;
+exports.createGcObserver = createGcObserver;
+exports.createMetricTypes = createMetricTypes;
+exports.createRequestRecorder = createRequestRecorder;
+exports.defaultNormalizers = defaultNormalizers;
+exports.defaultRegister = defaultRegister;
+exports.getContentType = getContentType;
+exports.getSummary = getSummary;
+exports.isRunningInKubernetes = isRunningInKubernetes;
+exports.normalizeMethod = normalizeMethod;
+exports.normalizePath = normalizePath;
+exports.normalizeStatusCode = normalizeStatusCode;

package/dist/promster-metrics.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./promster-metrics.cjs.prod.js");
+} else {
+  module.exports = require("./promster-metrics.cjs.dev.js");
+}