@yolo-croket-dev/core 1.10.0-jun.2-beta.1 → 1.10.1

package/CHANGELOG.md

@@ -1,7 +1,23 @@
 # Changelog
 
+## 1.10.0
+
+- 비회원 인증 로그 마스킹·검증 오류 보호·재시도 정보 필드를 정식 발행합니다.
+- 기존 1.9.14의 AMQP timeout, ACK/NACK 옵션, RabbitMQ 연결 이름 설정을 보존합니다.
+- 소비 서비스에서 사용하던 1.10.0-jun.2의 gRPC metadata·예외 처리와 포트 파싱을 유지합니다.
+
 ## 1.10.0-jun.2-beta.1
 
 - 현재 소비 버전 1.10.0-jun.2의 gRPC metadata 및 예외 처리 동작을 유지합니다.
 - 비회원 인증 요청 로그의 민감 값을 마스킹하고 검증 오류에서 입력값을 제외합니다.
 - 인증 실패의 남은 입력 횟수와 재시도 대기시간 필드를 추가합니다.
+
+## 1.9.13-beta.1
+
+- AMQP 요청의 `param.timeout`을 최대 29분 범위에서 적용해 timeout 시 클라이언트 Observable 구독을 해제합니다.
+
+## 1.9.12-beta.1
+
+- `GracefulServerRMQ`가 RabbitMQ 연결에 queue, environment, owner, hostname, process ID 기반 `connection_name`을 자동으로 추가합니다.
+- 호출자가 지정한 `connectionOptions`, `clientProperties`, 유효한 문자열 `connection_name`은 그대로 보존합니다.
+- 문자열이 아닌 `connection_name`은 런타임 오류 없이 자동 생성값으로 대체합니다.

package/filters/grpc-exception.filter.js

@@ -152,7 +152,7 @@ let GrpcExceptionFilter = class GrpcExceptionFilter extends microservices_1.Base
         }
     }
 };
-GrpcExceptionFilter = __decorate([
+exports.GrpcExceptionFilter = GrpcExceptionFilter;
+exports.GrpcExceptionFilter = GrpcExceptionFilter = __decorate([
     (0, common_1.Catch)()
 ], GrpcExceptionFilter);
-exports.GrpcExceptionFilter = GrpcExceptionFilter;

package/functions/amqp-call-manager.function.js

@@ -25,6 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AmqpManagement = void 0;
 const msa_logger_1 = __importStar(require("@yolo-croket-dev/msa-logger"));
+const rmq_diagnostics_function_1 = require("./rmq-diagnostics.function");
 const _1 = require(".");
 const msaLogger = new msa_logger_1.default(msa_logger_1.ServerTypeEnum.SERVICE);
 class AmqpManagement {
@@ -44,7 +45,9 @@ class AmqpManagement {
         }
         return param;
     }
-    async call(funcName, messagePattern, payload, argParam, options, file) {
+    async call(funcName, messagePattern, payload, argParam, options, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    file) {
         const param = this.paramProcessor(argParam || {
             traceId: (0, _1.generateTraceId)(),
             isInternal: true,
@@ -58,7 +61,9 @@ class AmqpManagement {
             return result.data;
         }
         catch (err) {
-            msaLogger.warn(`ThrowWrapppingCall[${funcName}] error: traceId=${param.traceId}`, { traceId: param.traceId }, { param });
+            if (!(0, rmq_diagnostics_function_1.getRmqDiagnosticSnapshot)(this.client) && !(0, rmq_diagnostics_function_1.isRmqDiagnosticsEnabled)()) {
+                msaLogger.warn(`ThrowWrapppingCall[${funcName}] error: traceId=${param.traceId}`, { traceId: param.traceId }, { param });
+            }
             if (options && options.isErrorThrowing) {
                 throw err;
             }

package/functions/amqp-handler.function.js

@@ -1,10 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AmqpHandler = exports.HttpExceptionCustom = void 0;
+/* eslint-disable max-len */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const microservices_1 = require("@nestjs/microservices");
 const common_1 = require("@nestjs/common");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const msa_logger_1 = require("@yolo-croket-dev/msa-logger");
+const rmq_diagnostics_function_1 = require("./rmq-diagnostics.function");
 const _1 = require(".");
 const DEFAULT_TIMEOUT = 1000 * 60 * 29; // 29분 타임아웃
 const DEFAULT_TIMEOUT_MESSAGE = '요청이 타임아웃되었습니다.';
@@ -17,11 +21,31 @@ class HttpExceptionCustom extends common_1.HttpException {
     }
 }
 exports.HttpExceptionCustom = HttpExceptionCustom;
+function resolveAmqpTimeout(timeoutMs) {
+    if (typeof timeoutMs !== 'number' || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        return DEFAULT_TIMEOUT;
+    }
+    return Math.min(timeoutMs, DEFAULT_TIMEOUT);
+}
+function getLegacyRmqQueue(client) {
+    if (!(client instanceof microservices_1.ClientRMQ))
+        return undefined;
+    try {
+        const queue = Reflect.get(Reflect.get(client, 'options'), 'queue');
+        return typeof queue === 'string' ? (0, msa_logger_1.sanitizeDiagnosticText)(queue).slice(0, 240) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 async function AmqpHandler(client, messagePattern, payload) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e;
     let data;
+    const timeoutMs = resolveAmqpTimeout((_a = payload === null || payload === void 0 ? void 0 : payload.param) === null || _a === void 0 ? void 0 : _a.timeout);
+    const startedAt = Date.now();
+    const startConnection = (0, rmq_diagnostics_function_1.getRmqDiagnosticSnapshot)(client);
     try {
-        data = await (0, rxjs_1.lastValueFrom)(client.send(messagePattern, payload).pipe((0, operators_1.timeout)(DEFAULT_TIMEOUT)));
+        data = await (0, rxjs_1.lastValueFrom)(client.send(messagePattern, payload).pipe((0, operators_1.timeout)(timeoutMs)));
         if (data.isError) {
             const status = data.status || 500;
             const subMessage = data.subMessage;
@@ -29,7 +53,7 @@ async function AmqpHandler(client, messagePattern, payload) {
              * 파일 객체 처리
              * 다른 서비스에서 이미 처리가 될 수 있음
              * */
-            (0, _1.reWriteFileValue)((_a = data === null || data === void 0 ? void 0 : data.arg) === null || _a === void 0 ? void 0 : _a.file);
+            (0, _1.reWriteFileValue)((_b = data === null || data === void 0 ? void 0 : data.arg) === null || _b === void 0 ? void 0 : _b.file);
             const errInfo = data.errInfo ? data.errInfo : {
                 message: data.errMessage,
                 type: data.errType,
@@ -48,36 +72,67 @@ async function AmqpHandler(client, messagePattern, payload) {
         }
     }
     catch (err) {
+        const normalized = (startConnection || (0, rmq_diagnostics_function_1.isRmqDiagnosticsEnabled)())
+            ? (0, msa_logger_1.normalizeDiagnosticError)(err, err instanceof HttpExceptionCustom ? 'service_error' : undefined) : undefined;
+        const diagnosticInfo = normalized ? {
+            ...normalized.diagnosticInfo,
+            ...(0, rmq_diagnostics_function_1.getRmqDiagnosticSnapshot)(client),
+            ...(startConnection ? {} : {
+                direction: 'client',
+                connectionState: 'unobserved',
+                targetService: getLegacyRmqQueue(client),
+            }),
+            event: 'call_failed',
+            messagePattern: (0, msa_logger_1.sanitizeDiagnosticText)(messagePattern).slice(0, 240),
+            elapsedMs: Date.now() - startedAt,
+            timeoutMs,
+            startGeneration: startConnection === null || startConnection === void 0 ? void 0 : startConnection.generation,
+            startConnectionState: startConnection === null || startConnection === void 0 ? void 0 : startConnection.connectionState,
+        } : undefined;
+        const details = normalized ? normalized.details : { err };
+        if (normalized)
+            (0, rmq_diagnostics_function_1.recordRmqDiagnosticError)(err, normalized);
         if (typeof err === 'string' && err.includes('There is no matching message handler defined in the remote service.')) {
             msaLogger.error('NOT_EXISTS_MESSAGE_PATTERN', {
-                traceId: ((_b = payload === null || payload === void 0 ? void 0 : payload.param) === null || _b === void 0 ? void 0 : _b.traceId) || '-',
+                traceId: ((_c = payload === null || payload === void 0 ? void 0 : payload.param) === null || _c === void 0 ? void 0 : _c.traceId) || '-',
+                diagnosticInfo,
                 errInfo: {
                     errType: 'NOT_EXISTS_MESSAGE_PATTERN',
                     message: `${messagePattern} 해당 메시지 패턴은 존재하지 않습니다.`,
                     status: 404,
                 },
-            }, { err });
-            throw new HttpExceptionCustom('해당 메시지 패턴은 존재하지 않습니다.', 404, 'There is no matching message handler defined in the remote service.', {
+            }, details);
+            const exception = new HttpExceptionCustom('해당 메시지 패턴은 존재하지 않습니다.', 404, 'There is no matching message handler defined in the remote service.', {
                 type: 'NOT_EXISTS_MESSAGE_PATTERN',
                 message: `${messagePattern} 해당 메시지 패턴은 존재하지 않습니다.`,
             });
+            if (normalized)
+                (0, rmq_diagnostics_function_1.recordRmqDiagnosticError)(exception, normalized);
+            throw exception;
         }
-        else if (err instanceof rxjs_1.TimeoutError || err.message === DEFAULT_TIMEOUT_MESSAGE) {
+        else if (err instanceof rxjs_1.TimeoutError || (err === null || err === void 0 ? void 0 : err.message) === DEFAULT_TIMEOUT_MESSAGE) {
             msaLogger.error('TIMEOUT_ERROR', {
-                traceId: ((_c = payload === null || payload === void 0 ? void 0 : payload.param) === null || _c === void 0 ? void 0 : _c.traceId) || '-',
+                traceId: ((_d = payload === null || payload === void 0 ? void 0 : payload.param) === null || _d === void 0 ? void 0 : _d.traceId) || '-',
+                diagnosticInfo,
                 errInfo: {
                     errType: 'TIMEOUT_ERROR',
                     message: DEFAULT_TIMEOUT_MESSAGE,
                     status: 500,
                 },
-            }, { err });
-            throw new HttpExceptionCustom(DEFAULT_TIMEOUT_MESSAGE, 500, DEFAULT_TIMEOUT_MESSAGE, {
+            }, details);
+            const exception = new HttpExceptionCustom(DEFAULT_TIMEOUT_MESSAGE, 500, DEFAULT_TIMEOUT_MESSAGE, {
                 type: 'TIMEOUT_ERROR',
                 message: DEFAULT_TIMEOUT_MESSAGE,
             });
+            if (normalized)
+                (0, rmq_diagnostics_function_1.recordRmqDiagnosticError)(exception, normalized);
+            throw exception;
         }
         else {
-            msaLogger.warn('AMQP_HANDLER_ERROR', { traceId: ((_d = payload === null || payload === void 0 ? void 0 : payload.param) === null || _d === void 0 ? void 0 : _d.traceId) || '-' }, { err });
+            msaLogger.warn('AMQP_HANDLER_ERROR', {
+                traceId: ((_e = payload === null || payload === void 0 ? void 0 : payload.param) === null || _e === void 0 ? void 0 : _e.traceId) || '-',
+                diagnosticInfo,
+            }, details);
             throw err;
         }
     }

package/functions/grpc-param-metadata.function.d.ts

@@ -1,7 +1,7 @@
 import { Metadata } from '@grpc/grpc-js';
 import { AbstractParam } from '../interfaces';
 export declare const GRPC_PARAM_METADATA_KEY = "param";
-export declare type GrpcParamMetadata = AbstractParam;
+export type GrpcParamMetadata = AbstractParam;
 /**
  * @author jun
  * @description gRPC metadata에 AMQP param 호환 컨텍스트를 저장합니다.

package/functions/index.d.ts

@@ -8,3 +8,4 @@ export * from './extract-redis-url.function';
 export * from './abort';
 export * from './uncaught-exception-handler';
 export * from './unhandled-rejection-handler';
+export * from './rmq-diagnostics.function';

package/functions/index.js

@@ -24,3 +24,4 @@ __exportStar(require("./extract-redis-url.function"), exports);
 __exportStar(require("./abort"), exports);
 __exportStar(require("./uncaught-exception-handler"), exports);
 __exportStar(require("./unhandled-rejection-handler"), exports);
+__exportStar(require("./rmq-diagnostics.function"), exports);

package/functions/rmq-diagnostics.function.d.ts

@@ -0,0 +1,89 @@
+/// <reference types="node" />
+import { EventEmitter } from 'node:events';
+import { ClientRMQ, RmqOptions } from '@nestjs/microservices';
+import { DiagnosticInfo, NormalizedDiagnosticError } from '@yolo-croket-dev/msa-logger';
+type RmqConnectionOptions = NonNullable<RmqOptions['options']>;
+type Snapshot = Pick<DiagnosticInfo, 'connectionId' | 'connectionName' | 'direction' | 'targetService' | 'generation' | 'connectionState' | 'stateChangedAt'>;
+type DiagnosticWriter = (info: DiagnosticInfo, details?: NormalizedDiagnosticError['details']) => void;
+/**
+ * @author jun
+ * @description 프로세스의 RMQ 연결 진단 활성 여부를 확인한다.
+ * @process 명시적인 true 값만 활성으로 해석한다.
+ */
+export declare function isRmqDiagnosticsEnabled(): boolean;
+/**
+ * @author jun
+ * @description 전송 동작을 바꾸지 않고 연결 상태와 반복 실패를 기록한다.
+ * @process 연결 이벤트 구독 → 상태 갱신/60초 실패 요약 → 종료 시 listener/timer 정리.
+ */
+export declare class RmqConnectionObserver {
+    private readonly direction;
+    private readonly write;
+    readonly connectionId: `${string}-${string}-${string}-${string}-${string}`;
+    readonly connectionName: string;
+    readonly targetService: string;
+    private generation;
+    private state;
+    private changedAt;
+    private emitter?;
+    private listeners;
+    private timer?;
+    private failed;
+    private repeatCount;
+    private firstOccurredAt?;
+    private lastOccurredAt?;
+    private latestFailure?;
+    constructor(queue: string | undefined, direction: 'client' | 'consumer', configuredName?: string, write?: DiagnosticWriter);
+    snapshot(): Snapshot;
+    private transition;
+    private emit;
+    private flush;
+    private onFailure;
+    observe(emitter: EventEmitter): void;
+    private detach;
+    close(): void;
+}
+/**
+ * @author jun
+ * @description 기존 연결 옵션으로 관찰자를 만든다.
+ * @process 명시적인 broker 연결 이름을 읽고 인스턴스 식별자를 생성한다.
+ */
+export declare function createRmqObserver(options: RmqConnectionOptions, direction: 'client' | 'consumer'): RmqConnectionObserver;
+/**
+ * @author jun
+ * @description 기존 RMQ 옵션에 연결 이름만 추가한다.
+ * @process 원본 옵션과 명시적인 연결 이름을 보존한 복사본을 반환한다.
+ */
+export declare function withRmqConnectionName<T extends RmqConnectionOptions>(options: T, observer: RmqConnectionObserver): T;
+/**
+ * @author jun
+ * @description 클라이언트 또는 consumer 채널을 관찰자와 연결한다.
+ * @process WeakMap에 등록하여 전송 객체 수명 이후 참조를 유지하지 않는다.
+ */
+export declare function registerRmqObservation(owner: object, observer: RmqConnectionObserver): void;
+/**
+ * @author jun
+ * @description 현재 연결 상태의 독립적인 스냅샷을 반환한다.
+ * @process 관찰 대상이 아니면 undefined를 반환한다.
+ */
+export declare function getRmqDiagnosticSnapshot(owner: object): Snapshot | undefined;
+/**
+ * @author jun
+ * @description 이미 기록한 오류 상세를 표시한다.
+ * @process 요청별 호출 정보 없이 오류 메타데이터만 WeakMap에 저장한다.
+ */
+export declare function recordRmqDiagnosticError(error: unknown, diagnostic: NormalizedDiagnosticError): void;
+/**
+ * @author jun
+ * @description 동일 오류의 중복 상세 기록 여부를 확인한다.
+ * @process 객체 오류에 연결된 정규화 결과를 반환한다.
+ */
+export declare function getRecordedRmqDiagnosticError(error: unknown): NormalizedDiagnosticError | undefined;
+/** Same factory/options and lazy connection behavior; observation is opt-in per process. */
+/**
+ * @author jun
+ * @description lazy 연결을 유지하는 RMQ 클라이언트를 생성한다.
+ * @process 진단이 활성화되면 기존 ClientRMQ를 확장하고 그 외에는 기본 factory를 사용한다.
+ */
+export declare function createDiagnosticRmqClient(options: RmqOptions): ClientRMQ;
+export {};

package/functions/rmq-diagnostics.function.js

@@ -0,0 +1,300 @@
+"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.createDiagnosticRmqClient = exports.getRecordedRmqDiagnosticError = exports.recordRmqDiagnosticError = exports.getRmqDiagnosticSnapshot = exports.registerRmqObservation = exports.withRmqConnectionName = exports.createRmqObserver = exports.RmqConnectionObserver = exports.isRmqDiagnosticsEnabled = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_os_1 = __importDefault(require("node:os"));
+const microservices_1 = require("@nestjs/microservices");
+const msa_logger_1 = __importStar(require("@yolo-croket-dev/msa-logger"));
+const observations = new WeakMap();
+const recordedErrors = new WeakMap();
+let logger;
+/**
+ * @author jun
+ * @description 프로세스의 RMQ 연결 진단 활성 여부를 확인한다.
+ * @process 명시적인 true 값만 활성으로 해석한다.
+ */
+function isRmqDiagnosticsEnabled() {
+    return process.env.RMQ_DIAGNOSTICS_ENABLED === 'true';
+}
+exports.isRmqDiagnosticsEnabled = isRmqDiagnosticsEnabled;
+function writeConnectionEvent(info, details) {
+    logger !== null && logger !== void 0 ? logger : (logger = new msa_logger_1.default(msa_logger_1.ServerTypeEnum.SERVICE));
+    const method = info.event === 'connected' || info.event === 'unblocked' ? 'info' : 'warn';
+    logger[method]('RMQ_CONNECTION', {
+        traceId: '-',
+        diagnosticInfo: info,
+    }, details);
+}
+/**
+ * @author jun
+ * @description 전송 동작을 바꾸지 않고 연결 상태와 반복 실패를 기록한다.
+ * @process 연결 이벤트 구독 → 상태 갱신/60초 실패 요약 → 종료 시 listener/timer 정리.
+ */
+class RmqConnectionObserver {
+    constructor(queue, direction, configuredName, write = writeConnectionEvent) {
+        this.direction = direction;
+        this.write = write;
+        this.connectionId = (0, node_crypto_1.randomUUID)();
+        this.generation = 0;
+        this.state = 'not_connected';
+        this.changedAt = new Date().toISOString();
+        this.listeners = [];
+        this.failed = false;
+        this.repeatCount = 0;
+        this.targetService = (0, msa_logger_1.sanitizeDiagnosticText)(queue || 'unknown').slice(0, 240);
+        this.connectionName = (configuredName === null || configuredName === void 0 ? void 0 : configuredName.trim()) ? configuredName
+            : `${process.env.SERVER_NAME || 'unknown'}/${direction}/${queue || 'unknown'}/${node_os_1.default.hostname()}/${this.connectionId}`;
+    }
+    snapshot() {
+        return {
+            connectionId: this.connectionId,
+            connectionName: (0, msa_logger_1.sanitizeDiagnosticText)(this.connectionName).slice(0, 240),
+            direction: this.direction,
+            targetService: this.targetService,
+            generation: this.generation,
+            connectionState: this.state,
+            stateChangedAt: this.changedAt,
+        };
+    }
+    transition(state) {
+        if (this.state !== state) {
+            this.state = state;
+            this.changedAt = new Date().toISOString();
+        }
+    }
+    emit(event, error, extra = {}) {
+        // Diagnostics must not throw into the connection manager's synchronous event dispatch.
+        try {
+            this.write({
+                ...error === null || error === void 0 ? void 0 : error.diagnosticInfo,
+                ...this.snapshot(),
+                event,
+                ...extra,
+            }, error === null || error === void 0 ? void 0 : error.details);
+        }
+        catch { /* The transport remains authoritative if the log sink fails. */ }
+    }
+    flush() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        if (this.repeatCount) {
+            this.emit('connect_failed_summary', this.latestFailure, {
+                repeatCount: this.repeatCount,
+                firstOccurredAt: this.firstOccurredAt,
+                lastOccurredAt: this.lastOccurredAt,
+            });
+        }
+        this.repeatCount = 0;
+        this.latestFailure = undefined;
+        this.firstOccurredAt = undefined;
+        this.lastOccurredAt = undefined;
+    }
+    onFailure(value) {
+        var _a;
+        this.transition('connection_failed');
+        const error = (0, msa_logger_1.normalizeDiagnosticError)(value, 'connection_failed');
+        if (!this.failed) {
+            this.failed = true;
+            this.emit('connect_failed', error);
+            return;
+        }
+        this.repeatCount += 1;
+        this.latestFailure = error;
+        this.lastOccurredAt = new Date().toISOString();
+        (_a = this.firstOccurredAt) !== null && _a !== void 0 ? _a : (this.firstOccurredAt = this.lastOccurredAt);
+        if (!this.timer) {
+            this.timer = setTimeout(() => this.flush(), 60000);
+            this.timer.unref();
+        }
+    }
+    observe(emitter) {
+        if (this.emitter === emitter)
+            return;
+        this.detach();
+        this.emitter = emitter;
+        this.listeners = [
+            [
+                'connect',
+                () => {
+                    this.flush();
+                    this.failed = false;
+                    this.generation += 1;
+                    this.transition('connected');
+                    this.emit('connected');
+                },
+            ],
+            [
+                'connectFailed',
+                value => this.onFailure(value),
+            ],
+            [
+                'disconnect',
+                value => {
+                    this.transition('disconnected');
+                    this.emit('disconnected', (0, msa_logger_1.normalizeDiagnosticError)(value, 'connection_lost'));
+                },
+            ],
+            [
+                'blocked',
+                () => {
+                    this.transition('blocked');
+                    this.emit('blocked');
+                },
+            ],
+            [
+                'unblocked',
+                () => {
+                    this.transition('connected');
+                    this.emit('unblocked');
+                },
+            ],
+        ];
+        this.listeners.forEach(([event, listener,]) => emitter.on(event, listener));
+    }
+    detach() {
+        this.listeners.forEach(([event, listener,]) => { var _a; return (_a = this.emitter) === null || _a === void 0 ? void 0 : _a.removeListener(event, listener); });
+        this.listeners = [];
+        this.emitter = undefined;
+    }
+    close() {
+        this.flush();
+        this.detach();
+        this.failed = false;
+        this.transition('closed');
+    }
+}
+exports.RmqConnectionObserver = RmqConnectionObserver;
+/**
+ * @author jun
+ * @description 기존 연결 옵션으로 관찰자를 만든다.
+ * @process 명시적인 broker 연결 이름을 읽고 인스턴스 식별자를 생성한다.
+ */
+function createRmqObserver(options, direction) {
+    var _a, _b;
+    const properties = (_b = (_a = options.socketOptions) === null || _a === void 0 ? void 0 : _a.connectionOptions) === null || _b === void 0 ? void 0 : _b.clientProperties;
+    const configured = properties && typeof properties === 'object'
+        ? properties.connection_name : undefined;
+    return new RmqConnectionObserver(options.queue, direction, typeof configured === 'string' ? configured : undefined);
+}
+exports.createRmqObserver = createRmqObserver;
+/**
+ * @author jun
+ * @description 기존 RMQ 옵션에 연결 이름만 추가한다.
+ * @process 원본 옵션과 명시적인 연결 이름을 보존한 복사본을 반환한다.
+ */
+function withRmqConnectionName(options, observer) {
+    var _a, _b, _c;
+    return {
+        ...options,
+        socketOptions: {
+            ...options.socketOptions,
+            connectionOptions: {
+                ...(_a = options.socketOptions) === null || _a === void 0 ? void 0 : _a.connectionOptions,
+                clientProperties: {
+                    ...(_c = (_b = options.socketOptions) === null || _b === void 0 ? void 0 : _b.connectionOptions) === null || _c === void 0 ? void 0 : _c.clientProperties,
+                    connection_name: observer.connectionName,
+                },
+            },
+        },
+    };
+}
+exports.withRmqConnectionName = withRmqConnectionName;
+/**
+ * @author jun
+ * @description 클라이언트 또는 consumer 채널을 관찰자와 연결한다.
+ * @process WeakMap에 등록하여 전송 객체 수명 이후 참조를 유지하지 않는다.
+ */
+function registerRmqObservation(owner, observer) {
+    observations.set(owner, observer);
+}
+exports.registerRmqObservation = registerRmqObservation;
+/**
+ * @author jun
+ * @description 현재 연결 상태의 독립적인 스냅샷을 반환한다.
+ * @process 관찰 대상이 아니면 undefined를 반환한다.
+ */
+function getRmqDiagnosticSnapshot(owner) {
+    var _a;
+    return (_a = observations.get(owner)) === null || _a === void 0 ? void 0 : _a.snapshot();
+}
+exports.getRmqDiagnosticSnapshot = getRmqDiagnosticSnapshot;
+// Contains error metadata only, never per-request context: one RMQ error can reject concurrent calls.
+/**
+ * @author jun
+ * @description 이미 기록한 오류 상세를 표시한다.
+ * @process 요청별 호출 정보 없이 오류 메타데이터만 WeakMap에 저장한다.
+ */
+function recordRmqDiagnosticError(error, diagnostic) {
+    if (error !== null && typeof error === 'object')
+        recordedErrors.set(error, diagnostic);
+}
+exports.recordRmqDiagnosticError = recordRmqDiagnosticError;
+/**
+ * @author jun
+ * @description 동일 오류의 중복 상세 기록 여부를 확인한다.
+ * @process 객체 오류에 연결된 정규화 결과를 반환한다.
+ */
+function getRecordedRmqDiagnosticError(error) {
+    return error !== null && typeof error === 'object' ? recordedErrors.get(error) : undefined;
+}
+exports.getRecordedRmqDiagnosticError = getRecordedRmqDiagnosticError;
+class DiagnosticClientRMQ extends microservices_1.ClientRMQ {
+    constructor(options, observation) {
+        super(withRmqConnectionName(options, observation));
+        this.observation = observation;
+        registerRmqObservation(this, observation);
+    }
+    createClient() {
+        const client = super.createClient();
+        this.observation.observe(client);
+        return client;
+    }
+    async close() {
+        try {
+            await super.close();
+        }
+        finally {
+            this.observation.close();
+        }
+    }
+}
+/** Same factory/options and lazy connection behavior; observation is opt-in per process. */
+/**
+ * @author jun
+ * @description lazy 연결을 유지하는 RMQ 클라이언트를 생성한다.
+ * @process 진단이 활성화되면 기존 ClientRMQ를 확장하고 그 외에는 기본 factory를 사용한다.
+ */
+function createDiagnosticRmqClient(options) {
+    if (!isRmqDiagnosticsEnabled())
+        return microservices_1.ClientProxyFactory.create(options);
+    const connectionOptions = options.options || {};
+    return new DiagnosticClientRMQ(connectionOptions, createRmqObserver(connectionOptions, 'client'));
+}
+exports.createDiagnosticRmqClient = createDiagnosticRmqClient;