@ecdt/server-common 1.1.0 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecdt/server-common",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Conjunto de ferramentas e configurações comuns nos servidores da Econodata",
   "main": "src/index.js",
   "scripts": {

package/src/index.js

@@ -1,6 +1,7 @@
 const bodyParser = require("body-parser");
 const { devMktTokenSanitaze } = require("./services/tokenService.js");
 const { expressCors } = require("./services/corsService.js");
+const { setupGracefulShutdown } = require("./services/shutdownService.js");
 
 function expressCommonMiddlewares({ cookieName } = {}){
     return [bodyParser.text(), bodyParser.json(), bodyParser.urlencoded({extended: false}), devMktTokenSanitaze({ cookieName })];
@@ -9,4 +10,4 @@ function expressCommonMiddlewares({ cookieName } = {}){
 
 
 
-module.exports = { expressCommonMiddlewares, expressCors }
+module.exports = { expressCommonMiddlewares, expressCors, setupGracefulShutdown }

package/src/services/shutdownService.js

@@ -0,0 +1,58 @@
+/**
+ * Graceful shutdown padrão dos microsserviços da Econodata em Kubernetes.
+ * Extraído do dev-mkt-busca: o preStop (20s) já tirou o pod do EndpointSlice
+ * antes do SIGTERM, então aqui só drenamos as conexões em voo e encerramos o
+ * processo antes do SIGKILL.
+ *
+ * @param {import('http').Server} server - servidor retornado por http.createServer(app).listen(...) ou app.listen(...)
+ * @param {object} [options]
+ * @param {() => (Promise<void>|void)} [options.onShutdown] - cleanup extra (fechar pools, Redis, etc.) executado após o server fechar
+ * @param {number} [options.failsafeTimeoutMs] - tempo máximo do graceful antes de forçar a saída (default 10s: grace 40s − 20s de preStop)
+ */
+function setupGracefulShutdown(server, { onShutdown, failsafeTimeoutMs = 10 * 1000 } = {}) {
+    let shuttingDown = false;
+    const gracefulShutdown = signal => {
+        if (shuttingDown) return;
+        shuttingDown = true;
+        console.warn(JSON.stringify({
+            severity: 'WARNING',
+            message: `[shutdown] ${signal} recebido — encerrando`,
+        }));
+
+        server.close(async err => {
+            if (err) {
+                console.error('[shutdown] Erro ao fechar o server HTTP:', err.message || err);
+            } else {
+                console.warn(JSON.stringify({
+                    severity: 'WARNING',
+                    message: '[shutdown] Server HTTP fechado, conexões em voo drenadas',
+                }));
+            }
+            if (onShutdown) {
+                try {
+                    await onShutdown();
+                } catch (cleanupErr) {
+                    console.warn(JSON.stringify({
+                        severity: 'WARNING',
+                        message: `[shutdown] Falha no cleanup: ${cleanupErr.message || cleanupErr}`,
+                    }));
+                }
+            }
+            process.exit(err ? 1 : 0);
+        });
+
+        // fecha conexões keep-alive ociosas, senão um keepAliveTimeout alto segura o close()
+        server.closeIdleConnections();
+
+        // failsafe antes do SIGKILL (grace 40s − 20s de preStop)
+        setTimeout(() => {
+            console.error('[shutdown] Timeout no graceful shutdown, forçando saída');
+            process.exit(1);
+        }, failsafeTimeoutMs).unref();
+    };
+
+    process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
+    process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+}
+
+module.exports = { setupGracefulShutdown };