whatap 1.0.1 → 1.0.2

package/lib/observers/mysql2-observer.js

@@ -6,17 +6,24 @@
 
 var TraceContextManager = require('../trace/trace-context-manager'),
     ParsedSql = require('../trace/parsed-sql'),
+    SqlStepX = require('../step/sql-stepx'),
+    DBCStep = require('../step/dbc-step'),
+    ResultSetStep = require('../step/resultset-step'),
+    DataTextAgent = require('../data/datatext-agent'),
+    StatSql = require('../stat/stat-sql'),
+    MeterSql = require('../counter/meter/meter-sql'),
     conf = require('../conf/configure'),
     IntKeyMap = require('../util/intkey-map'),
     EscapeLiteralSQL = require('../util/escape-literal-sql'),
     HashUtil = require('../util/hashutil'),
+    StatError = require('../stat/stat-error'),
+    TextTypes = require('../lang/text-types'),
+    ParamSecurity = require('../util/paramsecurity'),
     Logger = require('../logger'),
     DateUtil = require('../util/dateutil'),
-    AsyncSender = require('../udp/async_sender'),
-    PacketTypeEnum = require('../udp/packet_type_enum'),
-    shimmer = require('../core/shimmer'),
-    TraceSQL = require('../trace/trace-sql');
-const { AsyncResource } = require('async_hooks');
+    Buffer = require('buffer').Buffer,
+    TraceSQL = require('../trace/trace-sql'),
+    shimmer = require('../core/shimmer');
 
 var Mysql2Observer = function (agent) {
     this.agent = agent;
@@ -26,25 +33,12 @@ var Mysql2Observer = function (agent) {
 var dbc_hash = 0;
 var dbc = 'mysql://';
 
-// 후킹된 객체 인스턴스들을 추적 (중복 방지)
+// 전역으로 후킹된 함수들을 추적
+var globalHookedFunctions = new WeakSet();
+// 후킹된 객체 인스턴스들을 추적 (중복 방지 강화)
 var hookedInstances = new WeakSet();
 
-// formatSqlWithParams 함수 개선 - mod를 직접 받아서 사용
-function formatSqlWithParams(sql, params, mod) {
-    try {
-        if (mod && mod.format && typeof mod.format === 'function') {
-            return mod.format(sql, params);
-        }
-        // fallback: 동적으로 require (성능상 권장하지 않음)
-        var mysql = require('mysql2');
-        return mysql.format(sql, params);
-    } catch (e) {
-        return sql;
-    }
-}
-
-// 쿼리 래핑 함수 (AsyncResource.bind 적용)
-var createQueryWrapper = function(isPromise = false, dbcUrl, mod) {
+var createQueryWrapper = function(isPromise = false) {
     return function(original) {
         return function wrappedQuery() {
             var args = Array.prototype.slice.call(arguments);
@@ -52,15 +46,12 @@ var createQueryWrapper = function(isPromise = false, dbcUrl, mod) {
 
             // ctx가 없으면 추적하지 않고 원본 함수만 실행
             if (ctx == null || args[0] == null) {
-                return original.apply(this, arguments);
+                return original.apply(this, args);
             }
             if (args[0].sql == null && typeof args[0] != 'string') {
-                return original.apply(this, arguments);
+                return original.apply(this, args);
             }
 
-            // AsyncResource 생성
-            var asyncResource = new AsyncResource('mysql2-query');
-
             // 동시 쿼리 처리를 위한 고유 ID 생성
             var queryId = Date.now() + '-' + Math.random().toString(36).substr(2, 9);
 
@@ -69,123 +60,181 @@ var createQueryWrapper = function(isPromise = false, dbcUrl, mod) {
                 ctx._processing_queries = new Set();
             }
 
-            // SQL과 파라미터 추출
-            var sql = args.length > 0 ? args[0] : undefined;
-            var params = args.length > 1 && Array.isArray(args[1]) ? args[1] : undefined;
-
-            if (typeof sql !== 'string') {
-                sql = args[0].sql || undefined;
-                if (args[0].values && Array.isArray(args[0].values)) {
-                    params = args[0].values;
-                }
-            }
-
-            // 최종 SQL 생성 (파라미터 바인딩) - mod 직접 전달
-            var finalSql = sql;
-            if (typeof sql === 'string' && sql.length > 0 && params && params.length > 0) {
-                try {
-                    finalSql = formatSqlWithParams(sql, params, mod);
-                } catch (e) {
-                    Logger.printError('WHATAP-SQL-BINDING', 'Error binding parameters', e, false);
-                    finalSql = sql; // 바인딩 실패 시 원본 사용
-                }
-            }
-
-            // 같은 최종 SQL이 동시에 처리되고 있는지 확인
-            if (finalSql && ctx._processing_queries.has(finalSql)) {
+            // 같은 SQL이 동시에 처리되고 있는지 확인
+            var sqlKey = typeof args[0] === 'string' ? args[0] : (args[0] && args[0].sql);
+            if (sqlKey && ctx._processing_queries.has(sqlKey)) {
                 return original.apply(this, args);
             }
 
-            if (finalSql) {
-                ctx._processing_queries.add(finalSql);
+            if (sqlKey) {
+                ctx._processing_queries.add(sqlKey);
             }
 
-            // HTTP Observer 패턴을 따라 시작 시간 설정
-            ctx.start_time = Date.now();
+            var dbc_step = new DBCStep();
+            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);
 
-            // DB 연결 패킷 전송 (elapsed = 0으로 설정)
-            ctx.elapsed = 0;
-            AsyncSender.send_packet(PacketTypeEnum.TX_DB_CONN, ctx, [dbcUrl]);
+            var sql_step = new SqlStepX();
+            sql_step.queryId = queryId;
+            sql_step.start_time = ctx.getElapsedTime();
+            ctx.profile.push(sql_step);
 
-            // SQL 시작 시간 기록
-            var sql_start_time = Date.now();
             ctx.footprint('MySql2 Query Start [' + queryId + ']');
             ctx.sql_count++;
 
-            var psql = null;
-            if (typeof finalSql === 'string' && finalSql.length > 0) {
+            var sql = args.length > 0 ? args[0] : undefined,
+                psql = null;
+
+            if (typeof sql !== 'string') {
+                sql = args[0].sql || undefined;
+            }
+
+            if (typeof sql === 'string' && sql.length > 0) {
                 try {
-                    psql = escapeLiteral(finalSql);
-                    Logger.print('WHATAP-SQL-DEBUG', 'Processing SQL [' + queryId + ']: ' + finalSql.substring(0, 200), false);
+                    psql = escapeLiteral(sql);
+                    Logger.print('WHATAP-SQL-DEBUG', 'Processing SQL [' + queryId + ']: ' + sql.substring(0, 100), false);
                 } catch (e) {
-                    Logger.printError('WHATAP-225', 'Mysql2Observer escapeliteral error', e, false);
+                    Logger.printError('WHATAP-191', 'Mysql2Observer escapeliteral error', e, false);
                 }
             } else {
-                finalSql = '';
-                psql = escapeLiteral(finalSql);
+                sql = '';
+                psql = escapeLiteral(sql);
             }
 
-            var sqlHash = psql ? psql.sql : 0;
-            ctx.active_sqlhash = true;
-            ctx.active_dbc = dbc_hash;
+            if (psql != null) {
+                sql_step.hash = psql.sql;
+            }
+            sql_step.dbc = dbc_hash;
 
-            // AsyncResource로 바인딩된 쿼리 콜백 생성
-            function createBoundQueryCallback() {
-                function queryCallback(err, results, fields) {
-                    var currentCtx = TraceContextManager.getCurrentContext();
+            var els = new EscapeLiteralSQL(sql);
+            els.process();
 
-                    // bind된 함수에서도 context가 없는 경우 복원
-                    if (currentCtx == null) {
-                        TraceContextManager.resume(ctx.id);
-                        currentCtx = ctx;
-                    }
+            // Context 활성 상태를 배열로 관리 (여러 쿼리 동시 처리)
+            if (!ctx.active_queries) {
+                ctx.active_queries = [];
+            }
+            ctx.active_queries.push({
+                sqlhash: sql_step.hash,
+                dbc: sql_step.dbc,
+                queryId: queryId
+            });
+
+            // 백워드 호환성을 위해 마지막 쿼리 정보 유지
+            ctx.active_sqlhash = sql_step.hash;
+            ctx.active_dbc = sql_step.dbc;
+
+            if (conf.profile_sql_param_enabled) {
+                var params = args.length > 1 && Array.isArray(args[1]) ? args[1] : undefined;
+                sql_step.setTrue(1);
+                var crc = {value: 0};
+                sql_step.p1 = toParamBytes(psql.param, crc);
+                if (params != undefined) {
+                    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;
+            }
 
-                    if (currentCtx == null) {
-                        return;
-                    }
+            // 원본 MySQL Observer의 queryCallback 함수를 참고한 결과 처리 함수
+            function queryCallback(obj, args) {
+                if (ctx == null) {
+                    return;
+                }
 
-                    // 처리 완료된 쿼리를 목록에서 제거
-                    if (finalSql && currentCtx._processing_queries) {
-                        currentCtx._processing_queries.delete(finalSql);
-                    }
+                // 처리 완료된 쿼리를 목록에서 제거
+                if (sqlKey && ctx._processing_queries) {
+                    ctx._processing_queries.delete(sqlKey);
+                }
 
-                    var sql_elapsed = Date.now() - sql_start_time;
-                    var resultCount = 0;
+                // 활성 쿼리 목록에서 현재 쿼리 제거
+                if (ctx.active_queries) {
+                    ctx.active_queries = ctx.active_queries.filter(q => q.queryId !== queryId);
+                }
 
-                    if (err) {
-                        handleSqlError(currentCtx, err, sqlHash);
-                    }
+                TraceContextManager.resume(ctx._id);
 
-                    // 결과 개수 계산
-                    if (!err && results) {
-                        if (Array.isArray(results)) {
-                            resultCount = results.length;
-                        } else if (results.affectedRows !== undefined) {
-                            resultCount = results.affectedRows;
-                        } else if (results.changedRows !== undefined) {
-                            resultCount = results.changedRows;
+                // 에러 처리 (args[0]이 에러 객체)
+                if (args[0]) {
+                    try {
+                        if (conf.trace_sql_error_stack && conf.trace_sql_error_depth) {
+                            var traceDepth = conf.trace_sql_error_depth;
+                            var errorStack = args[0].stack ? args[0].stack.split("\n") : [];
+                            if (errorStack.length > traceDepth) {
+                                errorStack = errorStack.slice(0, traceDepth + 1);
+                            }
+                            ctx.error_message = errorStack.join("\n");
+                            sql_step.error = ctx.error = StatError.addError('mysql2-' + (args[0].code || 'UNKNOWN'),
+                                args[0].sqlMessage || args[0].message, ctx.service_hash, TextTypes.SQL, sql_step.hash);
                         }
-                    }
 
-                    // TraceSQL 처리
-                    try {
-                        TraceSQL.isSlowSQL(currentCtx);
+                        // 에러 무시 설정 확인
+                        var shouldAddError = false;
+                        if (conf._is_trace_ignore_err_cls_contains === true && args[0].code &&
+                            args[0].code.indexOf(conf.trace_ignore_err_cls_contains) < 0) {
+                            shouldAddError = true;
+                        } else if (conf._is_trace_ignore_err_msg_contains === true && args[0].message &&
+                            args[0].message.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;
+                        }
 
-                        // ResultSet 처리 (SELECT 쿼리)
-                        if (!err && results && psql && psql.type === 'S') {
-                            TraceSQL.isTooManyRecords(resultCount, currentCtx);
+                        if (shouldAddError) {
+                            sql_step.error = StatError.addError('mysql2-' + (args[0].code || 'UNKNOWN'),
+                                args[0].message || 'mysql2 error', ctx.service_hash, TextTypes.SQL, sql_step.hash);
+                            if (ctx.error.isZero()) {
+                                ctx.error = sql_step.error;
+                            }
                         }
                     } catch (e) {
-                        Logger.printError('WHATAP-TRACESQL', 'Error in TraceSQL processing', e, false);
+                        Logger.printError('WHATAP-192', 'Error handling MySQL2 error', e, false);
                     }
+                }
 
-                    currentCtx.elapsed = sql_elapsed;
-                    currentCtx.active_sqlhash = false;
-                    AsyncSender.send_packet(PacketTypeEnum.TX_SQL, currentCtx, [dbcUrl, finalSql, String(resultCount)]);
+                sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+                ctx.sql_time += sql_step.elapsed;
+
+                // 핵심 통계 수집 로직
+                TraceSQL.isSlowSQL(ctx);
+                ctx.footprint('MySql2 Query Done [' + queryId + ']');
+
+                MeterSql.add(dbc_hash, sql_step.elapsed, args[0] != null);
+                StatSql.addSqlTime(ctx.service_hash, sql_step.dbc,
+                    sql_step.hash, sql_step.elapsed, args[0] != null, 0);
+
+                // 결과 집합 처리 (SELECT 쿼리) - args[1]이 결과 배열
+                if (Array.isArray(args[1]) && psql != null && psql.type === 'S') {
+                    var result_step = new ResultSetStep();
+                    result_step.start_time = ctx.getElapsedTime();
+                    result_step.elapsed = 0;
+                    result_step.fetch = args[1].length;
+                    result_step.sqlhash = psql.sql;
+                    result_step.dbc = dbc_hash;
+                    ctx.profile.push(result_step);
+
+                    ctx.rs_count = ctx.rs_count ? ctx.rs_count + args[1].length : args[1].length;
+                    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);
                 }
 
-                // AsyncResource로 바인딩하여 안전한 context 보장
-                return asyncResource.bind(queryCallback);
+                // UPDATE/INSERT 쿼리 처리
+                if (args[1] != null && args[1].affectedRows != null && psql != null && psql.type === 'U') {
+                    sql_step.updated = args[1].affectedRows || 0;
+                }
             }
 
             // Promise 기반 처리 (mysql2/promise)
@@ -194,142 +243,119 @@ var createQueryWrapper = function(isPromise = false, dbcUrl, mod) {
 
                 // Promise 체인 처리
                 if (result && typeof result.then === 'function') {
-                    var boundCallback = createBoundQueryCallback();
-
                     return result.then(function(queryResult) {
                         // MySQL2 Promise 결과는 [rows, fields] 형태
                         var rows = Array.isArray(queryResult) ? queryResult[0] : queryResult;
                         var fields = Array.isArray(queryResult) ? queryResult[1] : null;
 
-                        // 바인딩된 콜백 호출
-                        boundCallback(null, rows, fields);
+                        // queryCallback 형태로 변환하여 호출
+                        queryCallback(null, [null, rows, fields]);
                         return queryResult;
                     }).catch(function(error) {
-                        // 에러 시 바인딩된 콜백 호출
-                        boundCallback(error, null, null);
+                        // 에러 시 처리
+                        queryCallback(null, [error, null]);
                         throw error;
                     });
                 }
                 return result;
             }
 
-            // 콜백 기반 처리 (일반 mysql2)
-            var callbackWrapped = false;
-            var boundCallback = createBoundQueryCallback();
+            // 콜백 기반 처리 (일반 mysql2) - 원본 MysqlObserver 방식 적용
+            var lastCallback = false;
 
+            // 원본 MysqlObserver의 functionHook 방식을 모방
             // 마지막 인자에서 함수를 찾아서 후킹
-            for (var i = args.length - 1; i >= 0; i--) {
-                if (typeof args[i] === 'function') {
-                    var originalCallback = args[i];
-                    args[i] = function() {
-                        var callbackArgs = Array.prototype.slice.call(arguments);
-                        try {
-                            // 바인딩된 콜백 먼저 실행
-                            boundCallback(callbackArgs[0], callbackArgs[1], callbackArgs[2]);
-                        } catch (e) {
-                            Logger.printError('WHATAP-CALLBACK', 'Error in callback hook', e, false);
-                        }
-                        // 원본 콜백 실행
-                        if (originalCallback && typeof originalCallback === 'function') {
-                            return originalCallback.apply(this, callbackArgs);
-                        }
-                    };
-                    callbackWrapped = true;
-                    break;
-                }
-            }
+            lastCallback = hookLastFunction(args, queryCallback);
 
-            if (!callbackWrapped && args.length > 0 && args[0]._callback) {
+            // functionHook이 실패한 경우 _callback 속성 확인 (원본 코드 참조)
+            if (lastCallback === false && args.length > 0 && args[0]._callback) {
                 try {
+                    // _callback 속성이 있는 경우 직접 후킹
                     var originalCallback = args[0]._callback;
                     args[0]._callback = function() {
                         var callbackArgs = Array.prototype.slice.call(arguments);
                         try {
-                            boundCallback(callbackArgs[0], callbackArgs[1], callbackArgs[2]);
+                            queryCallback(this, callbackArgs);
                         } catch (e) {
                             Logger.printError('WHATAP-CALLBACK', 'Error in _callback hook', e, false);
                         }
+                        // 원본 콜백 실행
                         if (originalCallback && typeof originalCallback === 'function') {
                             return originalCallback.apply(this, callbackArgs);
                         }
                     };
-                    callbackWrapped = true;
+                    lastCallback = true;
                 } catch (e) {
                     Logger.printError('WHATAP-CALLBACK-HOOK', 'Error hooking _callback', e, false);
                 }
             }
 
+            // 수정된 args로 원본 함수 실행
             try {
                 return original.apply(this, args);
             } catch (queryError) {
-                boundCallback(queryError, null, null);
+                // 쿼리 실행 중 에러 발생 시 즉시 처리
+                queryCallback(null, [queryError, null]);
                 throw queryError;
             }
         };
     };
 };
 
-function handleSqlError(ctx, err, sqlHash) {
-    if (!err) return;
+/**
+ * 원본 MySQL Observer의 functionHook을 모방한 함수
+ * 마지막 함수 인자를 찾아서 콜백으로 후킹
+ */
+function hookLastFunction(args, callback) {
+    if (!args || args.length === 0) {
+        return false;
+    }
 
-    try {
-        var errorClass = err.code || err.name || err.constructor?.name || 'MySQLError';
-        var errorMessage = err.message || err.sqlMessage || 'mysql2 error';
-        var errorStack = '';
-
-        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");
-            if (stackLines.length > traceDepth) {
-                stackLines = stackLines.slice(0, traceDepth + 1);
-            }
-            errorStack = stackLines.join("\n");
-            ctx.error_message = errorStack;
-        }
+    // 뒤에서부터 함수를 찾음
+    for (var i = args.length - 1; i >= 0; i--) {
+        if (typeof args[i] === 'function') {
+            var originalFunction = args[i];
 
-        var shouldAddError = false;
-        if (conf._is_trace_ignore_err_cls_contains === true && errorClass &&
-            errorClass.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;
-        }
+            // 함수를 래핑
+            args[i] = function() {
+                var functionArgs = Array.prototype.slice.call(arguments);
 
-        if (shouldAddError) {
-            if(!ctx.error) ctx.error = 1;
-            ctx.status = 500;
-            ctx.error_message = errorMessage;
-            ctx.errClass = errorClass;
-            ctx.errMessage = errorMessage;
+                try {
+                    // WHATAP 콜백 먼저 실행
+                    callback(this, functionArgs);
+                } catch (e) {
+                    Logger.printError('WHATAP-FUNCTION-HOOK', 'Error in function hook callback', e, false);
+                }
 
-            var errors = [errorClass];
-            if (errorMessage) {
-                errors.push(errorMessage);
-            }
-            if (errorStack || err.stack) {
-                errors.push(errorStack || err.stack);
-            }
-            AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+                // 원본 함수 실행
+                if (originalFunction && typeof originalFunction === 'function') {
+                    try {
+                        return originalFunction.apply(this, functionArgs);
+                    } catch (e) {
+                        Logger.printError('WHATAP-ORIGINAL-FUNCTION', 'Error in original function', e, false);
+                        throw e;
+                    }
+                }
+            };
+
+            // 후킹된 함수임을 표시
+            args[i].__whatap_hooked__ = true;
+            return true;
         }
-    } catch (e) {
-        Logger.printError('WHATAP-226', 'Error handling MySQL2 error', e, false);
     }
+
+    return false;
 }
 
-// 연결 래핑 함수 (AsyncResource 적용)
-var createConnectionWrapper = function(isPromise = false, mod) {
+/**
+ * 개선된 Connection 래퍼 - 원본 패턴 적용
+ */
+var createConnectionWrapper = function(isPromise = false) {
     return function(original) {
         return function wrappedCreateConnection() {
             var args = Array.prototype.slice.call(arguments);
             var ctx = TraceContextManager.getCurrentContext();
 
-            // AsyncResource 생성
-            var asyncResource = ctx ? new AsyncResource('mysql2-connection') : null;
-
             // DB 연결 정보 구성
             if (dbc_hash === 0 && args.length > 0) {
                 var info = (args[0] || {});
@@ -340,12 +366,18 @@ var createConnectionWrapper = function(isPromise = false, mod) {
                 dbc += '/';
                 dbc += info.database || '';
                 dbc_hash = HashUtil.hashFromString(dbc);
+                DataTextAgent.DBC.add(dbc_hash, dbc);
+                DataTextAgent.METHOD.add(dbc_hash, dbc);
+                DataTextAgent.ERROR.add(dbc_hash, dbc);
             }
 
-            if (ctx) {
+            var dbc_step = null;
+            if (ctx && !ctx.db_opening) {
                 ctx.db_opening = true;
                 ctx.footprint('MySql2 Connecting Start');
-                ctx.start_time = Date.now();
+                dbc_step = new DBCStep();
+                dbc_step.start_time = ctx.getElapsedTime();
+                dbc_step.hash = dbc_hash;
             }
 
             var result = original.apply(this, args);
@@ -358,31 +390,29 @@ var createConnectionWrapper = function(isPromise = false, mod) {
 
                     // Connection의 query와 execute 메서드 후킹
                     if (connection.query && !connection.query.__whatap_wrapped__) {
-                        shimmer.wrap(connection, 'query', createQueryWrapper(isPromise, dbc, mod));
+                        shimmer.wrap(connection, 'query', createQueryWrapper(isPromise));
                         connection.query.__whatap_wrapped__ = true;
                     }
                     if (connection.execute && !connection.execute.__whatap_wrapped__) {
-                        shimmer.wrap(connection, 'execute', createQueryWrapper(isPromise, dbc, mod));
+                        shimmer.wrap(connection, 'execute', createQueryWrapper(isPromise));
                         connection.execute.__whatap_wrapped__ = true;
                     }
 
-                    // 에러 델리게이트 후킹
-                    if (connection._protocol && connection._protocol._delegateError &&
-                        !connection._protocol._delegateError.__whatap_wrapped__) {
+                    // 에러 델리게이트 후킹 (원본 패턴)
+                    if (connection._protocol && connection._protocol._delegateError) {
                         try {
-                            shimmer.wrap(connection._protocol, '_delegateError', function(original) {
-                                return function wrappedDelegateError() {
-                                    var args = Array.prototype.slice.call(arguments);
-                                    var ctx = TraceContextManager.getCurrentContext();
-
-                                    if (ctx && args[0]) {
-                                        handleProtocolError(ctx, args[0]);
-                                    }
-
-                                    return original.apply(this, args);
-                                };
-                            });
-                            connection._protocol._delegateError.__whatap_wrapped__ = true;
+                            var originalDelegateError = connection._protocol._delegateError;
+                            connection._protocol._delegateError = function() {
+                                var args = Array.prototype.slice.call(arguments);
+                                try {
+                                    // WHATAP 에러 처리
+                                    handleProtocolError(args);
+                                } catch (e) {
+                                    Logger.printError('WHATAP-PROTOCOL-ERROR', 'Error in protocol error handler', e, false);
+                                }
+                                // 원본 함수 실행
+                                return originalDelegateError.apply(this, args);
+                            };
                         } catch (e) {
                             Logger.printError('WHATAP-PROTOCOL-HOOK', 'Error hooking _delegateError', e, false);
                         }
@@ -391,30 +421,50 @@ var createConnectionWrapper = function(isPromise = false, mod) {
                 return connection;
             }
 
-            function handleProtocolError(ctx, error) {
-                if (!error) return;
+            // 프로토콜 에러 처리 함수
+            function handleProtocolError(args) {
+                var ctx = TraceContextManager.getCurrentContext();
+                if (ctx == null || !args[0]) {
+                    return;
+                }
+
+                var laststep = ctx.profile.getLastSteps(1);
+                if (laststep == null || laststep.length === 0) {
+                    return;
+                }
+
+                var step = laststep[0];
+                if (!args[0].fatal) {
+                    MeterSql.add(step.dbc, step.elapsed, true);
+                    StatSql.addSqlTime(ctx.service_hash, step.dbc, step.hash, step.elapsed, true, 0);
+                }
 
                 try {
-                    var errorClass = error.code || error.name || error.constructor?.name || 'MySQLError';
-                    var errorMessage = error.message || 'mysql2 error';
-
-                    var shouldAddError = false;
-                    if (conf._is_trace_ignore_err_cls_contains === true && errorClass.indexOf(conf.trace_ignore_err_cls_contains) < 0) {
-                        shouldAddError = true;
-                    } else if (conf._is_trace_ignore_err_msg_contains === true && 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;
-                    }
+                    var errorCode = args[0].code || 'UNKNOWN';
+                    var errorMessage = ctx.error_message = args[0].message || 'mysql2 error';
+                    ctx.error_class = args[0].name || args[0].constructor?.name || 'MySQLError';
+
+                    if (args[0].fatal) {
+                        step.error = StatError.addError('mysql2-' + errorCode, errorMessage, ctx.service_hash);
+                        if (ctx.error.isZero()) {
+                            ctx.error = step.error;
+                        }
+                    } else {
+                        var shouldAddError = false;
+                        if (conf._is_trace_ignore_err_cls_contains === true && errorCode.indexOf(conf.trace_ignore_err_cls_contains) < 0) {
+                            shouldAddError = true;
+                        } else if (conf._is_trace_ignore_err_msg_contains === true && 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) {
-                        ctx.error = 1;
-                        ctx.status = 500;
-                        var errors = [errorClass];
-                        if (errorMessage) {
-                            errors.push(errorMessage);
+                        if (shouldAddError) {
+                            step.error = StatError.addError('mysql2-' + errorCode, errorMessage, ctx.service_hash, TextTypes.SQL, step.hash);
+                            if (ctx.error.isZero()) {
+                                ctx.error = step.error;
+                            }
                         }
-                        AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
                     }
                 } catch (e) {
                     Logger.printError('WHATAP-PROTOCOL-ERROR-HANDLING', 'Error processing protocol error', e, false);
@@ -423,41 +473,37 @@ var createConnectionWrapper = function(isPromise = false, mod) {
 
             // Promise 기반 연결 처리
             if (isPromise && result && typeof result.then === 'function') {
-                if (asyncResource) {
-                    return result.then(asyncResource.bind(function(connection) {
-                        hookConnection(connection);
-
-                        if (ctx) {
-                            ctx.elapsed = Date.now() - ctx.start_time;
-                            ctx.footprint('MySql2 Connecting Done');
-                            ctx.db_opening = false;
-                        }
-                        return connection;
-                    })).catch(asyncResource.bind(function(error) {
-                        if (ctx) {
-                            ctx.elapsed = Date.now() - ctx.start_time;
-                            ctx.footprint('MySql2 Connecting Error');
-                            ctx.db_opening = false;
-                            handleSqlError(ctx, error, 0);
-                        }
-                        throw error;
-                    }));
-                } else {
-                    return result.then(function(connection) {
-                        hookConnection(connection);
-                        return connection;
-                    });
-                }
-            } else {
-                // 동기/콜백 기반 연결 처리
+                return result.then(function(connection) {
+                    hookConnection(connection);
+
+                    if (ctx && dbc_step) {
+                        ctx.footprint('MySql2 Connecting Done');
+                        ctx.db_opening = false;
+                        dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
+                        ctx.profile.push(dbc_step);
+                    }
+                    return connection;
+                }).catch(function(error) {
+                    if (ctx && dbc_step) {
+                        ctx.footprint('MySql2 Connecting Error');
+                        ctx.db_opening = false;
+                        dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
+                        ctx.profile.push(dbc_step);
+                    }
+                    throw error;
+                });
+            }
+            // 동기/콜백 기반 연결 처리
+            else {
                 if (result && typeof result === 'object') {
                     hookConnection(result);
                 }
 
-                if (ctx) {
-                    ctx.elapsed = Date.now() - ctx.start_time;
+                if (ctx && dbc_step) {
                     ctx.footprint('MySql2 Connecting Done');
                     ctx.db_opening = false;
+                    dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
+                    ctx.profile.push(dbc_step);
                 }
             }
 
@@ -466,7 +512,10 @@ var createConnectionWrapper = function(isPromise = false, mod) {
     };
 };
 
-var createPoolWrapper = function(isPromise = false, mod) {
+/**
+ * 개선된 Pool 래퍼 - 원본 패턴 적용
+ */
+var createPoolWrapper = function(isPromise = false) {
     return function(original) {
         return function wrappedCreatePool() {
             var args = Array.prototype.slice.call(arguments);
@@ -481,22 +530,28 @@ var createPoolWrapper = function(isPromise = false, mod) {
                 dbc += '/';
                 dbc += info.database || '';
                 dbc_hash = HashUtil.hashFromString(dbc);
+                DataTextAgent.DBC.add(dbc_hash, dbc);
+                DataTextAgent.METHOD.add(dbc_hash, dbc);
+                DataTextAgent.ERROR.add(dbc_hash, dbc);
             }
 
             var pool = original.apply(this, args);
 
+            // Pool 객체 후킹
             if (pool && !hookedInstances.has(pool)) {
                 hookedInstances.add(pool);
 
+                // Pool의 query와 execute 메서드 후킹
                 if (pool.query && !pool.query.__whatap_wrapped__) {
-                    shimmer.wrap(pool, 'query', createQueryWrapper(isPromise, dbc, mod));
+                    shimmer.wrap(pool, 'query', createQueryWrapper(isPromise));
                     pool.query.__whatap_wrapped__ = true;
                 }
                 if (pool.execute && !pool.execute.__whatap_wrapped__) {
-                    shimmer.wrap(pool, 'execute', createQueryWrapper(isPromise, dbc, mod));
+                    shimmer.wrap(pool, 'execute', createQueryWrapper(isPromise));
                     pool.execute.__whatap_wrapped__ = true;
                 }
 
+                // getConnection 메서드 후킹 - 원본 패턴 적용
                 if (pool.getConnection && !pool.getConnection.__whatap_wrapped__) {
                     shimmer.wrap(pool, 'getConnection', function(original) {
                         return function wrappedGetConnection() {
@@ -507,76 +562,42 @@ var createPoolWrapper = function(isPromise = false, mod) {
                                 return original.apply(this, args);
                             }
 
-                            var asyncResource = new AsyncResource('mysql2-get-connection');
-                            ctx.start_time = Date.now();
-
-                            for (var i = args.length - 1; i >= 0; i--) {
-                                if (typeof args[i] === 'function') {
-                                    var originalCallback = args[i];
-                                    // AsyncResource로 바인딩된 콜백 생성
-                                    args[i] = asyncResource.bind(function() {
-                                        var callbackArgs = Array.prototype.slice.call(arguments);
-                                        var err = callbackArgs[0];
-                                        var conn = callbackArgs[1];
-
-                                        var currentCtx = TraceContextManager.getCurrentContext();
-                                        if (!currentCtx) {
-                                            TraceContextManager.resume(ctx.id);
-                                            currentCtx = ctx;
-                                        }
-
-                                        if (currentCtx) {
-                                            currentCtx.elapsed = Date.now() - ctx.start_time;
-                                            if (!err && conn && !conn.__query_hook__) {
-                                                conn.__query_hook__ = true;
-
-                                                // Connection 객체의 메서드들 후킹
-                                                if (conn.query && !conn.query.__whatap_wrapped__) {
-                                                    shimmer.wrap(conn, 'query', createQueryWrapper(isPromise, dbc, mod));
-                                                    conn.query.__whatap_wrapped__ = true;
-                                                }
-                                                if (conn.execute && !conn.execute.__whatap_wrapped__) {
-                                                    shimmer.wrap(conn, 'execute', createQueryWrapper(isPromise, dbc, mod));
-                                                    conn.execute.__whatap_wrapped__ = true;
-                                                }
-                                            }
-                                        }
-
-                                        return originalCallback.apply(this, callbackArgs);
-                                    });
-                                    break;
+                            // 원본 패턴: functionHook을 사용하여 콜백 후킹
+                            hookLastFunction(args, function(obj, callbackArgs) {
+                                TraceContextManager.resume(ctx._id);
+                                DataTextAgent.DBC.add(dbc_hash, dbc);
+
+                                if (callbackArgs[0] != null) {
+                                    return; // 에러가 있으면 처리하지 않음
                                 }
-                            }
 
-                            var result = original.apply(this, args);
+                                var conn = callbackArgs[1];
+                                if (conn && !conn.__query_hook__) {
+                                    conn.__query_hook__ = true;
 
-                            // Promise 기반 처리
-                            if (result && typeof result.then === 'function' && args.every(arg => typeof arg !== 'function')) {
-                                return result.then(asyncResource.bind(function(connection) {
-                                    var currentCtx = TraceContextManager.getCurrentContext();
-                                    if (!currentCtx) {
-                                        TraceContextManager.resume(ctx.id);
-                                        currentCtx = ctx;
+                                    // Connection 객체의 메서드들 후킹
+                                    if (conn.query && !conn.query.__whatap_wrapped__) {
+                                        shimmer.wrap(conn, 'query', createQueryWrapper(isPromise));
+                                        conn.query.__whatap_wrapped__ = true;
                                     }
-
-                                    if (currentCtx) {
-                                        currentCtx.elapsed = Date.now() - ctx.start_time;
-                                        if (connection && !connection.__query_hook__) {
-                                            connection.__query_hook__ = true;
-
-                                            if (connection.query && !connection.query.__whatap_wrapped__) {
-                                                shimmer.wrap(connection, 'query', createQueryWrapper(isPromise, dbc, mod));
-                                                connection.query.__whatap_wrapped__ = true;
-                                            }
-                                            if (connection.execute && !connection.execute.__whatap_wrapped__) {
-                                                shimmer.wrap(connection, 'execute', createQueryWrapper(isPromise, dbc, mod));
-                                                connection.execute.__whatap_wrapped__ = true;
-                                            }
-                                        }
+                                    if (conn.execute && !conn.execute.__whatap_wrapped__) {
+                                        shimmer.wrap(conn, 'execute', createQueryWrapper(isPromise));
+                                        conn.execute.__whatap_wrapped__ = true;
                                     }
+                                }
+                            });
+
+                            var result = original.apply(this, args);
 
-                                    return connection;
-                                }));
+                            // 연결 통계 업데이트 (원본 패턴)
+                            try {
+                                if (this._allConnections != undefined) {
+                                    var all = this._allConnections.length;
+                                    var idle = this._freeConnections.length;
+                                    MeterSql.setConnection((all - idle), idle, dbc);
+                                }
+                            } catch (e) {
+                                Logger.printError('WHATAP-CONNECTION-STATS', 'Error updating connection stats', e, false);
                             }
 
                             return result;
@@ -591,6 +612,50 @@ var createPoolWrapper = function(isPromise = false, mod) {
     };
 };
 
+var toParamBytes = function (p, crc) {
+    if (p == null || p.length === 0) {
+        return null;
+    }
+    try {
+        return ParamSecurity.encrypt(Buffer.from(p, 'utf8'), crc);
+    } catch (e) {
+        return null;
+    }
+};
+
+Mysql2Observer.prototype.inject = function (mod, moduleName) {
+    if (mod.__whatap_observe__) {
+        return;
+    }
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("Mysql2Observer");
+
+    if (conf.sql_enabled === false) {
+        return;
+    }
+
+    // mysql2/promise인지 일반 mysql2인지 구분
+    var isPromise = moduleName && moduleName.includes('promise');
+
+    Logger.print('WHATAP-MYSQL2-INJECT', 'Injecting MySQL2 module: ' + moduleName + ', Promise mode: ' + isPromise, false);
+
+    // 전역 함수 추적으로 중복 후킹 방지
+    if (mod.createConnection && !globalHookedFunctions.has(mod.createConnection)) {
+        globalHookedFunctions.add(mod.createConnection);
+        shimmer.wrap(mod, 'createConnection', createConnectionWrapper(isPromise));
+    }
+
+    if (mod.createPool && !globalHookedFunctions.has(mod.createPool)) {
+        globalHookedFunctions.add(mod.createPool);
+        shimmer.wrap(mod, 'createPool', createPoolWrapper(isPromise));
+    }
+
+    if (mod.createPoolCluster && !globalHookedFunctions.has(mod.createPoolCluster)) {
+        globalHookedFunctions.add(mod.createPoolCluster);
+        shimmer.wrap(mod, 'createPoolCluster', createPoolWrapper(isPromise));
+    }
+};
+
 var checkedSql = new IntKeyMap(2000).setMax(2000);
 var nonLiteSql = new IntKeyMap(5000).setMax(5000);
 var date = DateUtil.yyyymmdd();
@@ -623,6 +688,8 @@ function escapeLiteral(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);
@@ -633,33 +700,4 @@ function escapeLiteral(sql) {
     return psql;
 }
 
-Mysql2Observer.prototype.inject = function (mod, moduleName) {
-    if (mod.__whatap_observe__) {
-        return;
-    }
-    mod.__whatap_observe__ = true;
-    Logger.initPrint("Mysql2Observer");
-
-    if (conf.sql_enabled === false) {
-        return;
-    }
-
-    var isPromise = moduleName && moduleName.includes('promise');
-
-    if (mod.createConnection && !mod.createConnection.__whatap_wrapped__) {
-        shimmer.wrap(mod, 'createConnection', createConnectionWrapper(isPromise, mod));
-        mod.createConnection.__whatap_wrapped__ = true;
-    }
-
-    if (mod.createPool && !mod.createPool.__whatap_wrapped__) {
-        shimmer.wrap(mod, 'createPool', createPoolWrapper(isPromise, mod));
-        mod.createPool.__whatap_wrapped__ = true;
-    }
-
-    if (mod.createPoolCluster && !mod.createPoolCluster.__whatap_wrapped__) {
-        shimmer.wrap(mod, 'createPoolCluster', createPoolWrapper(isPromise, mod));
-        mod.createPoolCluster.__whatap_wrapped__ = true;
-    }
-};
-
 exports.Mysql2Observer = Mysql2Observer;