chore: address comments from #361

Author: fmenezes

src/common/logger.ts

@@ -44,8 +44,9 @@ export const LogId = {
     streamableHttpTransportStarted: mongoLogId(1_006_001),
     streamableHttpTransportSessionCloseFailure: mongoLogId(1_006_002),
     streamableHttpTransportSessionCloseNotification: mongoLogId(1_006_003),
-    streamableHttpTransportRequestFailure: mongoLogId(1_006_004),
-    streamableHttpTransportCloseFailure: mongoLogId(1_006_005),
+    streamableHttpTransportSessionCloseNotificationFailure: mongoLogId(1_006_004),
+    streamableHttpTransportRequestFailure: mongoLogId(1_006_005),
+    streamableHttpTransportCloseFailure: mongoLogId(1_006_006),
 } as const;
 
 export abstract class LoggerBase {

src/common/sessionStore.ts

@@ -1,12 +1,12 @@
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import logger, { LogId, McpLogger } from "./logger.js";
+import logger, { LogId, LoggerBase, McpLogger } from "./logger.js";
 import { TimeoutManager } from "./timeoutManager.js";
 
 export class SessionStore {
     private sessions: {
         [sessionId: string]: {
-            mcpServer: McpServer;
+            logger: LoggerBase;
             transport: StreamableHTTPServerTransport;
             abortTimeout: TimeoutManager;
             notificationTimeout: TimeoutManager;
@@ -47,46 +47,53 @@ export class SessionStore {
     private sendNotification(sessionId: string): void {
         const session = this.sessions[sessionId];
         if (!session) {
+            logger.warning(
+                LogId.streamableHttpTransportSessionCloseNotificationFailure,
+                "sessionStore",
+                `session ${sessionId} not found, no notification delivered`
+            );
             return;
         }
-        const logger = new McpLogger(session.mcpServer);
-        logger.info(
+        session.logger.info(
             LogId.streamableHttpTransportSessionCloseNotification,
             "sessionStore",
             "Session is about to be closed due to inactivity"
         );
     }
 
     setSession(sessionId: string, transport: StreamableHTTPServerTransport, mcpServer: McpServer): void {
-        if (this.sessions[sessionId]) {
+        const session = this.sessions[sessionId];
+        if (session) {
             throw new Error(`Session ${sessionId} already exists`);
         }
         const abortTimeout = new TimeoutManager(async () => {
-            const logger = new McpLogger(mcpServer);
-            logger.info(
-                LogId.streamableHttpTransportSessionCloseNotification,
-                "sessionStore",
-                "Session closed due to inactivity"
-            );
+            if (this.sessions[sessionId]) {
+                this.sessions[sessionId].logger.info(
+                    LogId.streamableHttpTransportSessionCloseNotification,
+                    "sessionStore",
+                    "Session closed due to inactivity"
+                );
 
-            await this.closeSession(sessionId);
+                await this.closeSession(sessionId);
+            }
         }, this.idleTimeoutMS);
         const notificationTimeout = new TimeoutManager(
             () => this.sendNotification(sessionId),
             this.notificationTimeoutMS
         );
-        this.sessions[sessionId] = { mcpServer, transport, abortTimeout, notificationTimeout };
+        this.sessions[sessionId] = { logger: new McpLogger(mcpServer), transport, abortTimeout, notificationTimeout };
     }
 
     async closeSession(sessionId: string, closeTransport: boolean = true): Promise<void> {
-        if (!this.sessions[sessionId]) {
+        const session = this.sessions[sessionId];
+        if (!session) {
             throw new Error(`Session ${sessionId} not found`);
         }
-        this.sessions[sessionId].abortTimeout.clear();
-        this.sessions[sessionId].notificationTimeout.clear();
+        session.abortTimeout.clear();
+        session.notificationTimeout.clear();
         if (closeTransport) {
             try {
-                await this.sessions[sessionId].transport.close();
+                await session.transport.close();
             } catch (error) {
                 logger.error(
                     LogId.streamableHttpTransportSessionCloseFailure,