@arela/uploader 0.2.13 → 1.0.0

package/src/services/LoggingService.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'crypto';
 import fs from 'fs';
 import path from 'path';
 
@@ -6,7 +7,7 @@ import FileOperations from '../utils/FileOperations.js';
 
 /**
  * Logging Service
- * Handles application logging with buffering, file output, and console output
+ * Handles application logging with buffering, file output, console output, and event tracking
  */
 export class LoggingService {
   constructor() {
@@ -17,6 +18,12 @@ export class LoggingService {
     this.flushInterval = appConfig.performance.logFlushInterval;
     this.lastFlushTime = Date.now();
 
+    // Event tracking (new in Fase 5)
+    this.uploadEvents = [];
+    this.retryEvents = [];
+    this.sessionStartTime = null;
+    this.sessionId = null;
+
     this.#setupProcessHandlers();
   }
 
@@ -187,6 +194,417 @@ export class LoggingService {
   getBufferSize() {
     return this.buffer.length;
   }
+
+  /**
+   * Initialize session tracking (Fase 5)
+   * @param {string} sessionId - Unique session identifier
+   */
+  initializeSession(sessionId) {
+    this.sessionId = sessionId;
+    this.sessionStartTime = Date.now();
+    this.uploadEvents = [];
+    this.retryEvents = [];
+    this.info(`Session initialized: ${sessionId}`);
+  }
+
+  /**
+   * Record an upload event
+   * @param {Object} uploadEvent - Upload event details
+   */
+  recordUploadEvent(uploadEvent) {
+    const event = {
+      id: randomUUID(),
+      timestamp: new Date().toISOString(),
+      ...uploadEvent,
+    };
+
+    this.uploadEvents.push(event);
+    this.info(
+      `Upload event recorded: ${event.strategy} (${event.fileCount} files, ` +
+        `${event.successCount} success, ${event.failureCount} failed)`,
+    );
+
+    return event.id;
+  }
+
+  /**
+   * Record a retry event
+   * @param {string} uploadEventId - ID of the original upload event
+   * @param {number} attemptNumber - Retry attempt number
+   * @param {string} error - Error message
+   * @param {number} backoffMs - Backoff time in milliseconds
+   */
+  recordRetryEvent(uploadEventId, attemptNumber, error, backoffMs) {
+    const event = {
+      id: randomUUID(),
+      timestamp: new Date().toISOString(),
+      uploadEventId,
+      attemptNumber,
+      error,
+      backoffMs,
+    };
+
+    this.retryEvents.push(event);
+    this.warn(
+      `Retry attempt ${attemptNumber} for upload ${uploadEventId.substring(0, 8)}: ${error}`,
+    );
+
+    return event.id;
+  }
+
+  /**
+   * Get upload history
+   * @returns {Array} Array of upload events
+   */
+  getUploadHistory() {
+    return [...this.uploadEvents];
+  }
+
+  /**
+   * Get retry history
+   * @returns {Array} Array of retry events
+   */
+  getRetryHistory() {
+    return [...this.retryEvents];
+  }
+
+  /**
+   * Get session statistics
+   * @returns {Object} Session statistics
+   */
+  getSessionStatistics() {
+    const stats = {
+      sessionId: this.sessionId,
+      startTime: new Date(this.sessionStartTime).toISOString(),
+      duration: Date.now() - this.sessionStartTime,
+      totalUploadEvents: this.uploadEvents.length,
+      totalRetryEvents: this.retryEvents.length,
+      totalFileCount: this.uploadEvents.reduce(
+        (sum, e) => sum + e.fileCount,
+        0,
+      ),
+      totalSuccessCount: this.uploadEvents.reduce(
+        (sum, e) => sum + e.successCount,
+        0,
+      ),
+      totalFailureCount: this.uploadEvents.reduce(
+        (sum, e) => sum + e.failureCount,
+        0,
+      ),
+      successRate: 0,
+      byStrategy: {
+        individual: this.#getStrategyStats('individual'),
+        batch: this.#getStrategyStats('batch'),
+        fullStructure: this.#getStrategyStats('full-structure'),
+      },
+      retryStats: {
+        totalRetries: this.retryEvents.length,
+        uniqueUploadsWithRetries: new Set(
+          this.retryEvents.map((e) => e.uploadEventId),
+        ).size,
+        totalRetryDuration: this.retryEvents.reduce(
+          (sum, e) => sum + e.backoffMs,
+          0,
+        ),
+      },
+    };
+
+    // Calculate success rate
+    if (stats.totalFileCount > 0) {
+      stats.successRate =
+        (stats.totalSuccessCount / stats.totalFileCount) * 100;
+    }
+
+    return stats;
+  }
+
+  /**
+   * Get statistics for a specific strategy (private)
+   * @private
+   * @param {string} strategy - Strategy name
+   * @returns {Object} Strategy statistics
+   */
+  #getStrategyStats(strategy) {
+    const strategyEvents = this.uploadEvents.filter(
+      (e) => e.strategy === strategy,
+    );
+
+    return {
+      uploadCount: strategyEvents.length,
+      totalFiles: strategyEvents.reduce((sum, e) => sum + e.fileCount, 0),
+      totalSuccess: strategyEvents.reduce((sum, e) => sum + e.successCount, 0),
+      totalFailure: strategyEvents.reduce((sum, e) => sum + e.failureCount, 0),
+      totalDuration: strategyEvents.reduce((sum, e) => sum + e.duration, 0),
+      averageDuration:
+        strategyEvents.length > 0
+          ? strategyEvents.reduce((sum, e) => sum + e.duration, 0) /
+            strategyEvents.length
+          : 0,
+      successRate:
+        strategyEvents.length > 0
+          ? (strategyEvents.reduce((sum, e) => sum + e.successCount, 0) /
+              strategyEvents.reduce((sum, e) => sum + e.fileCount, 0)) *
+            100
+          : 0,
+    };
+  }
+
+  /**
+   * Format session report
+   * @returns {string} Formatted session report
+   */
+  formatSessionReport() {
+    const stats = this.getSessionStatistics();
+    const endTime = new Date();
+    const startTime = new Date(stats.startTime);
+    const durationMin = Math.floor(stats.duration / 60000);
+    const durationSec = Math.floor((stats.duration % 60000) / 1000);
+
+    let report = '';
+
+    // Header with visual separators
+    report +=
+      '\n┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓\n';
+    report +=
+      '┃                   📊 SESSION SUMMARY REPORT                       ┃\n';
+    report +=
+      '┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n\n';
+
+    // Session Information
+    report += '🕐 SESSION INFORMATION\n';
+    report +=
+      '─────────────────────────────────────────────────────────────────\n';
+    report += `│ Session ID:       ${this.#padRight(stats.sessionId, 49)}\n`;
+    report += `│ Duration:         ${this.#padRight(`${durationMin}m ${durationSec}s`, 49)}\n`;
+    report += `│ Start Time:       ${this.#padRight(stats.startTime, 49)}\n`;
+    report += `│ End Time:         ${this.#padRight(endTime.toISOString(), 49)}\n`;
+    report += `│ Total Uploads:    ${this.#padRight(`${stats.totalUploadEvents}`, 49)}\n`;
+    report += `│ Total Retries:    ${this.#padRight(`${stats.totalRetryEvents}`, 49)}\n\n`;
+
+    // Overall Statistics
+    report += '� OVERALL STATISTICS\n';
+    report +=
+      '─────────────────────────────────────────────────────────────────\n';
+    report += `│ Total Files Processed:   ${this.#padRight(`${stats.totalFileCount}`, 41)}\n`;
+    report += `│ Successful Files:        ${this.#padRight(`${stats.totalSuccessCount} (${stats.successRate.toFixed(1)}%)`, 41)}\n`;
+    report += `│ Failed Files:            ${this.#padRight(`${stats.totalFailureCount}`, 41)}\n`;
+    report += `│ Session Success Rate:    ${this.#padRight(`${stats.successRate.toFixed(1)}%`, 41)}\n\n`;
+
+    // Strategy breakdown
+    report += '🎯 BY STRATEGY BREAKDOWN\n';
+    report +=
+      '─────────────────────────────────────────────────────────────────\n';
+    report += this.#formatStrategyStatsDetailed(stats.byStrategy);
+
+    // Performance metrics
+    if (stats.totalFileCount > 0) {
+      const avgTimePerFile = stats.duration / stats.totalFileCount;
+      const filesPerMin = (
+        stats.totalFileCount /
+        (stats.duration / 60000)
+      ).toFixed(1);
+
+      report += '⚡ PERFORMANCE METRICS\n';
+      report +=
+        '─────────────────────────────────────────────────────────────────\n';
+      report += `│ Average Time per File:   ${this.#padRight(`${avgTimePerFile.toFixed(1)}ms`, 41)}\n`;
+      report += `│ Processing Speed:        ${this.#padRight(`${filesPerMin} files/min`, 41)}\n`;
+      report += `│ Total Session Duration:  ${this.#padRight(`${durationMin}m ${durationSec}s`, 41)}\n\n`;
+    }
+
+    // Retry statistics
+    if (stats.retryStats.totalRetries > 0) {
+      const avgRetryWait =
+        stats.retryStats.totalRetryDuration /
+        stats.retryStats.totalRetries /
+        1000;
+      report += '🔄 RETRY STATISTICS\n';
+      report +=
+        '─────────────────────────────────────────────────────────────────\n';
+      report += `│ Total Retries:           ${this.#padRight(`${stats.retryStats.totalRetries}`, 41)}\n`;
+      report += `│ Uploads with Retries:    ${this.#padRight(`${stats.retryStats.uniqueUploadsWithRetries}`, 41)}\n`;
+      report += `│ Total Retry Duration:    ${this.#padRight(`${(stats.retryStats.totalRetryDuration / 1000).toFixed(2)}s`, 41)}\n`;
+      report += `│ Retry Success Rate:      ${this.#padRight(`100%`, 41)}\n\n`;
+    }
+
+    // Intelligent recommendations
+    report += '💡 RECOMMENDATIONS\n';
+    report +=
+      '─────────────────────────────────────────────────────────────────\n';
+    report += this.#generateRecommendations(stats);
+
+    // Footer
+    report +=
+      '\n┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛\n';
+
+    return report;
+  }
+
+  /**
+   * Pad string to the right with spaces (private)
+   * @private
+   * @param {string} str - String to pad
+   * @param {number} length - Target length
+   * @returns {string} Padded string
+   */
+  #padRight(str, length) {
+    const padding = Math.max(0, length - String(str).length);
+    return String(str) + ' '.repeat(padding);
+  }
+
+  /**
+   * Format detailed strategy statistics (private)
+   * @private
+   * @param {Object} strategies - Strategy statistics
+   * @returns {string} Formatted statistics
+   */
+  #formatStrategyStatsDetailed(strategies) {
+    let report = '';
+    const strategyEmojis = {
+      individual: '📁',
+      batch: '📦',
+      'full-structure': '🗂️',
+    };
+
+    for (const [strategyName, stats] of Object.entries(strategies)) {
+      if (stats.uploadCount > 0) {
+        const emoji = strategyEmojis[strategyName] || '📋';
+        const durationSec = (stats.totalDuration / 1000).toFixed(1);
+        const filesPerMin =
+          stats.totalDuration > 0
+            ? (stats.totalFiles / (stats.totalDuration / 60000)).toFixed(1)
+            : '0.0';
+
+        report += `${emoji} ${strategyName.toUpperCase()}\n`;
+        report += `│ ├─ Uploads:        ${this.#padRight(`${stats.uploadCount}`, 47)}\n`;
+        report += `│ ├─ Files:          ${this.#padRight(`${stats.totalFiles}`, 47)}\n`;
+        report += `│ ├─ Success:        ${this.#padRight(`${stats.totalSuccess} (${stats.successRate.toFixed(1)}%)`, 47)}\n`;
+        report += `│ ├─ Failed:         ${this.#padRight(`${stats.totalFiles - stats.totalSuccess}`, 47)}\n`;
+        report += `│ ├─ Duration:       ${this.#padRight(`${durationSec}s`, 47)}\n`;
+        report += `│ └─ Speed:          ${this.#padRight(`${filesPerMin} files/min`, 47)}\n`;
+        report += `│\n`;
+      }
+    }
+
+    return report;
+  }
+
+  /**
+   * Generate intelligent recommendations based on statistics (private)
+   * @private
+   * @param {Object} stats - Session statistics
+   * @returns {string} Formatted recommendations
+   */
+  #generateRecommendations(stats) {
+    const recommendations = [];
+
+    // Analyze success rate
+    if (stats.successRate >= 95) {
+      recommendations.push(
+        '✅ Excellent performance! Success rate is outstanding.',
+      );
+    } else if (stats.successRate >= 80) {
+      recommendations.push(
+        '⚠️  Good performance but consider investigating failures.',
+      );
+    } else {
+      recommendations.push(
+        '🚨 Low success rate - review error logs for issues.',
+      );
+    }
+
+    // Analyze retries
+    if (stats.retryStats.totalRetries === 0) {
+      recommendations.push(
+        '✅ No retries needed - upload system is very stable.',
+      );
+    } else if (stats.retryStats.totalRetries <= 5) {
+      recommendations.push(
+        '✅ Retries were minimal and successful - system handled errors well.',
+      );
+    } else {
+      recommendations.push(
+        '⚠️  High retry count - consider improving connection stability.',
+      );
+    }
+
+    // Analyze strategies
+    const byStrategy = stats.byStrategy;
+    const strategies = Object.entries(byStrategy)
+      .filter(([_, s]) => s.uploadCount > 0)
+      .sort((a, b) => {
+        const aSpeed =
+          a[1].totalDuration > 0
+            ? a[1].totalFiles / (a[1].totalDuration / 60000)
+            : 0;
+        const bSpeed =
+          b[1].totalDuration > 0
+            ? b[1].totalFiles / (b[1].totalDuration / 60000)
+            : 0;
+        return bSpeed - aSpeed;
+      });
+
+    if (strategies.length > 0) {
+      const fastest = strategies[0];
+      recommendations.push(
+        `💡 Fastest strategy: ${fastest[0]} (${(fastest[1].totalFiles / (fastest[1].totalDuration / 60000)).toFixed(1)} files/min)`,
+      );
+    }
+
+    if (stats.totalFileCount > 100) {
+      recommendations.push(
+        '💡 Large session detected - monitor memory usage for future sessions.',
+      );
+    }
+
+    // Format recommendations
+    let report = '';
+    recommendations.forEach((rec, idx) => {
+      if (idx < recommendations.length - 1) {
+        report += `│ ${rec}\n`;
+      } else {
+        report += `│ ${rec}\n`;
+      }
+    });
+
+    return report;
+  }
+
+  /**
+   * Format strategy statistics (private) - Legacy method
+   * @private
+   * @param {Object} strategies - Strategy statistics
+   * @returns {string} Formatted statistics
+   */
+  #formatStrategyStats(strategies) {
+    let report = '';
+
+    for (const [strategyName, stats] of Object.entries(strategies)) {
+      if (stats.uploadCount > 0) {
+        report += `├─ ${strategyName}:\n`;
+        report += `│  ├─ Uploads:  ${stats.uploadCount}\n`;
+        report += `│  ├─ Files:    ${stats.totalFiles}\n`;
+        report += `│  ├─ Success:  ${stats.totalSuccess} (${stats.successRate.toFixed(1)}%)\n`;
+        report += `│  └─ Duration: ${(stats.totalDuration / 1000).toFixed(1)}s\n`;
+      }
+    }
+
+    report += '\n';
+    return report;
+  }
+
+  /**
+   * Get session end statistics
+   * @returns {Object} Final session statistics
+   */
+  getSessionSummary() {
+    const stats = this.getSessionStatistics();
+    return {
+      ...stats,
+      endTime: new Date().toISOString(),
+      report: this.formatSessionReport(),
+    };
+  }
 }
 
 // Export singleton instance