net: add new net.server.listen tracing channel

PR-URL: #53136
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Mohammed Keyvanzadeh <mohammadkeyvanzade94@gmail.com>
Reviewed-By: Santiago Gimeno <santiago.gimeno@gmail.com>

Author: ShogunPanda

doc/api/diagnostics_channel.md

@@ -1131,6 +1131,26 @@ Emitted when a new TCP or pipe client socket is created.
 
 Emitted when a new TCP or pipe connection is received.
 
+`tracing:net.server.listen:asyncStart`
+
+*`server` {net.Server}
+*`options` {Object}
+
+Emitted when [`net.Server.listen()`][] is invoked, before the port or pipe is actually setup.
+
+`tracing:net.server.listen:asyncEnd`
+
+*`server` {net.Server}
+
+Emitted when [`net.Server.listen()`][] has completed and thus the server is ready to accept connection.
+
+`tracing:net.server.listen:error`
+
+*`server` {net.Server}
+*`error` {Error}
+
+Emitted when [`net.Server.listen()`][] is returning an error.
+
 #### UDP
 
 `udp.socket`
@@ -1179,5 +1199,6 @@ Emitted when a new thread is created.
 [`diagnostics_channel.unsubscribe(name, onMessage)`]: #diagnostics_channelunsubscribename-onmessage
 [`end` event]: #endevent
 [`error` event]: #errorevent
+[`net.Server.listen()`]: net.md#serverlisten
 [`start` event]: #startevent
 [context loss]: async_context.md#troubleshooting-context-loss

lib/net.js

@@ -151,6 +151,7 @@ const kPerfHooksNetConnectContext = Symbol('kPerfHooksNetConnectContext');
 constdc=require('diagnostics_channel');
 constnetClientSocketChannel=dc.channel('net.client.socket');
 constnetServerSocketChannel=dc.channel('net.server.socket');
+constnetServerListen=dc.tracingChannel('net.server.listen');
 
 const{
  hasObserver,
@@ -1879,6 +1880,11 @@ function setupListenHandle(address, port, addressType, backlog, fd, flags) {
 
 if(typeofrval==='number'){
 consterror=newUVExceptionWithHostPort(rval,'listen',address,port);
+
+if(netServerListen.hasSubscribers){
+netServerListen.error.publish({server: this, error });
+}
+
 process.nextTick(emitErrorNT,this,error);
 return;
 }
@@ -1898,6 +1904,11 @@ function setupListenHandle(address, port, addressType, backlog, fd, flags) {
 constex=newUVExceptionWithHostPort(err,'listen',address,port);
 this._handle.close();
 this._handle=null;
+
+if(netServerListen.hasSubscribers){
+netServerListen.error.publish({server: this,error: ex});
+}
+
 defaultTriggerAsyncIdScope(this[async_id_symbol],
 process.nextTick,
 emitErrorNT,
@@ -1906,6 +1917,10 @@ function setupListenHandle(address, port, addressType, backlog, fd, flags) {
 return;
 }
 
+if(netServerListen.hasSubscribers){
+netServerListen.asyncEnd.publish({server: this});
+}
+
 // Generate connection key, this should be unique to the connection
 this._connectionKey=addressType+':'+address+':'+port;
 
@@ -1993,6 +2008,10 @@ Server.prototype.listen = function(...args) {
 thrownewERR_SERVER_ALREADY_LISTEN();
 }
 
+if(netServerListen.hasSubscribers){
+netServerListen.asyncStart.publish({server: this, options });
+}
+
 if(cb!==null){
 this.once('listening',cb);
 }

test/parallel/test-diagnostics-channel-net.js

@@ -5,21 +5,87 @@ const net = require('net');
 constdc=require('diagnostics_channel');
 
 constisNetSocket=(socket)=>socketinstanceofnet.Socket;
+constisNetServer=(server)=>serverinstanceofnet.Server;
 
-dc.subscribe('net.client.socket',common.mustCall(({ socket })=>{
-assert.strictEqual(isNetSocket(socket),true);
-}));
+functiontestDiagnosticChannel(subscribers,test,after){
+dc.tracingChannel('net.server.listen').subscribe(subscribers);
 
-dc.subscribe('net.server.socket',common.mustCall(({ socket })=>{
-assert.strictEqual(isNetSocket(socket),true);
-}));
+test(common.mustCall(()=>{
+dc.tracingChannel('net.server.listen').unsubscribe(subscribers);
+after?.();
+}));
+}
 
-constserver=net.createServer(common.mustCall((socket)=>{
-socket.destroy();
-server.close();
-}));
+consttestSuccessfullListen=common.mustCall(()=>{
+letcb;
+constserver=net.createServer(common.mustCall((socket)=>{
+socket.destroy();
+server.close();
+cb();
+}));
 
-server.listen(()=>{
-const{ port }=server.address();
-net.connect(port);
+dc.subscribe('net.client.socket',common.mustCall(({ socket })=>{
+assert.strictEqual(isNetSocket(socket),true);
+}));
+
+dc.subscribe('net.server.socket',common.mustCall(({ socket })=>{
+assert.strictEqual(isNetSocket(socket),true);
+}));
+
+testDiagnosticChannel(
+{
+asyncStart: common.mustCall(({server: currentServer, options })=>{
+assert.strictEqual(isNetServer(server),true);
+assert.strictEqual(currentServer,server);
+assert.strictEqual(options.customOption,true);
+}),
+asyncEnd: common.mustCall(({server: currentServer})=>{
+assert.strictEqual(isNetServer(server),true);
+assert.strictEqual(currentServer,server);
+}),
+error: common.mustNotCall()
+},
+common.mustCall((callback)=>{
+cb=callback;
+server.listen({port: 0,customOption: true},()=>{
+const{ port }=server.address();
+net.connect(port);
+});
+}),
+testFailingListen
+);
 });
+
+consttestFailingListen=common.mustCall(()=>{
+constoriginalServer=net.createServer(common.mustNotCall());
+
+originalServer.listen(()=>{
+constserver=net.createServer(common.mustNotCall());
+
+testDiagnosticChannel(
+{
+asyncStart: common.mustCall(({server: currentServer, options })=>{
+assert.strictEqual(isNetServer(server),true);
+assert.strictEqual(currentServer,server);
+assert.strictEqual(options.customOption,true);
+}),
+asyncEnd: common.mustNotCall(),
+error: common.mustCall(({server: currentServer})=>{
+assert.strictEqual(isNetServer(server),true);
+assert.strictEqual(currentServer,server);
+}),
+},
+common.mustCall((callback)=>{
+server.on('error',()=>{});
+server.listen({port: originalServer.address().port,customOption: true});
+callback();
+}),
+common.mustCall(()=>{
+originalServer.close();
+server.close();
+})
+);
+});
+});
+
+testSuccessfullListen();