decocms 2.333.0 → 2.334.0

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/src/export/MetricReader.js

@@ -0,0 +1,128 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricReader = void 0;
+const api = require("@opentelemetry/api");
+const utils_1 = require("../utils");
+const AggregationSelector_1 = require("./AggregationSelector");
+/**
+ * A registered reader of metrics that, when linked to a {@link MetricProducer}, offers global
+ * control over metrics.
+ */
+class MetricReader {
+    // Tracks the shutdown state.
+    // TODO: use BindOncePromise here once a new version of @opentelemetry/core is available.
+    _shutdown = false;
+    // Additional MetricProducers which will be combined with the SDK's output
+    _metricProducers;
+    // MetricProducer used by this instance which produces metrics from the SDK
+    _sdkMetricProducer;
+    _aggregationTemporalitySelector;
+    _aggregationSelector;
+    _cardinalitySelector;
+    constructor(options) {
+        this._aggregationSelector =
+            options?.aggregationSelector ?? AggregationSelector_1.DEFAULT_AGGREGATION_SELECTOR;
+        this._aggregationTemporalitySelector =
+            options?.aggregationTemporalitySelector ??
+                AggregationSelector_1.DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR;
+        this._metricProducers = options?.metricProducers ?? [];
+        this._cardinalitySelector = options?.cardinalitySelector;
+    }
+    setMetricProducer(metricProducer) {
+        if (this._sdkMetricProducer) {
+            throw new Error('MetricReader can not be bound to a MeterProvider again.');
+        }
+        this._sdkMetricProducer = metricProducer;
+        this.onInitialized();
+    }
+    selectAggregation(instrumentType) {
+        return this._aggregationSelector(instrumentType);
+    }
+    selectAggregationTemporality(instrumentType) {
+        return this._aggregationTemporalitySelector(instrumentType);
+    }
+    selectCardinalityLimit(instrumentType) {
+        return this._cardinalitySelector
+            ? this._cardinalitySelector(instrumentType)
+            : 2000; // default value if no selector is provided
+    }
+    /**
+     * Handle once the SDK has initialized this {@link MetricReader}
+     * Overriding this method is optional.
+     */
+    onInitialized() {
+        // Default implementation is empty.
+    }
+    async collect(options) {
+        if (this._sdkMetricProducer === undefined) {
+            throw new Error('MetricReader is not bound to a MetricProducer');
+        }
+        // Subsequent invocations to collect are not allowed. SDKs SHOULD return some failure for these calls.
+        if (this._shutdown) {
+            throw new Error('MetricReader is shutdown');
+        }
+        const [sdkCollectionResults, ...additionalCollectionResults] = await Promise.all([
+            this._sdkMetricProducer.collect({
+                timeoutMillis: options?.timeoutMillis,
+            }),
+            ...this._metricProducers.map(producer => producer.collect({
+                timeoutMillis: options?.timeoutMillis,
+            })),
+        ]);
+        // Merge the results, keeping the SDK's Resource
+        const errors = sdkCollectionResults.errors.concat((0, utils_1.FlatMap)(additionalCollectionResults, result => result.errors));
+        const resource = sdkCollectionResults.resourceMetrics.resource;
+        const scopeMetrics = sdkCollectionResults.resourceMetrics.scopeMetrics.concat((0, utils_1.FlatMap)(additionalCollectionResults, result => result.resourceMetrics.scopeMetrics));
+        return {
+            resourceMetrics: {
+                resource,
+                scopeMetrics,
+            },
+            errors,
+        };
+    }
+    async shutdown(options) {
+        // Do not call shutdown again if it has already been called.
+        if (this._shutdown) {
+            api.diag.error('Cannot call shutdown twice.');
+            return;
+        }
+        // No timeout if timeoutMillis is undefined or null.
+        if (options?.timeoutMillis == null) {
+            await this.onShutdown();
+        }
+        else {
+            await (0, utils_1.callWithTimeout)(this.onShutdown(), options.timeoutMillis);
+        }
+        this._shutdown = true;
+    }
+    async forceFlush(options) {
+        if (this._shutdown) {
+            api.diag.warn('Cannot forceFlush on already shutdown MetricReader.');
+            return;
+        }
+        // No timeout if timeoutMillis is undefined or null.
+        if (options?.timeoutMillis == null) {
+            await this.onForceFlush();
+            return;
+        }
+        await (0, utils_1.callWithTimeout)(this.onForceFlush(), options.timeoutMillis);
+    }
+}
+exports.MetricReader = MetricReader;
+//# sourceMappingURL=MetricReader.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/src/export/MetricReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricReader.js","sourceRoot":"","sources":["../../../src/export/MetricReader.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as api from '@opentelemetry/api';\nimport { AggregationTemporality } from './AggregationTemporality';\nimport { MetricProducer } from './MetricProducer';\nimport { CollectionResult, InstrumentType } from './MetricData';\nimport { callWithTimeout, FlatMap } from '../utils';\nimport {\n  CollectionOptions,\n  ForceFlushOptions,\n  ShutdownOptions,\n} from '../types';\nimport {\n  AggregationSelector,\n  AggregationTemporalitySelector,\n  DEFAULT_AGGREGATION_SELECTOR,\n  DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR,\n} from './AggregationSelector';\nimport { AggregationOption } from '../view/AggregationOption';\nimport { CardinalitySelector } from './CardinalitySelector';\n\nexport interface MetricReaderOptions {\n  /**\n   * Aggregation selector based on metric instrument types. If no views are\n   * configured for a metric instrument, a per-metric-reader aggregation is\n   * selected with this selector.\n   *\n   * <p> NOTE: the provided function MUST be pure\n   */\n  aggregationSelector?: AggregationSelector;\n  /**\n   * Aggregation temporality selector based on metric instrument types. If\n   * not configured, cumulative is used for all instruments.\n   *\n   * <p> NOTE: the provided function MUST be pure\n   */\n  aggregationTemporalitySelector?: AggregationTemporalitySelector;\n  /**\n   * Cardinality selector based on metric instrument types. If not configured,\n   * a default value is used.\n   *\n   * <p> NOTE: the provided function MUST be pure\n   */\n  cardinalitySelector?: CardinalitySelector;\n  /**\n   * **Note, this option is experimental**. Additional MetricProducers to use as a source of\n   * aggregated metric data in addition to the SDK's metric data. The resource returned by\n   * these MetricProducers is ignored; the SDK's resource will be used instead.\n   * @experimental\n   */\n  metricProducers?: MetricProducer[];\n}\n\n/**\n * Reads metrics from the SDK. Implementations MUST follow the Metric Reader Specification as well as the requirements\n * listed in this interface. Consider extending {@link MetricReader} to get a specification-compliant base implementation\n * of this interface\n */\nexport interface IMetricReader {\n  /**\n   * Set the {@link MetricProducer} used by this instance. **This should only be called once by the\n   * SDK and should be considered internal.**\n   *\n   * <p> NOTE: implementations MUST throw when called more than once\n   *\n   * @param metricProducer\n   */\n  setMetricProducer(metricProducer: MetricProducer): void;\n\n  /**\n   * Select the {@link AggregationOption} for the given {@link InstrumentType} for this\n   * reader.\n   *\n   * <p> NOTE: implementations MUST be pure\n   */\n  selectAggregation(instrumentType: InstrumentType): AggregationOption;\n\n  /**\n   * Select the {@link AggregationTemporality} for the given\n   * {@link InstrumentType} for this reader.\n   *\n   * <p> NOTE: implementations MUST be pure\n   */\n  selectAggregationTemporality(\n    instrumentType: InstrumentType\n  ): AggregationTemporality;\n\n  /**\n   * Select the cardinality limit for the given {@link InstrumentType} for this\n   * reader.\n   *\n   * <p> NOTE: implementations MUST be pure\n   */\n  selectCardinalityLimit(instrumentType: InstrumentType): number;\n\n  /**\n   * Collect all metrics from the associated {@link MetricProducer}\n   */\n  collect(options?: CollectionOptions): Promise<CollectionResult>;\n\n  /**\n   * Shuts down the metric reader, the promise will reject after the optional timeout or resolve after completion.\n   *\n   * <p> NOTE: this operation MAY continue even after the promise rejects due to a timeout.\n   * @param options options with timeout.\n   */\n  shutdown(options?: ShutdownOptions): Promise<void>;\n\n  /**\n   * Flushes metrics read by this reader, the promise will reject after the optional timeout or resolve after completion.\n   *\n   * <p> NOTE: this operation MAY continue even after the promise rejects due to a timeout.\n   * @param options options with timeout.\n   */\n  forceFlush(options?: ForceFlushOptions): Promise<void>;\n}\n\n/**\n * A registered reader of metrics that, when linked to a {@link MetricProducer}, offers global\n * control over metrics.\n */\nexport abstract class MetricReader implements IMetricReader {\n  // Tracks the shutdown state.\n  // TODO: use BindOncePromise here once a new version of @opentelemetry/core is available.\n  private _shutdown = false;\n  // Additional MetricProducers which will be combined with the SDK's output\n  private _metricProducers: MetricProducer[];\n  // MetricProducer used by this instance which produces metrics from the SDK\n  private _sdkMetricProducer?: MetricProducer;\n  private readonly _aggregationTemporalitySelector: AggregationTemporalitySelector;\n  private readonly _aggregationSelector: AggregationSelector;\n  private readonly _cardinalitySelector?: CardinalitySelector;\n\n  constructor(options?: MetricReaderOptions) {\n    this._aggregationSelector =\n      options?.aggregationSelector ?? DEFAULT_AGGREGATION_SELECTOR;\n    this._aggregationTemporalitySelector =\n      options?.aggregationTemporalitySelector ??\n      DEFAULT_AGGREGATION_TEMPORALITY_SELECTOR;\n    this._metricProducers = options?.metricProducers ?? [];\n    this._cardinalitySelector = options?.cardinalitySelector;\n  }\n\n  setMetricProducer(metricProducer: MetricProducer) {\n    if (this._sdkMetricProducer) {\n      throw new Error(\n        'MetricReader can not be bound to a MeterProvider again.'\n      );\n    }\n    this._sdkMetricProducer = metricProducer;\n    this.onInitialized();\n  }\n\n  selectAggregation(instrumentType: InstrumentType): AggregationOption {\n    return this._aggregationSelector(instrumentType);\n  }\n\n  selectAggregationTemporality(\n    instrumentType: InstrumentType\n  ): AggregationTemporality {\n    return this._aggregationTemporalitySelector(instrumentType);\n  }\n\n  selectCardinalityLimit(instrumentType: InstrumentType): number {\n    return this._cardinalitySelector\n      ? this._cardinalitySelector(instrumentType)\n      : 2000; // default value if no selector is provided\n  }\n\n  /**\n   * Handle once the SDK has initialized this {@link MetricReader}\n   * Overriding this method is optional.\n   */\n  protected onInitialized(): void {\n    // Default implementation is empty.\n  }\n\n  /**\n   * Handle a shutdown signal by the SDK.\n   *\n   * <p> For push exporters, this should shut down any intervals and close any open connections.\n   * @protected\n   */\n  protected abstract onShutdown(): Promise<void>;\n\n  /**\n   * Handle a force flush signal by the SDK.\n   *\n   * <p> In all scenarios metrics should be collected via {@link collect()}.\n   * <p> For push exporters, this should collect and report metrics.\n   * @protected\n   */\n  protected abstract onForceFlush(): Promise<void>;\n\n  async collect(options?: CollectionOptions): Promise<CollectionResult> {\n    if (this._sdkMetricProducer === undefined) {\n      throw new Error('MetricReader is not bound to a MetricProducer');\n    }\n\n    // Subsequent invocations to collect are not allowed. SDKs SHOULD return some failure for these calls.\n    if (this._shutdown) {\n      throw new Error('MetricReader is shutdown');\n    }\n\n    const [sdkCollectionResults, ...additionalCollectionResults] =\n      await Promise.all([\n        this._sdkMetricProducer.collect({\n          timeoutMillis: options?.timeoutMillis,\n        }),\n        ...this._metricProducers.map(producer =>\n          producer.collect({\n            timeoutMillis: options?.timeoutMillis,\n          })\n        ),\n      ]);\n\n    // Merge the results, keeping the SDK's Resource\n    const errors = sdkCollectionResults.errors.concat(\n      FlatMap(additionalCollectionResults, result => result.errors)\n    );\n    const resource = sdkCollectionResults.resourceMetrics.resource;\n    const scopeMetrics =\n      sdkCollectionResults.resourceMetrics.scopeMetrics.concat(\n        FlatMap(\n          additionalCollectionResults,\n          result => result.resourceMetrics.scopeMetrics\n        )\n      );\n    return {\n      resourceMetrics: {\n        resource,\n        scopeMetrics,\n      },\n      errors,\n    };\n  }\n\n  async shutdown(options?: ShutdownOptions): Promise<void> {\n    // Do not call shutdown again if it has already been called.\n    if (this._shutdown) {\n      api.diag.error('Cannot call shutdown twice.');\n      return;\n    }\n\n    // No timeout if timeoutMillis is undefined or null.\n    if (options?.timeoutMillis == null) {\n      await this.onShutdown();\n    } else {\n      await callWithTimeout(this.onShutdown(), options.timeoutMillis);\n    }\n\n    this._shutdown = true;\n  }\n\n  async forceFlush(options?: ForceFlushOptions): Promise<void> {\n    if (this._shutdown) {\n      api.diag.warn('Cannot forceFlush on already shutdown MetricReader.');\n      return;\n    }\n\n    // No timeout if timeoutMillis is undefined or null.\n    if (options?.timeoutMillis == null) {\n      await this.onForceFlush();\n      return;\n    }\n\n    await callWithTimeout(this.onForceFlush(), options.timeoutMillis);\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/src/export/PeriodicExportingMetricReader.d.ts

@@ -0,0 +1,42 @@
+import { MetricReader } from './MetricReader';
+import { PushMetricExporter } from './MetricExporter';
+import { MetricProducer } from './MetricProducer';
+export type PeriodicExportingMetricReaderOptions = {
+    /**
+     * The backing exporter for the metric reader.
+     */
+    exporter: PushMetricExporter;
+    /**
+     * An internal milliseconds for the metric reader to initiate metric
+     * collection.
+     */
+    exportIntervalMillis?: number;
+    /**
+     * Milliseconds for the async observable callback to timeout.
+     */
+    exportTimeoutMillis?: number;
+    /**
+     * **Note, this option is experimental**. Additional MetricProducers to use as a source of
+     * aggregated metric data in addition to the SDK's metric data. The resource returned by
+     * these MetricProducers is ignored; the SDK's resource will be used instead.
+     * @experimental
+     */
+    metricProducers?: MetricProducer[];
+};
+/**
+ * {@link MetricReader} which collects metrics based on a user-configurable time interval, and passes the metrics to
+ * the configured {@link PushMetricExporter}
+ */
+export declare class PeriodicExportingMetricReader extends MetricReader {
+    private _interval?;
+    private _exporter;
+    private readonly _exportInterval;
+    private readonly _exportTimeout;
+    constructor(options: PeriodicExportingMetricReaderOptions);
+    private _runOnce;
+    private _doRun;
+    protected onInitialized(): void;
+    protected onForceFlush(): Promise<void>;
+    protected onShutdown(): Promise<void>;
+}
+//# sourceMappingURL=PeriodicExportingMetricReader.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/src/export/PeriodicExportingMetricReader.js

@@ -0,0 +1,115 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PeriodicExportingMetricReader = void 0;
+const api = require("@opentelemetry/api");
+const core_1 = require("@opentelemetry/core");
+const MetricReader_1 = require("./MetricReader");
+const utils_1 = require("../utils");
+/**
+ * {@link MetricReader} which collects metrics based on a user-configurable time interval, and passes the metrics to
+ * the configured {@link PushMetricExporter}
+ */
+class PeriodicExportingMetricReader extends MetricReader_1.MetricReader {
+    _interval;
+    _exporter;
+    _exportInterval;
+    _exportTimeout;
+    constructor(options) {
+        super({
+            aggregationSelector: options.exporter.selectAggregation?.bind(options.exporter),
+            aggregationTemporalitySelector: options.exporter.selectAggregationTemporality?.bind(options.exporter),
+            metricProducers: options.metricProducers,
+        });
+        if (options.exportIntervalMillis !== undefined &&
+            options.exportIntervalMillis <= 0) {
+            throw Error('exportIntervalMillis must be greater than 0');
+        }
+        if (options.exportTimeoutMillis !== undefined &&
+            options.exportTimeoutMillis <= 0) {
+            throw Error('exportTimeoutMillis must be greater than 0');
+        }
+        if (options.exportTimeoutMillis !== undefined &&
+            options.exportIntervalMillis !== undefined &&
+            options.exportIntervalMillis < options.exportTimeoutMillis) {
+            throw Error('exportIntervalMillis must be greater than or equal to exportTimeoutMillis');
+        }
+        this._exportInterval = options.exportIntervalMillis ?? 60000;
+        this._exportTimeout = options.exportTimeoutMillis ?? 30000;
+        this._exporter = options.exporter;
+    }
+    async _runOnce() {
+        try {
+            await (0, utils_1.callWithTimeout)(this._doRun(), this._exportTimeout);
+        }
+        catch (err) {
+            if (err instanceof utils_1.TimeoutError) {
+                api.diag.error('Export took longer than %s milliseconds and timed out.', this._exportTimeout);
+                return;
+            }
+            (0, core_1.globalErrorHandler)(err);
+        }
+    }
+    async _doRun() {
+        const { resourceMetrics, errors } = await this.collect({
+            timeoutMillis: this._exportTimeout,
+        });
+        if (errors.length > 0) {
+            api.diag.error('PeriodicExportingMetricReader: metrics collection errors', ...errors);
+        }
+        if (resourceMetrics.resource.asyncAttributesPending) {
+            try {
+                await resourceMetrics.resource.waitForAsyncAttributes?.();
+            }
+            catch (e) {
+                api.diag.debug('Error while resolving async portion of resource: ', e);
+                (0, core_1.globalErrorHandler)(e);
+            }
+        }
+        if (resourceMetrics.scopeMetrics.length === 0) {
+            return;
+        }
+        const result = await core_1.internal._export(this._exporter, resourceMetrics);
+        if (result.code !== core_1.ExportResultCode.SUCCESS) {
+            throw new Error(`PeriodicExportingMetricReader: metrics export failed (error ${result.error})`);
+        }
+    }
+    onInitialized() {
+        // start running the interval as soon as this reader is initialized and keep handle for shutdown.
+        this._interval = setInterval(() => {
+            // this._runOnce never rejects. Using void operator to suppress @typescript-eslint/no-floating-promises.
+            void this._runOnce();
+        }, this._exportInterval);
+        // depending on runtime, this may be a 'number' or NodeJS.Timeout
+        if (typeof this._interval !== 'number') {
+            this._interval.unref();
+        }
+    }
+    async onForceFlush() {
+        await this._runOnce();
+        await this._exporter.forceFlush();
+    }
+    async onShutdown() {
+        if (this._interval) {
+            clearInterval(this._interval);
+        }
+        await this.onForceFlush();
+        await this._exporter.shutdown();
+    }
+}
+exports.PeriodicExportingMetricReader = PeriodicExportingMetricReader;
+//# sourceMappingURL=PeriodicExportingMetricReader.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/src/export/PeriodicExportingMetricReader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PeriodicExportingMetricReader.js","sourceRoot":"","sources":["../../../src/export/PeriodicExportingMetricReader.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport * as api from '@opentelemetry/api';\nimport {\n  internal,\n  ExportResultCode,\n  globalErrorHandler,\n} from '@opentelemetry/core';\nimport { MetricReader } from './MetricReader';\nimport { PushMetricExporter } from './MetricExporter';\nimport { callWithTimeout, TimeoutError } from '../utils';\nimport { MetricProducer } from './MetricProducer';\n\nexport type PeriodicExportingMetricReaderOptions = {\n  /**\n   * The backing exporter for the metric reader.\n   */\n  exporter: PushMetricExporter;\n  /**\n   * An internal milliseconds for the metric reader to initiate metric\n   * collection.\n   */\n  exportIntervalMillis?: number;\n  /**\n   * Milliseconds for the async observable callback to timeout.\n   */\n  exportTimeoutMillis?: number;\n  /**\n   * **Note, this option is experimental**. Additional MetricProducers to use as a source of\n   * aggregated metric data in addition to the SDK's metric data. The resource returned by\n   * these MetricProducers is ignored; the SDK's resource will be used instead.\n   * @experimental\n   */\n  metricProducers?: MetricProducer[];\n};\n\n/**\n * {@link MetricReader} which collects metrics based on a user-configurable time interval, and passes the metrics to\n * the configured {@link PushMetricExporter}\n */\nexport class PeriodicExportingMetricReader extends MetricReader {\n  private _interval?: ReturnType<typeof setInterval>;\n  private _exporter: PushMetricExporter;\n  private readonly _exportInterval: number;\n  private readonly _exportTimeout: number;\n\n  constructor(options: PeriodicExportingMetricReaderOptions) {\n    super({\n      aggregationSelector: options.exporter.selectAggregation?.bind(\n        options.exporter\n      ),\n      aggregationTemporalitySelector:\n        options.exporter.selectAggregationTemporality?.bind(options.exporter),\n      metricProducers: options.metricProducers,\n    });\n\n    if (\n      options.exportIntervalMillis !== undefined &&\n      options.exportIntervalMillis <= 0\n    ) {\n      throw Error('exportIntervalMillis must be greater than 0');\n    }\n\n    if (\n      options.exportTimeoutMillis !== undefined &&\n      options.exportTimeoutMillis <= 0\n    ) {\n      throw Error('exportTimeoutMillis must be greater than 0');\n    }\n\n    if (\n      options.exportTimeoutMillis !== undefined &&\n      options.exportIntervalMillis !== undefined &&\n      options.exportIntervalMillis < options.exportTimeoutMillis\n    ) {\n      throw Error(\n        'exportIntervalMillis must be greater than or equal to exportTimeoutMillis'\n      );\n    }\n\n    this._exportInterval = options.exportIntervalMillis ?? 60000;\n    this._exportTimeout = options.exportTimeoutMillis ?? 30000;\n    this._exporter = options.exporter;\n  }\n\n  private async _runOnce(): Promise<void> {\n    try {\n      await callWithTimeout(this._doRun(), this._exportTimeout);\n    } catch (err) {\n      if (err instanceof TimeoutError) {\n        api.diag.error(\n          'Export took longer than %s milliseconds and timed out.',\n          this._exportTimeout\n        );\n        return;\n      }\n\n      globalErrorHandler(err);\n    }\n  }\n\n  private async _doRun(): Promise<void> {\n    const { resourceMetrics, errors } = await this.collect({\n      timeoutMillis: this._exportTimeout,\n    });\n\n    if (errors.length > 0) {\n      api.diag.error(\n        'PeriodicExportingMetricReader: metrics collection errors',\n        ...errors\n      );\n    }\n\n    if (resourceMetrics.resource.asyncAttributesPending) {\n      try {\n        await resourceMetrics.resource.waitForAsyncAttributes?.();\n      } catch (e) {\n        api.diag.debug('Error while resolving async portion of resource: ', e);\n        globalErrorHandler(e);\n      }\n    }\n\n    if (resourceMetrics.scopeMetrics.length === 0) {\n      return;\n    }\n\n    const result = await internal._export(this._exporter, resourceMetrics);\n    if (result.code !== ExportResultCode.SUCCESS) {\n      throw new Error(\n        `PeriodicExportingMetricReader: metrics export failed (error ${result.error})`\n      );\n    }\n  }\n\n  protected override onInitialized(): void {\n    // start running the interval as soon as this reader is initialized and keep handle for shutdown.\n    this._interval = setInterval(() => {\n      // this._runOnce never rejects. Using void operator to suppress @typescript-eslint/no-floating-promises.\n      void this._runOnce();\n    }, this._exportInterval);\n\n    // depending on runtime, this may be a 'number' or NodeJS.Timeout\n    if (typeof this._interval !== 'number') {\n      this._interval.unref();\n    }\n  }\n\n  protected async onForceFlush(): Promise<void> {\n    await this._runOnce();\n    await this._exporter.forceFlush();\n  }\n\n  protected async onShutdown(): Promise<void> {\n    if (this._interval) {\n      clearInterval(this._interval);\n    }\n    await this.onForceFlush();\n    await this._exporter.shutdown();\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/src/index.d.ts

@@ -0,0 +1,22 @@
+export type { Sum, LastValue, Histogram, ExponentialHistogram, } from './aggregator/types';
+export type { AggregationSelector, AggregationTemporalitySelector, } from './export/AggregationSelector';
+export { AggregationTemporality } from './export/AggregationTemporality';
+export { DataPointType, InstrumentType } from './export/MetricData';
+export type { DataPoint, SumMetricData, GaugeMetricData, HistogramMetricData, ExponentialHistogramMetricData, ResourceMetrics, ScopeMetrics, MetricData, MetricDescriptor, CollectionResult, } from './export/MetricData';
+export type { PushMetricExporter } from './export/MetricExporter';
+export { MetricReader } from './export/MetricReader';
+export type { IMetricReader, MetricReaderOptions } from './export/MetricReader';
+export { PeriodicExportingMetricReader } from './export/PeriodicExportingMetricReader';
+export type { PeriodicExportingMetricReaderOptions } from './export/PeriodicExportingMetricReader';
+export { InMemoryMetricExporter } from './export/InMemoryMetricExporter';
+export { ConsoleMetricExporter } from './export/ConsoleMetricExporter';
+export type { MetricCollectOptions, MetricProducer, } from './export/MetricProducer';
+export { MeterProvider } from './MeterProvider';
+export type { MeterProviderOptions } from './MeterProvider';
+export { AggregationType } from './view/AggregationOption';
+export type { AggregationOption } from './view/AggregationOption';
+export type { ViewOptions } from './view/View';
+export type { IAttributesProcessor } from './view/AttributesProcessor';
+export { createAllowListAttributesProcessor, createDenyListAttributesProcessor, } from './view/AttributesProcessor';
+export { TimeoutError } from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/src/index.js

@@ -0,0 +1,41 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutError = exports.createDenyListAttributesProcessor = exports.createAllowListAttributesProcessor = exports.AggregationType = exports.MeterProvider = exports.ConsoleMetricExporter = exports.InMemoryMetricExporter = exports.PeriodicExportingMetricReader = exports.MetricReader = exports.InstrumentType = exports.DataPointType = exports.AggregationTemporality = void 0;
+var AggregationTemporality_1 = require("./export/AggregationTemporality");
+Object.defineProperty(exports, "AggregationTemporality", { enumerable: true, get: function () { return AggregationTemporality_1.AggregationTemporality; } });
+var MetricData_1 = require("./export/MetricData");
+Object.defineProperty(exports, "DataPointType", { enumerable: true, get: function () { return MetricData_1.DataPointType; } });
+Object.defineProperty(exports, "InstrumentType", { enumerable: true, get: function () { return MetricData_1.InstrumentType; } });
+var MetricReader_1 = require("./export/MetricReader");
+Object.defineProperty(exports, "MetricReader", { enumerable: true, get: function () { return MetricReader_1.MetricReader; } });
+var PeriodicExportingMetricReader_1 = require("./export/PeriodicExportingMetricReader");
+Object.defineProperty(exports, "PeriodicExportingMetricReader", { enumerable: true, get: function () { return PeriodicExportingMetricReader_1.PeriodicExportingMetricReader; } });
+var InMemoryMetricExporter_1 = require("./export/InMemoryMetricExporter");
+Object.defineProperty(exports, "InMemoryMetricExporter", { enumerable: true, get: function () { return InMemoryMetricExporter_1.InMemoryMetricExporter; } });
+var ConsoleMetricExporter_1 = require("./export/ConsoleMetricExporter");
+Object.defineProperty(exports, "ConsoleMetricExporter", { enumerable: true, get: function () { return ConsoleMetricExporter_1.ConsoleMetricExporter; } });
+var MeterProvider_1 = require("./MeterProvider");
+Object.defineProperty(exports, "MeterProvider", { enumerable: true, get: function () { return MeterProvider_1.MeterProvider; } });
+var AggregationOption_1 = require("./view/AggregationOption");
+Object.defineProperty(exports, "AggregationType", { enumerable: true, get: function () { return AggregationOption_1.AggregationType; } });
+var AttributesProcessor_1 = require("./view/AttributesProcessor");
+Object.defineProperty(exports, "createAllowListAttributesProcessor", { enumerable: true, get: function () { return AttributesProcessor_1.createAllowListAttributesProcessor; } });
+Object.defineProperty(exports, "createDenyListAttributesProcessor", { enumerable: true, get: function () { return AttributesProcessor_1.createDenyListAttributesProcessor; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "TimeoutError", { enumerable: true, get: function () { return utils_1.TimeoutError; } });
+//# sourceMappingURL=index.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAcH,0EAAyE;AAAhE,gIAAA,sBAAsB,OAAA;AAE/B,kDAAoE;AAA3D,2GAAA,aAAa,OAAA;AAAE,4GAAA,cAAc,OAAA;AAgBtC,sDAAqD;AAA5C,4GAAA,YAAY,OAAA;AAGrB,wFAAuF;AAA9E,8IAAA,6BAA6B,OAAA;AAGtC,0EAAyE;AAAhE,gIAAA,sBAAsB,OAAA;AAE/B,wEAAuE;AAA9D,8HAAA,qBAAqB,OAAA;AAO9B,iDAAgD;AAAvC,8GAAA,aAAa,OAAA;AAGtB,8DAA2D;AAAlD,oHAAA,eAAe,OAAA;AAMxB,kEAGoC;AAFlC,yIAAA,kCAAkC,OAAA;AAClC,wIAAA,iCAAiC,OAAA;AAGnC,iCAAuC;AAA9B,qGAAA,YAAY,OAAA","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport type {\n  Sum,\n  LastValue,\n  Histogram,\n  ExponentialHistogram,\n} from './aggregator/types';\n\nexport type {\n  AggregationSelector,\n  AggregationTemporalitySelector,\n} from './export/AggregationSelector';\n\nexport { AggregationTemporality } from './export/AggregationTemporality';\n\nexport { DataPointType, InstrumentType } from './export/MetricData';\nexport type {\n  DataPoint,\n  SumMetricData,\n  GaugeMetricData,\n  HistogramMetricData,\n  ExponentialHistogramMetricData,\n  ResourceMetrics,\n  ScopeMetrics,\n  MetricData,\n  MetricDescriptor,\n  CollectionResult,\n} from './export/MetricData';\n\nexport type { PushMetricExporter } from './export/MetricExporter';\n\nexport { MetricReader } from './export/MetricReader';\nexport type { IMetricReader, MetricReaderOptions } from './export/MetricReader';\n\nexport { PeriodicExportingMetricReader } from './export/PeriodicExportingMetricReader';\nexport type { PeriodicExportingMetricReaderOptions } from './export/PeriodicExportingMetricReader';\n\nexport { InMemoryMetricExporter } from './export/InMemoryMetricExporter';\n\nexport { ConsoleMetricExporter } from './export/ConsoleMetricExporter';\n\nexport type {\n  MetricCollectOptions,\n  MetricProducer,\n} from './export/MetricProducer';\n\nexport { MeterProvider } from './MeterProvider';\nexport type { MeterProviderOptions } from './MeterProvider';\n\nexport { AggregationType } from './view/AggregationOption';\nexport type { AggregationOption } from './view/AggregationOption';\n\nexport type { ViewOptions } from './view/View';\n\nexport type { IAttributesProcessor } from './view/AttributesProcessor';\nexport {\n  createAllowListAttributesProcessor,\n  createDenyListAttributesProcessor,\n} from './view/AttributesProcessor';\n\nexport { TimeoutError } from './utils';\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/src/state/AsyncMetricStorage.d.ts

@@ -0,0 +1,32 @@
+import { HrTime } from '@opentelemetry/api';
+import { Accumulation, Aggregator } from '../aggregator/types';
+import { InstrumentDescriptor } from '../InstrumentDescriptor';
+import { MetricStorage } from './MetricStorage';
+import { MetricData } from '../export/MetricData';
+import { Maybe } from '../utils';
+import { MetricCollectorHandle } from './MetricCollector';
+import { AttributeHashMap } from './HashMap';
+import { AsyncWritableMetricStorage } from './WritableMetricStorage';
+import { IAttributesProcessor } from '../view/AttributesProcessor';
+/**
+ * Internal interface.
+ *
+ * Stores and aggregates {@link MetricData} for asynchronous instruments.
+ */
+export declare class AsyncMetricStorage<T extends Maybe<Accumulation>> extends MetricStorage implements AsyncWritableMetricStorage {
+    private _attributesProcessor;
+    private _aggregationCardinalityLimit?;
+    private _deltaMetricStorage;
+    private _temporalMetricStorage;
+    constructor(_instrumentDescriptor: InstrumentDescriptor, aggregator: Aggregator<T>, _attributesProcessor: IAttributesProcessor, collectorHandles: MetricCollectorHandle[], _aggregationCardinalityLimit?: number | undefined);
+    record(measurements: AttributeHashMap<number>, observationTime: HrTime): void;
+    /**
+     * Collects the metrics from this storage. The ObservableCallback is invoked
+     * during the collection.
+     *
+     * Note: This is a stateful operation and may reset any interval-related
+     * state for the MetricCollector.
+     */
+    collect(collector: MetricCollectorHandle, collectionTime: HrTime): Maybe<MetricData>;
+}
+//# sourceMappingURL=AsyncMetricStorage.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/src/state/AsyncMetricStorage.js

@@ -0,0 +1,60 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncMetricStorage = void 0;
+const MetricStorage_1 = require("./MetricStorage");
+const DeltaMetricProcessor_1 = require("./DeltaMetricProcessor");
+const TemporalMetricProcessor_1 = require("./TemporalMetricProcessor");
+const HashMap_1 = require("./HashMap");
+/**
+ * Internal interface.
+ *
+ * Stores and aggregates {@link MetricData} for asynchronous instruments.
+ */
+class AsyncMetricStorage extends MetricStorage_1.MetricStorage {
+    _attributesProcessor;
+    _aggregationCardinalityLimit;
+    _deltaMetricStorage;
+    _temporalMetricStorage;
+    constructor(_instrumentDescriptor, aggregator, _attributesProcessor, collectorHandles, _aggregationCardinalityLimit) {
+        super(_instrumentDescriptor);
+        this._attributesProcessor = _attributesProcessor;
+        this._aggregationCardinalityLimit = _aggregationCardinalityLimit;
+        this._deltaMetricStorage = new DeltaMetricProcessor_1.DeltaMetricProcessor(aggregator, this._aggregationCardinalityLimit);
+        this._temporalMetricStorage = new TemporalMetricProcessor_1.TemporalMetricProcessor(aggregator, collectorHandles);
+    }
+    record(measurements, observationTime) {
+        const processed = new HashMap_1.AttributeHashMap();
+        Array.from(measurements.entries()).forEach(([attributes, value]) => {
+            processed.set(this._attributesProcessor.process(attributes), value);
+        });
+        this._deltaMetricStorage.batchCumulate(processed, observationTime);
+    }
+    /**
+     * Collects the metrics from this storage. The ObservableCallback is invoked
+     * during the collection.
+     *
+     * Note: This is a stateful operation and may reset any interval-related
+     * state for the MetricCollector.
+     */
+    collect(collector, collectionTime) {
+        const accumulations = this._deltaMetricStorage.collect();
+        return this._temporalMetricStorage.buildMetrics(collector, this._instrumentDescriptor, accumulations, collectionTime);
+    }
+}
+exports.AsyncMetricStorage = AsyncMetricStorage;
+//# sourceMappingURL=AsyncMetricStorage.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/src/state/AsyncMetricStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncMetricStorage.js","sourceRoot":"","sources":["../../../src/state/AsyncMetricStorage.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAKH,mDAAgD;AAEhD,iEAA8D;AAC9D,uEAAoE;AAGpE,uCAA6C;AAI7C;;;;GAIG;AACH,MAAa,kBACX,SAAQ,6BAAa;IASX;IAEA;IARF,mBAAmB,CAA0B;IAC7C,sBAAsB,CAA6B;IAE3D,YACE,qBAA2C,EAC3C,UAAyB,EACjB,oBAA0C,EAClD,gBAAyC,EACjC,4BAAqC;QAE7C,KAAK,CAAC,qBAAqB,CAAC,CAAC;QAJrB,yBAAoB,GAApB,oBAAoB,CAAsB;QAE1C,iCAA4B,GAA5B,4BAA4B,CAAS;QAG7C,IAAI,CAAC,mBAAmB,GAAG,IAAI,2CAAoB,CACjD,UAAU,EACV,IAAI,CAAC,4BAA4B,CAClC,CAAC;QACF,IAAI,CAAC,sBAAsB,GAAG,IAAI,iDAAuB,CACvD,UAAU,EACV,gBAAgB,CACjB,CAAC;IACJ,CAAC;IAED,MAAM,CAAC,YAAsC,EAAE,eAAuB;QACpE,MAAM,SAAS,GAAG,IAAI,0BAAgB,EAAU,CAAC;QACjD,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,EAAE,KAAK,CAAC,EAAE,EAAE;YACjE,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC,CAAC;QACtE,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,mBAAmB,CAAC,aAAa,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;IACrE,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CACL,SAAgC,EAChC,cAAsB;QAEtB,MAAM,aAAa,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,CAAC;QAEzD,OAAO,IAAI,CAAC,sBAAsB,CAAC,YAAY,CAC7C,SAAS,EACT,IAAI,CAAC,qBAAqB,EAC1B,aAAa,EACb,cAAc,CACf,CAAC;IACJ,CAAC;CACF;AArDD,gDAqDC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { HrTime } from '@opentelemetry/api';\nimport { Accumulation, Aggregator } from '../aggregator/types';\nimport { InstrumentDescriptor } from '../InstrumentDescriptor';\nimport { MetricStorage } from './MetricStorage';\nimport { MetricData } from '../export/MetricData';\nimport { DeltaMetricProcessor } from './DeltaMetricProcessor';\nimport { TemporalMetricProcessor } from './TemporalMetricProcessor';\nimport { Maybe } from '../utils';\nimport { MetricCollectorHandle } from './MetricCollector';\nimport { AttributeHashMap } from './HashMap';\nimport { AsyncWritableMetricStorage } from './WritableMetricStorage';\nimport { IAttributesProcessor } from '../view/AttributesProcessor';\n\n/**\n * Internal interface.\n *\n * Stores and aggregates {@link MetricData} for asynchronous instruments.\n */\nexport class AsyncMetricStorage<T extends Maybe<Accumulation>>\n  extends MetricStorage\n  implements AsyncWritableMetricStorage\n{\n  private _deltaMetricStorage: DeltaMetricProcessor<T>;\n  private _temporalMetricStorage: TemporalMetricProcessor<T>;\n\n  constructor(\n    _instrumentDescriptor: InstrumentDescriptor,\n    aggregator: Aggregator<T>,\n    private _attributesProcessor: IAttributesProcessor,\n    collectorHandles: MetricCollectorHandle[],\n    private _aggregationCardinalityLimit?: number\n  ) {\n    super(_instrumentDescriptor);\n    this._deltaMetricStorage = new DeltaMetricProcessor(\n      aggregator,\n      this._aggregationCardinalityLimit\n    );\n    this._temporalMetricStorage = new TemporalMetricProcessor(\n      aggregator,\n      collectorHandles\n    );\n  }\n\n  record(measurements: AttributeHashMap<number>, observationTime: HrTime) {\n    const processed = new AttributeHashMap<number>();\n    Array.from(measurements.entries()).forEach(([attributes, value]) => {\n      processed.set(this._attributesProcessor.process(attributes), value);\n    });\n    this._deltaMetricStorage.batchCumulate(processed, observationTime);\n  }\n\n  /**\n   * Collects the metrics from this storage. The ObservableCallback is invoked\n   * during the collection.\n   *\n   * Note: This is a stateful operation and may reset any interval-related\n   * state for the MetricCollector.\n   */\n  collect(\n    collector: MetricCollectorHandle,\n    collectionTime: HrTime\n  ): Maybe<MetricData> {\n    const accumulations = this._deltaMetricStorage.collect();\n\n    return this._temporalMetricStorage.buildMetrics(\n      collector,\n      this._instrumentDescriptor,\n      accumulations,\n      collectionTime\n    );\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/src/state/DeltaMetricProcessor.d.ts

@@ -0,0 +1,28 @@
+import { Context, HrTime, Attributes } from '@opentelemetry/api';
+import { Maybe } from '../utils';
+import { Accumulation, Aggregator } from '../aggregator/types';
+import { AttributeHashMap } from './HashMap';
+/**
+ * Internal interface.
+ *
+ * Allows synchronous collection of metrics. This processor should allow
+ * allocation of new aggregation cells for metrics and convert cumulative
+ * recording to delta data points.
+ */
+export declare class DeltaMetricProcessor<T extends Maybe<Accumulation>> {
+    private _aggregator;
+    private _activeCollectionStorage;
+    private _cumulativeMemoStorage;
+    private _cardinalityLimit;
+    private _overflowAttributes;
+    private _overflowHashCode;
+    constructor(_aggregator: Aggregator<T>, aggregationCardinalityLimit?: number);
+    record(value: number, attributes: Attributes, _context: Context, collectionTime: HrTime): void;
+    batchCumulate(measurements: AttributeHashMap<number>, collectionTime: HrTime): void;
+    /**
+     * Returns a collection of delta metrics. Start time is the when first
+     * time event collected.
+     */
+    collect(): AttributeHashMap<T>;
+}
+//# sourceMappingURL=DeltaMetricProcessor.d.ts.map