TLSSocket and Highwater marks question

[constantind]

Hi,

In nodejs 18.18.2 im trying to measure the activity of WritableStream by looking at the _writableState of the TLSSocket from server.on("upgrade", (req,socket,head)), where the websocketserver sender (https://github.com/websockets/ws/blob/master/lib/sender.js#L469) is writing to in order to find when it does actually push to the kernel buffers as docs suggests it may not be immediately. I could not find any easy way to debug or diagnose this, so I decided to log the writable state by increasing or decreasing the highWaterMark on the writable socket, to my surprise the _writableState does not change and always stays like this:

 _writableState: WritableState {
    objectMode: false,
    highWaterMark: 524288,
    finalCalled: false,
    needDrain: false,
    ending: false,
    ended: false,
    finished: false,
    destroyed: false,
    decodeStrings: false,
    defaultEncoding: 'utf8',
    length: 0,
    writing: false,
    corked: 0,
    sync: true,
    bufferProcessing: false,
    onwrite: [Function: bound onwrite],
    writecb: null,
    writelen: 0,
    afterWriteTickInfo: null,
    buffered: [],
    bufferedIndex: 0,
    allBuffers: true,
    allNoop: true,
    pendingcb: 0,
    constructed: true,
    prefinished: false,
    errorEmitted: false,
    emitClose: false,
    autoDestroy: true,
    errored: null,
    closed: false,
    closeEmitted: false,
    [Symbol(kOnFinished)]: []
  }

on server:

const stream_1 = __importDefault(require("stream"));
const https_1 = __importDefault(require("https"));
let server;
server = https_1.default.createServer(config_1.SERVER_OPTIONS, (0, express_1.default)());
let currentSocket;
        server.on('upgrade', (req, socket, _head) => {
            if (req.socket.setNoDelay) {
                req.socket.setNoDelay(true);
            }
            if (req.socket.setTimeout) {
                req.socket.setTimeout(0);
            }
            socket.on('drain', () => {
                logger_1.logger.info('Socket drain event triggered? ');
            });
            currentSocket = socket;
            stream_1.default.setDefaultHighWaterMark(false, 524288);
        });

Later writing using AsyncIterator onNext method and websocket is created from the latest WebSocket.Server.completeUpgrade:

    const emit = {
     next: async (result, args) => {
        let nextMessage = {
            id,
            type: common_1.MessageType.Next,
            payload: result,
        };
        const maybeResult = await (onNext === null || onNext === void 0 ? void 0 : onNext(ctx, nextMessage, args, result));
        if (maybeResult)
            nextMessage = Object.assign(Object.assign({}, nextMessage), { payload: maybeResult });
        await websocket.send((0, common_1.stringifyMessage)(nextMessage, replacer));
    }
    //async iterator
    try {
        for (var _e = true, operationResult_1 = __asyncValues(operationResult), operationResult_1_1; operationResult_1_1 = await operationResult_1.next(), _a = operationResult_1_1.done, !_a;) {
            _c = operationResult_1_1.value;
            _e = false;
            try {
                const result = _c;
                await emit.next(result, execArgs);
            }
            finally {
                _e = true;
            }
        }
    }
    catch (e_1_1) { e_1 = { error: e_1_1 }; }
    finally {
        try {
            if (!_e && !_a && (_b = operationResult_1.return)) await _b.call(operationResult_1);
        }
        finally { if (e_1) throw e_1.error; }
    }
   //call chain
   send: (data) => new Promise((resolve, reject) => {
       if (socket.readyState !== socket.OPEN)
         return resolve();
      websocket.send(data, (err) => (err ? reject(err) : resolve()));
   })

next call chain for the socket write: https://github.com/websockets/ws/blob/master/lib/sender.js#L469
Adding onNext method above logs the _writetableState:

async function onNext(context, message, _args, result) {
     console.log(currentSocket._writableState); //always the same?
}

Next to simulate reading chunks of 4MB and emitting into the AsyncIterator, also 1MB or 16MB and i was expecting to see at least once needDrain: true or lengh:0 to change in order to understand when it is in fact written to the kernel and how much does it write.
It appears that changing the default highwater mark does work on the same socket since i can see improvement in throughput only at 256k and 512k and lower network throughput otherwise but the writable state never changes.

Is this intended or i'm doing something wrong?