whatap 0.5.12 → 0.5.13

package/lib/core/agent.js

@@ -32,7 +32,9 @@ var Interceptor      = require('./interceptor').Interceptor,
     ScheduleObserver = require('../observers/schedule-observer').ScheduleObserver,
     // GRpcObserver     = require('../observers/grpc-observer').GRpcObserver,
     ApolloObserver   = require('../observers/apollo-server-observer').ApolloServerObserver,
-    PrismaObserver  = require('../observers/prisma-observer').PrismaObserver;
+    PrismaObserver  = require('../observers/prisma-observer').PrismaObserver,
+    OracleObserver  = require('../observers/oracle-observer').OracleObserver;
+
 
 
 var Configuration    = require('./../conf/configure'),
@@ -279,6 +281,7 @@ NodeAgent.prototype.loadObserves = function() {
     // observes.push(GRpcObserver);
     observes.push(ApolloObserver);
     observes.push(PrismaObserver);
+    observes.push(OracleObserver);
 
     var packageToObserve = {};
     observes.forEach(function(observeObj) {

package/lib/observers/http-observer.js

@@ -513,6 +513,7 @@ HttpObserver.prototype.__endTransaction = function(error, ctx, req, res) {
         if(wtx.malloc < 0) { wtx.malloc = 0; }
         wtx.originUrl = ctx.originUrl;
 
+        wtx.cipher = HashUtil.hash(ParamSecurity.key);
         wtx.seq = ctx.txid;
         wtx.sqlCount = ctx.sql_count;
         wtx.sqlTime = ctx.sql_time;

package/lib/observers/oracle-observer.js

@@ -0,0 +1,656 @@
+/**
+ * Copyright 2023 the WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+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'),
+    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 toParamBytes = function (p, crc) {
+    if (p == null || p.length === 0) {
+        return null;
+    }
+    try {
+        return ParamSecurity.encrypt(Buffer.from(p, 'utf8'), crc);
+    } catch (e) {
+        return null;
+    }
+};
+
+var errorDelegate = function (ctx, step) {
+    return function (obj, args) {
+        if (ctx == null) {
+            return;
+        }
+
+        if (step == null) {
+            var laststep = ctx.profile.getLastSteps(1);
+            if (laststep == null || laststep.length === 0) {
+                return;
+            }
+            step = laststep[0];
+        }
+
+        MeterSql.add(step.dbc, step.elapsed, true);
+        StatSql.addSqlTime(ctx.service_hash, step.dbc, step.hash, step.elapsed, true, 0);
+
+        try {
+            var errorCode = args[0].errorNum || args[0].code || 'ORA-00000';
+            var errorMsg = args[0].message || 'Oracle error';
+
+            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;
+                }
+            }
+
+            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);
+        }
+    };
+};
+
+// 커넥션 풀 관리 함수
+OracleObserver.prototype._wrapPoolOrConnection = function (obj, dbc) {
+    var self = this;
+
+    if (obj.__whatap_observed) {
+        return;
+    }
+    obj.__whatap_observed = true;
+
+    // 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.length === 0) {
+                    return original.apply(this, args);
+                }
+
+                var sql = args[0];
+                if (sql == null) {
+                    return original.apply(this, args);
+                }
+
+                // DBC 단계 생성
+                var dbc_hash = HashUtil.hashFromString(dbc);
+
+                // SQL 단계 생성
+                var sql_step = new SqlStepX();
+                sql_step.start_time = ctx.getElapsedTime();
+                ctx.profile.push(sql_step);
+
+                ctx.footprint('Oracle Query Start');
+                ctx.sql_count++;
+
+                var psql = null;
+                if (typeof sql === 'string' && sql.length > 0) {
+                    try {
+                        psql = escapeLiteral(sql);
+                    } catch (e) {
+                        Logger.printError('WHATAP-111', 'OracleObserver escapeliteral error', e, false);
+                    }
+                } else {
+                    sql = '';
+                    psql = escapeLiteral(sql);
+                }
+
+                if (psql != null) {
+                    sql_step.hash = psql.sql;
+                    // sql_step.crud = psql.type.charCodeAt(0);
+                }
+                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 ? args[1] : undefined;
+                    if (params) {
+                        sql_step.setTrue(1);
+                        var crc = {value: 0};
+                        sql_step.p1 = toParamBytes(psql.param, crc);
+
+                        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;
+                    }
+                }
+
+                // 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);
+                        }
+
+                        TraceContextManager.resume(ctx._id);
+
+                        sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+                        ctx.sql_time += sql_step.elapsed;
+
+                        if (err) {
+                            errorDelegate(ctx, sql_step)(null, [err]);
+                            ctx.footprint('Oracle Query Error');
+                        } else {
+                            ctx.footprint('Oracle Query Done');
+
+                            // 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);
+                            }
+
+                            // 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;
+                                }
+                            }
+                        }
+
+                        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 {
+                    // 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(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) {
+    if (mod.__whatap_observe__) {
+        return;
+    }
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("OracleObserver");
+
+    var self = this;
+
+    if (conf.sql_enabled === false) {
+        return;
+    }
+
+    shimmer.wrap(mod, 'getConnection', function (original) {
+        return function () {
+            var args = Array.from(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);
+
+            DataTextAgent.DBC.add(dbc_hash, dbc);
+            DataTextAgent.METHOD.add(dbc_hash, dbc);
+            DataTextAgent.ERROR.add(dbc_hash, dbc);
+
+            var dbc_step = null;
+
+            if (ctx) {
+                dbc_step = new DBCStep();
+                dbc_step.start_time = ctx.getElapsedTime();
+                dbc_step.hash = dbc_hash;
+
+                ctx.footprint('Oracle Connecting Start');
+                ctx.db_opening = true;
+                ctx.profile.push(dbc_step);
+            }
+
+            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;
+                        }
+                    }
+
+                    if (connection) {
+                        connectionAttributes.set(connection, connectionInfo);
+                        self._wrapPoolOrConnection(connection, dbc);
+                    }
+
+                    return originalCallback.apply(this, arguments);
+                };
+
+                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(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;
+                    });
+            }
+        };
+    });
+
+    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);
+                        // Wrap Pool's getConnection method after pool is created
+                        shimmer.wrap(pool, 'getConnection', function(originalGetConn) {
+                            return self._wrapPoolGetConnection(originalGetConn, poolAttrs);
+                        });
+                    }
+
+                    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);
+                            shimmer.wrap(pool, 'getConnection', function(originalGetConn) {
+                                return self._wrapPoolGetConnection(originalGetConn, poolAttrs);
+                            });
+                        }
+                        return pool;
+                    });
+            }
+        };
+    });
+
+    if (mod.Pool && mod.Pool.prototype) {
+        shimmer.wrap(mod.Pool.prototype, 'getConnection', function(original) {
+            return self._wrapPoolGetConnection(original);
+        });
+    }
+};
+
+OracleObserver.prototype._wrapPoolGetConnection = function(originalGetConn, poolAttrs) {
+    var self = this;
+
+    return function wrappedGetConnection() {
+        var args = Array.from(arguments);
+        var ctx = TraceContextManager.getCurrentContext();
+
+        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);
+
+        DataTextAgent.DBC.add(dbc_hash, dbc);
+        DataTextAgent.METHOD.add(dbc_hash, dbc);
+        DataTextAgent.ERROR.add(dbc_hash, dbc);
+
+        var dbc_step = null;
+
+        if (ctx) {
+            dbc_step = new DBCStep();
+            dbc_step.start_time = ctx.getElapsedTime();
+            dbc_step.hash = dbc_hash;
+
+            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);
+                        }
+                    } else {
+                        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 originalCallback.apply(this, arguments);
+            };
+
+            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;
+                });
+        }
+    };
+};
+
+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;

package/lib/observers/prisma-observer.js

@@ -365,8 +365,8 @@ PrismaObserver.prototype.hookUseMiddleware = function(prismaInstance) {
             ctx.footprint(`Prisma ${modelName}.${action} Start`);
             ctx.sql_count = (ctx.sql_count || 0) + 1;
 
-            // 사용된 모델과 액션으로 SQL 문자열 구성
-            const queryInfo = `Prisma ${action.toUpperCase()} ${modelName}`;
+            // Prisma 쿼리 정보 직접 사용 (SQL 변환 없이)
+            const queryInfo = `Prisma ${modelName}.${action}`;
             const queryHash = HashUtil.hashFromString(queryInfo);
 
             DataTextAgent.SQL.add(queryHash, queryInfo);
@@ -388,6 +388,7 @@ PrismaObserver.prototype.hookUseMiddleware = function(prismaInstance) {
             try {
                 result = await next(params);
 
+                // Raw 쿼리 처리
                 if (action === "queryRaw" || action === "executeRaw" || action === "queryRawUnsafe" || action === "executeRawUnsafe") {
                     // SQL 문자열 추출
                     let sqlString = "";
@@ -408,10 +409,6 @@ PrismaObserver.prototype.hookUseMiddleware = function(prismaInstance) {
                             var psql = escapeLiteral(sqlString);
                             if (psql != null) {
                                 sql_step.hash = psql.sql;
-                                // CRUD 타입 설정 (S: Select, U: Update 등)
-                                // if (psql.type) {
-                                //     sql_step.crud = psql.type.charCodeAt(0);
-                                // }
                             }
 
                             // 추가 SQL 정보 처리
@@ -451,9 +448,8 @@ PrismaObserver.prototype.hookUseMiddleware = function(prismaInstance) {
                             recordCount = 1;
                         }
 
-                        if (recordCount > 0) {
-                            // 가장 최근에 처리된 SQL 해시 사용 (Raw 쿼리에서 업데이트된 경우)
-                            const sqlHashToUse = psql ? psql.sql : queryHash;
+                        if(psql && psql.sql){
+                            const sqlHashToUse = psql.sql;
 
                             var result_step = new ResultSetStep();
                             result_step.start_time = ctx.getElapsedTime();
@@ -484,23 +480,21 @@ PrismaObserver.prototype.hookUseMiddleware = function(prismaInstance) {
                         recordCount = 1;
                     }
 
-                    if (recordCount > 0) {
-                        var result_step = new ResultSetStep();
-                        result_step.start_time = ctx.getElapsedTime();
-                        result_step.elapsed = 0;
-                        result_step.fetch = recordCount;
-                        result_step.sqlhash = queryHash;
-                        result_step.dbc = dbc_hash;
-                        ctx.profile.push(result_step);
+                    var result_step = new ResultSetStep();
+                    result_step.start_time = ctx.getElapsedTime();
+                    result_step.elapsed = 0;
+                    result_step.fetch = recordCount;
+                    result_step.sqlhash = queryHash;
+                    result_step.dbc = dbc_hash;
+                    ctx.profile.push(result_step);
 
-                        ctx.rs_count = ctx.rs_count ? ctx.rs_count + recordCount : recordCount;
-                        ctx.rs_time = ctx.rs_time ? ctx.rs_time + sql_step.elapsed : sql_step.elapsed;
+                    ctx.rs_count = ctx.rs_count ? ctx.rs_count + recordCount : recordCount;
+                    ctx.rs_time = ctx.rs_time ? ctx.rs_time + sql_step.elapsed : sql_step.elapsed;
 
-                        MeterSql.addFetch(result_step.dbc, result_step.fetch, 0);
-                        StatSql.addFetch(result_step.dbc, result_step.sqlhash, result_step.fetch, 0);
+                    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);
-                    }
+                    TraceSQL.isTooManyRecords(sql_step, result_step.fetch, ctx);
                 }
 
                 // 수정된 레코드 수 처리 (create, update, delete 등)
@@ -512,252 +506,9 @@ PrismaObserver.prototype.hookUseMiddleware = function(prismaInstance) {
                     }
                 }
 
-                // findUnique, create 등의 메서드에 대한 SQL 형식의 정보 구성
-                if (modelName !== 'unknown' && action !== 'queryRaw' && action !== 'executeRaw' &&
-                    action !== 'queryRawUnsafe' && action !== 'executeRawUnsafe') {
-
-                    try {
-                        // 모델 메서드를 SQL 스타일로 변환
-                        let sqlStyleQuery = "";
-
-                        // 액션에 따라 SQL 명령 결정
-                        if (action.startsWith('find')) {
-                            sqlStyleQuery = "SELECT ";
-
-                            // select 필드가 있는 경우 해당 필드 사용
-                            if (params.args && params.args.select) {
-                                const fields = Object.keys(params.args.select)
-                                    .filter(key => params.args.select[key] === true);
-
-                                if (fields.length > 0) {
-                                    sqlStyleQuery += fields.join(", ");
-                                } else {
-                                    sqlStyleQuery += "*";
-                                }
-                            } else {
-                                sqlStyleQuery += "*";
-                            }
-
-                            sqlStyleQuery += ` FROM ${modelName}`;
-
-                            // where 조건 추가
-                            if (params.args && params.args.where) {
-                                const conditions = [];
-                                for (const [key, value] of Object.entries(params.args.where)) {
-                                    if (typeof value === 'object' && value !== null) {
-                                        // 복합 조건(contains, startsWith 등)
-                                        for (const [op, val] of Object.entries(value)) {
-                                            let sqlOp = "";
-
-                                            // Prisma 연산자를 SQL 연산자로 변환
-                                            switch (op) {
-                                                case 'equals': sqlOp = '='; break;
-                                                case 'not': sqlOp = '!='; break;
-                                                case 'in': sqlOp = 'IN'; break;
-                                                case 'notIn': sqlOp = 'NOT IN'; break;
-                                                case 'lt': sqlOp = '<'; break;
-                                                case 'lte': sqlOp = '<='; break;
-                                                case 'gt': sqlOp = '>'; break;
-                                                case 'gte': sqlOp = '>='; break;
-                                                case 'contains': sqlOp = 'LIKE'; break;
-                                                case 'startsWith': sqlOp = 'LIKE'; break;
-                                                case 'endsWith': sqlOp = 'LIKE'; break;
-                                                default: sqlOp = op;
-                                            }
-
-                                            let sqlVal = val;
-                                            if (op === 'contains') {
-                                                sqlVal = `'%${val}%'`;
-                                            } else if (op === 'startsWith') {
-                                                sqlVal = `'${val}%'`;
-                                            } else if (op === 'endsWith') {
-                                                sqlVal = `'%${val}'`;
-                                            } else if (typeof val === 'string') {
-                                                sqlVal = `'${val}'`;
-                                            } else if (Array.isArray(val)) {
-                                                sqlVal = `(${val.map(v => typeof v === 'string' ? `'${v}'` : v).join(', ')})`;
-                                            }
-
-                                            conditions.push(`${key} ${sqlOp} ${sqlVal}`);
-                                        }
-                                    } else {
-                                        // 단순 조건
-                                        let formattedValue = typeof value === 'string' ? `'${value}'` : value;
-                                        conditions.push(`${key} = ${formattedValue}`);
-                                    }
-                                }
-
-                                if (conditions.length > 0) {
-                                    sqlStyleQuery += ` WHERE ${conditions.join(' AND ')}`;
-                                }
-                            }
-
-                            // 정렬 조건 추가
-                            if (params.args && params.args.orderBy) {
-                                const orderClauses = [];
-
-                                if (Array.isArray(params.args.orderBy)) {
-                                    for (const item of params.args.orderBy) {
-                                        for (const [field, dir] of Object.entries(item)) {
-                                            orderClauses.push(`${field} ${dir}`);
-                                        }
-                                    }
-                                } else {
-                                    for (const [field, dir] of Object.entries(params.args.orderBy)) {
-                                        orderClauses.push(`${field} ${dir}`);
-                                    }
-                                }
-
-                                if (orderClauses.length > 0) {
-                                    sqlStyleQuery += ` ORDER BY ${orderClauses.join(', ')}`;
-                                }
-                            }
-
-                            // 페이징 정보 추가
-                            if (params.args) {
-                                if (params.args.skip !== undefined) {
-                                    sqlStyleQuery += ` OFFSET ${params.args.skip}`;
-                                }
-
-                                if (params.args.take !== undefined) {
-                                    sqlStyleQuery += ` LIMIT ${params.args.take}`;
-                                }
-                            }
-
-                        } else if (action.startsWith('create')) {
-                            sqlStyleQuery = `INSERT INTO ${modelName}`;
-
-                            if (params.args && params.args.data) {
-                                const columns = [];
-                                const values = [];
-
-                                for (const [key, val] of Object.entries(params.args.data)) {
-                                    columns.push(key);
-                                    if (typeof val === 'string') {
-                                        values.push(`'${val}'`);
-                                    } else if (val === null) {
-                                        values.push('NULL');
-                                    } else if (typeof val === 'object') {
-                                        values.push(`'${JSON.stringify(val)}'`);
-                                    } else {
-                                        values.push(val);
-                                    }
-                                }
-
-                                sqlStyleQuery += ` (${columns.join(', ')}) VALUES (${values.join(', ')})`;
-                            }
-
-                        } else if (action.startsWith('update')) {
-                            sqlStyleQuery = `UPDATE ${modelName}`;
-
-                            if (params.args && params.args.data) {
-                                const setExpressions = [];
-
-                                for (const [key, val] of Object.entries(params.args.data)) {
-                                    let formattedValue;
-                                    if (typeof val === 'string') {
-                                        formattedValue = `'${val}'`;
-                                    } else if (val === null) {
-                                        formattedValue = 'NULL';
-                                    } else if (typeof val === 'object') {
-                                        formattedValue = `'${JSON.stringify(val)}'`;
-                                    } else {
-                                        formattedValue = val;
-                                    }
-
-                                    setExpressions.push(`${key} = ${formattedValue}`);
-                                }
-
-                                if (setExpressions.length > 0) {
-                                    sqlStyleQuery += ` SET ${setExpressions.join(', ')}`;
-                                }
-                            }
-
-                            // where 조건 추가
-                            if (params.args && params.args.where) {
-                                const conditions = [];
-                                for (const [key, value] of Object.entries(params.args.where)) {
-                                    if (typeof value === 'object' && value !== null) {
-                                        for (const [op, val] of Object.entries(value)) {
-                                            let sqlOp = op === 'equals' ? '=' : op;
-                                            let sqlVal = typeof val === 'string' ? `'${val}'` : val;
-                                            conditions.push(`${key} ${sqlOp} ${sqlVal}`);
-                                        }
-                                    } else {
-                                        let formattedValue = typeof value === 'string' ? `'${value}'` : value;
-                                        conditions.push(`${key} = ${formattedValue}`);
-                                    }
-                                }
-
-                                if (conditions.length > 0) {
-                                    sqlStyleQuery += ` WHERE ${conditions.join(' AND ')}`;
-                                }
-                            }
-
-                        } else if (action.startsWith('delete')) {
-                            sqlStyleQuery = `DELETE FROM ${modelName}`;
-
-                            // where 조건 추가
-                            if (params.args && params.args.where) {
-                                const conditions = [];
-                                for (const [key, value] of Object.entries(params.args.where)) {
-                                    if (typeof value === 'object' && value !== null) {
-                                        for (const [op, val] of Object.entries(value)) {
-                                            let sqlOp = op === 'equals' ? '=' : op;
-                                            let sqlVal = typeof val === 'string' ? `'${val}'` : val;
-                                            conditions.push(`${key} ${sqlOp} ${sqlVal}`);
-                                        }
-                                    } else {
-                                        let formattedValue = typeof value === 'string' ? `'${value}'` : value;
-                                        conditions.push(`${key} = ${formattedValue}`);
-                                    }
-                                }
-
-                                if (conditions.length > 0) {
-                                    sqlStyleQuery += ` WHERE ${conditions.join(' AND ')}`;
-                                }
-                            }
-                        } else {
-                            // 기타 액션은 기본 형식으로
-                            sqlStyleQuery = `${action.toUpperCase()} ${modelName}`;
-
-                            if (params.args) {
-                                sqlStyleQuery += ` ${JSON.stringify(params.args)}`;
-                            }
-                        }
-
-                        // 생성된 SQL 쿼리에 escapeLiteral 적용하여 처리
-                        try {
-                            var psql = escapeLiteral(sqlStyleQuery);
-                            if (psql != null) {
-                                sql_step.hash = psql.sql;
-                                // CRUD 타입 설정
-                                if (psql.type) {
-                                    sql_step.crud = psql.type.charCodeAt(0);
-                                }
-                            }
-
-                            // 추가 SQL 정보 처리
-                            var els = new EscapeLiteralSQL(sqlStyleQuery);
-                            els.process();
-
-                            // SQL 파라미터 처리
-                            if (conf.profile_sql_param_enabled) {
-                                sql_step.setTrue(1);
-                                var crc = {value: 0};
-                                sql_step.p1 = toParamBytes(psql.param, crc);
-
-                                // 원래 인자를 파라미터로 추가
-                                const paramsString = JSON.stringify(params.args || {});
-                                sql_step.p2 = toParamBytes(paramsString, crc);
-                                sql_step.pcrc = crc.value;
-                            }
-                        } catch (e) {
-                            Logger.printError("WHATAP-306", "escapeLiteral error for model method", e, false);
-                        }
-                    } catch (e) {
-                        Logger.printError("WHATAP-307", "Error creating SQL-style query", e, false);
-                    }
+                // UPSERT 처리 추가
+                if (action === "upsert") {
+                    sql_step.updated = 1; // upsert는 항상 1개의 레코드에 영향을 미침
                 }
 
                 sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;

package/lib/util/escape-literal-sql.js

@@ -173,10 +173,10 @@ EscapeLiteralSQL.prototype._quotation = function () {
             break;
         case STAT.ALPHABET:
             this.parsedSql += this.chars[this.pos];
-            status = STAT.QUOTATION;
+            this.status = STAT.QUOTATION;
             break;
         case STAT.NUMBER:
-            parsedSql += this.chars[this.pos];
+            this.parsedSql += this.chars[this.pos];
             this.status = STAT.QUOTATION;
             break;
         case STAT.QUOTATION:
@@ -194,16 +194,16 @@ EscapeLiteralSQL.prototype._dquotation = function () {
             }
             this.param += this.chars[this.pos];
             this.status = STAT.DQUOTATION;
-            break;;
+            break;
         case STAT.COMMENT:
             this.parsedSql += this.chars[this.pos];
             break;
         case STAT.ALPHABET:
             this.parsedSql += this.chars[this.pos];
-            status = STAT.DQUOTATION;
+            this.status = STAT.DQUOTATION;
             break;
         case STAT.NUMBER:
-            parsedSql += this.chars[this.pos];
+            this.parsedSql += this.chars[this.pos];
             this.status = STAT.DQUOTATION;
             break;
         case STAT.DQUOTATION:

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "whatap",
   "homepage": "http://www.whatap.io",
-  "version": "0.5.12",
-  "releaseDate": "20250324",
+  "version": "0.5.13",
+  "releaseDate": "20250404",
   "description": "Monitoring and Profiling Service",
   "main": "index.js",
   "scripts": {},