@arela/uploader 0.2.12 → 0.3.0

package/src/services/ErrorMonitor.js

@@ -0,0 +1,275 @@
+/**
+ * Error Monitor Service
+ * Tracks, logs, and monitors errors during signal handling and cleanup operations
+ * Provides detailed error reporting and failure recovery mechanisms
+ */
+export class ErrorMonitor {
+  constructor(logger, cleanupManager, signalHandler) {
+    this.logger = logger;
+    this.cleanupManager = cleanupManager;
+    this.signalHandler = signalHandler;
+
+    /**
+     * Array of recorded errors
+     * @type {Array<Object>}
+     */
+    this.errors = [];
+
+    /**
+     * Error categories
+     * @type {Object}
+     */
+    this.errorCategories = {
+      SIGNAL: 'signal_error',
+      CLEANUP: 'cleanup_error',
+      DATABASE: 'database_error',
+      WATCH_SERVICE: 'watch_service_error',
+      LOGGING: 'logging_error',
+      GENERAL: 'general_error',
+    };
+
+    /**
+     * Error statistics
+     * @type {Object}
+     */
+    this.stats = {
+      totalErrors: 0,
+      errorsByCategory: {},
+      fatalErrors: 0,
+      recoveredErrors: 0,
+      lastErrorTime: null,
+    };
+
+    // Initialize error category stats
+    for (const category of Object.values(this.errorCategories)) {
+      this.stats.errorsByCategory[category] = 0;
+    }
+  }
+
+  /**
+   * Record an error occurrence
+   * @param {string} category - Error category
+   * @param {string} message - Error message
+   * @param {Error} error - Error object
+   * @param {Object} context - Additional context
+   * @param {boolean} isFatal - Whether error is fatal
+   * @returns {Object} Error record
+   */
+  recordError(category, message, error, context = {}, isFatal = false) {
+    const errorRecord = {
+      id: `err_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      timestamp: new Date().toISOString(),
+      category,
+      message,
+      isFatal,
+      stack: error?.stack || null,
+      context,
+      signal: this.signalHandler?.getSignalReceived() || null,
+      resolved: false,
+    };
+
+    this.errors.push(errorRecord);
+    this.stats.totalErrors++;
+    this.stats.errorsByCategory[category]++;
+    this.stats.lastErrorTime = errorRecord.timestamp;
+
+    if (isFatal) {
+      this.stats.fatalErrors++;
+      this.logger.error(
+        `🚨 FATAL ERROR [${category}]: ${message} - ${error?.message}`,
+      );
+    } else {
+      this.logger.warn(
+        `⚠️  ERROR [${category}]: ${message} - ${error?.message}`,
+      );
+    }
+
+    return errorRecord;
+  }
+
+  /**
+   * Mark an error as resolved
+   * @param {string} errorId - Error ID to resolve
+   * @returns {boolean} True if resolved
+   */
+  resolveError(errorId) {
+    const errorRecord = this.errors.find((e) => e.id === errorId);
+    if (errorRecord) {
+      errorRecord.resolved = true;
+      this.stats.recoveredErrors++;
+      this.logger.info(`✅ Error resolved: ${errorId}`);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get all unresolved errors
+   * @returns {Array<Object>} Unresolved error records
+   */
+  getUnresolvedErrors() {
+    return this.errors.filter((e) => !e.resolved);
+  }
+
+  /**
+   * Get errors by category
+   * @param {string} category - Error category
+   * @returns {Array<Object>} Errors in category
+   */
+  getErrorsByCategory(category) {
+    return this.errors.filter((e) => e.category === category);
+  }
+
+  /**
+   * Check if critical errors occurred
+   * @returns {boolean} True if there are fatal errors
+   */
+  hasCriticalErrors() {
+    return this.stats.fatalErrors > 0;
+  }
+
+  /**
+   * Get error statistics
+   * @returns {Object} Error statistics
+   */
+  getStatistics() {
+    return {
+      totalErrors: this.stats.totalErrors,
+      fatalErrors: this.stats.fatalErrors,
+      recoveredErrors: this.stats.recoveredErrors,
+      unresolvedErrors: this.getUnresolvedErrors().length,
+      errorsByCategory: { ...this.stats.errorsByCategory },
+      lastErrorTime: this.stats.lastErrorTime,
+      successRate:
+        this.stats.totalErrors > 0
+          ? (
+              (this.stats.recoveredErrors / this.stats.totalErrors) *
+              100
+            ).toFixed(2)
+          : 100,
+    };
+  }
+
+  /**
+   * Generate detailed error report
+   * @returns {string} Formatted error report
+   */
+  generateErrorReport() {
+    const stats = this.getStatistics();
+    let report =
+      '\n═══════════════════════════════════════════════════════════\n';
+    report += 'ERROR MONITORING REPORT\n';
+    report += '═══════════════════════════════════════════════════════════\n\n';
+
+    report += 'STATISTICS\n';
+    report += `├─ Total Errors:        ${stats.totalErrors}\n`;
+    report += `├─ Fatal Errors:        ${stats.fatalErrors}\n`;
+    report += `├─ Recovered Errors:    ${stats.recoveredErrors}\n`;
+    report += `├─ Unresolved Errors:   ${stats.unresolvedErrors}\n`;
+    report += `├─ Recovery Rate:       ${stats.successRate}%\n`;
+    report += `└─ Last Error:          ${stats.lastErrorTime || 'None'}\n\n`;
+
+    if (this.errors.length > 0) {
+      report += 'ERROR DETAILS (Last 10)\n';
+      const recentErrors = this.errors.slice(-10);
+      recentErrors.forEach((err, idx) => {
+        const status = err.resolved ? '✅' : '❌';
+        const severity = err.isFatal ? '🚨' : '⚠️ ';
+        report += `${idx + 1}. ${status} ${severity} [${err.category}]\n`;
+        report += `   Message: ${err.message}\n`;
+        report += `   Time: ${err.timestamp}\n`;
+        if (err.signal) {
+          report += `   Signal: ${err.signal}\n`;
+        }
+        report += '\n';
+      });
+    }
+
+    report += '═══════════════════════════════════════════════════════════\n';
+    return report;
+  }
+
+  /**
+   * Clear error history (useful after processing)
+   * @returns {void}
+   */
+  clearErrors() {
+    const count = this.errors.length;
+    this.errors = [];
+    this.logger.debug(`ErrorMonitor: Cleared ${count} error records`);
+  }
+
+  /**
+   * Get error monitor status
+   * @returns {Object} Status information
+   */
+  getStatus() {
+    return {
+      isHealthy: this.stats.fatalErrors === 0,
+      hasErrors: this.stats.totalErrors > 0,
+      unresolvedCount: this.getUnresolvedErrors().length,
+      stats: this.getStatistics(),
+    };
+  }
+
+  /**
+   * Validate cleanup operation for errors
+   * @param {Object} cleanupResult - Result from cleanup operation
+   * @returns {Object} Validation result
+   */
+  validateCleanupResult(cleanupResult) {
+    const validation = {
+      isValid: cleanupResult.failureCount === 0,
+      failureCount: cleanupResult.failureCount,
+      successCount: cleanupResult.successCount,
+      issues: [],
+    };
+
+    if (cleanupResult.results) {
+      for (const result of cleanupResult.results) {
+        if (!result.success) {
+          validation.issues.push({
+            resource: result.name,
+            error: result.error,
+            duration: result.duration,
+          });
+
+          this.recordError(
+            this.errorCategories.CLEANUP,
+            `Cleanup failed for ${result.name}`,
+            new Error(result.error),
+            { resource: result.name, duration: result.duration },
+            false,
+          );
+        }
+      }
+    }
+
+    return validation;
+  }
+
+  /**
+   * Reset monitor state (for testing)
+   * @returns {void}
+   */
+  reset() {
+    this.errors = [];
+    this.stats.totalErrors = 0;
+    this.stats.fatalErrors = 0;
+    this.stats.recoveredErrors = 0;
+    this.stats.lastErrorTime = null;
+
+    for (const category of Object.keys(this.stats.errorsByCategory)) {
+      this.stats.errorsByCategory[category] = 0;
+    }
+
+    this.logger.debug('ErrorMonitor: Reset to initial state');
+  }
+}
+
+// Export singleton
+export function createErrorMonitor(logger, cleanupManager, signalHandler) {
+  return new ErrorMonitor(logger, cleanupManager, signalHandler);
+}
+
+export default ErrorMonitor;