whatap 0.5.26 → 1.0.0

package/lib/observers/mysql-observer.js

@@ -6,420 +6,394 @@
 
 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'),
-    conf = require('../conf/configure'),
     DateUtil = require('../util/dateutil'),
-    Buffer = require('buffer').Buffer,
+    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');
 
 var MysqlObserver = function (agent) {
     this.agent = agent;
     this.packages = ['mysql'];
 };
 
-var queryHook = function (dbc, agent) {
-
-    return function (obj, args) {
-        var ctx = TraceContextManager.getCurrentContext();
-
-        if (ctx == null || args[0] == null) {
-            return;
-        }
-        if (args[0].sql == null && typeof args[0] != 'string') {
-            return;
-        }
-
-        var dbc_step = new DBCStep();
-        var 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);
-
-        var sql_step = new SqlStepX();
-        sql_step.start_time = ctx.getElapsedTime();
-        ctx.profile.push(sql_step);
-
-        ctx.footprint('MySql Query Start');
-
-        ctx.sql_count++;
+// 전역 dbc 정보
+var dbc_hash = 0;
+var dbc = 'mysql://';
 
-        var sql = args.length > 0 ? args[0] : undefined,
-            psql = null;
+// 후킹된 객체 추적
+var hookedInstances = new WeakSet();
 
-        if (typeof sql !== 'string') {
-            sql = args[0].sql || undefined;
-        }
+// 공통 함수들
+function handleSqlError(ctx, err, sqlHash) {
+    if (!err) return;
 
-        if (typeof sql === 'string' && sql.length > 0) {
-            try {
-                psql = escapeLiteral(sql);
-            } catch (e) {
-                Logger.printError('WHATAP-191', 'MysqlObserver escapeliteral error', e);
+    try {
+        var errorClass = err.code || err.name || err.constructor?.name || 'MySQLError';
+        var errorMessage = err.message || err.sqlMessage || 'mysql 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);
             }
-        } else {
-            sql = '';
-            psql = escapeLiteral(sql);
+            errorStack = stackLines.join("\n");
         }
 
-        if (psql != null) {
-            sql_step.hash = psql.sql;
-            // sql_step.crud = psql.type.charCodeAt(0);
+        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;
         }
-        sql_step.dbc = dbc_hash;
-
-        var els = new EscapeLiteralSQL(sql);
-        els.process();
-
-        ctx.active_sqlhash = sql_step.hash;
-        ctx.active_dbc = sql_step.dbc;
-        //ctx.active_crud = sql_step.crud;
-
-        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;
-        }
-
-        var lastCallback = false;
 
-        function queryCallback(obj, args) {
-            if (ctx == null) {
-                return;
+        if (shouldAddError) {
+            if(!ctx.error) ctx.error = 1;
+            ctx.status = 500;
+            var errors = [errorClass];
+            if (errorMessage) {
+                errors.push(errorMessage);
             }
-            TraceContextManager.resume(ctx._id);
-
-            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.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('mysql-' + args[0].code, args[0].sqlMessage, ctx.service_hash, TextTypes.SQL, null);
-                    }
-                    ctx.error_class = args[0].name || args[0].constructor?.name || 'MySQLError';
-                    if (!ctx.error_message) {
-                        ctx.error_message = args[0].message || args[0].sqlMessage || 'MySQL error';
-                    }
-                    if (conf._is_trace_ignore_err_cls_contains === true && args[0].code.indexOf(conf.trace_ignore_err_cls_contains) < 0) {
-                        sql_step.error = StatError.addError('mysql-' + args[0].code, args[0].message || 'mysql error', ctx.service_hash, TextTypes.SQL, sql_step.hash); /*long*/
-                        if (ctx.error.isZero()) {
-                            ctx.error = sql_step.error;
-                        }
-                    } else if (conf._is_trace_ignore_err_msg_contains === true && args[0].message.indexOf(conf.trace_ignore_err_msg_contains) < 0) {
-                        sql_step.error = StatError.addError('mysql-' + args[0].code, args[0].message || 'mysql error', ctx.service_hash, TextTypes.SQL, sql_step.hash); /*long*/
-                        if (ctx.error.isZero()) {
-                            ctx.error = sql_step.error;
-                        }
-                    } else if (conf._is_trace_ignore_err_cls_contains === false && conf._is_trace_ignore_err_msg_contains === false) {
-                        sql_step.error = StatError.addError('mysql-' + args[0].code, args[0].message || 'mysql error', ctx.service_hash, TextTypes.SQL, sql_step.hash); /*long*/
-                        if (ctx.error.isZero()) {
-                            ctx.error = sql_step.error;
-                        }
-                    }
-                    /*
-                     sql_step.error = StatError.addError(
-                     ('mysql-'+args[0].code ),
-                     (args[0].message || 'mysql error'),
-                      ctx.service_hash,
-                      TextTypes.SQL, sql_step.hash);
-                     if(ctx.error.isZero()) {
-                         ctx.error = sql_step.error;
-                     }
-                     */
-                } catch (e) {
-
-                }
+            if (errorStack || err.stack) {
+                errors.push(errorStack || err.stack);
             }
 
-            sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
-            ctx.sql_time += sql_step.elapsed;
-
-            TraceSQL.isSlowSQL(ctx);
-
-            // if(conf.getProperty('profile_sql_resource_enabled', false)){
-            //     sql_step.start_cpu = ResourceProfile.getCPUTime();
-            //     sql_step.start_mem = ResourceProfile.getUsedHeapSize();
-            // }
-
-            ctx.footprint('MySql Query Done');
-
-            MeterSql.add(dbc_hash, sql_step.elapsed, false);
-            StatSql.addSqlTime(ctx.service_hash, sql_step.dbc,
-                sql_step.hash, sql_step.elapsed, args[0] != null, 0);
-
-            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);
+            AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+        }
+    } catch (e) {
+        Logger.printError('WHATAP-232', 'Error handling MySQL error', e, false);
+    }
+}
 
-                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;
-                // ctx.rs_time = ctx.rs_time ? ctx.rs_time + (result_step.start_time - ctx.getElapsedTime()) : result_step.start_time - ctx.getElapsedTime();
+function handleProtocolError(ctx, error) {
+    if (!error) return;
 
-                MeterSql.addFetch(result_step.dbc, result_step.fetch, 0);
-                StatSql.addFetch(result_step.dbc, result_step.sqlhash, result_step.fetch, 0);
+    try {
+        var errorClass = error.code || error.name || error.constructor?.name || 'MySQLError';
+        var errorMessage = error.message || 'mysql 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;
+        }
 
-                TraceSQL.isTooManyRecords(sql_step, result_step.fetch, ctx);
+        if (shouldAddError) {
+            ctx.error = 1;
+            ctx.status = 500;
+            var errors = [errorClass];
+            if (errorMessage) {
+                errors.push(errorMessage);
             }
-
-            if (args[1] != null && psql != null && psql.type === 'U') {
-                sql_step.updated = args[1].affectedRows || 0;
-                //StatSql.addUpdate(dbc_hash, psql.sql, sql_step.updated);
+            if (error.stack) {
+                errors.push(error.stack);
             }
-        }
-
-        lastCallback = agent.aop.functionHook(args, -1, queryCallback);
 
-        if (lastCallback === false && args.length > 0 && args[0]._callback) {
-            agent.aop.both(args[0], '_callback', queryCallback);
+            AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
         }
+    } catch (e) {
+        Logger.printError('WHATAP-PROTOCOL-ERROR-HANDLING', 'Error processing protocol error', e, false);
     }
-};
+}
 
-var toParamBytes = function (p, crc) {
-    if (p == null || p.length === 0) {
-        return null;
+function setupDbcInfo(args) {
+    if (dbc_hash === 0 && args.length > 0) {
+        var info = args[0] || {};
+        dbc = 'mysql://';
+        dbc += info.user || '';
+        dbc += "@";
+        dbc += info.host || '';
+        dbc += '/';
+        dbc += info.database || '';
+        dbc_hash = HashUtil.hashFromString(dbc);
     }
-    try {
-        return ParamSecurity.encrypt(Buffer.from(p, 'utf8'), crc);
-    } catch (e) {
-        return null;
-    }
-};
+}
 
-var errorDelegate = function () {
-    return function (obj, args) {
-        var ctx = TraceContextManager.getCurrentContext();
-        if (ctx == null) {
-            return;
-        }
+function hookConnectionMethods(connection, agent, mysqlModule) {
+    if (connection && !hookedInstances.has(connection)) {
+        hookedInstances.add(connection);
+        Logger.print('WHATAP-MYSQL-CONNECTION', 'Hooking new connection object', false);
 
-        var laststep = ctx.profile.getLastSteps(1);
-        if (laststep == null || laststep.length === 0) {
-            return;
+        // query와 execute 메서드 후킹
+        if (connection.query && !connection.query.__whatap_wrapped__) {
+            shimmer.wrap(connection, 'query', createQueryWrapper(agent, dbc, mysqlModule));
+            connection.query.__whatap_wrapped__ = true;
         }
-
-        var step = laststep[0];
-        if (!args[0].fatal) {
-            MeterSql.add(step.dbc, step.elapsed, true);
-            StatSql.addSqlTime(ctx, ctx.service_hash, step.dbc, step.hash, step.elapsed, true, 0);
+        if (connection.execute && !connection.execute.__whatap_wrapped__) {
+            shimmer.wrap(connection, 'execute', createQueryWrapper(agent, dbc, mysqlModule));
+            connection.execute.__whatap_wrapped__ = true;
         }
 
-        try {
-            if (args[0].fatal) {
-                step.error = StatError.addError('mysql-' + args[0].code, args[0].message, ctx.service_hash); /*long*/
-                if (ctx.error.isZero()) {
-                    ctx.error = step.error;
-                }
-            } else {
-                if (conf._is_trace_ignore_err_cls_contains === true && args[0].code.indexOf(conf.trace_ignore_err_cls_contains) < 0) {
-                    step.error = StatError.addError('mysql-' + args[0].code, args[0].message, ctx.service_hash, TextTypes.SQL, step.hash); /*long*/
-                    if (ctx.error.isZero()) {
-                        ctx.error = step.error;
-                    }
-                } else if (conf._is_trace_ignore_err_msg_contains === true && args[0].message.indexOf(conf.trace_ignore_err_msg_contains) < 0) {
-                    step.error = StatError.addError('mysql-' + args[0].code, args[0].message, ctx.service_hash, TextTypes.SQL, step.hash); /*long*/
-                    if (ctx.error.isZero()) {
-                        ctx.error = step.error;
-                    }
-                } else if (conf._is_trace_ignore_err_cls_contains === false && conf._is_trace_ignore_err_msg_contains === false) {
-                    step.error = StatError.addError('mysql-' + args[0].code, args[0].message, ctx.service_hash, TextTypes.SQL, step.hash); /*long*/
-                    if (ctx.error.isZero()) {
-                        ctx.error = step.error;
-                    }
-                }
+        // 프로토콜 에러 델리게이트 래핑
+        if (connection._protocol && connection._protocol._delegateError &&
+            !connection._protocol._delegateError.__whatap_wrapped__) {
+            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]) {
+                            handleSqlError(ctx, args[0], 0);
+                        }
+
+                        return original.apply(this, args);
+                    };
+                });
+                connection._protocol._delegateError.__whatap_wrapped__ = true;
+            } catch (e) {
+                Logger.printError('WHATAP-PROTOCOL-HOOK', 'Error hooking _delegateError', e, false);
             }
-        } catch (e) {
         }
     }
-};
-
-MysqlObserver.prototype.inject = function (mod, moduleName) {
-    if (mod.__whatap_observe__) {
-        return;
-    }
-    mod.__whatap_observe__ = true;
-    Logger.initPrint("MysqlObserver");
-    var self = this;
-    var aop = self.agent.aop;
+}
 
-    if (conf.sql_enabled === false) {
-        return;
-    }
+// 쿼리 래핑 함수
+var createQueryWrapper = function(agent, dbcUrl, mysqlModule) {
+    return function(original) {
+        return function wrappedQuery() {
+            var args = Array.prototype.slice.call(arguments);
+            var ctx = TraceContextManager.getCurrentContext();
 
-    var dbc_hash = 0;
-    var dbc = 'mysql://';
-    aop.both(mod, 'createConnection',
-        function (obj, args, lctx) {
-            var ctx = lctx.context;
-            if (ctx == null || ctx.db_opening) {
-                return;
+            if (ctx == null || args[0] == null) {
+                return original.apply(this, arguments);
             }
-            ctx.db_opening = true;
-            ctx.footprint('MySql Connecting Start');
-
-            var dbc_step = new DBCStep();
-            dbc_step.start_time = ctx.getElapsedTime();
-            lctx.step = dbc_step;
-        },
-        function (obj, args, ret, lctx) {
-
-            if (dbc_hash === 0) {
-                if (args.length > 0) {
-                    var info = (args[0] || {});
-                    dbc = 'mysql://';
-                    dbc += info.user || '';
-                    dbc += "@";
-                    dbc += info.host || '';
-                    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 (args[0].sql == null && typeof args[0] != 'string') {
+                return original.apply(this, arguments);
             }
 
-            aop.both(ret, 'query', queryHook(dbc, self.agent), function (obj, args, ret, lctx) {
-                var ctx = lctx.context;
-                TraceContextManager.resume(ctx);
-            });
+            // AsyncResource 생성
+            const asyncResource = new AsyncResource('mysql-query');
+            const callbackResource = new AsyncResource('mysql-callback');
 
-            aop.both(ret, 'execute', queryHook(dbc, self.agent), function (obj, args, ret, lctx) {
-                var ctx = lctx.context;
-                TraceContextManager.resume(ctx);
-            });
+            return asyncResource.runInAsyncScope(() => {
+                ctx.start_time = Date.now();
 
-            aop.after(ret._protocol, '_delegateError', errorDelegate());
+                // DB 연결 패킷 전송 (elapsed = 0으로 설정)
+                ctx.elapsed = 0;
+                AsyncSender.send_packet(PacketTypeEnum.TX_DB_CONN, ctx, [dbcUrl]);
 
-            var ctx = lctx.context,
-                step = lctx.step;
+                // SQL 시작 시간 기록
+                var sql_start_time = Date.now();
+                ctx.footprint('MySql Query Start');
 
-            if (ctx == null || step == null) {
-                return;
-            }
+                var sql = args.length > 0 ? args[0] : undefined;
+                var values = args.length > 1 ? args[1] : undefined;
+                var finalSql = '';
+
+                // mysql.format()을 사용하여 최종 SQL 구성
+                try {
+                    if (typeof sql === 'string') {
+                        // 일반 문자열 쿼리인 경우
+                        if (values && typeof mysqlModule.format === 'function') {
+                            finalSql = mysqlModule.format(sql, values);
+                        } else {
+                            finalSql = sql;
+                        }
+                    } else if (sql && typeof sql === 'object') {
+                        // 쿼리 객체인 경우 (prepared statement 등)
+                        if (sql.sql) {
+                            if (sql.values && typeof mysqlModule.format === 'function') {
+                                finalSql = mysqlModule.format(sql.sql, sql.values);
+                            } else {
+                                finalSql = sql.sql;
+                            }
+                        }
+                    }
+                } catch (formatError) {
+                    Logger.printError('WHATAP-SQL-FORMAT', 'Error formatting SQL with mysql.format()', formatError, false);
+                    // 포맷 실패 시 원본 사용
+                    if (typeof sql === 'string') {
+                        finalSql = sql;
+                    } else if (sql && sql.sql) {
+                        finalSql = sql.sql;
+                    }
+                }
+
+                if (typeof finalSql !== 'string' || finalSql.length === 0) {
+                    finalSql = '';
+                }
+
+                var psql = null;
+                if (typeof finalSql === 'string' && finalSql.length > 0) {
+                    try {
+                        psql = escapeLiteral(finalSql);
+                        Logger.print('WHATAP-SQL-DEBUG', 'Processing SQL: ' + finalSql.substring(0, 200), false);
+                    } catch (e) {
+                        Logger.printError('WHATAP-233', 'MysqlObserver escapeliteral error', e, false);
+                    }
+                } else {
+                    psql = escapeLiteral(finalSql);
+                }
 
-            TraceContextManager.resume(ctx);
-            ctx.footprint('MySql Connecting Done');
-            ctx.db_opening = false;
-            step.hash = dbc_hash;
+                var sqlHash = psql ? psql.sql : 0;
+                ctx.active_sqlhash = true;
 
-            aop.both(ret, 'connect', function (obj, args) {
+                // 쿼리 콜백 처리 함수 - AsyncResource로 바인딩
+                function queryCallback(err, results) {
+                    // AsyncResource 스코프 내에서 실행되므로 컨텍스트 유지됨
                     var ctx = TraceContextManager.getCurrentContext();
                     if (ctx == null) {
                         return;
                     }
 
-                    ctx.footprint('MySql Connecting Start');
+                    TraceContextManager.resume(ctx.id);
 
-                    ctx.db_opening = true;
+                    var sql_elapsed = Date.now() - sql_start_time;
+                    var resultCount = 0;
+
+                    // 에러 처리 먼저 수행 (TX_ERROR 패킷 전송)
+                    if (err) {
+                        handleSqlError(ctx, err, sqlHash);
+                    }
 
-                    aop.functionHook(args, -1, function (obj, args) {
-                        if (args[0] && step.error.isZero()) {
-                            step.error = StatError.addError('mysql-' + args[0].code,
-                                args[0].message, ctx.service_hash);
-                            step.elapsed = ctx.getElapsedTime() - step.start_time;
+                    // 결과 개수 계산
+                    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;
                         }
-                        TraceContextManager.resume(ctx._id);
-                    });
-                    ctx.profile.push(step);
+                    }
+
+                    try {
+                        TraceSQL.isSlowSQL(ctx);
+                        if (!err && results && psql && psql.type === 'S') {
+                            TraceSQL.isTooManyRecords(resultCount, ctx);
+                        }
+                    } catch (e) {
+                        Logger.printError('WHATAP-TRACESQL', 'Error in TraceSQL processing', e, false);
+                    }
+
+                    ctx.elapsed = sql_elapsed;
+                    ctx.active_sqlhash = false;
+                    AsyncSender.send_packet(PacketTypeEnum.TX_SQL, ctx, [dbcUrl, finalSql, String(resultCount)]);
+
+                    ctx.footprint('MySql Query Done');
                 }
-                ,
-                function (obj, args, ret, lctx) {
-                    if (lctx.context) {
-                        ctx.db_opening = false;
-                        ctx.footprint('MySql Connecting Done');
+
+                var callbackWrapped = false;
+
+                // 일반 콜백 래핑 - callbackResource로 바인딩
+                for (var i = args.length - 1; i >= 0; i--) {
+                    if (typeof args[i] === 'function') {
+                        var originalCallback = args[i];
+                        // AsyncResource로 콜백 바인딩
+                        args[i] = callbackResource.bind(function() {
+                            var callbackArgs = Array.prototype.slice.call(arguments);
+                            try {
+                                queryCallback(callbackArgs[0], callbackArgs[1]);
+                            } 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;
                     }
                 }
-            );
-        });
 
+                // _callback 래핑 - callbackResource로 바인딩
+                if (!callbackWrapped && args.length > 0 && args[0]._callback) {
+                    try {
+                        var originalCallback = args[0]._callback;
+                        args[0]._callback = callbackResource.bind(function() {
+                            var callbackArgs = Array.prototype.slice.call(arguments);
+                            try {
+                                queryCallback(callbackArgs[0], callbackArgs[1]);
+                            } catch (e) {
+                                Logger.printError('WHATAP-CALLBACK', 'Error in _callback hook', e, false);
+                            }
+                            if (originalCallback && typeof originalCallback === 'function') {
+                                return originalCallback.apply(this, callbackArgs);
+                            }
+                        });
+                        callbackWrapped = true;
+                    } catch (e) {
+                        Logger.printError('WHATAP-CALLBACK-HOOK', 'Error hooking _callback', e, false);
+                    }
+                }
 
-    var dbc_pool_hash = 0;
-    aop.after(mod, ['createPool', 'createPoolCluster'], function (obj, args, ret) {
-        if (dbc_pool_hash == 0 && dbc === 'mysql://') {
-            if (args.length > 0) {
-                var info = args[0];
-                //Open [DatabaseName] connection 메세지 보여줄때 필요함.
-                dbc += info.user || '';
-                dbc += "@";
-                dbc += info.host || '';
-                dbc += '/';
-                dbc += info.database || '';
-            }
+                try {
+                    return original.apply(this, args);
+                } catch (queryError) {
+                    queryCallback(queryError, null);
+                    throw queryError;
+                }
+            });
+        };
+    };
+};
 
-            // dbc_pool_hash = HashUtil.hashFromString(dbc);
-            // DataTextAgent.DBC.add(dbc_pool_hash, dbc);
-            // DataTextAgent.METHOD.add(dbc_pool_hash, dbc);
-            // DataTextAgent.ERROR.add(dbc_pool_hash, dbc);
-        }
-        aop.both(ret, 'getConnection', function (obj, args, lctx) {
+// getConnection 래핑 함수
+var wrapGetConnection = function(agent, mysqlModule) {
+    return function(original) {
+        return function wrappedGetConnection() {
+            var args = Array.prototype.slice.call(arguments);
             var ctx = TraceContextManager.getCurrentContext();
+
             if (ctx == null) {
-                return;
+                return original.apply(this, args);
             }
 
-            aop.functionHook(args, -1, function (obj, args) {
-                TraceContextManager.resume(ctx._id);
-                DataTextAgent.DBC.add(dbc_hash, dbc);
-
-                if (args[0] != null) {
-                    return;
-                }
-                var conn = args[1];
-                if (conn.__query_hook__) {
-                    return;
+            // AsyncResource로 getConnection 컨텍스트 유지
+            const connectionResource = new AsyncResource('mysql-getConnection');
+
+            return connectionResource.runInAsyncScope(() => {
+                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] = connectionResource.bind(function() {
+                            var callbackArgs = Array.prototype.slice.call(arguments);
+                            var err = callbackArgs[0];
+                            var conn = callbackArgs[1];
+
+                            TraceContextManager.resume(ctx.id);
+                            ctx.elapsed = Date.now() - ctx.start_time;
+
+                            if (!err && conn && !conn.__query_hook__) {
+                                conn.__query_hook__ = true;
+                                hookConnectionMethods(conn, agent, mysqlModule);
+                            }
+
+                            return originalCallback.apply(this, callbackArgs);
+                        });
+                        break;
+                    }
                 }
-                conn.__query_hook__ = true;
-                aop.before(conn, 'query', queryHook(dbc, self.agent));
-                aop.before(conn, 'execute', queryHook(dbc, self.agent));
-                aop.before(conn._protocol, '_delegateError', errorDelegate(ctx));
+
+                return original.apply(this, args);
             });
-        }, function (obj, args, ret, lctx) {
-            if (obj._allConnections != undefined) {
-                var all = obj._allConnections.length;
-                var idle = obj._freeConnections.length;
-                MeterSql.setConnection((all - idle), idle, dbc);
-            }
-        });
-    });
+        };
+    };
 };
 
+// 유틸리티 함수들
 var checkedSql = new IntKeyMap(2000).setMax(2000);
 var nonLiteSql = new IntKeyMap(5000).setMax(5000);
 var date = DateUtil.yyyymmdd();
@@ -452,8 +426,6 @@ 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);
@@ -464,4 +436,139 @@ function escapeLiteral(sql) {
     return psql;
 }
 
+// 메인 inject 함수
+MysqlObserver.prototype.inject = function (mod, moduleName) {
+    if (mod.__whatap_observe__) {
+        return;
+    }
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("MysqlObserver");
+
+    if (conf.sql_enabled === false) {
+        return;
+    }
+
+    var self = this;
+
+    // createConnection 래핑
+    if (mod.createConnection && !mod.createConnection.__whatap_wrapped__) {
+        shimmer.wrap(mod, 'createConnection', function(original) {
+            return function wrappedCreateConnection() {
+                var args = Array.prototype.slice.call(arguments);
+                var ctx = TraceContextManager.getCurrentContext();
+
+                setupDbcInfo(args);
+
+                if (ctx) {
+                    ctx.db_opening = true;
+                    ctx.footprint('MySql Connecting Start');
+                    ctx.start_time = Date.now();
+                }
+
+                var result = original.apply(this, args);
+
+                // 연결 객체 후킹
+                hookConnectionMethods(result, self.agent, mod);
+
+                // connect 메서드 래핑
+                if (result && result.connect && !result.connect.__whatap_wrapped__) {
+                    shimmer.wrap(result, 'connect', function(original) {
+                        return function wrappedConnect() {
+                            var args = Array.prototype.slice.call(arguments);
+                            var ctx = TraceContextManager.getCurrentContext();
+
+                            if (ctx) {
+                                ctx.footprint('MySql Connecting Start');
+                                ctx.db_opening = true;
+
+                                // 콜백 래핑
+                                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);
+                                            var err = callbackArgs[0];
+
+                                            if (err) {
+                                                handleSqlError(ctx, err, 0);
+                                            }
+
+                                            ctx.db_opening = false;
+                                            ctx.footprint('MySql Connecting Done');
+                                            TraceContextManager.resume(ctx.id);
+
+                                            return originalCallback.apply(this, callbackArgs);
+                                        };
+                                        break;
+                                    }
+                                }
+                            }
+
+                            return original.apply(this, args);
+                        };
+                    });
+                    result.connect.__whatap_wrapped__ = true;
+                }
+
+                if (ctx) {
+                    ctx.elapsed = Date.now() - ctx.start_time;
+                    ctx.footprint('MySql Connecting Done');
+                    ctx.db_opening = false;
+                }
+
+                return result;
+            };
+        });
+        mod.createConnection.__whatap_wrapped__ = true;
+    }
+
+    // createPool 래핑
+    if (mod.createPool && !mod.createPool.__whatap_wrapped__) {
+        shimmer.wrap(mod, 'createPool', function(original) {
+            return function wrappedCreatePool() {
+                var args = Array.prototype.slice.call(arguments);
+                setupDbcInfo(args);
+
+                var pool = original.apply(this, args);
+
+                if (pool && !hookedInstances.has(pool)) {
+                    hookedInstances.add(pool);
+
+                    if (pool.getConnection && !pool.getConnection.__whatap_wrapped__) {
+                        shimmer.wrap(pool, 'getConnection', wrapGetConnection(self.agent, mod));
+                        pool.getConnection.__whatap_wrapped__ = true;
+                    }
+                }
+
+                return pool;
+            };
+        });
+        mod.createPool.__whatap_wrapped__ = true;
+    }
+
+    // createPoolCluster 래핑
+    if (mod.createPoolCluster && !mod.createPoolCluster.__whatap_wrapped__) {
+        shimmer.wrap(mod, 'createPoolCluster', function(original) {
+            return function wrappedCreatePoolCluster() {
+                var args = Array.prototype.slice.call(arguments);
+                setupDbcInfo(args);
+
+                var poolCluster = original.apply(this, args);
+
+                if (poolCluster && !hookedInstances.has(poolCluster)) {
+                    hookedInstances.add(poolCluster);
+
+                    if (poolCluster.getConnection && !poolCluster.getConnection.__whatap_wrapped__) {
+                        shimmer.wrap(poolCluster, 'getConnection', wrapGetConnection(self.agent, mod));
+                        poolCluster.getConnection.__whatap_wrapped__ = true;
+                    }
+                }
+
+                return poolCluster;
+            };
+        });
+        mod.createPoolCluster.__whatap_wrapped__ = true;
+    }
+};
+
 exports.MysqlObserver = MysqlObserver;