whatap 0.5.19 → 0.5.21

package/lib/observers/mongoose-observer.js

@@ -1,10 +1,10 @@
-
 var TraceContextManager = require('../trace/trace-context-manager'),
     SqlStepX            = require('../step/sql-stepx'),
     DataTextAgent       = require('../data/datatext-agent'),
     HashUtil            = require('../util/hashutil');
-const DBCStep = require("whatap/lib/step/dbc-step");
-const Logger = require("whatap/lib/logger");
+const DBCStep = require("../step/dbc-step");
+const Logger = require("../logger");
+const shimmer = require('../core/shimmer');
 
 var MongooseObserver = function (agent) {
     this.agent = agent;
@@ -12,8 +12,8 @@ var MongooseObserver = function (agent) {
 };
 
 var dbc_step, dbc, conn_dbc_hash;
-MongooseObserver.prototype.inject = function (mod, modName) {
 
+MongooseObserver.prototype.inject = function (mod, modName) {
     var self = this;
     var hookCommand = [
         "create",             // Create: Create a new document
@@ -34,133 +34,433 @@ MongooseObserver.prototype.inject = function (mod, modName) {
         "findByIdAndDelete"   // Delete: Find a document by its ID and delete it
     ];
 
-    self.agent.aop.after(mod, ['connect'] ,function (obj, args, ret) {
-        if(!args[0]) { return; }
-        if(dbc) { return; }
-        dbc = args[0];
-        conn_dbc_hash = HashUtil.hashFromString(dbc);
-
-        ret.then(data => {
-            self.agent.aop.both(data.Model, 'aggregate', function (_obj, _args, _lctx) {
-                var ctx = TraceContextManager.getCurrentContext();
-                if(!ctx) {return;}
-
-                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);
+    // 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);
+            }
+
+            dbc = args[0];
+            conn_dbc_hash = HashUtil.hashFromString(dbc);
+
+            var result = original.apply(this, arguments);
+
+            // Promise 체인으로 연결 성공 후 Model을 hook
+            result.then(connection => {
+                // Model 생성 시점을 intercept하기 위해 mongoose.model을 hook
+                self.hookModelCreation(mod);
+
+            }).catch(e => {
+                Logger.printError("WHATAP-612", "Mongodb connection error", e, false);
+            });
+
+            return result;
+        };
+    });
+
+    // 이미 생성된 모델들도 처리하기 위해 mongoose.model 함수를 hook
+    this.hookModelCreation(mod);
+};
+
+// Model 생성을 intercept하여 각 Model에 hook을 적용
+MongooseObserver.prototype.hookModelCreation = function(mongoose) {
+    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);
+
+                // 새로 생성된 Model에 hook 적용
+                if (result && typeof result === 'function') {
+                    self.wrapModelMethods(result);
+                }
+
+                return result;
+            };
+        });
+        mongoose._whatapHooked = true;
+    }
+
+    // 이미 존재하는 모델들에도 hook 적용
+    var modelNames = mongoose.modelNames();
+    modelNames.forEach(function(modelName) {
+        var Model = mongoose.model(modelName);
+        self.wrapModelMethods(Model);
+    });
+};
+
+// Model의 메서드들을 wrap
+MongooseObserver.prototype.wrapModelMethods = function(Model) {
+    var self = this;
+
+    if (Model._whatapHooked) {
+        return; // 이미 hook된 경우 스킵
+    }
+
+    // aggregate 메서드 hook (Model에 직접 정의됨)
+    if (typeof Model.aggregate === 'function') {
+        shimmer.wrap(Model, 'aggregate', function(original) {
+            return function wrappedAggregate() {
+                return self.wrapAggregateExecution(original, this, arguments);
+            };
+        });
+    }
+
+    // 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);
+                };
+            });
+        }
+    });
+
+    Model._whatapHooked = true;
+};
+
+// aggregate 실행을 wrap하는 함수
+MongooseObserver.prototype.wrapAggregateExecution = function(original, thisArg, args) {
+    var argsArray = Array.prototype.slice.call(args);
+    var ctx = TraceContextManager.getCurrentContext();
+
+    if(!ctx) {
+        return original.apply(thisArg, argsArray);
+    }
+
+    // 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);
+    }
+
+    // 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();
+
+    var result;
+    var hasError = 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);
+                        }
+
+                        Logger.printError("WHATAP-611", "Mongodb aggregate execution error", error, false);
+                        throw error; // 에러를 다시 던져서 원래 동작 유지
+                    });
                 }
 
-                var dbc_step = new DBCStep();
-                dbc_step.hash = conn_dbc_hash;
-                dbc_step.start_time = ctx.getElapsedTime();
-
-                _lctx.dbc_step = dbc_step;
-
-                var sql_step = new SqlStepX();
-                sql_step.start_time = ctx.getElapsedTime();
-                _lctx.sql_step = sql_step;
-            }, function (_obj, _args, _ret, _lctx) {
-                var ctx = _lctx.context;
-                var dbc_step = _lctx.dbc_step;
-                var sql_step = _lctx.sql_step;
-                if(!ctx || !dbc_step || !sql_step) {return null;}
-
-                dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
-                ctx.profile.push(dbc_step);
-
-                ctx.footprint('Mongodb Command Start: ' + _ret.op );
-
-                const mongooseCollection = _ret._model;
-                try {
-                    var sql = mongooseCollection.modelName + ' aggregate';
-                    var param = "";
-                    if(Array.isArray(_args[0])) {
-                        _args[0].forEach(function (val, i) {
-                            if(i > 0 && param.length > 0) {
-                                param += ",";
-                            }
-                            if(val.hasOwnProperty('$match')) {
-                                var keys = Object.keys(val['$match']);
-                                param += keys;
-                            }
-
-                            if(val.hasOwnProperty('$group')) {
-                                var keys = Object.keys(val['$group']);
-                                param += keys;
-                            }
-                        })
-                    }
-                    sql += ' field=['+param+']';
-
-                    sql_step.hash = HashUtil.hashFromString(sql);
-                    sql_step.start_time = ctx.getElapsedTime();
-                    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 query error", e, false);
-                    sql_step = null;
+                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);
+                        }
+
+                        Logger.printError("WHATAP-611", "Mongodb aggregate execution error", error, false);
+
+                        // 원래 reject 핸들러가 있으면 호출, 없으면 에러를 다시 던짐
+                        if (onReject) {
+                            return onReject(error);
+                        } else {
+                            throw error;
+                        }
+                    });
+                };
+            }
+        }
+
+        // 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';
+
+                // 에러 정보를 DataTextAgent에도 추가
+                if (conn_dbc_hash) {
+                    DataTextAgent.ERROR.add(conn_dbc_hash, ctx.error_message);
                 }
+
+                Logger.printError("WHATAP-611", "Mongodb aggregate execution error", error, false);
+                throw error; // 에러를 다시 던져서 원래 동작 유지
             });
+        }
+
+    } catch(error) {
+        hasError = true;
+        // 동기 에러 처리
+        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);
+        }
+
+        Logger.printError("WHATAP-611", "Mongodb aggregate execution error", error, false);
+        throw error; // 에러를 다시 던져서 원래 동작 유지
+    }
+
+    // 결과 처리
+    try {
+        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);
 
-            self.agent.aop.both(data.Model, hookCommand, function (_obj, _args, _lctx) {
-                if(_args[0] && typeof _args[0] !== "object") { return; }
-                const ctx = TraceContextManager.getCurrentContext();
-                if(!ctx) { return; }
-                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);
+        // Model 이름 가져오기
+        var modelName = thisArg.modelName || 'Unknown';
+
+        var sql = modelName + ' aggregate';
+        var param = "";
+
+        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 += ' field=['+param+']';
+
+        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);
+
+    } catch(e) {
+        Logger.printError("WHATAP-611", "Mongodb aggregate query processing error", e, false);
+    }
+
+    return result;
+};
+
+// 일반 CRUD 메서드 실행을 wrap하는 함수
+MongooseObserver.prototype.wrapMethodExecution = function(original, thisArg, args, methodName) {
+    var argsArray = Array.prototype.slice.call(args);
+
+    // 첫 번째 인자가 객체가 아니면 무시 (일부 메서드 제외)
+    if(argsArray[0] && typeof argsArray[0] !== "object" &&
+        !['findById', 'findByIdAndUpdate', 'findByIdAndDelete'].includes(methodName)) {
+        return original.apply(thisArg, argsArray);
+    }
 
-                var dbc_step = new DBCStep();
-                dbc_step.hash = conn_dbc_hash;
-                dbc_step.start_time = ctx.getElapsedTime();
+    var ctx = TraceContextManager.getCurrentContext();
+    if(!ctx) {
+        return original.apply(thisArg, argsArray);
+    }
 
-                _lctx.dbc_step = dbc_step;
+    // 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);
+    }
 
-                var sql_step = new SqlStepX();
-                sql_step.start_time = ctx.getElapsedTime();
-                _lctx.sql_step = sql_step;
-            }, function (_obj, _args, _ret, _lctx) {
-                var ctx = _lctx.context;
-                var dbc_step = _lctx.dbc_step;
-                var sql_step = _lctx.sql_step;
-                if(!ctx || !dbc_step || !sql_step) {return null;}
+    // DBC Step 생성
+    var dbc_step = new DBCStep();
+    dbc_step.hash = conn_dbc_hash;
+    dbc_step.start_time = ctx.getElapsedTime();
 
-                dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
-                ctx.profile.push(dbc_step);
+    // SQL Step 생성
+    var sql_step = new SqlStepX();
+    sql_step.start_time = ctx.getElapsedTime();
 
-                ctx.footprint('Mongodb Command Start: ' + _ret.op );
+    var result;
+    var hasError = false;
 
-                const mongooseCollection = _ret.mongooseCollection;
-                try {
-                    if(mongooseCollection && mongooseCollection.modelName){
-                        var sql = mongooseCollection.modelName + ' ' + _ret.op;//+ ': ' + JSON.stringify(Object.keys(args[0]));
-                        if (_args[0]) {
-                            sql += ' field=' + JSON.stringify(Object.keys(_args[0]));
+    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);
+                        }
+
+                        Logger.printError("WHATAP-611", "Mongodb " + methodName + " execution error", error, false);
+                        throw error; // 에러를 다시 던져서 원래 동작 유지
+                    });
+                }
+
+                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);
                         }
-                        if (_args[1]) {
-                            sql += ' value=' + JSON.stringify(Object.keys(_args[1]));
+
+                        Logger.printError("WHATAP-611", "Mongodb " + methodName + " execution error", error, false);
+
+                        // 원래 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';
 
-                        sql_step.hash = HashUtil.hashFromString(sql);
-                        sql_step.start_time = ctx.getElapsedTime();
-                        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 query error", e, false);
-                    sql_step = null;
+                // 에러 정보를 DataTextAgent에도 추가
+                if (conn_dbc_hash) {
+                    DataTextAgent.ERROR.add(conn_dbc_hash, ctx.error_message);
                 }
-            })
-        }).catch(e => {
-            Logger.printError("WHATAP-612", "Mongodb connection error", e, false);
-        })
-    })
 
+                Logger.printError("WHATAP-611", "Mongodb " + methodName + " execution error", error, false);
+                throw error; // 에러를 다시 던져서 원래 동작 유지
+            });
+        }
+
+    } catch(error) {
+        hasError = true;
+        // 동기 에러 처리
+        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);
+        }
+
+        Logger.printError("WHATAP-611", "Mongodb " + methodName + " execution error", error, false);
+        throw error;
+    }
+
+    // 결과 처리
+    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);
+
+        // Model 이름 가져오기
+        var modelName = thisArg.modelName || 'Unknown';
+
+        var sql = modelName + ' ' + operation;
+
+        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]';
+            }
+        }
+        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]';
+            }
+        }
+
+        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);
+
+    } catch(e) {
+        Logger.printError("WHATAP-611", "Mongodb query processing error", e, false);
+    }
+
+    return result;
 };
 
 exports.MongooseObserver = MongooseObserver;

package/lib/observers/mssql-observer.js

@@ -95,6 +95,8 @@ MssqlObserver.prototype.inject = function (mod, modName) {
                 self.aop.functionHook(args, -1, function (obj, args) {
                     TraceContextManager.resume(ctx);
                     if(args[0] != null) {
+                        ctx.error_message = args[0].message;
+                        ctx.error_class = args[0].name || args[0].constructor?.name || 'MSSQLError';
                         if (conf.trace_sql_error_stack && conf.trace_sql_error_depth) {
                             var traceDepth = conf.trace_sql_error_depth;
 

package/lib/observers/mysql-observer.js

@@ -12,7 +12,6 @@ var TraceContextManager = require('../trace/trace-context-manager'),
     DataTextAgent = require('../data/datatext-agent'),
     StatSql = require('../stat/stat-sql'),
     MeterSql = require('../counter/meter/meter-sql'),
-    conf = require('../conf/configure'),
     IntKeyMap = require('../util/intkey-map'),
     EscapeLiteralSQL = require('../util/escape-literal-sql'),
     HashUtil = require('../util/hashutil'),
@@ -27,7 +26,7 @@ var TraceContextManager = require('../trace/trace-context-manager'),
 
 var MysqlObserver = function (agent) {
     this.agent = agent;
-    this.packages = ['mysql', 'mysql2'];
+    this.packages = ['mysql'];
 };
 
 var queryHook = function (dbc, agent) {
@@ -128,6 +127,10 @@ var queryHook = function (dbc, agent) {
                         ctx.error_message = errorStack.join("\n");
                         sql_step.error = ctx.error = StatError.addError('mysql-' + args[0].code, args[0].sqlMessage, ctx.service_hash, TextTypes.SQL, null);
                     }
+                    ctx.error_class = args[0].name || args[0].constructor?.name || 'MySQLError';
+                    if (!ctx.error_message) {
+                        ctx.error_message = args[0].message || args[0].sqlMessage || 'MySQL error';
+                    }
                     if (conf._is_trace_ignore_err_cls_contains === true && args[0].code.indexOf(conf.trace_ignore_err_cls_contains) < 0) {
                         sql_step.error = StatError.addError('mysql-' + args[0].code, args[0].message || 'mysql error', ctx.service_hash, TextTypes.SQL, sql_step.hash); /*long*/
                         if (ctx.error.isZero()) {