673 lines
21 KiB
TypeScript
673 lines
21 KiB
TypeScript
/*
|
|
* Copyright The OpenTelemetry Authors
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* https://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
import * as assert from 'assert';
|
|
|
|
import { SumAggregator } from '../../src/aggregator';
|
|
import { AggregationTemporality } from '../../src/export/AggregationTemporality';
|
|
import { DataPointType } from '../../src/export/MetricData';
|
|
import { MetricCollectorHandle } from '../../src/state/MetricCollector';
|
|
import { AsyncMetricStorage } from '../../src/state/AsyncMetricStorage';
|
|
import { NoopAttributesProcessor } from '../../src/view/AttributesProcessor';
|
|
import { ObservableRegistry } from '../../src/state/ObservableRegistry';
|
|
import {
|
|
assertMetricData,
|
|
assertDataPoint,
|
|
defaultInstrumentDescriptor,
|
|
ObservableCallbackDelegate,
|
|
} from '../util';
|
|
import { ObservableInstrument } from '../../src/Instruments';
|
|
import { HrTime } from '@opentelemetry/api';
|
|
|
|
const deltaCollector: MetricCollectorHandle = {
|
|
selectAggregationTemporality: () => AggregationTemporality.DELTA,
|
|
};
|
|
|
|
const cumulativeCollector: MetricCollectorHandle = {
|
|
selectAggregationTemporality: () => AggregationTemporality.CUMULATIVE,
|
|
};
|
|
|
|
describe('AsyncMetricStorage', () => {
|
|
describe('collect', () => {
|
|
describe('Delta Collector', () => {
|
|
const collectors = [deltaCollector];
|
|
it('should collect and reset memos', async () => {
|
|
const delegate = new ObservableCallbackDelegate();
|
|
const observableRegistry = new ObservableRegistry();
|
|
const metricStorage = new AsyncMetricStorage(
|
|
defaultInstrumentDescriptor,
|
|
new SumAggregator(true),
|
|
new NoopAttributesProcessor()
|
|
);
|
|
const observable = new ObservableInstrument(
|
|
defaultInstrumentDescriptor,
|
|
[metricStorage],
|
|
observableRegistry
|
|
);
|
|
|
|
observableRegistry.addCallback(delegate.getCallback(), observable);
|
|
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(1, { key: '1' });
|
|
observableResult.observe(2, { key: '2' });
|
|
observableResult.observe(3, { key: '3' });
|
|
});
|
|
{
|
|
const collectionTime: HrTime = [0, 0];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
deltaCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 3);
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
1,
|
|
collectionTime,
|
|
collectionTime
|
|
);
|
|
assertDataPoint(
|
|
metric.dataPoints[1],
|
|
{ key: '2' },
|
|
2,
|
|
collectionTime,
|
|
collectionTime
|
|
);
|
|
assertDataPoint(
|
|
metric.dataPoints[2],
|
|
{ key: '3' },
|
|
3,
|
|
collectionTime,
|
|
collectionTime
|
|
);
|
|
}
|
|
|
|
delegate.setDelegate(observableResult => {});
|
|
// The attributes should not be memorized if no measurement was reported.
|
|
{
|
|
const collectionTime: HrTime = [1, 1];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
deltaCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 0);
|
|
}
|
|
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(4, { key: '1' });
|
|
observableResult.observe(5, { key: '2' });
|
|
observableResult.observe(6, { key: '3' });
|
|
});
|
|
{
|
|
const collectionTime: HrTime = [2, 2];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
deltaCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 3);
|
|
// All values were diffed. StartTime is being reset for gaps.
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
3,
|
|
collectionTime,
|
|
collectionTime
|
|
);
|
|
assertDataPoint(
|
|
metric.dataPoints[1],
|
|
{ key: '2' },
|
|
3,
|
|
collectionTime,
|
|
collectionTime
|
|
);
|
|
assertDataPoint(
|
|
metric.dataPoints[2],
|
|
{ key: '3' },
|
|
3,
|
|
collectionTime,
|
|
collectionTime
|
|
);
|
|
}
|
|
});
|
|
|
|
it('should detect resets for monotonic sum metrics', async () => {
|
|
const delegate = new ObservableCallbackDelegate();
|
|
const observableRegistry = new ObservableRegistry();
|
|
const metricStorage = new AsyncMetricStorage(
|
|
defaultInstrumentDescriptor,
|
|
new SumAggregator(true),
|
|
new NoopAttributesProcessor()
|
|
);
|
|
const observable = new ObservableInstrument(
|
|
defaultInstrumentDescriptor,
|
|
[metricStorage],
|
|
observableRegistry
|
|
);
|
|
|
|
observableRegistry.addCallback(delegate.getCallback(), observable);
|
|
|
|
// Observe a metric
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(100, { key: '1' });
|
|
});
|
|
let lastCollectionTime: HrTime;
|
|
{
|
|
const collectionTime: HrTime = [0, 0];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
deltaCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 1);
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
100,
|
|
collectionTime,
|
|
collectionTime
|
|
);
|
|
lastCollectionTime = collectionTime;
|
|
}
|
|
|
|
// Observe a drop on the metric
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(1, { key: '1' });
|
|
});
|
|
// The result data should not be diff-ed to be a negative value
|
|
{
|
|
const collectionTime: HrTime = [1, 1];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
deltaCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 1);
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
1,
|
|
lastCollectionTime,
|
|
collectionTime
|
|
);
|
|
lastCollectionTime = collectionTime;
|
|
}
|
|
|
|
// Observe a new data point
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(50, { key: '1' });
|
|
});
|
|
// The result data should now be a delta to the previous collection
|
|
{
|
|
const collectionTime: HrTime = [2, 2];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
deltaCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 1);
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
49,
|
|
lastCollectionTime,
|
|
collectionTime
|
|
);
|
|
}
|
|
});
|
|
|
|
it('should not detect resets and gaps for non-monotonic sum metrics', async () => {
|
|
const delegate = new ObservableCallbackDelegate();
|
|
const observableRegistry = new ObservableRegistry();
|
|
const metricStorage = new AsyncMetricStorage(
|
|
defaultInstrumentDescriptor,
|
|
new SumAggregator(false),
|
|
new NoopAttributesProcessor()
|
|
);
|
|
const observable = new ObservableInstrument(
|
|
defaultInstrumentDescriptor,
|
|
[metricStorage],
|
|
observableRegistry
|
|
);
|
|
|
|
observableRegistry.addCallback(delegate.getCallback(), observable);
|
|
|
|
// Observe a metric
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(100, { key: '1' });
|
|
});
|
|
let lastCollectionTime: HrTime;
|
|
{
|
|
const collectionTime: HrTime = [0, 0];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
deltaCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 1);
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
100,
|
|
collectionTime,
|
|
collectionTime
|
|
);
|
|
lastCollectionTime = collectionTime;
|
|
}
|
|
|
|
// Observe a drop on the metric
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(1, { key: '1' });
|
|
});
|
|
// The result data should be a delta to the previous collection
|
|
{
|
|
const collectionTime: HrTime = [0, 0];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
deltaCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 1);
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
-99,
|
|
lastCollectionTime,
|
|
collectionTime
|
|
);
|
|
lastCollectionTime = collectionTime;
|
|
}
|
|
|
|
// Observe a new data point
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(50, { key: '1' });
|
|
});
|
|
// The result data should be a delta to the previous collection
|
|
{
|
|
const collectionTime: HrTime = [2, 2];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
deltaCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 1);
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
49,
|
|
lastCollectionTime,
|
|
collectionTime
|
|
);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('Cumulative Collector', () => {
|
|
const collectors = [cumulativeCollector];
|
|
it('should collect cumulative metrics', async () => {
|
|
const delegate = new ObservableCallbackDelegate();
|
|
const observableRegistry = new ObservableRegistry();
|
|
const metricStorage = new AsyncMetricStorage(
|
|
defaultInstrumentDescriptor,
|
|
new SumAggregator(true),
|
|
new NoopAttributesProcessor()
|
|
);
|
|
const observable = new ObservableInstrument(
|
|
defaultInstrumentDescriptor,
|
|
[metricStorage],
|
|
observableRegistry
|
|
);
|
|
|
|
observableRegistry.addCallback(delegate.getCallback(), observable);
|
|
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(1, { key: '1' });
|
|
observableResult.observe(2, { key: '2' });
|
|
observableResult.observe(3, { key: '3' });
|
|
});
|
|
let startTime: HrTime;
|
|
{
|
|
const collectionTime: HrTime = [0, 0];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
cumulativeCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
startTime = collectionTime;
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 3);
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
1,
|
|
startTime,
|
|
collectionTime
|
|
);
|
|
assertDataPoint(
|
|
metric.dataPoints[1],
|
|
{ key: '2' },
|
|
2,
|
|
startTime,
|
|
collectionTime
|
|
);
|
|
assertDataPoint(
|
|
metric.dataPoints[2],
|
|
{ key: '3' },
|
|
3,
|
|
startTime,
|
|
collectionTime
|
|
);
|
|
}
|
|
|
|
delegate.setDelegate(observableResult => {});
|
|
// The attributes should be memorized even if no measurement was reported.
|
|
{
|
|
const collectionTime: HrTime = [1, 1];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
cumulativeCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 3);
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
1,
|
|
startTime,
|
|
collectionTime
|
|
);
|
|
assertDataPoint(
|
|
metric.dataPoints[1],
|
|
{ key: '2' },
|
|
2,
|
|
startTime,
|
|
collectionTime
|
|
);
|
|
assertDataPoint(
|
|
metric.dataPoints[2],
|
|
{ key: '3' },
|
|
3,
|
|
startTime,
|
|
collectionTime
|
|
);
|
|
}
|
|
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(4, { key: '1' });
|
|
observableResult.observe(5, { key: '2' });
|
|
observableResult.observe(6, { key: '3' });
|
|
});
|
|
{
|
|
const collectionTime: HrTime = [2, 2];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
cumulativeCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 3);
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
4,
|
|
startTime,
|
|
collectionTime
|
|
);
|
|
assertDataPoint(
|
|
metric.dataPoints[1],
|
|
{ key: '2' },
|
|
5,
|
|
startTime,
|
|
collectionTime
|
|
);
|
|
assertDataPoint(
|
|
metric.dataPoints[2],
|
|
{ key: '3' },
|
|
6,
|
|
startTime,
|
|
collectionTime
|
|
);
|
|
}
|
|
});
|
|
|
|
it('should collect monotonic metrics with resets and gaps', async () => {
|
|
const delegate = new ObservableCallbackDelegate();
|
|
const observableRegistry = new ObservableRegistry();
|
|
const metricStorage = new AsyncMetricStorage(
|
|
defaultInstrumentDescriptor,
|
|
new SumAggregator(true),
|
|
new NoopAttributesProcessor()
|
|
);
|
|
const observable = new ObservableInstrument(
|
|
defaultInstrumentDescriptor,
|
|
[metricStorage],
|
|
observableRegistry
|
|
);
|
|
|
|
observableRegistry.addCallback(delegate.getCallback(), observable);
|
|
|
|
// Observe a metric
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(100, { key: '1' });
|
|
});
|
|
let startTime: HrTime;
|
|
{
|
|
const collectionTime: HrTime = [0, 0];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
cumulativeCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
startTime = collectionTime;
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 1);
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
100,
|
|
startTime,
|
|
collectionTime
|
|
);
|
|
}
|
|
|
|
// Observe a drop on the metric
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(1, { key: '1' });
|
|
});
|
|
// The result data should not be diff-ed to be a negative value
|
|
{
|
|
const collectionTime: HrTime = [1, 1];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
cumulativeCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 1);
|
|
// The startTime should be reset.
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
1,
|
|
collectionTime,
|
|
collectionTime
|
|
);
|
|
startTime = collectionTime;
|
|
}
|
|
|
|
// Observe a new data point
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(50, { key: '1' });
|
|
});
|
|
// The result data should now be a delta to the previous collection
|
|
{
|
|
const collectionTime: HrTime = [2, 2];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
cumulativeCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 1);
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
50,
|
|
startTime,
|
|
collectionTime
|
|
);
|
|
}
|
|
});
|
|
|
|
it('should collect non-monotonic metrics with resets and gaps', async () => {
|
|
const delegate = new ObservableCallbackDelegate();
|
|
const observableRegistry = new ObservableRegistry();
|
|
const metricStorage = new AsyncMetricStorage(
|
|
defaultInstrumentDescriptor,
|
|
new SumAggregator(false),
|
|
new NoopAttributesProcessor()
|
|
);
|
|
const observable = new ObservableInstrument(
|
|
defaultInstrumentDescriptor,
|
|
[metricStorage],
|
|
observableRegistry
|
|
);
|
|
|
|
observableRegistry.addCallback(delegate.getCallback(), observable);
|
|
|
|
// Observe a metric
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(100, { key: '1' });
|
|
});
|
|
let startTime: HrTime;
|
|
{
|
|
const collectionTime: HrTime = [0, 0];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
cumulativeCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
startTime = collectionTime;
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 1);
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
100,
|
|
startTime,
|
|
collectionTime
|
|
);
|
|
}
|
|
|
|
// Observe a drop on the metric
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(1, { key: '1' });
|
|
});
|
|
// The result data should be a delta to the previous collection
|
|
{
|
|
const collectionTime: HrTime = [1, 1];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
cumulativeCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 1);
|
|
// No reset on the value or the startTime
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
1,
|
|
startTime,
|
|
collectionTime
|
|
);
|
|
}
|
|
|
|
// Observe a new data point
|
|
delegate.setDelegate(observableResult => {
|
|
observableResult.observe(50, { key: '1' });
|
|
});
|
|
// The result data should be a delta to the previous collection
|
|
{
|
|
const collectionTime: HrTime = [2, 2];
|
|
await observableRegistry.observe(collectionTime);
|
|
const metric = metricStorage.collect(
|
|
cumulativeCollector,
|
|
collectors,
|
|
collectionTime
|
|
);
|
|
|
|
assertMetricData(metric, DataPointType.SUM);
|
|
assert.strictEqual(metric.dataPoints.length, 1);
|
|
assertDataPoint(
|
|
metric.dataPoints[0],
|
|
{ key: '1' },
|
|
50,
|
|
startTime,
|
|
collectionTime
|
|
);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
});
|