decocms 2.333.0 → 2.334.0

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

@@ -0,0 +1,88 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { diag, ValueType, } from '@opentelemetry/api';
+import { AttributeHashMap } from './state/HashMap';
+import { isObservableInstrument } from './Instruments';
+/**
+ * The class implements {@link ObservableResult} interface.
+ */
+export class ObservableResultImpl {
+    _instrumentName;
+    _valueType;
+    /**
+     * @internal
+     */
+    _buffer = new AttributeHashMap();
+    constructor(_instrumentName, _valueType) {
+        this._instrumentName = _instrumentName;
+        this._valueType = _valueType;
+    }
+    /**
+     * Observe a measurement of the value associated with the given attributes.
+     */
+    observe(value, attributes = {}) {
+        if (typeof value !== 'number') {
+            diag.warn(`non-number value provided to metric ${this._instrumentName}: ${value}`);
+            return;
+        }
+        if (this._valueType === ValueType.INT && !Number.isInteger(value)) {
+            diag.warn(`INT value type cannot accept a floating-point value for ${this._instrumentName}, ignoring the fractional digits.`);
+            value = Math.trunc(value);
+            // ignore non-finite values.
+            if (!Number.isInteger(value)) {
+                return;
+            }
+        }
+        this._buffer.set(attributes, value);
+    }
+}
+/**
+ * The class implements {@link BatchObservableCallback} interface.
+ */
+export class BatchObservableResultImpl {
+    /**
+     * @internal
+     */
+    _buffer = new Map();
+    /**
+     * Observe a measurement of the value associated with the given attributes.
+     */
+    observe(metric, value, attributes = {}) {
+        if (!isObservableInstrument(metric)) {
+            return;
+        }
+        let map = this._buffer.get(metric);
+        if (map == null) {
+            map = new AttributeHashMap();
+            this._buffer.set(metric, map);
+        }
+        if (typeof value !== 'number') {
+            diag.warn(`non-number value provided to metric ${metric._descriptor.name}: ${value}`);
+            return;
+        }
+        if (metric._descriptor.valueType === ValueType.INT &&
+            !Number.isInteger(value)) {
+            diag.warn(`INT value type cannot accept a floating-point value for ${metric._descriptor.name}, ignoring the fractional digits.`);
+            value = Math.trunc(value);
+            // ignore non-finite values.
+            if (!Number.isInteger(value)) {
+                return;
+            }
+        }
+        map.set(attributes, value);
+    }
+}
+//# sourceMappingURL=ObservableResult.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ObservableResult.js","sourceRoot":"","sources":["../../src/ObservableResult.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EACL,IAAI,EAGJ,SAAS,GAGV,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,sBAAsB,EAAwB,MAAM,eAAe,CAAC;AAE7E;;GAEG;AACH,MAAM,OAAO,oBAAoB;IAOrB;IACA;IAPV;;OAEG;IACH,OAAO,GAAG,IAAI,gBAAgB,EAAU,CAAC;IAEzC,YACU,eAAuB,EACvB,UAAqB;QADrB,oBAAe,GAAf,eAAe,CAAQ;QACvB,eAAU,GAAV,UAAU,CAAW;IAC5B,CAAC;IAEJ;;OAEG;IACH,OAAO,CAAC,KAAa,EAAE,aAAyB,EAAE;QAChD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC7B,IAAI,CAAC,IAAI,CACP,uCAAuC,IAAI,CAAC,eAAe,KAAK,KAAK,EAAE,CACxE,CAAC;YACF,OAAO;SACR;QACD,IAAI,IAAI,CAAC,UAAU,KAAK,SAAS,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;YACjE,IAAI,CAAC,IAAI,CACP,2DAA2D,IAAI,CAAC,eAAe,mCAAmC,CACnH,CAAC;YACF,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC1B,4BAA4B;YAC5B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;gBAC5B,OAAO;aACR;SACF;QACD,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IACtC,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,yBAAyB;IACpC;;OAEG;IACH,OAAO,GAAwD,IAAI,GAAG,EAAE,CAAC;IAEzE;;OAEG;IACH,OAAO,CACL,MAAkB,EAClB,KAAa,EACb,aAAyB,EAAE;QAE3B,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,EAAE;YACnC,OAAO;SACR;QACD,IAAI,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACnC,IAAI,GAAG,IAAI,IAAI,EAAE;YACf,GAAG,GAAG,IAAI,gBAAgB,EAAE,CAAC;YAC7B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;SAC/B;QACD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE;YAC7B,IAAI,CAAC,IAAI,CACP,uCAAuC,MAAM,CAAC,WAAW,CAAC,IAAI,KAAK,KAAK,EAAE,CAC3E,CAAC;YACF,OAAO;SACR;QACD,IACE,MAAM,CAAC,WAAW,CAAC,SAAS,KAAK,SAAS,CAAC,GAAG;YAC9C,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,EACxB;YACA,IAAI,CAAC,IAAI,CACP,2DAA2D,MAAM,CAAC,WAAW,CAAC,IAAI,mCAAmC,CACtH,CAAC;YACF,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC1B,4BAA4B;YAC5B,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE;gBAC5B,OAAO;aACR;SACF;QACD,GAAG,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IAC7B,CAAC;CACF","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  diag,\n  ObservableResult,\n  Attributes,\n  ValueType,\n  BatchObservableResult,\n  Observable,\n} from '@opentelemetry/api';\nimport { AttributeHashMap } from './state/HashMap';\nimport { isObservableInstrument, ObservableInstrument } from './Instruments';\n\n/**\n * The class implements {@link ObservableResult} interface.\n */\nexport class ObservableResultImpl implements ObservableResult {\n  /**\n   * @internal\n   */\n  _buffer = new AttributeHashMap<number>();\n\n  constructor(\n    private _instrumentName: string,\n    private _valueType: ValueType\n  ) {}\n\n  /**\n   * Observe a measurement of the value associated with the given attributes.\n   */\n  observe(value: number, attributes: Attributes = {}): void {\n    if (typeof value !== 'number') {\n      diag.warn(\n        `non-number value provided to metric ${this._instrumentName}: ${value}`\n      );\n      return;\n    }\n    if (this._valueType === ValueType.INT && !Number.isInteger(value)) {\n      diag.warn(\n        `INT value type cannot accept a floating-point value for ${this._instrumentName}, ignoring the fractional digits.`\n      );\n      value = Math.trunc(value);\n      // ignore non-finite values.\n      if (!Number.isInteger(value)) {\n        return;\n      }\n    }\n    this._buffer.set(attributes, value);\n  }\n}\n\n/**\n * The class implements {@link BatchObservableCallback} interface.\n */\nexport class BatchObservableResultImpl implements BatchObservableResult {\n  /**\n   * @internal\n   */\n  _buffer: Map<ObservableInstrument, AttributeHashMap<number>> = new Map();\n\n  /**\n   * Observe a measurement of the value associated with the given attributes.\n   */\n  observe(\n    metric: Observable,\n    value: number,\n    attributes: Attributes = {}\n  ): void {\n    if (!isObservableInstrument(metric)) {\n      return;\n    }\n    let map = this._buffer.get(metric);\n    if (map == null) {\n      map = new AttributeHashMap();\n      this._buffer.set(metric, map);\n    }\n    if (typeof value !== 'number') {\n      diag.warn(\n        `non-number value provided to metric ${metric._descriptor.name}: ${value}`\n      );\n      return;\n    }\n    if (\n      metric._descriptor.valueType === ValueType.INT &&\n      !Number.isInteger(value)\n    ) {\n      diag.warn(\n        `INT value type cannot accept a floating-point value for ${metric._descriptor.name}, ignoring the fractional digits.`\n      );\n      value = Math.trunc(value);\n      // ignore non-finite values.\n      if (!Number.isInteger(value)) {\n        return;\n      }\n    }\n    map.set(attributes, value);\n  }\n}\n"]}

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

@@ -0,0 +1,14 @@
+import { HrTime } from '@opentelemetry/api';
+import { AggregationTemporality } from '../export/AggregationTemporality';
+import { MetricData, MetricDescriptor } from '../export/MetricData';
+import { Maybe } from '../utils';
+import { AggregatorKind, Aggregator, AccumulationRecord } from './types';
+/** Basic aggregator for None which keeps no recorded value. */
+export declare class DropAggregator implements Aggregator<undefined> {
+    kind: AggregatorKind.DROP;
+    createAccumulation(): undefined;
+    merge(_previous: undefined, _delta: undefined): undefined;
+    diff(_previous: undefined, _current: undefined): undefined;
+    toMetricData(_descriptor: MetricDescriptor, _aggregationTemporality: AggregationTemporality, _accumulationByAttributes: AccumulationRecord<undefined>[], _endTime: HrTime): Maybe<MetricData>;
+}
+//# sourceMappingURL=Drop.d.ts.map

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

@@ -0,0 +1,33 @@
+/*
+ * Copyright The OpenTelemetry Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AggregatorKind } from './types';
+/** Basic aggregator for None which keeps no recorded value. */
+export class DropAggregator {
+    kind = AggregatorKind.DROP;
+    createAccumulation() {
+        return undefined;
+    }
+    merge(_previous, _delta) {
+        return undefined;
+    }
+    diff(_previous, _current) {
+        return undefined;
+    }
+    toMetricData(_descriptor, _aggregationTemporality, _accumulationByAttributes, _endTime) {
+        return undefined;
+    }
+}
+//# sourceMappingURL=Drop.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Drop.js","sourceRoot":"","sources":["../../../src/aggregator/Drop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAMH,OAAO,EAAE,cAAc,EAAkC,MAAM,SAAS,CAAC;AAEzE,+DAA+D;AAC/D,MAAM,OAAO,cAAc;IACzB,IAAI,GAAwB,cAAc,CAAC,IAAI,CAAC;IAEhD,kBAAkB;QAChB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,KAAK,CAAC,SAAoB,EAAE,MAAiB;QAC3C,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,CAAC,SAAoB,EAAE,QAAmB;QAC5C,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,YAAY,CACV,WAA6B,EAC7B,uBAA+C,EAC/C,yBAA0D,EAC1D,QAAgB;QAEhB,OAAO,SAAS,CAAC;IACnB,CAAC;CACF","sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { HrTime } from '@opentelemetry/api';\nimport { AggregationTemporality } from '../export/AggregationTemporality';\nimport { MetricData, MetricDescriptor } from '../export/MetricData';\nimport { Maybe } from '../utils';\nimport { AggregatorKind, Aggregator, AccumulationRecord } from './types';\n\n/** Basic aggregator for None which keeps no recorded value. */\nexport class DropAggregator implements Aggregator<undefined> {\n  kind: AggregatorKind.DROP = AggregatorKind.DROP;\n\n  createAccumulation() {\n    return undefined;\n  }\n\n  merge(_previous: undefined, _delta: undefined) {\n    return undefined;\n  }\n\n  diff(_previous: undefined, _current: undefined) {\n    return undefined;\n  }\n\n  toMetricData(\n    _descriptor: MetricDescriptor,\n    _aggregationTemporality: AggregationTemporality,\n    _accumulationByAttributes: AccumulationRecord<undefined>[],\n    _endTime: HrTime\n  ): Maybe<MetricData> {\n    return undefined;\n  }\n}\n"]}

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

@@ -0,0 +1,177 @@
+import { Accumulation, AccumulationRecord, Aggregator, AggregatorKind, ExponentialHistogram } from './types';
+import { ExponentialHistogramMetricData } from '../export/MetricData';
+import { HrTime } from '@opentelemetry/api';
+import { Maybe } from '../utils';
+import { AggregationTemporality } from '../export/AggregationTemporality';
+import { InstrumentDescriptor } from '../InstrumentDescriptor';
+import { Buckets } from './exponential-histogram/Buckets';
+import { Mapping } from './exponential-histogram/mapping/types';
+/**
+ * Internal value type for ExponentialHistogramAggregation.
+ * Differs from the exported type as undefined sum/min/max complicate arithmetic
+ * performed by this aggregation, but are required to be undefined in the exported types.
+ */
+interface InternalHistogram extends ExponentialHistogram {
+    hasMinMax: boolean;
+    min: number;
+    max: number;
+    sum: number;
+}
+export declare class ExponentialHistogramAccumulation implements Accumulation {
+    startTime: HrTime;
+    private _maxSize;
+    private _recordMinMax;
+    private _sum;
+    private _count;
+    private _zeroCount;
+    private _min;
+    private _max;
+    private _positive;
+    private _negative;
+    private _mapping;
+    constructor(startTime: HrTime, _maxSize?: number, _recordMinMax?: boolean, _sum?: number, _count?: number, _zeroCount?: number, _min?: number, _max?: number, _positive?: Buckets, _negative?: Buckets, _mapping?: Mapping);
+    /**
+     * record updates a histogram with a single count
+     * @param {Number} value
+     */
+    record(value: number): void;
+    /**
+     * Sets the start time for this accumulation
+     * @param {HrTime} startTime
+     */
+    setStartTime(startTime: HrTime): void;
+    /**
+     * Returns the datapoint representation of this accumulation
+     * @param {HrTime} startTime
+     */
+    toPointValue(): InternalHistogram;
+    /**
+     * @returns {Number} The sum of values recorded by this accumulation
+     */
+    get sum(): number;
+    /**
+     * @returns {Number} The minimum value recorded by this accumulation
+     */
+    get min(): number;
+    /**
+     * @returns {Number} The maximum value recorded by this accumulation
+     */
+    get max(): number;
+    /**
+     * @returns {Number} The count of values recorded by this accumulation
+     */
+    get count(): number;
+    /**
+     * @returns {Number} The number of 0 values recorded by this accumulation
+     */
+    get zeroCount(): number;
+    /**
+     * @returns {Number} The scale used by this accumulation
+     */
+    get scale(): number;
+    /**
+     * positive holds the positive values
+     * @returns {Buckets}
+     */
+    get positive(): Buckets;
+    /**
+     * negative holds the negative values by their absolute value
+     * @returns {Buckets}
+     */
+    get negative(): Buckets;
+    /**
+     * updateByIncr supports updating a histogram with a non-negative
+     * increment.
+     * @param value
+     * @param increment
+     */
+    updateByIncrement(value: number, increment: number): void;
+    /**
+     * merge combines data from previous value into self
+     * @param {ExponentialHistogramAccumulation} previous
+     */
+    merge(previous: ExponentialHistogramAccumulation): void;
+    /**
+     * diff subtracts other from self
+     * @param {ExponentialHistogramAccumulation} other
+     */
+    diff(other: ExponentialHistogramAccumulation): void;
+    /**
+     * clone returns a deep copy of self
+     * @returns {ExponentialHistogramAccumulation}
+     */
+    clone(): ExponentialHistogramAccumulation;
+    /**
+     * _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.
+     */
+    private _updateBuckets;
+    /**
+     * _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.
+     */
+    private _incrementIndexBy;
+    /**
+     * 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.
+     */
+    private _grow;
+    /**
+     * _changeScale computes how much downscaling is needed by shifting the
+     * high and low values until they are separated by no more than size.
+     */
+    private _changeScale;
+    /**
+     * _downscale subtracts `change` from the current mapping scale.
+     */
+    private _downscale;
+    /**
+     * _minScale is used by diff and merge to compute an ideal combined scale
+     */
+    private _minScale;
+    /**
+     * _highLowAtScale is used by diff and merge to compute an ideal combined scale.
+     */
+    private _highLowAtScale;
+    /**
+     * _mergeBuckets translates index values from another histogram and
+     * adds the values into the corresponding buckets of this histogram.
+     */
+    private _mergeBuckets;
+    /**
+     * _diffBuckets translates index values from another histogram and
+     * subtracts the values in the corresponding buckets of this histogram.
+     */
+    private _diffBuckets;
+}
+/**
+ * Aggregator for ExponentialHistogramAccumulations
+ */
+export declare class ExponentialHistogramAggregator implements Aggregator<ExponentialHistogramAccumulation> {
+    readonly _maxSize: number;
+    private readonly _recordMinMax;
+    kind: AggregatorKind.EXPONENTIAL_HISTOGRAM;
+    /**
+     * @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: number, _recordMinMax: boolean);
+    createAccumulation(startTime: HrTime): ExponentialHistogramAccumulation;
+    /**
+     * Return the result of the merge of two exponential histogram accumulations.
+     */
+    merge(previous: ExponentialHistogramAccumulation, delta: ExponentialHistogramAccumulation): ExponentialHistogramAccumulation;
+    /**
+     * Returns a new DELTA aggregation by comparing two cumulative measurements.
+     */
+    diff(previous: ExponentialHistogramAccumulation, current: ExponentialHistogramAccumulation): ExponentialHistogramAccumulation;
+    toMetricData(descriptor: InstrumentDescriptor, aggregationTemporality: AggregationTemporality, accumulationByAttributes: AccumulationRecord<ExponentialHistogramAccumulation>[], endTime: HrTime): Maybe<ExponentialHistogramMetricData>;
+}
+export {};
+//# sourceMappingURL=ExponentialHistogram.d.ts.map