decocms 2.388.2 → 2.388.3

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/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/esm/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

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/state/MultiWritableMetricStorage.js

@@ -0,0 +1,30 @@
+/*
+ * 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.
+ */
+/**
+ * Internal interface.
+ */
+export class MultiMetricStorage {
+    _backingStorages;
+    constructor(backingStorages) {
+        this._backingStorages = backingStorages;
+    }
+    record(value, attributes, context, recordTime) {
+        this._backingStorages.forEach(it => {
+            it.record(value, attributes, context, recordTime);
+        });
+    }
+}
+//# sourceMappingURL=MultiWritableMetricStorage.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/state/MultiWritableMetricStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiWritableMetricStorage.js","sourceRoot":"","sources":["../../../src/state/MultiWritableMetricStorage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH;;GAEG;AACH,MAAM,OAAO,kBAAkB;IACZ,gBAAgB,CAA0B;IAC3D,YAAY,eAAwC;QAClD,IAAI,CAAC,gBAAgB,GAAG,eAAe,CAAC;IAC1C,CAAC;IAED,MAAM,CACJ,KAAa,EACb,UAAsB,EACtB,OAAgB,EAChB,UAAkB;QAElB,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE;YACjC,EAAE,CAAC,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QACpD,CAAC,CAAC,CAAC;IACL,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 { Context, HrTime, Attributes } from '@opentelemetry/api';\nimport { WritableMetricStorage } from './WritableMetricStorage';\n\n/**\n * Internal interface.\n */\nexport class MultiMetricStorage implements WritableMetricStorage {\n  private readonly _backingStorages: WritableMetricStorage[];\n  constructor(backingStorages: WritableMetricStorage[]) {\n    this._backingStorages = backingStorages;\n  }\n\n  record(\n    value: number,\n    attributes: Attributes,\n    context: Context,\n    recordTime: HrTime\n  ) {\n    this._backingStorages.forEach(it => {\n      it.record(value, attributes, context, recordTime);\n    });\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/state/ObservableRegistry.d.ts

@@ -0,0 +1,25 @@
+import { HrTime, BatchObservableCallback, Observable, ObservableCallback } from '@opentelemetry/api';
+import { ObservableInstrument } from '../Instruments';
+/**
+ * An internal interface for managing ObservableCallbacks.
+ *
+ * Every registered callback associated with a set of instruments are be evaluated
+ * exactly once during collection prior to reading data for that instrument.
+ */
+export declare class ObservableRegistry {
+    private _callbacks;
+    private _batchCallbacks;
+    addCallback(callback: ObservableCallback, instrument: ObservableInstrument): void;
+    removeCallback(callback: ObservableCallback, instrument: ObservableInstrument): void;
+    addBatchCallback(callback: BatchObservableCallback, instruments: Observable[]): void;
+    removeBatchCallback(callback: BatchObservableCallback, instruments: Observable[]): void;
+    /**
+     * @returns a promise of rejected reasons for invoking callbacks.
+     */
+    observe(collectionTime: HrTime, timeoutMillis?: number): Promise<unknown[]>;
+    private _observeCallbacks;
+    private _observeBatchCallbacks;
+    private _findCallback;
+    private _findBatchCallback;
+}
+//# sourceMappingURL=ObservableRegistry.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/state/ObservableRegistry.js

@@ -0,0 +1,124 @@
+/*
+ * 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 { diag, } from '@opentelemetry/api';
+import { isObservableInstrument } from '../Instruments';
+import { BatchObservableResultImpl, ObservableResultImpl, } from '../ObservableResult';
+import { callWithTimeout, setEquals } from '../utils';
+/**
+ * An internal interface for managing ObservableCallbacks.
+ *
+ * Every registered callback associated with a set of instruments are be evaluated
+ * exactly once during collection prior to reading data for that instrument.
+ */
+export class ObservableRegistry {
+    _callbacks = [];
+    _batchCallbacks = [];
+    addCallback(callback, instrument) {
+        const idx = this._findCallback(callback, instrument);
+        if (idx >= 0) {
+            return;
+        }
+        this._callbacks.push({ callback, instrument });
+    }
+    removeCallback(callback, instrument) {
+        const idx = this._findCallback(callback, instrument);
+        if (idx < 0) {
+            return;
+        }
+        this._callbacks.splice(idx, 1);
+    }
+    addBatchCallback(callback, instruments) {
+        // Create a set of unique instruments.
+        const observableInstruments = new Set(instruments.filter(isObservableInstrument));
+        if (observableInstruments.size === 0) {
+            diag.error('BatchObservableCallback is not associated with valid instruments', instruments);
+            return;
+        }
+        const idx = this._findBatchCallback(callback, observableInstruments);
+        if (idx >= 0) {
+            return;
+        }
+        this._batchCallbacks.push({ callback, instruments: observableInstruments });
+    }
+    removeBatchCallback(callback, instruments) {
+        // Create a set of unique instruments.
+        const observableInstruments = new Set(instruments.filter(isObservableInstrument));
+        const idx = this._findBatchCallback(callback, observableInstruments);
+        if (idx < 0) {
+            return;
+        }
+        this._batchCallbacks.splice(idx, 1);
+    }
+    /**
+     * @returns a promise of rejected reasons for invoking callbacks.
+     */
+    async observe(collectionTime, timeoutMillis) {
+        const callbackFutures = this._observeCallbacks(collectionTime, timeoutMillis);
+        const batchCallbackFutures = this._observeBatchCallbacks(collectionTime, timeoutMillis);
+        const results = await Promise.allSettled([
+            ...callbackFutures,
+            ...batchCallbackFutures,
+        ]);
+        const rejections = results
+            .filter(result => result.status === 'rejected')
+            .map(result => result.reason);
+        return rejections;
+    }
+    _observeCallbacks(observationTime, timeoutMillis) {
+        return this._callbacks.map(async ({ callback, instrument }) => {
+            const observableResult = new ObservableResultImpl(instrument._descriptor.name, instrument._descriptor.valueType);
+            let callPromise = Promise.resolve(callback(observableResult));
+            if (timeoutMillis != null) {
+                callPromise = callWithTimeout(callPromise, timeoutMillis);
+            }
+            await callPromise;
+            instrument._metricStorages.forEach(metricStorage => {
+                metricStorage.record(observableResult._buffer, observationTime);
+            });
+        });
+    }
+    _observeBatchCallbacks(observationTime, timeoutMillis) {
+        return this._batchCallbacks.map(async ({ callback, instruments }) => {
+            const observableResult = new BatchObservableResultImpl();
+            let callPromise = Promise.resolve(callback(observableResult));
+            if (timeoutMillis != null) {
+                callPromise = callWithTimeout(callPromise, timeoutMillis);
+            }
+            await callPromise;
+            instruments.forEach(instrument => {
+                const buffer = observableResult._buffer.get(instrument);
+                if (buffer == null) {
+                    return;
+                }
+                instrument._metricStorages.forEach(metricStorage => {
+                    metricStorage.record(buffer, observationTime);
+                });
+            });
+        });
+    }
+    _findCallback(callback, instrument) {
+        return this._callbacks.findIndex(record => {
+            return record.callback === callback && record.instrument === instrument;
+        });
+    }
+    _findBatchCallback(callback, instruments) {
+        return this._batchCallbacks.findIndex(record => {
+            return (record.callback === callback &&
+                setEquals(record.instruments, instruments));
+        });
+    }
+}
+//# sourceMappingURL=ObservableRegistry.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/state/ObservableRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ObservableRegistry.js","sourceRoot":"","sources":["../../../src/state/ObservableRegistry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,IAAI,GAKL,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,sBAAsB,EAAwB,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EACL,yBAAyB,EACzB,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAkBtD;;;;;GAKG;AACH,MAAM,OAAO,kBAAkB;IACrB,UAAU,GAA+B,EAAE,CAAC;IAC5C,eAAe,GAAoC,EAAE,CAAC;IAE9D,WAAW,CAAC,QAA4B,EAAE,UAAgC;QACxE,MAAM,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QACrD,IAAI,GAAG,IAAI,CAAC,EAAE;YACZ,OAAO;SACR;QACD,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC;IACjD,CAAC;IAED,cAAc,CACZ,QAA4B,EAC5B,UAAgC;QAEhC,MAAM,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;QACrD,IAAI,GAAG,GAAG,CAAC,EAAE;YACX,OAAO;SACR;QACD,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IACjC,CAAC;IAED,gBAAgB,CACd,QAAiC,EACjC,WAAyB;QAEzB,sCAAsC;QACtC,MAAM,qBAAqB,GAAG,IAAI,GAAG,CACnC,WAAW,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAC3C,CAAC;QACF,IAAI,qBAAqB,CAAC,IAAI,KAAK,CAAC,EAAE;YACpC,IAAI,CAAC,KAAK,CACR,kEAAkE,EAClE,WAAW,CACZ,CAAC;YACF,OAAO;SACR;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,qBAAqB,CAAC,CAAC;QACrE,IAAI,GAAG,IAAI,CAAC,EAAE;YACZ,OAAO;SACR;QACD,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,WAAW,EAAE,qBAAqB,EAAE,CAAC,CAAC;IAC9E,CAAC;IAED,mBAAmB,CACjB,QAAiC,EACjC,WAAyB;QAEzB,sCAAsC;QACtC,MAAM,qBAAqB,GAAG,IAAI,GAAG,CACnC,WAAW,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAC3C,CAAC;QACF,MAAM,GAAG,GAAG,IAAI,CAAC,kBAAkB,CAAC,QAAQ,EAAE,qBAAqB,CAAC,CAAC;QACrE,IAAI,GAAG,GAAG,CAAC,EAAE;YACX,OAAO;SACR;QACD,IAAI,CAAC,eAAe,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IACtC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,OAAO,CACX,cAAsB,EACtB,aAAsB;QAEtB,MAAM,eAAe,GAAG,IAAI,CAAC,iBAAiB,CAC5C,cAAc,EACd,aAAa,CACd,CAAC;QACF,MAAM,oBAAoB,GAAG,IAAI,CAAC,sBAAsB,CACtD,cAAc,EACd,aAAa,CACd,CAAC;QAEF,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC;YACvC,GAAG,eAAe;YAClB,GAAG,oBAAoB;SACxB,CAAC,CAAC;QAEH,MAAM,UAAU,GAAG,OAAO;aACvB,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,KAAK,UAAU,CAAC;aAC9C,GAAG,CAAC,MAAM,CAAC,EAAE,CAAE,MAAgC,CAAC,MAAM,CAAC,CAAC;QAC3D,OAAO,UAAU,CAAC;IACpB,CAAC;IAEO,iBAAiB,CAAC,eAAuB,EAAE,aAAsB;QACvE,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,EAAE;YAC5D,MAAM,gBAAgB,GAAG,IAAI,oBAAoB,CAC/C,UAAU,CAAC,WAAW,CAAC,IAAI,EAC3B,UAAU,CAAC,WAAW,CAAC,SAAS,CACjC,CAAC;YACF,IAAI,WAAW,GAAkB,OAAO,CAAC,OAAO,CAC9C,QAAQ,CAAC,gBAAgB,CAAC,CAC3B,CAAC;YACF,IAAI,aAAa,IAAI,IAAI,EAAE;gBACzB,WAAW,GAAG,eAAe,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;aAC3D;YACD,MAAM,WAAW,CAAC;YAClB,UAAU,CAAC,eAAe,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE;gBACjD,aAAa,CAAC,MAAM,CAAC,gBAAgB,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;YAClE,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,sBAAsB,CAC5B,eAAuB,EACvB,aAAsB;QAEtB,OAAO,IAAI,CAAC,eAAe,CAAC,GAAG,CAAC,KAAK,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,EAAE,EAAE;YAClE,MAAM,gBAAgB,GAAG,IAAI,yBAAyB,EAAE,CAAC;YACzD,IAAI,WAAW,GAAkB,OAAO,CAAC,OAAO,CAC9C,QAAQ,CAAC,gBAAgB,CAAC,CAC3B,CAAC;YACF,IAAI,aAAa,IAAI,IAAI,EAAE;gBACzB,WAAW,GAAG,eAAe,CAAC,WAAW,EAAE,aAAa,CAAC,CAAC;aAC3D;YACD,MAAM,WAAW,CAAC;YAClB,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;gBAC/B,MAAM,MAAM,GAAG,gBAAgB,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;gBACxD,IAAI,MAAM,IAAI,IAAI,EAAE;oBAClB,OAAO;iBACR;gBACD,UAAU,CAAC,eAAe,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE;oBACjD,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;gBAChD,CAAC,CAAC,CAAC;YACL,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,aAAa,CACnB,QAA4B,EAC5B,UAAgC;QAEhC,OAAO,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;YACxC,OAAO,MAAM,CAAC,QAAQ,KAAK,QAAQ,IAAI,MAAM,CAAC,UAAU,KAAK,UAAU,CAAC;QAC1E,CAAC,CAAC,CAAC;IACL,CAAC;IAEO,kBAAkB,CACxB,QAAiC,EACjC,WAAsC;QAEtC,OAAO,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE;YAC7C,OAAO,CACL,MAAM,CAAC,QAAQ,KAAK,QAAQ;gBAC5B,SAAS,CAAC,MAAM,CAAC,WAAW,EAAE,WAAW,CAAC,CAC3C,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,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 {\n  diag,\n  HrTime,\n  BatchObservableCallback,\n  Observable,\n  ObservableCallback,\n} from '@opentelemetry/api';\nimport { isObservableInstrument, ObservableInstrument } from '../Instruments';\nimport {\n  BatchObservableResultImpl,\n  ObservableResultImpl,\n} from '../ObservableResult';\nimport { callWithTimeout, setEquals } from '../utils';\n\n/**\n * Records for single instrument observable callback.\n */\ninterface ObservableCallbackRecord {\n  callback: ObservableCallback;\n  instrument: ObservableInstrument;\n}\n\n/**\n * Records for multiple instruments observable callback.\n */\ninterface BatchObservableCallbackRecord {\n  callback: BatchObservableCallback;\n  instruments: Set<ObservableInstrument>;\n}\n\n/**\n * An internal interface for managing ObservableCallbacks.\n *\n * Every registered callback associated with a set of instruments are be evaluated\n * exactly once during collection prior to reading data for that instrument.\n */\nexport class ObservableRegistry {\n  private _callbacks: ObservableCallbackRecord[] = [];\n  private _batchCallbacks: BatchObservableCallbackRecord[] = [];\n\n  addCallback(callback: ObservableCallback, instrument: ObservableInstrument) {\n    const idx = this._findCallback(callback, instrument);\n    if (idx >= 0) {\n      return;\n    }\n    this._callbacks.push({ callback, instrument });\n  }\n\n  removeCallback(\n    callback: ObservableCallback,\n    instrument: ObservableInstrument\n  ) {\n    const idx = this._findCallback(callback, instrument);\n    if (idx < 0) {\n      return;\n    }\n    this._callbacks.splice(idx, 1);\n  }\n\n  addBatchCallback(\n    callback: BatchObservableCallback,\n    instruments: Observable[]\n  ) {\n    // Create a set of unique instruments.\n    const observableInstruments = new Set(\n      instruments.filter(isObservableInstrument)\n    );\n    if (observableInstruments.size === 0) {\n      diag.error(\n        'BatchObservableCallback is not associated with valid instruments',\n        instruments\n      );\n      return;\n    }\n    const idx = this._findBatchCallback(callback, observableInstruments);\n    if (idx >= 0) {\n      return;\n    }\n    this._batchCallbacks.push({ callback, instruments: observableInstruments });\n  }\n\n  removeBatchCallback(\n    callback: BatchObservableCallback,\n    instruments: Observable[]\n  ) {\n    // Create a set of unique instruments.\n    const observableInstruments = new Set(\n      instruments.filter(isObservableInstrument)\n    );\n    const idx = this._findBatchCallback(callback, observableInstruments);\n    if (idx < 0) {\n      return;\n    }\n    this._batchCallbacks.splice(idx, 1);\n  }\n\n  /**\n   * @returns a promise of rejected reasons for invoking callbacks.\n   */\n  async observe(\n    collectionTime: HrTime,\n    timeoutMillis?: number\n  ): Promise<unknown[]> {\n    const callbackFutures = this._observeCallbacks(\n      collectionTime,\n      timeoutMillis\n    );\n    const batchCallbackFutures = this._observeBatchCallbacks(\n      collectionTime,\n      timeoutMillis\n    );\n\n    const results = await Promise.allSettled([\n      ...callbackFutures,\n      ...batchCallbackFutures,\n    ]);\n\n    const rejections = results\n      .filter(result => result.status === 'rejected')\n      .map(result => (result as PromiseRejectedResult).reason);\n    return rejections;\n  }\n\n  private _observeCallbacks(observationTime: HrTime, timeoutMillis?: number) {\n    return this._callbacks.map(async ({ callback, instrument }) => {\n      const observableResult = new ObservableResultImpl(\n        instrument._descriptor.name,\n        instrument._descriptor.valueType\n      );\n      let callPromise: Promise<void> = Promise.resolve(\n        callback(observableResult)\n      );\n      if (timeoutMillis != null) {\n        callPromise = callWithTimeout(callPromise, timeoutMillis);\n      }\n      await callPromise;\n      instrument._metricStorages.forEach(metricStorage => {\n        metricStorage.record(observableResult._buffer, observationTime);\n      });\n    });\n  }\n\n  private _observeBatchCallbacks(\n    observationTime: HrTime,\n    timeoutMillis?: number\n  ) {\n    return this._batchCallbacks.map(async ({ callback, instruments }) => {\n      const observableResult = new BatchObservableResultImpl();\n      let callPromise: Promise<void> = Promise.resolve(\n        callback(observableResult)\n      );\n      if (timeoutMillis != null) {\n        callPromise = callWithTimeout(callPromise, timeoutMillis);\n      }\n      await callPromise;\n      instruments.forEach(instrument => {\n        const buffer = observableResult._buffer.get(instrument);\n        if (buffer == null) {\n          return;\n        }\n        instrument._metricStorages.forEach(metricStorage => {\n          metricStorage.record(buffer, observationTime);\n        });\n      });\n    });\n  }\n\n  private _findCallback(\n    callback: ObservableCallback,\n    instrument: ObservableInstrument\n  ) {\n    return this._callbacks.findIndex(record => {\n      return record.callback === callback && record.instrument === instrument;\n    });\n  }\n\n  private _findBatchCallback(\n    callback: BatchObservableCallback,\n    instruments: Set<ObservableInstrument>\n  ) {\n    return this._batchCallbacks.findIndex(record => {\n      return (\n        record.callback === callback &&\n        setEquals(record.instruments, instruments)\n      );\n    });\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/state/SyncMetricStorage.d.ts

@@ -0,0 +1,30 @@
+import { Context, HrTime, Attributes } from '@opentelemetry/api';
+import { WritableMetricStorage } from './WritableMetricStorage';
+import { Accumulation, Aggregator } from '../aggregator/types';
+import { InstrumentDescriptor } from '../InstrumentDescriptor';
+import { IAttributesProcessor } from '../view/AttributesProcessor';
+import { MetricStorage } from './MetricStorage';
+import { MetricData } from '../export/MetricData';
+import { Maybe } from '../utils';
+import { MetricCollectorHandle } from './MetricCollector';
+/**
+ * Internal interface.
+ *
+ * Stores and aggregates {@link MetricData} for synchronous instruments.
+ */
+export declare class SyncMetricStorage<T extends Maybe<Accumulation>> extends MetricStorage implements WritableMetricStorage {
+    private _aggregationCardinalityLimit?;
+    private _deltaMetricStorage;
+    private _temporalMetricStorage;
+    private _attributesProcessor;
+    constructor(instrumentDescriptor: InstrumentDescriptor, aggregator: Aggregator<T>, attributesProcessor: IAttributesProcessor, collectorHandles: MetricCollectorHandle[], aggregationCardinalityLimit?: number);
+    record(value: number, attributes: Attributes, context: Context, recordTime: HrTime): void;
+    /**
+     * Collects the metrics from this storage.
+     *
+     * Note: This is a stateful operation and may reset any interval-related
+     * state for the MetricCollector.
+     */
+    collect(collector: MetricCollectorHandle, collectionTime: HrTime): Maybe<MetricData>;
+}
+//# sourceMappingURL=SyncMetricStorage.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/state/SyncMetricStorage.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 { MetricStorage } from './MetricStorage';
+import { DeltaMetricProcessor } from './DeltaMetricProcessor';
+import { TemporalMetricProcessor } from './TemporalMetricProcessor';
+/**
+ * Internal interface.
+ *
+ * Stores and aggregates {@link MetricData} for synchronous instruments.
+ */
+export class SyncMetricStorage extends MetricStorage {
+    _aggregationCardinalityLimit;
+    _deltaMetricStorage;
+    _temporalMetricStorage;
+    _attributesProcessor;
+    constructor(instrumentDescriptor, aggregator, attributesProcessor, collectorHandles, aggregationCardinalityLimit) {
+        super(instrumentDescriptor);
+        this._aggregationCardinalityLimit = aggregationCardinalityLimit;
+        this._deltaMetricStorage = new DeltaMetricProcessor(aggregator, this._aggregationCardinalityLimit);
+        this._temporalMetricStorage = new TemporalMetricProcessor(aggregator, collectorHandles);
+        this._attributesProcessor = attributesProcessor;
+    }
+    record(value, attributes, context, recordTime) {
+        attributes = this._attributesProcessor.process(attributes, context);
+        this._deltaMetricStorage.record(value, attributes, context, recordTime);
+    }
+    /**
+     * Collects the metrics from this storage.
+     *
+     * Note: This is a stateful operation and may reset any interval-related
+     * state for the MetricCollector.
+     */
+    collect(collector, collectionTime) {
+        const accumulations = this._deltaMetricStorage.collect();
+        return this._temporalMetricStorage.buildMetrics(collector, this._instrumentDescriptor, accumulations, collectionTime);
+    }
+}
+//# sourceMappingURL=SyncMetricStorage.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/state/SyncMetricStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SyncMetricStorage.js","sourceRoot":"","sources":["../../../src/state/SyncMetricStorage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAOH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAIpE;;;;GAIG;AACH,MAAM,OAAO,iBACX,SAAQ,aAAa;IAGb,4BAA4B,CAAU;IACtC,mBAAmB,CAA0B;IAC7C,sBAAsB,CAA6B;IACnD,oBAAoB,CAAuB;IAEnD,YACE,oBAA0C,EAC1C,UAAyB,EACzB,mBAAyC,EACzC,gBAAyC,EACzC,2BAAoC;QAEpC,KAAK,CAAC,oBAAoB,CAAC,CAAC;QAC5B,IAAI,CAAC,4BAA4B,GAAG,2BAA2B,CAAC;QAChE,IAAI,CAAC,mBAAmB,GAAG,IAAI,oBAAoB,CACjD,UAAU,EACV,IAAI,CAAC,4BAA4B,CAClC,CAAC;QACF,IAAI,CAAC,sBAAsB,GAAG,IAAI,uBAAuB,CACvD,UAAU,EACV,gBAAgB,CACjB,CAAC;QACF,IAAI,CAAC,oBAAoB,GAAG,mBAAmB,CAAC;IAClD,CAAC;IAED,MAAM,CACJ,KAAa,EACb,UAAsB,EACtB,OAAgB,EAChB,UAAkB;QAElB,UAAU,GAAG,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;QACpE,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;IAC1E,CAAC;IAED;;;;;OAKG;IACH,OAAO,CACL,SAAgC,EAChC,cAAsB;QAEtB,MAAM,aAAa,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,CAAC;QAEzD,OAAO,IAAI,CAAC,sBAAsB,CAAC,YAAY,CAC7C,SAAS,EACT,IAAI,CAAC,qBAAqB,EAC1B,aAAa,EACb,cAAc,CACf,CAAC;IACJ,CAAC;CACF","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 { WritableMetricStorage } from './WritableMetricStorage';\nimport { Accumulation, Aggregator } from '../aggregator/types';\nimport { InstrumentDescriptor } from '../InstrumentDescriptor';\nimport { IAttributesProcessor } from '../view/AttributesProcessor';\nimport { MetricStorage } from './MetricStorage';\nimport { MetricData } from '../export/MetricData';\nimport { DeltaMetricProcessor } from './DeltaMetricProcessor';\nimport { TemporalMetricProcessor } from './TemporalMetricProcessor';\nimport { Maybe } from '../utils';\nimport { MetricCollectorHandle } from './MetricCollector';\n\n/**\n * Internal interface.\n *\n * Stores and aggregates {@link MetricData} for synchronous instruments.\n */\nexport class SyncMetricStorage<T extends Maybe<Accumulation>>\n  extends MetricStorage\n  implements WritableMetricStorage\n{\n  private _aggregationCardinalityLimit?: number;\n  private _deltaMetricStorage: DeltaMetricProcessor<T>;\n  private _temporalMetricStorage: TemporalMetricProcessor<T>;\n  private _attributesProcessor: IAttributesProcessor;\n\n  constructor(\n    instrumentDescriptor: InstrumentDescriptor,\n    aggregator: Aggregator<T>,\n    attributesProcessor: IAttributesProcessor,\n    collectorHandles: MetricCollectorHandle[],\n    aggregationCardinalityLimit?: number\n  ) {\n    super(instrumentDescriptor);\n    this._aggregationCardinalityLimit = aggregationCardinalityLimit;\n    this._deltaMetricStorage = new DeltaMetricProcessor(\n      aggregator,\n      this._aggregationCardinalityLimit\n    );\n    this._temporalMetricStorage = new TemporalMetricProcessor(\n      aggregator,\n      collectorHandles\n    );\n    this._attributesProcessor = attributesProcessor;\n  }\n\n  record(\n    value: number,\n    attributes: Attributes,\n    context: Context,\n    recordTime: HrTime\n  ) {\n    attributes = this._attributesProcessor.process(attributes, context);\n    this._deltaMetricStorage.record(value, attributes, context, recordTime);\n  }\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  collect(\n    collector: MetricCollectorHandle,\n    collectionTime: HrTime\n  ): Maybe<MetricData> {\n    const accumulations = this._deltaMetricStorage.collect();\n\n    return this._temporalMetricStorage.buildMetrics(\n      collector,\n      this._instrumentDescriptor,\n      accumulations,\n      collectionTime\n    );\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/state/TemporalMetricProcessor.d.ts

@@ -0,0 +1,38 @@
+import { HrTime } from '@opentelemetry/api';
+import { Accumulation, Aggregator } from '../aggregator/types';
+import { MetricData } from '../export/MetricData';
+import { InstrumentDescriptor } from '../InstrumentDescriptor';
+import { Maybe } from '../utils';
+import { MetricCollectorHandle } from './MetricCollector';
+import { AttributeHashMap } from './HashMap';
+/**
+ * Internal interface.
+ *
+ * Provides unique reporting for each collector. Allows synchronous collection
+ * of metrics and reports given temporality values.
+ */
+export declare class TemporalMetricProcessor<T extends Maybe<Accumulation>> {
+    private _aggregator;
+    private _unreportedAccumulations;
+    private _reportHistory;
+    constructor(aggregator: Aggregator<T>, collectorHandles: MetricCollectorHandle[]);
+    /**
+     * Builds the {@link MetricData} streams to report against a specific MetricCollector.
+     * @param collector The information of the MetricCollector.
+     * @param collectors The registered collectors.
+     * @param instrumentDescriptor The instrumentation descriptor that these metrics generated with.
+     * @param currentAccumulations The current accumulation of metric data from instruments.
+     * @param collectionTime The current collection timestamp.
+     * @returns The {@link MetricData} points or `null`.
+     */
+    buildMetrics(collector: MetricCollectorHandle, instrumentDescriptor: InstrumentDescriptor, currentAccumulations: AttributeHashMap<T>, collectionTime: HrTime): Maybe<MetricData>;
+    private _stashAccumulations;
+    private _getMergedUnreportedAccumulations;
+    static merge<T extends Maybe<Accumulation>>(last: AttributeHashMap<T>, current: AttributeHashMap<T>, aggregator: Aggregator<T>): AttributeHashMap<T>;
+    /**
+     * Calibrate the reported metric streams' startTime to lastCollectionTime. Leaves
+     * the new stream to be the initial observation time unchanged.
+     */
+    static calibrateStartTime<T extends Maybe<Accumulation>>(last: AttributeHashMap<T>, current: AttributeHashMap<T>, lastCollectionTime: HrTime): AttributeHashMap<T>;
+}
+//# sourceMappingURL=TemporalMetricProcessor.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/state/TemporalMetricProcessor.js

@@ -0,0 +1,152 @@
+/*
+ * 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 { AggregationTemporality } from '../export/AggregationTemporality';
+import { AttributeHashMap } from './HashMap';
+/**
+ * Internal interface.
+ *
+ * Provides unique reporting for each collector. Allows synchronous collection
+ * of metrics and reports given temporality values.
+ */
+export class TemporalMetricProcessor {
+    _aggregator;
+    _unreportedAccumulations = new Map();
+    _reportHistory = new Map();
+    constructor(aggregator, collectorHandles) {
+        this._aggregator = aggregator;
+        collectorHandles.forEach(handle => {
+            this._unreportedAccumulations.set(handle, []);
+        });
+    }
+    /**
+     * Builds the {@link MetricData} streams to report against a specific MetricCollector.
+     * @param collector The information of the MetricCollector.
+     * @param collectors The registered collectors.
+     * @param instrumentDescriptor The instrumentation descriptor that these metrics generated with.
+     * @param currentAccumulations The current accumulation of metric data from instruments.
+     * @param collectionTime The current collection timestamp.
+     * @returns The {@link MetricData} points or `null`.
+     */
+    buildMetrics(collector, instrumentDescriptor, currentAccumulations, collectionTime) {
+        this._stashAccumulations(currentAccumulations);
+        const unreportedAccumulations = this._getMergedUnreportedAccumulations(collector);
+        let result = unreportedAccumulations;
+        let aggregationTemporality;
+        // Check our last report time.
+        if (this._reportHistory.has(collector)) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const last = this._reportHistory.get(collector);
+            const lastCollectionTime = last.collectionTime;
+            aggregationTemporality = last.aggregationTemporality;
+            // Use aggregation temporality + instrument to determine if we do a merge or a diff of
+            // previous. We have the following four scenarios:
+            // 1. Cumulative Aggregation (temporality) + Delta recording (sync instrument).
+            //    Here we merge with our last record to get a cumulative aggregation.
+            // 2. Cumulative Aggregation + Cumulative recording (async instrument).
+            //    Cumulative records are converted to delta recording with DeltaMetricProcessor.
+            //    Here we merge with our last record to get a cumulative aggregation.
+            // 3. Delta Aggregation + Delta recording
+            //    Calibrate the startTime of metric streams to be the reader's lastCollectionTime.
+            // 4. Delta Aggregation + Cumulative recording.
+            //    Cumulative records are converted to delta recording with DeltaMetricProcessor.
+            //    Calibrate the startTime of metric streams to be the reader's lastCollectionTime.
+            if (aggregationTemporality === AggregationTemporality.CUMULATIVE) {
+                // We need to make sure the current delta recording gets merged into the previous cumulative
+                // for the next cumulative recording.
+                result = TemporalMetricProcessor.merge(last.accumulations, unreportedAccumulations, this._aggregator);
+            }
+            else {
+                result = TemporalMetricProcessor.calibrateStartTime(last.accumulations, unreportedAccumulations, lastCollectionTime);
+            }
+        }
+        else {
+            // Call into user code to select aggregation temporality for the instrument.
+            aggregationTemporality = collector.selectAggregationTemporality(instrumentDescriptor.type);
+        }
+        // Update last reported (cumulative) accumulation.
+        this._reportHistory.set(collector, {
+            accumulations: result,
+            collectionTime,
+            aggregationTemporality,
+        });
+        const accumulationRecords = AttributesMapToAccumulationRecords(result);
+        // do not convert to metric data if there is nothing to convert.
+        if (accumulationRecords.length === 0) {
+            return undefined;
+        }
+        return this._aggregator.toMetricData(instrumentDescriptor, aggregationTemporality, accumulationRecords, 
+        /* endTime */ collectionTime);
+    }
+    _stashAccumulations(currentAccumulation) {
+        const registeredCollectors = this._unreportedAccumulations.keys();
+        for (const collector of registeredCollectors) {
+            let stash = this._unreportedAccumulations.get(collector);
+            if (stash === undefined) {
+                stash = [];
+                this._unreportedAccumulations.set(collector, stash);
+            }
+            stash.push(currentAccumulation);
+        }
+    }
+    _getMergedUnreportedAccumulations(collector) {
+        let result = new AttributeHashMap();
+        const unreportedList = this._unreportedAccumulations.get(collector);
+        this._unreportedAccumulations.set(collector, []);
+        if (unreportedList === undefined) {
+            return result;
+        }
+        for (const it of unreportedList) {
+            result = TemporalMetricProcessor.merge(result, it, this._aggregator);
+        }
+        return result;
+    }
+    static merge(last, current, aggregator) {
+        const result = last;
+        const iterator = current.entries();
+        let next = iterator.next();
+        while (next.done !== true) {
+            const [key, record, hash] = next.value;
+            if (last.has(key, hash)) {
+                const lastAccumulation = last.get(key, hash);
+                // last.has() returned true, lastAccumulation is present.
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                const accumulation = aggregator.merge(lastAccumulation, record);
+                result.set(key, accumulation, hash);
+            }
+            else {
+                result.set(key, record, hash);
+            }
+            next = iterator.next();
+        }
+        return result;
+    }
+    /**
+     * Calibrate the reported metric streams' startTime to lastCollectionTime. Leaves
+     * the new stream to be the initial observation time unchanged.
+     */
+    static calibrateStartTime(last, current, lastCollectionTime) {
+        for (const [key, hash] of last.keys()) {
+            const currentAccumulation = current.get(key, hash);
+            currentAccumulation?.setStartTime(lastCollectionTime);
+        }
+        return current;
+    }
+}
+// TypeScript complains about converting 3 elements tuple to AccumulationRecord<T>.
+function AttributesMapToAccumulationRecords(map) {
+    return Array.from(map.entries());
+}
+//# sourceMappingURL=TemporalMetricProcessor.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/state/TemporalMetricProcessor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TemporalMetricProcessor.js","sourceRoot":"","sources":["../../../src/state/TemporalMetricProcessor.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 {\n  Accumulation,\n  AccumulationRecord,\n  Aggregator,\n} from '../aggregator/types';\nimport { MetricData } from '../export/MetricData';\nimport { InstrumentDescriptor } from '../InstrumentDescriptor';\nimport { AggregationTemporality } from '../export/AggregationTemporality';\nimport { Maybe } from '../utils';\nimport { MetricCollectorHandle } from './MetricCollector';\nimport { AttributeHashMap } from './HashMap';\n\n/**\n * Remembers what was presented to a specific exporter.\n */\ninterface LastReportedHistory<T extends Maybe<Accumulation>> {\n  /**\n   * The last accumulation of metric data.\n   */\n  accumulations: AttributeHashMap<T>;\n  /**\n   * The timestamp the data was reported.\n   */\n  collectionTime: HrTime;\n  /**\n   * The AggregationTemporality used to aggregate reports.\n   */\n  aggregationTemporality: AggregationTemporality;\n}\n\n/**\n * Internal interface.\n *\n * Provides unique reporting for each collector. Allows synchronous collection\n * of metrics and reports given temporality values.\n */\nexport class TemporalMetricProcessor<T extends Maybe<Accumulation>> {\n  private _aggregator: Aggregator<T>;\n  private _unreportedAccumulations = new Map<\n    MetricCollectorHandle,\n    AttributeHashMap<T>[]\n  >();\n  private _reportHistory = new Map<\n    MetricCollectorHandle,\n    LastReportedHistory<T>\n  >();\n\n  constructor(\n    aggregator: Aggregator<T>,\n    collectorHandles: MetricCollectorHandle[]\n  ) {\n    this._aggregator = aggregator;\n    collectorHandles.forEach(handle => {\n      this._unreportedAccumulations.set(handle, []);\n    });\n  }\n\n  /**\n   * Builds the {@link MetricData} streams to report against a specific MetricCollector.\n   * @param collector The information of the MetricCollector.\n   * @param collectors The registered collectors.\n   * @param instrumentDescriptor The instrumentation descriptor that these metrics generated with.\n   * @param currentAccumulations The current accumulation of metric data from instruments.\n   * @param collectionTime The current collection timestamp.\n   * @returns The {@link MetricData} points or `null`.\n   */\n  buildMetrics(\n    collector: MetricCollectorHandle,\n    instrumentDescriptor: InstrumentDescriptor,\n    currentAccumulations: AttributeHashMap<T>,\n    collectionTime: HrTime\n  ): Maybe<MetricData> {\n    this._stashAccumulations(currentAccumulations);\n    const unreportedAccumulations =\n      this._getMergedUnreportedAccumulations(collector);\n\n    let result = unreportedAccumulations;\n    let aggregationTemporality: AggregationTemporality;\n    // Check our last report time.\n    if (this._reportHistory.has(collector)) {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      const last = this._reportHistory.get(collector)!;\n      const lastCollectionTime = last.collectionTime;\n      aggregationTemporality = last.aggregationTemporality;\n\n      // Use aggregation temporality + instrument to determine if we do a merge or a diff of\n      // previous. We have the following four scenarios:\n      // 1. Cumulative Aggregation (temporality) + Delta recording (sync instrument).\n      //    Here we merge with our last record to get a cumulative aggregation.\n      // 2. Cumulative Aggregation + Cumulative recording (async instrument).\n      //    Cumulative records are converted to delta recording with DeltaMetricProcessor.\n      //    Here we merge with our last record to get a cumulative aggregation.\n      // 3. Delta Aggregation + Delta recording\n      //    Calibrate the startTime of metric streams to be the reader's lastCollectionTime.\n      // 4. Delta Aggregation + Cumulative recording.\n      //    Cumulative records are converted to delta recording with DeltaMetricProcessor.\n      //    Calibrate the startTime of metric streams to be the reader's lastCollectionTime.\n      if (aggregationTemporality === AggregationTemporality.CUMULATIVE) {\n        // We need to make sure the current delta recording gets merged into the previous cumulative\n        // for the next cumulative recording.\n        result = TemporalMetricProcessor.merge(\n          last.accumulations,\n          unreportedAccumulations,\n          this._aggregator\n        );\n      } else {\n        result = TemporalMetricProcessor.calibrateStartTime(\n          last.accumulations,\n          unreportedAccumulations,\n          lastCollectionTime\n        );\n      }\n    } else {\n      // Call into user code to select aggregation temporality for the instrument.\n      aggregationTemporality = collector.selectAggregationTemporality(\n        instrumentDescriptor.type\n      );\n    }\n\n    // Update last reported (cumulative) accumulation.\n    this._reportHistory.set(collector, {\n      accumulations: result,\n      collectionTime,\n      aggregationTemporality,\n    });\n\n    const accumulationRecords = AttributesMapToAccumulationRecords(result);\n\n    // do not convert to metric data if there is nothing to convert.\n    if (accumulationRecords.length === 0) {\n      return undefined;\n    }\n\n    return this._aggregator.toMetricData(\n      instrumentDescriptor,\n      aggregationTemporality,\n      accumulationRecords,\n      /* endTime */ collectionTime\n    );\n  }\n\n  private _stashAccumulations(currentAccumulation: AttributeHashMap<T>) {\n    const registeredCollectors = this._unreportedAccumulations.keys();\n    for (const collector of registeredCollectors) {\n      let stash = this._unreportedAccumulations.get(collector);\n      if (stash === undefined) {\n        stash = [];\n        this._unreportedAccumulations.set(collector, stash);\n      }\n      stash.push(currentAccumulation);\n    }\n  }\n\n  private _getMergedUnreportedAccumulations(collector: MetricCollectorHandle) {\n    let result = new AttributeHashMap<T>();\n    const unreportedList = this._unreportedAccumulations.get(collector);\n    this._unreportedAccumulations.set(collector, []);\n    if (unreportedList === undefined) {\n      return result;\n    }\n    for (const it of unreportedList) {\n      result = TemporalMetricProcessor.merge(result, it, this._aggregator);\n    }\n    return result;\n  }\n\n  static merge<T extends Maybe<Accumulation>>(\n    last: AttributeHashMap<T>,\n    current: AttributeHashMap<T>,\n    aggregator: Aggregator<T>\n  ) {\n    const result = last;\n    const iterator = current.entries();\n    let next = iterator.next();\n    while (next.done !== true) {\n      const [key, record, hash] = next.value;\n      if (last.has(key, hash)) {\n        const lastAccumulation = last.get(key, hash);\n        // last.has() returned true, lastAccumulation is present.\n        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n        const accumulation = aggregator.merge(lastAccumulation!, record);\n        result.set(key, accumulation, hash);\n      } else {\n        result.set(key, record, hash);\n      }\n\n      next = iterator.next();\n    }\n    return result;\n  }\n\n  /**\n   * Calibrate the reported metric streams' startTime to lastCollectionTime. Leaves\n   * the new stream to be the initial observation time unchanged.\n   */\n  static calibrateStartTime<T extends Maybe<Accumulation>>(\n    last: AttributeHashMap<T>,\n    current: AttributeHashMap<T>,\n    lastCollectionTime: HrTime\n  ) {\n    for (const [key, hash] of last.keys()) {\n      const currentAccumulation = current.get(key, hash);\n      currentAccumulation?.setStartTime(lastCollectionTime);\n    }\n    return current;\n  }\n}\n\n// TypeScript complains about converting 3 elements tuple to AccumulationRecord<T>.\nfunction AttributesMapToAccumulationRecords<T>(\n  map: AttributeHashMap<T>\n): AccumulationRecord<T>[] {\n  return Array.from(map.entries()) as unknown as AccumulationRecord<T>[];\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/state/WritableMetricStorage.d.ts

@@ -0,0 +1,23 @@
+import { Context, HrTime, Attributes } from '@opentelemetry/api';
+import { AttributeHashMap } from './HashMap';
+/**
+ * Internal interface. Stores measurements and allows synchronous writes of
+ * measurements.
+ *
+ * An interface representing SyncMetricStorage with type parameters removed.
+ */
+export interface WritableMetricStorage {
+    /** Records a measurement. */
+    record(value: number, attributes: Attributes, context: Context, recordTime: HrTime): void;
+}
+/**
+ * Internal interface. Stores measurements and allows asynchronous writes of
+ * measurements.
+ *
+ * An interface representing AsyncMetricStorage with type parameters removed.
+ */
+export interface AsyncWritableMetricStorage {
+    /** Records a batch of measurements. */
+    record(measurements: AttributeHashMap<number>, observationTime: HrTime): void;
+}
+//# sourceMappingURL=WritableMetricStorage.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/state/WritableMetricStorage.js

@@ -0,0 +1,17 @@
+/*
+ * 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.
+ */
+export {};
+//# sourceMappingURL=WritableMetricStorage.js.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/state/WritableMetricStorage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WritableMetricStorage.js","sourceRoot":"","sources":["../../../src/state/WritableMetricStorage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG","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 { AttributeHashMap } from './HashMap';\n\n/**\n * Internal interface. Stores measurements and allows synchronous writes of\n * measurements.\n *\n * An interface representing SyncMetricStorage with type parameters removed.\n */\nexport interface WritableMetricStorage {\n  /** Records a measurement. */\n  record(\n    value: number,\n    attributes: Attributes,\n    context: Context,\n    recordTime: HrTime\n  ): void;\n}\n\n/**\n * Internal interface. Stores measurements and allows asynchronous writes of\n * measurements.\n *\n * An interface representing AsyncMetricStorage with type parameters removed.\n */\nexport interface AsyncWritableMetricStorage {\n  /** Records a batch of measurements. */\n  record(measurements: AttributeHashMap<number>, observationTime: HrTime): void;\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/types.d.ts

@@ -0,0 +1,7 @@
+export type CommonReaderOptions = {
+    timeoutMillis?: number;
+};
+export type CollectionOptions = CommonReaderOptions;
+export type ShutdownOptions = CommonReaderOptions;
+export type ForceFlushOptions = CommonReaderOptions;
+//# sourceMappingURL=types.d.ts.map

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/esm/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport type CommonReaderOptions = {\n  timeoutMillis?: number;\n};\n\nexport type CollectionOptions = CommonReaderOptions;\n\nexport type ShutdownOptions = CommonReaderOptions;\n\nexport type ForceFlushOptions = CommonReaderOptions;\n"]}