diff --git a/plugins/node/instrumentation-runtime-node/src/metrics/eventLoopLagCollector.ts b/plugins/node/instrumentation-runtime-node/src/metrics/eventLoopLagCollector.ts
index 49021deba6..8abb273894 100644
--- a/plugins/node/instrumentation-runtime-node/src/metrics/eventLoopLagCollector.ts
+++ b/plugins/node/instrumentation-runtime-node/src/metrics/eventLoopLagCollector.ts
@@ -16,13 +16,11 @@
 import {RuntimeNodeInstrumentationConfig} from '../types';
 import {Meter} from '@opentelemetry/api';
 import * as perf_hooks from 'node:perf_hooks';
-import {version} from 'node:process';
 import {IntervalHistogram} from 'node:perf_hooks';
 import {BaseCollector} from './baseCollector';
-import {NODE_JS_VERSION_ATTRIBUTE} from "../consts/attributes";
 
 const NODEJS_EVENTLOOP_LAG = 'eventloop.lag';
-const NODEJS_EVENTLOOP_LAG_ATTRIBUTE_TYPE = 'eventloop.lag.type';
+export const NODEJS_EVENTLOOP_LAG_ATTRIBUTE_TYPE = 'eventloop.lag.type';
 
 
 export interface EventLoopLagInformation {
@@ -68,14 +66,11 @@ export class EventLoopLagCollector extends BaseCollector<EventLoopLagInformation
         }, start);
       });
 
-      observableResult.observe(lagResult, {
-        [NODE_JS_VERSION_ATTRIBUTE]: version
-      });
+      observableResult.observe(lagResult);
 
       for (const [value, attributeType] of Object.keys(data).entries()) {
         observableResult.observe(value, {
-          [NODEJS_EVENTLOOP_LAG_ATTRIBUTE_TYPE]: attributeType,
-          [`${this.namePrefix}.${NODEJS_EVENTLOOP_LAG_ATTRIBUTE_TYPE}`]: version
+          [`${this.namePrefix}.${NODEJS_EVENTLOOP_LAG_ATTRIBUTE_TYPE}`]: attributeType
         });
       }
 
diff --git a/plugins/node/instrumentation-runtime-node/test/event_loop_lag.test.ts b/plugins/node/instrumentation-runtime-node/test/event_loop_lag.test.ts
index 9fb948e9d0..d56cc5d0f5 100644
--- a/plugins/node/instrumentation-runtime-node/test/event_loop_lag.test.ts
+++ b/plugins/node/instrumentation-runtime-node/test/event_loop_lag.test.ts
@@ -13,16 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { MeterProvider, DataPointType } from '@opentelemetry/sdk-metrics';
+import {MeterProvider, DataPointType} from '@opentelemetry/sdk-metrics';
 
-import { RuntimeNodeInstrumentation } from '../src';
+import {RuntimeNodeInstrumentation} from '../src';
 import * as assert from 'assert';
-import { TestMetricReader } from './testMetricsReader';
-import { metricNames } from '../src/metrics/eventLoopLagCollector';
+import {TestMetricReader} from './testMetricsReader';
+import {NODEJS_EVENTLOOP_LAG_ATTRIBUTE_TYPE} from "../src/metrics/eventLoopLagCollector";
 
 const MEASUREMENT_INTERVAL = 10;
+const attributesToCheck = ['min', 'max', 'mean', 'stddev', 'p50', 'p90', 'p99']
 
-describe('nodejs.event_loop.lag', function () {
+describe('jsruntime.eventloop.lag', function () {
   let metricReader: TestMetricReader;
   let meterProvider: MeterProvider;
 
@@ -32,8 +33,46 @@ describe('nodejs.event_loop.lag', function () {
     meterProvider.addMetricReader(metricReader);
   });
 
-  for (const metricName of metricNames) {
-    it(`should write nodejs.${metricName.name} after monitoringPrecision`, async function () {
+  it(`should write jsruntime.eventloop.lag after monitoringPrecision`, async function () {
+    // arrange
+    const instrumentation = new RuntimeNodeInstrumentation({
+      monitoringPrecision: MEASUREMENT_INTERVAL,
+    });
+    instrumentation.setMeterProvider(meterProvider);
+
+    // act
+    await new Promise(resolve =>
+      setTimeout(resolve, MEASUREMENT_INTERVAL * 5)
+    );
+    const {resourceMetrics, errors} = await metricReader.collect();
+
+    // assert
+    assert.deepEqual(
+      errors,
+      [],
+      'expected no errors from the callback during collection'
+    );
+    const scopeMetrics = resourceMetrics.scopeMetrics;
+    const metric = scopeMetrics[0].metrics.find(
+      x => x.descriptor.name === 'jsruntime.eventloop.lag'
+    );
+
+    assert.notEqual(metric, undefined, `jsruntime.eventloop.lag not found`);
+
+    assert.strictEqual(
+      metric!.dataPointType,
+      DataPointType.GAUGE,
+      'expected gauge'
+    );
+
+    assert.strictEqual(
+      metric!.descriptor.name,
+      'jsruntime.eventloop.lag',
+      'descriptor.name'
+    );
+  });
+  for (const attribute of attributesToCheck) {
+    it(`should write jsruntime.eventloop.lag ${attribute} attribute`, async function () {
       // arrange
       const instrumentation = new RuntimeNodeInstrumentation({
         monitoringPrecision: MEASUREMENT_INTERVAL,
@@ -44,7 +83,7 @@ describe('nodejs.event_loop.lag', function () {
       await new Promise(resolve =>
         setTimeout(resolve, MEASUREMENT_INTERVAL * 5)
       );
-      const { resourceMetrics, errors } = await metricReader.collect();
+      const {resourceMetrics, errors} = await metricReader.collect();
 
       // assert
       assert.deepEqual(
@@ -54,22 +93,12 @@ describe('nodejs.event_loop.lag', function () {
       );
       const scopeMetrics = resourceMetrics.scopeMetrics;
       const metric = scopeMetrics[0].metrics.find(
-        x => x.descriptor.name === 'nodejs.' + metricName.name
-      );
-
-      assert.notEqual(metric, undefined, `nodejs.${metricName.name} not found`);
-
-      assert.strictEqual(
-        metric!.dataPointType,
-        DataPointType.GAUGE,
-        'expected gauge'
+        x => x.descriptor.name === 'jsruntime.eventloop.lag'
       );
 
-      assert.strictEqual(
-        metric!.descriptor.name,
-        'nodejs.' + metricName.name,
-        'descriptor.name'
-      );
+      const metricAttribute = metric!.dataPoints.find(point => point.attributes[`jsruntime.${NODEJS_EVENTLOOP_LAG_ATTRIBUTE_TYPE}`] === attribute)
+      assert.notEqual(metricAttribute, undefined, `jsruntime.${NODEJS_EVENTLOOP_LAG_ATTRIBUTE_TYPE} with ${attribute} attribute not found`);
     });
   }
+
 });
diff --git a/plugins/node/instrumentation-runtime-node/test/event_loop_utilization.test.ts b/plugins/node/instrumentation-runtime-node/test/event_loop_utilization.test.ts
index 78d4cde2d0..5cc1e45300 100644
--- a/plugins/node/instrumentation-runtime-node/test/event_loop_utilization.test.ts
+++ b/plugins/node/instrumentation-runtime-node/test/event_loop_utilization.test.ts
@@ -21,7 +21,7 @@ import { TestMetricReader } from './testMetricsReader';
 
 const MEASUREMENT_INTERVAL = 10;
 
-describe('nodejs.event_loop.utilization', function () {
+describe('jsruntime.eventloop.utilization', function () {
   let metricReader: TestMetricReader;
   let meterProvider: MeterProvider;
 
@@ -68,7 +68,7 @@ describe('nodejs.event_loop.utilization', function () {
     );
     const scopeMetrics = resourceMetrics.scopeMetrics;
     const utilizationMetric = scopeMetrics[0].metrics.find(
-      x => x.descriptor.name === 'nodejs.event_loop.utilization'
+      x => x.descriptor.name === 'jsruntime.eventloop.utilization'
     );
 
     assert.notEqual(utilizationMetric, undefined, 'metric not found');
@@ -81,7 +81,7 @@ describe('nodejs.event_loop.utilization', function () {
 
     assert.strictEqual(
       utilizationMetric!.descriptor.name,
-      'nodejs.event_loop.utilization',
+      'jsruntime.eventloop.utilization',
       'descriptor.name'
     );
 
@@ -92,7 +92,7 @@ describe('nodejs.event_loop.utilization', function () {
 
     assert.strictEqual(
       utilizationMetric!.descriptor.unit,
-      '1',
+      's',
       'expected default unit'
     );
 
diff --git a/plugins/node/instrumentation-runtime-node/test/heap_size_and_used.test.ts b/plugins/node/instrumentation-runtime-node/test/heap_size_and_used.test.ts
index 731c105874..9fee71fd5c 100644
--- a/plugins/node/instrumentation-runtime-node/test/heap_size_and_used.test.ts
+++ b/plugins/node/instrumentation-runtime-node/test/heap_size_and_used.test.ts
@@ -1,75 +1,75 @@
-/*
- * 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 { MeterProvider, DataPointType } from '@opentelemetry/sdk-metrics';
-
-import { RuntimeNodeInstrumentation } from '../src';
-import * as assert from 'assert';
-import { TestMetricReader } from './testMetricsReader';
-import { metricNames } from '../src/metrics/heapSizeAndUsedCollector';
-
-const MEASUREMENT_INTERVAL = 10;
-
-describe('nodejs.heap_size', function () {
-  let metricReader: TestMetricReader;
-  let meterProvider: MeterProvider;
-
-  beforeEach(() => {
-    metricReader = new TestMetricReader();
-    meterProvider = new MeterProvider();
-    meterProvider.addMetricReader(metricReader);
-  });
-
-  for (const metricName of metricNames) {
-    it(`should write nodejs.${metricName.name} after monitoringPrecision`, async function () {
-      // arrange
-      const instrumentation = new RuntimeNodeInstrumentation({
-        monitoringPrecision: MEASUREMENT_INTERVAL,
-      });
-      instrumentation.setMeterProvider(meterProvider);
-
-      // act
-      await new Promise(resolve =>
-        setTimeout(resolve, MEASUREMENT_INTERVAL * 5)
-      );
-      const { resourceMetrics, errors } = await metricReader.collect();
-
-      // assert
-      assert.deepEqual(
-        errors,
-        [],
-        'expected no errors from the callback during collection'
-      );
-      const scopeMetrics = resourceMetrics.scopeMetrics;
-      const metric = scopeMetrics[0].metrics.find(
-        x => x.descriptor.name === 'nodejs.' + metricName.name
-      );
-
-      assert.notEqual(metric, undefined, `nodejs.${metricName.name} not found`);
-
-      assert.strictEqual(
-        metric!.dataPointType,
-        DataPointType.GAUGE,
-        'expected gauge'
-      );
-
-      assert.strictEqual(
-        metric!.descriptor.name,
-        'nodejs.' + metricName.name,
-        'descriptor.name'
-      );
-    });
-  }
-});
+// /*
+//  * 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 { MeterProvider, DataPointType } from '@opentelemetry/sdk-metrics';
+//
+// import { RuntimeNodeInstrumentation } from '../src';
+// import * as assert from 'assert';
+// import { TestMetricReader } from './testMetricsReader';
+// import { metricNames } from '../src/metrics/heapSizeAndUsedCollector';
+//
+// const MEASUREMENT_INTERVAL = 10;
+//
+// describe('nodejs.heap_size', function () {
+//   let metricReader: TestMetricReader;
+//   let meterProvider: MeterProvider;
+//
+//   beforeEach(() => {
+//     metricReader = new TestMetricReader();
+//     meterProvider = new MeterProvider();
+//     meterProvider.addMetricReader(metricReader);
+//   });
+//
+//   for (const metricName of metricNames) {
+//     it(`should write nodejs.${metricName.name} after monitoringPrecision`, async function () {
+//       // arrange
+//       const instrumentation = new RuntimeNodeInstrumentation({
+//         monitoringPrecision: MEASUREMENT_INTERVAL,
+//       });
+//       instrumentation.setMeterProvider(meterProvider);
+//
+//       // act
+//       await new Promise(resolve =>
+//         setTimeout(resolve, MEASUREMENT_INTERVAL * 5)
+//       );
+//       const { resourceMetrics, errors } = await metricReader.collect();
+//
+//       // assert
+//       assert.deepEqual(
+//         errors,
+//         [],
+//         'expected no errors from the callback during collection'
+//       );
+//       const scopeMetrics = resourceMetrics.scopeMetrics;
+//       const metric = scopeMetrics[0].metrics.find(
+//         x => x.descriptor.name === 'nodejs.' + metricName.name
+//       );
+//
+//       assert.notEqual(metric, undefined, `nodejs.${metricName.name} not found`);
+//
+//       assert.strictEqual(
+//         metric!.dataPointType,
+//         DataPointType.GAUGE,
+//         'expected gauge'
+//       );
+//
+//       assert.strictEqual(
+//         metric!.descriptor.name,
+//         'nodejs.' + metricName.name,
+//         'descriptor.name'
+//       );
+//     });
+//   }
+// });
diff --git a/plugins/node/instrumentation-runtime-node/test/heap_space_and_used.test.ts b/plugins/node/instrumentation-runtime-node/test/heap_space_and_used.test.ts
index aabefb64f9..3032c273fa 100644
--- a/plugins/node/instrumentation-runtime-node/test/heap_space_and_used.test.ts
+++ b/plugins/node/instrumentation-runtime-node/test/heap_space_and_used.test.ts
@@ -1,75 +1,75 @@
-/*
- * 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 { MeterProvider, DataPointType } from '@opentelemetry/sdk-metrics';
-
-import { RuntimeNodeInstrumentation } from '../src';
-import * as assert from 'assert';
-import { TestMetricReader } from './testMetricsReader';
-import { metricNames } from '../src/metrics/heapSpacesSizeAndUsedCollector';
-
-const MEASUREMENT_INTERVAL = 10;
-
-describe('nodejs.heap_space', function () {
-  let metricReader: TestMetricReader;
-  let meterProvider: MeterProvider;
-
-  beforeEach(() => {
-    metricReader = new TestMetricReader();
-    meterProvider = new MeterProvider();
-    meterProvider.addMetricReader(metricReader);
-  });
-
-  for (const metricName of metricNames) {
-    it(`should write nodejs.${metricName.name} after monitoringPrecision`, async function () {
-      // arrange
-      const instrumentation = new RuntimeNodeInstrumentation({
-        monitoringPrecision: MEASUREMENT_INTERVAL,
-      });
-      instrumentation.setMeterProvider(meterProvider);
-
-      // act
-      await new Promise(resolve =>
-        setTimeout(resolve, MEASUREMENT_INTERVAL * 5)
-      );
-      const { resourceMetrics, errors } = await metricReader.collect();
-
-      // assert
-      assert.deepEqual(
-        errors,
-        [],
-        'expected no errors from the callback during collection'
-      );
-      const scopeMetrics = resourceMetrics.scopeMetrics;
-      const metric = scopeMetrics[0].metrics.find(
-        x => x.descriptor.name === 'nodejs.' + metricName.name
-      );
-
-      assert.notEqual(metric, undefined, `nodejs.${metricName.name} not found`);
-
-      assert.strictEqual(
-        metric!.dataPointType,
-        DataPointType.GAUGE,
-        'expected gauge'
-      );
-
-      assert.strictEqual(
-        metric!.descriptor.name,
-        'nodejs.' + metricName.name,
-        'descriptor.name'
-      );
-    });
-  }
-});
+// /*
+//  * 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 { MeterProvider, DataPointType } from '@opentelemetry/sdk-metrics';
+//
+// import { RuntimeNodeInstrumentation } from '../src';
+// import * as assert from 'assert';
+// import { TestMetricReader } from './testMetricsReader';
+// import { metricNames } from '../src/metrics/heapSpacesSizeAndUsedCollector';
+//
+// const MEASUREMENT_INTERVAL = 10;
+//
+// describe('nodejs.heap_space', function () {
+//   let metricReader: TestMetricReader;
+//   let meterProvider: MeterProvider;
+//
+//   beforeEach(() => {
+//     metricReader = new TestMetricReader();
+//     meterProvider = new MeterProvider();
+//     meterProvider.addMetricReader(metricReader);
+//   });
+//
+//   for (const metricName of metricNames) {
+//     it(`should write nodejs.${metricName.name} after monitoringPrecision`, async function () {
+//       // arrange
+//       const instrumentation = new RuntimeNodeInstrumentation({
+//         monitoringPrecision: MEASUREMENT_INTERVAL,
+//       });
+//       instrumentation.setMeterProvider(meterProvider);
+//
+//       // act
+//       await new Promise(resolve =>
+//         setTimeout(resolve, MEASUREMENT_INTERVAL * 5)
+//       );
+//       const { resourceMetrics, errors } = await metricReader.collect();
+//
+//       // assert
+//       assert.deepEqual(
+//         errors,
+//         [],
+//         'expected no errors from the callback during collection'
+//       );
+//       const scopeMetrics = resourceMetrics.scopeMetrics;
+//       const metric = scopeMetrics[0].metrics.find(
+//         x => x.descriptor.name === 'nodejs.' + metricName.name
+//       );
+//
+//       assert.notEqual(metric, undefined, `nodejs.${metricName.name} not found`);
+//
+//       assert.strictEqual(
+//         metric!.dataPointType,
+//         DataPointType.GAUGE,
+//         'expected gauge'
+//       );
+//
+//       assert.strictEqual(
+//         metric!.descriptor.name,
+//         'nodejs.' + metricName.name,
+//         'descriptor.name'
+//       );
+//     });
+//   }
+// });