Skip to content

Commit 926f052

Browse files
pikalovArtemNpikalovArtemN
committed
test(instrumentation-runtime-node): fix tests
1 parent 54858de commit 926f052

File tree

8 files changed

+202
-9
lines changed

8 files changed

+202
-9
lines changed

‎plugins/node/instrumentation-runtime-node/src/consts/attributes.ts‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1 +1,3 @@
11
export const NODE_JS_VERSION_ATTRIBUTE = "nodejsruntime.version"
2+
export const V8_HEAP_SIZE_STATE_ATTRIBUTE = 'heap.size.state';
3+
export const V8_HEAP_SIZE = 'heap.size';

‎plugins/node/instrumentation-runtime-node/src/metrics/eventLoopDelayCollector.ts‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -65,7 +65,6 @@ export const metricNames: Record<NodeJsEventLoopDelay, { description: string }>
6565
}
6666
,
6767
[NodeJsEventLoopDelay.p99]: {
68-
6968
description:
7069
'The 99th percentile of the recorded event loop delays.',
7170
}

‎plugins/node/instrumentation-runtime-node/src/metrics/heapSizeAndUsedCollector.ts‎

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -17,9 +17,8 @@ import { RuntimeNodeInstrumentationConfig } from '../types';
1717
import { Meter } from '@opentelemetry/api';
1818
import { BaseCollector } from './baseCollector';
1919
import {HeapSizes} from "../types/heapSizes";
20+
import {V8_HEAP_SIZE, V8_HEAP_SIZE_STATE_ATTRIBUTE} from "../consts/attributes";
2021

21-
export const V8_HEAP_SIZE = 'heap.size';
22-
const V8_HEAP_SIZE_STATE = 'heap.size.state';
2322

2423
export class HeapSizeAndUsedCollector extends BaseCollector<NodeJS.MemoryUsage> {
2524
constructor(
@@ -42,11 +41,11 @@ export class HeapSizeAndUsedCollector extends BaseCollector<NodeJS.MemoryUsage>
4241
const data = this._scrapeQueue.shift();
4342
if (data === undefined) return;
4443
observableResult.observe(data.heapTotal, {
45-
[`${this.namePrefix}.${V8_HEAP_SIZE_STATE}`]: HeapSizes.Total,
44+
[`${this.namePrefix}.${V8_HEAP_SIZE_STATE_ATTRIBUTE}`]: HeapSizes.Total,
4645
...this.versionAttribute
4746
});
4847
observableResult.observe(data.heapUsed, {
49-
[`${this.namePrefix}.${V8_HEAP_SIZE_STATE}`]: HeapSizes.Used,
48+
[`${this.namePrefix}.${V8_HEAP_SIZE_STATE_ATTRIBUTE}`]: HeapSizes.Used,
5049
...this.versionAttribute
5150
});
5251
});

‎plugins/node/instrumentation-runtime-node/src/metrics/heapSpacesSizeAndUsedCollector.ts‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -18,15 +18,18 @@ import {Meter} from '@opentelemetry/api';
1818
import {BaseCollector} from './baseCollector';
1919
import * as v8 from 'node:v8';
2020
import {HeapSpaceInfo} from 'v8';
21+
import {V8_HEAP_SIZE_STATE_ATTRIBUTE} from "../consts/attributes";
2122

2223

23-
enum V8HeapSpaceMetrics {
24+
export enum V8HeapSpaceMetrics {
2425
spaceSize = 'heap.space_size',
2526
used = 'heap.space_used_size',
2627
available = 'heap.space_available_size',
2728
physical = 'heap.physical_space_size',
2829
}
2930

31+
32+
3033
export const metricNames: Record<V8HeapSpaceMetrics, { description: string }> = {
3134
[V8HeapSpaceMetrics.spaceSize]: {
3235
description:
@@ -85,7 +88,7 @@ export class HeapSpacesSizeAndUsedCollector extends BaseCollector<
8588
unit: 'bytes',
8689
}
8790
);
88-
const heapSpaceNameAttributeName = `${this.namePrefix}.heap.space.name`
91+
const heapSpaceNameAttributeName = `${this.namePrefix}.${V8_HEAP_SIZE_STATE_ATTRIBUTE}`
8992

9093
meter.addBatchObservableCallback(
9194
observableResult => {

‎plugins/node/instrumentation-runtime-node/test/event_loop_delay.test.ts‎

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ import * as assert from 'assert';
2020
import { TestMetricReader } from './testMetricsReader';
2121
import { metricNames } from '../src/metrics/eventLoopDelayCollector';
2222
import {ConventionalNamePrefix} from "../src/types/ConventionalNamePrefix";
23+
import {NODE_JS_VERSION_ATTRIBUTE} from "../src/consts/attributes";
2324

2425
const MEASUREMENT_INTERVAL = 10;
2526

@@ -72,5 +73,36 @@ describe(`${ConventionalNamePrefix.NodeJsRuntime}.eventloop`, function () {
7273
'descriptor.name'
7374
);
7475
});
76+
77+
it(`should write ${ConventionalNamePrefix.NodeJsRuntime}.${metricName} version attribute`, async function () {
78+
// arrange
79+
const instrumentation = new RuntimeNodeInstrumentation({
80+
monitoringPrecision: MEASUREMENT_INTERVAL,
81+
});
82+
instrumentation.setMeterProvider(meterProvider);
83+
84+
// act
85+
await new Promise(resolve =>
86+
setTimeout(resolve, MEASUREMENT_INTERVAL * 5)
87+
);
88+
const { resourceMetrics, errors } = await metricReader.collect();
89+
90+
// assert
91+
assert.deepEqual(
92+
errors,
93+
[],
94+
'expected no errors from the callback during collection'
95+
);
96+
const scopeMetrics = resourceMetrics.scopeMetrics;
97+
const metric = scopeMetrics[0].metrics.find(
98+
x => x.descriptor.name === `${ConventionalNamePrefix.NodeJsRuntime}.${ metricName}`
99+
);
100+
101+
assert.strictEqual(
102+
metric!.dataPoints[0].attributes[NODE_JS_VERSION_ATTRIBUTE],
103+
process.version,
104+
`version attribute ${NODE_JS_VERSION_ATTRIBUTE} not found`
105+
);
106+
});
75107
}
76108
});

‎plugins/node/instrumentation-runtime-node/test/event_loop_utilization.test.ts‎

Lines changed: 33 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ import * as assert from 'assert';
2020
import { TestMetricReader } from './testMetricsReader';
2121
import {ConventionalNamePrefix} from "../src/types/ConventionalNamePrefix";
2222
import {NODEJS_EVENT_LOOP_UTILIZATION} from "../src/metrics/eventLoopUtilizationCollector";
23+
import {NODE_JS_VERSION_ATTRIBUTE} from "../src/consts/attributes";
2324

2425
const MEASUREMENT_INTERVAL = 10;
2526

@@ -51,7 +52,7 @@ describe(`${ConventionalNamePrefix.NodeJsRuntime}.${NODEJS_EVENT_LOOP_UTILIZATIO
5152
assert.strictEqual(scopeMetrics.length, 0);
5253
});
5354

54-
it('should write event loop utilization metrics after monitoringPrecision', async function () {
55+
it(`should write ${ConventionalNamePrefix.NodeJsRuntime}.${NODEJS_EVENT_LOOP_UTILIZATION} after monitoringPrecision`, async function () {
5556
// arrange
5657
const instrumentation = new RuntimeNodeInstrumentation({
5758
monitoringPrecision: MEASUREMENT_INTERVAL,
@@ -108,4 +109,35 @@ describe(`${ConventionalNamePrefix.NodeJsRuntime}.${NODEJS_EVENT_LOOP_UTILIZATIO
108109
assert.strictEqual(val > 0, true, `val (${val}) > 0`);
109110
assert.strictEqual(val <= 1, true, `val (${val}) <= 1`);
110111
});
112+
113+
it(`should write ${ConventionalNamePrefix.NodeJsRuntime}.${NODEJS_EVENT_LOOP_UTILIZATION} version attribute`, async function () {
114+
// arrange
115+
const instrumentation = new RuntimeNodeInstrumentation({
116+
monitoringPrecision: MEASUREMENT_INTERVAL,
117+
});
118+
instrumentation.setMeterProvider(meterProvider);
119+
120+
// act
121+
await new Promise(resolve =>
122+
setTimeout(resolve, MEASUREMENT_INTERVAL * 5)
123+
);
124+
const { resourceMetrics, errors } = await metricReader.collect();
125+
126+
// assert
127+
assert.deepEqual(
128+
errors,
129+
[],
130+
'expected no errors from the callback during collection'
131+
);
132+
const scopeMetrics = resourceMetrics.scopeMetrics;
133+
const metric = scopeMetrics[0].metrics.find(
134+
x => x.descriptor.name === `${ConventionalNamePrefix.NodeJsRuntime}.${NODEJS_EVENT_LOOP_UTILIZATION}`
135+
);
136+
137+
assert.strictEqual(
138+
metric!.dataPoints[0].attributes[NODE_JS_VERSION_ATTRIBUTE],
139+
process.version,
140+
`version attribute ${NODE_JS_VERSION_ATTRIBUTE} not found`
141+
);
142+
});
111143
});

‎plugins/node/instrumentation-runtime-node/test/heap_size_and_used.test.ts‎

Lines changed: 95 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -19,7 +19,8 @@ import {RuntimeNodeInstrumentation} from '../src';
1919
import * as assert from 'assert';
2020
import {TestMetricReader} from './testMetricsReader';
2121
import {ConventionalNamePrefix} from "../src/types/ConventionalNamePrefix";
22-
import {V8_HEAP_SIZE} from "../src/metrics/heapSizeAndUsedCollector";
22+
import {NODE_JS_VERSION_ATTRIBUTE, V8_HEAP_SIZE, V8_HEAP_SIZE_STATE_ATTRIBUTE} from "../src/consts/attributes";
23+
import {HeapSizes} from "../src/types/heapSizes";
2324

2425
const MEASUREMENT_INTERVAL = 10;
2526

@@ -71,4 +72,97 @@ describe(`${ConventionalNamePrefix.V8EnjineRuntime}.${V8_HEAP_SIZE}`, function (
7172
'descriptor.name'
7273
);
7374
});
75+
76+
it(`should write ${ConventionalNamePrefix.V8EnjineRuntime}.${V8_HEAP_SIZE} version attribute`, async function () {
77+
// arrange
78+
const instrumentation = new RuntimeNodeInstrumentation({
79+
monitoringPrecision: MEASUREMENT_INTERVAL,
80+
});
81+
instrumentation.setMeterProvider(meterProvider);
82+
83+
// act
84+
await new Promise(resolve =>
85+
setTimeout(resolve, MEASUREMENT_INTERVAL * 5)
86+
);
87+
const { resourceMetrics, errors } = await metricReader.collect();
88+
89+
// assert
90+
assert.deepEqual(
91+
errors,
92+
[],
93+
'expected no errors from the callback during collection'
94+
);
95+
const scopeMetrics = resourceMetrics.scopeMetrics;
96+
const metric = scopeMetrics[0].metrics.find(
97+
x => x.descriptor.name === `${ConventionalNamePrefix.V8EnjineRuntime}.${V8_HEAP_SIZE}`
98+
);
99+
100+
assert.strictEqual(
101+
metric!.dataPoints[0].attributes[NODE_JS_VERSION_ATTRIBUTE],
102+
process.version,
103+
`version attribute ${NODE_JS_VERSION_ATTRIBUTE} not found`
104+
);
105+
});
106+
107+
it(`should write ${ConventionalNamePrefix.V8EnjineRuntime}.${V8_HEAP_SIZE} ${HeapSizes.Total} attribute`, async function () {
108+
// arrange
109+
const instrumentation = new RuntimeNodeInstrumentation({
110+
monitoringPrecision: MEASUREMENT_INTERVAL,
111+
});
112+
instrumentation.setMeterProvider(meterProvider);
113+
114+
// act
115+
await new Promise(resolve =>
116+
setTimeout(resolve, MEASUREMENT_INTERVAL * 5)
117+
);
118+
const { resourceMetrics, errors } = await metricReader.collect();
119+
120+
// assert
121+
assert.deepEqual(
122+
errors,
123+
[],
124+
'expected no errors from the callback during collection'
125+
);
126+
const scopeMetrics = resourceMetrics.scopeMetrics;
127+
const metric = scopeMetrics[0].metrics.find(
128+
x => x.descriptor.name === `${ConventionalNamePrefix.V8EnjineRuntime}.${V8_HEAP_SIZE}`
129+
);
130+
131+
assert.strictEqual(
132+
metric!.dataPoints[0].attributes[`${ConventionalNamePrefix.V8EnjineRuntime}.${V8_HEAP_SIZE_STATE_ATTRIBUTE}`],
133+
HeapSizes.Total,
134+
`${ConventionalNamePrefix.V8EnjineRuntime}.${V8_HEAP_SIZE_STATE_ATTRIBUTE} attribute ${NODE_JS_VERSION_ATTRIBUTE} not found`
135+
);
136+
});
137+
138+
it(`should write ${ConventionalNamePrefix.V8EnjineRuntime}.${V8_HEAP_SIZE} ${HeapSizes.Used} attribute`, async function () {
139+
// arrange
140+
const instrumentation = new RuntimeNodeInstrumentation({
141+
monitoringPrecision: MEASUREMENT_INTERVAL,
142+
});
143+
instrumentation.setMeterProvider(meterProvider);
144+
145+
// act
146+
await new Promise(resolve =>
147+
setTimeout(resolve, MEASUREMENT_INTERVAL * 5)
148+
);
149+
const { resourceMetrics, errors } = await metricReader.collect();
150+
151+
// assert
152+
assert.deepEqual(
153+
errors,
154+
[],
155+
'expected no errors from the callback during collection'
156+
);
157+
const scopeMetrics = resourceMetrics.scopeMetrics;
158+
const metric = scopeMetrics[0].metrics.find(
159+
x => x.descriptor.name === `${ConventionalNamePrefix.V8EnjineRuntime}.${V8_HEAP_SIZE}`
160+
);
161+
162+
assert.strictEqual(
163+
metric!.dataPoints[1].attributes[`${ConventionalNamePrefix.V8EnjineRuntime}.${V8_HEAP_SIZE_STATE_ATTRIBUTE}`],
164+
HeapSizes.Used,
165+
`${ConventionalNamePrefix.V8EnjineRuntime}.${V8_HEAP_SIZE_STATE_ATTRIBUTE} attribute not found`
166+
);
167+
});
74168
});

‎plugins/node/instrumentation-runtime-node/test/heap_space_and_used.test.ts‎

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@ import * as assert from 'assert';
2020
import { TestMetricReader } from './testMetricsReader';
2121
import { metricNames } from '../src/metrics/heapSpacesSizeAndUsedCollector';
2222
import {ConventionalNamePrefix} from "../src/types/ConventionalNamePrefix";
23+
import {V8_HEAP_SIZE_STATE_ATTRIBUTE} from "../src/consts/attributes";
2324

2425
const MEASUREMENT_INTERVAL = 10;
2526

@@ -72,5 +73,36 @@ describe('nodejs.heap_space', function () {
7273
'descriptor.name'
7374
);
7475
});
76+
77+
for (const space of ["new_space", "old_space", "code_space", "large_object_space"]) {
78+
it(`should write ${ConventionalNamePrefix.V8EnjineRuntime}.${metricName} ${space} attribute`, async function () {
79+
// arrange
80+
const instrumentation = new RuntimeNodeInstrumentation({
81+
monitoringPrecision: MEASUREMENT_INTERVAL,
82+
});
83+
instrumentation.setMeterProvider(meterProvider);
84+
const map = [...Array(10).keys()].map(x => x + 10)
85+
map.indexOf(1)
86+
// act
87+
await new Promise(resolve =>
88+
setTimeout(resolve, MEASUREMENT_INTERVAL * 5)
89+
);
90+
const { resourceMetrics, errors } = await metricReader.collect();
91+
92+
// assert
93+
assert.deepEqual(
94+
errors,
95+
[],
96+
'expected no errors from the callback during collection'
97+
);
98+
const scopeMetrics = resourceMetrics.scopeMetrics;
99+
const metric = scopeMetrics[0].metrics.find(
100+
x => x.descriptor.name === `${ConventionalNamePrefix.V8EnjineRuntime}.${metricName}`
101+
);
102+
const spaceAttribute = metric!.dataPoints.find(x => x.attributes[`${ConventionalNamePrefix.V8EnjineRuntime}.${V8_HEAP_SIZE_STATE_ATTRIBUTE}`] === space)
103+
104+
assert.notEqual(spaceAttribute, undefined, `${ConventionalNamePrefix.V8EnjineRuntime}.${metricName} space: ${space} not found`);
105+
});
106+
}
75107
}
76108
});

0 commit comments

Comments
 (0)