GeezerVison

The high resolution millisecond timestamp at which the Node.js process was

initialized.

* Returns: {Object}

* `loopCount` {number} Number of event loop iterations.

* `events` {number} Number of events that have been processed by the event handler.

* `eventsWaiting` {number} Number of events that were waiting to be processed when the event provider was called.

This is a wrapper to the `uv_metrics_info` function.

It returns the current set of event loop metrics.

It is recommended to use this property inside a function whose execution was

scheduled using `setImmediate` to avoid collecting metrics before finishing all

operations scheduled during the current loop iteration.

const { performance } = require('node:perf_hooks');

setImmediate(() => {

console.log(performance.nodeTiming.uvMetricsInfo);

});

import { performance } from 'node:perf_hooks';

setImmediate(() => {

console.log(performance.nodeTiming.uvMetricsInfo);

});

NODE_PERFORMANCE_MILESTONE_ENVIRONMENT,

},

loopIdleTime,

uvMetricsInfo,

} = internalBinding('performance');

class PerformanceNodeTiming {

configurable: true,

get: loopIdleTime,

},

uvMetricsInfo: {

__proto__: null,

enumerable: true,

configurable: true,

get: uvMetricsInfo,

},

});

}

V(env_var_settings_string, "envVarSettings") \

V(errno_string, "errno") \

V(error_string, "error") \

V(events, "events") \

V(events_waiting, "eventsWaiting") \

V(exchange_string, "exchange") \

V(expire_string, "expire") \

V(exponent_string, "exponent") \

V(kind_string, "kind") \

V(length_string, "length") \

V(library_string, "library") \

V(loop_count, "loopCount") \

V(mac_string, "mac") \

V(max_buffer_string, "maxBuffer") \

V(max_concurrent_streams_string, "maxConcurrentStreams") \

args.GetReturnValue().Set(1.0 * idle_time / NANOS_PER_MILLIS);

}

void UvMetricsInfo(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

uv_metrics_t metrics;

// uv_metrics_info always return 0

CHECK_EQ(uv_metrics_info(env->event_loop(), &metrics), 0);

Local<Object> obj = Object::New(env->isolate());

obj->Set(env->context(),

env->loop_count(),

Integer::NewFromUnsigned(env->isolate(), metrics.loop_count))

.Check();

obj->Set(env->context(),

env->events(),

Integer::NewFromUnsigned(env->isolate(), metrics.events))

.Check();

obj->Set(env->context(),

env->events_waiting(),

Integer::NewFromUnsigned(env->isolate(), metrics.events_waiting))

.Check();

args.GetReturnValue().Set(obj);

}

void CreateELDHistogram(const FunctionCallbackInfo<Value>& args) {

Environment* env = Environment::GetCurrent(args);

int64_t interval = args[0].As<Integer>()->Value();

SetMethod(isolate, target, "loopIdleTime", LoopIdleTime);

SetMethod(isolate, target, "createELDHistogram", CreateELDHistogram);

SetMethod(isolate, target, "markBootstrapComplete", MarkBootstrapComplete);

SetMethod(isolate, target, "uvMetricsInfo", UvMetricsInfo);

SetFastMethodNoSideEffect(

isolate, target, "now", SlowPerformanceNow, &fast_performance_now);

}

registry->Register(LoopIdleTime);

registry->Register(CreateELDHistogram);

registry->Register(MarkBootstrapComplete);

registry->Register(UvMetricsInfo);

registry->Register(SlowPerformanceNow);

registry->Register(FastPerformanceNow);

registry->Register(fast_performance_now.GetTypeInfo());

const { performance } = require('node:perf_hooks');

const assert = require('node:assert');

const fs = require('node:fs');

const { nodeTiming } = performance;

function safeMetricsInfo(cb) {

setImmediate(() => {

const info = nodeTiming.uvMetricsInfo;

cb(info);

});

const info = nodeTiming.uvMetricsInfo;

assert.strictEqual(info.loopCount, 0);

assert.strictEqual(info.events, 0);

// This is the only part of the test that we test events waiting

// Adding checks for this property will make the test flaky

// as it can be highly influenced by race conditions.

assert.strictEqual(info.eventsWaiting, 0);

// The synchronous call should obviously not affect the uv metrics

const fd = fs.openSync(__filename, 'r');

fs.readFileSync(fd);

const info = nodeTiming.uvMetricsInfo;

assert.strictEqual(info.loopCount, 0);

assert.strictEqual(info.events, 0);

assert.strictEqual(info.eventsWaiting, 0);

function openFile(info) {

assert.strictEqual(info.loopCount, 1);

fs.open(__filename, 'r', (err) => {

assert.ifError(err);

});

}

safeMetricsInfo(openFile);

const common = require('../common');

const { spawnSync } = require('node:child_process');

const assert = require('node:assert');

const fixtures = require('../common/fixtures');

const file = fixtures.path('test-nodetiming-uvmetricsinfo.js');

const { status, stderr } = spawnSync(

process.execPath,

[

file,

],

);

assert.strictEqual(status, 0, stderr.toString());