whatap 1.0.1 → 1.0.2

package/lib/observers/prisma-observer.js

@@ -5,12 +5,31 @@
  */
 
 const TraceContextManager = require("../trace/trace-context-manager");
+const ParsedSql = require("../trace/parsed-sql");
+const SqlStepX = require("../step/sql-stepx");
+const DBCStep = require("../step/dbc-step");
+const ResultSetStep = require("../step/resultset-step");
+const DataTextAgent = require("../data/datatext-agent");
+const StatSql = require("../stat/stat-sql");
+const MeterSql = require("../counter/meter/meter-sql");
 const conf = require("../conf/configure");
+const IntKeyMap = require("../util/intkey-map");
+const EscapeLiteralSQL = require("../util/escape-literal-sql");
 const HashUtil = require("../util/hashutil");
+const StatError = require("../stat/stat-error");
+const TextTypes = require("../lang/text-types");
+const ParamSecurity = require("../util/paramsecurity");
 const Logger = require("../logger");
+const Buffer = require("buffer").Buffer;
+const DateUtil = require("../util/dateutil");
+const TraceSQL = require("../trace/trace-sql");
 const shimmer = require("../core/shimmer");
-const AsyncSender = require('../udp/async_sender');
-const PacketTypeEnum = require('../udp/packet_type_enum');
+
+var prisma_read_func_name = conf.getProperty('prisma_read_func_name', 'read');
+var prisma_database_url_name = conf.getProperty('prisma_database_url_name', 'DATABASE_URL')
+conf.on('prisma_database_url_name', function (newProps) {
+    prisma_database_url_name = newProps;
+})
 
 var PrismaObserver = function(agent) {
     this.agent = agent;
@@ -36,20 +55,40 @@ PrismaObserver.prototype.inject = function(mod, moduleName) {
 
     // Prisma Client 초기화 메서드 후킹
     if (mod.PrismaClient) {
+        // 직접 PrismaClient 생성자 후킹
         shimmer.wrap(mod, 'PrismaClient', function(originalConstructor) {
             return function(...args) {
-                // 원래 생성자 호출
-                const instance = originalConstructor.apply(this, args);
+                const originalInstance = new originalConstructor(...args);
+                const instance = Object.create(originalInstance);
+
+                const prismaServicePrototype = Object.getPrototypeOf(this);
+                Object.getOwnPropertyNames(prismaServicePrototype).forEach((method) => {
+                    if (typeof prismaServicePrototype[method] === "function" && !instance[method]) {
+                        instance[method] = prismaServicePrototype[method].bind(instance);
+                    }
+                });
+
+                Object.getOwnPropertyNames(originalInstance).forEach((prop) => {
+                    if (!instance.hasOwnProperty(prop)) {
+                        instance[prop] = originalInstance[prop];
+                    }
+                });
 
-                // 패치 적용
                 self.patchPrismaInstance(instance);
 
+                if (!instance[prisma_read_func_name]) {
+                    instance[prisma_read_func_name] = function () {
+                        return this;
+                    };
+                }
+
                 return instance;
             };
         });
     }
 };
 
+// 각 Prisma 인스턴스에 패치 적용
 PrismaObserver.prototype.patchPrismaInstance = function(prismaInstance) {
     if (prismaInstance.__whatap_observe__) {
         return;
@@ -57,56 +96,71 @@ PrismaObserver.prototype.patchPrismaInstance = function(prismaInstance) {
     prismaInstance.__whatap_observe__ = true;
 
     this.setupConnectionInfo(prismaInstance);
+
     this.hookUseMiddleware(prismaInstance);
 };
 
+// 연결 정보 설정
 PrismaObserver.prototype.setupConnectionInfo = function(prismaInstance) {
     try {
         // 연결 정보 가져오기 시도
         const url = prismaInstance._engineConfig?.overrideDatasources?.db?.url ||
-            prismaInstance._engineConfig?.datasources?.db?.url ||
-            prismaInstance._baseDmmf?.datamodel?.datasources?.[0]?.url?.value ||
-            process.env.DATABASE_URL ||
+            prismaInstance.env?.DATABASE_URL ||
+            process.env[prisma_database_url_name] ||
             'prisma:unknown';
 
         if (url && url !== "prisma:unknown" && !dbc_hash) {
             const dbUrl = new URL(url);
             const protocol = dbUrl.protocol.replace(':', '');
 
+            // 프로토콜에 따라 접두사 설정 (postgresql -> pgsql로 변환할 수도 있음)
+            const dbProtocol = protocol === 'pgsql' ? 'postgresql' : protocol;
+
             // MySQL 관찰자와 동일한 형식으로 구성
-            dbc = `${protocol}://`;
+            dbc = `${dbProtocol}://`;
             dbc += dbUrl.username || '';
             dbc += "@";
             dbc += dbUrl.hostname || '';
             dbc += '/';
             dbc += dbUrl.pathname.replace('/', '') || '';
             dbc_hash = HashUtil.hashFromString(dbc);
+
+            DataTextAgent.DBC.add(dbc_hash, dbc);
+            DataTextAgent.METHOD.add(dbc_hash, dbc);
+            DataTextAgent.ERROR.add(dbc_hash, dbc);
         }
 
     } catch (e) {
-        Logger.printError("WHATAP-223", "Failed to extract connection info", e, false);
+        Logger.printError("WHATAP-301", "Failed to extract connection info", e, false);
         dbc = "prisma:unknown";
         dbc_hash = HashUtil.hashFromString(dbc);
     }
 };
 
 PrismaObserver.prototype.hookUseMiddleware = function(prismaInstance) {
-    const self = this;
-    
-    if (typeof prismaInstance.$use === 'function') {
+    const originalUse = prismaInstance.$use;
+    if (typeof originalUse === 'function') {
         prismaInstance.$use(async (params, next) => {
+            var result;
             const ctx = TraceContextManager.getCurrentContext();
             if (!ctx) {
                 return next(params);
             }
 
-            // DB 연결 패킷 전송 (mysql2-observer와 동일한 패턴)
-            ctx.start_time = Date.now();
-            ctx.elapsed = 0;
-            AsyncSender.send_packet(PacketTypeEnum.TX_DB_CONN, ctx, [dbc]);
+            var dbc_step = new DBCStep();
+            dbc_hash = HashUtil.hashFromString(dbc);
+            DataTextAgent.DBC.add(dbc_hash, dbc);
+            DataTextAgent.METHOD.add(dbc_hash, dbc);
+            DataTextAgent.ERROR.add(dbc_hash, dbc)
+
+            dbc_step.hash = dbc_hash;
+            dbc_step.start_time = ctx.getElapsedTime();
+            ctx.profile.push(dbc_step);
 
-            // SQL 시작 시간 기록
-            var sql_start_time = Date.now();
+            const sql_step = new SqlStepX();
+            sql_step.start_time = ctx.getElapsedTime();
+            sql_step.elapsed = 0;
+            ctx.profile.push(sql_step);
 
             const modelName = params.model || 'unknown';
             const action = params.action || 'unknown';
@@ -114,21 +168,161 @@ PrismaObserver.prototype.hookUseMiddleware = function(prismaInstance) {
             ctx.footprint(`Prisma ${modelName}.${action} Start`);
             ctx.sql_count = (ctx.sql_count || 0) + 1;
 
-            // 쿼리 정보 생성
+            // Prisma 쿼리 정보 직접 사용 (SQL 변환 없이)
             const queryInfo = `Prisma ${modelName}.${action}`;
+            const queryHash = HashUtil.hashFromString(queryInfo);
+
+            DataTextAgent.SQL.add(queryHash, queryInfo);
+            sql_step.hash = queryHash;
+            sql_step.dbc = dbc_hash;
+
+            ctx.active_sqlhash = sql_step.hash;
+            ctx.active_dbc = sql_step.dbc;
+
+            // 쿼리 파라미터 정보 추출
+            if (conf.profile_sql_param_enabled) {
+                const paramsString = JSON.stringify(params.args || {});
+                sql_step.setTrue(1);
+                var crc = { value: 0 };
+                sql_step.p1 = toParamBytes(paramsString, crc);
+                sql_step.pcrc = crc.value;
+            }
 
-            ctx.active_sqlhash = HashUtil.hashFromString(queryInfo);
-            ctx.active_dbc = dbc_hash;
-
+            if (action === "queryRaw" || action === "executeRaw" || action === "queryRawUnsafe" || action === "executeRawUnsafe") {
+                // SQL 문자열 추출
+                let sqlString = "";
+                if (params.args && params.args.length > 0) {
+                    if (params.args[0] && params.args[0].strings && Array.isArray(params.args[0].strings)) {
+                        sqlString = params.args[0].strings.join('').trim();
+                    } else if (params.args[0] && params.args[0] && Array.isArray(params.args[0])){
+                        sqlString = params.args[0].join('').trim();
+                    } else if (typeof params.args[0] === 'string') {
+                        sqlString = params.args[0];
+                    }
+                }
+
+                // SQL 문자열이 있으면 처리
+                if (sqlString && sqlString.length > 0) {
+                    try {
+                        var psql = escapeLiteral(sqlString);
+                        if (psql != null) {
+                            sql_step.hash = psql.sql;
+                        }
+
+                        // 추가 SQL 정보 처리
+                        var els = new EscapeLiteralSQL(sqlString);
+                        els.process();
+
+                        // SQL 파라미터 처리
+                        if (conf.profile_sql_param_enabled) {
+                            var params = params.args.slice(1);
+                            sql_step.setTrue(1);
+                            var crc = { value: 0 };
+                            sql_step.p1 = toParamBytes(psql.param, crc);
+
+                            if (params && params.length > 0) {
+                                const result = params.map((param) => {
+                                    if (typeof param === 'string') {
+                                        return `'${param}'`;
+                                    }
+                                    return param;
+                                }).toString();
+                                sql_step.p2 = toParamBytes(result, crc);
+                            }
+                            sql_step.pcrc = crc.value;
+                        }
+                    } catch (e) {
+                        Logger.printError("WHATAP-305", "escapeLiteral error", e, false);
+                    }
+                }
+            }
             try {
-                const result = await next(params);
+                result = await next(params);
+
+                // Raw 쿼리 처리
+                if (action === "queryRaw" || action === "executeRaw" || action === "queryRawUnsafe" || action === "executeRawUnsafe") {
+                    // Raw 쿼리 결과셋 처리
+                    if ((action === "queryRaw" || action === "queryRawUnsafe") && result) {
+                        let recordCount = 0;
+
+                        if (Array.isArray(result)) {
+                            recordCount = result.length;
+                        } else if (result && typeof result === "object") {
+                            recordCount = 1;
+                        }
+
+                        if(psql && psql.sql){
+                            const sqlHashToUse = psql.sql;
+
+                            var result_step = new ResultSetStep();
+                            result_step.start_time = ctx.getElapsedTime();
+                            result_step.elapsed = 0;
+                            result_step.fetch = recordCount;
+                            result_step.sqlhash = sqlHashToUse;
+                            result_step.dbc = dbc_hash;
+                            ctx.profile.push(result_step);
+
+                            ctx.rs_count = ctx.rs_count ? ctx.rs_count + recordCount : recordCount;
+                            ctx.rs_time = ctx.rs_time ? ctx.rs_time + sql_step.elapsed : sql_step.elapsed;
+
+                            MeterSql.addFetch(result_step.dbc, result_step.fetch, 0);
+                            StatSql.addFetch(result_step.dbc, result_step.sqlhash, result_step.fetch, 0);
+
+                            TraceSQL.isTooManyRecords(sql_step, result_step.fetch, ctx);
+                        }
+                    }
+                }
+
+                // 결과셋 처리 (findMany, findFirst, findUnique 등)
+                if (["findMany", "findFirst", "findUnique"].includes(action)) {
+                    let recordCount = 0;
+
+                    if (Array.isArray(result)) {
+                        recordCount = result.length;
+                    } else if (result && typeof result === "object") {
+                        recordCount = 1;
+                    }
+
+                    var result_step = new ResultSetStep();
+                    result_step.start_time = ctx.getElapsedTime();
+                    result_step.elapsed = 0;
+                    result_step.fetch = recordCount;
+                    result_step.sqlhash = queryHash;
+                    result_step.dbc = dbc_hash;
+                    ctx.profile.push(result_step);
+
+                    ctx.rs_count = ctx.rs_count ? ctx.rs_count + recordCount : recordCount;
+                    ctx.rs_time = ctx.rs_time ? ctx.rs_time + sql_step.elapsed : sql_step.elapsed;
+
+                    MeterSql.addFetch(result_step.dbc, result_step.fetch, 0);
+                    StatSql.addFetch(result_step.dbc, result_step.sqlhash, result_step.fetch, 0);
+
+                    TraceSQL.isTooManyRecords(sql_step, result_step.fetch, ctx);
+                }
+
+                // 수정된 레코드 수 처리 (create, update, delete 등)
+                if (["create", "createMany", "update", "updateMany", "delete", "deleteMany"].includes(action)) {
+                    if (result && result.count !== undefined) {
+                        sql_step.updated = result.count;
+                    } else if (result && typeof result === "object") {
+                        sql_step.updated = 1;
+                    }
+                }
+
+                // UPSERT 처리 추가
+                if (action === "upsert") {
+                    sql_step.updated = 1; // upsert는 항상 1개의 레코드에 영향을 미침
+                }
+
+                this._finishQuery(ctx, sql_step);
 
-                self._finishQuery(ctx, sql_start_time, result, queryInfo);
                 ctx.footprint(`Prisma ${modelName}.${action} Done`);
 
                 return result;
             } catch (err) {
-                self._handleError(ctx, sql_start_time, err, queryInfo);
+                Logger.printError("WHATAP-308", `Middleware error in ${modelName}.${action}: ${err.message}`, err, false);
+
+                this._handleError(ctx, sql_step, err);
                 ctx.footprint(`Prisma ${modelName}.${action} Error`);
                 throw err;
             }
@@ -136,89 +330,106 @@ PrismaObserver.prototype.hookUseMiddleware = function(prismaInstance) {
     }
 };
 
-PrismaObserver.prototype._finishQuery = function(ctx, sql_start_time, result, queryInfo) {
-    var sql_elapsed = Date.now() - sql_start_time;
-    ctx.sql_time = (ctx.sql_time || 0) + sql_elapsed;
-
-    // 결과 개수 계산
-    let resultCount = 0;
-    if (result) {
-        if (Array.isArray(result)) {
-            resultCount = result.length;
-        } else if (result && typeof result === "object" && result.count !== undefined) {
-            resultCount = result.count;
-        } else if (result && typeof result === "object") {
-            resultCount = 1;
-        }
-    }
+PrismaObserver.prototype._finishQuery = function(ctx, sql_step) {
+    sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+    ctx.sql_time = (ctx.sql_time || 0) + sql_step.elapsed;
+
+    TraceSQL.isSlowSQL(ctx);
 
-    // SQL 패킷 전송 (mysql2-observer와 동일한 패턴)
-    ctx.elapsed = sql_elapsed;
-    ctx.active_sqlhash = false;
-    AsyncSender.send_packet(PacketTypeEnum.TX_SQL, ctx, [dbc, queryInfo, String(resultCount)]);
+    MeterSql.add(dbc_hash, sql_step.elapsed, false);
+    StatSql.addSqlTime(ctx.service_hash, sql_step.dbc, sql_step.hash, sql_step.elapsed, false, 0);
+
+    ctx.footprint("Prisma Query Done");
 };
 
-PrismaObserver.prototype._handleError = function(ctx, sql_start_time, err, queryInfo) {
-    var sql_elapsed = Date.now() - sql_start_time;
-    ctx.sql_time = (ctx.sql_time || 0) + sql_elapsed;
+PrismaObserver.prototype._handleError = function(ctx, sql_step, err) {
+    sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+    ctx.sql_time = (ctx.sql_time || 0) + sql_step.elapsed;
+
+    TraceSQL.isSlowSQL(ctx);
+
+    MeterSql.add(dbc_hash, sql_step.elapsed, true);
+    StatSql.addSqlTime(ctx.service_hash, sql_step.dbc, sql_step.hash, sql_step.elapsed, true, 0);
 
     try {
         const errorClassName = err.name || err.constructor?.name || "UnknownError";
-        const errorMessage = err.message || 'Prisma error';
-        let errorStack = '';
-
         ctx.error_class = errorClassName;
-        ctx.error_message = errorMessage;
-
-        // 스택 트레이스 처리
-        if (conf.trace_sql_error_stack && conf.trace_sql_error_depth && err.stack) {
-            var traceDepth = conf.trace_sql_error_depth;
-            var stackLines = err.stack.split("\n");
+        ctx.error_message = err.message;
+        sql_step.error = StatError.addError(errorClassName, err.message, ctx.service_hash, TextTypes.SQL, sql_step.hash);
 
-            if (stackLines.length > traceDepth) {
-                stackLines = stackLines.slice(0, traceDepth + 1);
-            }
-            errorStack = stackLines.join("\n");
-            ctx.error_message = errorStack;
+        if (ctx.error.isZero()) {
+            ctx.error = sql_step.error;
         }
 
-        // 에러 무시 조건 확인 (mysql2-observer와 동일한 로직)
-        var shouldAddError = false;
-        if (conf._is_trace_ignore_err_cls_contains === true && errorClassName &&
-            errorClassName.indexOf(conf.trace_ignore_err_cls_contains) < 0) {
-            shouldAddError = true;
-        } else if (conf._is_trace_ignore_err_msg_contains === true && errorMessage &&
-            errorMessage.indexOf(conf.trace_ignore_err_msg_contains) < 0) {
-            shouldAddError = true;
-        } else if (conf._is_trace_ignore_err_cls_contains === false &&
-            conf._is_trace_ignore_err_msg_contains === false) {
-            shouldAddError = true;
-        }
-
-        if (shouldAddError) {
-            if(!ctx.error) ctx.error = 1;
-            ctx.status = 500;
-            ctx.errClass = errorClassName;
-            ctx.errMessage = errorMessage;
+        if (conf.trace_sql_error_stack && conf.trace_sql_error_depth) {
+            var traceDepth = conf.trace_sql_error_depth;
+            var errorStack = err.stack.split("\n");
 
-            var errors = [errorClassName];
-            if (errorMessage) {
-                errors.push(errorMessage);
-            }
-            if (errorStack || err.stack) {
-                errors.push(errorStack || err.stack);
+            if (errorStack.length > traceDepth) {
+                errorStack = errorStack.slice(0, traceDepth + 1);
             }
-            AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+            ctx.error_message = errorStack.join("\n");
         }
+    } catch (e) {
+        Logger.printError("WHATAP-309", "Error handling failed", e, false);
+    }
 
-        // SQL 패킷 전송 (에러 발생시에도)
-        ctx.elapsed = sql_elapsed;
-        ctx.active_sqlhash = false;
-        AsyncSender.send_packet(PacketTypeEnum.TX_SQL, ctx, [dbc, queryInfo, "0"]);
+    ctx.footprint("Prisma Query Error");
+};
 
+var toParamBytes = function(p, crc) {
+    if (p == null || p.length === 0) {
+        return null;
+    }
+    try {
+        return ParamSecurity.encrypt(Buffer.from(p, "utf8"), crc);
     } catch (e) {
-        Logger.printError("WHATAP-224", "Error handling failed", e, false);
+        return null;
     }
 };
 
+var checkedSql = new IntKeyMap(2000).setMax(2000);
+var nonLiteSql = new IntKeyMap(5000).setMax(5000);
+var date = DateUtil.yyyymmdd();
+
+function escapeLiteral(sql) {
+    if (sql == null) {
+        sql = "";
+    }
+
+    if (date !== DateUtil.yyyymmdd()) {
+        checkedSql.clear();
+        nonLiteSql.clear();
+        date = DateUtil.yyyymmdd();
+        Logger.print("WHATAP-SQL-CLEAR", "PrismaObserver CLEAR OK!!!!!!!!!!!!!!!!", false);
+    }
+
+    var sqlHash = HashUtil.hashFromString(sql);
+    var psql = nonLiteSql.get(sqlHash);
+
+    if (psql != null) {
+        return psql;
+    }
+    psql = checkedSql.get(sqlHash);
+
+    if (psql != null) {
+        return psql;
+    }
+
+    var els = new EscapeLiteralSQL(sql);
+    els.process();
+
+    var hash = HashUtil.hashFromString(els.getParsedSql());
+    DataTextAgent.SQL.add(hash, els.getParsedSql());
+
+    if (hash === sqlHash) {
+        psql = new ParsedSql(els.sqlType, hash, null);
+        nonLiteSql.put(sqlHash, psql);
+    } else {
+        psql = new ParsedSql(els.sqlType, hash, els.getParameter());
+        checkedSql.put(sqlHash, psql);
+    }
+    return psql;
+}
+
 exports.PrismaObserver = PrismaObserver;

package/lib/observers/process-observer.js

@@ -6,26 +6,28 @@
 
 const TraceContextManager = require('../trace/trace-context-manager');
 const conf = require('../conf/configure');
-const AsyncSender = require('../udp/async_sender');
-const DataOuputX = require('../io/data-outputx');
-const SecurityMaster = require('../net/security-master');
-const LogSinkPack = require('../pack/log-sink-pack');
+const LogTracer = require('../logsink/log-tracer');
+const Logger = require('../logger');
 
 let logsink_enabled = conf.getProperty('logsink_enabled', false);
+let logTracer = logsink_enabled ? new LogTracer() : null;
 
-conf.on('logsink_enabled', function(newProperty) {
+conf.on('logsink_enabled', function (newProperty) {
     logsink_enabled = newProperty;
+    logTracer = logsink_enabled ? new LogTracer() : null;
 });
 
 const ProcessObserver = function (agent) {
     this.agent = agent;
     this.packages = ['process'];
+    this.exitHandlersRegistered = false;
 };
 
 ProcessObserver.prototype.inject = function (mod, moduleName) {
     this._hookNextTick(mod);
     this._hookStdOutWrite();
     this._hookStdErrWrite();
+    this._hookProcessExit(mod);
 };
 
 ProcessObserver.prototype._hookNextTick = function (mod) {
@@ -39,26 +41,6 @@ ProcessObserver.prototype._hookNextTick = function (mod) {
     });
 };
 
-ProcessObserver.prototype._sendLogPack = function (content, category) {
-    const ctx = TraceContextManager.getCurrentContext();
-    const tags = ctx && ctx.id ? {'@txid': ctx.id.toString()} : {};
-
-    const fields = {"filename": null};
-
-    const p = new LogSinkPack();
-    p.Category = category;
-    p.time = Date.now();
-    p.line = Date.now();
-    p.content = content;
-
-    p.pcode = SecurityMaster.PCODE;
-    const bout = new DataOuputX();
-    bout.writePack(p, null);
-    const packbytes = bout.toByteArray();
-
-    AsyncSender.send_relaypack(packbytes);
-};
-
 ProcessObserver.prototype._hookStdOutWrite = function () {
     this.agent.aop.after(process.stdout, 'write', (obj, args) => {
         if (conf.getProperty('logsink_enabled', false) && args[0]) {
@@ -67,12 +49,9 @@ ProcessObserver.prototype._hookStdOutWrite = function () {
                 const parsedContent = JSON.parse(content);
                 content = parsedContent.message ? parsedContent.message : JSON.stringify(parsedContent);
             } catch (e) {
-                // JSON 파싱 실패 시 원본 content 사용
             }
-
-            if (content && content.trim()) {
-                const category = conf.getProperty('logsink_category_stdout', 'AppStdOut');
-                this._sendLogPack(content, category);
+            if (logTracer && content) {
+                logTracer.addStdWrite(content, conf.logsink_category_stdout);
             }
         }
     });
@@ -86,15 +65,80 @@ ProcessObserver.prototype._hookStdErrWrite = function () {
                 const parsedContent = JSON.parse(content);
                 content = parsedContent.message ? parsedContent.message : JSON.stringify(parsedContent);
             } catch (e) {
-                // JSON 파싱 실패 시 원본 content 사용
             }
-
-            if (content && content.trim()) {
-                const category = conf.getProperty('logsink_category_stderr', 'AppStdErr');
-                this._sendLogPack(content, category);
+            if (logTracer && content) {
+                logTracer.addStdWrite(content, conf.logsink_category_stderr);
             }
         }
     });
 };
 
+ProcessObserver.prototype._hookProcessExit = function (mod) {
+    if (this.exitHandlersRegistered) {
+        Logger.print("WHATAP-901", "[ProcessObserver] Exit handlers already registered, skipping...", false)
+        return;
+    }
+    const self = this;
+
+    // SIGTERM (graceful shutdown)
+    process.on('SIGTERM', function () {
+        const message = 'Process termination requested by system or process manager (SIGTERM) - Usually from service stop or container shutdown';
+        Logger.print('WHATAP-902', message, false);
+        setTimeout(() => process.exit(0), 100);
+    });
+
+    // SIGINT (Ctrl+C)
+    process.on('SIGINT', function () {
+        const message = 'Process interrupted by user (SIGINT) - Typically Ctrl+C or kill command';
+        Logger.print('WHATAP-903', message, false);
+        setTimeout(() => process.exit(0), 100);
+    });
+
+    // SIGHUP (hang up)
+    process.on('SIGHUP', function () {
+        const message = 'Process hangup signal received (SIGHUP) - Terminal disconnection or parent process terminated';
+        Logger.print('WHATAP-904', message, false);
+        setTimeout(() => process.exit(0), 100);
+    });
+
+    // SIGUSR1 (user-defined signal 1)
+    process.on('SIGUSR1', function () {
+        const message = 'User-defined signal 1 received (SIGUSR1) - Custom application signal';
+        Logger.print('WHATAP-905', message, false);
+        setTimeout(() => process.exit(0), 100);
+    });
+
+    // SIGUSR2 (user-defined signal 2)
+    process.on('SIGUSR2', function () {
+        const message = 'User-defined signal 2 received (SIGUSR2) - Custom application signal';
+        Logger.print('WHATAP-906', message, false);
+        setTimeout(() => process.exit(0), 100);
+    });
+
+    // 처리되지 않은 예외
+    // process.on('uncaughtException', function (err) {
+    //     const message = `Unhandled exception caused process crash - Error: ${err.message}, File: ${err.stack ? err.stack.split('\n')[1] || 'unknown' : 'unknown'}`;
+    //     Logger.print('WHATAP-907', message, err, false);
+    //
+    //     // 로그 남긴 후 프로세스 종료
+    //     setTimeout(() => {
+    //         process.exit(1);
+    //     }, 100);
+    // });
+    //
+    // // 처리되지 않은 Promise rejection
+    // process.on('unhandledRejection', function (reason, promise) {
+    //     const message = `Unhandled Promise rejection may cause process termination - Reason: ${reason instanceof Error ? reason.message : String(reason)}`;
+    //     const err = reason instanceof Error ? reason : new Error(String(reason));
+    //     Logger.print('WHATAP-908', message, err, false);
+    //
+    //     // 로그 남긴 후 프로세스 종료
+    //     setTimeout(() => {
+    //         process.exit(1);
+    //     }, 100);
+    // });
+
+    this.exitHandlersRegistered = true;
+};
+
 module.exports.ProcessObserver = ProcessObserver;