@heliyos/heliyos-api-core 1.0.42 → 1.0.43

package/dist/mongoose.d.ts

@@ -5,6 +5,8 @@ export declare class MongoConnectionManager {
     private initializationPromise;
     private isInitialized;
     private static connectionCount;
+    private lastConnectedTimestamp;
+    private monitoringInterval;
     private constructor();
     private getConnectionOptions;
     static getInstance(): MongoConnectionManager;
@@ -13,6 +15,9 @@ export declare class MongoConnectionManager {
     getConnection(): mongoose.Connection;
     logConnectionStatus(): void;
     private checkConnectionLatency;
+    private startConnectionMonitoring;
+    private getDetailedConnectionStatus;
+    private getReadyStateText;
 }
 export declare const mongoInstance: MongoConnectionManager;
 export declare const mongooseConnection: mongoose.Connection;

package/dist/mongoose.js

@@ -38,21 +38,48 @@ class MongoConnectionManager {
     constructor() {
         this.initializationPromise = null;
         this.isInitialized = false;
-        // Setup connection listeners only once
+        this.lastConnectedTimestamp = null;
+        this.monitoringInterval = null;
+        // Add detailed connection state logging
+        mongoose_1.default.connection.on("connecting", () => {
+            logger_1.logger.info("MongoDB is attempting to connect...");
+        });
         mongoose_1.default.connection.on("error", (err) => {
-            logger_1.logger.error("MongoDB connection error:", err);
+            logger_1.logger.error("MongoDB connection error:", {
+                error: err,
+                state: mongoose_1.default.connection.readyState,
+                host: mongoose_1.default.connection.host,
+                name: mongoose_1.default.connection.name,
+            });
         });
         mongoose_1.default.connection.on("disconnected", () => {
-            logger_1.logger.warn("MongoDB disconnected. Attempting to reconnect...");
+            logger_1.logger.warn("MongoDB disconnected.", {
+                lastConnectedAt: this.lastConnectedTimestamp,
+                timeSinceLastConnection: this.lastConnectedTimestamp
+                    ? Date.now() - this.lastConnectedTimestamp
+                    : "never connected",
+            });
         });
         mongoose_1.default.connection.on("reconnected", () => {
-            logger_1.logger.info("MongoDB reconnected");
+            logger_1.logger.info("MongoDB reconnected", {
+                reconnectAttempts: MongoConnectionManager.connectionCount,
+                downtime: this.lastConnectedTimestamp
+                    ? Date.now() - this.lastConnectedTimestamp
+                    : "unknown",
+            });
             this.isInitialized = true;
+            this.lastConnectedTimestamp = Date.now();
         });
         mongoose_1.default.connection.on("connected", () => {
-            logger_1.logger.info("MongoDB connected");
+            this.lastConnectedTimestamp = Date.now();
+            logger_1.logger.info("MongoDB connected", {
+                host: mongoose_1.default.connection.host,
+                name: mongoose_1.default.connection.name,
+                attemptCount: MongoConnectionManager.connectionCount,
+            });
             this.isInitialized = true;
             this.checkConnectionLatency();
+            this.startConnectionMonitoring();
         });
         // Add pool monitoring
         mongoose_1.default.connection.on("connected", () => {
@@ -127,10 +154,15 @@ class MongoConnectionManager {
     }
     disconnect() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.monitoringInterval) {
+                clearInterval(this.monitoringInterval);
+                this.monitoringInterval = null;
+            }
             if (mongoose_1.default.connection.readyState === 1) {
                 yield mongoose_1.default.disconnect();
                 this.isInitialized = false;
                 this.initializationPromise = null;
+                this.lastConnectedTimestamp = null;
             }
         });
     }
@@ -164,6 +196,79 @@ class MongoConnectionManager {
             }
         });
     }
+    // Add new method for continuous connection monitoring
+    startConnectionMonitoring() {
+        if (this.monitoringInterval) {
+            clearInterval(this.monitoringInterval);
+        }
+        this.monitoringInterval = setInterval(() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                const start = Date.now();
+                const status = yield this.getDetailedConnectionStatus();
+                const latency = Date.now() - start;
+                logger_1.logger.info("MongoDB Connection Health Check:", Object.assign(Object.assign({}, status), { latency, timestamp: new Date().toISOString() }));
+                if (latency > 1000) {
+                    logger_1.logger.warn("MongoDB Connection Latency Alert:", {
+                        latency,
+                        threshold: 1000,
+                        status,
+                    });
+                }
+            }
+            catch (error) {
+                logger_1.logger.error("MongoDB Connection Health Check Failed:", {
+                    error,
+                    state: mongoose_1.default.connection.readyState,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+        }), 30000); // Check every 30 seconds
+    }
+    // Add method to get detailed connection status
+    getDetailedConnectionStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const conn = mongoose_1.default.connection;
+            try {
+                const adminDb = conn.db.admin();
+                const serverStatus = yield adminDb.serverStatus();
+                return {
+                    readyState: conn.readyState,
+                    readyStateText: this.getReadyStateText(conn.readyState),
+                    host: conn.host,
+                    port: conn.port,
+                    name: conn.name,
+                    connections: serverStatus.connections,
+                    uptime: serverStatus.uptime,
+                    lastConnectedAt: this.lastConnectedTimestamp,
+                    timeSinceLastConnection: this.lastConnectedTimestamp
+                        ? Date.now() - this.lastConnectedTimestamp
+                        : null,
+                };
+            }
+            catch (error) {
+                logger_1.logger.error("Failed to get detailed server status:", error);
+                return {
+                    readyState: conn.readyState,
+                    readyStateText: this.getReadyStateText(conn.readyState),
+                    host: conn.host,
+                    port: conn.port,
+                    name: conn.name,
+                    error: error.message,
+                };
+            }
+        });
+    }
+    // Helper method to convert readyState to human readable text
+    getReadyStateText(state) {
+        const states = {
+            0: "disconnected",
+            1: "connected",
+            2: "connecting",
+            3: "disconnecting",
+            99: "uninitialized",
+        };
+        return states[state] || "unknown";
+    }
 }
 exports.MongoConnectionManager = MongoConnectionManager;
 MongoConnectionManager.connectionCount = 0; // Add connection counter

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heliyos/heliyos-api-core",
-  "version": "1.0.42",
+  "version": "1.0.43",
   "description": "Heliyos's core api functions and middlewares. Its a private package hosted on npm.",
   "main": "./dist/index.js",
   "scripts": {