whatap 1.0.1 → 1.0.2

package/lib/observers/mongoose-observer.js

@@ -1,388 +1,583 @@
-/**
- * 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'),
-    HashUtil = require('../util/hashutil'),
-    Logger = require('../logger'),
-    conf = require('../conf/configure'),
-    AsyncSender = require('../udp/async_sender'),
-    PacketTypeEnum = require('../udp/packet_type_enum'),
-    shimmer = require('../core/shimmer'),
-    AsyncResource = require('async_hooks').AsyncResource;
+    SqlStepX            = require('../step/sql-stepx'),
+    DataTextAgent       = require('../data/datatext-agent'),
+    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) {
     this.agent = agent;
     this.packages = ['mongoose'];
 };
 
-var dbc_hash = 0;
-var dbc = '';
-
-// Mongoose 명령어 매핑
-var MONGOOSE_COMMANDS = {
-    'create': 'CREATE',
-    'insertMany': 'INSERTMANY',
-    'find': 'FIND',
-    'findById': 'FINDBYID',
-    'findOne': 'FINDONE',
-    'countDocuments': 'COUNTDOCUMENTS',
-    'distinct': 'DISTINCT',
-    'updateMany': 'UPDATEMANY',
-    'updateOne': 'UPDATEONE',
-    'replaceOne': 'REPLACEONE',
-    'findOneAndUpdate': 'FINDONEANDUPDATE',
-    'findByIdAndUpdate': 'FINDBYIDANDUPDATE',
-    'deleteOne': 'DELETEONE',
-    'deleteMany': 'DELETEMANY',
-    'findOneAndDelete': 'FINDONEANDDELETE',
-    'findByIdAndDelete': 'FINDBYIDANDDELETE',
-    'aggregate': 'AGGREGATE'
+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;
+
+    // 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);
+        };
+    });
+
+    // Model 생성 후킹
+    shimmer.wrap(mod, 'model', function(originalModel) {
+        return function wrappedModel() {
+            const model = originalModel.apply(this, arguments);
+
+            // 생성된 Model에 메서드 패치 적용
+            self.patchModelMethods(model);
+
+            return model;
+        };
+    });
 };
 
-// DBC 정보 설정
-function setupDbcInfo(connectionString) {
-    if (dbc_hash === 0 && connectionString) {
-        dbc = connectionString;
-        dbc_hash = HashUtil.hashFromString(dbc);
-        Logger.print('WHATAP-MONGOOSE-DBC', 'DBC setup: ' + dbc, false);
-    }
-}
+MongooseObserver.prototype.patchModelMethods = function(Model) {
+    if(Model.__whatap_observe__) {return;}
+    Model.__whatap_observe__ = true;
+    var self = this;
 
-// Mongoose 에러 처리
-function handleMongooseError(ctx, err) {
-    if (!err) return;
+    // 단일 필터 메서드 패치
+    collectionMethodsWithFilter.forEach(function(methodName) {
+        if (Model[methodName]) {
+            shimmer.wrap(Model, methodName, function(originalMethod) {
+                return self.createSingleFilterWrapper(originalMethod, methodName);
+            });
+        }
+    });
 
-    try {
-        var errorClass = err.code || err.name || 'MongooseError';
-        var errorMessage = err.message || 'mongoose error';
-        var errorStack = '';
-
-        if (conf.trace_sql_error_stack && conf.trace_sql_error_depth && err.stack) {
-            var traceDepth = conf.trace_sql_error_depth;
-            var stackLines = err.stack.split("\n");
-            if (stackLines.length > traceDepth) {
-                stackLines = stackLines.slice(0, traceDepth + 1);
-            }
-            errorStack = stackLines.join("\n");
+    // 이중 필터 메서드 패치
+    collectionMethodsWithTwoFilters.forEach(function(methodName) {
+        if (Model[methodName]) {
+            shimmer.wrap(Model, methodName, function(originalMethod) {
+                return self.createDoubleFilterWrapper(originalMethod, methodName);
+            });
         }
+    });
+
+    // aggregate 메서드 패치
+    if (Model.aggregate) {
+        shimmer.wrap(Model, 'aggregate', function(originalAggregate) {
+            return self.createAggregateWrapper(originalAggregate);
+        });
+    }
 
-        var shouldAddError = false;
-        if (conf._is_trace_ignore_err_cls_contains === true && errorClass &&
-            errorClass.toString().indexOf(conf.trace_ignore_err_cls_contains) < 0) {
-            shouldAddError = true;
-        } else if (conf._is_trace_ignore_err_msg_contains === true && errorMessage &&
-            errorMessage.indexOf(conf.trace_ignore_err_msg_contains) < 0) {
-            shouldAddError = true;
-        } else if (conf._is_trace_ignore_err_cls_contains === false &&
-            conf._is_trace_ignore_err_msg_contains === false) {
-            shouldAddError = true;
+    // create, insertMany 패치
+    ['create', 'insertMany'].forEach(function(methodName) {
+        if (Model[methodName]) {
+            shimmer.wrap(Model, methodName, function(originalMethod) {
+                return self.createInsertWrapper(originalMethod, methodName);
+            });
+        }
+    });
+};
+
+MongooseObserver.prototype.createSingleFilterWrapper = function(originalMethod, methodName) {
+    var self = this;
+
+    return function wrappedSingleFilter() {
+        const ctx = TraceContextManager.getCurrentContext();
+        if (!ctx) {
+            return originalMethod.apply(this, arguments);
         }
+        ctx.__mongoose_traced__ = true;
+
+        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;
+
+        try {
+            const filterObj = arguments[0];
+            const parseResult = self.parseSingleFilter(methodName, filterObj);
 
-        if (shouldAddError) {
-            if (!ctx.error) ctx.error = 1;
-            ctx.status = 500;
-            var errors = [errorClass];
-            if (errorMessage) {
-                errors.push(errorMessage);
+            // SQL 문자열 생성: "ModelName methodName where=[field1,field2]"
+            const modelName = this.modelName || 'Unknown';
+            let sql = `${modelName} ${methodName}`;
+
+            if (parseResult.whereFields.length > 0) {
+                sql += ` where=[${parseResult.whereFields.join(',')}]`;
             }
-            if (errorStack || err.stack) {
-                errors.push(errorStack || err.stack);
+
+            // 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;
             }
 
-            AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+            ctx.profile.push(sql_step);
+
+        } catch (e) {
+            Logger.printError("WHATAP-611", "Mongodb single filter query error", e, false);
         }
-    } catch (e) {
-        Logger.printError('WHATAP-245', 'Error handling Mongoose error', e, false);
-    }
-}
-
-// Model 메서드 래퍼 생성
-function createModelMethodWrapper(methodName) {
-    return function(original) {
-        return function wrappedMethod() {
-            var ctx = TraceContextManager.getCurrentContext();
-            if (!ctx) {
-                return original.apply(this, arguments);
+
+        return result;
+    };
+};
+
+MongooseObserver.prototype.createDoubleFilterWrapper = function(originalMethod, methodName) {
+    var self = this;
+
+    return function wrappedDoubleFilter() {
+        const ctx = TraceContextManager.getCurrentContext();
+        if (!ctx) {
+            return originalMethod.apply(this, arguments);
+        }
+        ctx.__mongoose_traced__ = true;
+
+        // DBC Step 생성
+        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;
+
+        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(',')}]`;
             }
 
-            var args = Array.prototype.slice.call(arguments);
-            var modelName = this.modelName || this.collection?.collectionName || 'unknown';
-            var commandName = MONGOOSE_COMMANDS[methodName] || methodName.toUpperCase();
-
-            const asyncResource = new AsyncResource('mongoose-command');
-
-            return asyncResource.runInAsyncScope(() => {
-                // DB 연결 패킷 전송
-                ctx.start_time = Date.now();
-                ctx.elapsed = 0;
-                AsyncSender.send_packet(PacketTypeEnum.TX_DB_CONN, ctx, [dbc]);
-
-                var command_start_time = Date.now();
-                ctx.footprint(`Mongoose ${commandName} Start`);
-
-                // 쿼리 텍스트 구성
-                var queryParts = [commandName, modelName];
-                var fieldNames = [];
-
-                try {
-                    if (methodName === 'aggregate' && Array.isArray(args[0])) {
-                        // aggregate 파이프라인 처리
-                        var pipelineFields = [];
-                        args[0].forEach(function(stage) {
-                            if (stage.$match) {
-                                pipelineFields = pipelineFields.concat(Object.keys(stage.$match));
-                            }
-                            if (stage.$group) {
-                                pipelineFields = pipelineFields.concat(Object.keys(stage.$group));
-                            }
-                        });
-                        if (pipelineFields.length > 0) {
-                            queryParts.push('field=[' + pipelineFields.join(',') + ']');
-                        }
-                    } else {
-                        // 첫 번째 인자에서 필드명 추출
-                        if (args[0] && typeof args[0] === 'object' && !Array.isArray(args[0])) {
-                            fieldNames = Object.keys(args[0]);
-                        }
-                        if (fieldNames.length > 0) {
-                            queryParts.push('field=[' + fieldNames.join(',') + ']');
-                        }
+            if (parseResult.updateFields.length > 0) {
+                sql += ` field=[${parseResult.updateFields.join(',')}]`;
+            }
 
-                        // 두 번째 인자에서 업데이트 필드 추출 (update 계열 메서드)
-                        if (args[1] && typeof args[1] === 'object' &&
-                            (methodName.includes('update') || methodName.includes('Update'))) {
-                            var updateFields = [];
-                            if (args[1].$set) {
-                                updateFields = updateFields.concat(Object.keys(args[1].$set));
-                            } else {
-                                updateFields = Object.keys(args[1]);
-                            }
-                            if (updateFields.length > 0) {
-                                queryParts.push('value=[' + updateFields.join(',') + ']');
-                            }
-                        }
+            // 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}'`;
                     }
-                } catch (e) {
-                    Logger.printError('WHATAP-246', 'Error extracting field names', e, false);
-                }
+                    return val;
+                }).toString();
+                sql_step.p2 = toParamBytes(valuesString, crc);
+                sql_step.pcrc = crc.value;
+            }
 
-                var commandText = 'MongoDB ' + queryParts.join(' ');
+            ctx.profile.push(sql_step);
 
-                function executeCallback(err, result) {
-                    try {
-                        var command_elapsed = Date.now() - command_start_time;
+        } catch (e) {
+            Logger.printError("WHATAP-611", "Mongodb double filter query error", e, false);
+        }
 
-                        if (err) {
-                            handleMongooseError(ctx, err);
-                        }
+        return result;
+    };
+};
 
-                        ctx.elapsed = command_elapsed;
-                        AsyncSender.send_packet(PacketTypeEnum.TX_SQL, ctx, [dbc, commandText, '0']);
-                        ctx.footprint(`Mongoose ${commandName} Done`);
-                    } catch (e) {
-                        Logger.printError('WHATAP-247', 'Error in Mongoose callback', e, false);
-                    }
-                }
+MongooseObserver.prototype.createAggregateWrapper = function(originalAggregate) {
+    var self = this;
 
-                // 콜백 처리
-                var hasCallback = false;
-                for (var i = args.length - 1; i >= 0; i--) {
-                    if (typeof args[i] === 'function') {
-                        hasCallback = true;
-                        var originalCallback = args[i];
-
-                        args[i] = asyncResource.bind(function() {
-                            var callbackArgs = Array.prototype.slice.call(arguments);
-                            executeCallback(callbackArgs[0], callbackArgs[1]);
-
-                            if (originalCallback && typeof originalCallback === 'function') {
-                                return originalCallback.apply(this, callbackArgs);
-                            }
-                        });
-                        break;
-                    }
-                }
+    return function wrappedAggregate() {
+        const ctx = TraceContextManager.getCurrentContext();
+        if (!ctx) {
+            return originalAggregate.apply(this, arguments);
+        }
+        ctx.__mongoose_traced__ = true;
 
-                try {
-                    var result = original.apply(this, args);
-
-                    // Promise 기반 처리
-                    if (!hasCallback && result && typeof result.then === 'function') {
-                        return result.then(function(res) {
-                            executeCallback(null, res);
-                            return res;
-                        }).catch(function(err) {
-                            executeCallback(err, null);
-                            throw err;
-                        });
-                    }
+        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 = originalAggregate.apply(this, arguments);
+        sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+
+        try {
+            const pipeline = arguments[0];
+            const parseResult = self.parseAggregatePipeline(pipeline);
+
+            // SQL 문자열 생성
+            const modelName = this.modelName || 'Unknown';
+            let sql = `${modelName} aggregate`;
 
-                    // 동기적 결과 처리
-                    if (!hasCallback) {
-                        executeCallback(null, result);
+            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;
+            }
 
-                    return result;
-                } catch (executeError) {
-                    executeCallback(executeError, null);
-                    throw executeError;
-                }
-            });
-        };
+            ctx.profile.push(sql_step);
+
+        } catch (e) {
+            Logger.printError("WHATAP-611", "Mongodb aggregate query error", e, false);
+        }
+
+        return result;
     };
-}
+};
 
-// Connection wrapper 함수
-var createConnectWrapper = function() {
-    return function(original) {
-        return function wrappedConnect() {
-            var args = Array.prototype.slice.call(arguments);
-            var connectionString = args[0];
-            var ctx = TraceContextManager.getCurrentContext();
+MongooseObserver.prototype.createInsertWrapper = function(originalMethod, methodName) {
+    var self = this;
+
+    return function wrappedInsert() {
+        const ctx = TraceContextManager.getCurrentContext();
+        if (!ctx) {
+            return originalMethod.apply(this, arguments);
+        }
+        ctx.__mongoose_traced__ = true;
+
+        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;
 
-            setupDbcInfo(connectionString);
+        try {
+            const docs = arguments[0];
+            const parseResult = self.parseInsertDocuments(methodName, docs);
 
-            if (!ctx) {
-                return original.apply(this, arguments);
+            // SQL 문자열 생성
+            const modelName = this.modelName || 'Unknown';
+            let sql = `${modelName} ${methodName}`;
+
+            if (parseResult.insertFields.length > 0) {
+                sql += ` field=[${parseResult.insertFields.join(',')}]`;
             }
 
-            const connectionResource = new AsyncResource('mongoose-connect');
-
-            return connectionResource.runInAsyncScope(() => {
-                ctx.start_time = Date.now();
-                ctx.footprint('Mongoose Connecting Start');
-                ctx.db_opening = true;
-
-                // 콜백 래핑
-                for (var i = args.length - 1; i >= 0; i--) {
-                    if (typeof args[i] === 'function') {
-                        var originalCallback = args[i];
-                        args[i] = connectionResource.bind(function() {
-                            var callbackArgs = Array.prototype.slice.call(arguments);
-                            var err = callbackArgs[0];
-
-                            if (ctx) {
-                                ctx.elapsed = Date.now() - ctx.start_time;
-                                ctx.db_opening = false;
-
-                                if (err) {
-                                    handleMongooseError(ctx, err);
-                                    ctx.footprint('Mongoose Connecting Error');
-                                } else {
-                                    ctx.footprint('Mongoose Connecting Done');
-                                }
-                            }
-
-                            return originalCallback.apply(this, callbackArgs);
-                        });
-                        break;
+            // 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 result = original.apply(this, args);
+            ctx.profile.push(sql_step);
 
-                // Promise 기반 처리
-                if (result && typeof result.then === 'function') {
-                    return result.then(connectionResource.bind(function(connection) {
-                        if (ctx) {
-                            ctx.elapsed = Date.now() - ctx.start_time;
-                            ctx.db_opening = false;
-                            ctx.footprint('Mongoose Connecting Done');
-                        }
+        } catch (e) {
+            Logger.printError("WHATAP-611", "Mongodb insert query error", e, false);
+        }
 
-                        // 연결 완료 후 Model 래핑
-                        if (connection && connection.Model) {
-                            wrapModelMethods(connection.Model);
-                        }
+        return result;
+    };
+};
 
-                        return connection;
-                    })).catch(connectionResource.bind(function(err) {
-                        if (ctx) {
-                            ctx.elapsed = Date.now() - ctx.start_time;
-                            ctx.db_opening = false;
-                            ctx.footprint('Mongoose Connecting Error');
-                            handleMongooseError(ctx, err);
-                        }
-                        throw err;
-                    }));
-                }
+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);
+    }
 
-                return result;
-            });
-        };
-    };
+    var dbc_step = new DBCStep();
+    dbc_step.hash = conn_dbc_hash;
+    dbc_step.start_time = ctx.getElapsedTime();
+
+    return dbc_step;
 };
 
-// Model 메서드 래핑 함수
-function wrapModelMethods(ModelConstructor) {
-    if (ModelConstructor && ModelConstructor.prototype && !ModelConstructor.__whatap_wrapped__) {
-        Object.keys(MONGOOSE_COMMANDS).forEach(function(methodName) {
-            if (ModelConstructor.prototype[methodName] &&
-                !ModelConstructor.prototype[methodName].__whatap_wrapped__) {
+// 비동기 결과 처리
+MongooseObserver.prototype.handleAsyncResult = function(result, ctx, methodName) {
+    ctx.footprint('Mongodb Command Start: ' + methodName);
 
-                shimmer.wrap(ModelConstructor.prototype, methodName,
-                    createModelMethodWrapper(methodName));
-                ModelConstructor.prototype[methodName].__whatap_wrapped__ = true;
-            }
-        });
-        ModelConstructor.__whatap_wrapped__ = true;
-        Logger.print('WHATAP-MONGOOSE-MODEL', 'Model methods wrapped', false);
+    // Promise인 경우 처리 (대부분의 Mongoose 메서드가 Promise 반환)
+    if (result && typeof result.then === 'function') {
+        // 이미 실행은 완료되었으므로 특별한 처리 불필요
+        return result;
+    }
+
+    return result;
+};
+
+// 단일 필터 파싱
+MongooseObserver.prototype.parseSingleFilter = function(methodName, filterObj) {
+    const result = {
+        whereFields: [],
+        values: []
+    };
+
+    if (filterObj && typeof filterObj === 'object') {
+        this.extractFieldsAndValues(filterObj, result.whereFields, result.values);
     }
-}
 
-MongooseObserver.prototype.inject = function(mod, moduleName) {
-    if (mod.__whatap_observe__) {
-        return;
+    return result;
+};
+
+// 이중 필터 파싱 - 수정된 버전
+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);
     }
-    mod.__whatap_observe__ = true;
-    Logger.initPrint("MongooseObserver");
 
-    if (conf.sql_enabled === false) {
-        return;
+    // update 조건 파싱 - 수정된 로직
+    if (updateObj && typeof updateObj === 'object') {
+        this.extractUpdateFieldsOnly(updateObj, result.updateFields, result.values);
     }
 
-    var self = this;
+    return result;
+};
 
-    // mongoose.connect 래핑
-    if (mod.connect && !mod.connect.__whatap_wrapped__) {
-        shimmer.wrap(mod, 'connect', createConnectWrapper());
-        mod.connect.__whatap_wrapped__ = true;
+// 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);
+            }
+        });
     }
 
-    // 기본 Model이 이미 존재하는 경우 래핑
-    if (mod.Model) {
-        wrapModelMethods(mod.Model);
+    return result;
+};
+
+// 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);
     }
 
-    // mongoose.model() 메서드 래핑 (새로운 모델 생성 시)
-    if (mod.model && !mod.model.__whatap_wrapped__) {
-        var originalModel = mod.model;
-        mod.model = function() {
-            var model = originalModel.apply(this, arguments);
-
-            // 새로 생성된 모델의 메서드들 래핑
-            if (model && !model.__whatap_wrapped__) {
-                Object.keys(MONGOOSE_COMMANDS).forEach(function(methodName) {
-                    if (model[methodName] && !model[methodName].__whatap_wrapped__) {
-                        shimmer.wrap(model, methodName, createModelMethodWrapper(methodName));
-                        model[methodName].__whatap_wrapped__ = true;
-                    }
-                });
-                model.__whatap_wrapped__ = true;
+    return result;
+};
+
+// 필드와 값 추출 (기본)
+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]);
+                }
             }
+        }
+    });
+};
 
-            return model;
-        };
+// 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]);
+            }
+        }
+    });
+};
 
-        // 기존 속성들 복사
-        Object.keys(originalModel).forEach(function(key) {
-            mod.model[key] = originalModel[key];
-        });
+// Group 필드 추출
+MongooseObserver.prototype.extractGroupFields = function(groupObj, fieldsArray) {
+    if (!groupObj || typeof groupObj !== 'object') return;
+
+    Object.keys(groupObj).forEach(key => {
+        if (key !== '_id') {
+            fieldsArray.push(key);
+        }
+    });
+};
+
+// Project 필드 추출
+MongooseObserver.prototype.extractProjectFields = function(projectObj, fieldsArray) {
+    if (!projectObj || typeof projectObj !== 'object') return;
 
-        mod.model.__whatap_wrapped__ = true;
+    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;
     }
 };