chore(instrumentation-runtime-node): addnodejs.eventloop.time, fix tests

Author: pikalovArtemN

package-lock.json

@@ -20,7 +20,7 @@
   "author": "OpenTelemetry Authors",
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=14.10.0"
+    "node": ">=17.4.0"
   },
   "keywords": [
     "perf_hooks",
@@ -45,7 +45,7 @@
     "@opentelemetry/api": "^1.3.0",
     "@opentelemetry/sdk-metrics": "^1.20.0",
     "@types/mocha": "^10.0.6",
-    "@types/node": "^20.11.2",
+    "@types/node": "^22.1.0",
     "mocha": "7.2.0",
     "nyc": "^15.1.0",
     "rimraf": "5.0.5",

plugins/node/instrumentation-runtime-node/package.json

@@ -23,6 +23,7 @@ import { EventLoopDelayCollector } from './metrics/eventLoopDelayCollector';
 import { GCCollector } from './metrics/gcCollector';
 import { HeapSpacesSizeAndUsedCollector } from './metrics/heapSpacesSizeAndUsedCollector';
 import { ConventionalNamePrefix } from './types/ConventionalNamePrefix';
+import {EventLoopTimeCollector} from "./metrics/eventLoopTimeCollector";
 
 const DEFAULT_CONFIG: RuntimeNodeInstrumentationConfig = {
   monitoringPrecision: 10,
@@ -42,10 +43,11 @@ export class RuntimeNodeInstrumentation extends InstrumentationBase {
         this._config,
         ConventionalNamePrefix.NodeJs
       ),
-      new EventLoopDelayCollector(
+      new EventLoopTimeCollector(
         this._config,
         ConventionalNamePrefix.NodeJs
       ),
+      new EventLoopDelayCollector(this._config, ConventionalNamePrefix.NodeJs),
       new GCCollector(this._config, ConventionalNamePrefix.V8js),
       new HeapSpacesSizeAndUsedCollector(
         this._config,

plugins/node/instrumentation-runtime-node/src/instrumentation.ts

@@ -17,7 +17,6 @@ import { MetricCollector } from '../types/metricCollector';
 import { Meter } from '@opentelemetry/api';
 import { RuntimeNodeInstrumentationConfig } from '../types';
 
-
 export abstract class BaseCollector implements MetricCollector {
   protected _config: RuntimeNodeInstrumentationConfig = {};
 
@@ -41,7 +40,6 @@ export abstract class BaseCollector implements MetricCollector {
     this.internalEnable();
   }
 
-
   public abstract updateMetricInstruments(meter: Meter): void;
 
   protected abstract internalEnable(): void;

plugins/node/instrumentation-runtime-node/src/metrics/baseCollector.ts

@@ -13,11 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {RuntimeNodeInstrumentationConfig} from '../types';
-import {Meter} from '@opentelemetry/api';
+import { RuntimeNodeInstrumentationConfig } from '../types';
+import { Meter } from '@opentelemetry/api';
 import * as perf_hooks from 'node:perf_hooks';
-import {IntervalHistogram} from 'node:perf_hooks';
-import {BaseCollector} from './baseCollector';
+import { IntervalHistogram } from 'node:perf_hooks';
+import { BaseCollector } from './baseCollector';
 
 enum NodeJsEventLoopDelay {
   min = 'eventloop.delay.min',
@@ -26,7 +26,7 @@ enum NodeJsEventLoopDelay {
   stddev = 'eventloop.delay.stddev',
   p50 = 'eventloop.delay.p50',
   p90 = 'eventloop.delay.p90',
-  p99 = 'eventloop.delay.p99'
+  p99 = 'eventloop.delay.p99',
 }
 
 export const metricNames: Record<
@@ -53,7 +53,7 @@ export const metricNames: Record<
   },
   [NodeJsEventLoopDelay.p99]: {
     description: 'Event loop 99 percentile delay.',
-  }
+  },
 };
 
 export interface EventLoopLagInformation {
@@ -132,10 +132,11 @@ export class EventLoopDelayCollector extends BaseCollector {
 
     meter.addBatchObservableCallback(
       async observableResult => {
-        if(!this._config.enabled) return
+        if (!this._config.enabled) return;
 
         const data = this.scrape();
         if (data === undefined) return;
+        if (this._histogram.count < 5) return; // Don't return histogram data if we have less than 5 samples
 
         observableResult.observe(delayMin, data.min);
         observableResult.observe(delayMax, data.max);
@@ -147,15 +148,7 @@ export class EventLoopDelayCollector extends BaseCollector {
 
         this._histogram.reset();
       },
-      [
-        delayMin,
-        delayMax,
-        delayMean,
-        delayStddev,
-        delayp50,
-        delayp90,
-        delayp99,
-      ]
+      [delayMin, delayMax, delayMean, delayStddev, delayp50, delayp90, delayp99]
     );
   }
 
@@ -179,7 +172,6 @@ export class EventLoopDelayCollector extends BaseCollector {
     };
   }
 
-
   private checkNan(value: number) {
     return isNaN(value) ? 0 : value;
   }

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

@@ -0,0 +1,68 @@
+/*
+ * 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 { EventLoopUtilization, performance } from 'node:perf_hooks';
+import { RuntimeNodeInstrumentationConfig } from '../types';
+import { Meter } from '@opentelemetry/api';
+import { BaseCollector } from './baseCollector';
+
+const { eventLoopUtilization: eventLoopUtilizationCollector } = performance;
+
+export const NODEJS_EVENT_LOOP_TIME = 'eventloop.time';
+
+export class EventLoopTimeCollector extends BaseCollector {
+  constructor(
+    config: RuntimeNodeInstrumentationConfig = {},
+    namePrefix: string
+  ) {
+    super(config, namePrefix);
+  }
+
+  public updateMetricInstruments(meter: Meter): void {
+    const timeCounter = meter.createObservableCounter(
+      `${this.namePrefix}.${NODEJS_EVENT_LOOP_TIME}`,
+      {
+        description:
+          'Cumulative duration of time the event loop has been in each state.',
+        unit: 's',
+      }
+    );
+
+    meter.addBatchObservableCallback(
+      async observableResult => {
+        if (!this._config.enabled) return;
+
+        const data = this.scrape();
+        if (data === undefined) return;
+
+        observableResult.observe(timeCounter, data.active / 1000, {
+          [`${this.namePrefix}.eventloop.state`]: 'active',
+        });
+        observableResult.observe(timeCounter, data.idle / 1000, {
+          [`${this.namePrefix}.eventloop.state`]: 'idle',
+        });
+      },
+      [timeCounter]
+    );
+  }
+
+  protected internalDisable(): void {}
+
+  protected internalEnable(): void {}
+
+  private scrape(): EventLoopUtilization {
+    return eventLoopUtilizationCollector();
+  }
+}

plugins/node/instrumentation-runtime-node/src/metrics/eventLoopTimeCollector.ts

@@ -40,16 +40,14 @@ export class EventLoopUtilizationCollector extends BaseCollector {
         }
       )
       .addCallback(async observableResult => {
-        if(!this._config.enabled) return
+        if (!this._config.enabled) return;
 
         const elu = eventLoopUtilizationCollector(this.scrape());
         observableResult.observe(elu.utilization);
       });
   }
 
-  protected internalDisable(): void {
-
-  }
+  protected internalDisable(): void {}
 
   protected internalEnable(): void {}
 

plugins/node/instrumentation-runtime-node/src/metrics/eventLoopUtilizationCollector.ts

@@ -39,7 +39,7 @@ export class GCCollector extends BaseCollector {
   ) {
     super(config, namePrefix);
     this._observer = new perf_hooks.PerformanceObserver(list => {
-      if(!this._config.enabled) return
+      if (!this._config.enabled) return;
 
       const entry = list.getEntries()[0];
       // Node < 16 uses entry.kind
@@ -50,9 +50,7 @@ export class GCCollector extends BaseCollector {
       const kind = entry.detail ? kinds[entry.detail.kind] : kinds[entry.kind];
       this._gcDurationByKindHistogram?.record(
         entry.duration / 1000,
-        Object.assign(
-          { [`${this.namePrefix}.gc.type`]: kind }
-        )
+        Object.assign({ [`${this.namePrefix}.gc.type`]: kind })
       );
     });
   }

plugins/node/instrumentation-runtime-node/src/metrics/gcCollector.ts

@@ -84,7 +84,7 @@ export class HeapSpacesSizeAndUsedCollector extends BaseCollector {
 
     meter.addBatchObservableCallback(
       observableResult => {
-        if(!this._config.enabled) return
+        if (!this._config.enabled) return;
 
         const data = this.scrape();
         if (data === undefined) return;

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

@@ -21,7 +21,6 @@ import { TestMetricReader } from './testMetricsReader';
 import { metricNames } from '../src/metrics/eventLoopDelayCollector';
 import { ConventionalNamePrefix } from '../src/types/ConventionalNamePrefix';
 
-const MEASUREMENT_INTERVAL = 10;
 
 describe(`${ConventionalNamePrefix.NodeJs}.eventloop`, function () {
   let metricReader: TestMetricReader;
@@ -37,13 +36,13 @@ describe(`${ConventionalNamePrefix.NodeJs}.eventloop`, function () {
     it(`should write ${ConventionalNamePrefix.NodeJs}.${metricName} after monitoringPrecision`, async function () {
       // arrange
       const instrumentation = new RuntimeNodeInstrumentation({
-        monitoringPrecision: MEASUREMENT_INTERVAL,
+        monitoringPrecision: 10,
       });
       instrumentation.setMeterProvider(meterProvider);
 
       // act
       await new Promise(resolve =>
-        setTimeout(resolve, MEASUREMENT_INTERVAL * 5)
+        setTimeout(resolve, 100)
       );
       const { resourceMetrics, errors } = await metricReader.collect();
 
@@ -56,8 +55,7 @@ describe(`${ConventionalNamePrefix.NodeJs}.eventloop`, function () {
       const scopeMetrics = resourceMetrics.scopeMetrics;
       const metric = scopeMetrics[0].metrics.find(
         x =>
-          x.descriptor.name ===
-          `${ConventionalNamePrefix.NodeJs}.${metricName}`
+          x.descriptor.name === `${ConventionalNamePrefix.NodeJs}.${metricName}`
       );
 
       assert.notEqual(