@yolo-croket-dev/core 1.10.3 → 1.10.4

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 1.10.4
+
+- 종료 중 consumer 취소나 채널 설정이 실패해도 기존 RPC 완료 대기와 최종 연결 정리를 계속합니다.
+- 취소 실패는 민감 정보가 제거된 진단 로그로 한 번 기록합니다.
+
 ## 1.10.3
 
 - 종료 시작 시 등록한 RMQ consumer를 먼저 중단하고 실행 중인 RPC는 완료까지 기다립니다.

package/modules/graceful-shutdown/graceful-shutdown.rmq.js

@@ -1,14 +1,39 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GracefulServerRMQ = void 0;
 const microservices_1 = require("@nestjs/microservices");
+const msa_logger_1 = __importStar(require("@yolo-croket-dev/msa-logger"));
 const os_1 = __importDefault(require("os"));
 const node_util_1 = require("node:util");
 const rmq_diagnostics_function_1 = require("../../functions/rmq-diagnostics.function");
 const sleep = (0, node_util_1.promisify)(setTimeout);
+const msaLogger = new msa_logger_1.default(msa_logger_1.ServerTypeEnum.SERVICE);
 const RMQ_DEFAULT_WAITING_ENDING_HANDLERS_TIMEOUT_MS = 5000;
 const RMQ_DEFAULT_WAITING_ENDING_HANDLERS_INTERVAL_MS = 500;
 const RMQ_UNKNOWN_CONNECTION_IDENTITY = 'unknown';
@@ -128,13 +153,25 @@ class GracefulServerRMQ extends microservices_1.ServerRMQ {
     }
     async cancelConsumer() {
         const consumerTag = this.consumerTag;
-        if (this.channel) {
-            await this.channel.removeSetup(undefined, async (channel) => {
-                if (consumerTag)
-                    await channel.cancel(consumerTag);
-            });
+        try {
+            if (this.channel) {
+                await this.channel.removeSetup(undefined, async (channel) => {
+                    if (consumerTag)
+                        await channel.cancel(consumerTag);
+                });
+            }
+        }
+        catch (err) {
+            // 취소 실패가 Nest 종료 훅을 중단하면 실행 중인 요청 완료 대기와 연결 정리가 생략된다.
+            const diagnostic = (0, msa_logger_1.normalizeDiagnosticError)(err);
+            msaLogger.warn('GracefulServerRMQ consumer 취소 실패: 기존 요청 완료 후 연결 정리', {
+                traceId: 'RMQ_SHUTDOWN_CANCEL_FAILED',
+                diagnosticInfo: diagnostic.diagnosticInfo,
+            }, diagnostic.details);
+        }
+        finally {
+            this.consumerTag = null;
         }
-        this.consumerTag = null;
     }
     async close() {
         var _a;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolo-croket-dev/core",
-  "version": "1.10.3",
+  "version": "1.10.4",
   "author": "Yolo Co., Ltd.",
   "description": "Yolo commonization module",
   "main": "index.js",

package/tests/rmq-consumer-diagnostics.test.cjs

@@ -78,17 +78,35 @@ test('primitive and getter failures retain the original rejection and emit diagn
   }
 });
 
-test('consumer observer is disposed even when channel setup removal fails', async t => {
+test('consumer setup removal failure is logged and native close still disposes the observer', async t => {
   const flag = process.env.RMQ_DIAGNOSTICS_ENABLED;
   process.env.RMQ_DIAGNOSTICS_ENABLED = 'true';
   t.after(() => { if (flag === undefined) delete process.env.RMQ_DIAGNOSTICS_ENABLED; else process.env.RMQ_DIAGNOSTICS_ENABLED = flag; });
   const manager = new EventEmitter();
   t.mock.method(ServerRMQ.prototype, 'createClient', () => manager);
-  t.mock.method(ServerRMQ.prototype, 'close', () => {});
+  const close = t.mock.method(ServerRMQ.prototype, 'close', () => {});
+  const warning = t.mock.method(MsaLogger.prototype, 'warn', () => {});
   const server = new GracefulServerRMQ({ queue: 'USER_SERVICE' });
   server.createClient();
   server.channel = { removeSetup: async () => { throw Error('channel closed'); } };
-  await assert.rejects(server.close(), /channel closed/);
+  await assert.doesNotReject(server.close());
+  assert.equal(close.mock.callCount(), 1);
+  assert.equal(warning.mock.callCount(), 1);
+  assert.equal(manager.listenerCount('connect'), 0);
+});
+
+test('native server close failure retains its rejection after observer disposal', async t => {
+  const flag = process.env.RMQ_DIAGNOSTICS_ENABLED;
+  process.env.RMQ_DIAGNOSTICS_ENABLED = 'true';
+  t.after(() => { if (flag === undefined) delete process.env.RMQ_DIAGNOSTICS_ENABLED; else process.env.RMQ_DIAGNOSTICS_ENABLED = flag; });
+  const manager = new EventEmitter();
+  const failure = Error('native close failed');
+  t.mock.method(ServerRMQ.prototype, 'createClient', () => manager);
+  t.mock.method(ServerRMQ.prototype, 'close', async () => { throw failure; });
+  const server = new GracefulServerRMQ({ queue: 'USER_SERVICE' });
+  server.createClient();
+  server.channel = { removeSetup: async () => {} };
+  await assert.rejects(server.close(), err => err === failure);
   assert.equal(manager.listenerCount('connect'), 0);
 });
 

package/tests/rmq-shutdown-requeue.test.cjs

@@ -1,10 +1,15 @@
 const assert = require('node:assert/strict');
 const test = require('node:test');
+const { createRequire } = require('node:module');
 const { RmqContext, ServerRMQ } = require('@nestjs/microservices');
+const { callModuleDestroyHook } = require('@nestjs/core/hooks/on-module-destroy.hook');
+const { InstanceWrapper } = require('@nestjs/core/injector/instance-wrapper');
 const { Subject } = require('rxjs');
-const { MsaLogger } = require('@yolo-croket-dev/msa-logger');
+const coreRequire = createRequire(require.resolve('../modules/graceful-shutdown/graceful-shutdown.rmq'));
+const { MsaLogger } = coreRequire('@yolo-croket-dev/msa-logger');
 const { RPCInterceptor } = require('../interceptors/rpc.interceptor');
 const { GracefulShutdownService } = require('../modules/graceful-shutdown/graceful-shutdown.service');
+const { GracefulShutdownModule } = require('../modules/graceful-shutdown/graceful-shutdown.module');
 const { GracefulServerRMQ } = require('../modules/graceful-shutdown/graceful-shutdown.rmq');
 
 function createRequest(channel, headers = {}) {
@@ -152,6 +157,60 @@ test('수신 중단과 서버 close가 겹쳐도 consumer는 한 번만 취소
   assert.deepEqual(calls, [['cancel', 'consumer-1'], ['close']]);
 });
 
+for (const failurePoint of ['cancel', 'setup']) {
+  test(`${failurePoint} 실패 후에도 Nest 종료 훅은 기존 RPC 완료를 기다리고 연결을 정리한다`, async t => {
+    t.mock.method(MsaLogger.prototype, 'debug', () => {});
+    t.mock.method(MsaLogger.prototype, 'info', () => {});
+    const warning = t.mock.method(MsaLogger.prototype, 'warn', () => {});
+    const shutdown = new GracefulShutdownService();
+    const server = new GracefulServerRMQ({ queue: 'TEST', noAck: false });
+    const calls = [];
+    const failure = new Error('Channel ended during consumer cancellation');
+    server.consumerTag = 'consumer-1';
+    server.channel = {
+      removeSetup: async (_setup, teardown) => {
+        if (failurePoint === 'setup') throw failure;
+        await teardown({ cancel: async () => { calls.push('cancel'); throw failure; } });
+      },
+    };
+    const active = { method: 'test.payment', traceId: 'shutdown-test', correlationId: 'active-request' };
+    shutdown.pushActiveInterceptors(active);
+    t.after(() => shutdown.popActiveInterceptors(active));
+    shutdown.registerRmqServer(server);
+    let enteredDrain;
+    const startedDrain = new Promise(resolve => { enteredDrain = resolve; });
+    const originalDrain = shutdown.waitForActiveInterceptors.bind(shutdown);
+    t.mock.method(shutdown, 'waitForActiveInterceptors', async () => {
+      calls.push('drain');
+      enteredDrain();
+      await originalDrain();
+      calls.push('finished');
+    });
+    t.mock.method(ServerRMQ.prototype, 'close', async () => { calls.push('close'); });
+    const moduleInstance = new GracefulShutdownModule(shutdown);
+    const moduleFixture = {
+      getNonAliasProviders: () => [
+        ['module', new InstanceWrapper({ instance: moduleInstance, metatype: GracefulShutdownModule })],
+        ['service', new InstanceWrapper({ instance: shutdown, metatype: GracefulShutdownService })],
+      ],
+      controllers: new Map(), injectables: new Map(), middlewares: new Map(),
+    };
+    const destroying = callModuleDestroyHook(moduleFixture);
+    await Promise.race([startedDrain, destroying]);
+    assert.equal(shutdown.isApplicationExit, true);
+    assert.equal(shutdown.getActiveInterceptorsCount(), 1);
+    assert.equal(calls.includes('close'), false);
+    shutdown.popActiveInterceptors(active);
+    await destroying;
+    await server.close();
+    assert.deepEqual(calls, failurePoint === 'cancel'
+      ? ['cancel', 'drain', 'finished', 'close'] : ['drain', 'finished', 'close']);
+    assert.equal(warning.mock.callCount(), 1);
+    assert.equal(server.consumerTag, null);
+    assert.equal(shutdown.getActiveInterceptorsCount(), 0);
+  });
+}
+
 test('채널 설정 중 종료가 시작되면 새 consumer를 만들지 않는다', async () => {
   let finishPrefetch;
   const prefetch = new Promise(resolve => { finishPrefetch = resolve; });