dynamic-self-register-proxy 1.0.9 → 1.0.11

package/README.md

@@ -461,6 +461,15 @@ const INTERNAL_PORT_END = 5000;
 - **Négociation de contenu** : l'URL racine `/` retourne HTML pour les navigateurs, JSON pour les API
 - **Health check automatique** : désenregistrement automatique des serveurs non répondants
 
+## 📝 Logs et Débogage
+
+Le serveur enregistre ses activités (requêtes, erreurs, enregistrements) dans un fichier de log persistant :
+
+- **Windows** : `C:\var\log\proxy-server\server.log`
+- **Linux/Mac** : `/var/log/proxy-server/server.log`
+
+Le format des logs inclut la date, l'heure, le PID et le tag `[PROXY]`.
+
 ## Limitations
 
 - Les routes sont stockées en mémoire (perdues au redémarrage du proxy)

package/logger.js

@@ -0,0 +1,69 @@
+const fs = require('fs');
+const path = require('path');
+
+let currentPrefix = 'PROXY';
+
+/**
+ * Log a message to a file at the root of the disk.
+ * @param {string} message The message to log
+ * @param {string} [prefix] Optional prefix to override
+ */
+function logToFile(message, prefix = '') {
+  const logDir = process.platform === 'win32' 
+    ? 'C:\\var\\log\\proxy-server' 
+    : '/var/log/proxy-server';
+  const logFile = path.join(logDir, 'server.log');
+  const now = new Date().toLocaleString('fr-FR', {
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+  });
+  
+  const effectivePrefix = prefix || currentPrefix;
+  const label = effectivePrefix ? ` [${effectivePrefix}]` : "";
+  const logEntry = `[${now}] [PID ${process.pid}]${label} ${message}\n`;
+
+  try {
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true });
+    }
+    fs.appendFileSync(logFile, logEntry);
+  } catch (error) {
+    // On ne log pas l'erreur de log ici pour éviter une boucle infinie
+    // mais on l'affiche sur la console
+    process.stderr.write(`Critical: Failed to write to log file: ${error.message}\n`);
+  }
+}
+
+/**
+ * Override console methods to also log to file
+ * @param {string} [prefix] Prefix for this process
+ */
+function setupLogging(prefix = 'PROXY') {
+  currentPrefix = prefix;
+  const originalLog = console.log;
+  const originalError = console.error;
+
+  console.log = (...args) => {
+    const message = args.map(arg => 
+      typeof arg === 'object' ? JSON.stringify(arg, null, 2) : arg
+    ).join(' ');
+    logToFile(message);
+    originalLog.apply(console, args);
+  };
+
+  console.error = (...args) => {
+    const message = args.map(arg => 
+      typeof arg === 'object' ? JSON.stringify(arg, null, 2) : arg
+    ).join(' ');
+    logToFile(`[ERROR] ${message}`);
+    originalError.apply(console, args);
+  };
+  
+  logToFile('--- Logging system initialized ---');
+}
+
+module.exports = { logToFile, setupLogging };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dynamic-self-register-proxy",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "Dynamic reverse proxy with self-registration API - applications can register themselves and receive an automatically assigned port",
   "main": "proxy-client.js",
   "bin": {
@@ -15,6 +15,7 @@
   "files": [
     "proxy.js",
     "proxy-client.js",
+    "logger.js",
     "README.md",
     "LICENSE"
   ],

package/proxy-client.js

@@ -1,144 +1,144 @@
-/**
- * ProxyClient - Helper pour s'enregistrer auprès du Dynamic Proxy
- * 
- * Usage:
- *   const ProxyClient = require('./proxy-client');
- *   const proxy = new ProxyClient('http://localhost:3000');
- *   const { port } = await proxy.register('/myapp', 'My App');
- *   app.listen(port);
- */
-
-class ProxyClient {
-  /**
-   * @param {string} proxyUrl - URL du proxy (ex: 'http://localhost:3000')
-   */
-  constructor(proxyUrl = 'http://localhost:3000') {
-    this.proxyUrl = proxyUrl;
-    this.registeredPath = null;
-    this.assignedPort = null;
-  }
-
-  /**
-   * Enregistre une route auprès du proxy
-   * @param {string} path - Chemin URL (ex: '/myapp')
-   * @param {string} [name] - Nom de l'application
-   * @param {number} [port] - Port spécifique (optionnel, sinon auto-attribué)
-   * @returns {Promise<{success: boolean, path: string, port: number, name: string}>}
-   */
-  async register(path, name, port) {
-    const body = { path, name };
-    if (port) body.port = port;
-
-    const response = await fetch(`${this.proxyUrl}/proxy/register`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(body)
-    });
-
-    const data = await response.json();
-
-    if (!response.ok) {
-      throw new Error(data.error || 'Registration failed');
-    }
-
-    this.registeredPath = data.path;
-    this.assignedPort = data.port;
-
-    return data;
-  }
-
-  /**
-   * Supprime l'enregistrement de cette application
-   * @returns {Promise<{success: boolean, path: string, freedPort: number}>}
-   */
-  async unregister() {
-    if (!this.registeredPath) {
-      return { success: false, error: 'Not registered' };
-    }
-
-    try {
-      const response = await fetch(`${this.proxyUrl}/proxy/unregister`, {
-        method: 'DELETE',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ path: this.registeredPath })
-      });
-
-      const data = await response.json();
-      
-      if (response.ok) {
-        this.registeredPath = null;
-        this.assignedPort = null;
-      }
-
-      return data;
-    } catch (error) {
-      console.error('Unregister error:', error.message);
-      return { success: false, error: error.message };
-    }
-  }
-
-  /**
-   * Liste toutes les routes enregistrées
-   * @returns {Promise<{count: number, routes: Array, availablePorts: number}>}
-   */
-  async listRoutes() {
-    const response = await fetch(`${this.proxyUrl}/proxy/routes`);
-    return response.json();
-  }
-
-  /**
-   * Vérifie l'état du proxy
-   * @returns {Promise<{status: string, uptime: number, registeredRoutes: number}>}
-   */
-  async health() {
-    const response = await fetch(`${this.proxyUrl}/proxy/health`);
-    return response.json();
-  }
-
-  /**
-   * Configure les handlers pour un arrêt propre
-   * @param {http.Server} server - Instance du serveur HTTP/Express
-   */
-  setupGracefulShutdown(server) {
-    const shutdown = async () => {
-      console.log('Shutting down...');
-      await this.unregister();
-      server.close(() => {
-        console.log('Server closed.');
-        process.exit(0);
-      });
-    };
-
-    process.on('SIGTERM', shutdown);
-    process.on('SIGINT', shutdown);
-  }
-
-  /**
-   * Ajoute la route /proxy/health requise par le proxy pour le health check polling
-   * @param {express.Application} app - Instance de l'application Express
-   * @param {object} [options] - Options de configuration
-   * @param {function} [options.healthCheck] - Fonction personnalisée pour vérifier la santé (doit retourner true/false)
-   */
-  setupHealthRoute(app, options = {}) {
-    app.get('/proxy/health', async (req, res) => {
-      try {
-        // Si une fonction de health check personnalisée est fournie
-        if (options.healthCheck) {
-          const isHealthy = await options.healthCheck();
-          if (isHealthy) {
-            return res.status(200).json({ status: 'healthy' });
-          } else {
-            return res.status(503).json({ status: 'unhealthy' });
-          }
-        }
-        
-        // Par défaut, retourne 200 si le serveur répond
-        res.status(200).json({ status: 'healthy' });
-      } catch (error) {
-        res.status(503).json({ status: 'unhealthy', error: error.message });
-      }
-    });
-  }
-}
-
-module.exports = ProxyClient;
+/**
+ * ProxyClient - Helper pour s'enregistrer auprès du Dynamic Proxy
+ * 
+ * Usage:
+ *   const ProxyClient = require('./proxy-client');
+ *   const proxy = new ProxyClient('http://localhost:3000');
+ *   const { port } = await proxy.register('/myapp', 'My App');
+ *   app.listen(port);
+ */
+
+class ProxyClient {
+  /**
+   * @param {string} proxyUrl - URL du proxy (ex: 'http://localhost:3000')
+   */
+  constructor(proxyUrl = 'http://localhost:3000') {
+    this.proxyUrl = proxyUrl;
+    this.registeredPath = null;
+    this.assignedPort = null;
+  }
+
+  /**
+   * Enregistre une route auprès du proxy
+   * @param {string} path - Chemin URL (ex: '/myapp')
+   * @param {string} [name] - Nom de l'application
+   * @param {number} [port] - Port spécifique (optionnel, sinon auto-attribué)
+   * @returns {Promise<{success: boolean, path: string, port: number, name: string}>}
+   */
+  async register(path, name, port) {
+    const body = { path, name };
+    if (port) body.port = port;
+
+    const response = await fetch(`${this.proxyUrl}/proxy/register`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    });
+
+    const data = await response.json();
+
+    if (!response.ok) {
+      throw new Error(data.error || 'Registration failed');
+    }
+
+    this.registeredPath = data.path;
+    this.assignedPort = data.port;
+
+    return data;
+  }
+
+  /**
+   * Supprime l'enregistrement de cette application
+   * @returns {Promise<{success: boolean, path: string, freedPort: number}>}
+   */
+  async unregister() {
+    if (!this.registeredPath) {
+      return { success: false, error: 'Not registered' };
+    }
+
+    try {
+      const response = await fetch(`${this.proxyUrl}/proxy/unregister`, {
+        method: 'DELETE',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ path: this.registeredPath })
+      });
+
+      const data = await response.json();
+      
+      if (response.ok) {
+        this.registeredPath = null;
+        this.assignedPort = null;
+      }
+
+      return data;
+    } catch (error) {
+      console.error('Unregister error:', error.message);
+      return { success: false, error: error.message };
+    }
+  }
+
+  /**
+   * Liste toutes les routes enregistrées
+   * @returns {Promise<{count: number, routes: Array, availablePorts: number}>}
+   */
+  async listRoutes() {
+    const response = await fetch(`${this.proxyUrl}/proxy/routes`);
+    return response.json();
+  }
+
+  /**
+   * Vérifie l'état du proxy
+   * @returns {Promise<{status: string, uptime: number, registeredRoutes: number}>}
+   */
+  async health() {
+    const response = await fetch(`${this.proxyUrl}/proxy/health`);
+    return response.json();
+  }
+
+  /**
+   * Configure les handlers pour un arrêt propre
+   * @param {http.Server} server - Instance du serveur HTTP/Express
+   */
+  setupGracefulShutdown(server) {
+    const shutdown = async () => {
+      console.log('Shutting down...');
+      await this.unregister();
+      server.close(() => {
+        console.log('Server closed.');
+        process.exit(0);
+      });
+    };
+
+    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', shutdown);
+  }
+
+  /**
+   * Ajoute la route /proxy/health requise par le proxy pour le health check polling
+   * @param {express.Application} app - Instance de l'application Express
+   * @param {object} [options] - Options de configuration
+   * @param {function} [options.healthCheck] - Fonction personnalisée pour vérifier la santé (doit retourner true/false)
+   */
+  setupHealthRoute(app, options = {}) {
+    app.get('/proxy/health', async (req, res) => {
+      try {
+        // Si une fonction de health check personnalisée est fournie
+        if (options.healthCheck) {
+          const isHealthy = await options.healthCheck();
+          if (isHealthy) {
+            return res.status(200).json({ status: 'healthy' });
+          } else {
+            return res.status(503).json({ status: 'unhealthy' });
+          }
+        }
+        
+        // Par défaut, retourne 200 si le serveur répond
+        res.status(200).json({ status: 'healthy' });
+      } catch (error) {
+        res.status(503).json({ status: 'unhealthy', error: error.message });
+      }
+    });
+  }
+}
+
+module.exports = ProxyClient;