whatap 0.5.26 → 1.0.0

package/lib/observers/mongoose-observer.js

@@ -1,583 +1,388 @@
+/**
+ * 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'),
-    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');
+    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;
 
 var MongooseObserver = function (agent) {
     this.agent = agent;
     this.packages = ['mongoose'];
 };
 
-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;
-        };
-    });
+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'
 };
 
-MongooseObserver.prototype.patchModelMethods = function(Model) {
-    if(Model.__whatap_observe__) {return;}
-    Model.__whatap_observe__ = true;
-    var self = this;
-
-    // 단일 필터 메서드 패치
-    collectionMethodsWithFilter.forEach(function(methodName) {
-        if (Model[methodName]) {
-            shimmer.wrap(Model, methodName, function(originalMethod) {
-                return self.createSingleFilterWrapper(originalMethod, methodName);
-            });
-        }
-    });
-
-    // 이중 필터 메서드 패치
-    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);
-        });
+// 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);
     }
+}
 
-    // 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);
+// Mongoose 에러 처리
+function handleMongooseError(ctx, err) {
+    if (!err) return;
 
-            // 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(',')}]`;
-            }
-
-            // 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;
+    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);
             }
-
-            ctx.profile.push(sql_step);
-
-        } catch (e) {
-            Logger.printError("WHATAP-611", "Mongodb single filter query error", e, false);
+            errorStack = stackLines.join("\n");
         }
 
-        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);
+        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;
         }
-        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(',')}]`;
-            }
-
-            if (parseResult.updateFields.length > 0) {
-                sql += ` field=[${parseResult.updateFields.join(',')}]`;
+        if (shouldAddError) {
+            if (!ctx.error) ctx.error = 1;
+            ctx.status = 500;
+            var errors = [errorClass];
+            if (errorMessage) {
+                errors.push(errorMessage);
             }
-
-            // 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;
+            if (errorStack || err.stack) {
+                errors.push(errorStack || err.stack);
             }
 
-            ctx.profile.push(sql_step);
-
-        } catch (e) {
-            Logger.printError("WHATAP-611", "Mongodb double filter query error", e, false);
-        }
-
-        return result;
-    };
-};
-
-MongooseObserver.prototype.createAggregateWrapper = function(originalAggregate) {
-    var self = this;
-
-    return function wrappedAggregate() {
-        const ctx = TraceContextManager.getCurrentContext();
-        if (!ctx) {
-            return originalAggregate.apply(this, arguments);
+            AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
         }
-        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 = 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 (parseResult.matchFields.length > 0) {
-                sql += ` where=[${parseResult.matchFields.join(',')}]`;
-            }
-
-            if (parseResult.groupFields.length > 0) {
-                sql += ` group=[${parseResult.groupFields.join(',')}]`;
+    } 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);
             }
 
-            if (parseResult.projectFields.length > 0) {
-                sql += ` field=[${parseResult.projectFields.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(',') + ']');
+                        }
 
-            // 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}'`;
+                        // 두 번째 인자에서 업데이트 필드 추출 (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(',') + ']');
+                            }
+                        }
                     }
-                    return val;
-                }).toString();
-                sql_step.p2 = toParamBytes(valuesString, crc);
-                sql_step.pcrc = crc.value;
-            }
+                } catch (e) {
+                    Logger.printError('WHATAP-246', 'Error extracting field names', e, false);
+                }
 
-            ctx.profile.push(sql_step);
+                var commandText = 'MongoDB ' + queryParts.join(' ');
 
-        } catch (e) {
-            Logger.printError("WHATAP-611", "Mongodb aggregate query error", e, false);
-        }
+                function executeCallback(err, result) {
+                    try {
+                        var command_elapsed = Date.now() - command_start_time;
 
-        return result;
-    };
-};
+                        if (err) {
+                            handleMongooseError(ctx, err);
+                        }
 
-MongooseObserver.prototype.createInsertWrapper = function(originalMethod, methodName) {
-    var self = this;
+                        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);
+                    }
+                }
 
-    return function wrappedInsert() {
-        const ctx = TraceContextManager.getCurrentContext();
-        if (!ctx) {
-            return originalMethod.apply(this, arguments);
-        }
-        ctx.__mongoose_traced__ = true;
+                // 콜백 처리
+                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;
+                    }
+                }
 
-        const dbc_step = self.createDBCStep(ctx);
-        dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
-        ctx.profile.push(dbc_step);
+                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;
+                        });
+                    }
 
-        // SQL Step 생성
-        const sql_step = new SqlStepX();
-        sql_step.start_time = ctx.getElapsedTime();
+                    // 동기적 결과 처리
+                    if (!hasCallback) {
+                        executeCallback(null, result);
+                    }
 
-        const result = originalMethod.apply(this, arguments);
-        sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+                    return result;
+                } catch (executeError) {
+                    executeCallback(executeError, null);
+                    throw executeError;
+                }
+            });
+        };
+    };
+}
 
-        try {
-            const docs = arguments[0];
-            const parseResult = self.parseInsertDocuments(methodName, docs);
+// 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();
 
-            // SQL 문자열 생성
-            const modelName = this.modelName || 'Unknown';
-            let sql = `${modelName} ${methodName}`;
+            setupDbcInfo(connectionString);
 
-            if (parseResult.insertFields.length > 0) {
-                sql += ` field=[${parseResult.insertFields.join(',')}]`;
+            if (!ctx) {
+                return original.apply(this, arguments);
             }
 
-            // 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}'`;
+            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;
                     }
-                    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 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);
-    }
-
-    var dbc_step = new DBCStep();
-    dbc_step.hash = conn_dbc_hash;
-    dbc_step.start_time = ctx.getElapsedTime();
+                }
 
-    return dbc_step;
-};
+                var result = original.apply(this, args);
 
-// 비동기 결과 처리
-MongooseObserver.prototype.handleAsyncResult = function(result, ctx, methodName) {
-    ctx.footprint('Mongodb Command Start: ' + methodName);
+                // 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');
+                        }
 
-    // Promise인 경우 처리 (대부분의 Mongoose 메서드가 Promise 반환)
-    if (result && typeof result.then === 'function') {
-        // 이미 실행은 완료되었으므로 특별한 처리 불필요
-        return result;
-    }
+                        // 연결 완료 후 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.parseSingleFilter = function(methodName, filterObj) {
-    const result = {
-        whereFields: [],
-        values: []
+                return result;
+            });
+        };
     };
-
-    if (filterObj && typeof filterObj === 'object') {
-        this.extractFieldsAndValues(filterObj, result.whereFields, result.values);
-    }
-
-    return result;
 };
 
-// 이중 필터 파싱 - 수정된 버전
-MongooseObserver.prototype.parseDoubleFilter = function(methodName, filterObj, updateObj) {
-    const result = {
-        whereFields: [],
-        updateFields: [],
-        values: []
-    };
+// 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__) {
 
-    // where 조건 파싱
-    if (filterObj && typeof filterObj === 'object') {
-        this.extractFieldsAndValues(filterObj, result.whereFields, result.values);
+                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);
     }
+}
 
-    // update 조건 파싱 - 수정된 로직
-    if (updateObj && typeof updateObj === 'object') {
-        this.extractUpdateFieldsOnly(updateObj, result.updateFields, result.values);
+MongooseObserver.prototype.inject = function(mod, moduleName) {
+    if (mod.__whatap_observe__) {
+        return;
     }
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("MongooseObserver");
 
-    return result;
-};
-
-// 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);
-            }
-        });
+    if (conf.sql_enabled === false) {
+        return;
     }
 
-    return result;
-};
-
-// Insert documents 파싱
-MongooseObserver.prototype.parseInsertDocuments = function(methodName, docs) {
-    const result = {
-        insertFields: [],
-        values: []
-    };
+    var self = this;
 
-    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.connect 래핑
+    if (mod.connect && !mod.connect.__whatap_wrapped__) {
+        shimmer.wrap(mod, 'connect', createConnectWrapper());
+        mod.connect.__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]);
-                }
-            }
-        }
-    });
-};
+    // 기본 Model이 이미 존재하는 경우 래핑
+    if (mod.Model) {
+        wrapModelMethods(mod.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]);
+    // 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;
             }
-        }
-    });
-};
-
-// 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;
-
-    Object.keys(projectObj).forEach(key => {
-        fieldsArray.push(key);
-    });
-};
 
-// 중첩 값 추출
-MongooseObserver.prototype.extractNestedValues = function(obj, valuesArray) {
-    if (!obj || typeof obj !== 'object') return;
+            return model;
+        };
 
-    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);
-            }
-        }
-    });
-};
+        // 기존 속성들 복사
+        Object.keys(originalModel).forEach(function(key) {
+            mod.model[key] = originalModel[key];
+        });
 
-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;
+        mod.model.__whatap_wrapped__ = true;
     }
 };