decocms 2.333.0 → 2.334.0

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

@@ -0,0 +1,103 @@
+"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.DeltaMetricProcessor = void 0;
+const utils_1 = require("../utils");
+const HashMap_1 = require("./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.
+ */
+class DeltaMetricProcessor {
+    _aggregator;
+    _activeCollectionStorage = new HashMap_1.AttributeHashMap();
+    // TODO: find a reasonable mean to clean the memo;
+    // https://github.com/open-telemetry/opentelemetry-specification/pull/2208
+    _cumulativeMemoStorage = new HashMap_1.AttributeHashMap();
+    _cardinalityLimit;
+    _overflowAttributes = { 'otel.metric.overflow': true };
+    _overflowHashCode;
+    constructor(_aggregator, aggregationCardinalityLimit) {
+        this._aggregator = _aggregator;
+        this._cardinalityLimit = (aggregationCardinalityLimit ?? 2000) - 1;
+        this._overflowHashCode = (0, utils_1.hashAttributes)(this._overflowAttributes);
+    }
+    record(value, attributes, _context, collectionTime) {
+        let accumulation = this._activeCollectionStorage.get(attributes);
+        if (!accumulation) {
+            if (this._activeCollectionStorage.size >= this._cardinalityLimit) {
+                const overflowAccumulation = this._activeCollectionStorage.getOrDefault(this._overflowAttributes, () => this._aggregator.createAccumulation(collectionTime));
+                overflowAccumulation?.record(value);
+                return;
+            }
+            accumulation = this._aggregator.createAccumulation(collectionTime);
+            this._activeCollectionStorage.set(attributes, accumulation);
+        }
+        accumulation?.record(value);
+    }
+    batchCumulate(measurements, collectionTime) {
+        Array.from(measurements.entries()).forEach(([attributes, value, hashCode]) => {
+            const accumulation = this._aggregator.createAccumulation(collectionTime);
+            accumulation?.record(value);
+            let delta = accumulation;
+            // Diff with recorded cumulative memo.
+            if (this._cumulativeMemoStorage.has(attributes, hashCode)) {
+                // has() returned true, previous is present.
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const previous = this._cumulativeMemoStorage.get(attributes, hashCode);
+                delta = this._aggregator.diff(previous, accumulation);
+            }
+            else {
+                // If the cardinality limit is reached, we need to change the attributes
+                if (this._cumulativeMemoStorage.size >= this._cardinalityLimit) {
+                    attributes = this._overflowAttributes;
+                    hashCode = this._overflowHashCode;
+                    if (this._cumulativeMemoStorage.has(attributes, hashCode)) {
+                        // has() returned true, previous is present.
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                        const previous = this._cumulativeMemoStorage.get(attributes, hashCode);
+                        delta = this._aggregator.diff(previous, accumulation);
+                    }
+                }
+            }
+            // Merge with uncollected active delta.
+            if (this._activeCollectionStorage.has(attributes, hashCode)) {
+                // has() returned true, active is present.
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const active = this._activeCollectionStorage.get(attributes, hashCode);
+                delta = this._aggregator.merge(active, delta);
+            }
+            // Save the current record and the delta record.
+            this._cumulativeMemoStorage.set(attributes, accumulation, hashCode);
+            this._activeCollectionStorage.set(attributes, delta, hashCode);
+        });
+    }
+    /**
+     * Returns a collection of delta metrics. Start time is the when first
+     * time event collected.
+     */
+    collect() {
+        const unreportedDelta = this._activeCollectionStorage;
+        this._activeCollectionStorage = new HashMap_1.AttributeHashMap();
+        return unreportedDelta;
+    }
+}
+exports.DeltaMetricProcessor = DeltaMetricProcessor;
+//# sourceMappingURL=DeltaMetricProcessor.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DeltaMetricProcessor.js","sourceRoot":"","sources":["../../../src/state/DeltaMetricProcessor.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 { Context, HrTime, Attributes } from '@opentelemetry/api';\nimport { Maybe, hashAttributes } from '../utils';\nimport { Accumulation, Aggregator } from '../aggregator/types';\nimport { AttributeHashMap } from './HashMap';\n\n/**\n * Internal interface.\n *\n * Allows synchronous collection of metrics. This processor should allow\n * allocation of new aggregation cells for metrics and convert cumulative\n * recording to delta data points.\n */\nexport class DeltaMetricProcessor<T extends Maybe<Accumulation>> {\n  private _activeCollectionStorage = new AttributeHashMap<T>();\n  // TODO: find a reasonable mean to clean the memo;\n  // https://github.com/open-telemetry/opentelemetry-specification/pull/2208\n  private _cumulativeMemoStorage = new AttributeHashMap<T>();\n  private _cardinalityLimit: number;\n  private _overflowAttributes = { 'otel.metric.overflow': true };\n  private _overflowHashCode: string;\n\n  constructor(\n    private _aggregator: Aggregator<T>,\n    aggregationCardinalityLimit?: number\n  ) {\n    this._cardinalityLimit = (aggregationCardinalityLimit ?? 2000) - 1;\n    this._overflowHashCode = hashAttributes(this._overflowAttributes);\n  }\n\n  record(\n    value: number,\n    attributes: Attributes,\n    _context: Context,\n    collectionTime: HrTime\n  ) {\n    let accumulation = this._activeCollectionStorage.get(attributes);\n\n    if (!accumulation) {\n      if (this._activeCollectionStorage.size >= this._cardinalityLimit) {\n        const overflowAccumulation = this._activeCollectionStorage.getOrDefault(\n          this._overflowAttributes,\n          () => this._aggregator.createAccumulation(collectionTime)\n        );\n        overflowAccumulation?.record(value);\n        return;\n      }\n\n      accumulation = this._aggregator.createAccumulation(collectionTime);\n      this._activeCollectionStorage.set(attributes, accumulation);\n    }\n\n    accumulation?.record(value);\n  }\n\n  batchCumulate(\n    measurements: AttributeHashMap<number>,\n    collectionTime: HrTime\n  ) {\n    Array.from(measurements.entries()).forEach(\n      ([attributes, value, hashCode]) => {\n        const accumulation =\n          this._aggregator.createAccumulation(collectionTime);\n        accumulation?.record(value);\n        let delta = accumulation;\n        // Diff with recorded cumulative memo.\n        if (this._cumulativeMemoStorage.has(attributes, hashCode)) {\n          // has() returned true, previous is present.\n          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n          const previous = this._cumulativeMemoStorage.get(\n            attributes,\n            hashCode\n          )!;\n          delta = this._aggregator.diff(previous, accumulation);\n        } else {\n          // If the cardinality limit is reached, we need to change the attributes\n          if (this._cumulativeMemoStorage.size >= this._cardinalityLimit) {\n            attributes = this._overflowAttributes;\n            hashCode = this._overflowHashCode;\n            if (this._cumulativeMemoStorage.has(attributes, hashCode)) {\n              // has() returned true, previous is present.\n              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n              const previous = this._cumulativeMemoStorage.get(\n                attributes,\n                hashCode\n              )!;\n              delta = this._aggregator.diff(previous, accumulation);\n            }\n          }\n        }\n        // Merge with uncollected active delta.\n        if (this._activeCollectionStorage.has(attributes, hashCode)) {\n          // has() returned true, active is present.\n          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n          const active = this._activeCollectionStorage.get(\n            attributes,\n            hashCode\n          )!;\n          delta = this._aggregator.merge(active, delta);\n        }\n\n        // Save the current record and the delta record.\n        this._cumulativeMemoStorage.set(attributes, accumulation, hashCode);\n        this._activeCollectionStorage.set(attributes, delta, hashCode);\n      }\n    );\n  }\n\n  /**\n   * Returns a collection of delta metrics. Start time is the when first\n   * time event collected.\n   */\n  collect() {\n    const unreportedDelta = this._activeCollectionStorage;\n    this._activeCollectionStorage = new AttributeHashMap();\n\n    return unreportedDelta;\n  }\n}\n"]}

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

@@ -0,0 +1,21 @@
+import { Attributes } from '@opentelemetry/api';
+export interface Hash<ValueType, HashCodeType> {
+    (value: ValueType): HashCodeType;
+}
+export declare class HashMap<KeyType, ValueType, HashCodeType> {
+    private _hash;
+    private _valueMap;
+    private _keyMap;
+    constructor(_hash: Hash<KeyType, HashCodeType>);
+    get(key: KeyType, hashCode?: HashCodeType): ValueType | undefined;
+    getOrDefault(key: KeyType, defaultFactory: () => ValueType): ValueType | undefined;
+    set(key: KeyType, value: ValueType, hashCode?: HashCodeType): void;
+    has(key: KeyType, hashCode?: HashCodeType): boolean;
+    keys(): IterableIterator<[KeyType, HashCodeType]>;
+    entries(): IterableIterator<[KeyType, ValueType, HashCodeType]>;
+    get size(): number;
+}
+export declare class AttributeHashMap<ValueType> extends HashMap<Attributes, ValueType, string> {
+    constructor();
+}
+//# sourceMappingURL=HashMap.d.ts.map

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

@@ -0,0 +1,83 @@
+"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.AttributeHashMap = exports.HashMap = void 0;
+const utils_1 = require("../utils");
+class HashMap {
+    _hash;
+    _valueMap = new Map();
+    _keyMap = new Map();
+    constructor(_hash) {
+        this._hash = _hash;
+    }
+    get(key, hashCode) {
+        hashCode ??= this._hash(key);
+        return this._valueMap.get(hashCode);
+    }
+    getOrDefault(key, defaultFactory) {
+        const hash = this._hash(key);
+        if (this._valueMap.has(hash)) {
+            return this._valueMap.get(hash);
+        }
+        const val = defaultFactory();
+        if (!this._keyMap.has(hash)) {
+            this._keyMap.set(hash, key);
+        }
+        this._valueMap.set(hash, val);
+        return val;
+    }
+    set(key, value, hashCode) {
+        hashCode ??= this._hash(key);
+        if (!this._keyMap.has(hashCode)) {
+            this._keyMap.set(hashCode, key);
+        }
+        this._valueMap.set(hashCode, value);
+    }
+    has(key, hashCode) {
+        hashCode ??= this._hash(key);
+        return this._valueMap.has(hashCode);
+    }
+    *keys() {
+        const keyIterator = this._keyMap.entries();
+        let next = keyIterator.next();
+        while (next.done !== true) {
+            yield [next.value[1], next.value[0]];
+            next = keyIterator.next();
+        }
+    }
+    *entries() {
+        const valueIterator = this._valueMap.entries();
+        let next = valueIterator.next();
+        while (next.done !== true) {
+            // next.value[0] here can not be undefined
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            yield [this._keyMap.get(next.value[0]), next.value[1], next.value[0]];
+            next = valueIterator.next();
+        }
+    }
+    get size() {
+        return this._valueMap.size;
+    }
+}
+exports.HashMap = HashMap;
+class AttributeHashMap extends HashMap {
+    constructor() {
+        super(utils_1.hashAttributes);
+    }
+}
+exports.AttributeHashMap = AttributeHashMap;
+//# sourceMappingURL=HashMap.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"HashMap.js","sourceRoot":"","sources":["../../../src/state/HashMap.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAGH,oCAA0C;AAM1C,MAAa,OAAO;IAIE;IAHZ,SAAS,GAAG,IAAI,GAAG,EAA2B,CAAC;IAC/C,OAAO,GAAG,IAAI,GAAG,EAAyB,CAAC;IAEnD,YAAoB,KAAkC;QAAlC,UAAK,GAAL,KAAK,CAA6B;IAAG,CAAC;IAE1D,GAAG,CAAC,GAAY,EAAE,QAAuB;QACvC,QAAQ,KAAK,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC7B,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACtC,CAAC;IAED,YAAY,CAAC,GAAY,EAAE,cAA+B;QACxD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC7B,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;YAC5B,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;SACjC;QACD,MAAM,GAAG,GAAG,cAAc,EAAE,CAAC;QAC7B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;YAC3B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;SAC7B;QACD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAC9B,OAAO,GAAG,CAAC;IACb,CAAC;IAED,GAAG,CAAC,GAAY,EAAE,KAAgB,EAAE,QAAuB;QACzD,QAAQ,KAAK,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC7B,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE;YAC/B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;SACjC;QACD,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,GAAG,CAAC,GAAY,EAAE,QAAuB;QACvC,QAAQ,KAAK,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC7B,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IACtC,CAAC;IAED,CAAC,IAAI;QACH,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;QAC3C,IAAI,IAAI,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC;QAC9B,OAAO,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE;YACzB,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YACrC,IAAI,GAAG,WAAW,CAAC,IAAI,EAAE,CAAC;SAC3B;IACH,CAAC;IAED,CAAC,OAAO;QACN,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;QAC/C,IAAI,IAAI,GAAG,aAAa,CAAC,IAAI,EAAE,CAAC;QAChC,OAAO,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE;YACzB,0CAA0C;YAC1C,oEAAoE;YACpE,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAE,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YACvE,IAAI,GAAG,aAAa,CAAC,IAAI,EAAE,CAAC;SAC7B;IACH,CAAC;IAED,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC;IAC7B,CAAC;CACF;AA5DD,0BA4DC;AAED,MAAa,gBAA4B,SAAQ,OAIhD;IACC;QACE,KAAK,CAAC,sBAAc,CAAC,CAAC;IACxB,CAAC;CACF;AARD,4CAQC","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 { Attributes } from '@opentelemetry/api';\nimport { hashAttributes } from '../utils';\n\nexport interface Hash<ValueType, HashCodeType> {\n  (value: ValueType): HashCodeType;\n}\n\nexport class HashMap<KeyType, ValueType, HashCodeType> {\n  private _valueMap = new Map<HashCodeType, ValueType>();\n  private _keyMap = new Map<HashCodeType, KeyType>();\n\n  constructor(private _hash: Hash<KeyType, HashCodeType>) {}\n\n  get(key: KeyType, hashCode?: HashCodeType) {\n    hashCode ??= this._hash(key);\n    return this._valueMap.get(hashCode);\n  }\n\n  getOrDefault(key: KeyType, defaultFactory: () => ValueType) {\n    const hash = this._hash(key);\n    if (this._valueMap.has(hash)) {\n      return this._valueMap.get(hash);\n    }\n    const val = defaultFactory();\n    if (!this._keyMap.has(hash)) {\n      this._keyMap.set(hash, key);\n    }\n    this._valueMap.set(hash, val);\n    return val;\n  }\n\n  set(key: KeyType, value: ValueType, hashCode?: HashCodeType) {\n    hashCode ??= this._hash(key);\n    if (!this._keyMap.has(hashCode)) {\n      this._keyMap.set(hashCode, key);\n    }\n    this._valueMap.set(hashCode, value);\n  }\n\n  has(key: KeyType, hashCode?: HashCodeType) {\n    hashCode ??= this._hash(key);\n    return this._valueMap.has(hashCode);\n  }\n\n  *keys(): IterableIterator<[KeyType, HashCodeType]> {\n    const keyIterator = this._keyMap.entries();\n    let next = keyIterator.next();\n    while (next.done !== true) {\n      yield [next.value[1], next.value[0]];\n      next = keyIterator.next();\n    }\n  }\n\n  *entries(): IterableIterator<[KeyType, ValueType, HashCodeType]> {\n    const valueIterator = this._valueMap.entries();\n    let next = valueIterator.next();\n    while (next.done !== true) {\n      // next.value[0] here can not be undefined\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      yield [this._keyMap.get(next.value[0])!, next.value[1], next.value[0]];\n      next = valueIterator.next();\n    }\n  }\n\n  get size() {\n    return this._valueMap.size;\n  }\n}\n\nexport class AttributeHashMap<ValueType> extends HashMap<\n  Attributes,\n  ValueType,\n  string\n> {\n  constructor() {\n    super(hashAttributes);\n  }\n}\n"]}

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

@@ -0,0 +1,20 @@
+import { InstrumentationScope } from '@opentelemetry/core';
+import { Resource } from '@opentelemetry/resources';
+import { ViewRegistry } from '../view/ViewRegistry';
+import { MeterSharedState } from './MeterSharedState';
+import { MetricCollector, MetricCollectorHandle } from './MetricCollector';
+import { Aggregation } from '../view/Aggregation';
+import { InstrumentType } from '../export/MetricData';
+/**
+ * An internal record for shared meter provider states.
+ */
+export declare class MeterProviderSharedState {
+    resource: Resource;
+    viewRegistry: ViewRegistry;
+    metricCollectors: MetricCollector[];
+    meterSharedStates: Map<string, MeterSharedState>;
+    constructor(resource: Resource);
+    getMeterSharedState(instrumentationScope: InstrumentationScope): MeterSharedState;
+    selectAggregations(instrumentType: InstrumentType): [MetricCollectorHandle, Aggregation][];
+}
+//# sourceMappingURL=MeterProviderSharedState.d.ts.map

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

@@ -0,0 +1,55 @@
+"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.MeterProviderSharedState = void 0;
+const utils_1 = require("../utils");
+const ViewRegistry_1 = require("../view/ViewRegistry");
+const MeterSharedState_1 = require("./MeterSharedState");
+const AggregationOption_1 = require("../view/AggregationOption");
+/**
+ * An internal record for shared meter provider states.
+ */
+class MeterProviderSharedState {
+    resource;
+    viewRegistry = new ViewRegistry_1.ViewRegistry();
+    metricCollectors = [];
+    meterSharedStates = new Map();
+    constructor(resource) {
+        this.resource = resource;
+    }
+    getMeterSharedState(instrumentationScope) {
+        const id = (0, utils_1.instrumentationScopeId)(instrumentationScope);
+        let meterSharedState = this.meterSharedStates.get(id);
+        if (meterSharedState == null) {
+            meterSharedState = new MeterSharedState_1.MeterSharedState(this, instrumentationScope);
+            this.meterSharedStates.set(id, meterSharedState);
+        }
+        return meterSharedState;
+    }
+    selectAggregations(instrumentType) {
+        const result = [];
+        for (const collector of this.metricCollectors) {
+            result.push([
+                collector,
+                (0, AggregationOption_1.toAggregation)(collector.selectAggregation(instrumentType)),
+            ]);
+        }
+        return result;
+    }
+}
+exports.MeterProviderSharedState = MeterProviderSharedState;
+//# sourceMappingURL=MeterProviderSharedState.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MeterProviderSharedState.js","sourceRoot":"","sources":["../../../src/state/MeterProviderSharedState.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAIH,oCAAkD;AAClD,uDAAoD;AACpD,yDAAsD;AAEtD,iEAA0D;AAI1D;;GAEG;AACH,MAAa,wBAAwB;IAOhB;IANnB,YAAY,GAAG,IAAI,2BAAY,EAAE,CAAC;IAElC,gBAAgB,GAAsB,EAAE,CAAC;IAEzC,iBAAiB,GAAkC,IAAI,GAAG,EAAE,CAAC;IAE7D,YAAmB,QAAkB;QAAlB,aAAQ,GAAR,QAAQ,CAAU;IAAG,CAAC;IAEzC,mBAAmB,CAAC,oBAA0C;QAC5D,MAAM,EAAE,GAAG,IAAA,8BAAsB,EAAC,oBAAoB,CAAC,CAAC;QACxD,IAAI,gBAAgB,GAAG,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACtD,IAAI,gBAAgB,IAAI,IAAI,EAAE;YAC5B,gBAAgB,GAAG,IAAI,mCAAgB,CAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC;YACpE,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,EAAE,EAAE,gBAAgB,CAAC,CAAC;SAClD;QACD,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IAED,kBAAkB,CAAC,cAA8B;QAC/C,MAAM,MAAM,GAA2C,EAAE,CAAC;QAC1D,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,gBAAgB,EAAE;YAC7C,MAAM,CAAC,IAAI,CAAC;gBACV,SAAS;gBACT,IAAA,iCAAa,EAAC,SAAS,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC;aAC3D,CAAC,CAAC;SACJ;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AA7BD,4DA6BC","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 { InstrumentationScope } from '@opentelemetry/core';\nimport { Resource } from '@opentelemetry/resources';\nimport { instrumentationScopeId } from '../utils';\nimport { ViewRegistry } from '../view/ViewRegistry';\nimport { MeterSharedState } from './MeterSharedState';\nimport { MetricCollector, MetricCollectorHandle } from './MetricCollector';\nimport { toAggregation } from '../view/AggregationOption';\nimport { Aggregation } from '../view/Aggregation';\nimport { InstrumentType } from '../export/MetricData';\n\n/**\n * An internal record for shared meter provider states.\n */\nexport class MeterProviderSharedState {\n  viewRegistry = new ViewRegistry();\n\n  metricCollectors: MetricCollector[] = [];\n\n  meterSharedStates: Map<string, MeterSharedState> = new Map();\n\n  constructor(public resource: Resource) {}\n\n  getMeterSharedState(instrumentationScope: InstrumentationScope) {\n    const id = instrumentationScopeId(instrumentationScope);\n    let meterSharedState = this.meterSharedStates.get(id);\n    if (meterSharedState == null) {\n      meterSharedState = new MeterSharedState(this, instrumentationScope);\n      this.meterSharedStates.set(id, meterSharedState);\n    }\n    return meterSharedState;\n  }\n\n  selectAggregations(instrumentType: InstrumentType) {\n    const result: [MetricCollectorHandle, Aggregation][] = [];\n    for (const collector of this.metricCollectors) {\n      result.push([\n        collector,\n        toAggregation(collector.selectAggregation(instrumentType)),\n      ]);\n    }\n    return result;\n  }\n}\n"]}

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

@@ -0,0 +1,42 @@
+import { HrTime } from '@opentelemetry/api';
+import { InstrumentationScope } from '@opentelemetry/core';
+import { MetricCollectOptions } from '../export/MetricProducer';
+import { ScopeMetrics } from '../export/MetricData';
+import { InstrumentDescriptor } from '../InstrumentDescriptor';
+import { Meter } from '../Meter';
+import { Maybe } from '../utils';
+import { AsyncMetricStorage } from './AsyncMetricStorage';
+import { MeterProviderSharedState } from './MeterProviderSharedState';
+import { MetricCollectorHandle } from './MetricCollector';
+import { MetricStorageRegistry } from './MetricStorageRegistry';
+import { MultiMetricStorage } from './MultiWritableMetricStorage';
+import { ObservableRegistry } from './ObservableRegistry';
+import { SyncMetricStorage } from './SyncMetricStorage';
+import { Accumulation } from '../aggregator/types';
+/**
+ * An internal record for shared meter provider states.
+ */
+export declare class MeterSharedState {
+    private _meterProviderSharedState;
+    private _instrumentationScope;
+    metricStorageRegistry: MetricStorageRegistry;
+    observableRegistry: ObservableRegistry;
+    meter: Meter;
+    constructor(_meterProviderSharedState: MeterProviderSharedState, _instrumentationScope: InstrumentationScope);
+    registerMetricStorage(descriptor: InstrumentDescriptor): MultiMetricStorage | SyncMetricStorage<Maybe<Accumulation>>;
+    registerAsyncMetricStorage(descriptor: InstrumentDescriptor): AsyncMetricStorage<Maybe<Accumulation>>[];
+    /**
+     * @param collector opaque handle of {@link MetricCollector} which initiated the collection.
+     * @param collectionTime the HrTime at which the collection was initiated.
+     * @param options options for collection.
+     * @returns the list of metric data collected.
+     */
+    collect(collector: MetricCollectorHandle, collectionTime: HrTime, options?: MetricCollectOptions): Promise<ScopeMetricsResult | null>;
+    private _registerMetricStorage;
+}
+interface ScopeMetricsResult {
+    scopeMetrics?: ScopeMetrics;
+    errors: unknown[];
+}
+export {};
+//# sourceMappingURL=MeterSharedState.d.ts.map

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

@@ -0,0 +1,120 @@
+"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.MeterSharedState = void 0;
+const InstrumentDescriptor_1 = require("../InstrumentDescriptor");
+const Meter_1 = require("../Meter");
+const utils_1 = require("../utils");
+const AsyncMetricStorage_1 = require("./AsyncMetricStorage");
+const MetricStorageRegistry_1 = require("./MetricStorageRegistry");
+const MultiWritableMetricStorage_1 = require("./MultiWritableMetricStorage");
+const ObservableRegistry_1 = require("./ObservableRegistry");
+const SyncMetricStorage_1 = require("./SyncMetricStorage");
+const AttributesProcessor_1 = require("../view/AttributesProcessor");
+/**
+ * An internal record for shared meter provider states.
+ */
+class MeterSharedState {
+    _meterProviderSharedState;
+    _instrumentationScope;
+    metricStorageRegistry = new MetricStorageRegistry_1.MetricStorageRegistry();
+    observableRegistry = new ObservableRegistry_1.ObservableRegistry();
+    meter;
+    constructor(_meterProviderSharedState, _instrumentationScope) {
+        this._meterProviderSharedState = _meterProviderSharedState;
+        this._instrumentationScope = _instrumentationScope;
+        this.meter = new Meter_1.Meter(this);
+    }
+    registerMetricStorage(descriptor) {
+        const storages = this._registerMetricStorage(descriptor, SyncMetricStorage_1.SyncMetricStorage);
+        if (storages.length === 1) {
+            return storages[0];
+        }
+        return new MultiWritableMetricStorage_1.MultiMetricStorage(storages);
+    }
+    registerAsyncMetricStorage(descriptor) {
+        const storages = this._registerMetricStorage(descriptor, AsyncMetricStorage_1.AsyncMetricStorage);
+        return storages;
+    }
+    /**
+     * @param collector opaque handle of {@link MetricCollector} which initiated the collection.
+     * @param collectionTime the HrTime at which the collection was initiated.
+     * @param options options for collection.
+     * @returns the list of metric data collected.
+     */
+    async collect(collector, collectionTime, options) {
+        /**
+         * 1. Call all observable callbacks first.
+         * 2. Collect metric result for the collector.
+         */
+        const errors = await this.observableRegistry.observe(collectionTime, options?.timeoutMillis);
+        const storages = this.metricStorageRegistry.getStorages(collector);
+        // prevent more allocations if there are no storages.
+        if (storages.length === 0) {
+            return null;
+        }
+        const metricDataList = storages
+            .map(metricStorage => {
+            return metricStorage.collect(collector, collectionTime);
+        })
+            .filter(utils_1.isNotNullish);
+        // skip this scope if no data was collected (storage created, but no data observed)
+        if (metricDataList.length === 0) {
+            return { errors };
+        }
+        return {
+            scopeMetrics: {
+                scope: this._instrumentationScope,
+                metrics: metricDataList,
+            },
+            errors,
+        };
+    }
+    _registerMetricStorage(descriptor, MetricStorageType) {
+        const views = this._meterProviderSharedState.viewRegistry.findViews(descriptor, this._instrumentationScope);
+        let storages = views.map(view => {
+            const viewDescriptor = (0, InstrumentDescriptor_1.createInstrumentDescriptorWithView)(view, descriptor);
+            const compatibleStorage = this.metricStorageRegistry.findOrUpdateCompatibleStorage(viewDescriptor);
+            if (compatibleStorage != null) {
+                return compatibleStorage;
+            }
+            const aggregator = view.aggregation.createAggregator(viewDescriptor);
+            const viewStorage = new MetricStorageType(viewDescriptor, aggregator, view.attributesProcessor, this._meterProviderSharedState.metricCollectors, view.aggregationCardinalityLimit);
+            this.metricStorageRegistry.register(viewStorage);
+            return viewStorage;
+        });
+        // Fallback to the per-collector aggregations if no view is configured for the instrument.
+        if (storages.length === 0) {
+            const perCollectorAggregations = this._meterProviderSharedState.selectAggregations(descriptor.type);
+            const collectorStorages = perCollectorAggregations.map(([collector, aggregation]) => {
+                const compatibleStorage = this.metricStorageRegistry.findOrUpdateCompatibleCollectorStorage(collector, descriptor);
+                if (compatibleStorage != null) {
+                    return compatibleStorage;
+                }
+                const aggregator = aggregation.createAggregator(descriptor);
+                const cardinalityLimit = collector.selectCardinalityLimit(descriptor.type);
+                const storage = new MetricStorageType(descriptor, aggregator, (0, AttributesProcessor_1.createNoopAttributesProcessor)(), [collector], cardinalityLimit);
+                this.metricStorageRegistry.registerForCollector(collector, storage);
+                return storage;
+            });
+            storages = storages.concat(collectorStorages);
+        }
+        return storages;
+    }
+}
+exports.MeterSharedState = MeterSharedState;
+//# sourceMappingURL=MeterSharedState.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MeterSharedState.js","sourceRoot":"","sources":["../../../src/state/MeterSharedState.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 { HrTime } from '@opentelemetry/api';\nimport { InstrumentationScope } from '@opentelemetry/core';\nimport { MetricCollectOptions } from '../export/MetricProducer';\nimport { ScopeMetrics } from '../export/MetricData';\nimport {\n  createInstrumentDescriptorWithView,\n  InstrumentDescriptor,\n} from '../InstrumentDescriptor';\nimport { Meter } from '../Meter';\nimport { isNotNullish, Maybe } from '../utils';\nimport { AsyncMetricStorage } from './AsyncMetricStorage';\nimport { MeterProviderSharedState } from './MeterProviderSharedState';\nimport { MetricCollectorHandle } from './MetricCollector';\nimport { MetricStorageRegistry } from './MetricStorageRegistry';\nimport { MultiMetricStorage } from './MultiWritableMetricStorage';\nimport { ObservableRegistry } from './ObservableRegistry';\nimport { SyncMetricStorage } from './SyncMetricStorage';\nimport { Accumulation, Aggregator } from '../aggregator/types';\nimport {\n  createNoopAttributesProcessor,\n  IAttributesProcessor,\n} from '../view/AttributesProcessor';\nimport { MetricStorage } from './MetricStorage';\n\n/**\n * An internal record for shared meter provider states.\n */\nexport class MeterSharedState {\n  metricStorageRegistry = new MetricStorageRegistry();\n  observableRegistry = new ObservableRegistry();\n  meter: Meter;\n\n  constructor(\n    private _meterProviderSharedState: MeterProviderSharedState,\n    private _instrumentationScope: InstrumentationScope\n  ) {\n    this.meter = new Meter(this);\n  }\n\n  registerMetricStorage(descriptor: InstrumentDescriptor) {\n    const storages = this._registerMetricStorage(descriptor, SyncMetricStorage);\n\n    if (storages.length === 1) {\n      return storages[0];\n    }\n    return new MultiMetricStorage(storages);\n  }\n\n  registerAsyncMetricStorage(descriptor: InstrumentDescriptor) {\n    const storages = this._registerMetricStorage(\n      descriptor,\n      AsyncMetricStorage\n    );\n\n    return storages;\n  }\n\n  /**\n   * @param collector opaque handle of {@link MetricCollector} which initiated the collection.\n   * @param collectionTime the HrTime at which the collection was initiated.\n   * @param options options for collection.\n   * @returns the list of metric data collected.\n   */\n  async collect(\n    collector: MetricCollectorHandle,\n    collectionTime: HrTime,\n    options?: MetricCollectOptions\n  ): Promise<ScopeMetricsResult | null> {\n    /**\n     * 1. Call all observable callbacks first.\n     * 2. Collect metric result for the collector.\n     */\n    const errors = await this.observableRegistry.observe(\n      collectionTime,\n      options?.timeoutMillis\n    );\n    const storages = this.metricStorageRegistry.getStorages(collector);\n\n    // prevent more allocations if there are no storages.\n    if (storages.length === 0) {\n      return null;\n    }\n\n    const metricDataList = storages\n      .map(metricStorage => {\n        return metricStorage.collect(collector, collectionTime);\n      })\n      .filter(isNotNullish);\n\n    // skip this scope if no data was collected (storage created, but no data observed)\n    if (metricDataList.length === 0) {\n      return { errors };\n    }\n\n    return {\n      scopeMetrics: {\n        scope: this._instrumentationScope,\n        metrics: metricDataList,\n      },\n      errors,\n    };\n  }\n\n  private _registerMetricStorage<\n    MetricStorageType extends MetricStorageConstructor,\n    R extends InstanceType<MetricStorageType>,\n  >(\n    descriptor: InstrumentDescriptor,\n    MetricStorageType: MetricStorageType\n  ): R[] {\n    const views = this._meterProviderSharedState.viewRegistry.findViews(\n      descriptor,\n      this._instrumentationScope\n    );\n    let storages = views.map(view => {\n      const viewDescriptor = createInstrumentDescriptorWithView(\n        view,\n        descriptor\n      );\n      const compatibleStorage =\n        this.metricStorageRegistry.findOrUpdateCompatibleStorage<R>(\n          viewDescriptor\n        );\n      if (compatibleStorage != null) {\n        return compatibleStorage;\n      }\n      const aggregator = view.aggregation.createAggregator(viewDescriptor);\n      const viewStorage = new MetricStorageType(\n        viewDescriptor,\n        aggregator,\n        view.attributesProcessor,\n        this._meterProviderSharedState.metricCollectors,\n        view.aggregationCardinalityLimit\n      ) as R;\n      this.metricStorageRegistry.register(viewStorage);\n      return viewStorage;\n    });\n\n    // Fallback to the per-collector aggregations if no view is configured for the instrument.\n    if (storages.length === 0) {\n      const perCollectorAggregations =\n        this._meterProviderSharedState.selectAggregations(descriptor.type);\n      const collectorStorages = perCollectorAggregations.map(\n        ([collector, aggregation]) => {\n          const compatibleStorage =\n            this.metricStorageRegistry.findOrUpdateCompatibleCollectorStorage<R>(\n              collector,\n              descriptor\n            );\n          if (compatibleStorage != null) {\n            return compatibleStorage;\n          }\n\n          const aggregator = aggregation.createAggregator(descriptor);\n          const cardinalityLimit = collector.selectCardinalityLimit(\n            descriptor.type\n          );\n          const storage = new MetricStorageType(\n            descriptor,\n            aggregator,\n            createNoopAttributesProcessor(),\n            [collector],\n            cardinalityLimit\n          ) as R;\n          this.metricStorageRegistry.registerForCollector(collector, storage);\n          return storage;\n        }\n      );\n      storages = storages.concat(collectorStorages);\n    }\n\n    return storages;\n  }\n}\n\ninterface ScopeMetricsResult {\n  scopeMetrics?: ScopeMetrics;\n  errors: unknown[];\n}\n\ninterface MetricStorageConstructor {\n  new (\n    instrumentDescriptor: InstrumentDescriptor,\n    aggregator: Aggregator<Maybe<Accumulation>>,\n    attributesProcessor: IAttributesProcessor,\n    collectors: MetricCollectorHandle[],\n    aggregationCardinalityLimit?: number\n  ): MetricStorage;\n}\n"]}

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

@@ -0,0 +1,41 @@
+import { AggregationTemporalitySelector } from '../export/AggregationSelector';
+import { CollectionResult, InstrumentType } from '../export/MetricData';
+import { MetricCollectOptions, MetricProducer } from '../export/MetricProducer';
+import { IMetricReader } from '../export/MetricReader';
+import { ForceFlushOptions, ShutdownOptions } from '../types';
+import { MeterProviderSharedState } from './MeterProviderSharedState';
+/**
+ * An internal opaque interface that the MetricReader receives as
+ * MetricProducer. It acts as the storage key to the internal metric stream
+ * state for each MetricReader.
+ */
+export declare class MetricCollector implements MetricProducer {
+    private _sharedState;
+    private _metricReader;
+    constructor(_sharedState: MeterProviderSharedState, _metricReader: IMetricReader);
+    collect(options?: MetricCollectOptions): Promise<CollectionResult>;
+    /**
+     * Delegates for MetricReader.forceFlush.
+     */
+    forceFlush(options?: ForceFlushOptions): Promise<void>;
+    /**
+     * Delegates for MetricReader.shutdown.
+     */
+    shutdown(options?: ShutdownOptions): Promise<void>;
+    selectAggregationTemporality(instrumentType: InstrumentType): import("..").AggregationTemporality;
+    selectAggregation(instrumentType: InstrumentType): import("..").AggregationOption;
+    /**
+     * Select the cardinality limit for the given {@link InstrumentType} for this
+     * collector.
+     */
+    selectCardinalityLimit(instrumentType: InstrumentType): number;
+}
+/**
+ * An internal interface for MetricCollector. Exposes the necessary
+ * information for metric collection.
+ */
+export interface MetricCollectorHandle {
+    selectAggregationTemporality: AggregationTemporalitySelector;
+    selectCardinalityLimit(instrumentType: InstrumentType): number;
+}
+//# sourceMappingURL=MetricCollector.d.ts.map

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

@@ -0,0 +1,83 @@
+"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.MetricCollector = void 0;
+const core_1 = require("@opentelemetry/core");
+/**
+ * An internal opaque interface that the MetricReader receives as
+ * MetricProducer. It acts as the storage key to the internal metric stream
+ * state for each MetricReader.
+ */
+class MetricCollector {
+    _sharedState;
+    _metricReader;
+    constructor(_sharedState, _metricReader) {
+        this._sharedState = _sharedState;
+        this._metricReader = _metricReader;
+    }
+    async collect(options) {
+        const collectionTime = (0, core_1.millisToHrTime)(Date.now());
+        const scopeMetrics = [];
+        const errors = [];
+        const meterCollectionPromises = Array.from(this._sharedState.meterSharedStates.values()).map(async (meterSharedState) => {
+            const current = await meterSharedState.collect(this, collectionTime, options);
+            // only add scope metrics if available
+            if (current?.scopeMetrics != null) {
+                scopeMetrics.push(current.scopeMetrics);
+            }
+            // only add errors if available
+            if (current?.errors != null) {
+                errors.push(...current.errors);
+            }
+        });
+        await Promise.all(meterCollectionPromises);
+        return {
+            resourceMetrics: {
+                resource: this._sharedState.resource,
+                scopeMetrics: scopeMetrics,
+            },
+            errors: errors,
+        };
+    }
+    /**
+     * Delegates for MetricReader.forceFlush.
+     */
+    async forceFlush(options) {
+        await this._metricReader.forceFlush(options);
+    }
+    /**
+     * Delegates for MetricReader.shutdown.
+     */
+    async shutdown(options) {
+        await this._metricReader.shutdown(options);
+    }
+    selectAggregationTemporality(instrumentType) {
+        return this._metricReader.selectAggregationTemporality(instrumentType);
+    }
+    selectAggregation(instrumentType) {
+        return this._metricReader.selectAggregation(instrumentType);
+    }
+    /**
+     * Select the cardinality limit for the given {@link InstrumentType} for this
+     * collector.
+     */
+    selectCardinalityLimit(instrumentType) {
+        return this._metricReader.selectCardinalityLimit?.(instrumentType) ?? 2000;
+    }
+}
+exports.MetricCollector = MetricCollector;
+//# sourceMappingURL=MetricCollector.js.map