@safaricom-mxl/web-sdk 0.0.16 → 0.0.18

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/ExponentialHistogram.cjs

@@ -0,0 +1,423 @@
+"use strict";
+const require_runtime = require("../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_MetricData$1 = require("../export/MetricData.cjs");
+const require_types$1 = require("./types.cjs");
+const require_Buckets$1 = require("./exponential-histogram/Buckets.cjs");
+const require_util$1 = require("./exponential-histogram/util.cjs");
+const require_getMapping$1 = require("./exponential-histogram/mapping/getMapping.cjs");
+//#region ../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/ExponentialHistogram.js
+var require_ExponentialHistogram = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ExponentialHistogramAggregator = exports.ExponentialHistogramAccumulation = void 0;
+	const types_1 = require_types$1.default;
+	const MetricData_1 = require_MetricData$1.default;
+	const api_1 = require("@opentelemetry/api");
+	const Buckets_1 = require_Buckets$1.default;
+	const getMapping_1 = require_getMapping$1.default;
+	const util_1 = require_util$1.default;
+	var HighLow = class HighLow {
+		static combine(h1, h2) {
+			return new HighLow(Math.min(h1.low, h2.low), Math.max(h1.high, h2.high));
+		}
+		low;
+		high;
+		constructor(low, high) {
+			this.low = low;
+			this.high = high;
+		}
+	};
+	const MAX_SCALE = 20;
+	const DEFAULT_MAX_SIZE = 160;
+	const MIN_MAX_SIZE = 2;
+	var ExponentialHistogramAccumulation = class ExponentialHistogramAccumulation {
+		startTime;
+		_maxSize;
+		_recordMinMax;
+		_sum;
+		_count;
+		_zeroCount;
+		_min;
+		_max;
+		_positive;
+		_negative;
+		_mapping;
+		constructor(startTime, maxSize = DEFAULT_MAX_SIZE, recordMinMax = true, sum = 0, count = 0, zeroCount = 0, min = Number.POSITIVE_INFINITY, max = Number.NEGATIVE_INFINITY, positive = new Buckets_1.Buckets(), negative = new Buckets_1.Buckets(), mapping = (0, getMapping_1.getMapping)(MAX_SCALE)) {
+			this.startTime = startTime;
+			this._maxSize = maxSize;
+			this._recordMinMax = recordMinMax;
+			this._sum = sum;
+			this._count = count;
+			this._zeroCount = zeroCount;
+			this._min = min;
+			this._max = max;
+			this._positive = positive;
+			this._negative = negative;
+			this._mapping = mapping;
+			if (this._maxSize < MIN_MAX_SIZE) {
+				api_1.diag.warn(`Exponential Histogram Max Size set to ${this._maxSize}, \
+                changing to the minimum size of: ${MIN_MAX_SIZE}`);
+				this._maxSize = MIN_MAX_SIZE;
+			}
+		}
+		/**
+		* record updates a histogram with a single count
+		* @param {Number} value
+		*/
+		record(value) {
+			this.updateByIncrement(value, 1);
+		}
+		/**
+		* Sets the start time for this accumulation
+		* @param {HrTime} startTime
+		*/
+		setStartTime(startTime) {
+			this.startTime = startTime;
+		}
+		/**
+		* Returns the datapoint representation of this accumulation
+		* @param {HrTime} startTime
+		*/
+		toPointValue() {
+			return {
+				hasMinMax: this._recordMinMax,
+				min: this.min,
+				max: this.max,
+				sum: this.sum,
+				positive: {
+					offset: this.positive.offset,
+					bucketCounts: this.positive.counts()
+				},
+				negative: {
+					offset: this.negative.offset,
+					bucketCounts: this.negative.counts()
+				},
+				count: this.count,
+				scale: this.scale,
+				zeroCount: this.zeroCount
+			};
+		}
+		/**
+		* @returns {Number} The sum of values recorded by this accumulation
+		*/
+		get sum() {
+			return this._sum;
+		}
+		/**
+		* @returns {Number} The minimum value recorded by this accumulation
+		*/
+		get min() {
+			return this._min;
+		}
+		/**
+		* @returns {Number} The maximum value recorded by this accumulation
+		*/
+		get max() {
+			return this._max;
+		}
+		/**
+		* @returns {Number} The count of values recorded by this accumulation
+		*/
+		get count() {
+			return this._count;
+		}
+		/**
+		* @returns {Number} The number of 0 values recorded by this accumulation
+		*/
+		get zeroCount() {
+			return this._zeroCount;
+		}
+		/**
+		* @returns {Number} The scale used by this accumulation
+		*/
+		get scale() {
+			if (this._count === this._zeroCount) return 0;
+			return this._mapping.scale;
+		}
+		/**
+		* positive holds the positive values
+		* @returns {Buckets}
+		*/
+		get positive() {
+			return this._positive;
+		}
+		/**
+		* negative holds the negative values by their absolute value
+		* @returns {Buckets}
+		*/
+		get negative() {
+			return this._negative;
+		}
+		/**
+		* updateByIncr supports updating a histogram with a non-negative
+		* increment.
+		* @param value
+		* @param increment
+		*/
+		updateByIncrement(value, increment) {
+			if (Number.isNaN(value)) return;
+			if (value > this._max) this._max = value;
+			if (value < this._min) this._min = value;
+			this._count += increment;
+			if (value === 0) {
+				this._zeroCount += increment;
+				return;
+			}
+			this._sum += value * increment;
+			if (value > 0) this._updateBuckets(this._positive, value, increment);
+			else this._updateBuckets(this._negative, -value, increment);
+		}
+		/**
+		* merge combines data from previous value into self
+		* @param {ExponentialHistogramAccumulation} previous
+		*/
+		merge(previous) {
+			if (this._count === 0) {
+				this._min = previous.min;
+				this._max = previous.max;
+			} else if (previous.count !== 0) {
+				if (previous.min < this.min) this._min = previous.min;
+				if (previous.max > this.max) this._max = previous.max;
+			}
+			this.startTime = previous.startTime;
+			this._sum += previous.sum;
+			this._count += previous.count;
+			this._zeroCount += previous.zeroCount;
+			const minScale = this._minScale(previous);
+			this._downscale(this.scale - minScale);
+			this._mergeBuckets(this.positive, previous, previous.positive, minScale);
+			this._mergeBuckets(this.negative, previous, previous.negative, minScale);
+		}
+		/**
+		* diff subtracts other from self
+		* @param {ExponentialHistogramAccumulation} other
+		*/
+		diff(other) {
+			this._min = Infinity;
+			this._max = -Infinity;
+			this._sum -= other.sum;
+			this._count -= other.count;
+			this._zeroCount -= other.zeroCount;
+			const minScale = this._minScale(other);
+			this._downscale(this.scale - minScale);
+			this._diffBuckets(this.positive, other, other.positive, minScale);
+			this._diffBuckets(this.negative, other, other.negative, minScale);
+		}
+		/**
+		* clone returns a deep copy of self
+		* @returns {ExponentialHistogramAccumulation}
+		*/
+		clone() {
+			return new ExponentialHistogramAccumulation(this.startTime, this._maxSize, this._recordMinMax, this._sum, this._count, this._zeroCount, this._min, this._max, this.positive.clone(), this.negative.clone(), this._mapping);
+		}
+		/**
+		* _updateBuckets maps the incoming value to a bucket index for the current
+		* scale. If the bucket index is outside of the range of the backing array,
+		* it will rescale the backing array and update the mapping for the new scale.
+		*/
+		_updateBuckets(buckets, value, increment) {
+			let index = this._mapping.mapToIndex(value);
+			let rescalingNeeded = false;
+			let high = 0;
+			let low = 0;
+			if (buckets.length === 0) {
+				buckets.indexStart = index;
+				buckets.indexEnd = buckets.indexStart;
+				buckets.indexBase = buckets.indexStart;
+			} else if (index < buckets.indexStart && buckets.indexEnd - index >= this._maxSize) {
+				rescalingNeeded = true;
+				low = index;
+				high = buckets.indexEnd;
+			} else if (index > buckets.indexEnd && index - buckets.indexStart >= this._maxSize) {
+				rescalingNeeded = true;
+				low = buckets.indexStart;
+				high = index;
+			}
+			if (rescalingNeeded) {
+				const change = this._changeScale(high, low);
+				this._downscale(change);
+				index = this._mapping.mapToIndex(value);
+			}
+			this._incrementIndexBy(buckets, index, increment);
+		}
+		/**
+		* _incrementIndexBy increments the count of the bucket specified by `index`.
+		* If the index is outside of the range [buckets.indexStart, buckets.indexEnd]
+		* the boundaries of the backing array will be adjusted and more buckets will
+		* be added if needed.
+		*/
+		_incrementIndexBy(buckets, index, increment) {
+			if (increment === 0) return;
+			if (buckets.length === 0) buckets.indexStart = buckets.indexEnd = buckets.indexBase = index;
+			if (index < buckets.indexStart) {
+				const span = buckets.indexEnd - index;
+				if (span >= buckets.backing.length) this._grow(buckets, span + 1);
+				buckets.indexStart = index;
+			} else if (index > buckets.indexEnd) {
+				const span = index - buckets.indexStart;
+				if (span >= buckets.backing.length) this._grow(buckets, span + 1);
+				buckets.indexEnd = index;
+			}
+			let bucketIndex = index - buckets.indexBase;
+			if (bucketIndex < 0) bucketIndex += buckets.backing.length;
+			buckets.incrementBucket(bucketIndex, increment);
+		}
+		/**
+		* grow resizes the backing array by doubling in size up to maxSize.
+		* This extends the array with a bunch of zeros and copies the
+		* existing counts to the same position.
+		*/
+		_grow(buckets, needed) {
+			const size = buckets.backing.length;
+			const bias = buckets.indexBase - buckets.indexStart;
+			const oldPositiveLimit = size - bias;
+			let newSize = (0, util_1.nextGreaterSquare)(needed);
+			if (newSize > this._maxSize) newSize = this._maxSize;
+			const newPositiveLimit = newSize - bias;
+			buckets.backing.growTo(newSize, oldPositiveLimit, newPositiveLimit);
+		}
+		/**
+		* _changeScale computes how much downscaling is needed by shifting the
+		* high and low values until they are separated by no more than size.
+		*/
+		_changeScale(high, low) {
+			let change = 0;
+			while (high - low >= this._maxSize) {
+				high >>= 1;
+				low >>= 1;
+				change++;
+			}
+			return change;
+		}
+		/**
+		* _downscale subtracts `change` from the current mapping scale.
+		*/
+		_downscale(change) {
+			if (change === 0) return;
+			if (change < 0) throw new Error(`impossible change of scale: ${this.scale}`);
+			const newScale = this._mapping.scale - change;
+			this._positive.downscale(change);
+			this._negative.downscale(change);
+			this._mapping = (0, getMapping_1.getMapping)(newScale);
+		}
+		/**
+		* _minScale is used by diff and merge to compute an ideal combined scale
+		*/
+		_minScale(other) {
+			const minScale = Math.min(this.scale, other.scale);
+			const highLowPos = HighLow.combine(this._highLowAtScale(this.positive, this.scale, minScale), this._highLowAtScale(other.positive, other.scale, minScale));
+			const highLowNeg = HighLow.combine(this._highLowAtScale(this.negative, this.scale, minScale), this._highLowAtScale(other.negative, other.scale, minScale));
+			return Math.min(minScale - this._changeScale(highLowPos.high, highLowPos.low), minScale - this._changeScale(highLowNeg.high, highLowNeg.low));
+		}
+		/**
+		* _highLowAtScale is used by diff and merge to compute an ideal combined scale.
+		*/
+		_highLowAtScale(buckets, currentScale, newScale) {
+			if (buckets.length === 0) return new HighLow(0, -1);
+			const shift = currentScale - newScale;
+			return new HighLow(buckets.indexStart >> shift, buckets.indexEnd >> shift);
+		}
+		/**
+		* _mergeBuckets translates index values from another histogram and
+		* adds the values into the corresponding buckets of this histogram.
+		*/
+		_mergeBuckets(ours, other, theirs, scale) {
+			const theirOffset = theirs.offset;
+			const theirChange = other.scale - scale;
+			for (let i = 0; i < theirs.length; i++) this._incrementIndexBy(ours, theirOffset + i >> theirChange, theirs.at(i));
+		}
+		/**
+		* _diffBuckets translates index values from another histogram and
+		* subtracts the values in the corresponding buckets of this histogram.
+		*/
+		_diffBuckets(ours, other, theirs, scale) {
+			const theirOffset = theirs.offset;
+			const theirChange = other.scale - scale;
+			for (let i = 0; i < theirs.length; i++) {
+				let bucketIndex = (theirOffset + i >> theirChange) - ours.indexBase;
+				if (bucketIndex < 0) bucketIndex += ours.backing.length;
+				ours.decrementBucket(bucketIndex, theirs.at(i));
+			}
+			ours.trim();
+		}
+	};
+	exports.ExponentialHistogramAccumulation = ExponentialHistogramAccumulation;
+	/**
+	* Aggregator for ExponentialHistogramAccumulations
+	*/
+	var ExponentialHistogramAggregator = class {
+		kind = types_1.AggregatorKind.EXPONENTIAL_HISTOGRAM;
+		_maxSize;
+		_recordMinMax;
+		/**
+		* @param _maxSize Maximum number of buckets for each of the positive
+		*    and negative ranges, exclusive of the zero-bucket.
+		* @param _recordMinMax If set to true, min and max will be recorded.
+		*    Otherwise, min and max will not be recorded.
+		*/
+		constructor(maxSize, recordMinMax) {
+			this._maxSize = maxSize;
+			this._recordMinMax = recordMinMax;
+		}
+		createAccumulation(startTime) {
+			return new ExponentialHistogramAccumulation(startTime, this._maxSize, this._recordMinMax);
+		}
+		/**
+		* Return the result of the merge of two exponential histogram accumulations.
+		*/
+		merge(previous, delta) {
+			const result = delta.clone();
+			result.merge(previous);
+			return result;
+		}
+		/**
+		* Returns a new DELTA aggregation by comparing two cumulative measurements.
+		*/
+		diff(previous, current) {
+			const result = current.clone();
+			result.diff(previous);
+			return result;
+		}
+		toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) {
+			return {
+				descriptor,
+				aggregationTemporality,
+				dataPointType: MetricData_1.DataPointType.EXPONENTIAL_HISTOGRAM,
+				dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {
+					const pointValue = accumulation.toPointValue();
+					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 : void 0,
+							max: pointValue.hasMinMax ? pointValue.max : void 0,
+							sum: !allowsNegativeValues ? pointValue.sum : void 0,
+							positive: {
+								offset: pointValue.positive.offset,
+								bucketCounts: pointValue.positive.bucketCounts
+							},
+							negative: {
+								offset: pointValue.negative.offset,
+								bucketCounts: pointValue.negative.bucketCounts
+							},
+							count: pointValue.count,
+							scale: pointValue.scale,
+							zeroCount: pointValue.zeroCount
+						}
+					};
+				})
+			};
+		}
+	};
+	exports.ExponentialHistogramAggregator = ExponentialHistogramAggregator;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_ExponentialHistogram();
+	}
+});
+
+//# sourceMappingURL=ExponentialHistogram.cjs.map

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/ExponentialHistogram.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExponentialHistogram.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/ExponentialHistogram.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ExponentialHistogramAggregator = exports.ExponentialHistogramAccumulation = void 0;\nconst types_1 = require(\"./types\");\nconst MetricData_1 = require(\"../export/MetricData\");\nconst api_1 = require(\"@opentelemetry/api\");\nconst Buckets_1 = require(\"./exponential-histogram/Buckets\");\nconst getMapping_1 = require(\"./exponential-histogram/mapping/getMapping\");\nconst util_1 = require(\"./exponential-histogram/util\");\n// HighLow is a utility class used for computing a common scale for\n// two exponential histogram accumulations\nclass HighLow {\n    static combine(h1, h2) {\n        return new HighLow(Math.min(h1.low, h2.low), Math.max(h1.high, h2.high));\n    }\n    low;\n    high;\n    constructor(low, high) {\n        this.low = low;\n        this.high = high;\n    }\n}\nconst MAX_SCALE = 20;\nconst DEFAULT_MAX_SIZE = 160;\nconst MIN_MAX_SIZE = 2;\nclass ExponentialHistogramAccumulation {\n    startTime;\n    _maxSize;\n    _recordMinMax;\n    _sum;\n    _count;\n    _zeroCount;\n    _min;\n    _max;\n    _positive;\n    _negative;\n    _mapping;\n    constructor(startTime, maxSize = DEFAULT_MAX_SIZE, recordMinMax = true, sum = 0, count = 0, zeroCount = 0, min = Number.POSITIVE_INFINITY, max = Number.NEGATIVE_INFINITY, positive = new Buckets_1.Buckets(), negative = new Buckets_1.Buckets(), mapping = (0, getMapping_1.getMapping)(MAX_SCALE)) {\n        this.startTime = startTime;\n        this._maxSize = maxSize;\n        this._recordMinMax = recordMinMax;\n        this._sum = sum;\n        this._count = count;\n        this._zeroCount = zeroCount;\n        this._min = min;\n        this._max = max;\n        this._positive = positive;\n        this._negative = negative;\n        this._mapping = mapping;\n        if (this._maxSize < MIN_MAX_SIZE) {\n            api_1.diag.warn(`Exponential Histogram Max Size set to ${this._maxSize}, \\\n                changing to the minimum size of: ${MIN_MAX_SIZE}`);\n            this._maxSize = MIN_MAX_SIZE;\n        }\n    }\n    /**\n     * record updates a histogram with a single count\n     * @param {Number} value\n     */\n    record(value) {\n        this.updateByIncrement(value, 1);\n    }\n    /**\n     * Sets the start time for this accumulation\n     * @param {HrTime} startTime\n     */\n    setStartTime(startTime) {\n        this.startTime = startTime;\n    }\n    /**\n     * Returns the datapoint representation of this accumulation\n     * @param {HrTime} startTime\n     */\n    toPointValue() {\n        return {\n            hasMinMax: this._recordMinMax,\n            min: this.min,\n            max: this.max,\n            sum: this.sum,\n            positive: {\n                offset: this.positive.offset,\n                bucketCounts: this.positive.counts(),\n            },\n            negative: {\n                offset: this.negative.offset,\n                bucketCounts: this.negative.counts(),\n            },\n            count: this.count,\n            scale: this.scale,\n            zeroCount: this.zeroCount,\n        };\n    }\n    /**\n     * @returns {Number} The sum of values recorded by this accumulation\n     */\n    get sum() {\n        return this._sum;\n    }\n    /**\n     * @returns {Number} The minimum value recorded by this accumulation\n     */\n    get min() {\n        return this._min;\n    }\n    /**\n     * @returns {Number} The maximum value recorded by this accumulation\n     */\n    get max() {\n        return this._max;\n    }\n    /**\n     * @returns {Number} The count of values recorded by this accumulation\n     */\n    get count() {\n        return this._count;\n    }\n    /**\n     * @returns {Number} The number of 0 values recorded by this accumulation\n     */\n    get zeroCount() {\n        return this._zeroCount;\n    }\n    /**\n     * @returns {Number} The scale used by this accumulation\n     */\n    get scale() {\n        if (this._count === this._zeroCount) {\n            // all zeros! scale doesn't matter, use zero\n            return 0;\n        }\n        return this._mapping.scale;\n    }\n    /**\n     * positive holds the positive values\n     * @returns {Buckets}\n     */\n    get positive() {\n        return this._positive;\n    }\n    /**\n     * negative holds the negative values by their absolute value\n     * @returns {Buckets}\n     */\n    get negative() {\n        return this._negative;\n    }\n    /**\n     * updateByIncr supports updating a histogram with a non-negative\n     * increment.\n     * @param value\n     * @param increment\n     */\n    updateByIncrement(value, increment) {\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        if (value > this._max) {\n            this._max = value;\n        }\n        if (value < this._min) {\n            this._min = value;\n        }\n        this._count += increment;\n        if (value === 0) {\n            this._zeroCount += increment;\n            return;\n        }\n        this._sum += value * increment;\n        if (value > 0) {\n            this._updateBuckets(this._positive, value, increment);\n        }\n        else {\n            this._updateBuckets(this._negative, -value, increment);\n        }\n    }\n    /**\n     * merge combines data from previous value into self\n     * @param {ExponentialHistogramAccumulation} previous\n     */\n    merge(previous) {\n        if (this._count === 0) {\n            this._min = previous.min;\n            this._max = previous.max;\n        }\n        else if (previous.count !== 0) {\n            if (previous.min < this.min) {\n                this._min = previous.min;\n            }\n            if (previous.max > this.max) {\n                this._max = previous.max;\n            }\n        }\n        this.startTime = previous.startTime;\n        this._sum += previous.sum;\n        this._count += previous.count;\n        this._zeroCount += previous.zeroCount;\n        const minScale = this._minScale(previous);\n        this._downscale(this.scale - minScale);\n        this._mergeBuckets(this.positive, previous, previous.positive, minScale);\n        this._mergeBuckets(this.negative, previous, previous.negative, minScale);\n    }\n    /**\n     * diff subtracts other from self\n     * @param {ExponentialHistogramAccumulation} other\n     */\n    diff(other) {\n        this._min = Infinity;\n        this._max = -Infinity;\n        this._sum -= other.sum;\n        this._count -= other.count;\n        this._zeroCount -= other.zeroCount;\n        const minScale = this._minScale(other);\n        this._downscale(this.scale - minScale);\n        this._diffBuckets(this.positive, other, other.positive, minScale);\n        this._diffBuckets(this.negative, other, other.negative, minScale);\n    }\n    /**\n     * clone returns a deep copy of self\n     * @returns {ExponentialHistogramAccumulation}\n     */\n    clone() {\n        return new ExponentialHistogramAccumulation(this.startTime, this._maxSize, this._recordMinMax, this._sum, this._count, this._zeroCount, this._min, this._max, this.positive.clone(), this.negative.clone(), this._mapping);\n    }\n    /**\n     * _updateBuckets maps the incoming value to a bucket index for the current\n     * scale. If the bucket index is outside of the range of the backing array,\n     * it will rescale the backing array and update the mapping for the new scale.\n     */\n    _updateBuckets(buckets, value, increment) {\n        let index = this._mapping.mapToIndex(value);\n        // rescale the mapping if needed\n        let rescalingNeeded = false;\n        let high = 0;\n        let low = 0;\n        if (buckets.length === 0) {\n            buckets.indexStart = index;\n            buckets.indexEnd = buckets.indexStart;\n            buckets.indexBase = buckets.indexStart;\n        }\n        else if (index < buckets.indexStart &&\n            buckets.indexEnd - index >= this._maxSize) {\n            rescalingNeeded = true;\n            low = index;\n            high = buckets.indexEnd;\n        }\n        else if (index > buckets.indexEnd &&\n            index - buckets.indexStart >= this._maxSize) {\n            rescalingNeeded = true;\n            low = buckets.indexStart;\n            high = index;\n        }\n        // rescale and compute index at new scale\n        if (rescalingNeeded) {\n            const change = this._changeScale(high, low);\n            this._downscale(change);\n            index = this._mapping.mapToIndex(value);\n        }\n        this._incrementIndexBy(buckets, index, increment);\n    }\n    /**\n     * _incrementIndexBy increments the count of the bucket specified by `index`.\n     * If the index is outside of the range [buckets.indexStart, buckets.indexEnd]\n     * the boundaries of the backing array will be adjusted and more buckets will\n     * be added if needed.\n     */\n    _incrementIndexBy(buckets, index, increment) {\n        if (increment === 0) {\n            // nothing to do for a zero increment, can happen during a merge operation\n            return;\n        }\n        if (buckets.length === 0) {\n            buckets.indexStart = buckets.indexEnd = buckets.indexBase = index;\n        }\n        if (index < buckets.indexStart) {\n            const span = buckets.indexEnd - index;\n            if (span >= buckets.backing.length) {\n                this._grow(buckets, span + 1);\n            }\n            buckets.indexStart = index;\n        }\n        else if (index > buckets.indexEnd) {\n            const span = index - buckets.indexStart;\n            if (span >= buckets.backing.length) {\n                this._grow(buckets, span + 1);\n            }\n            buckets.indexEnd = index;\n        }\n        let bucketIndex = index - buckets.indexBase;\n        if (bucketIndex < 0) {\n            bucketIndex += buckets.backing.length;\n        }\n        buckets.incrementBucket(bucketIndex, increment);\n    }\n    /**\n     * grow resizes the backing array by doubling in size up to maxSize.\n     * This extends the array with a bunch of zeros and copies the\n     * existing counts to the same position.\n     */\n    _grow(buckets, needed) {\n        const size = buckets.backing.length;\n        const bias = buckets.indexBase - buckets.indexStart;\n        const oldPositiveLimit = size - bias;\n        let newSize = (0, util_1.nextGreaterSquare)(needed);\n        if (newSize > this._maxSize) {\n            newSize = this._maxSize;\n        }\n        const newPositiveLimit = newSize - bias;\n        buckets.backing.growTo(newSize, oldPositiveLimit, newPositiveLimit);\n    }\n    /**\n     * _changeScale computes how much downscaling is needed by shifting the\n     * high and low values until they are separated by no more than size.\n     */\n    _changeScale(high, low) {\n        let change = 0;\n        while (high - low >= this._maxSize) {\n            high >>= 1;\n            low >>= 1;\n            change++;\n        }\n        return change;\n    }\n    /**\n     * _downscale subtracts `change` from the current mapping scale.\n     */\n    _downscale(change) {\n        if (change === 0) {\n            return;\n        }\n        if (change < 0) {\n            // Note: this should be impossible. If we get here it's because\n            // there is a bug in the implementation.\n            throw new Error(`impossible change of scale: ${this.scale}`);\n        }\n        const newScale = this._mapping.scale - change;\n        this._positive.downscale(change);\n        this._negative.downscale(change);\n        this._mapping = (0, getMapping_1.getMapping)(newScale);\n    }\n    /**\n     * _minScale is used by diff and merge to compute an ideal combined scale\n     */\n    _minScale(other) {\n        const minScale = Math.min(this.scale, other.scale);\n        const highLowPos = HighLow.combine(this._highLowAtScale(this.positive, this.scale, minScale), this._highLowAtScale(other.positive, other.scale, minScale));\n        const highLowNeg = HighLow.combine(this._highLowAtScale(this.negative, this.scale, minScale), this._highLowAtScale(other.negative, other.scale, minScale));\n        return Math.min(minScale - this._changeScale(highLowPos.high, highLowPos.low), minScale - this._changeScale(highLowNeg.high, highLowNeg.low));\n    }\n    /**\n     * _highLowAtScale is used by diff and merge to compute an ideal combined scale.\n     */\n    _highLowAtScale(buckets, currentScale, newScale) {\n        if (buckets.length === 0) {\n            return new HighLow(0, -1);\n        }\n        const shift = currentScale - newScale;\n        return new HighLow(buckets.indexStart >> shift, buckets.indexEnd >> shift);\n    }\n    /**\n     * _mergeBuckets translates index values from another histogram and\n     * adds the values into the corresponding buckets of this histogram.\n     */\n    _mergeBuckets(ours, other, theirs, scale) {\n        const theirOffset = theirs.offset;\n        const theirChange = other.scale - scale;\n        for (let i = 0; i < theirs.length; i++) {\n            this._incrementIndexBy(ours, (theirOffset + i) >> theirChange, theirs.at(i));\n        }\n    }\n    /**\n     * _diffBuckets translates index values from another histogram and\n     * subtracts the values in the corresponding buckets of this histogram.\n     */\n    _diffBuckets(ours, other, theirs, scale) {\n        const theirOffset = theirs.offset;\n        const theirChange = other.scale - scale;\n        for (let i = 0; i < theirs.length; i++) {\n            const ourIndex = (theirOffset + i) >> theirChange;\n            let bucketIndex = ourIndex - ours.indexBase;\n            if (bucketIndex < 0) {\n                bucketIndex += ours.backing.length;\n            }\n            ours.decrementBucket(bucketIndex, theirs.at(i));\n        }\n        ours.trim();\n    }\n}\nexports.ExponentialHistogramAccumulation = ExponentialHistogramAccumulation;\n/**\n * Aggregator for ExponentialHistogramAccumulations\n */\nclass ExponentialHistogramAggregator {\n    kind = types_1.AggregatorKind.EXPONENTIAL_HISTOGRAM;\n    _maxSize;\n    _recordMinMax;\n    /**\n     * @param _maxSize Maximum number of buckets for each of the positive\n     *    and negative ranges, exclusive of the zero-bucket.\n     * @param _recordMinMax If set to true, min and max will be recorded.\n     *    Otherwise, min and max will not be recorded.\n     */\n    constructor(maxSize, recordMinMax) {\n        this._maxSize = maxSize;\n        this._recordMinMax = recordMinMax;\n    }\n    createAccumulation(startTime) {\n        return new ExponentialHistogramAccumulation(startTime, this._maxSize, this._recordMinMax);\n    }\n    /**\n     * Return the result of the merge of two exponential histogram accumulations.\n     */\n    merge(previous, delta) {\n        const result = delta.clone();\n        result.merge(previous);\n        return result;\n    }\n    /**\n     * Returns a new DELTA aggregation by comparing two cumulative measurements.\n     */\n    diff(previous, current) {\n        const result = current.clone();\n        result.diff(previous);\n        return result;\n    }\n    toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) {\n        return {\n            descriptor,\n            aggregationTemporality,\n            dataPointType: MetricData_1.DataPointType.EXPONENTIAL_HISTOGRAM,\n            dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {\n                const pointValue = accumulation.toPointValue();\n                // determine if instrument allows negative values.\n                const allowsNegativeValues = descriptor.type === MetricData_1.InstrumentType.GAUGE ||\n                    descriptor.type === MetricData_1.InstrumentType.UP_DOWN_COUNTER ||\n                    descriptor.type === MetricData_1.InstrumentType.OBSERVABLE_GAUGE ||\n                    descriptor.type === MetricData_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER;\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                        positive: {\n                            offset: pointValue.positive.offset,\n                            bucketCounts: pointValue.positive.bucketCounts,\n                        },\n                        negative: {\n                            offset: pointValue.negative.offset,\n                            bucketCounts: pointValue.negative.bucketCounts,\n                        },\n                        count: pointValue.count,\n                        scale: pointValue.scale,\n                        zeroCount: pointValue.zeroCount,\n                    },\n                };\n            }),\n        };\n    }\n}\nexports.ExponentialHistogramAggregator = ExponentialHistogramAggregator;\n//# sourceMappingURL=ExponentialHistogram.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/ExponentialHistogram.d.cts

@@ -0,0 +1 @@
+import { HrTime } from "@opentelemetry/api";

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

@@ -0,0 +1 @@
+import { HrTime } from "@opentelemetry/api";

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

@@ -0,0 +1,172 @@
+"use strict";
+const require_runtime = require("../../../../../../_virtual/_rolldown/runtime.cjs");
+const require_MetricData$1 = require("../export/MetricData.cjs");
+const require_utils$1 = require("../utils.cjs");
+const require_types$1 = require("./types.cjs");
+//#region ../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Histogram.js
+var require_Histogram = /* @__PURE__ */ require_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.HistogramAggregator = exports.HistogramAccumulation = void 0;
+	const types_1 = require_types$1.default;
+	const MetricData_1 = require_MetricData$1.default;
+	const utils_1 = require_utils$1.default;
+	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
+		};
+	}
+	var HistogramAccumulation = class {
+		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) {
+			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.
+	*/
+	var HistogramAggregator = class {
+		kind = types_1.AggregatorKind.HISTOGRAM;
+		_boundaries;
+		_recordMinMax;
+		/**
+		* @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,
+				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();
+					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 : void 0,
+							max: pointValue.hasMinMax ? pointValue.max : void 0,
+							sum: !allowsNegativeValues ? pointValue.sum : void 0,
+							buckets: pointValue.buckets,
+							count: pointValue.count
+						}
+					};
+				})
+			};
+		}
+	};
+	exports.HistogramAggregator = HistogramAggregator;
+}));
+//#endregion
+Object.defineProperty(exports, "default", {
+	enumerable: true,
+	get: function() {
+		return require_Histogram();
+	}
+});
+
+//# sourceMappingURL=Histogram.cjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Histogram.cjs","names":[],"sources":["../../../../../../../../../node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Histogram.js"],"sourcesContent":["\"use strict\";\n/*\n * Copyright The OpenTelemetry Authors\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.HistogramAggregator = exports.HistogramAccumulation = void 0;\nconst types_1 = require(\"./types\");\nconst MetricData_1 = require(\"../export/MetricData\");\nconst utils_1 = require(\"../utils\");\nfunction createNewEmptyCheckpoint(boundaries) {\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}\nclass HistogramAccumulation {\n    startTime;\n    _boundaries;\n    _recordMinMax;\n    _current;\n    constructor(startTime, boundaries, recordMinMax = true, current = createNewEmptyCheckpoint(boundaries)) {\n        this.startTime = startTime;\n        this._boundaries = boundaries;\n        this._recordMinMax = recordMinMax;\n        this._current = current;\n    }\n    record(value) {\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        this._current.count += 1;\n        this._current.sum += value;\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        const idx = (0, utils_1.binarySearchUB)(this._boundaries, value);\n        this._current.buckets.counts[idx] += 1;\n    }\n    setStartTime(startTime) {\n        this.startTime = startTime;\n    }\n    toPointValue() {\n        return this._current;\n    }\n}\nexports.HistogramAccumulation = HistogramAccumulation;\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 */\nclass HistogramAggregator {\n    kind = types_1.AggregatorKind.HISTOGRAM;\n    _boundaries;\n    _recordMinMax;\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(boundaries, recordMinMax) {\n        this._boundaries = boundaries;\n        this._recordMinMax = recordMinMax;\n    }\n    createAccumulation(startTime) {\n        return new HistogramAccumulation(startTime, this._boundaries, this._recordMinMax);\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(previous, delta) {\n        const previousValue = previous.toPointValue();\n        const deltaValue = delta.toPointValue();\n        const previousCounts = previousValue.buckets.counts;\n        const deltaCounts = deltaValue.buckets.counts;\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        let min = Infinity;\n        let max = -Infinity;\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            }\n            else if (previousValue.hasMinMax) {\n                min = previousValue.min;\n                max = previousValue.max;\n            }\n            else if (deltaValue.hasMinMax) {\n                min = deltaValue.min;\n                max = deltaValue.max;\n            }\n        }\n        return new HistogramAccumulation(previous.startTime, previousValue.buckets.boundaries, this._recordMinMax, {\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: this._recordMinMax &&\n                (previousValue.hasMinMax || deltaValue.hasMinMax),\n            min: min,\n            max: max,\n        });\n    }\n    /**\n     * Returns a new DELTA aggregation by comparing two cumulative measurements.\n     */\n    diff(previous, current) {\n        const previousValue = previous.toPointValue();\n        const currentValue = current.toPointValue();\n        const previousCounts = previousValue.buckets.counts;\n        const currentCounts = currentValue.buckets.counts;\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        return new HistogramAccumulation(current.startTime, previousValue.buckets.boundaries, this._recordMinMax, {\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    toMetricData(descriptor, aggregationTemporality, accumulationByAttributes, endTime) {\n        return {\n            descriptor,\n            aggregationTemporality,\n            dataPointType: MetricData_1.DataPointType.HISTOGRAM,\n            dataPoints: accumulationByAttributes.map(([attributes, accumulation]) => {\n                const pointValue = accumulation.toPointValue();\n                // determine if instrument allows negative values.\n                const allowsNegativeValues = descriptor.type === MetricData_1.InstrumentType.GAUGE ||\n                    descriptor.type === MetricData_1.InstrumentType.UP_DOWN_COUNTER ||\n                    descriptor.type === MetricData_1.InstrumentType.OBSERVABLE_GAUGE ||\n                    descriptor.type === MetricData_1.InstrumentType.OBSERVABLE_UP_DOWN_COUNTER;\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}\nexports.HistogramAggregator = HistogramAggregator;\n//# sourceMappingURL=Histogram.js.map"],"x_google_ignoreList":[0],"mappings":"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"}

package/dist/node_modules/@opentelemetry/sdk-metrics/build/src/aggregator/Histogram.d.cts

@@ -0,0 +1 @@
+import { HrTime } from "@opentelemetry/api";