whatap 0.5.20 → 0.5.22

package/lib/control/control-handler.js

@@ -139,7 +139,7 @@ ControlHandler.prototype.handle = async function (p) {
         case ParamDef.GET_ENV:
             try {
                 var mv = new MapValue();
-                let ignore_env_variable = conf.get('ignore_env_variable_set', '');
+                let ignore_env_variable = conf.getProperty('ignore_env_variable_set', '');
                 let ignore_env_variable_set = ignore_env_variable ? new Set(ignore_env_variable.split(',').map(item => item.trim())) : new Set();
                 for (var k in process.env) {
                     if(ignore_env_variable_set.has(k)) {

package/lib/observers/http-observer.js

@@ -779,12 +779,20 @@ HttpObserver.prototype.inject = function( mod, moduleName ) {
         });
     });
 
-    aop.before(mod.Server.prototype, ['on', 'addListener'], function (obj, args) {
-        if(args[0] !== 'request') {return;}
-
-        args[args.length-1] = self.__createTransactionObserver(args[args.length-1],
-            moduleName === 'https', obj);
-    });
+    shimmer.wrap(mod.Server.prototype, 'emit', function wrapEmit(originalEmit) {
+            return function wrappedEmit(eventName, ...args) {
+                if (eventName !== 'request') {
+                    return originalEmit.apply(this, [eventName, ...args]);
+                }
+                let [req, res] = args;
+                return self.__createTransactionObserver(
+                    (req, res) => originalEmit.call(this, eventName, req, res),
+                    moduleName === 'https',
+                    this
+                )(req, res);
+            };
+        }
+    );
 
     if( conf.getProperty('httpc_enabled', true) === false ) { return; }
 

package/lib/observers/mongo-observer.js

@@ -60,6 +60,7 @@ MongoObserver.prototype.inject = function( mod, moduleName ) {
         self.agent.aop.before(mod.Collection.prototype, command, function (obj, args) {
             var ctx = TraceContextManager.getCurrentContext();
             if(ctx == null) { return; }
+            if(ctx && ctx.__mongoose_traced__) { return; }
 
             ctx.footprint('Mongodb Command Start: ' + command );
             var sql_step;
@@ -94,6 +95,7 @@ MongoObserver.prototype.inject = function( mod, moduleName ) {
         self.agent.aop.both(mod.Collection.prototype, command, function (obj, args, lctx) {
             var ctx = lctx.context;
             if(ctx == null) { return; }
+            if(ctx && ctx.__mongoose_traced__) { return; }
 
             ctx.footprint('Mongodb Command Start: ' + command );
             var sql_step;
@@ -192,6 +194,7 @@ MongoObserver.prototype.inject = function( mod, moduleName ) {
             //args[0] where, args[1] set
             var ctx = TraceContextManager.getCurrentContext();
             if(ctx == null) {return;}
+            if(ctx && ctx.__mongoose_traced__) { return; }
 
             ctx.footprint('Mongodb Command Start: '+command);
             var sql_step;
@@ -239,6 +242,7 @@ MongoObserver.prototype.inject = function( mod, moduleName ) {
             //args[0] where
             var ctx = TraceContextManager.getCurrentContext();
             if(ctx == null) { return; }
+            if(ctx && ctx.__mongoose_traced__) { return; }
 
             ctx.footprint('Mongodb Command Start: '+command);
             var sql_step;
@@ -278,6 +282,7 @@ MongoObserver.prototype.inject = function( mod, moduleName ) {
         self.agent.aop.both(mod.Collection.prototype, command, function (obj, args) {
             var ctx = TraceContextManager.getCurrentContext();
             if(ctx == null) { return; }
+            if(ctx && ctx.__mongoose_traced__) { return; }
 
             ctx.footprint('Mongodb Command Start: '+command);
             var sql_step;

package/lib/observers/mongoose-observer.js

@@ -4,6 +4,9 @@ var TraceContextManager = require('../trace/trace-context-manager'),
     HashUtil            = require('../util/hashutil');
 const DBCStep = require("../step/dbc-step");
 const Logger = require("../logger");
+const ParamSecurity = require("../util/paramsecurity");
+const {Buffer} = require("buffer");
+const conf = require('../conf/configure');
 const shimmer = require('../core/shimmer');
 
 var MongooseObserver = function (agent) {
@@ -13,454 +16,569 @@ var MongooseObserver = function (agent) {
 
 var dbc_step, dbc, conn_dbc_hash;
 
+// 단일 필터 메서드 (첫 번째 인자가 filter)
+const collectionMethodsWithFilter = [
+    'find',
+    // 'findById',
+    'findOne',
+    'countDocuments',
+    'distinct',
+    'deleteOne',
+    'deleteMany'
+];
+
+// 이중 필터 메서드 (첫 번째: filter, 두 번째: update)
+const collectionMethodsWithTwoFilters = [
+    'findOneAndUpdate',
+    // 'findByIdAndUpdate',
+    'updateOne',
+    'updateMany',
+    'findOneAndDelete',
+    // 'findByIdAndDelete',
+    'replaceOne'
+];
+
+// 특수 메서드
+const specialMethods = [
+    'create',
+    'insertMany',
+    'aggregate'
+];
+
 MongooseObserver.prototype.inject = function (mod, modName) {
     var self = this;
-    var hookCommand = [
-        "create",             // Create: Create a new document
-        "insertMany",         // Create: Create multiple documents at once
-        "find",               // Read: Find documents that match criteria
-        "findById",           // Read: Find a document by its ID
-        "findOne",            // Read: Find the first document that matches criteria
-        "countDocuments",     // Read: Count the number of documents that match criteria
-        "distinct",           // Read: Find distinct values for a given field
-        "updateMany",         // Update: Update multiple documents that match criteria
-        "updateOne",          // Update: Update a single document that matches criteria
-        "replaceOne",         // Update: Replace one document with another
-        "findOneAndUpdate",   // Update: Find the first document that matches criteria and update it
-        "findByIdAndUpdate",  // Update: Find a document by its ID and update it
-        "deleteOne",          // Delete: Delete a single document that matches criteria
-        "deleteMany",         // Delete: Delete multiple documents that match criteria
-        "findOneAndDelete",   // Delete: Find the first document that matches criteria and delete it
-        "findByIdAndDelete"   // Delete: Find a document by its ID and delete it
-    ];
-
-    // mongoose.connect 함수를 shimmer로 래핑
-    shimmer.wrap(mod, 'connect', function(original) {
-        return function wrappedConnect() {
-            var args = Array.prototype.slice.call(arguments);
-
-            if(!args[0]) {
-                return original.apply(this, arguments);
-            }
 
-            if(dbc) {
-                return original.apply(this, arguments);
+    // mongoose.connect 후킹 (연결 정보 저장)
+    shimmer.wrap(mod, 'connect', function(originalConnect) {
+        return function wrappedConnect() {
+            if (arguments[0]) {
+                dbc = arguments[0];
+                conn_dbc_hash = HashUtil.hashFromString(dbc);
             }
+            return originalConnect.apply(this, arguments);
+        };
+    });
 
-            dbc = args[0];
-            conn_dbc_hash = HashUtil.hashFromString(dbc);
-
-            var result = original.apply(this, arguments);
+    // Model 생성 후킹
+    shimmer.wrap(mod, 'model', function(originalModel) {
+        return function wrappedModel() {
+            const model = originalModel.apply(this, arguments);
 
-            // Promise 체인으로 연결 성공 후 Model을 hook
-            result.then(connection => {
-                // Model 생성 시점을 intercept하기 위해 mongoose.model을 hook
-                self.hookModelCreation(mod);
+            // 생성된 Model에 메서드 패치 적용
+            self.patchModelMethods(model);
 
-            }).catch(e => {
-                Logger.printError("WHATAP-612", "Mongodb connection error", e, false);
-            });
-
-            return result;
+            return model;
         };
     });
-
-    // 이미 생성된 모델들도 처리하기 위해 mongoose.model 함수를 hook
-    this.hookModelCreation(mod);
 };
 
-// Model 생성을 intercept하여 각 Model에 hook을 적용
-MongooseObserver.prototype.hookModelCreation = function(mongoose) {
+MongooseObserver.prototype.patchModelMethods = function(Model) {
+    if(Model.__whatap_observe__) {return;}
+    Model.__whatap_observe__ = true;
     var self = this;
 
-    // mongoose.model 함수를 wrap하여 새로 생성되는 모델들을 intercept
-    if (!mongoose._whatapHooked) {
-        shimmer.wrap(mongoose, 'model', function(original) {
-            return function wrappedModel() {
-                var result = original.apply(this, arguments);
+    // 단일 필터 메서드 패치
+    collectionMethodsWithFilter.forEach(function(methodName) {
+        if (Model[methodName]) {
+            shimmer.wrap(Model, methodName, function(originalMethod) {
+                return self.createSingleFilterWrapper(originalMethod, methodName);
+            });
+        }
+    });
 
-                // 새로 생성된 Model에 hook 적용
-                if (result && typeof result === 'function') {
-                    self.wrapModelMethods(result);
-                }
+    // 이중 필터 메서드 패치
+    collectionMethodsWithTwoFilters.forEach(function(methodName) {
+        if (Model[methodName]) {
+            shimmer.wrap(Model, methodName, function(originalMethod) {
+                return self.createDoubleFilterWrapper(originalMethod, methodName);
+            });
+        }
+    });
 
-                return result;
-            };
+    // aggregate 메서드 패치
+    if (Model.aggregate) {
+        shimmer.wrap(Model, 'aggregate', function(originalAggregate) {
+            return self.createAggregateWrapper(originalAggregate);
         });
-        mongoose._whatapHooked = true;
     }
 
-    // 이미 존재하는 모델들에도 hook 적용
-    var modelNames = mongoose.modelNames();
-    modelNames.forEach(function(modelName) {
-        var Model = mongoose.model(modelName);
-        self.wrapModelMethods(Model);
+    // create, insertMany 패치
+    ['create', 'insertMany'].forEach(function(methodName) {
+        if (Model[methodName]) {
+            shimmer.wrap(Model, methodName, function(originalMethod) {
+                return self.createInsertWrapper(originalMethod, methodName);
+            });
+        }
     });
 };
 
-// Model의 메서드들을 wrap
-MongooseObserver.prototype.wrapModelMethods = function(Model) {
+MongooseObserver.prototype.createSingleFilterWrapper = function(originalMethod, methodName) {
     var self = this;
 
-    if (Model._whatapHooked) {
-        return; // 이미 hook된 경우 스킵
-    }
+    return function wrappedSingleFilter() {
+        const ctx = TraceContextManager.getCurrentContext();
+        if (!ctx) {
+            return originalMethod.apply(this, arguments);
+        }
+        ctx.__mongoose_traced__ = true;
 
-    // aggregate 메서드 hook (Model에 직접 정의됨)
-    if (typeof Model.aggregate === 'function') {
-        shimmer.wrap(Model, 'aggregate', function(original) {
-            return function wrappedAggregate() {
-                return self.wrapAggregateExecution(original, this, arguments);
-            };
-        });
-    }
+        const dbc_step = self.createDBCStep(ctx);
+        dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
+        ctx.profile.push(dbc_step);
 
-    // CRUD 메서드들 hook (대부분 Model에 직접 정의됨)
-    var hookCommand = [
-        "create", "insertMany", "find", "findById", "findOne",
-        "countDocuments", "distinct", "updateMany", "updateOne",
-        "replaceOne", "findOneAndUpdate", "findByIdAndUpdate",
-        "deleteOne", "deleteMany", "findOneAndDelete", "findByIdAndDelete"
-    ];
-
-    hookCommand.forEach(function(methodName) {
-        if (typeof Model[methodName] === 'function') {
-            shimmer.wrap(Model, methodName, function(original) {
-                return function wrappedMethod() {
-                    return self.wrapMethodExecution(original, this, arguments, methodName);
-                };
-            });
-        }
-    });
+        // SQL Step 생성
+        const sql_step = new SqlStepX();
+        sql_step.start_time = ctx.getElapsedTime();
 
-    Model._whatapHooked = true;
-};
+        const result = originalMethod.apply(this, arguments);
+        sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
 
-// aggregate 실행을 wrap하는 함수
-MongooseObserver.prototype.wrapAggregateExecution = function(original, thisArg, args) {
-    var argsArray = Array.prototype.slice.call(args);
-    var ctx = TraceContextManager.getCurrentContext();
+        try {
+            const filterObj = arguments[0];
+            const parseResult = self.parseSingleFilter(methodName, filterObj);
 
-    if(!ctx) {
-        return original.apply(thisArg, argsArray);
-    }
+            // SQL 문자열 생성: "ModelName methodName where=[field1,field2]"
+            const modelName = this.modelName || 'Unknown';
+            let sql = `${modelName} ${methodName}`;
 
-    // DBC 정보 등록
-    if(dbc && conn_dbc_hash){
-        DataTextAgent.DBC.add(conn_dbc_hash, dbc);
-        DataTextAgent.METHOD.add(conn_dbc_hash, dbc);
-        DataTextAgent.ERROR.add(conn_dbc_hash, dbc);
-    }
+            if (parseResult.whereFields.length > 0) {
+                sql += ` where=[${parseResult.whereFields.join(',')}]`;
+            }
 
-    // DBC Step 생성
-    var dbc_step = new DBCStep();
-    dbc_step.hash = conn_dbc_hash;
-    dbc_step.start_time = ctx.getElapsedTime();
+            // SQL Step 완성
+            sql_step.hash = HashUtil.hashFromString(sql);
+            DataTextAgent.SQL.add(sql_step.hash, sql);
+
+            // 파라미터 암호화 처리
+            if (conf.getProperty('profile_mongodb_param_enabled', false) === true &&
+                parseResult.values.length > 0) {
+                sql_step.setTrue(1);
+                var crc = {value: 0};
+                const valuesString = parseResult.values.map(val => {
+                    if (typeof val === 'string') {
+                        return `'${val}'`;
+                    }
+                    return val;
+                }).toString();
+                sql_step.p2 = toParamBytes(valuesString, crc);
+                sql_step.pcrc = crc.value;
+            }
 
-    // SQL Step 생성
-    var sql_step = new SqlStepX();
-    sql_step.start_time = ctx.getElapsedTime();
+            ctx.profile.push(sql_step);
 
-    var result;
-    var hasError = false;
+        } catch (e) {
+            Logger.printError("WHATAP-611", "Mongodb single filter query error", e, false);
+        }
 
-    try {
-        // 원본 함수 실행
-        result = original.apply(thisArg, argsArray);
-
-        // Query 객체인 경우 exec 메서드를 wrap하여 실행 시점의 에러를 캐치
-        if (result && typeof result.exec === 'function') {
-            // Query 객체의 exec 메서드를 wrap
-            var originalExec = result.exec;
-            result.exec = function(callback) {
-                var execResult = originalExec.call(this, callback);
-
-                // Promise 체인에 catch 추가
-                if (execResult && typeof execResult.catch === 'function') {
-                    execResult = execResult.catch(function(error) {
-                        // 에러 정보를 컨텍스트에 설정
-                        ctx.error_message = error.message || error.toString();
-                        ctx.error_class = error.name || error.constructor?.name || 'MongooseAggregateError';
-
-                        // 에러 정보를 DataTextAgent에도 추가
-                        if (conn_dbc_hash) {
-                            DataTextAgent.ERROR.add(conn_dbc_hash, ctx.error_message);
-                        }
+        return result;
+    };
+};
 
-                        Logger.printError("WHATAP-611", "Mongodb aggregate execution error", error, false);
-                        throw error; // 에러를 다시 던져서 원래 동작 유지
-                    });
-                }
+MongooseObserver.prototype.createDoubleFilterWrapper = function(originalMethod, methodName) {
+    var self = this;
 
-                return execResult;
-            };
-
-            // then 메서드도 wrap (Promise 체인 사용 시)
-            var originalThen = result.then;
-            if (originalThen) {
-                result.then = function(onResolve, onReject) {
-                    return originalThen.call(this, onResolve, function(error) {
-                        // 에러 정보를 컨텍스트에 설정
-                        ctx.error_message = error.message || error.toString();
-                        ctx.error_class = error.name || error.constructor?.name || 'MongooseAggregateError';
-
-                        // 에러 정보를 DataTextAgent에도 추가
-                        if (conn_dbc_hash) {
-                            DataTextAgent.ERROR.add(conn_dbc_hash, ctx.error_message);
-                        }
+    return function wrappedDoubleFilter() {
+        const ctx = TraceContextManager.getCurrentContext();
+        if (!ctx) {
+            return originalMethod.apply(this, arguments);
+        }
+        ctx.__mongoose_traced__ = true;
 
-                        Logger.printError("WHATAP-611", "Mongodb aggregate execution error", error, false);
+        // DBC Step 생성
+        const dbc_step = self.createDBCStep(ctx);
+        dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
+        ctx.profile.push(dbc_step);
 
-                        // 원래 reject 핸들러가 있으면 호출, 없으면 에러를 다시 던짐
-                        if (onReject) {
-                            return onReject(error);
-                        } else {
-                            throw error;
-                        }
-                    });
-                };
+        // SQL Step 생성
+        const sql_step = new SqlStepX();
+        sql_step.start_time = ctx.getElapsedTime();
+
+        const result = originalMethod.apply(this, arguments);
+        sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+
+        try {
+            const filterObj = arguments[0];
+            const updateObj = arguments[1];
+            const parseResult = self.parseDoubleFilter(methodName, filterObj, updateObj);
+
+            // SQL 문자열 생성: "ModelName methodName where=[field1] field=[field2,field3]"
+            const modelName = this.modelName || 'Unknown';
+            let sql = `${modelName} ${methodName}`;
+
+            if (parseResult.whereFields.length > 0) {
+                sql += ` where=[${parseResult.whereFields.join(',')}]`;
             }
-        }
 
-        // Promise인 경우 에러 처리를 위해 catch 추가 (직접 Promise를 반환하는 경우)
-        else if (result && typeof result.then === 'function') {
-            result = result.catch(function(error) {
-                // 에러 정보를 컨텍스트에 설정
-                ctx.error_message = error.message || error.toString();
-                ctx.error_class = error.name || error.constructor?.name || 'MongooseAggregateError';
+            if (parseResult.updateFields.length > 0) {
+                sql += ` field=[${parseResult.updateFields.join(',')}]`;
+            }
 
-                // 에러 정보를 DataTextAgent에도 추가
-                if (conn_dbc_hash) {
-                    DataTextAgent.ERROR.add(conn_dbc_hash, ctx.error_message);
-                }
+            // SQL Step 완성
+            sql_step.hash = HashUtil.hashFromString(sql);
+            DataTextAgent.SQL.add(sql_step.hash, sql);
+
+            // 파라미터 암호화 처리 (where 값 + update 값)
+            if (conf.getProperty('profile_mongodb_param_enabled', false) === true && parseResult.values.length > 0) {
+                sql_step.setTrue(1);
+                var crc = {value: 0};
+                const valuesString = parseResult.values.map(val => {
+                    if (typeof val === 'string') {
+                        return `'${val}'`;
+                    }
+                    return val;
+                }).toString();
+                sql_step.p2 = toParamBytes(valuesString, crc);
+                sql_step.pcrc = crc.value;
+            }
 
-                Logger.printError("WHATAP-611", "Mongodb aggregate execution error", error, false);
-                throw error; // 에러를 다시 던져서 원래 동작 유지
-            });
+            ctx.profile.push(sql_step);
+
+        } catch (e) {
+            Logger.printError("WHATAP-611", "Mongodb double filter query error", e, false);
         }
 
-    } catch(error) {
-        hasError = true;
-        // 동기 에러 처리
-        ctx.error_message = error.message || error.toString();
-        ctx.error_class = error.name || error.constructor?.name || 'MongooseAggregateError';
+        return result;
+    };
+};
 
-        // 에러 정보를 DataTextAgent에도 추가
-        if (conn_dbc_hash) {
-            DataTextAgent.ERROR.add(conn_dbc_hash, ctx.error_message);
-        }
+MongooseObserver.prototype.createAggregateWrapper = function(originalAggregate) {
+    var self = this;
 
-        Logger.printError("WHATAP-611", "Mongodb aggregate execution error", error, false);
-        throw error; // 에러를 다시 던져서 원래 동작 유지
-    }
+    return function wrappedAggregate() {
+        const ctx = TraceContextManager.getCurrentContext();
+        if (!ctx) {
+            return originalAggregate.apply(this, arguments);
+        }
+        ctx.__mongoose_traced__ = true;
 
-    // 결과 처리
-    try {
+        const dbc_step = self.createDBCStep(ctx);
         dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
         ctx.profile.push(dbc_step);
 
-        // aggregate의 경우 op 속성이 없을 수 있음
-        var operation = result && result.op ? result.op : 'aggregate';
-        ctx.footprint('Mongodb Command Start: ' + operation);
+        // SQL Step 생성
+        const sql_step = new SqlStepX();
+        sql_step.start_time = ctx.getElapsedTime();
 
-        // Model 이름 가져오기
-        var modelName = thisArg.modelName || 'Unknown';
+        const result = originalAggregate.apply(this, arguments);
+        sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
 
-        var sql = modelName + ' aggregate';
-        var param = "";
+        try {
+            const pipeline = arguments[0];
+            const parseResult = self.parseAggregatePipeline(pipeline);
 
-        if(Array.isArray(argsArray[0])) {
-            argsArray[0].forEach(function (val, i) {
-                if(i > 0 && param.length > 0) {
-                    param += ",";
-                }
-                if(val && val.hasOwnProperty('$match')) {
-                    var keys = Object.keys(val['$match']);
-                    param += keys.join(',');
-                }
-                if(val && val.hasOwnProperty('$group')) {
-                    var keys = Object.keys(val['$group']);
-                    param += keys.join(',');
-                }
-            });
+            // SQL 문자열 생성
+            const modelName = this.modelName || 'Unknown';
+            let sql = `${modelName} aggregate`;
+
+            if (parseResult.matchFields.length > 0) {
+                sql += ` where=[${parseResult.matchFields.join(',')}]`;
+            }
+
+            if (parseResult.groupFields.length > 0) {
+                sql += ` group=[${parseResult.groupFields.join(',')}]`;
+            }
+
+            if (parseResult.projectFields.length > 0) {
+                sql += ` field=[${parseResult.projectFields.join(',')}]`;
+            }
+
+            // SQL Step 완성
+            sql_step.hash = HashUtil.hashFromString(sql);
+            DataTextAgent.SQL.add(sql_step.hash, sql);
+
+            // 파라미터 암호화 처리 (주로 $match 조건값들)
+            if (conf.getProperty('profile_mongodb_param_enabled', false) === true &&
+                parseResult.values.length > 0) {
+                sql_step.setTrue(1);
+                var crc = {value: 0};
+                const valuesString = parseResult.values.map(val => {
+                    if (typeof val === 'string') {
+                        return `'${val}'`;
+                    }
+                    return val;
+                }).toString();
+                sql_step.p2 = toParamBytes(valuesString, crc);
+                sql_step.pcrc = crc.value;
+            }
+
+            ctx.profile.push(sql_step);
+
+        } catch (e) {
+            Logger.printError("WHATAP-611", "Mongodb aggregate query error", e, false);
+        }
+
+        return result;
+    };
+};
+
+MongooseObserver.prototype.createInsertWrapper = function(originalMethod, methodName) {
+    var self = this;
+
+    return function wrappedInsert() {
+        const ctx = TraceContextManager.getCurrentContext();
+        if (!ctx) {
+            return originalMethod.apply(this, arguments);
         }
-        sql += ' field=['+param+']';
+        ctx.__mongoose_traced__ = true;
 
-        sql_step.hash = HashUtil.hashFromString(sql);
+        const dbc_step = self.createDBCStep(ctx);
+        dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
+        ctx.profile.push(dbc_step);
+
+        // SQL Step 생성
+        const sql_step = new SqlStepX();
+        sql_step.start_time = ctx.getElapsedTime();
+
+        const result = originalMethod.apply(this, arguments);
         sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
-        DataTextAgent.SQL.add(sql_step.hash, sql);
-        ctx.profile.push(sql_step);
 
-    } catch(e) {
-        Logger.printError("WHATAP-611", "Mongodb aggregate query processing error", e, false);
-    }
+        try {
+            const docs = arguments[0];
+            const parseResult = self.parseInsertDocuments(methodName, docs);
 
-    return result;
-};
+            // SQL 문자열 생성
+            const modelName = this.modelName || 'Unknown';
+            let sql = `${modelName} ${methodName}`;
 
-// 일반 CRUD 메서드 실행을 wrap하는 함수
-MongooseObserver.prototype.wrapMethodExecution = function(original, thisArg, args, methodName) {
-    var argsArray = Array.prototype.slice.call(args);
+            if (parseResult.insertFields.length > 0) {
+                sql += ` field=[${parseResult.insertFields.join(',')}]`;
+            }
 
-    // 첫 번째 인자가 객체가 아니면 무시 (일부 메서드 제외)
-    if(argsArray[0] && typeof argsArray[0] !== "object" &&
-        !['findById', 'findByIdAndUpdate', 'findByIdAndDelete'].includes(methodName)) {
-        return original.apply(thisArg, argsArray);
-    }
+            // SQL Step 완성
+            sql_step.hash = HashUtil.hashFromString(sql);
+            DataTextAgent.SQL.add(sql_step.hash, sql);
+
+            // 파라미터 암호화 처리
+            if (conf.getProperty('profile_mongodb_param_enabled', false) === true &&
+                parseResult.values.length > 0) {
+                sql_step.setTrue(1);
+                var crc = {value: 0};
+                const valuesString = parseResult.values.map(val => {
+                    if (typeof val === 'string') {
+                        return `'${val}'`;
+                    }
+                    return val;
+                }).toString();
+                sql_step.p2 = toParamBytes(valuesString, crc);
+                sql_step.pcrc = crc.value;
+            }
 
-    var ctx = TraceContextManager.getCurrentContext();
-    if(!ctx) {
-        return original.apply(thisArg, argsArray);
-    }
+            ctx.profile.push(sql_step);
 
-    // DBC 정보 등록
-    if(dbc && conn_dbc_hash){
+        } catch (e) {
+            Logger.printError("WHATAP-611", "Mongodb insert query error", e, false);
+        }
+
+        return result;
+    };
+};
+
+MongooseObserver.prototype.createDBCStep = function(ctx) {
+    if (dbc && conn_dbc_hash) {
         DataTextAgent.DBC.add(conn_dbc_hash, dbc);
         DataTextAgent.METHOD.add(conn_dbc_hash, dbc);
         DataTextAgent.ERROR.add(conn_dbc_hash, dbc);
     }
 
-    // DBC Step 생성
     var dbc_step = new DBCStep();
     dbc_step.hash = conn_dbc_hash;
     dbc_step.start_time = ctx.getElapsedTime();
 
-    // SQL Step 생성
-    var sql_step = new SqlStepX();
-    sql_step.start_time = ctx.getElapsedTime();
+    return dbc_step;
+};
 
-    var result;
-    var hasError = false;
+// 비동기 결과 처리
+MongooseObserver.prototype.handleAsyncResult = function(result, ctx, methodName) {
+    ctx.footprint('Mongodb Command Start: ' + methodName);
 
-    try {
-        // 원본 함수 실행
-        result = original.apply(thisArg, argsArray);
-
-        // Query 객체인 경우 exec 메서드를 wrap하여 실행 시점의 에러를 캐치
-        if (result && typeof result.exec === 'function') {
-            // Query 객체의 exec 메서드를 wrap
-            var originalExec = result.exec;
-            result.exec = function(callback) {
-                var execResult = originalExec.call(this, callback);
-
-                // Promise 체인에 catch 추가
-                if (execResult && typeof execResult.catch === 'function') {
-                    execResult = execResult.catch(function(error) {
-                        // 에러 정보를 컨텍스트에 설정
-                        ctx.error_message = error.message || error.toString();
-                        ctx.error_class = error.name || error.constructor?.name || 'MongooseError';
-
-                        // 에러 정보를 DataTextAgent에도 추가
-                        if (conn_dbc_hash) {
-                            DataTextAgent.ERROR.add(conn_dbc_hash, ctx.error_message);
-                        }
+    // Promise인 경우 처리 (대부분의 Mongoose 메서드가 Promise 반환)
+    if (result && typeof result.then === 'function') {
+        // 이미 실행은 완료되었으므로 특별한 처리 불필요
+        return result;
+    }
 
-                        Logger.printError("WHATAP-611", "Mongodb " + methodName + " execution error", error, false);
-                        throw error; // 에러를 다시 던져서 원래 동작 유지
-                    });
-                }
+    return result;
+};
 
-                return execResult;
-            };
-
-            // then 메서드도 wrap (Promise 체인 사용 시)
-            var originalThen = result.then;
-            if (originalThen) {
-                result.then = function(onResolve, onReject) {
-                    return originalThen.call(this, onResolve, function(error) {
-                        // 에러 정보를 컨텍스트에 설정
-                        ctx.error_message = error.message || error.toString();
-                        ctx.error_class = error.name || error.constructor?.name || 'MongooseError';
-
-                        // 에러 정보를 DataTextAgent에도 추가
-                        if (conn_dbc_hash) {
-                            DataTextAgent.ERROR.add(conn_dbc_hash, ctx.error_message);
-                        }
+// 단일 필터 파싱
+MongooseObserver.prototype.parseSingleFilter = function(methodName, filterObj) {
+    const result = {
+        whereFields: [],
+        values: []
+    };
 
-                        Logger.printError("WHATAP-611", "Mongodb " + methodName + " execution error", error, false);
+    if (filterObj && typeof filterObj === 'object') {
+        this.extractFieldsAndValues(filterObj, result.whereFields, result.values);
+    }
 
-                        // 원래 reject 핸들러가 있으면 호출, 없으면 에러를 다시 던짐
-                        if (onReject) {
-                            return onReject(error);
-                        } else {
-                            throw error;
-                        }
-                    });
-                };
-            }
-        } else if (result && typeof result.then === 'function') {
-            // Promise인 경우 에러 처리를 위해 catch 추가 (직접 Promise를 반환하는 경우)
-            result = result.catch(function(error) {
-                // 에러 정보를 컨텍스트에 설정
-                ctx.error_message = error.message || error.toString();
-                ctx.error_class = error.name || error.constructor?.name || 'MongooseError';
-
-                // 에러 정보를 DataTextAgent에도 추가
-                if (conn_dbc_hash) {
-                    DataTextAgent.ERROR.add(conn_dbc_hash, ctx.error_message);
-                }
+    return result;
+};
 
-                Logger.printError("WHATAP-611", "Mongodb " + methodName + " execution error", error, false);
-                throw error; // 에러를 다시 던져서 원래 동작 유지
-            });
-        }
+// 이중 필터 파싱 - 수정된 버전
+MongooseObserver.prototype.parseDoubleFilter = function(methodName, filterObj, updateObj) {
+    const result = {
+        whereFields: [],
+        updateFields: [],
+        values: []
+    };
+
+    // where 조건 파싱
+    if (filterObj && typeof filterObj === 'object') {
+        this.extractFieldsAndValues(filterObj, result.whereFields, result.values);
+    }
 
-    } catch(error) {
-        hasError = true;
-        // 동기 에러 처리
-        ctx.error_message = error.message || error.toString();
-        ctx.error_class = error.name || error.constructor?.name || 'MongooseError';
+    // update 조건 파싱 - 수정된 로직
+    if (updateObj && typeof updateObj === 'object') {
+        this.extractUpdateFieldsOnly(updateObj, result.updateFields, result.values);
+    }
 
-        // 에러 정보를 DataTextAgent에도 추가
-        if (conn_dbc_hash) {
-            DataTextAgent.ERROR.add(conn_dbc_hash, ctx.error_message);
-        }
+    return result;
+};
 
-        Logger.printError("WHATAP-611", "Mongodb " + methodName + " execution error", error, false);
-        throw error;
+// Aggregate pipeline 파싱
+MongooseObserver.prototype.parseAggregatePipeline = function(pipeline) {
+    const result = {
+        matchFields: [],
+        groupFields: [],
+        projectFields: [],
+        values: []
+    };
+
+    if (Array.isArray(pipeline)) {
+        pipeline.forEach(stage => {
+            if (stage.$match) {
+                this.extractFieldsAndValues(stage.$match, result.matchFields, result.values);
+            }
+            if (stage.$group) {
+                this.extractGroupFields(stage.$group, result.groupFields);
+            }
+            if (stage.$project) {
+                this.extractProjectFields(stage.$project, result.projectFields);
+            }
+        });
     }
 
-    // 결과 처리
-    try {
-        dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
-        ctx.profile.push(dbc_step);
-
-        // operation 이름 가져오기
-        var operation = (result && result.op) ? result.op : methodName;
-        ctx.footprint('Mongodb Command Start: ' + operation);
+    return result;
+};
 
-        // Model 이름 가져오기
-        var modelName = thisArg.modelName || 'Unknown';
+// Insert documents 파싱
+MongooseObserver.prototype.parseInsertDocuments = function(methodName, docs) {
+    const result = {
+        insertFields: [],
+        values: []
+    };
+
+    if (methodName === 'insertMany' && Array.isArray(docs)) {
+        // 첫 번째 문서의 필드들을 기준으로 함
+        if (docs.length > 0 && typeof docs[0] === 'object') {
+            this.extractFieldsAndValues(docs[0], result.insertFields, result.values);
+        }
+    } else if (docs && typeof docs === 'object') {
+        this.extractFieldsAndValues(docs, result.insertFields, result.values);
+    }
 
-        var sql = modelName + ' ' + operation;
+    return result;
+};
 
-        if (argsArray[0]) {
-            try {
-                var keys = typeof argsArray[0] === 'object' ? Object.keys(argsArray[0]) : [argsArray[0]];
-                sql += ' field=' + JSON.stringify(keys);
-            } catch(e) {
-                sql += ' field=[unknown]';
+// 필드와 값 추출 (기본)
+MongooseObserver.prototype.extractFieldsAndValues = function(obj, fieldsArray, valuesArray) {
+    if (!obj || typeof obj !== 'object') return;
+
+    Object.keys(obj).forEach(key => {
+        if (key.startsWith('$')) {
+            // MongoDB 연산자는 중첩 처리
+            if (typeof obj[key] === 'object') {
+                this.extractFieldsAndValues(obj[key], fieldsArray, valuesArray);
+            } else {
+                valuesArray.push(obj[key]);
+            }
+        } else {
+            fieldsArray.push(key);
+            if (obj[key] !== null && obj[key] !== undefined) {
+                if (typeof obj[key] === 'object' && !Array.isArray(obj[key])) {
+                    // 중첩 객체의 값들도 추출
+                    this.extractNestedValues(obj[key], valuesArray);
+                } else {
+                    valuesArray.push(obj[key]);
+                }
             }
         }
-        if (argsArray[1]) {
-            try {
-                var keys = typeof argsArray[1] === 'object' ? Object.keys(argsArray[1]) : [argsArray[1]];
-                sql += ' value=' + JSON.stringify(keys);
-            } catch(e) {
-                sql += ' value=[unknown]';
+    });
+};
+
+// Update 필드만 추출 (수정된 버전) - where 필드 중복 방지
+MongooseObserver.prototype.extractUpdateFieldsOnly = function(updateObj, fieldsArray, valuesArray) {
+    if (!updateObj || typeof updateObj !== 'object') return;
+
+    Object.keys(updateObj).forEach(key => {
+        if (key.startsWith('$')) {
+            // $set: {name: 'new', email: 'new'} 처리
+            if (key === '$set' || key === '$inc' || key === '$push' || key === '$pull' || key === '$unset') {
+                if (typeof updateObj[key] === 'object') {
+                    Object.keys(updateObj[key]).forEach(field => {
+                        fieldsArray.push(field);
+                        const value = updateObj[key][field];
+                        if (value !== null && value !== undefined) {
+                            valuesArray.push(value);
+                        }
+                    });
+                }
+            }
+            // 다른 연산자들도 필요시 추가
+        } else {
+            // 직접 업데이트: {name: "new"} 형태
+            fieldsArray.push(key);
+            if (updateObj[key] !== null && updateObj[key] !== undefined) {
+                valuesArray.push(updateObj[key]);
             }
         }
+    });
+};
 
-        sql_step.hash = HashUtil.hashFromString(sql);
-        sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
-        DataTextAgent.SQL.add(sql_step.hash, sql);
-        ctx.profile.push(sql_step);
+// Group 필드 추출
+MongooseObserver.prototype.extractGroupFields = function(groupObj, fieldsArray) {
+    if (!groupObj || typeof groupObj !== 'object') return;
 
-    } catch(e) {
-        Logger.printError("WHATAP-611", "Mongodb query processing error", e, false);
-    }
+    Object.keys(groupObj).forEach(key => {
+        if (key !== '_id') {
+            fieldsArray.push(key);
+        }
+    });
+};
 
-    return result;
+// Project 필드 추출
+MongooseObserver.prototype.extractProjectFields = function(projectObj, fieldsArray) {
+    if (!projectObj || typeof projectObj !== 'object') return;
+
+    Object.keys(projectObj).forEach(key => {
+        fieldsArray.push(key);
+    });
+};
+
+// 중첩 값 추출
+MongooseObserver.prototype.extractNestedValues = function(obj, valuesArray) {
+    if (!obj || typeof obj !== 'object') return;
+
+    Object.values(obj).forEach(value => {
+        if (value !== null && value !== undefined) {
+            if (typeof value === 'object' && !Array.isArray(value)) {
+                this.extractNestedValues(value, valuesArray);
+            } else {
+                valuesArray.push(value);
+            }
+        }
+    });
+};
+
+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;
+    }
 };
 
 exports.MongooseObserver = MongooseObserver;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "whatap",
   "homepage": "http://www.whatap.io",
-  "version": "0.5.20",
-  "releaseDate": "20250626",
+  "version": "0.5.22",
+  "releaseDate": "20250630",
   "description": "Monitoring and Profiling Service",
   "main": "index.js",
   "scripts": {},