@yolo-croket-dev/core 1.10.3 → 1.10.5

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 1.10.5
+
+- 종료 중 RPC의 consumer 취소나 메시지 반환이 실패해도 기존 Pod의 오류·완료 응답으로 전파하지 않습니다.
+- 취소 실패 후에도 메시지 반환을 시도하며 실패한 작업은 요청 traceId와 정리된 진단 정보로 한 번 기록합니다.
+
+## 1.10.4
+
+- 종료 중 consumer 취소나 채널 설정이 실패해도 기존 RPC 완료 대기와 최종 연결 정리를 계속합니다.
+- 취소 실패는 민감 정보가 제거된 진단 로그로 한 번 기록합니다.
+
 ## 1.10.3
 
 - 종료 시작 시 등록한 RMQ consumer를 먼저 중단하고 실행 중인 RPC는 완료까지 기다립니다.

package/interceptors/rpc.interceptor.js

@@ -148,10 +148,39 @@ let RPCInterceptor = class RPCInterceptor {
         }
         return obj;
     }
-    async requeueMessageOnShutdown(channel, message) {
+    async requeueMessageOnShutdown(channel, message, traceId) {
         msaLogger.debug('RPCInterceptor isApplicationExit called', { traceId: 'IS_APPLICATION_EXIT' });
-        await channel.cancel(message.fields.consumerTag);
-        channel.nack(message, false, true);
+        const failures = [];
+        try {
+            await channel.cancel(message.fields.consumerTag);
+        }
+        catch (err) {
+            failures.push({
+                operation: 'cancel',
+                diagnostic: (0, msa_logger_1.normalizeDiagnosticError)(err),
+            });
+        }
+        try {
+            channel.nack(message, false, true);
+        }
+        catch (err) {
+            // 닫힌 채널의 미확인 메시지는 브로커가 재전달하므로 기존 Pod에서 오류 응답을 보내지 않는다.
+            failures.push({
+                operation: 'nack',
+                diagnostic: (0, msa_logger_1.normalizeDiagnosticError)(err),
+            });
+        }
+        if (failures.length) {
+            msaLogger.warn('RPCInterceptor 종료 중 메시지 재전달 처리 실패', {
+                traceId,
+                diagnosticInfo: failures[0].diagnostic.diagnosticInfo,
+            }, {
+                failures: failures.map(({ operation, diagnostic }) => ({
+                    operation,
+                    ...diagnostic.details,
+                })),
+            });
+        }
         // 기존 서버에서 응답을 완료하면 재전달된 요청의 실제 응답을 클라이언트가 기다릴 수 없다.
         return new rxjs_1.Observable();
     }
@@ -182,7 +211,7 @@ let RPCInterceptor = class RPCInterceptor {
         let abortController = new AbortController();
         /** consume 메시지 전부 cancel */
         if (this.gracefulShutdownService.isApplicationExit) {
-            return this.requeueMessageOnShutdown(channel, message);
+            return this.requeueMessageOnShutdown(channel, message, execInterceptor.traceId);
         }
         if (!staticRetryCount && reDeliveryCount > 0) {
             msaLogger.debug('RETRY_COUNT_ZERO_OR_NO_RETRY 발생 전, redelivery 발생', { traceId: ((_b = content.data.param) === null || _b === void 0 ? void 0 : _b.traceId) || 'RETRY_COUNT_ZERO_OR_NO_RETRY' }, {
@@ -195,7 +224,7 @@ let RPCInterceptor = class RPCInterceptor {
             });
             const isRedeliveryMessage = await this.isRedeliveryMessage(message.properties.replyTo, execInterceptor.traceId);
             if (this.gracefulShutdownService.isApplicationExit) {
-                return this.requeueMessageOnShutdown(channel, message);
+                return this.requeueMessageOnShutdown(channel, message, execInterceptor.traceId);
             }
             if (!isRedeliveryMessage || reDeliveryCount > 5) {
                 msaLogger.debug('isRedeliveryMessage RETRY_COUNT_ZERO_OR_NO_RETRY false', { traceId: ((_c = content.data.param) === null || _c === void 0 ? void 0 : _c.traceId) || 'RETRY_COUNT_ZERO_OR_NO_RETRY' });
@@ -368,7 +397,7 @@ let RPCInterceptor = class RPCInterceptor {
         }
         // 재전달 여부를 비동기로 확인하는 동안 종료가 시작될 수 있으므로 실행 직전에 다시 확인한다.
         if (this.gracefulShutdownService.isApplicationExit) {
-            return this.requeueMessageOnShutdown(channel, message);
+            return this.requeueMessageOnShutdown(channel, message, execInterceptor.traceId);
         }
         this.gracefulShutdownService.pushActiveInterceptors(execInterceptor);
         // eslint-disable-next-line consistent-return

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.5",
   "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,18 @@
 const assert = require('node:assert/strict');
 const test = require('node:test');
+const { createRequire } = require('node:module');
 const { RmqContext, ServerRMQ } = require('@nestjs/microservices');
+const { RpcProxy } = require('@nestjs/microservices/context/rpc-proxy');
+const { RpcExceptionsHandler } = require('@nestjs/microservices/exceptions/rpc-exceptions-handler');
+const { Logger } = require('@nestjs/common');
+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 = {}) {
@@ -44,6 +52,60 @@ test('종료 중 받은 미실행 RPC는 즉시 재전달하고 기존 요청의
   assert.equal(shutdown.getActiveInterceptorsCount(), 0);
 });
 
+for (const scenario of [
+  { name: '취소 실패', cancelFails: true, nackFails: false, duringRedelivery: false },
+  { name: '반환 실패', cancelFails: false, nackFails: true, duringRedelivery: false },
+  { name: '취소·반환 실패', cancelFails: true, nackFails: true, duringRedelivery: false },
+  { name: '재전달 확인 중 종료와 취소 실패', cancelFails: true, nackFails: false, duringRedelivery: true },
+]) {
+  test(`${scenario.name} 시에도 기존 Pod는 RPC 오류나 완료 응답을 보내지 않는다`, async t => {
+    t.mock.method(MsaLogger.prototype, 'debug', () => {});
+    t.mock.method(Logger.prototype, 'error', () => {});
+    const warning = t.mock.method(MsaLogger.prototype, 'warn', () => {});
+    const shutdown = new GracefulShutdownService();
+    shutdown.isApplicationExit = !scenario.duringRedelivery;
+    const calls = [];
+    const channel = {
+      cancel: async () => {
+        calls.push('cancel');
+        if (scenario.cancelFails) throw Error('channel closed during cancel');
+      },
+      nack: (_message, multiple, requeue) => {
+        calls.push(['nack', multiple, requeue]);
+        if (scenario.nackFails) throw Error('channel closed during nack');
+      },
+    };
+    const { message, context } = createRequest(channel, scenario.duringRedelivery ? { 'x-delivery-count': 1 } : {});
+    const interceptor = new RPCInterceptor({ get: () => undefined }, shutdown);
+    if (scenario.duringRedelivery) {
+      const server = new GracefulServerRMQ({ queue: 'TEST', noAck: false });
+      shutdown.registerRmqServer(server);
+      t.mock.method(interceptor, 'isRedeliveryMessage', async () => {
+        await shutdown.onModuleDestroy();
+        return true;
+      });
+    }
+    const next = { handle: t.mock.fn(() => { throw Error('실행하면 안 되는 신규 요청'); }) };
+    const handler = new RpcProxy().create(() => interceptor.intercept(context, next), new RpcExceptionsHandler());
+    const response = await handler(...context.getArgs());
+    const replies = [];
+    const subscription = new ServerRMQ({ queue: 'TEST', noAck: false }).send(response, value => replies.push(value));
+    t.after(() => subscription.unsubscribe());
+    await new Promise(resolve => setImmediate(resolve));
+    assert.deepEqual(replies, []);
+    assert.deepEqual(calls, ['cancel', ['nack', false, true]]);
+    assert.equal(next.handle.mock.callCount(), 0);
+    assert.equal(shutdown.getActiveInterceptorsCount(), 0);
+    assert.equal(warning.mock.callCount(), 1);
+    const [logMessage, logInfo, logDetails] = warning.mock.calls[0].arguments;
+    assert.match(logMessage, /종료/);
+    assert.equal(logInfo.traceId, 'shutdown-test');
+    assert.deepEqual(logDetails.failures.map(item => item.operation),
+      [scenario.cancelFails ? 'cancel' : null, scenario.nackFails ? 'nack' : null].filter(Boolean));
+    assert.equal(message.properties.replyTo, 'reply-queue');
+  });
+}
+
 test('종료 전에 실행한 RPC는 계속 처리하고 종료 이후 도착한 메시지만 반환한다', async t => {
   t.mock.method(MsaLogger.prototype, 'debug', () => {});
   const shutdown = new GracefulShutdownService();
@@ -152,6 +214,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; });