whatap 0.5.7 → 0.5.9

package/lib/conf/config-default.js

@@ -267,7 +267,11 @@ var ConfigDefault = {
     "grpc_profile_ignore_method": bool("grpc_profile_ignore_method", true),
 
     "oname_port_postfix_enabled": bool("oname_port_postfix_enabled", false),
-    "ignore_http_lost_connection": bool("ignore_http_lost_connection", false)
+    "ignore_http_lost_connection": bool("ignore_http_lost_connection", false),
+
+    "profile_graphql_enabled": bool("profile_graphql_enabled", true),
+    "profile_graphql_variable_enabled": bool("profile_graphql_variable_enabled", false),
+    "ignore_graphql_operation": str("ignore_graphql_operation", '')
 };
 
 ConfigDefault._hook_method_ignore_prefix = ConfigDefault.hook_method_ignore_prefixes.split(',');

package/lib/core/agent.js

@@ -30,7 +30,10 @@ var Interceptor      = require('./interceptor').Interceptor,
     PromiseObserver  = require('../observers/promise-observer').PromiseObserver,
     PgSqlObserver    = require('../observers/pgsql-observer').PgSqlObserver,
     ScheduleObserver = require('../observers/schedule-observer').ScheduleObserver,
-    GRpcObserver     = require('../observers/grpc-observer').GRpcObserver;
+    // GRpcObserver     = require('../observers/grpc-observer').GRpcObserver,
+    ApolloObserver   = require('../observers/apollo-server-observer').ApolloServerObserver,
+    PrismaObserver  = require('../observers/prisma-observer').PrismaObserver;
+
 
 var Configuration    = require('./../conf/configure'),
     SecurityMaster   = require('./../net/security-master'),
@@ -112,6 +115,12 @@ NodeAgent.prototype.init = function(cb) {
     self.findRoot();
 
     Logger.initializer.process();
+
+    // 최초 1회 실행 후 1시간마다 실행
+    const ONE_HOUR = 60 * 60 * 1000;
+    Logger.clearOldLog();
+    setInterval(Logger.clearOldLog, ONE_HOUR);
+
     Logger.print('WHATAP-001', 'Start initialize WhaTap Agent... Root[' + self._conf['app.root'] + ']', true);
 
     if(self._conf['app.root'] == null || self._conf['app.root'].length == 0) {
@@ -268,6 +277,8 @@ NodeAgent.prototype.loadObserves = function() {
     observes.push(PgSqlObserver);
     observes.push(ScheduleObserver);
     // observes.push(GRpcObserver);
+    observes.push(ApolloObserver);
+    observes.push(PrismaObserver);
 
     var packageToObserve = {};
     observes.forEach(function(observeObj) {

package/lib/logger.js

@@ -27,7 +27,7 @@
          var now = DateUtil.currentTime();
          if(now > this.last + DateUtil.MILLIS_PER_HOUR) {
              this.last = now;
-             Logger.clearOldLog();
+             // Logger.clearOldLog();
          }
          if(this.lastFileRotation !== conf.log_rotation_enabled
              || this.lastDateUnit !== DateUtil.getDateUnit()
@@ -210,7 +210,6 @@
              log_prefix = WHATAP_CONF + "-";
 
          fs.readdir(dir, function (err, files) {
-
              for (var i = 0; i < files.length; i++) {
                  var stat = fs.statSync(path.join(dir, files[i]));
                  if (stat.isDirectory()) {
@@ -232,12 +231,12 @@
                  var fileUnit = DateUtil.getDateUnit(d);
                  try {
                      if (nowUnit - fileUnit > conf.log_keep_days) {
+                         let filePath = `${dir}/${files[i]}`;
                          fs.rmSync(filePath);
                      }
                  } catch (e) {
                  }
              }
-
          });
      },
      read : function( file,  endpos,  length , callback) {

package/lib/observers/apollo-server-observer.js

@@ -0,0 +1,153 @@
+/**
+ * Copyright 2016 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'),
+    conf = require('../conf/configure'),
+    Logger = require('../logger');
+const HashUtil = require('../util/hashutil');
+const DataTextAgent = require('../data/datatext-agent');
+const MessageStep = require('../step/message-step');
+const shimmer = require('../core/shimmer');
+
+var profile_graphql_enabled = conf.getProperty('profile_graphql_enabled', true);
+var profile_graphql_variable_enabled = conf.getProperty('profile_graphql_variable_enabled', false);
+var ignore_graphql_operation = conf.getProperty('ignore_graphql_operation', '');
+
+conf.on('profile_graphql_enabled', function(newProperty) {
+    profile_graphql_enabled = newProperty;
+});
+conf.on('profile_graphql_variable_enabled', function(newProperty) {
+    profile_graphql_variable_enabled = newProperty;
+});
+conf.on('ignore_graphql_operation', function(newProperty) {
+    ignore_graphql_operation = newProperty;
+});
+
+var ApolloServerObserver = function(agent) {
+    this.agent = agent;
+    this.packages = ['@apollo/server'];
+};
+
+function checkIgnoreOperation(ignore_operation, operation_name) {
+    try {
+        let ignore_operation_set = null;
+        if (ignore_operation) {
+            ignore_operation_set = new Set(ignore_operation.split(','));
+        } else {
+            ignore_operation_set = null;
+        }
+        if (ignore_operation_set && ignore_operation_set.has(operation_name)) {
+            return true;
+        }
+    } catch (e) {
+        Logger.printError('WHATAP-803', 'GraphQL checkIgnoreOperation error: ' + e, false);
+    }
+    return false;
+}
+
+function wrapExecuteHTTPGraphQLRequest(original) {
+    return async function executeHTTPGraphQLRequest() {
+        if (!profile_graphql_enabled) {
+            return original.apply(this, arguments);
+        }
+
+        try {
+            var ctx = TraceContextManager.getCurrentContext();
+            if (!ctx) {
+                return original.apply(this, arguments);
+            }
+
+            const [requestContext] = arguments;
+            const { httpGraphQLRequest } = requestContext;
+            const { body } = httpGraphQLRequest;
+
+            const operationName = body.operationName;
+            if (checkIgnoreOperation(ignore_graphql_operation, operationName)) {
+                TraceContextManager.end(ctx._id)
+                return original.apply(this, arguments);
+            }
+
+            const originalServiceName = ctx.service_name || '';
+            if(operationName){
+                ctx.service_name = `${originalServiceName}?operationName=${operationName}`;
+                ctx.service_hash = HashUtil.hashFromString(ctx.service_name);
+            }
+
+            // Operation Type Step (query)
+            if(body.query && body.query.trim()){
+                var step_type = new MessageStep();
+                step_type.hash = HashUtil.hashFromString('Type');
+                step_type.start_time = ctx.getElapsedTime();
+                step_type.desc = body.query.trim().startsWith('mutation') ? 'mutation' : 'query';
+                DataTextAgent.MESSAGE.add(step_type.hash, "Type");
+                ctx.profile.push(step_type);
+            }
+
+            // Operation Name Step
+            if(operationName){
+                var step_operation = new MessageStep();
+                step_operation.hash = HashUtil.hashFromString('Operation');
+                step_operation.start_time = ctx.getElapsedTime();
+                step_operation.desc = operationName || 'anonymous';
+                DataTextAgent.MESSAGE.add(step_operation.hash, "Operation");
+                ctx.profile.push(step_operation);
+            }
+
+            // Variables Step
+            if (profile_graphql_variable_enabled && body.variables && Object.keys(body.variables).length > 0) {
+                var step_variables = new MessageStep();
+                step_variables.hash = HashUtil.hashFromString('Variables');
+                step_variables.start_time = ctx.getElapsedTime();
+                step_variables.desc = JSON.stringify(Object.keys(body.variables));
+                DataTextAgent.MESSAGE.add(step_variables.hash, "Variables");
+                ctx.profile.push(step_variables);
+            }
+
+            const response = await original.apply(this, arguments);
+
+            // 에러 처리
+            if (response.body.kind === 'complete' && response.body.string.includes('"errors"')) {
+                try {
+                    const result = JSON.parse(response.body.string);
+                    if (result.errors && result.errors.length > 0) {
+                        const errorMessages = result.errors.map(error => error.message).join('\n');
+                        ctx.statusCode = 500;
+                        ctx.error_message = errorMessages;
+                    }
+                } catch (e) {
+                    Logger.printError('WHATAP-802', 'GraphQL error parsing failed', e, false);
+                }
+            }
+
+            return response;
+
+        } catch (err) {
+            Logger.printError('WHATAP-801', 'GraphQL executeHTTPGraphQLRequest error: ' + err, false);
+            if (ctx) {
+                ctx.statusCode = 500;
+                ctx.error_message = err.stack;
+            }
+            return original.apply(this, arguments);
+        }
+    };
+}
+
+ApolloServerObserver.prototype.inject = function(mod, moduleName) {
+    if (mod.__whatap_observe__) {
+        return;
+    }
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("ApolloServerObserver");
+
+    if (profile_graphql_enabled) {
+        // Hook ApolloServer
+        if (mod.ApolloServer && mod.ApolloServer.prototype) {
+            shimmer.wrap(mod.ApolloServer.prototype, 'executeHTTPGraphQLRequest', wrapExecuteHTTPGraphQLRequest);
+        }
+    }
+};
+
+exports.ApolloServerObserver = ApolloServerObserver;

package/lib/observers/prisma-observer.js

@@ -0,0 +1,1045 @@
+/**
+ * Copyright 2025 WHATAP project authors. All rights reserved.
+ * Use of this source code is governed by a license that
+ * can be found in the LICENSE file.
+ */
+
+const TraceContextManager = require("../trace/trace-context-manager");
+const ParsedSql = require("../trace/parsed-sql");
+const SqlStepX = require("../step/sql-stepx");
+const DBCStep = require("../step/dbc-step");
+const ResultSetStep = require("../step/resultset-step");
+const DataTextAgent = require("../data/datatext-agent");
+const StatSql = require("../stat/stat-sql");
+const MeterSql = require("../counter/meter/meter-sql");
+const conf = require("../conf/configure");
+const IntKeyMap = require("../util/intkey-map");
+const EscapeLiteralSQL = require("../util/escape-literal-sql");
+const HashUtil = require("../util/hashutil");
+const StatError = require("../stat/stat-error");
+const TextTypes = require("../lang/text-types");
+const ParamSecurity = require("../util/paramsecurity");
+const Logger = require("../logger");
+const Buffer = require("buffer").Buffer;
+const DateUtil = require("../util/dateutil");
+const TraceSQL = require("../trace/trace-sql");
+const shimmer = require("../core/shimmer");
+
+var PrismaObserver = function(agent) {
+    this.agent = agent;
+    this.packages = ["@prisma/client"];
+};
+
+var dbc_hash = 0;
+var dbc = "";
+
+PrismaObserver.prototype.inject = function(mod, moduleName) {
+    if (mod.__whatap_observe__) {
+        return;
+    }
+
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("PrismaObserver");
+
+    const self = this;
+
+    if (conf.sql_enabled === false) {
+        return;
+    }
+
+    // Prisma Client 초기화 메서드 후킹
+    if (mod.PrismaClient) {
+        // 직접 PrismaClient 생성자 후킹
+        shimmer.wrap(mod, 'PrismaClient', function(originalConstructor) {
+            return function() {
+                // 원래 생성자 호출
+                const instance = new originalConstructor(...arguments);
+
+                // 이 시점에서 instance가 생성된 Prisma 클라이언트 인스턴스
+                self.patchPrismaInstance(instance);
+
+                return instance;
+            };
+        });
+    }
+};
+
+// 각 Prisma 인스턴스에 패치 적용
+PrismaObserver.prototype.patchPrismaInstance = function(prismaInstance) {
+    if (prismaInstance.__whatap_observe__) {
+        return;
+    }
+    prismaInstance.__whatap_observe__ = true;
+
+    // 모든 DB 연결 정보 추출 및 초기화
+    this.setupConnectionInfo(prismaInstance);
+
+    // $connect 후킹
+    this.hookConnect(prismaInstance);
+
+    // Raw 쿼리 메서드 후킹
+    // this.hookRawQueryMethods(prismaInstance);
+
+    // $use 미들웨어 후킹 (모델 메서드 추적)
+    this.hookUseMiddleware(prismaInstance);
+
+    // 각 모델에 대한 직접 메서드 후킹 (더 안정적인 추적을 위해)
+    // this.hookModelMethods(prismaInstance);
+};
+
+// 연결 정보 설정
+PrismaObserver.prototype.setupConnectionInfo = function(prismaInstance) {
+    try {
+        // 연결 정보 가져오기 시도
+        const url = prismaInstance._engineConfig?.datasources?.db?.url ||
+            prismaInstance._baseDmmf?.datamodel?.datasources?.[0]?.url?.value ||
+            process.env.DATABASE_URL ||
+            'prisma:unknown';
+
+        if (url && url !== "prisma:unknown") {
+            const dbUrl = new URL(url);
+            const protocol = dbUrl.protocol.replace(':', '');
+
+            // 프로토콜에 따라 접두사 설정 (postgresql -> pgsql로 변환할 수도 있음)
+            const dbProtocol = protocol === 'pgsql' ? 'postgresql' : protocol;
+
+            // MySQL 관찰자와 동일한 형식으로 구성
+            dbc = `${dbProtocol}://`;
+            dbc += dbUrl.username || '';
+            dbc += "@";
+            dbc += dbUrl.hostname || '';
+            dbc += '/';
+            dbc += dbUrl.pathname.replace('/', '') || '';
+            dbc_hash = HashUtil.hashFromString(dbc);
+
+            DataTextAgent.DBC.add(dbc_hash, dbc);
+            DataTextAgent.METHOD.add(dbc_hash, dbc);
+            DataTextAgent.ERROR.add(dbc_hash, dbc);
+        }
+
+    } catch (e) {
+        Logger.printError("WHATAP-301", "Failed to extract connection info", e, false);
+        dbc = "prisma:unknown";
+        dbc_hash = HashUtil.hashFromString(dbc);
+    }
+};
+
+// Connect 메서드 후킹
+PrismaObserver.prototype.hookConnect = function(prismaInstance) {
+    const self = this;
+
+    shimmer.wrap(prismaInstance, "$connect", function(original) {
+        return async function() {
+            const ctx = TraceContextManager.getCurrentContext();
+            if (!ctx || ctx.db_opening) {
+                return original.apply(this, arguments);
+            }
+
+            ctx.db_opening = true;
+            ctx.footprint("Prisma Connecting Start");
+
+            const dbc_step = new DBCStep();
+            dbc_step.start_time = ctx.getElapsedTime();
+
+            try {
+                const result = await original.apply(this, arguments);
+
+                dbc_step.hash = dbc_hash;
+                dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
+
+                ctx.db_opening = false;
+                ctx.footprint("Prisma Connecting Done");
+                ctx.profile.push(dbc_step);
+
+                return result;
+            } catch (err) {
+                ctx.db_opening = false;
+
+                dbc_step.hash = dbc_hash;
+                dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
+                dbc_step.error = StatError.addError("prisma-connection", err.message, ctx.service_hash);
+
+                if (ctx.error.isZero()) {
+                    ctx.error = dbc_step.error;
+                }
+
+                ctx.profile.push(dbc_step);
+                Logger.printError("WHATAP-302", "Connection Error", err);
+                throw err;
+            }
+        };
+    });
+};
+
+// Raw 쿼리 메서드 후킹
+PrismaObserver.prototype.hookRawQueryMethods = function(prismaInstance) {
+    const self = this;
+    const queryMethods = ["$queryRaw", "$executeRaw", "$queryRawUnsafe", "$executeRawUnsafe"];
+
+    queryMethods.forEach(method => {
+        if (typeof prismaInstance[method] === 'function') {
+            shimmer.wrap(prismaInstance, method, function(original) {
+                return async function() {
+                    const ctx = TraceContextManager.getCurrentContext();
+                    if (!ctx) {
+                        return original.apply(this, arguments);
+                    }
+
+                    const sql_step = new SqlStepX();
+                    sql_step.start_time = ctx.getElapsedTime();
+                    ctx.profile.push(sql_step);
+                    ctx.footprint(`Prisma ${method} Start`);
+
+                    ctx.sql_count = (ctx.sql_count || 0) + 1;
+
+                    // SQL 쿼리 추출
+                    let sql = "";
+                    let psql = null;
+
+                    if (arguments.length > 0) {
+                        if (typeof arguments[0] === "object" && arguments[0].sql) {
+                            // Tagged template으로 전달된 경우
+                            sql = arguments[0].sql;
+                        } else if (typeof arguments[0] === "string") {
+                            // Raw string으로 전달된 경우
+                            sql = arguments[0];
+                        }
+                    }
+
+                    // SQL 파싱
+                    if (sql && sql.length > 0) {
+                        try {
+                            psql = escapeLiteral(sql);
+                        } catch (e) {
+                            Logger.printError("WHATAP-303", "escapeliteral error", e, false);
+                        }
+                    } 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;
+
+                    // 파라미터 정보 추출
+                    if (conf.profile_sql_param_enabled) {
+                        var params = Array.from(arguments).slice(1);
+                        sql_step.setTrue(1);
+                        var crc = { value: 0 };
+                        sql_step.p1 = toParamBytes(psql.param, crc);
+
+                        if (params.length > 0) {
+                            const result = params.map((param) => {
+                                if (typeof param === "string") {
+                                    return `'${param}'`;
+                                }
+                                return param;
+                            }).toString();
+                            sql_step.p2 = toParamBytes(result, crc);
+                        }
+
+                        sql_step.pcrc = crc.value;
+                    }
+
+                    try {
+                        const result = await original.apply(this, arguments);
+
+                        // SELECT 쿼리의 결과셋 처리
+                        if (method === "$queryRaw" || method === "$queryRawUnsafe") {
+                            if (Array.isArray(result)) {
+                                var result_step = new ResultSetStep();
+                                result_step.start_time = ctx.getElapsedTime();
+                                result_step.elapsed = 0;
+                                result_step.fetch = result.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.length : result.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);
+                            }
+                        }
+
+                        // UPDATE/INSERT/DELETE 쿼리 결과 처리
+                        if ((method === "$executeRaw" || method === "$executeRawUnsafe") && typeof result === "number") {
+                            sql_step.updated = result;
+                        }
+
+                        self._finishQuery(ctx, sql_step);
+                        return result;
+                    } catch (err) {
+                        Logger.printError("WHATAP-304", `${method} error: ${err.message}`, 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("prisma-" + (err.code || "unknown"), err.message, ctx.service_hash, TextTypes.SQL, null);
+                        }
+
+                        throw err;
+                    }
+                };
+            });
+        }
+    });
+};
+
+PrismaObserver.prototype.hookUseMiddleware = function(prismaInstance) {
+    const self = this;
+
+    // 원본 $use 함수를 저장
+    const originalUse = prismaInstance.$use;
+
+    // 우리만의 미들웨어 추가
+    if (typeof originalUse === 'function') {
+        // 간단한 미들웨어 추가 (모든 쿼리를 추적)
+        prismaInstance.$use(async (params, next) => {
+            var result;
+            const ctx = TraceContextManager.getCurrentContext();
+            if (!ctx) {
+                return next(params);
+            }
+
+            var dbc_step = new DBCStep();
+            dbc_hash = HashUtil.hashFromString(dbc);
+            DataTextAgent.DBC.add(dbc_hash, dbc);
+            DataTextAgent.METHOD.add(dbc_hash, dbc);
+            DataTextAgent.ERROR.add(dbc_hash, dbc)
+
+            dbc_step.hash = dbc_hash;
+            dbc_step.start_time = ctx.getElapsedTime();
+            ctx.profile.push(dbc_step);
+
+            const sql_step = new SqlStepX();
+            sql_step.start_time = ctx.getElapsedTime();
+            ctx.profile.push(sql_step);
+
+            const modelName = params.model || 'unknown';
+            const action = params.action || 'unknown';
+
+            ctx.footprint(`Prisma ${modelName}.${action} Start`);
+            ctx.sql_count = (ctx.sql_count || 0) + 1;
+
+            // 사용된 모델과 액션으로 SQL 문자열 구성
+            const queryInfo = `Prisma ${action.toUpperCase()} ${modelName}`;
+            const queryHash = HashUtil.hashFromString(queryInfo);
+
+            DataTextAgent.SQL.add(queryHash, queryInfo);
+            sql_step.hash = queryHash;
+            sql_step.dbc = dbc_hash;
+
+            ctx.active_sqlhash = sql_step.hash;
+            ctx.active_dbc = sql_step.dbc;
+
+            // 쿼리 파라미터 정보 추출
+            if (conf.profile_sql_param_enabled) {
+                const paramsString = JSON.stringify(params.args || {});
+                sql_step.setTrue(1);
+                var crc = { value: 0 };
+                sql_step.p1 = toParamBytes(paramsString, crc);
+                sql_step.pcrc = crc.value;
+            }
+
+            try {
+                result = await next(params);
+
+                if (action === "queryRaw" || action === "executeRaw" || action === "queryRawUnsafe" || action === "executeRawUnsafe") {
+                    // SQL 문자열 추출
+                    let sqlString = "";
+                    if (params.args && params.args.length > 0) {
+                        // 첫 번째 인자가 문자열 배열인 경우 (tagged template)
+                        if (params.args[0] && params.args[0].strings && Array.isArray(params.args[0].strings)) {
+                            sqlString = params.args[0].strings.join('');
+                        }
+                        // 첫 번째 인자가 직접 문자열인 경우
+                        else if (typeof params.args[0] === 'string') {
+                            sqlString = params.args[0];
+                        }
+                    }
+
+                    // SQL 문자열이 있으면 처리
+                    if (sqlString && sqlString.length > 0) {
+                        try {
+                            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 정보 처리
+                            var els = new EscapeLiteralSQL(sqlString);
+                            els.process();
+
+                            // SQL 파라미터 처리
+                            if (conf.profile_sql_param_enabled) {
+                                var params = params.args.slice(1);
+                                sql_step.setTrue(1);
+                                var crc = {value: 0};
+                                sql_step.p1 = toParamBytes(psql.param, crc);
+
+                                if (params && params.length > 0) {
+                                    const result = params.map((param) => {
+                                        if (typeof param === 'string') {
+                                            return `'${param}'`;
+                                        }
+                                        return param;
+                                    }).toString();
+                                    sql_step.p2 = toParamBytes(result, crc);
+                                }
+                                sql_step.pcrc = crc.value;
+                            }
+                        } catch (e) {
+                            Logger.printError("WHATAP-305", "escapeLiteral error", e, false);
+                        }
+                    }
+
+                    // Raw 쿼리 결과셋 처리
+                    if ((action === "queryRaw" || action === "queryRawUnsafe") && result) {
+                        let recordCount = 0;
+
+                        if (Array.isArray(result)) {
+                            recordCount = result.length;
+                        } else if (result && typeof result === "object") {
+                            recordCount = 1;
+                        }
+
+                        if (recordCount > 0) {
+                            // 가장 최근에 처리된 SQL 해시 사용 (Raw 쿼리에서 업데이트된 경우)
+                            const sqlHashToUse = psql ? psql.sql : queryHash;
+
+                            var result_step = new ResultSetStep();
+                            result_step.start_time = ctx.getElapsedTime();
+                            result_step.elapsed = 0;
+                            result_step.fetch = recordCount;
+                            result_step.sqlhash = sqlHashToUse;
+                            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;
+
+                            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);
+                        }
+                    }
+                }
+
+                // 결과셋 처리 (findMany, findFirst, findUnique 등)
+                if (["findMany", "findFirst", "findUnique"].includes(action)) {
+                    let recordCount = 0;
+
+                    if (Array.isArray(result)) {
+                        recordCount = result.length;
+                    } else if (result && typeof result === "object") {
+                        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);
+
+                        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);
+
+                        TraceSQL.isTooManyRecords(sql_step, result_step.fetch, ctx);
+                    }
+                }
+
+                // 수정된 레코드 수 처리 (create, update, delete 등)
+                if (["create", "createMany", "update", "updateMany", "delete", "deleteMany"].includes(action)) {
+                    if (result && result.count !== undefined) {
+                        sql_step.updated = result.count;
+                    } else if (result && typeof result === "object") {
+                        sql_step.updated = 1;
+                    }
+                }
+
+                // 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);
+                    }
+                }
+
+                sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+                ctx.sql_time = (ctx.sql_time || 0) + sql_step.elapsed;
+
+                TraceSQL.isSlowSQL(ctx);
+
+                MeterSql.add(dbc_hash, sql_step.elapsed, false);
+                StatSql.addSqlTime(ctx.service_hash, sql_step.dbc, sql_step.hash, sql_step.elapsed, false, 0);
+
+                ctx.footprint(`Prisma ${modelName}.${action} Done`);
+
+                return result;
+            } catch (err) {
+                Logger.printError("WHATAP-308", `Middleware error in ${modelName}.${action}: ${err.message}`, err, false);
+
+                sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+                ctx.sql_time = (ctx.sql_time || 0) + sql_step.elapsed;
+
+                TraceSQL.isSlowSQL(ctx);
+
+                MeterSql.add(dbc_hash, sql_step.elapsed, true);
+                StatSql.addSqlTime(ctx.service_hash, sql_step.dbc, sql_step.hash, sql_step.elapsed, true, 0);
+
+                // 에러 처리
+                try {
+                    sql_step.error = StatError.addError("prisma-" + (err.code || "unknown"), err.message, ctx.service_hash, TextTypes.SQL, sql_step.hash);
+
+                    if (ctx.error.isZero()) {
+                        ctx.error = sql_step.error;
+                    }
+
+                    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");
+                    }
+                } catch (e) {
+                    Logger.printError("WHATAP-309", "Error handling failed", e, false);
+                }
+
+                ctx.footprint(`Prisma ${modelName}.${action} Error`);
+                throw err;
+            }
+        });
+    }
+};
+
+// 모델 메서드 직접 후킹
+// PrismaObserver.prototype.hookModelMethods = function(prismaInstance) {
+//     const self = this;
+//
+//     // Prisma에서 모든 모델 가져오기
+//     let models = [];
+//     try {
+//         // DMMF를 통해 모델 이름 얻기
+//         if (prismaInstance._baseDmmf && prismaInstance._baseDmmf.modelMap) {
+//             models = Object.keys(prismaInstance._baseDmmf.modelMap);
+//         } else if (prismaInstance._dmmf && prismaInstance._dmmf.modelMap) {
+//             models = Object.keys(prismaInstance._dmmf.modelMap);
+//         }
+//     } catch (e) {
+//         Logger.printError("WHATAP-PRISMA", "Failed to get models", e, false);
+//     }
+//
+//     // 모델 메서드 목록
+//     const methods = [
+//         "findUnique", "findFirst", "findMany",
+//         "create", "createMany",
+//         "update", "updateMany",
+//         "upsert",
+//         "delete", "deleteMany",
+//         "count", "aggregate", "groupBy"
+//     ];
+//
+//     Logger.print("WHATAP-PRISMA", `Found models: ${models.join(', ')}`, false);
+//
+//     // 각 모델에 대해 메서드 후킹
+//     models.forEach(model => {
+//         if (prismaInstance[model]) {
+//             methods.forEach(method => {
+//                 if (typeof prismaInstance[model][method] === 'function') {
+//                     shimmer.wrap(prismaInstance[model], method, function(original) {
+//                         return async function() {
+//                             const ctx = TraceContextManager.getCurrentContext();
+//                             if (!ctx) {
+//                                 return original.apply(this, arguments);
+//                             }
+//
+//                             Logger.print("WHATAP-PRISMA", `Direct model method called: ${model}.${method}`, false);
+//
+//                             const sql_step = new SqlStepX();
+//                             sql_step.start_time = ctx.getElapsedTime();
+//                             ctx.profile.push(sql_step);
+//                             ctx.footprint(`Prisma ${model}.${method} Start (Direct)`);
+//
+//                             ctx.sql_count = (ctx.sql_count || 0) + 1;
+//
+//                             // 쿼리 정보
+//                             const queryInfo = `${method.toUpperCase()} ${model}`;
+//                             const queryHash = HashUtil.hashFromString(queryInfo);
+//
+//                             DataTextAgent.SQL.add(queryHash, queryInfo);
+//                             sql_step.hash = queryHash;
+//                             sql_step.dbc = dbc_hash;
+//
+//                             ctx.active_sqlhash = sql_step.hash;
+//                             ctx.active_dbc = sql_step.dbc;
+//
+//                             // 쿼리 파라미터
+//                             if (conf.profile_sql_param_enabled) {
+//                                 const argsString = JSON.stringify(arguments[0] || {});
+//                                 sql_step.setTrue(1);
+//                                 var crc = { value: 0 };
+//                                 sql_step.p1 = toParamBytes(argsString, crc);
+//                                 sql_step.pcrc = crc.value;
+//                             }
+//
+//                             try {
+//                                 const result = await original.apply(this, arguments);
+//
+//                                 // 결과셋 처리
+//                                 if (["findMany", "findFirst", "findUnique"].includes(method)) {
+//                                     let recordCount = 0;
+//
+//                                     if (Array.isArray(result)) {
+//                                         recordCount = result.length;
+//                                     } else if (result && typeof result === "object") {
+//                                         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);
+//
+//                                         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);
+//
+//                                         TraceSQL.isTooManyRecords(sql_step, result_step.fetch, ctx);
+//                                     }
+//                                 }
+//
+//                                 // 수정된 레코드 처리
+//                                 if (["create", "createMany", "update", "updateMany", "delete", "deleteMany"].includes(method)) {
+//                                     if (result && result.count !== undefined) {
+//                                         sql_step.updated = result.count;
+//                                     } else if (result && typeof result === "object") {
+//                                         sql_step.updated = 1;
+//                                     }
+//                                 }
+//
+//                                 sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+//                                 ctx.sql_time = (ctx.sql_time || 0) + sql_step.elapsed;
+//
+//                                 TraceSQL.isSlowSQL(ctx);
+//
+//                                 MeterSql.add(dbc_hash, sql_step.elapsed, false);
+//                                 StatSql.addSqlTime(ctx.service_hash, sql_step.dbc, sql_step.hash, sql_step.elapsed, false, 0);
+//
+//                                 ctx.footprint(`Prisma ${model}.${method} Done (Direct)`);
+//                                 Logger.print("WHATAP-PRISMA", `Direct model method completed: ${model}.${method}`, false);
+//
+//                                 return result;
+//                             } catch (err) {
+//                                 Logger.printError("WHATAP-PRISMA", `Direct model method error in ${model}.${method}: ${err.message}`, err);
+//
+//                                 sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+//                                 ctx.sql_time = (ctx.sql_time || 0) + sql_step.elapsed;
+//
+//                                 TraceSQL.isSlowSQL(ctx);
+//
+//                                 MeterSql.add(dbc_hash, sql_step.elapsed, true);
+//                                 StatSql.addSqlTime(ctx.service_hash, sql_step.dbc, sql_step.hash, sql_step.elapsed, true, 0);
+//
+//                                 try {
+//                                     sql_step.error = StatError.addError("prisma-" + (err.code || "unknown"), err.message, ctx.service_hash, TextTypes.SQL, sql_step.hash);
+//
+//                                     if (ctx.error.isZero()) {
+//                                         ctx.error = sql_step.error;
+//                                     }
+//
+//                                     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");
+//                                     }
+//                                 } catch (e) {
+//                                     Logger.printError("WHATAP-PRISMA", "Error handling failed", e, false);
+//                                 }
+//
+//                                 ctx.footprint(`Prisma ${model}.${method} Error (Direct)`);
+//                                 throw err;
+//                             }
+//                         };
+//                     });
+//                 }
+//             });
+//         }
+//     });
+// };
+
+PrismaObserver.prototype._finishQuery = function(ctx, sql_step) {
+    sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+    ctx.sql_time = (ctx.sql_time || 0) + sql_step.elapsed;
+
+    TraceSQL.isSlowSQL(ctx);
+
+    MeterSql.add(dbc_hash, sql_step.elapsed, false);
+    StatSql.addSqlTime(ctx.service_hash, sql_step.dbc, sql_step.hash, sql_step.elapsed, false, 0);
+
+    ctx.footprint("Prisma Query Done");
+};
+
+PrismaObserver.prototype._handleError = function(ctx, sql_step, err) {
+    sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+    ctx.sql_time = (ctx.sql_time || 0) + sql_step.elapsed;
+
+    TraceSQL.isSlowSQL(ctx);
+
+    MeterSql.add(dbc_hash, sql_step.elapsed, true);
+    StatSql.addSqlTime(ctx.service_hash, sql_step.dbc, sql_step.hash, sql_step.elapsed, true, 0);
+
+    try {
+        sql_step.error = StatError.addError("prisma-" + (err.code || "unknown"), err.message, ctx.service_hash, TextTypes.SQL, sql_step.hash);
+
+        if (ctx.error.isZero()) {
+            ctx.error = sql_step.error;
+        }
+    } catch (e) {
+        Logger.printError("WHATAP-310", "Error handling failed", e, false);
+    }
+
+    ctx.footprint("Prisma Query Error");
+};
+
+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 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", "PrismaObserver CLEAR OK!!!!!!!!!!!!!!!!", 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.PrismaObserver = PrismaObserver;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "whatap",
   "homepage": "http://www.whatap.io",
-  "version": "0.5.7",
-  "releaseDate": "20250207",
+  "version": "0.5.9",
+  "releaseDate": "20250305",
   "description": "Monitoring and Profiling Service",
   "main": "index.js",
   "scripts": {},