decocms 2.333.0 → 2.334.0

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/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/esnext/state/MeterProviderSharedState.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"MeterProviderSharedState.js","sourceRoot":"","sources":["../../../src/state/MeterProviderSharedState.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,OAAO,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAI1D;;GAEG;AACH,MAAM,OAAO,wBAAwB;IAOhB;IANnB,YAAY,GAAG,IAAI,YAAY,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,sBAAsB,CAAC,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,gBAAgB,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,aAAa,CAAC,SAAS,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC;aAC3D,CAAC,CAAC;SACJ;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;CACF","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/esnext/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/esnext/state/MeterSharedState.js

@@ -0,0 +1,116 @@
+/*
+ * 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.
+ */
+import { createInstrumentDescriptorWithView, } from '../InstrumentDescriptor';
+import { Meter } from '../Meter';
+import { isNotNullish } from '../utils';
+import { AsyncMetricStorage } from './AsyncMetricStorage';
+import { MetricStorageRegistry } from './MetricStorageRegistry';
+import { MultiMetricStorage } from './MultiWritableMetricStorage';
+import { ObservableRegistry } from './ObservableRegistry';
+import { SyncMetricStorage } from './SyncMetricStorage';
+import { createNoopAttributesProcessor, } from '../view/AttributesProcessor';
+/**
+ * An internal record for shared meter provider states.
+ */
+export class MeterSharedState {
+    _meterProviderSharedState;
+    _instrumentationScope;
+    metricStorageRegistry = new MetricStorageRegistry();
+    observableRegistry = new ObservableRegistry();
+    meter;
+    constructor(_meterProviderSharedState, _instrumentationScope) {
+        this._meterProviderSharedState = _meterProviderSharedState;
+        this._instrumentationScope = _instrumentationScope;
+        this.meter = new Meter(this);
+    }
+    registerMetricStorage(descriptor) {
+        const storages = this._registerMetricStorage(descriptor, SyncMetricStorage);
+        if (storages.length === 1) {
+            return storages[0];
+        }
+        return new MultiMetricStorage(storages);
+    }
+    registerAsyncMetricStorage(descriptor) {
+        const storages = this._registerMetricStorage(descriptor, 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(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 = 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, createNoopAttributesProcessor(), [collector], cardinalityLimit);
+                this.metricStorageRegistry.registerForCollector(collector, storage);
+                return storage;
+            });
+            storages = storages.concat(collectorStorages);
+        }
+        return storages;
+    }
+}
+//# sourceMappingURL=MeterSharedState.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/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/esnext/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/esnext/state/MetricCollector.js

@@ -0,0 +1,79 @@
+/*
+ * 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.
+ */
+import { millisToHrTime } from '@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.
+ */
+export class MetricCollector {
+    _sharedState;
+    _metricReader;
+    constructor(_sharedState, _metricReader) {
+        this._sharedState = _sharedState;
+        this._metricReader = _metricReader;
+    }
+    async collect(options) {
+        const collectionTime = 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;
+    }
+}
+//# sourceMappingURL=MetricCollector.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MetricCollector.js","sourceRoot":"","sources":["../../../src/state/MetricCollector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAYrD;;;;GAIG;AACH,MAAM,OAAO,eAAe;IAEhB;IACA;IAFV,YACU,YAAsC,EACtC,aAA4B;QAD5B,iBAAY,GAAZ,YAAY,CAA0B;QACtC,kBAAa,GAAb,aAAa,CAAe;IACnC,CAAC;IAEJ,KAAK,CAAC,OAAO,CAAC,OAA8B;QAC1C,MAAM,cAAc,GAAG,cAAc,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;QAClD,MAAM,YAAY,GAAmB,EAAE,CAAC;QACxC,MAAM,MAAM,GAAc,EAAE,CAAC;QAE7B,MAAM,uBAAuB,GAAG,KAAK,CAAC,IAAI,CACxC,IAAI,CAAC,YAAY,CAAC,iBAAiB,CAAC,MAAM,EAAE,CAC7C,CAAC,GAAG,CAAC,KAAK,EAAC,gBAAgB,EAAC,EAAE;YAC7B,MAAM,OAAO,GAAG,MAAM,gBAAgB,CAAC,OAAO,CAC5C,IAAI,EACJ,cAAc,EACd,OAAO,CACR,CAAC;YAEF,sCAAsC;YACtC,IAAI,OAAO,EAAE,YAAY,IAAI,IAAI,EAAE;gBACjC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;aACzC;YAED,+BAA+B;YAC/B,IAAI,OAAO,EAAE,MAAM,IAAI,IAAI,EAAE;gBAC3B,MAAM,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;aAChC;QACH,CAAC,CAAC,CAAC;QACH,MAAM,OAAO,CAAC,GAAG,CAAC,uBAAuB,CAAC,CAAC;QAE3C,OAAO;YACL,eAAe,EAAE;gBACf,QAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,QAAQ;gBACpC,YAAY,EAAE,YAAY;aAC3B;YACD,MAAM,EAAE,MAAM;SACf,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,UAAU,CAAC,OAA2B;QAC1C,MAAM,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;IAC/C,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,QAAQ,CAAC,OAAyB;QACtC,MAAM,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC7C,CAAC;IAED,4BAA4B,CAAC,cAA8B;QACzD,OAAO,IAAI,CAAC,aAAa,CAAC,4BAA4B,CAAC,cAAc,CAAC,CAAC;IACzE,CAAC;IAED,iBAAiB,CAAC,cAA8B;QAC9C,OAAO,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,cAAc,CAAC,CAAC;IAC9D,CAAC;IAED;;;OAGG;IACH,sBAAsB,CAAC,cAA8B;QACnD,OAAO,IAAI,CAAC,aAAa,CAAC,sBAAsB,EAAE,CAAC,cAAc,CAAC,IAAI,IAAI,CAAC;IAC7E,CAAC;CACF","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 { millisToHrTime } from '@opentelemetry/core';\nimport { AggregationTemporalitySelector } from '../export/AggregationSelector';\nimport {\n  CollectionResult,\n  InstrumentType,\n  ScopeMetrics,\n} from '../export/MetricData';\nimport { MetricCollectOptions, MetricProducer } from '../export/MetricProducer';\nimport { IMetricReader } from '../export/MetricReader';\nimport { ForceFlushOptions, ShutdownOptions } from '../types';\nimport { MeterProviderSharedState } from './MeterProviderSharedState';\n\n/**\n * An internal opaque interface that the MetricReader receives as\n * MetricProducer. It acts as the storage key to the internal metric stream\n * state for each MetricReader.\n */\nexport class MetricCollector implements MetricProducer {\n  constructor(\n    private _sharedState: MeterProviderSharedState,\n    private _metricReader: IMetricReader\n  ) {}\n\n  async collect(options?: MetricCollectOptions): Promise<CollectionResult> {\n    const collectionTime = millisToHrTime(Date.now());\n    const scopeMetrics: ScopeMetrics[] = [];\n    const errors: unknown[] = [];\n\n    const meterCollectionPromises = Array.from(\n      this._sharedState.meterSharedStates.values()\n    ).map(async meterSharedState => {\n      const current = await meterSharedState.collect(\n        this,\n        collectionTime,\n        options\n      );\n\n      // only add scope metrics if available\n      if (current?.scopeMetrics != null) {\n        scopeMetrics.push(current.scopeMetrics);\n      }\n\n      // only add errors if available\n      if (current?.errors != null) {\n        errors.push(...current.errors);\n      }\n    });\n    await Promise.all(meterCollectionPromises);\n\n    return {\n      resourceMetrics: {\n        resource: this._sharedState.resource,\n        scopeMetrics: scopeMetrics,\n      },\n      errors: errors,\n    };\n  }\n\n  /**\n   * Delegates for MetricReader.forceFlush.\n   */\n  async forceFlush(options?: ForceFlushOptions): Promise<void> {\n    await this._metricReader.forceFlush(options);\n  }\n\n  /**\n   * Delegates for MetricReader.shutdown.\n   */\n  async shutdown(options?: ShutdownOptions): Promise<void> {\n    await this._metricReader.shutdown(options);\n  }\n\n  selectAggregationTemporality(instrumentType: InstrumentType) {\n    return this._metricReader.selectAggregationTemporality(instrumentType);\n  }\n\n  selectAggregation(instrumentType: InstrumentType) {\n    return this._metricReader.selectAggregation(instrumentType);\n  }\n\n  /**\n   * Select the cardinality limit for the given {@link InstrumentType} for this\n   * collector.\n   */\n  selectCardinalityLimit(instrumentType: InstrumentType): number {\n    return this._metricReader.selectCardinalityLimit?.(instrumentType) ?? 2000;\n  }\n}\n\n/**\n * An internal interface for MetricCollector. Exposes the necessary\n * information for metric collection.\n */\nexport interface MetricCollectorHandle {\n  selectAggregationTemporality: AggregationTemporalitySelector;\n  selectCardinalityLimit(instrumentType: InstrumentType): number;\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/state/MetricStorage.d.ts

@@ -0,0 +1,24 @@
+import { HrTime } from '@opentelemetry/api';
+import { MetricData } from '../export/MetricData';
+import { Maybe } from '../utils';
+import { MetricCollectorHandle } from './MetricCollector';
+import { InstrumentDescriptor } from '../InstrumentDescriptor';
+/**
+ * Internal interface.
+ *
+ * Represents a storage from which we can collect metrics.
+ */
+export declare abstract class MetricStorage {
+    protected _instrumentDescriptor: InstrumentDescriptor;
+    constructor(_instrumentDescriptor: InstrumentDescriptor);
+    /**
+     * Collects the metrics from this storage.
+     *
+     * Note: This is a stateful operation and may reset any interval-related
+     * state for the MetricCollector.
+     */
+    abstract collect(collector: MetricCollectorHandle, collectionTime: HrTime): Maybe<MetricData>;
+    getInstrumentDescriptor(): Readonly<InstrumentDescriptor>;
+    updateDescription(description: string): void;
+}
+//# sourceMappingURL=MetricStorage.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/state/MetricStorage.js

@@ -0,0 +1,39 @@
+/*
+ * 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.
+ */
+import { createInstrumentDescriptor, } from '../InstrumentDescriptor';
+/**
+ * Internal interface.
+ *
+ * Represents a storage from which we can collect metrics.
+ */
+export class MetricStorage {
+    _instrumentDescriptor;
+    constructor(_instrumentDescriptor) {
+        this._instrumentDescriptor = _instrumentDescriptor;
+    }
+    getInstrumentDescriptor() {
+        return this._instrumentDescriptor;
+    }
+    updateDescription(description) {
+        this._instrumentDescriptor = createInstrumentDescriptor(this._instrumentDescriptor.name, this._instrumentDescriptor.type, {
+            description: description,
+            valueType: this._instrumentDescriptor.valueType,
+            unit: this._instrumentDescriptor.unit,
+            advice: this._instrumentDescriptor.advice,
+        });
+    }
+}
+//# sourceMappingURL=MetricStorage.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/state/MetricStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricStorage.js","sourceRoot":"","sources":["../../../src/state/MetricStorage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,OAAO,EACL,0BAA0B,GAE3B,MAAM,yBAAyB,CAAC;AAEjC;;;;GAIG;AACH,MAAM,OAAgB,aAAa;IACX;IAAtB,YAAsB,qBAA2C;QAA3C,0BAAqB,GAArB,qBAAqB,CAAsB;IAAG,CAAC;IAarE,uBAAuB;QACrB,OAAO,IAAI,CAAC,qBAAqB,CAAC;IACpC,CAAC;IAED,iBAAiB,CAAC,WAAmB;QACnC,IAAI,CAAC,qBAAqB,GAAG,0BAA0B,CACrD,IAAI,CAAC,qBAAqB,CAAC,IAAI,EAC/B,IAAI,CAAC,qBAAqB,CAAC,IAAI,EAC/B;YACE,WAAW,EAAE,WAAW;YACxB,SAAS,EAAE,IAAI,CAAC,qBAAqB,CAAC,SAAS;YAC/C,IAAI,EAAE,IAAI,CAAC,qBAAqB,CAAC,IAAI;YACrC,MAAM,EAAE,IAAI,CAAC,qBAAqB,CAAC,MAAM;SAC1C,CACF,CAAC;IACJ,CAAC;CACF","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 { MetricData } from '../export/MetricData';\nimport { Maybe } from '../utils';\nimport { MetricCollectorHandle } from './MetricCollector';\nimport {\n  createInstrumentDescriptor,\n  InstrumentDescriptor,\n} from '../InstrumentDescriptor';\n\n/**\n * Internal interface.\n *\n * Represents a storage from which we can collect metrics.\n */\nexport abstract class MetricStorage {\n  constructor(protected _instrumentDescriptor: InstrumentDescriptor) {}\n\n  /**\n   * Collects the metrics from this storage.\n   *\n   * Note: This is a stateful operation and may reset any interval-related\n   * state for the MetricCollector.\n   */\n  abstract collect(\n    collector: MetricCollectorHandle,\n    collectionTime: HrTime\n  ): Maybe<MetricData>;\n\n  getInstrumentDescriptor(): Readonly<InstrumentDescriptor> {\n    return this._instrumentDescriptor;\n  }\n\n  updateDescription(description: string): void {\n    this._instrumentDescriptor = createInstrumentDescriptor(\n      this._instrumentDescriptor.name,\n      this._instrumentDescriptor.type,\n      {\n        description: description,\n        valueType: this._instrumentDescriptor.valueType,\n        unit: this._instrumentDescriptor.unit,\n        advice: this._instrumentDescriptor.advice,\n      }\n    );\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/state/MetricStorageRegistry.d.ts

@@ -0,0 +1,19 @@
+import { MetricStorage } from './MetricStorage';
+import { InstrumentDescriptor } from '../InstrumentDescriptor';
+import { MetricCollectorHandle } from './MetricCollector';
+/**
+ * Internal class for storing {@link MetricStorage}
+ */
+export declare class MetricStorageRegistry {
+    private readonly _sharedRegistry;
+    private readonly _perCollectorRegistry;
+    static create(): MetricStorageRegistry;
+    getStorages(collector: MetricCollectorHandle): MetricStorage[];
+    register(storage: MetricStorage): void;
+    registerForCollector(collector: MetricCollectorHandle, storage: MetricStorage): void;
+    findOrUpdateCompatibleStorage<T extends MetricStorage>(expectedDescriptor: InstrumentDescriptor): T | null;
+    findOrUpdateCompatibleCollectorStorage<T extends MetricStorage>(collector: MetricCollectorHandle, expectedDescriptor: InstrumentDescriptor): T | null;
+    private _registerStorage;
+    private _findOrUpdateCompatibleStorage;
+}
+//# sourceMappingURL=MetricStorageRegistry.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/state/MetricStorageRegistry.js

@@ -0,0 +1,108 @@
+/*
+ * 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.
+ */
+import { isDescriptorCompatibleWith, } from '../InstrumentDescriptor';
+import * as api from '@opentelemetry/api';
+import { getConflictResolutionRecipe, getIncompatibilityDetails, } from '../view/RegistrationConflicts';
+/**
+ * Internal class for storing {@link MetricStorage}
+ */
+export class MetricStorageRegistry {
+    _sharedRegistry = new Map();
+    _perCollectorRegistry = new Map();
+    static create() {
+        return new MetricStorageRegistry();
+    }
+    getStorages(collector) {
+        let storages = [];
+        for (const metricStorages of this._sharedRegistry.values()) {
+            storages = storages.concat(metricStorages);
+        }
+        const perCollectorStorages = this._perCollectorRegistry.get(collector);
+        if (perCollectorStorages != null) {
+            for (const metricStorages of perCollectorStorages.values()) {
+                storages = storages.concat(metricStorages);
+            }
+        }
+        return storages;
+    }
+    register(storage) {
+        this._registerStorage(storage, this._sharedRegistry);
+    }
+    registerForCollector(collector, storage) {
+        let storageMap = this._perCollectorRegistry.get(collector);
+        if (storageMap == null) {
+            storageMap = new Map();
+            this._perCollectorRegistry.set(collector, storageMap);
+        }
+        this._registerStorage(storage, storageMap);
+    }
+    findOrUpdateCompatibleStorage(expectedDescriptor) {
+        const storages = this._sharedRegistry.get(expectedDescriptor.name);
+        if (storages === undefined) {
+            return null;
+        }
+        // If the descriptor is compatible, the type of their metric storage
+        // (either SyncMetricStorage or AsyncMetricStorage) must be compatible.
+        return this._findOrUpdateCompatibleStorage(expectedDescriptor, storages);
+    }
+    findOrUpdateCompatibleCollectorStorage(collector, expectedDescriptor) {
+        const storageMap = this._perCollectorRegistry.get(collector);
+        if (storageMap === undefined) {
+            return null;
+        }
+        const storages = storageMap.get(expectedDescriptor.name);
+        if (storages === undefined) {
+            return null;
+        }
+        // If the descriptor is compatible, the type of their metric storage
+        // (either SyncMetricStorage or AsyncMetricStorage) must be compatible.
+        return this._findOrUpdateCompatibleStorage(expectedDescriptor, storages);
+    }
+    _registerStorage(storage, storageMap) {
+        const descriptor = storage.getInstrumentDescriptor();
+        const storages = storageMap.get(descriptor.name);
+        if (storages === undefined) {
+            storageMap.set(descriptor.name, [storage]);
+            return;
+        }
+        storages.push(storage);
+    }
+    _findOrUpdateCompatibleStorage(expectedDescriptor, existingStorages) {
+        let compatibleStorage = null;
+        for (const existingStorage of existingStorages) {
+            const existingDescriptor = existingStorage.getInstrumentDescriptor();
+            if (isDescriptorCompatibleWith(existingDescriptor, expectedDescriptor)) {
+                // Use the longer description if it does not match.
+                if (existingDescriptor.description !== expectedDescriptor.description) {
+                    if (expectedDescriptor.description.length >
+                        existingDescriptor.description.length) {
+                        existingStorage.updateDescription(expectedDescriptor.description);
+                    }
+                    api.diag.warn('A view or instrument with the name ', expectedDescriptor.name, ' has already been registered, but has a different description and is incompatible with another registered view.\n', 'Details:\n', getIncompatibilityDetails(existingDescriptor, expectedDescriptor), 'The longer description will be used.\nTo resolve the conflict:', getConflictResolutionRecipe(existingDescriptor, expectedDescriptor));
+                }
+                // Storage is fully compatible. There will never be more than one pre-existing fully compatible storage.
+                compatibleStorage = existingStorage;
+            }
+            else {
+                // The implementation SHOULD warn about duplicate instrument registration
+                // conflicts after applying View configuration.
+                api.diag.warn('A view or instrument with the name ', expectedDescriptor.name, ' has already been registered and is incompatible with another registered view.\n', 'Details:\n', getIncompatibilityDetails(existingDescriptor, expectedDescriptor), 'To resolve the conflict:\n', getConflictResolutionRecipe(existingDescriptor, expectedDescriptor));
+            }
+        }
+        return compatibleStorage;
+    }
+}
+//# sourceMappingURL=MetricStorageRegistry.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/state/MetricStorageRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricStorageRegistry.js","sourceRoot":"","sources":["../../../src/state/MetricStorageRegistry.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 { MetricStorage } from './MetricStorage';\nimport {\n  InstrumentDescriptor,\n  isDescriptorCompatibleWith,\n} from '../InstrumentDescriptor';\nimport * as api from '@opentelemetry/api';\nimport {\n  getConflictResolutionRecipe,\n  getIncompatibilityDetails,\n} from '../view/RegistrationConflicts';\nimport { MetricCollectorHandle } from './MetricCollector';\n\ntype StorageMap = Map<string, MetricStorage[]>;\n\n/**\n * Internal class for storing {@link MetricStorage}\n */\nexport class MetricStorageRegistry {\n  private readonly _sharedRegistry: StorageMap = new Map();\n  private readonly _perCollectorRegistry = new Map<\n    MetricCollectorHandle,\n    StorageMap\n  >();\n\n  static create() {\n    return new MetricStorageRegistry();\n  }\n\n  getStorages(collector: MetricCollectorHandle): MetricStorage[] {\n    let storages: MetricStorage[] = [];\n    for (const metricStorages of this._sharedRegistry.values()) {\n      storages = storages.concat(metricStorages);\n    }\n\n    const perCollectorStorages = this._perCollectorRegistry.get(collector);\n    if (perCollectorStorages != null) {\n      for (const metricStorages of perCollectorStorages.values()) {\n        storages = storages.concat(metricStorages);\n      }\n    }\n\n    return storages;\n  }\n\n  register(storage: MetricStorage) {\n    this._registerStorage(storage, this._sharedRegistry);\n  }\n\n  registerForCollector(\n    collector: MetricCollectorHandle,\n    storage: MetricStorage\n  ) {\n    let storageMap = this._perCollectorRegistry.get(collector);\n    if (storageMap == null) {\n      storageMap = new Map();\n      this._perCollectorRegistry.set(collector, storageMap);\n    }\n    this._registerStorage(storage, storageMap);\n  }\n\n  findOrUpdateCompatibleStorage<T extends MetricStorage>(\n    expectedDescriptor: InstrumentDescriptor\n  ): T | null {\n    const storages = this._sharedRegistry.get(expectedDescriptor.name);\n    if (storages === undefined) {\n      return null;\n    }\n\n    // If the descriptor is compatible, the type of their metric storage\n    // (either SyncMetricStorage or AsyncMetricStorage) must be compatible.\n    return this._findOrUpdateCompatibleStorage<T>(expectedDescriptor, storages);\n  }\n\n  findOrUpdateCompatibleCollectorStorage<T extends MetricStorage>(\n    collector: MetricCollectorHandle,\n    expectedDescriptor: InstrumentDescriptor\n  ): T | null {\n    const storageMap = this._perCollectorRegistry.get(collector);\n    if (storageMap === undefined) {\n      return null;\n    }\n\n    const storages = storageMap.get(expectedDescriptor.name);\n    if (storages === undefined) {\n      return null;\n    }\n\n    // If the descriptor is compatible, the type of their metric storage\n    // (either SyncMetricStorage or AsyncMetricStorage) must be compatible.\n    return this._findOrUpdateCompatibleStorage<T>(expectedDescriptor, storages);\n  }\n\n  private _registerStorage(storage: MetricStorage, storageMap: StorageMap) {\n    const descriptor = storage.getInstrumentDescriptor();\n    const storages = storageMap.get(descriptor.name);\n\n    if (storages === undefined) {\n      storageMap.set(descriptor.name, [storage]);\n      return;\n    }\n\n    storages.push(storage);\n  }\n\n  private _findOrUpdateCompatibleStorage<T extends MetricStorage>(\n    expectedDescriptor: InstrumentDescriptor,\n    existingStorages: MetricStorage[]\n  ): T | null {\n    let compatibleStorage = null;\n\n    for (const existingStorage of existingStorages) {\n      const existingDescriptor = existingStorage.getInstrumentDescriptor();\n\n      if (isDescriptorCompatibleWith(existingDescriptor, expectedDescriptor)) {\n        // Use the longer description if it does not match.\n        if (existingDescriptor.description !== expectedDescriptor.description) {\n          if (\n            expectedDescriptor.description.length >\n            existingDescriptor.description.length\n          ) {\n            existingStorage.updateDescription(expectedDescriptor.description);\n          }\n\n          api.diag.warn(\n            'A view or instrument with the name ',\n            expectedDescriptor.name,\n            ' has already been registered, but has a different description and is incompatible with another registered view.\\n',\n            'Details:\\n',\n            getIncompatibilityDetails(existingDescriptor, expectedDescriptor),\n            'The longer description will be used.\\nTo resolve the conflict:',\n            getConflictResolutionRecipe(existingDescriptor, expectedDescriptor)\n          );\n        }\n        // Storage is fully compatible. There will never be more than one pre-existing fully compatible storage.\n        compatibleStorage = existingStorage as T;\n      } else {\n        // The implementation SHOULD warn about duplicate instrument registration\n        // conflicts after applying View configuration.\n        api.diag.warn(\n          'A view or instrument with the name ',\n          expectedDescriptor.name,\n          ' has already been registered and is incompatible with another registered view.\\n',\n          'Details:\\n',\n          getIncompatibilityDetails(existingDescriptor, expectedDescriptor),\n          'To resolve the conflict:\\n',\n          getConflictResolutionRecipe(existingDescriptor, expectedDescriptor)\n        );\n      }\n    }\n\n    return compatibleStorage;\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esnext/state/MultiWritableMetricStorage.d.ts

@@ -0,0 +1,11 @@
+import { Context, HrTime, Attributes } from '@opentelemetry/api';
+import { WritableMetricStorage } from './WritableMetricStorage';
+/**
+ * Internal interface.
+ */
+export declare class MultiMetricStorage implements WritableMetricStorage {
+    private readonly _backingStorages;
+    constructor(_backingStorages: WritableMetricStorage[]);
+    record(value: number, attributes: Attributes, context: Context, recordTime: HrTime): void;
+}
+//# sourceMappingURL=MultiWritableMetricStorage.d.ts.map