@promster/metrics 8.0.0 → 9.0.0

package/dist/declarations/src/create-gc-metrics/create-gc-metrics.d.ts

@@ -0,0 +1,16 @@
+import type { TDefaultedPromsterOptions, TGcMetrics } from '@promster/types';
+declare const createGcMetrics: {
+    (options: TDefaultedPromsterOptions): TGcMetrics;
+    defaultOptions: {
+        getLabelValues: () => {};
+        labels: never[];
+        metricPrefix: string;
+        metricNames: {
+            up: string[];
+            countOfGcs: string[];
+            durationOfGc: string[];
+            reclaimedInGc: string[];
+        };
+    };
+};
+export { createGcMetrics };

package/dist/declarations/src/create-gc-metrics/index.d.ts

@@ -0,0 +1,2 @@
+import { createGcMetrics } from './create-gc-metrics';
+export { createGcMetrics };

package/dist/declarations/src/create-graphql-metrics/create-graphql-metrics.d.ts

@@ -0,0 +1,18 @@
+import type { TDefaultedPromsterOptions, TGraphQlMetrics } from '@promster/types';
+declare const createGraphQlMetrics: {
+    (options: TDefaultedPromsterOptions): TGraphQlMetrics;
+    defaultOptions: {
+        getLabelValues: () => {};
+        labels: never[];
+        metricPrefix: string;
+        metricTypes: string[];
+        metricNames: {
+            graphQlParseDuration: string[];
+            graphQlValidationDuration: string[];
+            graphQlResolveFieldDuration: string[];
+            graphQlRequestDuration: string[];
+            graphQlErrorsTotal: string[];
+        };
+    };
+};
+export { createGraphQlMetrics };

package/dist/declarations/src/create-graphql-metrics/index.d.ts

@@ -0,0 +1,2 @@
+import { createGraphQlMetrics } from './create-graphql-metrics';
+export { createGraphQlMetrics };

package/dist/declarations/src/create-http-metrics/create-http-metrics.d.ts

@@ -0,0 +1,18 @@
+import type { TDefaultedPromsterOptions, THttpMetrics } from '@promster/types';
+declare const createHttpMetrics: {
+    (options: TDefaultedPromsterOptions): THttpMetrics;
+    defaultOptions: {
+        getLabelValues: () => {};
+        labels: never[];
+        metricPrefix: string;
+        metricTypes: string[];
+        metricNames: {
+            httpRequestsTotal: string[];
+            httpRequestDurationPerPercentileInSeconds: string[];
+            httpRequestDurationInSeconds: string[];
+            httpRequestContentLengthInBytes: string[];
+            httpResponseContentLengthInBytes: string[];
+        };
+    };
+};
+export { createHttpMetrics };

package/dist/declarations/src/create-http-metrics/index.d.ts

@@ -0,0 +1,2 @@
+import { createHttpMetrics } from './create-http-metrics';
+export { createHttpMetrics };

package/dist/declarations/src/create-request-recorder/create-request-recorder.d.ts

@@ -1,18 +1,14 @@
-import type { TPromsterOptions, TLabelValues, TMetricTypes } from '@promster/types';
+import type { TPromsterOptions, TLabelValues, THttpMetrics, TRequestTiming } from '@promster/types';
+import { sortLabels } from '../sort-labels';
+import { endMeasurementFrom } from '../end-measurement-from';
 declare type TRecordingOptions = {
     labels: TLabelValues;
     requestContentLength?: number;
     responseContentLength?: number;
 };
-declare type TRequestTiming = [number, number];
 export declare type TRequestRecorder = (start: TRequestTiming, recordingOptions: TRecordingOptions) => void;
-declare const sortLabels: (unsortedLabels: TLabelValues) => TLabelValues;
-declare const endMeasurementFrom: (start: TRequestTiming) => {
-    durationMs: number;
-    durationS: number;
-};
 declare const createRequestRecorder: {
-    (metricTypes: TMetricTypes, options?: TPromsterOptions): TRequestRecorder;
+    (metrics: THttpMetrics, options?: TPromsterOptions): TRequestRecorder;
     defaultOptions: TPromsterOptions;
 };
 export { createRequestRecorder, sortLabels, endMeasurementFrom };

package/dist/declarations/src/end-measurement-from/end-measurement-from.d.ts

@@ -0,0 +1,5 @@
+import type { TRequestTiming } from '@promster/types';
+declare function endMeasurementFrom(start: TRequestTiming): {
+    durationS: number;
+};
+export { endMeasurementFrom };

package/dist/declarations/src/end-measurement-from/index.d.ts

@@ -0,0 +1,2 @@
+import { endMeasurementFrom } from './end-measurement-from';
+export { endMeasurementFrom };

package/dist/declarations/src/environment/index.d.ts

@@ -0,0 +1,3 @@
+import { isRunningInKubernetes } from './kubernetes';
+import { skipMetricsInEnvironment } from './skip-metrics-in-environment';
+export { isRunningInKubernetes, skipMetricsInEnvironment };

package/dist/declarations/src/environment/skip-metrics-in-environment.d.ts

@@ -0,0 +1,6 @@
+import type { TPromsterOptions } from '@promster/types';
+declare type TSkipMetricsInEnvironmentOptions = {
+    detectKubernetes?: TPromsterOptions['detectKubernetes'];
+};
+declare const skipMetricsInEnvironment: (options: TSkipMetricsInEnvironmentOptions) => boolean;
+export { skipMetricsInEnvironment };

package/dist/declarations/src/index.d.ts

@@ -1,9 +1,13 @@
 import { Prometheus, defaultRegister } from './client';
-import { createMetricTypes } from './create-metric-types';
+import { createHttpMetrics } from './create-http-metrics';
+import { createGraphQlMetrics } from './create-graphql-metrics';
+import { createGcMetrics } from './create-gc-metrics';
 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';
+import { isRunningInKubernetes, skipMetricsInEnvironment } from './environment';
+import { endMeasurementFrom } from './end-measurement-from';
+import { sortLabels } from './sort-labels';
 export type { TRequestRecorder } from './create-request-recorder';
-export { Prometheus, defaultRegister, createMetricTypes, getSummary, getContentType, createRequestRecorder, createGcObserver, defaultNormalizers, normalizeStatusCode, normalizePath, normalizeMethod, isRunningInKubernetes, };
+export { Prometheus, defaultRegister, createHttpMetrics, createGraphQlMetrics, createGcMetrics, getSummary, getContentType, createRequestRecorder, createGcObserver, defaultNormalizers, normalizeStatusCode, normalizePath, normalizeMethod, isRunningInKubernetes, skipMetricsInEnvironment, endMeasurementFrom, sortLabels, };

package/dist/declarations/src/sort-labels/index.d.ts

@@ -0,0 +1,2 @@
+import { sortLabels } from './sort-labels';
+export { sortLabels };

package/dist/declarations/src/sort-labels/sort-labels.d.ts

@@ -0,0 +1,3 @@
+import type { TLabelValues } from '@promster/types';
+declare function sortLabels(unsortedLabels: TLabelValues): TLabelValues;
+export { sortLabels };

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

@@ -38,31 +38,26 @@ var UrlValueParser__default = /*#__PURE__*/_interopDefault(UrlValueParser);
 
 const isRunningInKubernetes = () => Boolean(process.env.KUBERNETES_SERVICE_HOST);
 
+const skipMetricsInEnvironment = options => options.detectKubernetes === true && !isRunningInKubernetes();
+
 //   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();
+  const shouldSkipMetricsInEnvironment = skipMetricsInEnvironment(options);
 
-  if (!shouldSkipMetricsByEnvironment) {
+  if (!shouldSkipMetricsInEnvironment) {
     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 defaultHttpContentLengthInBytes = [100000, 200000, 500000, 1000000, 1500000, 2000000, 3000000, 5000000, 10000000];
-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 defaultLabels$2 = ['path', 'status_code', 'method'];
 
-const shouldObserveMetricsInMilliseconds = options => options.accuracies.includes('ms');
+const asArray$2 = maybeArray => Array.isArray(maybeArray) ? maybeArray : [maybeArray];
 
 const shouldObserveHttpRequestsAsSummary = options => options.metricTypes.includes('httpRequestsSummary');
 
@@ -72,218 +67,273 @@ const shouldObserveHttpRequestsAsCounter = options => options.metricTypes.includ
 
 const shouldObserveHttpContentLengthAsHistogram = options => options.metricTypes.includes('httpContentLengthHistogram');
 
-const defaultOptions$1 = {
+const defaultOptions$4 = {
   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'],
     httpRequestContentLengthInBytes: ['http_request_content_length_bytes'],
     httpResponseContentLengthInBytes: ['http_response_content_length_bytes']
   }
 };
 
-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(nameOfCountOfGcsMetric => new Prometheus__namespace.Counter({
-    name: `${options.metricPrefix}${nameOfCountOfGcsMetric}`,
-    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
-  })),
-  httpRequestContentLengthInBytes: shouldObserveHttpContentLengthAsHistogram(options) && asArray(options.metricNames.httpRequestContentLengthInBytes).map(nameOfHttpContentLengthMetric => new Prometheus__namespace.Histogram({
+const getMetrics$2 = options => ({
+  httpRequestContentLengthInBytes: shouldObserveHttpContentLengthAsHistogram(options) ? asArray$2(options.metricNames.httpRequestContentLengthInBytes).map(nameOfHttpContentLengthMetric => new Prometheus__namespace.Histogram({
     name: `${options.metricPrefix}${nameOfHttpContentLengthMetric}`,
     help: 'The HTTP request content length in bytes.',
-    labelNames: defaultRequestLabels.concat(options.labels).sort(),
+    labelNames: defaultLabels$2.concat(options.labels).sort(),
     buckets: options.buckets || defaultHttpContentLengthInBytes
-  })),
-  httpResponseContentLengthInBytes: shouldObserveHttpContentLengthAsHistogram(options) && asArray(options.metricNames.httpResponseContentLengthInBytes).map(nameOfHttpContentLengthMetric => new Prometheus__namespace.Histogram({
+  })) : undefined,
+  httpResponseContentLengthInBytes: shouldObserveHttpContentLengthAsHistogram(options) ? asArray$2(options.metricNames.httpResponseContentLengthInBytes).map(nameOfHttpContentLengthMetric => new Prometheus__namespace.Histogram({
     name: `${options.metricPrefix}${nameOfHttpContentLengthMetric}`,
     help: 'The HTTP response content length in bytes.',
-    labelNames: defaultRequestLabels.concat(options.labels).sort(),
+    labelNames: defaultLabels$2.concat(options.labels).sort(),
     buckets: options.buckets || defaultHttpContentLengthInBytes
-  }))
-});
-
-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
-  }))
+  })) : undefined
 });
 
 const getHttpRequestLatencyMetricsInSeconds = options => ({
-  httpRequestDurationPerPercentileInSeconds: shouldObserveHttpRequestsAsSummary(options) && asArray(options.metricNames.httpRequestDurationPerPercentileInSeconds).map(nameOfHttpRequestDurationPerPercentileInSeconds => new Prometheus__namespace.Summary({
+  httpRequestDurationPerPercentileInSeconds: shouldObserveHttpRequestsAsSummary(options) ? asArray$2(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(),
+    labelNames: defaultLabels$2.concat(options.labels).sort(),
     percentiles: options.percentiles || defaultHttpRequestDurationPercentileInSeconds
-  })),
-  httpRequestDurationInSeconds: shouldObserveHttpRequestsAsHistogram(options) && asArray(options.metricNames.httpRequestDurationInSeconds).map(nameOfHttpRequestDurationInSecondsMetric => new Prometheus__namespace.Histogram({
+  })) : undefined,
+  httpRequestDurationInSeconds: shouldObserveHttpRequestsAsHistogram(options) ? asArray$2(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(),
+    labelNames: defaultLabels$2.concat(options.labels).sort(),
     buckets: options.buckets || defaultHttpRequestDurationInSeconds
-  }))
+  })) : undefined
 });
 
 const getHttpRequestCounterMetric = options => ({
-  httpRequestsTotal: shouldObserveHttpRequestsAsCounter(options) && asArray(options.metricNames.httpRequestsTotal).map(nameOfHttpRequestsTotalMetric => new Prometheus__namespace.Counter({
+  httpRequestsTotal: shouldObserveHttpRequestsAsCounter(options) ? asArray$2(options.metricNames.httpRequestsTotal).map(nameOfHttpRequestsTotalMetric => new Prometheus__namespace.Counter({
     name: `${options.metricPrefix}${nameOfHttpRequestsTotalMetric}`,
     help: 'The total HTTP requests.',
-    labelNames: defaultRequestLabels.concat(options.labels).sort()
-  }))
+    labelNames: defaultLabels$2.concat(options.labels).sort()
+  })) : undefined
 });
 
-const createMetricTypes = options => {
-  const defaultedOptions = merge__default["default"](defaultOptions$1, options);
+const createHttpMetrics = options => {
+  const defaultedOptions = merge__default["default"](defaultOptions$4, options);
   configure({
     prefix: defaultedOptions.metricPrefix
   });
-  const defaultMetrics = getDefaultMetrics(defaultedOptions);
-  const httpRequestLatencyMetricsInMilliseconds = shouldObserveMetricsInMilliseconds(defaultedOptions) && getHttpRequestLatencyMetricsInMilliseconds(defaultedOptions);
-  const httpRequestLatencyMetricsInSeconds = shouldObserveMetricsInSeconds(defaultedOptions) && getHttpRequestLatencyMetricsInSeconds(defaultedOptions);
+  const metrics = getMetrics$2(defaultedOptions);
+  const httpRequestLatencyMetricsInSeconds = getHttpRequestLatencyMetricsInSeconds(defaultedOptions);
   const httpRequestCounterMetric = getHttpRequestCounterMetric(defaultedOptions);
-  return Object.assign({}, defaultMetrics, httpRequestLatencyMetricsInMilliseconds, httpRequestLatencyMetricsInSeconds, httpRequestCounterMetric);
+  return Object.assign({}, metrics, httpRequestLatencyMetricsInSeconds, httpRequestCounterMetric);
 };
 
-createMetricTypes.defaultOptions = defaultOptions$1;
+createHttpMetrics.defaultOptions = defaultOptions$4;
 
-const getSummary = async () => defaultRegister.metrics();
+const defaultGraphQlPercentiles = [0.5, 0.9, 0.95, 0.98, 0.99];
+const defaultLabels$1 = ['operation_name'];
 
-const getContentType = () => defaultRegister.contentType;
+const asArray$1 = maybeArray => Array.isArray(maybeArray) ? maybeArray : [maybeArray];
 
-const NS_PER_SEC = 1e9;
-const NS_PER_MS = 1e6;
+const shouldObserveGraphQlParseDurationAsHistogram = options => options.metricTypes.includes('graphQlParseDurationHistogram');
 
-const sortLabels = unsortedLabels => Object.keys(unsortedLabels).sort((a, b) => {
-  if (a < b) {
-    return -1;
-  }
+const shouldObserveGraphQlValidationDurationAsHistogram = options => options.metricTypes.includes('graphQlValidationDurationHistogram');
+
+const shouldObserveGraphQlResolveFieldDurationAsHistogram = options => options.metricTypes.includes('graphQlResolveFieldDurationHistogram');
 
-  if (a > b) {
-    return 1;
+const shouldObserveGraphQlRequestDurationAsHistogram = options => options.metricTypes.includes('graphQlRequestDurationHistogram');
+
+const shouldObserveGraphQlErrorsTotalAsCounter = options => options.metricTypes.includes('graphQlErrorsTotal');
+
+const defaultOptions$3 = {
+  getLabelValues: () => ({}),
+  labels: [],
+  metricPrefix: '',
+  metricTypes: ['graphQlParseDurationHistogram', 'graphQlValidationDurationHistogram', 'graphQlResolveFieldDurationHistogram', 'graphQlRequestDurationHistogram', 'graphQlErrorsTotal'],
+  metricNames: {
+    graphQlParseDuration: ['graphql_parse_duration_seconds'],
+    graphQlValidationDuration: ['graphql_validation_duration_seconds'],
+    graphQlResolveFieldDuration: ['graphql_resolve_field_duration_seconds'],
+    graphQlRequestDuration: ['graphql_request_duration_seconds'],
+    graphQlErrorsTotal: ['graphql_errors_total']
   }
+};
 
-  return 0;
-}).reduce((sortedLabels, labelName) => {
-  sortedLabels[labelName] = unsortedLabels[labelName];
-  return sortedLabels;
-}, {});
+const getMetrics$1 = options => ({
+  graphQlParseDuration: shouldObserveGraphQlParseDurationAsHistogram(options) ? asArray$1(options.metricNames.graphQlParseDuration).map(nameOfGraphQlParseDuration => new Prometheus__namespace.Histogram({
+    name: `${options.metricPrefix}${nameOfGraphQlParseDuration}`,
+    help: 'The GraphQL request parse time in seconds.',
+    labelNames: defaultLabels$1.concat(options.labels).sort(),
+    buckets: options.buckets || defaultGraphQlPercentiles
+  })) : undefined,
+  graphQlValidationDuration: shouldObserveGraphQlValidationDurationAsHistogram(options) ? asArray$1(options.metricNames.graphQlValidationDuration).map(nameOfGraphQlValidationDuration => new Prometheus__namespace.Histogram({
+    name: `${options.metricPrefix}${nameOfGraphQlValidationDuration}`,
+    help: 'The GraphQL request validation time in seconds.',
+    labelNames: defaultLabels$1.concat(options.labels).sort(),
+    buckets: options.buckets || defaultGraphQlPercentiles
+  })) : undefined,
+  graphQlResolveFieldDuration: shouldObserveGraphQlResolveFieldDurationAsHistogram(options) ? asArray$1(options.metricNames.graphQlResolveFieldDuration).map(nameOfGraphQlResolveFieldDuration => new Prometheus__namespace.Histogram({
+    name: `${options.metricPrefix}${nameOfGraphQlResolveFieldDuration}`,
+    help: 'The GraphQL field resolving time in seconds.',
+    labelNames: defaultLabels$1.concat(['field_name']).concat(options.labels).sort(),
+    buckets: options.buckets || defaultGraphQlPercentiles
+  })) : undefined,
+  graphQlRequestDuration: shouldObserveGraphQlRequestDurationAsHistogram(options) ? asArray$1(options.metricNames.graphQlRequestDuration).map(nameOfGraphQlRequestDuration => new Prometheus__namespace.Histogram({
+    name: `${options.metricPrefix}${nameOfGraphQlRequestDuration}`,
+    help: 'The GraphQL request duration time in seconds.',
+    labelNames: defaultLabels$1.concat(options.labels).sort(),
+    buckets: options.buckets || defaultGraphQlPercentiles
+  })) : undefined,
+  graphQlErrorsTotal: shouldObserveGraphQlErrorsTotalAsCounter(options) ? asArray$1(options.metricNames.graphQlErrorsTotal).map(nameOfGraphQlErrorsCount => new Prometheus__namespace.Counter({
+    name: `${options.metricPrefix}${nameOfGraphQlErrorsCount}`,
+    help: 'Count of errors while parsing, validating, or executing a GraphQL operation.',
+    labelNames: defaultLabels$1.concat(['phase']).concat(options.labels).sort()
+  })) : undefined
+});
 
-const endMeasurementFrom = 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 createGraphQlMetrics = options => {
+  const defaultedOptions = merge__default["default"](defaultOptions$3, options);
+  configure({
+    prefix: defaultedOptions.metricPrefix
+  });
+  const metrics = getMetrics$1(defaultedOptions);
+  return metrics;
 };
 
-const shouldObserveMetricType = metricType => options => {
-  var _options$metricTypes;
+createGraphQlMetrics.defaultOptions = defaultOptions$3;
+
+const defaultLabels = ['gc_type'];
+
+const asArray = maybeArray => Array.isArray(maybeArray) ? maybeArray : [maybeArray];
 
-  return (_options$metricTypes = options.metricTypes) === null || _options$metricTypes === void 0 ? void 0 : _options$metricTypes.includes(metricType);
+const defaultOptions$2 = {
+  getLabelValues: () => ({}),
+  labels: [],
+  metricPrefix: '',
+  metricNames: {
+    up: ['up'],
+    countOfGcs: ['nodejs_gc_runs_total'],
+    durationOfGc: ['nodejs_gc_pause_seconds_total'],
+    reclaimedInGc: ['nodejs_gc_reclaimed_bytes_total']
+  }
 };
 
-const shouldObserveMetricAccuracy = accuracy => options => {
-  var _options$accuracies;
+const getMetrics = 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(nameOfCountOfGcsMetric => new Prometheus__namespace.Counter({
+    name: `${options.metricPrefix}${nameOfCountOfGcsMetric}`,
+    help: 'Count of total garbage collections.',
+    labelNames: defaultLabels
+  })),
+  durationOfGc: asArray(options.metricNames.durationOfGc).map(nameOfDurationOfGcMetric => new Prometheus__namespace.Counter({
+    name: `${options.metricPrefix}${nameOfDurationOfGcMetric}`,
+    help: 'Time spent in GC Pause in seconds.',
+    labelNames: defaultLabels
+  })),
+  reclaimedInGc: asArray(options.metricNames.reclaimedInGc).map(nameOfReclaimedInGcMetric => new Prometheus__namespace.Counter({
+    name: `${options.metricPrefix}${nameOfReclaimedInGcMetric}`,
+    help: 'Total number of bytes reclaimed by GC.',
+    labelNames: defaultLabels
+  }))
+});
 
-  return (_options$accuracies = options.accuracies) === null || _options$accuracies === void 0 ? void 0 : _options$accuracies.includes(accuracy);
+const createGcMetrics = options => {
+  const defaultedOptions = merge__default["default"](defaultOptions$2, options);
+  configure({
+    prefix: defaultedOptions.metricPrefix
+  });
+  const gcMetrics = getMetrics(defaultedOptions);
+  return gcMetrics;
 };
 
-const defaultOptions = {
-  accuracies: ['s'],
-  metricTypes: ['httpRequestsTotal', 'httpRequestsHistogram'],
+createGcMetrics.defaultOptions = defaultOptions$2;
+
+const getSummary = async () => defaultRegister.metrics();
+
+const getContentType = () => defaultRegister.contentType;
+
+function 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 NS_PER_SEC = 1e9;
+
+function endMeasurementFrom(start) {
+  const [seconds, nanoseconds] = process.hrtime(start);
+  return {
+    durationS: (seconds * NS_PER_SEC + nanoseconds) / NS_PER_SEC
+  };
+}
+
+const defaultOptions$1 = {
   skip: () => false,
   detectKubernetes: 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);
-  const shouldObserveContentLengthInHistogram = shouldObserveMetricType('httpContentLengthHistogram')(defaultedRecorderOptions); // eslint-disable-next-line complexity
-
+const createRequestRecorder = (metrics, options = defaultOptions$1) => {
+  const defaultedRecorderOptions = merge__default["default"](defaultOptions$1, options);
+  const shouldSkipMetricsByEnvironment = skipMetricsInEnvironment(defaultedRecorderOptions);
   return (start, recordingOptions) => {
     const {
-      durationMs,
       durationS
     } = endMeasurementFrom(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 (!shouldSkipMetricsByEnvironment) {
+      var _metrics$httpRequestD;
 
-    if (shouldObserveInSeconds && shouldObserveInHistogram && !shouldSkipMetricsByEnvironment) {
-      metricTypes.httpRequestDurationInSeconds.forEach(httpRequestDurationInSecondsMetricType => {
+      (_metrics$httpRequestD = metrics.httpRequestDurationInSeconds) === null || _metrics$httpRequestD === void 0 ? void 0 : _metrics$httpRequestD.forEach(httpRequestDurationInSecondsMetricType => {
         httpRequestDurationInSecondsMetricType.observe(labels, durationS);
       });
     }
 
-    if (shouldObserveInSeconds && shouldObserveInSummary && !shouldSkipMetricsByEnvironment) {
-      metricTypes.httpRequestDurationPerPercentileInSeconds.forEach(httpRequestDurationPerPercentileInSecondsMetricType => {
+    if (!shouldSkipMetricsByEnvironment) {
+      var _metrics$httpRequestD2;
+
+      (_metrics$httpRequestD2 = metrics.httpRequestDurationPerPercentileInSeconds) === null || _metrics$httpRequestD2 === void 0 ? void 0 : _metrics$httpRequestD2.forEach(httpRequestDurationPerPercentileInSecondsMetricType => {
         httpRequestDurationPerPercentileInSecondsMetricType.observe(labels, durationS);
       });
     }
 
-    if (shouldObserveInCounter && !shouldSkipMetricsByEnvironment) {
-      metricTypes.httpRequestsTotal.forEach(httpRequestsTotalMetricType => {
+    if (!shouldSkipMetricsByEnvironment) {
+      var _metrics$httpRequests;
+
+      (_metrics$httpRequests = metrics.httpRequestsTotal) === null || _metrics$httpRequests === void 0 ? void 0 : _metrics$httpRequests.forEach(httpRequestsTotalMetricType => {
         httpRequestsTotalMetricType.inc(labels);
       });
     }
 
-    if (!shouldSkipMetricsByEnvironment && shouldObserveContentLengthInHistogram && recordingOptions.requestContentLength) {
-      metricTypes.httpRequestContentLengthInBytes.forEach(httpRequestContentLengthInBytesMetricType => {
+    if (recordingOptions.requestContentLength) {
+      var _metrics$httpRequestC;
+
+      (_metrics$httpRequestC = metrics.httpRequestContentLengthInBytes) === null || _metrics$httpRequestC === void 0 ? void 0 : _metrics$httpRequestC.forEach(httpRequestContentLengthInBytesMetricType => {
         httpRequestContentLengthInBytesMetricType.observe(labels, // @ts-expect-error
         recordingOptions.requestContentLength);
       });
     }
 
-    if (!shouldSkipMetricsByEnvironment && shouldObserveContentLengthInHistogram && recordingOptions.responseContentLength) {
-      metricTypes.httpResponseContentLengthInBytes.forEach(httpResponseContentLengthInBytesMetricType => {
+    if (recordingOptions.responseContentLength) {
+      var _metrics$httpResponse;
+
+      (_metrics$httpResponse = metrics.httpResponseContentLengthInBytes) === null || _metrics$httpResponse === void 0 ? void 0 : _metrics$httpResponse.forEach(httpResponseContentLengthInBytesMetricType => {
         httpResponseContentLengthInBytesMetricType.observe(labels, // @ts-expect-error
         recordingOptions.responseContentLength);
       });
@@ -291,7 +341,7 @@ const createRequestRecorder = (metricTypes, options = defaultOptions) => {
   };
 };
 
-createRequestRecorder.defaultOptions = defaultOptions;
+createRequestRecorder.defaultOptions = defaultOptions$1;
 
 const gc = requireOptional__default["default"]('@sematext/gc-stats');
 const gcTypes = {
@@ -303,27 +353,32 @@ const gcTypes = {
   8: 'weak_phantom',
   15: 'all'
 };
-const createGcObserver = once__default["default"](metricTypes => () => {
+const defaultOptions = {
+  disableGcMetrics: false
+};
+const createGcObserver = once__default["default"]((metrics, options) => () => {
   if (typeof gc !== 'function') {
     return;
   }
 
+  if (options.disableGcMetrics) return;
   gc().on('stats', stats => {
     const gcType = gcTypes[stats.gctype];
-    metricTypes.countOfGcs.forEach(countOfGcMetricType => {
+    metrics.countOfGcs.forEach(countOfGcMetricType => {
       countOfGcMetricType.labels(gcType).inc();
     });
-    metricTypes.durationOfGc.forEach(durationOfGcMetricType => {
+    metrics.durationOfGc.forEach(durationOfGcMetricType => {
       durationOfGcMetricType.labels(gcType).inc(stats.pause / 1e9);
     });
 
     if (stats.diff.usedHeapSize < 0) {
-      metricTypes.reclaimedInGc.forEach(reclaimedInGcMetricType => {
+      metrics.reclaimedInGc.forEach(reclaimedInGcMetricType => {
         reclaimedInGcMetricType.labels(gcType).inc(stats.diff.usedHeapSize * -1);
       });
     }
   });
 });
+createGcObserver.defaultOptions = defaultOptions;
 
 const normalizeStatusCode = statusCode => statusCode;
 
@@ -340,14 +395,19 @@ const defaultNormalizers = {
 };
 
 exports.Prometheus = Prometheus__namespace;
+exports.createGcMetrics = createGcMetrics;
 exports.createGcObserver = createGcObserver;
-exports.createMetricTypes = createMetricTypes;
+exports.createGraphQlMetrics = createGraphQlMetrics;
+exports.createHttpMetrics = createHttpMetrics;
 exports.createRequestRecorder = createRequestRecorder;
 exports.defaultNormalizers = defaultNormalizers;
 exports.defaultRegister = defaultRegister;
+exports.endMeasurementFrom = endMeasurementFrom;
 exports.getContentType = getContentType;
 exports.getSummary = getSummary;
 exports.isRunningInKubernetes = isRunningInKubernetes;
 exports.normalizeMethod = normalizeMethod;
 exports.normalizePath = normalizePath;
 exports.normalizeStatusCode = normalizeStatusCode;
+exports.skipMetricsInEnvironment = skipMetricsInEnvironment;
+exports.sortLabels = sortLabels;

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

@@ -38,31 +38,26 @@ var UrlValueParser__default = /*#__PURE__*/_interopDefault(UrlValueParser);
 
 const isRunningInKubernetes = () => Boolean(process.env.KUBERNETES_SERVICE_HOST);
 
+const skipMetricsInEnvironment = options => options.detectKubernetes === true && !isRunningInKubernetes();
+
 //   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();
+  const shouldSkipMetricsInEnvironment = skipMetricsInEnvironment(options);
 
-  if (!shouldSkipMetricsByEnvironment) {
+  if (!shouldSkipMetricsInEnvironment) {
     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 defaultHttpContentLengthInBytes = [100000, 200000, 500000, 1000000, 1500000, 2000000, 3000000, 5000000, 10000000];
-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 defaultLabels$2 = ['path', 'status_code', 'method'];
 
-const shouldObserveMetricsInMilliseconds = options => options.accuracies.includes('ms');
+const asArray$2 = maybeArray => Array.isArray(maybeArray) ? maybeArray : [maybeArray];
 
 const shouldObserveHttpRequestsAsSummary = options => options.metricTypes.includes('httpRequestsSummary');
 
@@ -72,218 +67,273 @@ const shouldObserveHttpRequestsAsCounter = options => options.metricTypes.includ
 
 const shouldObserveHttpContentLengthAsHistogram = options => options.metricTypes.includes('httpContentLengthHistogram');
 
-const defaultOptions$1 = {
+const defaultOptions$4 = {
   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'],
     httpRequestContentLengthInBytes: ['http_request_content_length_bytes'],
     httpResponseContentLengthInBytes: ['http_response_content_length_bytes']
   }
 };
 
-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(nameOfCountOfGcsMetric => new Prometheus__namespace.Counter({
-    name: `${options.metricPrefix}${nameOfCountOfGcsMetric}`,
-    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
-  })),
-  httpRequestContentLengthInBytes: shouldObserveHttpContentLengthAsHistogram(options) && asArray(options.metricNames.httpRequestContentLengthInBytes).map(nameOfHttpContentLengthMetric => new Prometheus__namespace.Histogram({
+const getMetrics$2 = options => ({
+  httpRequestContentLengthInBytes: shouldObserveHttpContentLengthAsHistogram(options) ? asArray$2(options.metricNames.httpRequestContentLengthInBytes).map(nameOfHttpContentLengthMetric => new Prometheus__namespace.Histogram({
     name: `${options.metricPrefix}${nameOfHttpContentLengthMetric}`,
     help: 'The HTTP request content length in bytes.',
-    labelNames: defaultRequestLabels.concat(options.labels).sort(),
+    labelNames: defaultLabels$2.concat(options.labels).sort(),
     buckets: options.buckets || defaultHttpContentLengthInBytes
-  })),
-  httpResponseContentLengthInBytes: shouldObserveHttpContentLengthAsHistogram(options) && asArray(options.metricNames.httpResponseContentLengthInBytes).map(nameOfHttpContentLengthMetric => new Prometheus__namespace.Histogram({
+  })) : undefined,
+  httpResponseContentLengthInBytes: shouldObserveHttpContentLengthAsHistogram(options) ? asArray$2(options.metricNames.httpResponseContentLengthInBytes).map(nameOfHttpContentLengthMetric => new Prometheus__namespace.Histogram({
     name: `${options.metricPrefix}${nameOfHttpContentLengthMetric}`,
     help: 'The HTTP response content length in bytes.',
-    labelNames: defaultRequestLabels.concat(options.labels).sort(),
+    labelNames: defaultLabels$2.concat(options.labels).sort(),
     buckets: options.buckets || defaultHttpContentLengthInBytes
-  }))
-});
-
-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
-  }))
+  })) : undefined
 });
 
 const getHttpRequestLatencyMetricsInSeconds = options => ({
-  httpRequestDurationPerPercentileInSeconds: shouldObserveHttpRequestsAsSummary(options) && asArray(options.metricNames.httpRequestDurationPerPercentileInSeconds).map(nameOfHttpRequestDurationPerPercentileInSeconds => new Prometheus__namespace.Summary({
+  httpRequestDurationPerPercentileInSeconds: shouldObserveHttpRequestsAsSummary(options) ? asArray$2(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(),
+    labelNames: defaultLabels$2.concat(options.labels).sort(),
     percentiles: options.percentiles || defaultHttpRequestDurationPercentileInSeconds
-  })),
-  httpRequestDurationInSeconds: shouldObserveHttpRequestsAsHistogram(options) && asArray(options.metricNames.httpRequestDurationInSeconds).map(nameOfHttpRequestDurationInSecondsMetric => new Prometheus__namespace.Histogram({
+  })) : undefined,
+  httpRequestDurationInSeconds: shouldObserveHttpRequestsAsHistogram(options) ? asArray$2(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(),
+    labelNames: defaultLabels$2.concat(options.labels).sort(),
     buckets: options.buckets || defaultHttpRequestDurationInSeconds
-  }))
+  })) : undefined
 });
 
 const getHttpRequestCounterMetric = options => ({
-  httpRequestsTotal: shouldObserveHttpRequestsAsCounter(options) && asArray(options.metricNames.httpRequestsTotal).map(nameOfHttpRequestsTotalMetric => new Prometheus__namespace.Counter({
+  httpRequestsTotal: shouldObserveHttpRequestsAsCounter(options) ? asArray$2(options.metricNames.httpRequestsTotal).map(nameOfHttpRequestsTotalMetric => new Prometheus__namespace.Counter({
     name: `${options.metricPrefix}${nameOfHttpRequestsTotalMetric}`,
     help: 'The total HTTP requests.',
-    labelNames: defaultRequestLabels.concat(options.labels).sort()
-  }))
+    labelNames: defaultLabels$2.concat(options.labels).sort()
+  })) : undefined
 });
 
-const createMetricTypes = options => {
-  const defaultedOptions = merge__default["default"](defaultOptions$1, options);
+const createHttpMetrics = options => {
+  const defaultedOptions = merge__default["default"](defaultOptions$4, options);
   configure({
     prefix: defaultedOptions.metricPrefix
   });
-  const defaultMetrics = getDefaultMetrics(defaultedOptions);
-  const httpRequestLatencyMetricsInMilliseconds = shouldObserveMetricsInMilliseconds(defaultedOptions) && getHttpRequestLatencyMetricsInMilliseconds(defaultedOptions);
-  const httpRequestLatencyMetricsInSeconds = shouldObserveMetricsInSeconds(defaultedOptions) && getHttpRequestLatencyMetricsInSeconds(defaultedOptions);
+  const metrics = getMetrics$2(defaultedOptions);
+  const httpRequestLatencyMetricsInSeconds = getHttpRequestLatencyMetricsInSeconds(defaultedOptions);
   const httpRequestCounterMetric = getHttpRequestCounterMetric(defaultedOptions);
-  return Object.assign({}, defaultMetrics, httpRequestLatencyMetricsInMilliseconds, httpRequestLatencyMetricsInSeconds, httpRequestCounterMetric);
+  return Object.assign({}, metrics, httpRequestLatencyMetricsInSeconds, httpRequestCounterMetric);
 };
 
-createMetricTypes.defaultOptions = defaultOptions$1;
+createHttpMetrics.defaultOptions = defaultOptions$4;
 
-const getSummary = async () => defaultRegister.metrics();
+const defaultGraphQlPercentiles = [0.5, 0.9, 0.95, 0.98, 0.99];
+const defaultLabels$1 = ['operation_name'];
 
-const getContentType = () => defaultRegister.contentType;
+const asArray$1 = maybeArray => Array.isArray(maybeArray) ? maybeArray : [maybeArray];
 
-const NS_PER_SEC = 1e9;
-const NS_PER_MS = 1e6;
+const shouldObserveGraphQlParseDurationAsHistogram = options => options.metricTypes.includes('graphQlParseDurationHistogram');
 
-const sortLabels = unsortedLabels => Object.keys(unsortedLabels).sort((a, b) => {
-  if (a < b) {
-    return -1;
-  }
+const shouldObserveGraphQlValidationDurationAsHistogram = options => options.metricTypes.includes('graphQlValidationDurationHistogram');
+
+const shouldObserveGraphQlResolveFieldDurationAsHistogram = options => options.metricTypes.includes('graphQlResolveFieldDurationHistogram');
 
-  if (a > b) {
-    return 1;
+const shouldObserveGraphQlRequestDurationAsHistogram = options => options.metricTypes.includes('graphQlRequestDurationHistogram');
+
+const shouldObserveGraphQlErrorsTotalAsCounter = options => options.metricTypes.includes('graphQlErrorsTotal');
+
+const defaultOptions$3 = {
+  getLabelValues: () => ({}),
+  labels: [],
+  metricPrefix: '',
+  metricTypes: ['graphQlParseDurationHistogram', 'graphQlValidationDurationHistogram', 'graphQlResolveFieldDurationHistogram', 'graphQlRequestDurationHistogram', 'graphQlErrorsTotal'],
+  metricNames: {
+    graphQlParseDuration: ['graphql_parse_duration_seconds'],
+    graphQlValidationDuration: ['graphql_validation_duration_seconds'],
+    graphQlResolveFieldDuration: ['graphql_resolve_field_duration_seconds'],
+    graphQlRequestDuration: ['graphql_request_duration_seconds'],
+    graphQlErrorsTotal: ['graphql_errors_total']
   }
+};
 
-  return 0;
-}).reduce((sortedLabels, labelName) => {
-  sortedLabels[labelName] = unsortedLabels[labelName];
-  return sortedLabels;
-}, {});
+const getMetrics$1 = options => ({
+  graphQlParseDuration: shouldObserveGraphQlParseDurationAsHistogram(options) ? asArray$1(options.metricNames.graphQlParseDuration).map(nameOfGraphQlParseDuration => new Prometheus__namespace.Histogram({
+    name: `${options.metricPrefix}${nameOfGraphQlParseDuration}`,
+    help: 'The GraphQL request parse time in seconds.',
+    labelNames: defaultLabels$1.concat(options.labels).sort(),
+    buckets: options.buckets || defaultGraphQlPercentiles
+  })) : undefined,
+  graphQlValidationDuration: shouldObserveGraphQlValidationDurationAsHistogram(options) ? asArray$1(options.metricNames.graphQlValidationDuration).map(nameOfGraphQlValidationDuration => new Prometheus__namespace.Histogram({
+    name: `${options.metricPrefix}${nameOfGraphQlValidationDuration}`,
+    help: 'The GraphQL request validation time in seconds.',
+    labelNames: defaultLabels$1.concat(options.labels).sort(),
+    buckets: options.buckets || defaultGraphQlPercentiles
+  })) : undefined,
+  graphQlResolveFieldDuration: shouldObserveGraphQlResolveFieldDurationAsHistogram(options) ? asArray$1(options.metricNames.graphQlResolveFieldDuration).map(nameOfGraphQlResolveFieldDuration => new Prometheus__namespace.Histogram({
+    name: `${options.metricPrefix}${nameOfGraphQlResolveFieldDuration}`,
+    help: 'The GraphQL field resolving time in seconds.',
+    labelNames: defaultLabels$1.concat(['field_name']).concat(options.labels).sort(),
+    buckets: options.buckets || defaultGraphQlPercentiles
+  })) : undefined,
+  graphQlRequestDuration: shouldObserveGraphQlRequestDurationAsHistogram(options) ? asArray$1(options.metricNames.graphQlRequestDuration).map(nameOfGraphQlRequestDuration => new Prometheus__namespace.Histogram({
+    name: `${options.metricPrefix}${nameOfGraphQlRequestDuration}`,
+    help: 'The GraphQL request duration time in seconds.',
+    labelNames: defaultLabels$1.concat(options.labels).sort(),
+    buckets: options.buckets || defaultGraphQlPercentiles
+  })) : undefined,
+  graphQlErrorsTotal: shouldObserveGraphQlErrorsTotalAsCounter(options) ? asArray$1(options.metricNames.graphQlErrorsTotal).map(nameOfGraphQlErrorsCount => new Prometheus__namespace.Counter({
+    name: `${options.metricPrefix}${nameOfGraphQlErrorsCount}`,
+    help: 'Count of errors while parsing, validating, or executing a GraphQL operation.',
+    labelNames: defaultLabels$1.concat(['phase']).concat(options.labels).sort()
+  })) : undefined
+});
 
-const endMeasurementFrom = 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 createGraphQlMetrics = options => {
+  const defaultedOptions = merge__default["default"](defaultOptions$3, options);
+  configure({
+    prefix: defaultedOptions.metricPrefix
+  });
+  const metrics = getMetrics$1(defaultedOptions);
+  return metrics;
 };
 
-const shouldObserveMetricType = metricType => options => {
-  var _options$metricTypes;
+createGraphQlMetrics.defaultOptions = defaultOptions$3;
+
+const defaultLabels = ['gc_type'];
+
+const asArray = maybeArray => Array.isArray(maybeArray) ? maybeArray : [maybeArray];
 
-  return (_options$metricTypes = options.metricTypes) === null || _options$metricTypes === void 0 ? void 0 : _options$metricTypes.includes(metricType);
+const defaultOptions$2 = {
+  getLabelValues: () => ({}),
+  labels: [],
+  metricPrefix: '',
+  metricNames: {
+    up: ['up'],
+    countOfGcs: ['nodejs_gc_runs_total'],
+    durationOfGc: ['nodejs_gc_pause_seconds_total'],
+    reclaimedInGc: ['nodejs_gc_reclaimed_bytes_total']
+  }
 };
 
-const shouldObserveMetricAccuracy = accuracy => options => {
-  var _options$accuracies;
+const getMetrics = 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(nameOfCountOfGcsMetric => new Prometheus__namespace.Counter({
+    name: `${options.metricPrefix}${nameOfCountOfGcsMetric}`,
+    help: 'Count of total garbage collections.',
+    labelNames: defaultLabels
+  })),
+  durationOfGc: asArray(options.metricNames.durationOfGc).map(nameOfDurationOfGcMetric => new Prometheus__namespace.Counter({
+    name: `${options.metricPrefix}${nameOfDurationOfGcMetric}`,
+    help: 'Time spent in GC Pause in seconds.',
+    labelNames: defaultLabels
+  })),
+  reclaimedInGc: asArray(options.metricNames.reclaimedInGc).map(nameOfReclaimedInGcMetric => new Prometheus__namespace.Counter({
+    name: `${options.metricPrefix}${nameOfReclaimedInGcMetric}`,
+    help: 'Total number of bytes reclaimed by GC.',
+    labelNames: defaultLabels
+  }))
+});
 
-  return (_options$accuracies = options.accuracies) === null || _options$accuracies === void 0 ? void 0 : _options$accuracies.includes(accuracy);
+const createGcMetrics = options => {
+  const defaultedOptions = merge__default["default"](defaultOptions$2, options);
+  configure({
+    prefix: defaultedOptions.metricPrefix
+  });
+  const gcMetrics = getMetrics(defaultedOptions);
+  return gcMetrics;
 };
 
-const defaultOptions = {
-  accuracies: ['s'],
-  metricTypes: ['httpRequestsTotal', 'httpRequestsHistogram'],
+createGcMetrics.defaultOptions = defaultOptions$2;
+
+const getSummary = async () => defaultRegister.metrics();
+
+const getContentType = () => defaultRegister.contentType;
+
+function 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 NS_PER_SEC = 1e9;
+
+function endMeasurementFrom(start) {
+  const [seconds, nanoseconds] = process.hrtime(start);
+  return {
+    durationS: (seconds * NS_PER_SEC + nanoseconds) / NS_PER_SEC
+  };
+}
+
+const defaultOptions$1 = {
   skip: () => false,
   detectKubernetes: 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);
-  const shouldObserveContentLengthInHistogram = shouldObserveMetricType('httpContentLengthHistogram')(defaultedRecorderOptions); // eslint-disable-next-line complexity
-
+const createRequestRecorder = (metrics, options = defaultOptions$1) => {
+  const defaultedRecorderOptions = merge__default["default"](defaultOptions$1, options);
+  const shouldSkipMetricsByEnvironment = skipMetricsInEnvironment(defaultedRecorderOptions);
   return (start, recordingOptions) => {
     const {
-      durationMs,
       durationS
     } = endMeasurementFrom(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 (!shouldSkipMetricsByEnvironment) {
+      var _metrics$httpRequestD;
 
-    if (shouldObserveInSeconds && shouldObserveInHistogram && !shouldSkipMetricsByEnvironment) {
-      metricTypes.httpRequestDurationInSeconds.forEach(httpRequestDurationInSecondsMetricType => {
+      (_metrics$httpRequestD = metrics.httpRequestDurationInSeconds) === null || _metrics$httpRequestD === void 0 ? void 0 : _metrics$httpRequestD.forEach(httpRequestDurationInSecondsMetricType => {
         httpRequestDurationInSecondsMetricType.observe(labels, durationS);
       });
     }
 
-    if (shouldObserveInSeconds && shouldObserveInSummary && !shouldSkipMetricsByEnvironment) {
-      metricTypes.httpRequestDurationPerPercentileInSeconds.forEach(httpRequestDurationPerPercentileInSecondsMetricType => {
+    if (!shouldSkipMetricsByEnvironment) {
+      var _metrics$httpRequestD2;
+
+      (_metrics$httpRequestD2 = metrics.httpRequestDurationPerPercentileInSeconds) === null || _metrics$httpRequestD2 === void 0 ? void 0 : _metrics$httpRequestD2.forEach(httpRequestDurationPerPercentileInSecondsMetricType => {
         httpRequestDurationPerPercentileInSecondsMetricType.observe(labels, durationS);
       });
     }
 
-    if (shouldObserveInCounter && !shouldSkipMetricsByEnvironment) {
-      metricTypes.httpRequestsTotal.forEach(httpRequestsTotalMetricType => {
+    if (!shouldSkipMetricsByEnvironment) {
+      var _metrics$httpRequests;
+
+      (_metrics$httpRequests = metrics.httpRequestsTotal) === null || _metrics$httpRequests === void 0 ? void 0 : _metrics$httpRequests.forEach(httpRequestsTotalMetricType => {
         httpRequestsTotalMetricType.inc(labels);
       });
     }
 
-    if (!shouldSkipMetricsByEnvironment && shouldObserveContentLengthInHistogram && recordingOptions.requestContentLength) {
-      metricTypes.httpRequestContentLengthInBytes.forEach(httpRequestContentLengthInBytesMetricType => {
+    if (recordingOptions.requestContentLength) {
+      var _metrics$httpRequestC;
+
+      (_metrics$httpRequestC = metrics.httpRequestContentLengthInBytes) === null || _metrics$httpRequestC === void 0 ? void 0 : _metrics$httpRequestC.forEach(httpRequestContentLengthInBytesMetricType => {
         httpRequestContentLengthInBytesMetricType.observe(labels, // @ts-expect-error
         recordingOptions.requestContentLength);
       });
     }
 
-    if (!shouldSkipMetricsByEnvironment && shouldObserveContentLengthInHistogram && recordingOptions.responseContentLength) {
-      metricTypes.httpResponseContentLengthInBytes.forEach(httpResponseContentLengthInBytesMetricType => {
+    if (recordingOptions.responseContentLength) {
+      var _metrics$httpResponse;
+
+      (_metrics$httpResponse = metrics.httpResponseContentLengthInBytes) === null || _metrics$httpResponse === void 0 ? void 0 : _metrics$httpResponse.forEach(httpResponseContentLengthInBytesMetricType => {
         httpResponseContentLengthInBytesMetricType.observe(labels, // @ts-expect-error
         recordingOptions.responseContentLength);
       });
@@ -291,7 +341,7 @@ const createRequestRecorder = (metricTypes, options = defaultOptions) => {
   };
 };
 
-createRequestRecorder.defaultOptions = defaultOptions;
+createRequestRecorder.defaultOptions = defaultOptions$1;
 
 const gc = requireOptional__default["default"]('@sematext/gc-stats');
 const gcTypes = {
@@ -303,27 +353,32 @@ const gcTypes = {
   8: 'weak_phantom',
   15: 'all'
 };
-const createGcObserver = once__default["default"](metricTypes => () => {
+const defaultOptions = {
+  disableGcMetrics: false
+};
+const createGcObserver = once__default["default"]((metrics, options) => () => {
   if (typeof gc !== 'function') {
     return;
   }
 
+  if (options.disableGcMetrics) return;
   gc().on('stats', stats => {
     const gcType = gcTypes[stats.gctype];
-    metricTypes.countOfGcs.forEach(countOfGcMetricType => {
+    metrics.countOfGcs.forEach(countOfGcMetricType => {
       countOfGcMetricType.labels(gcType).inc();
     });
-    metricTypes.durationOfGc.forEach(durationOfGcMetricType => {
+    metrics.durationOfGc.forEach(durationOfGcMetricType => {
       durationOfGcMetricType.labels(gcType).inc(stats.pause / 1e9);
     });
 
     if (stats.diff.usedHeapSize < 0) {
-      metricTypes.reclaimedInGc.forEach(reclaimedInGcMetricType => {
+      metrics.reclaimedInGc.forEach(reclaimedInGcMetricType => {
         reclaimedInGcMetricType.labels(gcType).inc(stats.diff.usedHeapSize * -1);
       });
     }
   });
 });
+createGcObserver.defaultOptions = defaultOptions;
 
 const normalizeStatusCode = statusCode => statusCode;
 
@@ -340,14 +395,19 @@ const defaultNormalizers = {
 };
 
 exports.Prometheus = Prometheus__namespace;
+exports.createGcMetrics = createGcMetrics;
 exports.createGcObserver = createGcObserver;
-exports.createMetricTypes = createMetricTypes;
+exports.createGraphQlMetrics = createGraphQlMetrics;
+exports.createHttpMetrics = createHttpMetrics;
 exports.createRequestRecorder = createRequestRecorder;
 exports.defaultNormalizers = defaultNormalizers;
 exports.defaultRegister = defaultRegister;
+exports.endMeasurementFrom = endMeasurementFrom;
 exports.getContentType = getContentType;
 exports.getSummary = getSummary;
 exports.isRunningInKubernetes = isRunningInKubernetes;
 exports.normalizeMethod = normalizeMethod;
 exports.normalizePath = normalizePath;
 exports.normalizeStatusCode = normalizeStatusCode;
+exports.skipMetricsInEnvironment = skipMetricsInEnvironment;
+exports.sortLabels = sortLabels;

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@promster/metrics",
-  "version": "8.0.0",
+  "version": "9.0.0",
   "description": "Metrics utilities used by all other server integrations",
   "main": "dist/promster-metrics.cjs.js",
   "typings": "dist/promster-metrics.cjs.d.ts",
   "types": "dist/promster-metrics.cjs.d.ts",
-  "scripts": {},
   "files": [
     "readme.md",
     "package.json",
@@ -22,7 +21,8 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/tdeekens/promster.git"
+    "url": "https://github.com/tdeekens/flopflip.git",
+    "directory": "packages/metrics"
   },
   "author": "Tobias Deekens <nerd@tdeekens.name>",
   "license": "MIT",
@@ -46,9 +46,9 @@
     "url-value-parser": "2.0.3"
   },
   "devDependencies": {
-    "@promster/types": "^3.1.5",
+    "@promster/types": "^3.2.0",
     "@types/lodash": "4.14.176",
-    "prom-client": "14.0.0",
+    "prom-client": "14.0.1",
     "typescript": "4.4.4"
   },
   "optionalDependencies": {

package/readme.md

@@ -1,6 +1,5 @@
 <p align="center">
-  <b style="font-size: 25px">⏰ Promster - Measure metrics from Hapi/Express servers with Prometheus 🚦</b><br />
-  <i>Promster is an Prometheus Exporter for Node.js servers written with Express or Hapi.</i>
+  <b style="font-size: 25px">⏰ Promster - Measure metrics from Hapi/Express servers with Prometheus 🚦</b>
 </p>
 
 ### `@promster/metrics`

package/dist/declarations/src/create-metric-types/create-metric-types.d.ts

@@ -1,25 +0,0 @@
-import type { TDefaultedPromsterOptions, TMetricTypes } from '@promster/types';
-declare const createMetricTypes: {
-    (options: TDefaultedPromsterOptions): TMetricTypes;
-    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[];
-            httpRequestContentLengthInBytes: string[];
-            httpResponseContentLengthInBytes: string[];
-        };
-    };
-};
-export { createMetricTypes };

package/dist/declarations/src/create-metric-types/index.d.ts

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

package/dist/declarations/src/kubernetes/index.d.ts

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