decocms 2.333.0 → 2.334.0

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

@@ -0,0 +1,187 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HistogramAggregator = exports.HistogramAccumulation = void 0;
+const types_1 = require("./types");
+const MetricData_1 = require("../export/MetricData");
+const utils_1 = require("../utils");
+function createNewEmptyCheckpoint(boundaries) {
+    const counts = boundaries.map(() => 0);
+    counts.push(0);
+    return {
+        buckets: {
+            boundaries,
+            counts,
+        },
+        sum: 0,
+        count: 0,
+        hasMinMax: false,
+        min: Infinity,
+        max: -Infinity,
+    };
+}
+class HistogramAccumulation {
+    startTime;
+    _boundaries;
+    _recordMinMax;
+    _current;
+    constructor(startTime, _boundaries, _recordMinMax = true, _current = createNewEmptyCheckpoint(_boundaries)) {
+        this.startTime = startTime;
+        this._boundaries = _boundaries;
+        this._recordMinMax = _recordMinMax;
+        this._current = _current;
+    }
+    record(value) {
+        // NaN does not fall into any bucket, is not zero and should not be counted,
+        // NaN is never greater than max nor less than min, therefore return as there's nothing for us to do.
+        if (Number.isNaN(value)) {
+            return;
+        }
+        this._current.count += 1;
+        this._current.sum += value;
+        if (this._recordMinMax) {
+            this._current.min = Math.min(value, this._current.min);
+            this._current.max = Math.max(value, this._current.max);
+            this._current.hasMinMax = true;
+        }
+        const idx = (0, utils_1.binarySearchUB)(this._boundaries, value);
+        this._current.buckets.counts[idx] += 1;
+    }
+    setStartTime(startTime) {
+        this.startTime = startTime;
+    }
+    toPointValue() {
+        return this._current;
+    }
+}
+exports.HistogramAccumulation = HistogramAccumulation;
+/**
+ * Basic aggregator which observes events and counts them in pre-defined buckets
+ * and provides the total sum and count of all observations.
+ */
+class HistogramAggregator {
+    _boundaries;
+    _recordMinMax;
+    kind = types_1.AggregatorKind.HISTOGRAM;
+    /**
+     * @param _boundaries sorted upper bounds of recorded values.
+     * @param _recordMinMax If set to true, min and max will be recorded. Otherwise, min and max will not be recorded.
+     */
+    constructor(_boundaries, _recordMinMax) {
+        this._boundaries = _boundaries;
+        this._recordMinMax = _recordMinMax;
+    }
+    createAccumulation(startTime) {
+        return new HistogramAccumulation(startTime, this._boundaries, this._recordMinMax);
+    }
+    /**
+     * Return the result of the merge of two histogram accumulations. As long as one Aggregator
+     * instance produces all Accumulations with constant boundaries we don't need to worry about
+     * merging accumulations with different boundaries.
+     */
+    merge(previous, delta) {
+        const previousValue = previous.toPointValue();
+        const deltaValue = delta.toPointValue();
+        const previousCounts = previousValue.buckets.counts;
+        const deltaCounts = deltaValue.buckets.counts;
+        const mergedCounts = new Array(previousCounts.length);
+        for (let idx = 0; idx < previousCounts.length; idx++) {
+            mergedCounts[idx] = previousCounts[idx] + deltaCounts[idx];
+        }
+        let min = Infinity;
+        let max = -Infinity;
+        if (this._recordMinMax) {
+            if (previousValue.hasMinMax && deltaValue.hasMinMax) {
+                min = Math.min(previousValue.min, deltaValue.min);
+                max = Math.max(previousValue.max, deltaValue.max);
+            }
+            else if (previousValue.hasMinMax) {
+                min = previousValue.min;
+                max = previousValue.max;
+            }
+            else if (deltaValue.hasMinMax) {
+                min = deltaValue.min;
+                max = deltaValue.max;
+            }
+        }
+        return new HistogramAccumulation(previous.startTime, previousValue.buckets.boundaries, this._recordMinMax, {
+            buckets: {
+                boundaries: previousValue.buckets.boundaries,
+                counts: mergedCounts,
+            },
+            count: previousValue.count + deltaValue.count,
+            sum: previousValue.sum + deltaValue.sum,
+            hasMinMax: this._recordMinMax &&
+                (previousValue.hasMinMax || deltaValue.hasMinMax),
+            min: min,
+            max: max,
+        });
+    }
+    /**
+     * Returns a new DELTA aggregation by comparing two cumulative measurements.
+     */
+    diff(previous, current) {
+        const previousValue = previous.toPointValue();
+        const currentValue = current.toPointValue();
+        const previousCounts = previousValue.buckets.counts;
+        const currentCounts = currentValue.buckets.counts;
+        const diffedCounts = new Array(previousCounts.length);
+        for (let idx = 0; idx < previousCounts.length; idx++) {
+            diffedCounts[idx] = currentCounts[idx] - previousCounts[idx];
+        }
+        return new HistogramAccumulation(current.startTime, previousValue.buckets.boundaries, this._recordMinMax, {
+            buckets: {
+                boundaries: previousValue.buckets.boundaries,
+                counts: diffedCounts,
+            },
+            count: currentValue.count - previousValue.count,
+            sum: currentValue.sum - previousValue.sum,
+            hasMinMax: false,
+            min: Infinity,
+            max: -Infinity,
+        });
+    }
+    toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) {
+        return {
+            descriptor,
+            aggregationTemporality,
+            dataPointType: MetricData_1.DataPointType.HISTOGRAM,
+            dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {
+                const pointValue = accumulation.toPointValue();
+                // determine if instrument allows negative values.
+                const allowsNegativeValues = descriptor.type === MetricData_1.InstrumentType.GAUGE ||
+                    descriptor.type === MetricData_1.InstrumentType.UP_DOWN_COUNTER ||
+                    descriptor.type === MetricData_1.InstrumentType.OBSERVABLE_GAUGE ||
+                    descriptor.type === MetricData_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER;
+                return {
+                    attributes,
+                    startTime: accumulation.startTime,
+                    endTime,
+                    value: {
+                        min: pointValue.hasMinMax ? pointValue.min : undefined,
+                        max: pointValue.hasMinMax ? pointValue.max : undefined,
+                        sum: !allowsNegativeValues ? pointValue.sum : undefined,
+                        buckets: pointValue.buckets,
+                        count: pointValue.count,
+                    },
+                };
+            }),
+        };
+    }
+}
+exports.HistogramAggregator = HistogramAggregator;
+//# sourceMappingURL=Histogram.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Histogram.js","sourceRoot":"","sources":["../../../src/aggregator/Histogram.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,mCAKiB;AACjB,qDAI8B;AAE9B,oCAAiD;AAqBjD,SAAS,wBAAwB,CAAC,UAAoB;IACpD,MAAM,MAAM,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;IACvC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACf,OAAO;QACL,OAAO,EAAE;YACP,UAAU;YACV,MAAM;SACP;QACD,GAAG,EAAE,CAAC;QACN,KAAK,EAAE,CAAC;QACR,SAAS,EAAE,KAAK;QAChB,GAAG,EAAE,QAAQ;QACb,GAAG,EAAE,CAAC,QAAQ;KACf,CAAC;AACJ,CAAC;AAED,MAAa,qBAAqB;IAEvB;IACU;IACT;IACA;IAJV,YACS,SAAiB,EACP,WAAqB,EAC9B,gBAAgB,IAAI,EACpB,WAA8B,wBAAwB,CAAC,WAAW,CAAC;QAHpE,cAAS,GAAT,SAAS,CAAQ;QACP,gBAAW,GAAX,WAAW,CAAU;QAC9B,kBAAa,GAAb,aAAa,CAAO;QACpB,aAAQ,GAAR,QAAQ,CAA2D;IAC1E,CAAC;IAEJ,MAAM,CAAC,KAAa;QAClB,4EAA4E;QAC5E,qGAAqG;QACrG,IAAI,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;YACvB,OAAO;SACR;QAED,IAAI,CAAC,QAAQ,CAAC,KAAK,IAAI,CAAC,CAAC;QACzB,IAAI,CAAC,QAAQ,CAAC,GAAG,IAAI,KAAK,CAAC;QAE3B,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,CAAC,QAAQ,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YACvD,IAAI,CAAC,QAAQ,CAAC,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;YACvD,IAAI,CAAC,QAAQ,CAAC,SAAS,GAAG,IAAI,CAAC;SAChC;QAED,MAAM,GAAG,GAAG,IAAA,sBAAc,EAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;QACpD,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACzC,CAAC;IAED,YAAY,CAAC,SAAiB;QAC5B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;CACF;AAnCD,sDAmCC;AAED;;;GAGG;AACH,MAAa,mBAAmB;IAQX;IACA;IARZ,IAAI,GAA6B,sBAAc,CAAC,SAAS,CAAC;IAEjE;;;OAGG;IACH,YACmB,WAAqB,EACrB,aAAsB;QADtB,gBAAW,GAAX,WAAW,CAAU;QACrB,kBAAa,GAAb,aAAa,CAAS;IACtC,CAAC;IAEJ,kBAAkB,CAAC,SAAiB;QAClC,OAAO,IAAI,qBAAqB,CAC9B,SAAS,EACT,IAAI,CAAC,WAAW,EAChB,IAAI,CAAC,aAAa,CACnB,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,KAAK,CACH,QAA+B,EAC/B,KAA4B;QAE5B,MAAM,aAAa,GAAG,QAAQ,CAAC,YAAY,EAAE,CAAC;QAC9C,MAAM,UAAU,GAAG,KAAK,CAAC,YAAY,EAAE,CAAC;QAExC,MAAM,cAAc,GAAG,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC;QACpD,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,CAAC,MAAM,CAAC;QAE9C,MAAM,YAAY,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QACtD,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE;YACpD,YAAY,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;SAC5D;QAED,IAAI,GAAG,GAAG,QAAQ,CAAC;QACnB,IAAI,GAAG,GAAG,CAAC,QAAQ,CAAC;QAEpB,IAAI,IAAI,CAAC,aAAa,EAAE;YACtB,IAAI,aAAa,CAAC,SAAS,IAAI,UAAU,CAAC,SAAS,EAAE;gBACnD,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,GAAG,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC;gBAClD,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,aAAa,CAAC,GAAG,EAAE,UAAU,CAAC,GAAG,CAAC,CAAC;aACnD;iBAAM,IAAI,aAAa,CAAC,SAAS,EAAE;gBAClC,GAAG,GAAG,aAAa,CAAC,GAAG,CAAC;gBACxB,GAAG,GAAG,aAAa,CAAC,GAAG,CAAC;aACzB;iBAAM,IAAI,UAAU,CAAC,SAAS,EAAE;gBAC/B,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC;gBACrB,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC;aACtB;SACF;QAED,OAAO,IAAI,qBAAqB,CAC9B,QAAQ,CAAC,SAAS,EAClB,aAAa,CAAC,OAAO,CAAC,UAAU,EAChC,IAAI,CAAC,aAAa,EAClB;YACE,OAAO,EAAE;gBACP,UAAU,EAAE,aAAa,CAAC,OAAO,CAAC,UAAU;gBAC5C,MAAM,EAAE,YAAY;aACrB;YACD,KAAK,EAAE,aAAa,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK;YAC7C,GAAG,EAAE,aAAa,CAAC,GAAG,GAAG,UAAU,CAAC,GAAG;YACvC,SAAS,EACP,IAAI,CAAC,aAAa;gBAClB,CAAC,aAAa,CAAC,SAAS,IAAI,UAAU,CAAC,SAAS,CAAC;YACnD,GAAG,EAAE,GAAG;YACR,GAAG,EAAE,GAAG;SACT,CACF,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,IAAI,CACF,QAA+B,EAC/B,OAA8B;QAE9B,MAAM,aAAa,GAAG,QAAQ,CAAC,YAAY,EAAE,CAAC;QAC9C,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;QAE5C,MAAM,cAAc,GAAG,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC;QACpD,MAAM,aAAa,GAAG,YAAY,CAAC,OAAO,CAAC,MAAM,CAAC;QAElD,MAAM,YAAY,GAAG,IAAI,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;QACtD,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,cAAc,CAAC,MAAM,EAAE,GAAG,EAAE,EAAE;YACpD,YAAY,CAAC,GAAG,CAAC,GAAG,aAAa,CAAC,GAAG,CAAC,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC;SAC9D;QAED,OAAO,IAAI,qBAAqB,CAC9B,OAAO,CAAC,SAAS,EACjB,aAAa,CAAC,OAAO,CAAC,UAAU,EAChC,IAAI,CAAC,aAAa,EAClB;YACE,OAAO,EAAE;gBACP,UAAU,EAAE,aAAa,CAAC,OAAO,CAAC,UAAU;gBAC5C,MAAM,EAAE,YAAY;aACrB;YACD,KAAK,EAAE,YAAY,CAAC,KAAK,GAAG,aAAa,CAAC,KAAK;YAC/C,GAAG,EAAE,YAAY,CAAC,GAAG,GAAG,aAAa,CAAC,GAAG;YACzC,SAAS,EAAE,KAAK;YAChB,GAAG,EAAE,QAAQ;YACb,GAAG,EAAE,CAAC,QAAQ;SACf,CACF,CAAC;IACJ,CAAC;IAED,YAAY,CACV,UAAgC,EAChC,sBAA8C,EAC9C,wBAAqE,EACrE,OAAe;QAEf,OAAO;YACL,UAAU;YACV,sBAAsB;YACtB,aAAa,EAAE,0BAAa,CAAC,SAAS;YACtC,UAAU,EAAE,wBAAwB,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,EAAE,YAAY,CAAC,EAAE,EAAE;gBACtE,MAAM,UAAU,GAAG,YAAY,CAAC,YAAY,EAAE,CAAC;gBAE/C,kDAAkD;gBAClD,MAAM,oBAAoB,GACxB,UAAU,CAAC,IAAI,KAAK,2BAAc,CAAC,KAAK;oBACxC,UAAU,CAAC,IAAI,KAAK,2BAAc,CAAC,eAAe;oBAClD,UAAU,CAAC,IAAI,KAAK,2BAAc,CAAC,gBAAgB;oBACnD,UAAU,CAAC,IAAI,KAAK,2BAAc,CAAC,0BAA0B,CAAC;gBAEhE,OAAO;oBACL,UAAU;oBACV,SAAS,EAAE,YAAY,CAAC,SAAS;oBACjC,OAAO;oBACP,KAAK,EAAE;wBACL,GAAG,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS;wBACtD,GAAG,EAAE,UAAU,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS;wBACtD,GAAG,EAAE,CAAC,oBAAoB,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS;wBACvD,OAAO,EAAE,UAAU,CAAC,OAAO;wBAC3B,KAAK,EAAE,UAAU,CAAC,KAAK;qBACxB;iBACF,CAAC;YACJ,CAAC,CAAC;SACH,CAAC;IACJ,CAAC;CACF;AAnJD,kDAmJC","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  Accumulation,\n  AccumulationRecord,\n  Aggregator,\n  AggregatorKind,\n} from './types';\nimport {\n  DataPointType,\n  HistogramMetricData,\n  InstrumentType,\n} from '../export/MetricData';\nimport { HrTime } from '@opentelemetry/api';\nimport { binarySearchUB, Maybe } from '../utils';\nimport { AggregationTemporality } from '../export/AggregationTemporality';\nimport { InstrumentDescriptor } from '../InstrumentDescriptor';\n\n/**\n * Internal value type for HistogramAggregation.\n * Differs from the exported type as undefined sum/min/max complicate arithmetic\n * performed by this aggregation, but are required to be undefined in the exported types.\n */\ninterface InternalHistogram {\n  buckets: {\n    boundaries: number[];\n    counts: number[];\n  };\n  sum: number;\n  count: number;\n  hasMinMax: boolean;\n  min: number;\n  max: number;\n}\n\nfunction createNewEmptyCheckpoint(boundaries: number[]): InternalHistogram {\n  const counts = boundaries.map(() => 0);\n  counts.push(0);\n  return {\n    buckets: {\n      boundaries,\n      counts,\n    },\n    sum: 0,\n    count: 0,\n    hasMinMax: false,\n    min: Infinity,\n    max: -Infinity,\n  };\n}\n\nexport class HistogramAccumulation implements Accumulation {\n  constructor(\n    public startTime: HrTime,\n    private readonly _boundaries: number[],\n    private _recordMinMax = true,\n    private _current: InternalHistogram = createNewEmptyCheckpoint(_boundaries)\n  ) {}\n\n  record(value: number): void {\n    // NaN does not fall into any bucket, is not zero and should not be counted,\n    // NaN is never greater than max nor less than min, therefore return as there's nothing for us to do.\n    if (Number.isNaN(value)) {\n      return;\n    }\n\n    this._current.count += 1;\n    this._current.sum += value;\n\n    if (this._recordMinMax) {\n      this._current.min = Math.min(value, this._current.min);\n      this._current.max = Math.max(value, this._current.max);\n      this._current.hasMinMax = true;\n    }\n\n    const idx = binarySearchUB(this._boundaries, value);\n    this._current.buckets.counts[idx] += 1;\n  }\n\n  setStartTime(startTime: HrTime): void {\n    this.startTime = startTime;\n  }\n\n  toPointValue(): InternalHistogram {\n    return this._current;\n  }\n}\n\n/**\n * Basic aggregator which observes events and counts them in pre-defined buckets\n * and provides the total sum and count of all observations.\n */\nexport class HistogramAggregator implements Aggregator<HistogramAccumulation> {\n  public kind: AggregatorKind.HISTOGRAM = AggregatorKind.HISTOGRAM;\n\n  /**\n   * @param _boundaries sorted upper bounds of recorded values.\n   * @param _recordMinMax If set to true, min and max will be recorded. Otherwise, min and max will not be recorded.\n   */\n  constructor(\n    private readonly _boundaries: number[],\n    private readonly _recordMinMax: boolean\n  ) {}\n\n  createAccumulation(startTime: HrTime) {\n    return new HistogramAccumulation(\n      startTime,\n      this._boundaries,\n      this._recordMinMax\n    );\n  }\n\n  /**\n   * Return the result of the merge of two histogram accumulations. As long as one Aggregator\n   * instance produces all Accumulations with constant boundaries we don't need to worry about\n   * merging accumulations with different boundaries.\n   */\n  merge(\n    previous: HistogramAccumulation,\n    delta: HistogramAccumulation\n  ): HistogramAccumulation {\n    const previousValue = previous.toPointValue();\n    const deltaValue = delta.toPointValue();\n\n    const previousCounts = previousValue.buckets.counts;\n    const deltaCounts = deltaValue.buckets.counts;\n\n    const mergedCounts = new Array(previousCounts.length);\n    for (let idx = 0; idx < previousCounts.length; idx++) {\n      mergedCounts[idx] = previousCounts[idx] + deltaCounts[idx];\n    }\n\n    let min = Infinity;\n    let max = -Infinity;\n\n    if (this._recordMinMax) {\n      if (previousValue.hasMinMax && deltaValue.hasMinMax) {\n        min = Math.min(previousValue.min, deltaValue.min);\n        max = Math.max(previousValue.max, deltaValue.max);\n      } else if (previousValue.hasMinMax) {\n        min = previousValue.min;\n        max = previousValue.max;\n      } else if (deltaValue.hasMinMax) {\n        min = deltaValue.min;\n        max = deltaValue.max;\n      }\n    }\n\n    return new HistogramAccumulation(\n      previous.startTime,\n      previousValue.buckets.boundaries,\n      this._recordMinMax,\n      {\n        buckets: {\n          boundaries: previousValue.buckets.boundaries,\n          counts: mergedCounts,\n        },\n        count: previousValue.count + deltaValue.count,\n        sum: previousValue.sum + deltaValue.sum,\n        hasMinMax:\n          this._recordMinMax &&\n          (previousValue.hasMinMax || deltaValue.hasMinMax),\n        min: min,\n        max: max,\n      }\n    );\n  }\n\n  /**\n   * Returns a new DELTA aggregation by comparing two cumulative measurements.\n   */\n  diff(\n    previous: HistogramAccumulation,\n    current: HistogramAccumulation\n  ): HistogramAccumulation {\n    const previousValue = previous.toPointValue();\n    const currentValue = current.toPointValue();\n\n    const previousCounts = previousValue.buckets.counts;\n    const currentCounts = currentValue.buckets.counts;\n\n    const diffedCounts = new Array(previousCounts.length);\n    for (let idx = 0; idx < previousCounts.length; idx++) {\n      diffedCounts[idx] = currentCounts[idx] - previousCounts[idx];\n    }\n\n    return new HistogramAccumulation(\n      current.startTime,\n      previousValue.buckets.boundaries,\n      this._recordMinMax,\n      {\n        buckets: {\n          boundaries: previousValue.buckets.boundaries,\n          counts: diffedCounts,\n        },\n        count: currentValue.count - previousValue.count,\n        sum: currentValue.sum - previousValue.sum,\n        hasMinMax: false,\n        min: Infinity,\n        max: -Infinity,\n      }\n    );\n  }\n\n  toMetricData(\n    descriptor: InstrumentDescriptor,\n    aggregationTemporality: AggregationTemporality,\n    accumulationByAttributes: AccumulationRecord<HistogramAccumulation>[],\n    endTime: HrTime\n  ): Maybe<HistogramMetricData> {\n    return {\n      descriptor,\n      aggregationTemporality,\n      dataPointType: DataPointType.HISTOGRAM,\n      dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {\n        const pointValue = accumulation.toPointValue();\n\n        // determine if instrument allows negative values.\n        const allowsNegativeValues =\n          descriptor.type === InstrumentType.GAUGE ||\n          descriptor.type === InstrumentType.UP_DOWN_COUNTER ||\n          descriptor.type === InstrumentType.OBSERVABLE_GAUGE ||\n          descriptor.type === InstrumentType.OBSERVABLE_UP_DOWN_COUNTER;\n\n        return {\n          attributes,\n          startTime: accumulation.startTime,\n          endTime,\n          value: {\n            min: pointValue.hasMinMax ? pointValue.min : undefined,\n            max: pointValue.hasMinMax ? pointValue.max : undefined,\n            sum: !allowsNegativeValues ? pointValue.sum : undefined,\n            buckets: pointValue.buckets,\n            count: pointValue.count,\n          },\n        };\n      }),\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,35 @@
+import { Accumulation, AccumulationRecord, Aggregator, AggregatorKind, LastValue } from './types';
+import { HrTime } from '@opentelemetry/api';
+import { GaugeMetricData } from '../export/MetricData';
+import { Maybe } from '../utils';
+import { AggregationTemporality } from '../export/AggregationTemporality';
+import { InstrumentDescriptor } from '../InstrumentDescriptor';
+export declare class LastValueAccumulation implements Accumulation {
+    startTime: HrTime;
+    private _current;
+    sampleTime: HrTime;
+    constructor(startTime: HrTime, _current?: number, sampleTime?: HrTime);
+    record(value: number): void;
+    setStartTime(startTime: HrTime): void;
+    toPointValue(): LastValue;
+}
+/** Basic aggregator which calculates a LastValue from individual measurements. */
+export declare class LastValueAggregator implements Aggregator<LastValueAccumulation> {
+    kind: AggregatorKind.LAST_VALUE;
+    createAccumulation(startTime: HrTime): LastValueAccumulation;
+    /**
+     * Returns the result of the merge of the given accumulations.
+     *
+     * Return the newly captured (delta) accumulation for LastValueAggregator.
+     */
+    merge(previous: LastValueAccumulation, delta: LastValueAccumulation): LastValueAccumulation;
+    /**
+     * Returns a new DELTA aggregation by comparing two cumulative measurements.
+     *
+     * A delta aggregation is not meaningful to LastValueAggregator, just return
+     * the newly captured (delta) accumulation for LastValueAggregator.
+     */
+    diff(previous: LastValueAccumulation, current: LastValueAccumulation): LastValueAccumulation;
+    toMetricData(descriptor: InstrumentDescriptor, aggregationTemporality: AggregationTemporality, accumulationByAttributes: AccumulationRecord<LastValueAccumulation>[], endTime: HrTime): Maybe<GaugeMetricData>;
+}
+//# sourceMappingURL=LastValue.d.ts.map

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

@@ -0,0 +1,93 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LastValueAggregator = exports.LastValueAccumulation = void 0;
+const types_1 = require("./types");
+const core_1 = require("@opentelemetry/core");
+const MetricData_1 = require("../export/MetricData");
+class LastValueAccumulation {
+    startTime;
+    _current;
+    sampleTime;
+    constructor(startTime, _current = 0, sampleTime = [0, 0]) {
+        this.startTime = startTime;
+        this._current = _current;
+        this.sampleTime = sampleTime;
+    }
+    record(value) {
+        this._current = value;
+        this.sampleTime = (0, core_1.millisToHrTime)(Date.now());
+    }
+    setStartTime(startTime) {
+        this.startTime = startTime;
+    }
+    toPointValue() {
+        return this._current;
+    }
+}
+exports.LastValueAccumulation = LastValueAccumulation;
+/** Basic aggregator which calculates a LastValue from individual measurements. */
+class LastValueAggregator {
+    kind = types_1.AggregatorKind.LAST_VALUE;
+    createAccumulation(startTime) {
+        return new LastValueAccumulation(startTime);
+    }
+    /**
+     * Returns the result of the merge of the given accumulations.
+     *
+     * Return the newly captured (delta) accumulation for LastValueAggregator.
+     */
+    merge(previous, delta) {
+        // nanoseconds may lose precisions.
+        const latestAccumulation = (0, core_1.hrTimeToMicroseconds)(delta.sampleTime) >=
+            (0, core_1.hrTimeToMicroseconds)(previous.sampleTime)
+            ? delta
+            : previous;
+        return new LastValueAccumulation(previous.startTime, latestAccumulation.toPointValue(), latestAccumulation.sampleTime);
+    }
+    /**
+     * Returns a new DELTA aggregation by comparing two cumulative measurements.
+     *
+     * A delta aggregation is not meaningful to LastValueAggregator, just return
+     * the newly captured (delta) accumulation for LastValueAggregator.
+     */
+    diff(previous, current) {
+        // nanoseconds may lose precisions.
+        const latestAccumulation = (0, core_1.hrTimeToMicroseconds)(current.sampleTime) >=
+            (0, core_1.hrTimeToMicroseconds)(previous.sampleTime)
+            ? current
+            : previous;
+        return new LastValueAccumulation(current.startTime, latestAccumulation.toPointValue(), latestAccumulation.sampleTime);
+    }
+    toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) {
+        return {
+            descriptor,
+            aggregationTemporality,
+            dataPointType: MetricData_1.DataPointType.GAUGE,
+            dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {
+                return {
+                    attributes,
+                    startTime: accumulation.startTime,
+                    endTime,
+                    value: accumulation.toPointValue(),
+                };
+            }),
+        };
+    }
+}
+exports.LastValueAggregator = LastValueAggregator;
+//# sourceMappingURL=LastValue.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LastValue.js","sourceRoot":"","sources":["../../../src/aggregator/LastValue.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,mCAMiB;AAEjB,8CAA2E;AAC3E,qDAAsE;AAKtE,MAAa,qBAAqB;IAEvB;IACC;IACD;IAHT,YACS,SAAiB,EAChB,WAAW,CAAC,EACb,aAAqB,CAAC,CAAC,EAAE,CAAC,CAAC;QAF3B,cAAS,GAAT,SAAS,CAAQ;QAChB,aAAQ,GAAR,QAAQ,CAAI;QACb,eAAU,GAAV,UAAU,CAAiB;IACjC,CAAC;IAEJ,MAAM,CAAC,KAAa;QAClB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QACtB,IAAI,CAAC,UAAU,GAAG,IAAA,qBAAc,EAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED,YAAY,CAAC,SAAiB;QAC5B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;CACF;AAnBD,sDAmBC;AAED,kFAAkF;AAClF,MAAa,mBAAmB;IACvB,IAAI,GAA8B,sBAAc,CAAC,UAAU,CAAC;IAEnE,kBAAkB,CAAC,SAAiB;QAClC,OAAO,IAAI,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAC9C,CAAC;IAED;;;;OAIG;IACH,KAAK,CACH,QAA+B,EAC/B,KAA4B;QAE5B,mCAAmC;QACnC,MAAM,kBAAkB,GACtB,IAAA,2BAAoB,EAAC,KAAK,CAAC,UAAU,CAAC;YACtC,IAAA,2BAAoB,EAAC,QAAQ,CAAC,UAAU,CAAC;YACvC,CAAC,CAAC,KAAK;YACP,CAAC,CAAC,QAAQ,CAAC;QACf,OAAO,IAAI,qBAAqB,CAC9B,QAAQ,CAAC,SAAS,EAClB,kBAAkB,CAAC,YAAY,EAAE,EACjC,kBAAkB,CAAC,UAAU,CAC9B,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,IAAI,CACF,QAA+B,EAC/B,OAA8B;QAE9B,mCAAmC;QACnC,MAAM,kBAAkB,GACtB,IAAA,2BAAoB,EAAC,OAAO,CAAC,UAAU,CAAC;YACxC,IAAA,2BAAoB,EAAC,QAAQ,CAAC,UAAU,CAAC;YACvC,CAAC,CAAC,OAAO;YACT,CAAC,CAAC,QAAQ,CAAC;QACf,OAAO,IAAI,qBAAqB,CAC9B,OAAO,CAAC,SAAS,EACjB,kBAAkB,CAAC,YAAY,EAAE,EACjC,kBAAkB,CAAC,UAAU,CAC9B,CAAC;IACJ,CAAC;IAED,YAAY,CACV,UAAgC,EAChC,sBAA8C,EAC9C,wBAAqE,EACrE,OAAe;QAEf,OAAO;YACL,UAAU;YACV,sBAAsB;YACtB,aAAa,EAAE,0BAAa,CAAC,KAAK;YAClC,UAAU,EAAE,wBAAwB,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,EAAE,YAAY,CAAC,EAAE,EAAE;gBACtE,OAAO;oBACL,UAAU;oBACV,SAAS,EAAE,YAAY,CAAC,SAAS;oBACjC,OAAO;oBACP,KAAK,EAAE,YAAY,CAAC,YAAY,EAAE;iBACnC,CAAC;YACJ,CAAC,CAAC;SACH,CAAC;IACJ,CAAC;CACF;AAxED,kDAwEC","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  Accumulation,\n  AccumulationRecord,\n  Aggregator,\n  AggregatorKind,\n  LastValue,\n} from './types';\nimport { HrTime } from '@opentelemetry/api';\nimport { millisToHrTime, hrTimeToMicroseconds } from '@opentelemetry/core';\nimport { DataPointType, GaugeMetricData } from '../export/MetricData';\nimport { Maybe } from '../utils';\nimport { AggregationTemporality } from '../export/AggregationTemporality';\nimport { InstrumentDescriptor } from '../InstrumentDescriptor';\n\nexport class LastValueAccumulation implements Accumulation {\n  constructor(\n    public startTime: HrTime,\n    private _current = 0,\n    public sampleTime: HrTime = [0, 0]\n  ) {}\n\n  record(value: number): void {\n    this._current = value;\n    this.sampleTime = millisToHrTime(Date.now());\n  }\n\n  setStartTime(startTime: HrTime): void {\n    this.startTime = startTime;\n  }\n\n  toPointValue(): LastValue {\n    return this._current;\n  }\n}\n\n/** Basic aggregator which calculates a LastValue from individual measurements. */\nexport class LastValueAggregator implements Aggregator<LastValueAccumulation> {\n  public kind: AggregatorKind.LAST_VALUE = AggregatorKind.LAST_VALUE;\n\n  createAccumulation(startTime: HrTime) {\n    return new LastValueAccumulation(startTime);\n  }\n\n  /**\n   * Returns the result of the merge of the given accumulations.\n   *\n   * Return the newly captured (delta) accumulation for LastValueAggregator.\n   */\n  merge(\n    previous: LastValueAccumulation,\n    delta: LastValueAccumulation\n  ): LastValueAccumulation {\n    // nanoseconds may lose precisions.\n    const latestAccumulation =\n      hrTimeToMicroseconds(delta.sampleTime) >=\n      hrTimeToMicroseconds(previous.sampleTime)\n        ? delta\n        : previous;\n    return new LastValueAccumulation(\n      previous.startTime,\n      latestAccumulation.toPointValue(),\n      latestAccumulation.sampleTime\n    );\n  }\n\n  /**\n   * Returns a new DELTA aggregation by comparing two cumulative measurements.\n   *\n   * A delta aggregation is not meaningful to LastValueAggregator, just return\n   * the newly captured (delta) accumulation for LastValueAggregator.\n   */\n  diff(\n    previous: LastValueAccumulation,\n    current: LastValueAccumulation\n  ): LastValueAccumulation {\n    // nanoseconds may lose precisions.\n    const latestAccumulation =\n      hrTimeToMicroseconds(current.sampleTime) >=\n      hrTimeToMicroseconds(previous.sampleTime)\n        ? current\n        : previous;\n    return new LastValueAccumulation(\n      current.startTime,\n      latestAccumulation.toPointValue(),\n      latestAccumulation.sampleTime\n    );\n  }\n\n  toMetricData(\n    descriptor: InstrumentDescriptor,\n    aggregationTemporality: AggregationTemporality,\n    accumulationByAttributes: AccumulationRecord<LastValueAccumulation>[],\n    endTime: HrTime\n  ): Maybe<GaugeMetricData> {\n    return {\n      descriptor,\n      aggregationTemporality,\n      dataPointType: DataPointType.GAUGE,\n      dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {\n        return {\n          attributes,\n          startTime: accumulation.startTime,\n          endTime,\n          value: accumulation.toPointValue(),\n        };\n      }),\n    };\n  }\n}\n"]}

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

@@ -0,0 +1,33 @@
+import { Sum, AggregatorKind, Aggregator, Accumulation, AccumulationRecord } from './types';
+import { HrTime } from '@opentelemetry/api';
+import { SumMetricData } from '../export/MetricData';
+import { Maybe } from '../utils';
+import { AggregationTemporality } from '../export/AggregationTemporality';
+import { InstrumentDescriptor } from '../InstrumentDescriptor';
+export declare class SumAccumulation implements Accumulation {
+    startTime: HrTime;
+    monotonic: boolean;
+    private _current;
+    reset: boolean;
+    constructor(startTime: HrTime, monotonic: boolean, _current?: number, reset?: boolean);
+    record(value: number): void;
+    setStartTime(startTime: HrTime): void;
+    toPointValue(): Sum;
+}
+/** Basic aggregator which calculates a Sum from individual measurements. */
+export declare class SumAggregator implements Aggregator<SumAccumulation> {
+    monotonic: boolean;
+    kind: AggregatorKind.SUM;
+    constructor(monotonic: boolean);
+    createAccumulation(startTime: HrTime): SumAccumulation;
+    /**
+     * Returns the result of the merge of the given accumulations.
+     */
+    merge(previous: SumAccumulation, delta: SumAccumulation): SumAccumulation;
+    /**
+     * Returns a new DELTA aggregation by comparing two cumulative measurements.
+     */
+    diff(previous: SumAccumulation, current: SumAccumulation): SumAccumulation;
+    toMetricData(descriptor: InstrumentDescriptor, aggregationTemporality: AggregationTemporality, accumulationByAttributes: AccumulationRecord<SumAccumulation>[], endTime: HrTime): Maybe<SumMetricData>;
+}
+//# sourceMappingURL=Sum.d.ts.map

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

@@ -0,0 +1,101 @@
+"use strict";
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SumAggregator = exports.SumAccumulation = void 0;
+const types_1 = require("./types");
+const MetricData_1 = require("../export/MetricData");
+class SumAccumulation {
+    startTime;
+    monotonic;
+    _current;
+    reset;
+    constructor(startTime, monotonic, _current = 0, reset = false) {
+        this.startTime = startTime;
+        this.monotonic = monotonic;
+        this._current = _current;
+        this.reset = reset;
+    }
+    record(value) {
+        if (this.monotonic && value < 0) {
+            return;
+        }
+        this._current += value;
+    }
+    setStartTime(startTime) {
+        this.startTime = startTime;
+    }
+    toPointValue() {
+        return this._current;
+    }
+}
+exports.SumAccumulation = SumAccumulation;
+/** Basic aggregator which calculates a Sum from individual measurements. */
+class SumAggregator {
+    monotonic;
+    kind = types_1.AggregatorKind.SUM;
+    constructor(monotonic) {
+        this.monotonic = monotonic;
+    }
+    createAccumulation(startTime) {
+        return new SumAccumulation(startTime, this.monotonic);
+    }
+    /**
+     * Returns the result of the merge of the given accumulations.
+     */
+    merge(previous, delta) {
+        const prevPv = previous.toPointValue();
+        const deltaPv = delta.toPointValue();
+        if (delta.reset) {
+            return new SumAccumulation(delta.startTime, this.monotonic, deltaPv, delta.reset);
+        }
+        return new SumAccumulation(previous.startTime, this.monotonic, prevPv + deltaPv);
+    }
+    /**
+     * Returns a new DELTA aggregation by comparing two cumulative measurements.
+     */
+    diff(previous, current) {
+        const prevPv = previous.toPointValue();
+        const currPv = current.toPointValue();
+        /**
+         * If the SumAggregator is a monotonic one and the previous point value is
+         * greater than the current one, a reset is deemed to be happened.
+         * Return the current point value to prevent the value from been reset.
+         */
+        if (this.monotonic && prevPv > currPv) {
+            return new SumAccumulation(current.startTime, this.monotonic, currPv, true);
+        }
+        return new SumAccumulation(current.startTime, this.monotonic, currPv - prevPv);
+    }
+    toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) {
+        return {
+            descriptor,
+            aggregationTemporality,
+            dataPointType: MetricData_1.DataPointType.SUM,
+            dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {
+                return {
+                    attributes,
+                    startTime: accumulation.startTime,
+                    endTime,
+                    value: accumulation.toPointValue(),
+                };
+            }),
+            isMonotonic: this.monotonic,
+        };
+    }
+}
+exports.SumAggregator = SumAggregator;
+//# sourceMappingURL=Sum.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Sum.js","sourceRoot":"","sources":["../../../src/aggregator/Sum.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AAEH,mCAMiB;AAEjB,qDAAoE;AAKpE,MAAa,eAAe;IAEjB;IACA;IACC;IACD;IAJT,YACS,SAAiB,EACjB,SAAkB,EACjB,WAAW,CAAC,EACb,QAAQ,KAAK;QAHb,cAAS,GAAT,SAAS,CAAQ;QACjB,cAAS,GAAT,SAAS,CAAS;QACjB,aAAQ,GAAR,QAAQ,CAAI;QACb,UAAK,GAAL,KAAK,CAAQ;IACnB,CAAC;IAEJ,MAAM,CAAC,KAAa;QAClB,IAAI,IAAI,CAAC,SAAS,IAAI,KAAK,GAAG,CAAC,EAAE;YAC/B,OAAO;SACR;QACD,IAAI,CAAC,QAAQ,IAAI,KAAK,CAAC;IACzB,CAAC;IAED,YAAY,CAAC,SAAiB;QAC5B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED,YAAY;QACV,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;CACF;AAtBD,0CAsBC;AAED,4EAA4E;AAC5E,MAAa,aAAa;IAGL;IAFZ,IAAI,GAAuB,sBAAc,CAAC,GAAG,CAAC;IAErD,YAAmB,SAAkB;QAAlB,cAAS,GAAT,SAAS,CAAS;IAAG,CAAC;IAEzC,kBAAkB,CAAC,SAAiB;QAClC,OAAO,IAAI,eAAe,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IACxD,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,QAAyB,EAAE,KAAsB;QACrD,MAAM,MAAM,GAAG,QAAQ,CAAC,YAAY,EAAE,CAAC;QACvC,MAAM,OAAO,GAAG,KAAK,CAAC,YAAY,EAAE,CAAC;QACrC,IAAI,KAAK,CAAC,KAAK,EAAE;YACf,OAAO,IAAI,eAAe,CACxB,KAAK,CAAC,SAAS,EACf,IAAI,CAAC,SAAS,EACd,OAAO,EACP,KAAK,CAAC,KAAK,CACZ,CAAC;SACH;QACD,OAAO,IAAI,eAAe,CACxB,QAAQ,CAAC,SAAS,EAClB,IAAI,CAAC,SAAS,EACd,MAAM,GAAG,OAAO,CACjB,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,IAAI,CAAC,QAAyB,EAAE,OAAwB;QACtD,MAAM,MAAM,GAAG,QAAQ,CAAC,YAAY,EAAE,CAAC;QACvC,MAAM,MAAM,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;QACtC;;;;WAIG;QACH,IAAI,IAAI,CAAC,SAAS,IAAI,MAAM,GAAG,MAAM,EAAE;YACrC,OAAO,IAAI,eAAe,CACxB,OAAO,CAAC,SAAS,EACjB,IAAI,CAAC,SAAS,EACd,MAAM,EACN,IAAI,CACL,CAAC;SACH;QACD,OAAO,IAAI,eAAe,CACxB,OAAO,CAAC,SAAS,EACjB,IAAI,CAAC,SAAS,EACd,MAAM,GAAG,MAAM,CAChB,CAAC;IACJ,CAAC;IAED,YAAY,CACV,UAAgC,EAChC,sBAA8C,EAC9C,wBAA+D,EAC/D,OAAe;QAEf,OAAO;YACL,UAAU;YACV,sBAAsB;YACtB,aAAa,EAAE,0BAAa,CAAC,GAAG;YAChC,UAAU,EAAE,wBAAwB,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,EAAE,YAAY,CAAC,EAAE,EAAE;gBACtE,OAAO;oBACL,UAAU;oBACV,SAAS,EAAE,YAAY,CAAC,SAAS;oBACjC,OAAO;oBACP,KAAK,EAAE,YAAY,CAAC,YAAY,EAAE;iBACnC,CAAC;YACJ,CAAC,CAAC;YACF,WAAW,EAAE,IAAI,CAAC,SAAS;SAC5B,CAAC;IACJ,CAAC;CACF;AA7ED,sCA6EC","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  Sum,\n  AggregatorKind,\n  Aggregator,\n  Accumulation,\n  AccumulationRecord,\n} from './types';\nimport { HrTime } from '@opentelemetry/api';\nimport { DataPointType, SumMetricData } from '../export/MetricData';\nimport { Maybe } from '../utils';\nimport { AggregationTemporality } from '../export/AggregationTemporality';\nimport { InstrumentDescriptor } from '../InstrumentDescriptor';\n\nexport class SumAccumulation implements Accumulation {\n  constructor(\n    public startTime: HrTime,\n    public monotonic: boolean,\n    private _current = 0,\n    public reset = false\n  ) {}\n\n  record(value: number): void {\n    if (this.monotonic && value < 0) {\n      return;\n    }\n    this._current += value;\n  }\n\n  setStartTime(startTime: HrTime): void {\n    this.startTime = startTime;\n  }\n\n  toPointValue(): Sum {\n    return this._current;\n  }\n}\n\n/** Basic aggregator which calculates a Sum from individual measurements. */\nexport class SumAggregator implements Aggregator<SumAccumulation> {\n  public kind: AggregatorKind.SUM = AggregatorKind.SUM;\n\n  constructor(public monotonic: boolean) {}\n\n  createAccumulation(startTime: HrTime) {\n    return new SumAccumulation(startTime, this.monotonic);\n  }\n\n  /**\n   * Returns the result of the merge of the given accumulations.\n   */\n  merge(previous: SumAccumulation, delta: SumAccumulation): SumAccumulation {\n    const prevPv = previous.toPointValue();\n    const deltaPv = delta.toPointValue();\n    if (delta.reset) {\n      return new SumAccumulation(\n        delta.startTime,\n        this.monotonic,\n        deltaPv,\n        delta.reset\n      );\n    }\n    return new SumAccumulation(\n      previous.startTime,\n      this.monotonic,\n      prevPv + deltaPv\n    );\n  }\n\n  /**\n   * Returns a new DELTA aggregation by comparing two cumulative measurements.\n   */\n  diff(previous: SumAccumulation, current: SumAccumulation): SumAccumulation {\n    const prevPv = previous.toPointValue();\n    const currPv = current.toPointValue();\n    /**\n     * If the SumAggregator is a monotonic one and the previous point value is\n     * greater than the current one, a reset is deemed to be happened.\n     * Return the current point value to prevent the value from been reset.\n     */\n    if (this.monotonic && prevPv > currPv) {\n      return new SumAccumulation(\n        current.startTime,\n        this.monotonic,\n        currPv,\n        true\n      );\n    }\n    return new SumAccumulation(\n      current.startTime,\n      this.monotonic,\n      currPv - prevPv\n    );\n  }\n\n  toMetricData(\n    descriptor: InstrumentDescriptor,\n    aggregationTemporality: AggregationTemporality,\n    accumulationByAttributes: AccumulationRecord<SumAccumulation>[],\n    endTime: HrTime\n  ): Maybe<SumMetricData> {\n    return {\n      descriptor,\n      aggregationTemporality,\n      dataPointType: DataPointType.SUM,\n      dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {\n        return {\n          attributes,\n          startTime: accumulation.startTime,\n          endTime,\n          value: accumulation.toPointValue(),\n        };\n      }),\n      isMonotonic: this.monotonic,\n    };\n  }\n}\n"]}

package/dist/server/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/exponential-histogram/Buckets.d.ts

@@ -0,0 +1,133 @@
+export declare class Buckets {
+    backing: BucketsBacking;
+    indexBase: number;
+    indexStart: number;
+    indexEnd: number;
+    /**
+     * The term index refers to the number of the exponential histogram bucket
+     * used to determine its boundaries. The lower boundary of a bucket is
+     * determined by base ** index and the upper boundary of a bucket is
+     * determined by base ** (index + 1). index values are signed to account
+     * for values less than or equal to 1.
+     *
+     * indexBase is the index of the 0th position in the
+     * backing array, i.e., backing[0] is the count
+     * in the bucket with index `indexBase`.
+     *
+     * indexStart is the smallest index value represented
+     * in the backing array.
+     *
+     * indexEnd is the largest index value represented in
+     * the backing array.
+     */
+    constructor(backing?: BucketsBacking, indexBase?: number, indexStart?: number, indexEnd?: number);
+    /**
+     * Offset is the bucket index of the smallest entry in the counts array
+     * @returns {number}
+     */
+    get offset(): number;
+    /**
+     * Buckets is a view into the backing array.
+     * @returns {number}
+     */
+    get length(): number;
+    /**
+     * An array of counts, where count[i] carries the count
+     * of the bucket at index (offset+i).  count[i] is the count of
+     * values greater than base^(offset+i) and less than or equal to
+     * base^(offset+i+1).
+     * @returns {number} The logical counts based on the backing array
+     */
+    counts(): number[];
+    /**
+     * At returns the count of the bucket at a position in the logical
+     * array of counts.
+     * @param position
+     * @returns {number}
+     */
+    at(position: number): number;
+    /**
+     * incrementBucket increments the backing array index by `increment`
+     * @param bucketIndex
+     * @param increment
+     */
+    incrementBucket(bucketIndex: number, increment: number): void;
+    /**
+     * decrementBucket decrements the backing array index by `decrement`
+     * if decrement is greater than the current value, it's set to 0.
+     * @param bucketIndex
+     * @param decrement
+     */
+    decrementBucket(bucketIndex: number, decrement: number): void;
+    /**
+     * trim removes leading and / or trailing zero buckets (which can occur
+     * after diffing two histos) and rotates the backing array so that the
+     * smallest non-zero index is in the 0th position of the backing array
+     */
+    trim(): void;
+    /**
+     * downscale first rotates, then collapses 2**`by`-to-1 buckets.
+     * @param by
+     */
+    downscale(by: number): void;
+    /**
+     * Clone returns a deep copy of Buckets
+     * @returns {Buckets}
+     */
+    clone(): Buckets;
+    /**
+     * _rotate shifts the backing array contents so that indexStart ==
+     * indexBase to simplify the downscale logic.
+     */
+    private _rotate;
+    /**
+     * _relocateBucket adds the count in counts[src] to counts[dest] and
+     * resets count[src] to zero.
+     */
+    private _relocateBucket;
+}
+/**
+ * BucketsBacking holds the raw buckets and some utility methods to
+ * manage them.
+ */
+declare class BucketsBacking {
+    private _counts;
+    constructor(_counts?: number[]);
+    /**
+     * length returns the physical size of the backing array, which
+     * is >= buckets.length()
+     */
+    get length(): number;
+    /**
+     * countAt returns the count in a specific bucket
+     */
+    countAt(pos: number): number;
+    /**
+     * growTo grows a backing array and copies old entries
+     * into their correct new positions.
+     */
+    growTo(newSize: number, oldPositiveLimit: number, newPositiveLimit: number): void;
+    /**
+     * reverse the items in the backing array in the range [from, limit).
+     */
+    reverse(from: number, limit: number): void;
+    /**
+     * emptyBucket empties the count from a bucket, for
+     * moving into another.
+     */
+    emptyBucket(src: number): number;
+    /**
+     * increments a bucket by `increment`
+     */
+    increment(bucketIndex: number, increment: number): void;
+    /**
+     * decrements a bucket by `decrement`
+     */
+    decrement(bucketIndex: number, decrement: number): void;
+    /**
+     * clone returns a deep copy of BucketsBacking
+     */
+    clone(): BucketsBacking;
+}
+export {};
+//# sourceMappingURL=Buckets.d.ts.map