whatap 1.0.1 → 1.0.2

package/lib/observers/oracle-observer.js

@@ -6,306 +6,350 @@
 
 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'),
-    AsyncResource = require('async_hooks').AsyncResource;
+    Buffer = require('buffer').Buffer,
+    TraceSQL = require('../trace/trace-sql');
+var shimmer = require('../core/shimmer');
+
+// Store connection info for reuse
+var connectionAttributes = new WeakMap();
+var poolAttributes = new WeakMap();
 
 var OracleObserver = function (agent) {
     this.agent = agent;
     this.packages = ['oracledb'];
 };
 
-var dbc_hash = 0;
-var dbc = 'oracle://';
-
-var hookedInstances = new WeakSet();
-
-var checkedSql = new IntKeyMap(2000).setMax(2000);
-var nonLiteSql = new IntKeyMap(5000).setMax(5000);
-var date = DateUtil.yyyymmdd();
-
-function handleSqlError(ctx, err) {
-    if (!err) return;
-
+// 쿼리 파라미터를 바이트 배열로 변환
+var toParamBytes = function (p, crc) {
+    if (p == null || p.length === 0) {
+        return null;
+    }
     try {
-        var errorClass = err.errorNum || err.code || err.name || err.constructor?.name || 'OracleError';
-        var errorMessage = err.message || 'oracle 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");
-        }
+        return ParamSecurity.encrypt(Buffer.from(p, 'utf8'), crc);
+    } catch (e) {
+        return null;
+    }
+};
 
-        var shouldAddError = false;
-        if (conf._is_trace_ignore_err_cls_contains === true && errorClass &&
-            errorClass.toString().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;
+var errorDelegate = function (ctx, step) {
+    return function (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);
-            }
-            if (errorStack || err.stack) {
-                errors.push(errorStack || err.stack);
+        if (step == null) {
+            var laststep = ctx.profile.getLastSteps(1);
+            if (laststep == null || laststep.length === 0) {
+                return;
             }
-
-            AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+            step = laststep[0];
         }
-    } catch (e) {
-        Logger.printError('WHATAP-251', 'Error handling Oracle error', e, false);
-    }
-}
 
-function setupDbcInfo(connectionInfo) {
-    if (dbc_hash === 0 && connectionInfo) {
-        var connectInfo = connectionInfo.connectString || connectionInfo.connectionString || '';
-        var user = connectionInfo.user || '';
-        dbc = 'oracle://' + user + '@' + connectInfo;
-        dbc_hash = HashUtil.hashFromString(dbc);
-    }
-}
+        MeterSql.add(step.dbc, step.elapsed, true);
+        StatSql.addSqlTime(ctx.service_hash, step.dbc, step.hash, step.elapsed, true, 0);
 
-function hookConnectionMethods(connection, agent) {
-    if (connection && !hookedInstances.has(connection)) {
-        hookedInstances.add(connection);
-        Logger.print('WHATAP-ORACLE-CONNECTION', 'Hooking new Oracle connection object', false);
+        ctx.error_class = args[0].name || args[0].constructor?.name || 'OracleError';
 
-        if (connection.execute && !connection.execute.__whatap_wrapped__) {
-            shimmer.wrap(connection, 'execute', createExecuteWrapper(agent, dbc));
-            connection.execute.__whatap_wrapped__ = true;
-        }
-    }
-}
+        try {
+            var errorCode = args[0].errorNum || args[0].code || 'ORA-00000';
+            var errorMsg = ctx.error_message = args[0].message || 'Oracle error';
 
-function escapeLiteral(sql) {
-    if (sql == null) {
-        sql = '';
-    }
-
-    if (date !== DateUtil.yyyymmdd()) {
-        checkedSql.clear();
-        nonLiteSql.clear();
-        date = DateUtil.yyyymmdd();
-    }
+            if (conf._is_trace_ignore_err_cls_contains === true && errorCode.toString().indexOf(conf.trace_ignore_err_cls_contains) < 0) {
+                step.error = StatError.addError('oracle-' + errorCode, errorMsg, ctx.service_hash, TextTypes.SQL, step.hash);
+                if (ctx.error.isZero()) {
+                    ctx.error = step.error;
+                }
+            } else if (conf._is_trace_ignore_err_msg_contains === true && errorMsg.indexOf(conf.trace_ignore_err_msg_contains) < 0) {
+                step.error = StatError.addError('oracle-' + errorCode, errorMsg, ctx.service_hash, TextTypes.SQL, step.hash);
+                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('oracle-' + errorCode, errorMsg, ctx.service_hash, TextTypes.SQL, step.hash);
+                if (ctx.error.isZero()) {
+                    ctx.error = step.error;
+                }
+            }
 
-    var sqlHash = HashUtil.hashFromString(sql);
-    var psql = nonLiteSql.get(sqlHash);
+            if (conf.trace_sql_error_stack && conf.trace_sql_error_depth) {
+                var traceDepth = conf.trace_sql_error_depth;
+                if (args[0].stack) {
+                    var errorStack = args[0].stack.split("\n");
+                    if (errorStack.length > traceDepth) {
+                        errorStack = errorStack.slice(0, traceDepth + 1);
+                    }
+                    ctx.error_message = errorStack.join("\n");
+                }
+            }
+        } catch (e) {
+            Logger.printError('WHATAP-110', 'OracleObserver error delegate exception', e, false);
+            ctx.error_message = 'Oracle error processing failed';
+        }
+    };
+};
 
-    if (psql != null) {
-        return psql;
-    }
-    psql = checkedSql.get(sqlHash);
+// 커넥션 풀 관리 함수
+OracleObserver.prototype._wrapPoolOrConnection = function (obj, dbc) {
+    var self = this;
 
-    if (psql != null) {
-        return psql;
+    if (obj.__whatap_observed) {
+        return;
     }
+    obj.__whatap_observed = true;
 
-    var els = new EscapeLiteralSQL(sql);
-    els.process();
-
-    var hash = HashUtil.hashFromString(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;
-}
-
-var createExecuteWrapper = function(agent, dbcUrl) {
-    return function(original) {
-        return function wrappedExecute() {
-            var args = Array.prototype.slice.call(arguments);
-            var ctx = TraceContextManager.getCurrentContext();
+    // execute 메소드 래핑
+    if (obj.execute && typeof obj.execute === 'function') {
+        shimmer.wrap(obj, 'execute', function (original) {
+            return function () {
+                var ctx = TraceContextManager.getCurrentContext();
+                var args = Array.from(arguments);
 
-            if (ctx == null || args[0] == null) {
-                return original.apply(this, arguments);
-            }
+                if (ctx == null || args.length === 0) {
+                    return original.apply(this, args);
+                }
 
-            if (dbcUrl === 'oracle://' || !dbc_hash) {
-                return original.apply(this, arguments);
-            }
+                var sql = args[0];
+                if (sql == null) {
+                    return original.apply(this, args);
+                }
 
-            const asyncResource = new AsyncResource('oracle-execute');
-            const callbackResource = new AsyncResource('oracle-callback');
+                // DBC 단계 생성
+                var dbc_hash = HashUtil.hashFromString(dbc);
 
-            return asyncResource.runInAsyncScope(() => {
-                ctx.start_time = Date.now();
-                ctx.elapsed = 0;
-                AsyncSender.send_packet(PacketTypeEnum.TX_DB_CONN, ctx, [dbcUrl]);
+                // SQL 단계 생성
+                var sql_step = new SqlStepX();
+                sql_step.start_time = ctx.getElapsedTime();
+                ctx.profile.push(sql_step);
 
-                var sql_start_time = Date.now();
                 ctx.footprint('Oracle Query Start');
                 ctx.sql_count++;
 
-                var sql = args.length > 0 ? args[0] : undefined;
-                var params = args.length > 1 ? args[1] : null;
-                var finalSql = '';
-
-                try {
-                    if (typeof sql === 'string') {
-                        finalSql = sql;
-
-                        // Oracle 파라미터 치환 (:name 형태)
-                        if (params && typeof params === 'object') {
-                            if (Array.isArray(params)) {
-                                // 배열 형태 파라미터 [value1, value2, ...]
-                                params.forEach((param, index) => {
-                                    const placeholder = ':' + (index + 1);
-                                    const value = param === null ? 'NULL' :
-                                        typeof param === 'string' ? `'${param.replace(/'/g, "''")}'` :
-                                            String(param);
-                                    finalSql = finalSql.replace(new RegExp(':' + (index + 1) + '\\b', 'g'), value);
-                                });
-                            } else {
-                                // 객체 형태 파라미터 {name: value, id: value}
-                                Object.keys(params).forEach(key => {
-                                    const placeholder = ':' + key;
-                                    const value = params[key] === null ? 'NULL' :
-                                        typeof params[key] === 'string' ? `'${params[key].replace(/'/g, "''")}'` :
-                                            String(params[key]);
-                                    finalSql = finalSql.replace(new RegExp(':' + key + '\\b', 'g'), value);
-                                });
-                            }
-                        }
-                    }
-                } catch (formatError) {
-                    Logger.printError('WHATAP-ORACLE-FORMAT', 'Error formatting Oracle query', formatError, false);
-                    if (typeof sql === 'string') {
-                        finalSql = sql;
-                    }
-                }
-
-                if (typeof finalSql !== 'string' || finalSql.length === 0) {
-                    finalSql = '';
-                }
-
                 var psql = null;
-                if (typeof finalSql === 'string' && finalSql.length > 0) {
+                if (typeof sql === 'string' && sql.length > 0) {
                     try {
-                        psql = escapeLiteral(finalSql);
-                        Logger.print('WHATAP-SQL-DEBUG', 'Processing SQL: ' + finalSql.substring(0, 200), false);
+                        psql = escapeLiteral(sql);
                     } catch (e) {
-                        Logger.printError('WHATAP-252', 'OracleObserver escapeliteral error', e, false);
+                        Logger.printError('WHATAP-111', 'OracleObserver escapeliteral error', e, false);
                     }
                 } else {
-                    psql = escapeLiteral(finalSql);
+                    sql = '';
+                    psql = escapeLiteral(sql);
                 }
 
-                ctx.active_sqlhash = true;
-                ctx.active_dbc = dbc_hash;
-
-                function executeCallback(err, results) {
-                    var currentCtx = TraceContextManager.getCurrentContext();
-                    if (currentCtx == null) {
-                        return;
-                    }
+                if (psql != null) {
+                    sql_step.hash = psql.sql;
+                    // sql_step.crud = psql.type.charCodeAt(0);
+                }
+                sql_step.dbc = dbc_hash;
 
-                    TraceContextManager.resume(currentCtx.id);
+                var els = new EscapeLiteralSQL(sql);
+                els.process();
 
-                    var sql_elapsed = Date.now() - sql_start_time;
-                    var resultCount = 0;
+                ctx.active_sqlhash = sql_step.hash;
+                ctx.active_dbc = sql_step.dbc;
+                //ctx.active_crud = sql_step.crud;
 
-                    if (err) {
-                        handleSqlError(currentCtx, err);
-                    }
+                // 파라미터 처리
+                if (conf.profile_sql_param_enabled) {
+                    var params = args.length > 1 ? args[1] : undefined;
+                    if (params) {
+                        sql_step.setTrue(1);
+                        var crc = {value: 0};
+                        sql_step.p1 = toParamBytes(psql.param, crc);
 
-                    if (!err && results) {
-                        if (results.rows && Array.isArray(results.rows)) {
-                            resultCount = results.rows.length;
-                        } else if (results.rowsAffected !== undefined) {
-                            resultCount = results.rowsAffected;
+                        if (params != undefined) {
+                            try {
+                                // Oracle 파라미터는 객체 형태일 수 있음
+                                let paramStr = '';
+                                if (typeof params === 'object' && !Array.isArray(params)) {
+                                    paramStr = Object.entries(params).map(([key, value]) => {
+                                        if (typeof value === 'string') {
+                                            return `${key}='${value}'`;
+                                        }
+                                        return `${key}=${value}`;
+                                    }).join(', ');
+                                } else if (Array.isArray(params)) {
+                                    paramStr = params.map((param) => {
+                                        if (typeof param === 'string') {
+                                            return `'${param}'`;
+                                        }
+                                        return param;
+                                    }).join(', ');
+                                } else {
+                                    paramStr = String(params);
+                                }
+                                sql_step.p2 = toParamBytes(paramStr, crc);
+                            } catch (e) {
+                                Logger.printError('WHATAP-112', 'Oracle param processing error', e, false);
+                            }
                         }
+                        sql_step.pcrc = crc.value;
                     }
+                }
 
-                    try {
-                        TraceSQL.isSlowSQL(currentCtx);
-                        if (!err && results && results.rows && Array.isArray(results.rows) && psql != null && psql.type === 'S') {
-                            TraceSQL.isTooManyRecords(resultCount, currentCtx);
+                // Check if the last argument is a callback
+                var hasCallback = false;
+                var callbackIndex = -1;
+
+                if (args.length > 0 && typeof args[args.length - 1] === 'function') {
+                    hasCallback = true;
+                    callbackIndex = args.length - 1;
+
+                    // Wrap callback to capture result
+                    var originalCallback = args[callbackIndex];
+                    args[callbackIndex] = function wrappedCallback(err, result) {
+                        if (ctx == null) {
+                            return originalCallback.apply(this, arguments);
                         }
-                    } catch (e) {
-                        Logger.printError('WHATAP-TRACESQL', 'Error in TraceSQL processing', e, false);
-                    }
 
-                    currentCtx.elapsed = sql_elapsed;
-                    currentCtx.active_sqlhash = false;
-                    AsyncSender.send_packet(PacketTypeEnum.TX_SQL, currentCtx, [dbcUrl, finalSql, String(resultCount)]);
+                        TraceContextManager.resume(ctx._id);
 
-                    currentCtx.footprint('Oracle Query Done');
-                }
+                        sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+                        ctx.sql_time += sql_step.elapsed;
 
-                var callbackWrapped = false;
-                var hasCallback = false;
+                        if (err) {
+                            errorDelegate(ctx, sql_step)(null, [err]);
+                            ctx.footprint('Oracle Query Error');
+                        } else {
+                            ctx.footprint('Oracle Query Done');
 
-                // 콜백 찾기 및 래핑
-                for (var i = args.length - 1; i >= 0; i--) {
-                    if (typeof args[i] === 'function') {
-                        hasCallback = true;
-                        var originalCallback = args[i];
-                        args[i] = callbackResource.bind(function() {
-                            var callbackArgs = Array.prototype.slice.call(arguments);
-                            try {
-                                executeCallback(callbackArgs[0], callbackArgs[1]);
-                            } catch (e) {
-                                Logger.printError('WHATAP-CALLBACK', 'Error in callback hook', e, false);
+                            // Process result for SELECT queries
+                            if (result && result.rows && Array.isArray(result.rows) && psql != null && psql.type === 'S') {
+                                var result_step = new ResultSetStep();
+                                result_step.start_time = ctx.getElapsedTime();
+                                result_step.elapsed = 0;
+                                result_step.fetch = result.rows.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 + result.rows.length : result.rows.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);
                             }
-                            if (originalCallback && typeof originalCallback === 'function') {
-                                return originalCallback.apply(this, callbackArgs);
+
+                            // Process affectedRows for UPDATE/INSERT/DELETE
+                            if (result != null && psql != null && (psql.type === 'U' || psql.type === 'I' || psql.type === 'D')) {
+                                if (result.rowsAffected !== undefined) {
+                                    sql_step.updated = result.rowsAffected || 0;
+                                }
                             }
-                        });
-                        callbackWrapped = true;
-                        break;
-                    }
+                        }
+
+                        MeterSql.add(dbc_hash, sql_step.elapsed, !!err);
+                        StatSql.addSqlTime(ctx.service_hash, sql_step.dbc,
+                            sql_step.hash, sql_step.elapsed, !!err, 0);
+
+                        return originalCallback.apply(this, arguments);
+                    };
                 }
 
                 try {
-                    const result = original.apply(this, args);
-
-                    // Promise 기반 처리
-                    if (!hasCallback && result && typeof result.then === 'function') {
-                        return result.then(function(res) {
-                            executeCallback(null, res);
-                            return res;
-                        }).catch(function(err) {
-                            executeCallback(err, null);
-                            throw err;
-                        });
-                    }
+                    // Handle promise-based execution
+                    if (!hasCallback) {
+                        return original.apply(this, args)
+                            .then(function (result) {
+                                // 성공 처리
+                                if (ctx == null) {
+                                    return result;
+                                }
+
+                                TraceContextManager.resume(ctx._id);
+
+                                sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+                                ctx.sql_time += sql_step.elapsed;
+
+                                TraceSQL.isSlowSQL(ctx);
+
+                                ctx.footprint('Oracle Query Done');
+
+                                MeterSql.add(dbc_hash, sql_step.elapsed, false);
+                                StatSql.addSqlTime(ctx.service_hash, sql_step.dbc,
+                                    sql_step.hash, sql_step.elapsed, false, 0);
+
+                                if (result && result.rows && Array.isArray(result.rows) && psql != null && psql.type === 'S') {
+                                    var result_step = new ResultSetStep();
+                                    result_step.start_time = ctx.getElapsedTime();
+                                    result_step.elapsed = 0;
+                                    result_step.fetch = result.rows.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 + result.rows.length : result.rows.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);
+                                }
+
+                                if (result != null && psql != null && (psql.type === 'U' || psql.type === 'I' || psql.type === 'D')) {
+                                    if (result.rowsAffected !== undefined) {
+                                        sql_step.updated = result.rowsAffected || 0;
+                                    }
+                                }
 
-                    return result;
-                } catch (executeError) {
-                    executeCallback(executeError, null);
-                    throw executeError;
+                                return result;
+                            })
+                            .catch(function (error) {
+                                if (ctx == null) {
+                                    throw error;
+                                }
+
+                                TraceContextManager.resume(ctx._id);
+                                errorDelegate(ctx, sql_step)(null, [error]);
+
+                                sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+                                ctx.sql_time += sql_step.elapsed;
+
+                                ctx.footprint('Oracle Query Error');
+
+                                MeterSql.add(dbc_hash, sql_step.elapsed, true);
+                                StatSql.addSqlTime(ctx.service_hash, sql_step.dbc,
+                                    sql_step.hash, sql_step.elapsed, true, 0);
+
+                                throw error;
+                            });
+                    } else {
+                        return original.apply(this, args);
+                    }
+                } catch (err) {
+                    if (ctx != null) {
+                        errorDelegate(ctx, sql_step)(null, [err]);
+                        sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+                        ctx.sql_time += sql_step.elapsed;
+                        ctx.footprint('Oracle Query Error');
+
+                        MeterSql.add(dbc_hash, sql_step.elapsed, true);
+                        StatSql.addSqlTime(ctx.service_hash, sql_step.dbc,
+                            sql_step.hash, sql_step.elapsed, true, 0);
+                    }
+                    throw err;
                 }
-            });
-        };
-    };
+            };
+        });
+    }
 };
 
 OracleObserver.prototype.inject = function (mod, moduleName) {
@@ -315,184 +359,315 @@ OracleObserver.prototype.inject = function (mod, moduleName) {
     mod.__whatap_observe__ = true;
     Logger.initPrint("OracleObserver");
 
+    var self = this;
+
     if (conf.sql_enabled === false) {
         return;
     }
 
-    var self = this;
+    shimmer.wrap(mod, 'getConnection', function (original) {
+        return function () {
+            var args = Array.from(arguments);
+            var connectionInfo = args[0] || {};
+            var ctx = TraceContextManager.getCurrentContext();
 
-    // getConnection 래핑
-    if (mod.getConnection && !mod.getConnection.__whatap_wrapped__) {
-        shimmer.wrap(mod, 'getConnection', function(original) {
-            return function wrappedGetConnection() {
-                var args = Array.prototype.slice.call(arguments);
-                var connectionInfo = args[0] || {};
-                var ctx = TraceContextManager.getCurrentContext();
+            var connectInfo = connectionInfo.connectString || connectionInfo.connectionString || '';
+            var user = connectionInfo.user || '';
+            var dbc = 'oracle://' + user + '@' + connectInfo;
+            var dbc_hash = HashUtil.hashFromString(dbc);
 
-                setupDbcInfo(connectionInfo);
+            DataTextAgent.DBC.add(dbc_hash, dbc);
+            DataTextAgent.METHOD.add(dbc_hash, dbc);
+            DataTextAgent.ERROR.add(dbc_hash, dbc);
 
-                if (ctx == null) {
-                    return original.apply(this, arguments);
-                }
+            var dbc_step = null;
 
-                const connectionResource = new AsyncResource('oracle-getconnection');
-
-                return connectionResource.runInAsyncScope(() => {
-                    ctx.start_time = Date.now();
-                    ctx.footprint('Oracle 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] = connectionResource.bind(function() {
-                                var callbackArgs = Array.prototype.slice.call(arguments);
-                                var err = callbackArgs[0];
-                                var connection = callbackArgs[1];
-
-                                if (ctx) {
-                                    TraceContextManager.resume(ctx.id);
-                                    ctx.elapsed = Date.now() - ctx.start_time;
-                                    ctx.db_opening = false;
-
-                                    if (err) {
-                                        handleSqlError(ctx, err);
-                                        ctx.footprint('Oracle Connecting Error');
-                                    } else {
-                                        ctx.footprint('Oracle Connecting Done');
-                                    }
-                                }
+            if (ctx) {
+                dbc_step = new DBCStep();
+                dbc_step.start_time = ctx.getElapsedTime();
+                dbc_step.hash = dbc_hash;
 
-                                if (connection) {
-                                    hookConnectionMethods(connection, self.agent);
-                                }
+                ctx.footprint('Oracle Connecting Start');
+                ctx.db_opening = true;
+                ctx.profile.push(dbc_step);
+            }
 
-                                return originalCallback.apply(this, callbackArgs);
-                            });
-                            break;
+            if (arguments.length > 0 && typeof arguments[arguments.length - 1] === 'function') {
+                var callbackIndex = arguments.length - 1;
+                var originalCallback = arguments[callbackIndex];
+
+                arguments[callbackIndex] = function wrappedCallback(err, connection) {
+                    if (ctx) {
+                        TraceContextManager.resume(ctx._id);
+
+                        if (err) {
+                            ctx.footprint('Oracle Connecting Error');
+                            if (dbc_step) {
+                                dbc_step.error = StatError.addError('oracle-' + (err.errorNum || 'ERROR'),
+                                    err.message || 'Oracle connection error', ctx.service_hash);
+                            }
+                        } else {
+                            ctx.footprint('Oracle Connecting Done');
+                        }
+
+                        ctx.db_opening = false;
+
+                        if (dbc_step) {
+                            dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
                         }
                     }
 
-                    var result = original.apply(this, args);
+                    if (connection) {
+                        connectionAttributes.set(connection, connectionInfo);
+                        self._wrapPoolOrConnection(connection, dbc);
+                    }
 
-                    // Promise 기반 처리
-                    if (result && typeof result.then === 'function') {
-                        return result.then(connectionResource.bind(function(connection) {
-                            if (ctx) {
-                                TraceContextManager.resume(ctx.id);
-                                ctx.elapsed = Date.now() - ctx.start_time;
-                                ctx.db_opening = false;
-                                ctx.footprint('Oracle Connecting Done');
-                            }
+                    return originalCallback.apply(this, arguments);
+                };
 
-                            if (connection) {
-                                hookConnectionMethods(connection, self.agent);
+                return original.apply(this, arguments);
+            } else {
+                return original.apply(this, args)
+                    .then(function (connection) {
+                        if (ctx) {
+                            TraceContextManager.resume(ctx._id);
+                            ctx.footprint('Oracle Connecting Done');
+                            ctx.db_opening = false;
+
+                            if (dbc_step) {
+                                dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
                             }
+                        }
+
+                        if (connection) {
+                            connectionAttributes.set(connection, connectionInfo);
+                            self._wrapPoolOrConnection(connection, dbc);
+                        }
 
-                            return connection;
-                        })).catch(connectionResource.bind(function(err) {
-                            if (ctx) {
-                                TraceContextManager.resume(ctx.id);
-                                ctx.elapsed = Date.now() - ctx.start_time;
-                                ctx.db_opening = false;
-                                ctx.footprint('Oracle Connecting Error');
-                                handleSqlError(ctx, err);
+                        return connection;
+                    })
+                    .catch(function (err) {
+                        if (ctx) {
+                            TraceContextManager.resume(ctx._id);
+                            ctx.footprint('Oracle Connecting Error');
+                            ctx.db_opening = false;
+
+                            if (dbc_step) {
+                                dbc_step.error = StatError.addError('oracle-' + (err.errorNum || 'ERROR'),
+                                    err.message || 'Oracle connection error', ctx.service_hash);
+                                dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
                             }
-                            throw err;
-                        }));
+                        }
+
+                        throw err;
+                    });
+            }
+        };
+    });
+
+    shimmer.wrap(mod, 'createPool', function (original) {
+        return function () {
+            var args = Array.from(arguments);
+            var poolAttrs = args[0] || {};
+
+            // Handle callback-style
+            if (args.length > 0 && typeof args[args.length - 1] === 'function') {
+                var callbackIndex = args.length - 1;
+                var originalCallback = args[callbackIndex];
+
+                args[callbackIndex] = function wrappedCallback(err, pool) {
+                    if (pool) {
+                        poolAttributes.set(pool, poolAttrs);
+                        if (!pool.__whatap_getconn_wrapped) {
+                            pool.__whatap_getconn_wrapped = true;
+                            shimmer.wrap(pool, 'getConnection', function(originalGetConn) {
+                                return self._wrapPoolGetConnection(originalGetConn, poolAttrs);
+                            });
+                        }
                     }
-                    return result;
-                });
-            };
+
+                    return originalCallback.apply(this, arguments);
+                };
+
+                return original.apply(this, args);
+            } else {
+                return original.apply(this, args)
+                    .then(function(pool) {
+                        if (pool) {
+                            poolAttributes.set(pool, poolAttrs);
+                            if (!pool.__whatap_getconn_wrapped) {
+                                pool.__whatap_getconn_wrapped = true;
+                                shimmer.wrap(pool, 'getConnection', function(originalGetConn) {
+                                    return self._wrapPoolGetConnection(originalGetConn, poolAttrs);
+                                });
+                            }
+                        }
+                        return pool;
+                    });
+            }
+        };
+    });
+
+    if (mod.Pool && mod.Pool.prototype && !mod.Pool.prototype.__whatap_getconn_wrapped) {
+        mod.Pool.prototype.__whatap_getconn_wrapped = true;
+        shimmer.wrap(mod.Pool.prototype, 'getConnection', function(original) {
+            return self._wrapPoolGetConnection(original);
         });
-        mod.getConnection.__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);
-                var poolAttrs = args[0] || {};
+// Helper function to wrap a pool's getConnection method
+OracleObserver.prototype._wrapPoolGetConnection = function(originalGetConn, poolAttrs) {
+    var self = this;
 
-                setupDbcInfo(poolAttrs);
+    if (originalGetConn.__whatap_wrapped) {
+        return originalGetConn;
+    }
 
-                var result = original.apply(this, args);
+    function wrappedGetConnection() {
+        var args = Array.from(arguments);
+        var ctx = TraceContextManager.getCurrentContext();
 
-                // 콜백 방식 처리
-                if (args.length > 0 && typeof args[args.length - 1] === 'function') {
-                    return result;
-                }
+        var poolInfo = poolAttrs || poolAttributes.get(this) || {};
+        var connectInfo = poolInfo.connectString || poolInfo.connectionString || '';
+        var user = poolInfo.user || '';
+        var dbc = 'oracle://' + user + '@' + connectInfo;
+        var dbc_hash = HashUtil.hashFromString(dbc);
 
-                // Promise 방식 처리
-                if (result && typeof result.then === 'function') {
-                    return result.then(function(pool) {
-                        if (pool && !hookedInstances.has(pool)) {
-                            hookedInstances.add(pool);
+        DataTextAgent.DBC.add(dbc_hash, dbc);
+        DataTextAgent.METHOD.add(dbc_hash, dbc);
+        DataTextAgent.ERROR.add(dbc_hash, dbc);
 
-                            if (pool.getConnection && !pool.getConnection.__whatap_wrapped__) {
-                                shimmer.wrap(pool, 'getConnection', function(originalGetConn) {
-                                    return function wrappedPoolGetConnection() {
-                                        var args = Array.prototype.slice.call(arguments);
-                                        var ctx = TraceContextManager.getCurrentContext();
+        var dbc_step = null;
 
-                                        if (ctx == null) {
-                                            return originalGetConn.apply(this, arguments);
-                                        }
+        if (ctx) {
+            dbc_step = new DBCStep();
+            dbc_step.start_time = ctx.getElapsedTime();
+            dbc_step.hash = dbc_hash;
 
-                                        const poolConnectionResource = new AsyncResource('oracle-pool-getconnection');
-
-                                        return poolConnectionResource.runInAsyncScope(() => {
-                                            ctx.start_time = Date.now();
-                                            ctx.footprint('Oracle Pool Connection Start');
-                                            ctx.db_opening = true;
-
-                                            var result = originalGetConn.apply(this, args);
-
-                                            // Promise 기반 처리
-                                            if (result && typeof result.then === 'function') {
-                                                return result.then(poolConnectionResource.bind(function(connection) {
-                                                    if (ctx) {
-                                                        TraceContextManager.resume(ctx.id);
-                                                        ctx.elapsed = Date.now() - ctx.start_time;
-                                                        ctx.db_opening = false;
-                                                        ctx.footprint('Oracle Pool Connection Done');
-                                                    }
-
-                                                    if (connection) {
-                                                        hookConnectionMethods(connection, self.agent);
-                                                    }
-
-                                                    return connection;
-                                                })).catch(poolConnectionResource.bind(function(err) {
-                                                    if (ctx) {
-                                                        TraceContextManager.resume(ctx.id);
-                                                        ctx.elapsed = Date.now() - ctx.start_time;
-                                                        ctx.db_opening = false;
-                                                        ctx.footprint('Oracle Pool Connection Error');
-                                                        handleSqlError(ctx, err);
-                                                    }
-                                                    throw err;
-                                                }));
-                                            }
-
-                                            return result;
-                                        });
-                                    };
-                                });
-                                pool.getConnection.__whatap_wrapped__ = true;
-                            }
+            ctx.footprint('Oracle Pool Connection Start');
+            ctx.db_opening = true;
+            ctx.profile.push(dbc_step);
+        }
+
+        if (args.length > 0 && typeof args[args.length - 1] === 'function') {
+            var callbackIndex = args.length - 1;
+            var originalCallback = args[callbackIndex];
+
+            args[callbackIndex] = function(err, connection) {
+                if (ctx) {
+                    TraceContextManager.resume(ctx._id);
+
+                    if (err) {
+                        ctx.footprint('Oracle Pool Connection Error');
+                        if (dbc_step) {
+                            dbc_step.error = StatError.addError('oracle-' + (err.errorNum || 'ERROR'),
+                                err.message || 'Oracle connection error', ctx.service_hash);
                         }
-                        return pool;
-                    });
+                    } else {
+                        ctx.footprint('Oracle Pool Connection Done');
+                    }
+
+                    ctx.db_opening = false;
+
+                    if (dbc_step) {
+                        dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
+                    }
                 }
 
-                return result;
+                if (connection) {
+                    connectionAttributes.set(connection, poolInfo);
+                    self._wrapPoolOrConnection(connection, dbc);
+                }
+
+                return originalCallback.apply(this, arguments);
             };
-        });
-        mod.createPool.__whatap_wrapped__ = true;
-    }
+
+            return originalGetConn.apply(this, args);
+        } else {
+            return originalGetConn.apply(this, args)
+                .then(function(connection) {
+                    if (ctx) {
+                        TraceContextManager.resume(ctx._id);
+                        ctx.footprint('Oracle Pool Connection Done');
+                        ctx.db_opening = false;
+
+                        if (dbc_step) {
+                            dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
+                        }
+                    }
+
+                    if (connection) {
+                        connectionAttributes.set(connection, poolInfo);
+                        self._wrapPoolOrConnection(connection, dbc);
+                    }
+
+                    return connection;
+                })
+                .catch(function(err) {
+                    if (ctx) {
+                        TraceContextManager.resume(ctx._id);
+                        ctx.footprint('Oracle Pool Connection Error');
+                        ctx.db_opening = false;
+
+                        if (dbc_step) {
+                            dbc_step.error = StatError.addError('oracle-' + (err.errorNum || 'ERROR'),
+                                err.message || 'Oracle connection error', ctx.service_hash);
+                            dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
+                        }
+                    }
+
+                    throw err;
+                });
+        }
+    };
+
+    wrappedGetConnection.__whatap_wrapped = true;
+    return wrappedGetConnection;
 };
 
+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', 'OracleObserver CLEAR SQL Cache', 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.OracleObserver = OracleObserver;