decocms 2.388.2 → 2.388.3

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

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

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

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

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

@@ -0,0 +1,118 @@
+/*
+ * 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 * as api from '@opentelemetry/api';
+import { internal, ExportResultCode, globalErrorHandler, } from '@opentelemetry/core';
+import { MetricReader } from './MetricReader';
+import { callWithTimeout, TimeoutError } from '../utils';
+/**
+ * {@link MetricReader} which collects metrics based on a user-configurable time interval, and passes the metrics to
+ * the configured {@link PushMetricExporter}
+ */
+export class PeriodicExportingMetricReader extends MetricReader {
+    _interval;
+    _exporter;
+    _exportInterval;
+    _exportTimeout;
+    constructor(options) {
+        const { exporter, exportIntervalMillis = 60000, metricProducers } = options;
+        let { exportTimeoutMillis = 30000 } = options;
+        super({
+            aggregationSelector: exporter.selectAggregation?.bind(exporter),
+            aggregationTemporalitySelector: exporter.selectAggregationTemporality?.bind(exporter),
+            metricProducers,
+        });
+        if (exportIntervalMillis <= 0) {
+            throw Error('exportIntervalMillis must be greater than 0');
+        }
+        if (exportTimeoutMillis <= 0) {
+            throw Error('exportTimeoutMillis must be greater than 0');
+        }
+        if (exportIntervalMillis < exportTimeoutMillis) {
+            if ('exportIntervalMillis' in options &&
+                'exportTimeoutMillis' in options) {
+                // An invalid combination of values was explicitly provided.
+                throw Error('exportIntervalMillis must be greater than or equal to exportTimeoutMillis');
+            }
+            else {
+                // An invalid combination of value was implicitly provided.
+                api.diag.info(`Timeout of ${exportTimeoutMillis} exceeds the interval of ${exportIntervalMillis}. Clamping timeout to interval duration.`);
+                exportTimeoutMillis = exportIntervalMillis;
+            }
+        }
+        this._exportInterval = exportIntervalMillis;
+        this._exportTimeout = exportTimeoutMillis;
+        this._exporter = exporter;
+    }
+    async _runOnce() {
+        try {
+            await callWithTimeout(this._doRun(), this._exportTimeout);
+        }
+        catch (err) {
+            if (err instanceof TimeoutError) {
+                api.diag.error('Export took longer than %s milliseconds and timed out.', this._exportTimeout);
+                return;
+            }
+            globalErrorHandler(err);
+        }
+    }
+    async _doRun() {
+        const { resourceMetrics, errors } = await this.collect({
+            timeoutMillis: this._exportTimeout,
+        });
+        if (errors.length > 0) {
+            api.diag.error('PeriodicExportingMetricReader: metrics collection errors', ...errors);
+        }
+        if (resourceMetrics.resource.asyncAttributesPending) {
+            try {
+                await resourceMetrics.resource.waitForAsyncAttributes?.();
+            }
+            catch (e) {
+                api.diag.debug('Error while resolving async portion of resource: ', e);
+                globalErrorHandler(e);
+            }
+        }
+        if (resourceMetrics.scopeMetrics.length === 0) {
+            return;
+        }
+        const result = await internal._export(this._exporter, resourceMetrics);
+        if (result.code !== ExportResultCode.SUCCESS) {
+            throw new Error(`PeriodicExportingMetricReader: metrics export failed (error ${result.error})`);
+        }
+    }
+    onInitialized() {
+        // start running the interval as soon as this reader is initialized and keep handle for shutdown.
+        this._interval = setInterval(() => {
+            // this._runOnce never rejects. Using void operator to suppress @typescript-eslint/no-floating-promises.
+            void this._runOnce();
+        }, this._exportInterval);
+        // depending on runtime, this may be a 'number' or NodeJS.Timeout
+        if (typeof this._interval !== 'number') {
+            this._interval.unref();
+        }
+    }
+    async onForceFlush() {
+        await this._runOnce();
+        await this._exporter.forceFlush();
+    }
+    async onShutdown() {
+        if (this._interval) {
+            clearInterval(this._interval);
+        }
+        await this.onForceFlush();
+        await this._exporter.shutdown();
+    }
+}
+//# sourceMappingURL=PeriodicExportingMetricReader.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PeriodicExportingMetricReader.js","sourceRoot":"","sources":["../../../src/export/PeriodicExportingMetricReader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,GAAG,MAAM,oBAAoB,CAAC;AAC1C,OAAO,EACL,QAAQ,EACR,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AA0BzD;;;GAGG;AACH,MAAM,OAAO,6BAA8B,SAAQ,YAAY;IACrD,SAAS,CAAkC;IAC3C,SAAS,CAAqB;IACrB,eAAe,CAAS;IACxB,cAAc,CAAS;IAExC,YAAY,OAA6C;QACvD,MAAM,EAAE,QAAQ,EAAE,oBAAoB,GAAG,KAAK,EAAE,eAAe,EAAE,GAAG,OAAO,CAAC;QAC5E,IAAI,EAAE,mBAAmB,GAAG,KAAK,EAAE,GAAG,OAAO,CAAC;QAE9C,KAAK,CAAC;YACJ,mBAAmB,EAAE,QAAQ,CAAC,iBAAiB,EAAE,IAAI,CAAC,QAAQ,CAAC;YAC/D,8BAA8B,EAC5B,QAAQ,CAAC,4BAA4B,EAAE,IAAI,CAAC,QAAQ,CAAC;YACvD,eAAe;SAChB,CAAC,CAAC;QAEH,IAAI,oBAAoB,IAAI,CAAC,EAAE;YAC7B,MAAM,KAAK,CAAC,6CAA6C,CAAC,CAAC;SAC5D;QAED,IAAI,mBAAmB,IAAI,CAAC,EAAE;YAC5B,MAAM,KAAK,CAAC,4CAA4C,CAAC,CAAC;SAC3D;QAED,IAAI,oBAAoB,GAAG,mBAAmB,EAAE;YAC9C,IACE,sBAAsB,IAAI,OAAO;gBACjC,qBAAqB,IAAI,OAAO,EAChC;gBACA,4DAA4D;gBAC5D,MAAM,KAAK,CACT,2EAA2E,CAC5E,CAAC;aACH;iBAAM;gBACL,2DAA2D;gBAC3D,GAAG,CAAC,IAAI,CAAC,IAAI,CACX,cAAc,mBAAmB,4BAA4B,oBAAoB,0CAA0C,CAC5H,CAAC;gBACF,mBAAmB,GAAG,oBAAoB,CAAC;aAC5C;SACF;QAED,IAAI,CAAC,eAAe,GAAG,oBAAoB,CAAC;QAC5C,IAAI,CAAC,cAAc,GAAG,mBAAmB,CAAC;QAC1C,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;IAC5B,CAAC;IAEO,KAAK,CAAC,QAAQ;QACpB,IAAI;YACF,MAAM,eAAe,CAAC,IAAI,CAAC,MAAM,EAAE,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;SAC3D;QAAC,OAAO,GAAG,EAAE;YACZ,IAAI,GAAG,YAAY,YAAY,EAAE;gBAC/B,GAAG,CAAC,IAAI,CAAC,KAAK,CACZ,wDAAwD,EACxD,IAAI,CAAC,cAAc,CACpB,CAAC;gBACF,OAAO;aACR;YAED,kBAAkB,CAAC,GAAG,CAAC,CAAC;SACzB;IACH,CAAC;IAEO,KAAK,CAAC,MAAM;QAClB,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC;YACrD,aAAa,EAAE,IAAI,CAAC,cAAc;SACnC,CAAC,CAAC;QAEH,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YACrB,GAAG,CAAC,IAAI,CAAC,KAAK,CACZ,0DAA0D,EAC1D,GAAG,MAAM,CACV,CAAC;SACH;QAED,IAAI,eAAe,CAAC,QAAQ,CAAC,sBAAsB,EAAE;YACnD,IAAI;gBACF,MAAM,eAAe,CAAC,QAAQ,CAAC,sBAAsB,EAAE,EAAE,CAAC;aAC3D;YAAC,OAAO,CAAC,EAAE;gBACV,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,mDAAmD,EAAE,CAAC,CAAC,CAAC;gBACvE,kBAAkB,CAAC,CAAC,CAAC,CAAC;aACvB;SACF;QAED,IAAI,eAAe,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;YAC7C,OAAO;SACR;QAED,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;QACvE,IAAI,MAAM,CAAC,IAAI,KAAK,gBAAgB,CAAC,OAAO,EAAE;YAC5C,MAAM,IAAI,KAAK,CACb,+DAA+D,MAAM,CAAC,KAAK,GAAG,CAC/E,CAAC;SACH;IACH,CAAC;IAEkB,aAAa;QAC9B,iGAAiG;QACjG,IAAI,CAAC,SAAS,GAAG,WAAW,CAAC,GAAG,EAAE;YAChC,wGAAwG;YACxG,KAAK,IAAI,CAAC,QAAQ,EAAE,CAAC;QACvB,CAAC,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;QAEzB,iEAAiE;QACjE,IAAI,OAAO,IAAI,CAAC,SAAS,KAAK,QAAQ,EAAE;YACtC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;SACxB;IACH,CAAC;IAES,KAAK,CAAC,YAAY;QAC1B,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAC;QACtB,MAAM,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,CAAC;IACpC,CAAC;IAES,KAAK,CAAC,UAAU;QACxB,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;SAC/B;QACD,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;QAC1B,MAAM,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IAClC,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 * as api from '@opentelemetry/api';\nimport {\n  internal,\n  ExportResultCode,\n  globalErrorHandler,\n} from '@opentelemetry/core';\nimport { MetricReader } from './MetricReader';\nimport { PushMetricExporter } from './MetricExporter';\nimport { callWithTimeout, TimeoutError } from '../utils';\nimport { MetricProducer } from './MetricProducer';\n\nexport type PeriodicExportingMetricReaderOptions = {\n  /**\n   * The backing exporter for the metric reader.\n   */\n  exporter: PushMetricExporter;\n  /**\n   * An internal milliseconds for the metric reader to initiate metric\n   * collection.\n   */\n  exportIntervalMillis?: number;\n  /**\n   * Milliseconds for the async observable callback to timeout.\n   */\n  exportTimeoutMillis?: number;\n  /**\n   * **Note, this option is experimental**. Additional MetricProducers to use as a source of\n   * aggregated metric data in addition to the SDK's metric data. The resource returned by\n   * these MetricProducers is ignored; the SDK's resource will be used instead.\n   * @experimental\n   */\n  metricProducers?: MetricProducer[];\n};\n\n/**\n * {@link MetricReader} which collects metrics based on a user-configurable time interval, and passes the metrics to\n * the configured {@link PushMetricExporter}\n */\nexport class PeriodicExportingMetricReader extends MetricReader {\n  private _interval?: ReturnType<typeof setInterval>;\n  private _exporter: PushMetricExporter;\n  private readonly _exportInterval: number;\n  private readonly _exportTimeout: number;\n\n  constructor(options: PeriodicExportingMetricReaderOptions) {\n    const { exporter, exportIntervalMillis = 60000, metricProducers } = options;\n    let { exportTimeoutMillis = 30000 } = options;\n\n    super({\n      aggregationSelector: exporter.selectAggregation?.bind(exporter),\n      aggregationTemporalitySelector:\n        exporter.selectAggregationTemporality?.bind(exporter),\n      metricProducers,\n    });\n\n    if (exportIntervalMillis <= 0) {\n      throw Error('exportIntervalMillis must be greater than 0');\n    }\n\n    if (exportTimeoutMillis <= 0) {\n      throw Error('exportTimeoutMillis must be greater than 0');\n    }\n\n    if (exportIntervalMillis < exportTimeoutMillis) {\n      if (\n        'exportIntervalMillis' in options &&\n        'exportTimeoutMillis' in options\n      ) {\n        // An invalid combination of values was explicitly provided.\n        throw Error(\n          'exportIntervalMillis must be greater than or equal to exportTimeoutMillis'\n        );\n      } else {\n        // An invalid combination of value was implicitly provided.\n        api.diag.info(\n          `Timeout of ${exportTimeoutMillis} exceeds the interval of ${exportIntervalMillis}. Clamping timeout to interval duration.`\n        );\n        exportTimeoutMillis = exportIntervalMillis;\n      }\n    }\n\n    this._exportInterval = exportIntervalMillis;\n    this._exportTimeout = exportTimeoutMillis;\n    this._exporter = exporter;\n  }\n\n  private async _runOnce(): Promise<void> {\n    try {\n      await callWithTimeout(this._doRun(), this._exportTimeout);\n    } catch (err) {\n      if (err instanceof TimeoutError) {\n        api.diag.error(\n          'Export took longer than %s milliseconds and timed out.',\n          this._exportTimeout\n        );\n        return;\n      }\n\n      globalErrorHandler(err);\n    }\n  }\n\n  private async _doRun(): Promise<void> {\n    const { resourceMetrics, errors } = await this.collect({\n      timeoutMillis: this._exportTimeout,\n    });\n\n    if (errors.length > 0) {\n      api.diag.error(\n        'PeriodicExportingMetricReader: metrics collection errors',\n        ...errors\n      );\n    }\n\n    if (resourceMetrics.resource.asyncAttributesPending) {\n      try {\n        await resourceMetrics.resource.waitForAsyncAttributes?.();\n      } catch (e) {\n        api.diag.debug('Error while resolving async portion of resource: ', e);\n        globalErrorHandler(e);\n      }\n    }\n\n    if (resourceMetrics.scopeMetrics.length === 0) {\n      return;\n    }\n\n    const result = await internal._export(this._exporter, resourceMetrics);\n    if (result.code !== ExportResultCode.SUCCESS) {\n      throw new Error(\n        `PeriodicExportingMetricReader: metrics export failed (error ${result.error})`\n      );\n    }\n  }\n\n  protected override onInitialized(): void {\n    // start running the interval as soon as this reader is initialized and keep handle for shutdown.\n    this._interval = setInterval(() => {\n      // this._runOnce never rejects. Using void operator to suppress @typescript-eslint/no-floating-promises.\n      void this._runOnce();\n    }, this._exportInterval);\n\n    // depending on runtime, this may be a 'number' or NodeJS.Timeout\n    if (typeof this._interval !== 'number') {\n      this._interval.unref();\n    }\n  }\n\n  protected async onForceFlush(): Promise<void> {\n    await this._runOnce();\n    await this._exporter.forceFlush();\n  }\n\n  protected async onShutdown(): Promise<void> {\n    if (this._interval) {\n      clearInterval(this._interval);\n    }\n    await this.onForceFlush();\n    await this._exporter.shutdown();\n  }\n}\n"]}

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

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

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

@@ -0,0 +1,26 @@
+/*
+ * 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 { AggregationTemporality } from './export/AggregationTemporality';
+export { DataPointType, InstrumentType } from './export/MetricData';
+export { MetricReader } from './export/MetricReader';
+export { PeriodicExportingMetricReader } from './export/PeriodicExportingMetricReader';
+export { InMemoryMetricExporter } from './export/InMemoryMetricExporter';
+export { ConsoleMetricExporter } from './export/ConsoleMetricExporter';
+export { MeterProvider } from './MeterProvider';
+export { AggregationType } from './view/AggregationOption';
+export { createAllowListAttributesProcessor, createDenyListAttributesProcessor, } from './view/AttributesProcessor';
+export { TimeoutError } from './utils';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAcH,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAEzE,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAgBpE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAGrD,OAAO,EAAE,6BAA6B,EAAE,MAAM,wCAAwC,CAAC;AAGvF,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAEzE,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAOvE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAM3D,OAAO,EACL,kCAAkC,EAClC,iCAAiC,GAClC,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport type {\n  Sum,\n  LastValue,\n  Histogram,\n  ExponentialHistogram,\n} from './aggregator/types';\n\nexport type {\n  AggregationSelector,\n  AggregationTemporalitySelector,\n} from './export/AggregationSelector';\n\nexport { AggregationTemporality } from './export/AggregationTemporality';\n\nexport { DataPointType, InstrumentType } from './export/MetricData';\nexport type {\n  DataPoint,\n  SumMetricData,\n  GaugeMetricData,\n  HistogramMetricData,\n  ExponentialHistogramMetricData,\n  ResourceMetrics,\n  ScopeMetrics,\n  MetricData,\n  MetricDescriptor,\n  CollectionResult,\n} from './export/MetricData';\n\nexport type { PushMetricExporter } from './export/MetricExporter';\n\nexport { MetricReader } from './export/MetricReader';\nexport type { IMetricReader, MetricReaderOptions } from './export/MetricReader';\n\nexport { PeriodicExportingMetricReader } from './export/PeriodicExportingMetricReader';\nexport type { PeriodicExportingMetricReaderOptions } from './export/PeriodicExportingMetricReader';\n\nexport { InMemoryMetricExporter } from './export/InMemoryMetricExporter';\n\nexport { ConsoleMetricExporter } from './export/ConsoleMetricExporter';\n\nexport type {\n  MetricCollectOptions,\n  MetricProducer,\n} from './export/MetricProducer';\n\nexport { MeterProvider } from './MeterProvider';\nexport type { MeterProviderOptions } from './MeterProvider';\n\nexport { AggregationType } from './view/AggregationOption';\nexport type { AggregationOption } from './view/AggregationOption';\n\nexport type { ViewOptions } from './view/View';\n\nexport type { IAttributesProcessor } from './view/AttributesProcessor';\nexport {\n  createAllowListAttributesProcessor,\n  createDenyListAttributesProcessor,\n} from './view/AttributesProcessor';\n\nexport { TimeoutError } from './utils';\n"]}

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

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

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

@@ -0,0 +1,56 @@
+/*
+ * 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';
+import { AttributeHashMap } from './HashMap';
+/**
+ * Internal interface.
+ *
+ * Stores and aggregates {@link MetricData} for asynchronous instruments.
+ */
+export class AsyncMetricStorage 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(measurements, observationTime) {
+        const processed = new AttributeHashMap();
+        Array.from(measurements.entries()).forEach(([attributes, value]) => {
+            processed.set(this._attributesProcessor.process(attributes), value);
+        });
+        this._deltaMetricStorage.batchCumulate(processed, observationTime);
+    }
+    /**
+     * Collects the metrics from this storage. The ObservableCallback is invoked
+     * during the collection.
+     *
+     * Note: This is a stateful operation and may reset any interval-related
+     * state for the MetricCollector.
+     */
+    collect(collector, collectionTime) {
+        const accumulations = this._deltaMetricStorage.collect();
+        return this._temporalMetricStorage.buildMetrics(collector, this._instrumentDescriptor, accumulations, collectionTime);
+    }
+}
+//# sourceMappingURL=AsyncMetricStorage.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"AsyncMetricStorage.js","sourceRoot":"","sources":["../../../src/state/AsyncMetricStorage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAKH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAGpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAI7C;;;;GAIG;AACH,MAAM,OAAO,kBACX,SAAQ,aAAa;IAGb,4BAA4B,CAAU;IACtC,mBAAmB,CAA0B;IAC7C,sBAAsB,CAA6B;IACnD,oBAAoB,CAAuB;IAEnD,YACE,qBAA2C,EAC3C,UAAyB,EACzB,mBAAyC,EACzC,gBAAyC,EACzC,2BAAoC;QAEpC,KAAK,CAAC,qBAAqB,CAAC,CAAC;QAC7B,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,CAAC,YAAsC,EAAE,eAAuB;QACpE,MAAM,SAAS,GAAG,IAAI,gBAAgB,EAAU,CAAC;QACjD,KAAK,CAAC,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,EAAE,KAAK,CAAC,EAAE,EAAE;YACjE,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,KAAK,CAAC,CAAC;QACtE,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,mBAAmB,CAAC,aAAa,CAAC,SAAS,EAAE,eAAe,CAAC,CAAC;IACrE,CAAC;IAED;;;;;;OAMG;IACH,OAAO,CACL,SAAgC,EAChC,cAAsB;QAEtB,MAAM,aAAa,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,EAAE,CAAC;QAEzD,OAAO,IAAI,CAAC,sBAAsB,CAAC,YAAY,CAC7C,SAAS,EACT,IAAI,CAAC,qBAAqB,EAC1B,aAAa,EACb,cAAc,CACf,CAAC;IACJ,CAAC;CACF","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { HrTime } from '@opentelemetry/api';\nimport { Accumulation, Aggregator } from '../aggregator/types';\nimport { InstrumentDescriptor } from '../InstrumentDescriptor';\nimport { MetricStorage } from './MetricStorage';\nimport { MetricData } from '../export/MetricData';\nimport { DeltaMetricProcessor } from './DeltaMetricProcessor';\nimport { TemporalMetricProcessor } from './TemporalMetricProcessor';\nimport { Maybe } from '../utils';\nimport { MetricCollectorHandle } from './MetricCollector';\nimport { AttributeHashMap } from './HashMap';\nimport { AsyncWritableMetricStorage } from './WritableMetricStorage';\nimport { IAttributesProcessor } from '../view/AttributesProcessor';\n\n/**\n * Internal interface.\n *\n * Stores and aggregates {@link MetricData} for asynchronous instruments.\n */\nexport class AsyncMetricStorage<T extends Maybe<Accumulation>>\n  extends MetricStorage\n  implements AsyncWritableMetricStorage\n{\n  private _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(measurements: AttributeHashMap<number>, observationTime: HrTime) {\n    const processed = new AttributeHashMap<number>();\n    Array.from(measurements.entries()).forEach(([attributes, value]) => {\n      processed.set(this._attributesProcessor.process(attributes), value);\n    });\n    this._deltaMetricStorage.batchCumulate(processed, observationTime);\n  }\n\n  /**\n   * Collects the metrics from this storage. The ObservableCallback is invoked\n   * during the collection.\n   *\n   * Note: This is a stateful operation and may reset any interval-related\n   * state for the MetricCollector.\n   */\n  collect(\n    collector: MetricCollectorHandle,\n    collectionTime: HrTime\n  ): Maybe<MetricData> {\n    const accumulations = this._deltaMetricStorage.collect();\n\n    return this._temporalMetricStorage.buildMetrics(\n      collector,\n      this._instrumentDescriptor,\n      accumulations,\n      collectionTime\n    );\n  }\n}\n"]}

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

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

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"DeltaMetricProcessor.js","sourceRoot":"","sources":["../../../src/state/DeltaMetricProcessor.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Context, HrTime, Attributes } from '@opentelemetry/api';\nimport { Maybe, hashAttributes } from '../utils';\nimport { Accumulation, Aggregator } from '../aggregator/types';\nimport { AttributeHashMap } from './HashMap';\n\n/**\n * Internal interface.\n *\n * Allows synchronous collection of metrics. This processor should allow\n * allocation of new aggregation cells for metrics and convert cumulative\n * recording to delta data points.\n */\nexport class DeltaMetricProcessor<T extends Maybe<Accumulation>> {\n  private _activeCollectionStorage = new AttributeHashMap<T>();\n  // TODO: find a reasonable mean to clean the memo;\n  // https://github.com/open-telemetry/opentelemetry-specification/pull/2208\n  private _cumulativeMemoStorage = new AttributeHashMap<T>();\n  private _cardinalityLimit: number;\n  private _overflowAttributes = { 'otel.metric.overflow': true };\n  private _overflowHashCode: string;\n  private _aggregator: Aggregator<T>;\n\n  constructor(aggregator: Aggregator<T>, aggregationCardinalityLimit?: number) {\n    this._aggregator = aggregator;\n    this._cardinalityLimit = (aggregationCardinalityLimit ?? 2000) - 1;\n    this._overflowHashCode = hashAttributes(this._overflowAttributes);\n  }\n\n  record(\n    value: number,\n    attributes: Attributes,\n    _context: Context,\n    collectionTime: HrTime\n  ) {\n    let accumulation = this._activeCollectionStorage.get(attributes);\n\n    if (!accumulation) {\n      if (this._activeCollectionStorage.size >= this._cardinalityLimit) {\n        const overflowAccumulation = this._activeCollectionStorage.getOrDefault(\n          this._overflowAttributes,\n          () => this._aggregator.createAccumulation(collectionTime)\n        );\n        overflowAccumulation?.record(value);\n        return;\n      }\n\n      accumulation = this._aggregator.createAccumulation(collectionTime);\n      this._activeCollectionStorage.set(attributes, accumulation);\n    }\n\n    accumulation?.record(value);\n  }\n\n  batchCumulate(\n    measurements: AttributeHashMap<number>,\n    collectionTime: HrTime\n  ) {\n    Array.from(measurements.entries()).forEach(\n      ([attributes, value, hashCode]) => {\n        const accumulation =\n          this._aggregator.createAccumulation(collectionTime);\n        accumulation?.record(value);\n        let delta = accumulation;\n        // Diff with recorded cumulative memo.\n        if (this._cumulativeMemoStorage.has(attributes, hashCode)) {\n          // has() returned true, previous is present.\n          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n          const previous = this._cumulativeMemoStorage.get(\n            attributes,\n            hashCode\n          )!;\n          delta = this._aggregator.diff(previous, accumulation);\n        } else {\n          // If the cardinality limit is reached, we need to change the attributes\n          if (this._cumulativeMemoStorage.size >= this._cardinalityLimit) {\n            attributes = this._overflowAttributes;\n            hashCode = this._overflowHashCode;\n            if (this._cumulativeMemoStorage.has(attributes, hashCode)) {\n              // has() returned true, previous is present.\n              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n              const previous = this._cumulativeMemoStorage.get(\n                attributes,\n                hashCode\n              )!;\n              delta = this._aggregator.diff(previous, accumulation);\n            }\n          }\n        }\n        // Merge with uncollected active delta.\n        if (this._activeCollectionStorage.has(attributes, hashCode)) {\n          // has() returned true, active is present.\n          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n          const active = this._activeCollectionStorage.get(\n            attributes,\n            hashCode\n          )!;\n          delta = this._aggregator.merge(active, delta);\n        }\n\n        // Save the current record and the delta record.\n        this._cumulativeMemoStorage.set(attributes, accumulation, hashCode);\n        this._activeCollectionStorage.set(attributes, delta, hashCode);\n      }\n    );\n  }\n\n  /**\n   * Returns a collection of delta metrics. Start time is the when first\n   * time event collected.\n   */\n  collect() {\n    const unreportedDelta = this._activeCollectionStorage;\n    this._activeCollectionStorage = new AttributeHashMap();\n\n    return unreportedDelta;\n  }\n}\n"]}

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

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

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

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