whatap 1.0.2 → 1.0.3-canary.0

package/lib/observers/pgsql-observer.js

@@ -5,25 +5,18 @@
  */
 
 var TraceContextManager = require('../trace/trace-context-manager'),
-    ParsedSql           = require('../trace/parsed-sql'),
-    SqlStepX            = require('../step/sql-stepx'),
-    DBCStep             = require('../step/dbc-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'),
-    Buffer              = require('buffer').Buffer,
-    DateUtil            = require('../util/dateutil'),
-    TraceSQL                 = require('../trace/trace-sql');
-const shimmer = require('../core/shimmer');
-const ResultSetStep = require("../step/resultset-step");
+    ParsedSql = require('../trace/parsed-sql'),
+    conf = require('../conf/configure'),
+    IntKeyMap = require('../util/intkey-map'),
+    EscapeLiteralSQL = require('../util/escape-literal-sql'),
+    HashUtil = require('../util/hashutil'),
+    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;
 
 var PgSqlObserver = function (agent) {
     this.agent = agent;
@@ -31,274 +24,539 @@ var PgSqlObserver = function (agent) {
 };
 
 var dbc_hash = 0;
-var dbc, dbc_step;
-PgSqlObserver.prototype.inject = function (mod, moduleName) {
-    if (mod.__whatap_observe__) { return; }
-    mod.__whatap_observe__ = true;
+var dbc = 'postgresql://';
 
-    Logger.initPrint("PgSqlObserver");
+var hookedInstances = new WeakSet();
 
-    var self = this;
-    var aop = self.agent.aop;
+var checkedSql = new IntKeyMap(2000).setMax(2000);
+var nonLiteSql = new IntKeyMap(5000).setMax(5000);
+var date = DateUtil.yyyymmdd();
 
-    if (conf.sql_enabled === false) { return; }
+function handleSqlError(ctx, err) {
+    if (!err) return;
 
-    shimmer.wrap(mod.Client.prototype, 'connect', function (original) {
-        return function () {
-            const ctx = TraceContextManager.getCurrentContext();
-            if (!ctx || ctx.db_opening) {
-                return original.apply(this, arguments);
+    try {
+        var errorClass = err.code || err.name || err.constructor?.name || 'PostgreSQLError';
+        var errorMessage = err.message || 'postgresql 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");
+        }
+
+        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;
+        }
+
+        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);
             }
 
-            ctx.pg_opening = true;
-            ctx.footprint('PgSql Connecting Start');
+            AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+        }
+    } catch (e) {
+        Logger.printError('WHATAP-204', 'Error handling PgSQL error', e, false);
+    }
+}
 
-            dbc_step = new DBCStep();
-            dbc_step.start_time = ctx.getElapsedTime();
+function setupDbcInfo(args) {
+    if (dbc_hash === 0 && args.length > 0) {
+        var info = args[0] || {};
+        dbc = 'postgresql://';
+        dbc += (info.user || '') + '@';
+        dbc += (info.host || '') + '/';
+        dbc += info.database || '';
+        dbc_hash = HashUtil.hashFromString(dbc);
+    }
+}
 
-            const finishConnect = function (param) {
-                if (ctx) {
-                    if (dbc_hash === 0) {
-                        const info = param.connectionParameters;
-                        dbc = 'postgresql://';
-                        dbc += (info.user || '') + '@';
-                        dbc += (info.host || '') + '/';
-                        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);
-                    }
-                    //
-                    // dbc_step.hash = dbc_hash;
-                    // dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
-                    //
-                    // ctx.db_opening = false;
-                    // ctx.footprint('PgSql Connecting Done');
-                    // ctx.profile.push(dbc_step);
-                }
-            };
+function hookConnectionMethods(connection, agent) {
+    if (connection && !hookedInstances.has(connection)) {
+        hookedInstances.add(connection);
+        Logger.print('WHATAP-201', 'Hooking new connection object', false);
+
+        if (dbc_hash === 0 && connection.connectionParameters) {
+            var info = connection.connectionParameters;
+            dbc = 'postgresql://';
+            dbc += (info.user || '') + '@';
+            dbc += (info.host || '') + '/';
+            dbc += info.database || '';
+            dbc_hash = HashUtil.hashFromString(dbc);
+        }
+
+        if (connection.query && !connection.query.__whatap_wrapped__) {
+            shimmer.wrap(connection, 'query', createQueryWrapper(agent, dbc));
+            connection.query.__whatap_wrapped__ = true;
+        }
+    }
+}
 
-            try {
-                const result = original.apply(this, arguments);
+function escapeLiteral(sql) {
+    if (sql == null) {
+        sql = '';
+    }
 
-                if (result && result.then) {
-                    result.then(finishConnect(this));
-                } else {
-                    finishConnect(this);
-                }
+    if (date !== DateUtil.yyyymmdd()) {
+        checkedSql.clear();
+        nonLiteSql.clear();
+        date = DateUtil.yyyymmdd();
+    }
 
-            } catch (err) {
-                ctx.db_opening = false;
-                Logger.printError('PgSqlObserver', 'Connect Error', err);
-                throw err;
-            }
-        };
-    });
+    var sqlHash = HashUtil.hashFromString(sql);
+    var psql = nonLiteSql.get(sqlHash);
+
+    if (psql != null) {
+        return psql;
+    }
+    psql = checkedSql.get(sqlHash);
+
+    if (psql != null) {
+        return psql;
+    }
 
-    shimmer.wrap(mod.Client.prototype, 'query', function (original) {
-        return function () {
-            const ctx = TraceContextManager.getCurrentContext();
-            if (!ctx) {
+    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 createQueryWrapper = function(agent, dbcUrl) {
+    return function(original) {
+        return function wrappedQuery() {
+            var args = Array.prototype.slice.call(arguments);
+            var ctx = TraceContextManager.getCurrentContext();
+
+            if (ctx == null || args[0] == null) {
                 return original.apply(this, arguments);
             }
 
-            if(dbc && dbc_hash){
-                if(!dbc_step){
-                    dbc_step = new DBCStep();
-                    dbc_step.start_time = ctx.getElapsedTime();
-                }
-                dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
-                dbc_step.hash = dbc_hash;
+            if (dbcUrl === 'postgresql://' || !dbc_hash) {
+                return original.apply(this, arguments);
+            }
 
-                DataTextAgent.DBC.add(dbc_hash, dbc);
-                DataTextAgent.METHOD.add(dbc_hash, dbc);
-                DataTextAgent.ERROR.add(dbc_hash, dbc);
+            const asyncResource = new AsyncResource('pg-query');
+            const callbackResource = new AsyncResource('pg-callback');
 
-                ctx.pg_opening = false;
-                ctx.footprint('PgSql Connecting Done');
-                ctx.profile.push(dbc_step);
-            }
-            dbc_step = null;
+            return asyncResource.runInAsyncScope(() => {
+                ctx.start_time = Date.now();
+                ctx.elapsed = 0;
+                ctx.active_sqlhash = true;
+                AsyncSender.send_packet(PacketTypeEnum.TX_DB_CONN, ctx, [dbcUrl]);
 
-            var sql_step = new SqlStepX();
-            sql_step.start_time = ctx.getElapsedTime();
-            ctx.profile.push(sql_step);
-            ctx.footprint('PgSql Query Start');
+                var sql_start_time = Date.now();
+                ctx.footprint('PgSql Query Start');
+                ctx.sql_count++;
 
-            ctx.vvv++;
+                var sql = args.length > 0 ? args[0] : undefined;
+                var params = null;
+                var finalSql = '';
 
-            let sql = arguments[0];
-            let psql = null;
-            if (typeof sql === 'string' && sql.length > 0) {
                 try {
-                    psql = escapeLiteral(sql);
-                } catch (e) {
-                    Logger.printError('WHATAP-191', 'PgSqlObserver escapeliteral error', e);
+                    if (sql !== null && typeof sql === 'object') {
+                        finalSql = sql.text || sql.query || '';
+                        params = sql.values || null;
+                    } else if (typeof sql === 'string') {
+                        finalSql = sql;
+                        params = args.length > 1 && Array.isArray(args[1]) ? args[1] : null;
+                    }
+
+                    if (typeof finalSql === 'string' && finalSql.length > 0 && params && Array.isArray(params) && params.length > 0) {
+                        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('\\' + placeholder + '\\b', 'g'), value);
+                        });
+                    }
+                } catch (formatError) {
+                    Logger.printError('WHATAP-205', 'Error formatting PostgreSQL query', formatError, false);
+                    if (typeof sql === 'string') {
+                        finalSql = sql;
+                    } else if (sql && sql.text) {
+                        finalSql = sql.text;
+                    }
                 }
-            } else {
-                sql = '';
-                psql = escapeLiteral(sql);
-            }
 
-            if(psql != null) {
-                sql_step.hash = psql.sql;
-            }
-            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 = arguments.length > 1 && Array.isArray(arguments[1]) ? arguments[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);
+                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-202', 'Processing SQL: ' + finalSql.substring(0, 200), false);
+                    } catch (e) {
+                        Logger.printError('WHATAP-206', 'PgSqlObserver escapeliteral error', e, false);
+                    }
+                } else {
+                    psql = escapeLiteral(finalSql);
                 }
-                sql_step.pcrc = crc.value;
-            }
 
-            try {
-                const result = original.apply(this, arguments);
+                var sqlHash = psql ? psql.sql : 0;
+                ctx.active_sqlhash = sqlHash;
+                ctx.active_dbc = dbc_hash;
 
-                if (result && result.then) {
-                    return result.then(res => {
-                        if(res.command && res.command === 'SELECT'){
-                            var result_step = new ResultSetStep();
-                            result_step.start_time = ctx.getElapsedTime();
-                            result_step.elapsed = 0;
-                            result_step.fetch = res.rowCount;
-                            result_step.sqlhash = psql.sql;
-                            result_step.dbc = dbc_hash;
-                            ctx.profile.push(result_step);
+                function queryCallback(err, results) {
+                    var currentCtx = TraceContextManager.getCurrentContext();
+                    if (currentCtx == null) {
+                        return;
+                    }
 
-                            ctx.rs_count = ctx.rs_count ? ctx.rs_count + res.rowCount : res.rowCount;
+                    TraceContextManager.resume(currentCtx.id);
 
-                            MeterSql.addFetch(result_step.dbc, result_step.fetch, 0);
-                            StatSql.addFetch(result_step.dbc, result_step.sqlhash, result_step.fetch, 0);
+                    var sql_elapsed = Date.now() - sql_start_time;
+                    var resultCount = 0;
 
-                            TraceSQL.isTooManyRecords(sql_step, result_step.fetch, ctx);
+                    if (err) {
+                        handleSqlError(currentCtx, err);
+                    }
+
+                    if (!err && results) {
+                        if (results.rowCount !== undefined) {
+                            resultCount = results.rowCount;
+                        } else if (results.rows && Array.isArray(results.rows)) {
+                            resultCount = results.rows.length;
                         }
-                        self._finishQuery(ctx, sql_step);
-                        return res;
-                    }).catch(err => {
-                        self._handleError(ctx, sql_step, err)
-                        if (conf.trace_sql_error_stack && conf.trace_sql_error_depth) {
-                            var traceDepth = conf.trace_sql_error_depth;
-
-                            var errorStack = err.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('pgsql -' + err.code, err.message, ctx.service_hash, TextTypes.SQL, null);
+                    }
+
+                    try {
+                        TraceSQL.isSlowSQL(currentCtx);
+                        if (results && results.command && results.command === 'SELECT' && psql != null && psql.type === 'S') {
+                            TraceSQL.isTooManyRecords(resultCount, currentCtx);
                         }
-                        throw err;
-                    });
-                } else {
-                    const callback = arguments[arguments.length - 1];
-                    if (typeof callback === 'function') {
-                        arguments[arguments.length - 1] = function (err, res) {
-                            if (err) {
-                                self._handleError(ctx, sql_step, err);
-                            } else {
-                                self._finishQuery(ctx, sql_step);
+                    } catch (e) {
+                        Logger.printError('WHATAP-207', '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)]);
+
+                    currentCtx.footprint('PgSql Query Done');
+                }
+
+                var callbackWrapped = false;
+                var hasCallback = false;
+
+                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 {
+                                queryCallback(callbackArgs[0], callbackArgs[1]);
+                            } catch (e) {
+                                Logger.printError('WHATAP-208', 'Error in callback hook', e, false);
                             }
-                            return callback.apply(this, arguments);
-                        };
+                            if (originalCallback && typeof originalCallback === 'function') {
+                                return originalCallback.apply(this, callbackArgs);
+                            }
+                        });
+                        callbackWrapped = true;
+                        break;
+                    }
+                }
+
+                try {
+                    const result = original.apply(this, args);
+
+                    // Promise 기반 처리
+                    if (!hasCallback && result && typeof result.then === 'function') {
+                        return result.then(function(res) {
+                            queryCallback(null, res);
+                            return res;
+                        }).catch(function(err) {
+                            queryCallback(err, null);
+                            throw err;
+                        });
                     }
+
                     return result;
+                } catch (queryError) {
+                    queryCallback(queryError, null);
+                    throw queryError;
                 }
-            } catch (err) {
-                self._handleError(ctx, sql_step, err);
-                throw err;
-            }
+            });
         };
-    });
+    };
 };
 
-PgSqlObserver.prototype._finishQuery = function (ctx, sql_step) {
-    sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
-    TraceSQL.isSlowSQL(ctx);
+var wrapPoolConnect = function(agent) {
+    return function(original) {
+        return function wrappedPoolConnect() {
+            var args = Array.prototype.slice.call(arguments);
+            var ctx = TraceContextManager.getCurrentContext();
 
-    MeterSql.add(sql_step.hash, sql_step.elapsed, false);
-    StatSql.addSqlTime(ctx, ctx.service_hash, sql_step.dbc, sql_step.hash, sql_step.elapsed, false, 0);
-};
+            if (ctx == null) {
+                return original.apply(this, args);
+            }
+
+            // AsyncResource로 connect 컨텍스트 유지
+            const connectionResource = new AsyncResource('pg-pool-connect');
+            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 client = callbackArgs[1];
+
+                            TraceContextManager.resume(ctx.id);
+                            ctx.elapsed = Date.now() - ctx.start_time;
+
+                            if (!err && client && !client.__query_hook__) {
+                                client.__query_hook__ = true;
+                                hookConnectionMethods(client, agent);
+                            }
+
+                            return originalCallback.apply(this, callbackArgs);
+                        });
+                        break;
+                    }
+                }
+
+                var result = original.apply(this, args);
 
-PgSqlObserver.prototype._handleError = function (ctx, sql_step, err) {
-    ctx.error_message = err.message;
-    ctx.error_class = err.name || err.constructor?.name || 'PgsqlError';
-    sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
-    TraceSQL.isSlowSQL(ctx);
+                // Promise 기반 처리
+                if (result && typeof result.then === 'function' && args.every(arg => typeof arg !== 'function')) {
+                    return result.then(connectionResource.bind(function(client) {
+                        TraceContextManager.resume(ctx.id);
+                        ctx.elapsed = Date.now() - ctx.start_time;
 
-    MeterSql.add(sql_step.hash, sql_step.elapsed, false);
-    StatSql.addSqlTime(ctx, ctx.service_hash, sql_step.dbc, sql_step.hash, sql_step.elapsed, true, 0);
+                        if (client && !client.__query_hook__) {
+                            client.__query_hook__ = true;
+                            hookConnectionMethods(client, agent);
+                        }
+
+                        return client;
+                    }));
+                }
+
+                return result;
+            });
+        };
+    };
 };
 
-var toParamBytes = function(p, crc) {
-    if(p == null || p.length === 0) {
-        return null;
+PgSqlObserver.prototype.inject = function (mod, moduleName) {
+    if (mod.__whatap_observe__) {
+        return;
     }
-    try{
-        return ParamSecurity.encrypt(Buffer.from(p), crc);
-    } catch(e) {
-        return null;
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("PgSqlObserver");
+
+    if (conf.sql_enabled === false) {
+        return;
     }
-};
 
-var checkedSql = new IntKeyMap(2000).setMax(2000);
-var nonLiteSql = new IntKeyMap(5000).setMax(5000);
-var date = DateUtil.yyyymmdd();
+    var self = this;
 
-function escapeLiteral(sql) {
-    if(sql == null) { sql = ''; }
+    // Client 생성자 래핑
+    if (mod.Client && !mod.Client.__whatap_wrapped__) {
+        shimmer.wrap(mod, 'Client', function(original) {
+            return function wrappedClient() {
+                var args = Array.prototype.slice.call(arguments);
+                var ctx = TraceContextManager.getCurrentContext();
+
+                setupDbcInfo(args);
+
+                // if (ctx && !ctx.db_opening) {
+                //     ctx.db_opening = true;
+                //     ctx.footprint('PgSql Connecting Start');
+                //     ctx.start_time = Date.now();
+                // }
+
+                var client = new (Function.prototype.bind.apply(original, [null].concat(args)));
+
+                hookConnectionMethods(client, self.agent);
+
+                if (client && client.connect && !client.connect.__whatap_wrapped__) {
+                    shimmer.wrap(client, 'connect', function(original) {
+                        return function wrappedConnect() {
+                            var args = Array.prototype.slice.call(arguments);
+                            var ctx = TraceContextManager.getCurrentContext();
+
+                            if (ctx) {
+                                ctx.start_time = Date.now();
+                                ctx.footprint('PgSql 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);
+                                            }
+
+                                            ctx.db_opening = false;
+                                            ctx.footprint('PgSql Connecting Done');
+                                            TraceContextManager.resume(ctx.id);
+
+                                            return originalCallback.apply(this, callbackArgs);
+                                        };
+                                        break;
+                                    }
+                                }
+                            }
 
-    if(date !== DateUtil.yyyymmdd()) {
-        checkedSql.clear();
-        nonLiteSql.clear();
-        date = DateUtil.yyyymmdd();
-        Logger.print('WHATAP-SQL-CLEAR', 'PgSqlObserver CLEAR OK!!!!!!!!!!!!!!!!', false);
-    }
+                            var result = original.apply(this, args);
+
+                            // Promise 기반 처리
+                            if (result && typeof result.then === 'function') {
+                                return result.then(function() {
+                                    if (ctx) {
+                                        ctx.db_opening = false;
+                                        ctx.footprint('PgSql Connecting Done');
+                                    }
+                                    return result;
+                                }).catch(function(err) {
+                                    if (ctx) {
+                                        ctx.db_opening = false;
+                                        ctx.footprint('PgSql Connecting Error');
+                                        handleSqlError(ctx, err);
+                                    }
+                                    throw err;
+                                });
+                            }
 
-    var sqlHash = HashUtil.hashFromString(sql);
-    var psql = nonLiteSql.get(sqlHash);
+                            return result;
+                        };
+                    });
+                    client.connect.__whatap_wrapped__ = true;
+                }
 
-    if(psql != null) {
-        return psql;
+                if (ctx) {
+                    ctx.elapsed = Date.now() - ctx.start_time;
+                    ctx.footprint('PgSql Client Created');
+                    ctx.db_opening = false;
+                }
+
+                return client;
+            };
+        });
+        mod.Client.__whatap_wrapped__ = true;
     }
-    psql = checkedSql.get(sqlHash);
 
-    if(psql != null) {
-        return psql;
+    if (mod.Pool && !mod.Pool.__whatap_wrapped__) {
+        shimmer.wrap(mod, 'Pool', function(original) {
+            return function wrappedPool() {
+                var args = Array.prototype.slice.call(arguments);
+                setupDbcInfo(args);
+
+                var pool = new (Function.prototype.bind.apply(original, [null].concat(args)));
+
+                if (pool && !hookedInstances.has(pool)) {
+                    hookedInstances.add(pool);
+
+                    // Pool의 query 메서드 후킹
+                    if (pool.query && !pool.query.__whatap_wrapped__) {
+                        shimmer.wrap(pool, 'query', createQueryWrapper(self.agent, dbc));
+                        pool.query.__whatap_wrapped__ = true;
+                    }
+
+                    // Pool의 connect 메서드는 수동 연결 시에만 후킹
+                    // pool.query() 내부에서 자동으로 연결을 가져올 때는 후킹하지 않음
+                    if (pool.connect && !pool.connect.__whatap_wrapped__) {
+                        shimmer.wrap(pool, 'connect', function(original) {
+                            return function wrappedConnect() {
+                                var args = Array.prototype.slice.call(arguments);
+                                var result = original.apply(this, args);
+
+                                // Promise 기반 처리 - 연결 객체에만 후킹 (query는 후킹하지 않음)
+                                if (result && typeof result.then === 'function') {
+                                    return result.then(function(client) {
+                                        // client에는 query 후킹하지 않음 (pool.query()에서 이미 추적됨)
+                                        return client;
+                                    });
+                                } else if (result && typeof result === 'object') {
+                                    // 동기적으로 반환된 client에도 query 후킹하지 않음
+                                    return result;
+                                }
+
+                                return result;
+                            };
+                        });
+                        pool.connect.__whatap_wrapped__ = true;
+                    }
+                }
+
+                return pool;
+            };
+        });
+        mod.Pool.__whatap_wrapped__ = true;
     }
 
-    var els = new EscapeLiteralSQL(sql);
-    els.process();
+    if (mod.Client && mod.Client.prototype && mod.Client.prototype.query && !mod.Client.prototype.query.__whatap_wrapped__) {
+        shimmer.wrap(mod.Client.prototype, 'query', function(original) {
+            return function wrappedQuery() {
+                var args = Array.prototype.slice.call(arguments);
+                var ctx = TraceContextManager.getCurrentContext();
 
-    var hash = HashUtil.hashFromString(els.getParsedSql());
-    DataTextAgent.SQL.add(hash, els.getParsedSql());
+                if (ctx == null || args[0] == null) {
+                    return original.apply(this, arguments);
+                }
 
-    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);
+                if (dbc_hash === 0 && this.connectionParameters) {
+                    var info = this.connectionParameters;
+                    dbc = 'postgresql://';
+                    dbc += (info.user || '') + '@';
+                    dbc += (info.host || '') + '/';
+                    dbc += info.database || '';
+                    dbc_hash = HashUtil.hashFromString(dbc);
+                }
+
+                return createQueryWrapper(self.agent, dbc)(original).apply(this, args);
+            };
+        });
+        mod.Client.prototype.query.__whatap_wrapped__ = true;
     }
-    return psql;
-}
+
+    if (mod.Pool && mod.Pool.prototype && mod.Pool.prototype.query && !mod.Pool.prototype.query.__whatap_wrapped__) {
+        shimmer.wrap(mod.Pool.prototype, 'query', createQueryWrapper(self.agent, dbc));
+        mod.Pool.prototype.query.__whatap_wrapped__ = true;
+    }
+};
 
 exports.PgSqlObserver = PgSqlObserver;