@promster/metrics 8.0.0 → 9.1.2

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 defaultLabels$2 = ['path', 'status_code', 'method'];
 
-const shouldObserveMetricsInSeconds = options => options.accuracies.includes('s');
-
-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,275 @@ 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'];
 
-  return (_options$metricTypes = options.metricTypes) === null || _options$metricTypes === void 0 ? void 0 : _options$metricTypes.includes(metricType);
+const asArray = maybeArray => Array.isArray(maybeArray) ? maybeArray : [maybeArray];
+
+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
-
-  return (start, recordingOptions) => {
-    const {
-      durationMs,
-      durationS
-    } = endMeasurementFrom(start);
-    const labels = sortLabels(recordingOptions.labels);
+function isTiming(timing) {
+  return !Array.isArray(timing);
+}
 
-    if (shouldObserveInMilliseconds && shouldObserveInHistogram && !shouldSkipMetricsByEnvironment) {
-      metricTypes.httpRequestDurationInMilliseconds.forEach(httpRequestDurationInMillisecondsMetricType => {
-        httpRequestDurationInMillisecondsMetricType.observe(labels, durationMs);
-      });
-    }
+const createRequestRecorder = (metrics, options = defaultOptions$1) => {
+  const defaultedRecorderOptions = merge__default["default"](defaultOptions$1, options);
+  const shouldSkipMetricsByEnvironment = skipMetricsInEnvironment(defaultedRecorderOptions);
+  return (timing, recordingOptions) => {
+    const durationS = isTiming(timing) ? timing.end().value().seconds : endMeasurementFrom(timing).durationS;
+    const labels = sortLabels(recordingOptions.labels);
 
-    if (shouldObserveInMilliseconds && shouldObserveInSummary && !shouldSkipMetricsByEnvironment) {
-      metricTypes.httpRequestDurationPerPercentileInMilliseconds.forEach(httpRequestDurationPerPercentileInMillisecondsMetricType => {
-        httpRequestDurationPerPercentileInMillisecondsMetricType.observe(labels, durationMs);
-      });
-    }
+    if (!shouldSkipMetricsByEnvironment && durationS !== undefined) {
+      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 && durationS !== undefined) {
+      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 && durationS !== undefined) {
+      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 +343,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 +355,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;
 
@@ -339,15 +396,143 @@ const defaultNormalizers = {
   normalizeMethod
 };
 
+function _checkPrivateRedeclaration(obj, privateCollection) {
+  if (privateCollection.has(obj)) {
+    throw new TypeError("Cannot initialize the same private elements twice on an object");
+  }
+}
+
+function _classPrivateFieldInitSpec(obj, privateMap, value) {
+  _checkPrivateRedeclaration(obj, privateMap);
+  privateMap.set(obj, value);
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+
+  return obj;
+}
+
+function _classApplyDescriptorSet(receiver, descriptor, value) {
+  if (descriptor.set) {
+    descriptor.set.call(receiver, value);
+  } else {
+    if (!descriptor.writable) {
+      throw new TypeError("attempted to set read only private field");
+    }
+
+    descriptor.value = value;
+  }
+}
+
+function _classExtractFieldDescriptor(receiver, privateMap, action) {
+  if (!privateMap.has(receiver)) {
+    throw new TypeError("attempted to " + action + " private field on non-instance");
+  }
+
+  return privateMap.get(receiver);
+}
+
+function _classPrivateFieldSet(receiver, privateMap, value) {
+  var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set");
+  _classApplyDescriptorSet(receiver, descriptor, value);
+  return value;
+}
+
+function _classApplyDescriptorGet(receiver, descriptor) {
+  if (descriptor.get) {
+    return descriptor.get.call(receiver);
+  }
+
+  return descriptor.value;
+}
+
+function _classPrivateFieldGet(receiver, privateMap) {
+  var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get");
+  return _classApplyDescriptorGet(receiver, descriptor);
+}
+
+var _startTime = /*#__PURE__*/new WeakMap();
+
+var _endTime = /*#__PURE__*/new WeakMap();
+
+class Timing {
+  constructor() {
+    _classPrivateFieldInitSpec(this, _startTime, {
+      writable: true,
+      value: void 0
+    });
+
+    _classPrivateFieldInitSpec(this, _endTime, {
+      writable: true,
+      value: void 0
+    });
+
+    this.reset();
+  }
+
+  value() {
+    const startTime = _classPrivateFieldGet(this, _startTime);
+
+    const endTime = _classPrivateFieldGet(this, _endTime);
+
+    if (!endTime || !startTime) return {
+      seconds: undefined
+    };
+    return {
+      seconds: Number((endTime - startTime) / Timing.NS_PER_SEC)
+    };
+  }
+
+  reset() {
+    _classPrivateFieldSet(this, _startTime, process.hrtime.bigint());
+
+    _classPrivateFieldSet(this, _endTime, undefined);
+
+    return this;
+  }
+
+  end() {
+    _classPrivateFieldSet(this, _endTime, process.hrtime.bigint());
+
+    return this;
+  }
+
+}
+
+_defineProperty(Timing, "NS_PER_SEC", BigInt(1e9));
+
+const timing = {
+  start() {
+    return new Timing();
+  }
+
+};
+
 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;
+exports.timing = timing;