Session Events (start, close)

[stefanwerfling]

Is your feature request related to a problem? Please describe

I searched the documentation and only found this: https://nginx.org/en/docs/njs/reference.html#s_on
I would like to know when a stream (which would also have to be a session) starts and closes again.

Describe the solution you'd like

It would be nice to have "start" and "close" on the event ".on()" for stream and http.

• start: A connection from the client is incoming (first connection from the client)
• close: The client disconnects

And to be able to identify the session using an “ID”.

async(s: NginxStreamRequest): Promise<void> => { 

   r.on('start', () => {
      const id = s.identifer();
      ....
   });

   r.on('close', () => {
      const id = s.identifer();
      // cleanup somthing
   });

}

As an alternative (This is actually a better approach to get “start” as an event.), I could also imagine having to create an event object/function:

stream {
	js_import mainstream from /opt/test.js;

	...

	server {
		listen 80;
		js_access mainstream.accessAddressStream;
		js_session_event mainstream.sessionEvent;
		...
	}
}

test.js:

const accessAddressStream = async(s: NginxStreamRequest): Promise<void> => {
.....
}

const sessionEvent = async(event: SessionEvent, s: NginxStreamRequest|NginxHTTPRequest, ): Promise<void> => {
	const id = s.identifer();

	switch(event) {
		case SessionEvent.start:
			.....
			break;

		case SessionEvent.start:
			.....
			break;
	}

.....
}

export default {accessAddressStream, sessionEvent};

[jo-carter]

@stefanwerfling

start: A connection from the client is incoming (first connection from the client)

Why not just use js_preread for this, or even js_access, or js_filter's main function scope?

close: The client disconnects

Well the end of a session can have logic associated with it, albeit in an ugly manner, and with limitations, by adding a js_set defined variable into the stream access log format. The function bound to the js_set can simply return empty string to avoid impacting output access logs, but any end-of-session logic can be placed in this function also.

Access logs are written when client and upstream connection and closed.

The main limitation with this approach is lack of asynchronous function call support, as js_set does not support it.

[stefanwerfling]

I don't really know when the socket actually starts and ends. But I would like to have this information (e.g., how long a connection is running). And being able to terminate an ongoing connection, such as a websocket, would also be great. Currently, we only get access midway through.

      TCP client connects (e.g. WebSocket handshake)
              │
              ▼
   ┌────────────────────────┐
   │   Connection accepted  │
   │     by stream server   │
   └────────────────────────┘
              │
              ▼
   ┌────────────────────────┐
   │   js_preread phase     │ ◄─ Triggered once at start
   │   (peek at data)       │
   └────────────────────────┘
              │
              ▼
   ┌────────────────────────┐
   │    js_access phase     │ ◄─ Access control check
   │ (allow or deny access) │
   └────────────────────────┘
              │
              ▼
   ┌────────────────────────┐
   │  Upstream connection   │
   │      is opened         │
   └────────────────────────┘
              │
              ▼
   ┌────────────────────────┐
   │   js_filter phase      │ ◄─ **This runs continuously**
   │  (stream data filter)  │     during WebSocket data flow
   └────────────────────────┘
              │
   ... WebSocket stays open ...
              │
  (Client or server eventually closes)
              │
              ▼
   ┌────────────────────────┐
   │  Connection closed     │
   └────────────────────────┘