whatap 0.5.26 → 1.0.0-canary.0

package/lib/observers/mongodb-observer.js

@@ -5,196 +5,253 @@
  */
 
 var TraceContextManager = require('../trace/trace-context-manager'),
-    SqlStepX            = require('../step/sql-stepx'),
-    ResultSetStep       = require('../step/resultset-step'),
-    DataTextAgent       = require('../data/datatext-agent'),
-    StatError           = require('../stat/stat-error'),
-    TextTypes           = require('../lang/text-types'),
-    hashUtil            = require('../util/hashutil'),
-    Logger              = require('../logger');
-
-var MongodbObserver = function(agent){
+    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 MongodbObserver = function (agent) {
     this.agent = agent;
     this.packages = ['mongodb'];
-}
+};
 
-MongodbObserver.prototype.inject = function( mod, moduleName ) {
-    var self = this;
-    var aop = self.agent.aop;
+var dbc_hash = 0;
+var dbc = '';
 
-    if('instrument' in mod == false) {
-        return;
-    }
+var hookedConnections = new WeakSet();
 
-    if(mod.__whatap_observe__) { return; }
-    mod.__whatap_observe__ = true;
+// MongoDB 명령어 매핑
+var MONGODB_COMMANDS = {
+    'insert': 'INSERT',
+    'insertOne': 'INSERTONE',
+    'insertMany': 'INSERTMANY',
+    'find': 'FIND',
+    // 'findOne': 'FINDONE',
+    'count': 'COUNT',
+    'countDocuments': 'COUNTDOCUMENTS',
+    'update': 'UPDATE',
+    'updateOne': 'UPDATEONE',
+    'updateMany': 'UPDATEMANY',
+    'delete': 'DELETE',
+    'deleteOne': 'DELETEONE',
+    'deleteMany': 'DELETEMANY',
+    'remove': 'REMOVE',
+    'removeOne': 'REMOVEONE',
+    'removeMany': 'REMOVEMANY',
+    'replaceOne': 'REPLACEONE',
+    'findAndReplace': 'FINDANDREPLACE',
+    'findAndUpdate': 'FINDANDUPDATE',
+    'findAndDelete': 'FINDANDDELETE',
+    'findOneAndUpdate': 'FINDONEANDUPDATE',
+    'findOneAndReplace': 'FINDONEANDREPLACE',
+    'findOneAndDelete': 'FINDONEANDDELETE',
+    'findAndModify': 'FINDANDMODIFY'
+};
 
-    Logger.initPrint("MongodbObserver");
-    
-    var requestTable = {},
-        nextRequest,
-        listener = mod.instrument({}, function(err, instrumentations) {});
-
-    listener.on('started', function (event) {
-        var requestId = event.requestId, request;
-        var ctx = TraceContextManager.getCurrentContext();
-        if(ctx == null) { return; }
-
-        if(nextRequest) {
-            requestTable[requestId] = { step : nextRequest.step, ctx : nextRequest.ctx };
-            nextRequest.requestId = requestId;
-            nextRequest = null;
-        } else if(event.commandName === 'findandmodify') {
-            var sql_step = new SqlStepX();
-            sql_step.start_time = ctx.getElapsedTime();
-            ctx.profile.add(sql_step);
-            requestTable[requestId] = {step : sql_step, ctx : ctx};
-        } else if( requestTable[requestId] == null ) {
-            return;
-        }
+// MongoDB 에러 처리
+function handleMongoError(ctx, err) {
+    if (!err) return;
 
-        var dbc = '',
-            dbc_hash = 0;
-        if(event.connectionId) {
-            var conn = event.connectionId;
-            dbc = 'mongodb://' + (conn.host || '') + ':' + (conn.port || '') + '/' + (event.databaseName || '');
-            dbc_hash = hashUtil.hashFromString(dbc);
-            DataTextAgent.DBC.add(dbc_hash, dbc);
-        }
-        request = requestTable[requestId];
-        request.step.dbc = dbc_hash;
-
-        var dbName = event.databaseName,
-            collection = event.command[event.commandName],
-            command = Object.keys(event.command).reduce(function (result, key) {
-                if(key != event.commandName && key != 'filter' && key != 'documents') {
-                    result[key] = event.command[key];
-                }
-                return result;
-            }, {});
-        command = JSON.stringify(command).slice(0, 1000);
-
-        var ctx = request.ctx;
-        ctx.sql_count++;
-
-        var command_string = '', queryKey = '', sql ='', sql_hash = '', crud ='';
-        if(event.commandName === 'find') {
-            queryKey = Object.keys(event.command.filter).toString().slice(0, 1000);
-            command_string = ',key='+queryKey + ',command=' + command;
-            crud = 'S';
-            ctx.sql_select++;
-        } else if(event.commandName === 'insert') {
-            queryKey = Object.keys(event.command.documents[0]).toString().slice(0, 1000);
-            command_string = ',documents='+queryKey + ',command=' + command;
-            crud = 'I';
-            ctx.sql_insert++;
-        } else if(event.commandName === 'delete') {
-            command_string = ',command=' + command;
-            crud = 'D';
-            ctx.sql_delete++;
-        } else if(event.commandName === 'findandmodify') {
-            command_string = ',command=' + command;
-            crud = 'U';
-            ctx.sql_update++;
-        } else if(event.commandName === 'update') {
-            command_string = ',command=' + command;
-            crud = 'U';
-            ctx.sql_update++;
-        } else {
-            ctx.sql_others++;
-        }
+    try {
+        var errorClass = err.code || err.name || 'MongoError';
+        var errorMessage = err.message || 'mongodb error';
+        var errorStack = '';
 
-        sql = event.commandName + ' : databaseName=' + dbName +',collection=' + collection + command_string;
-        sql_hash = hashUtil.hashFromString(sql);
-        DataTextAgent.SQL.add(sql_hash, sql);
-        request.step.hash = sql_hash;
-        request.step.crud = crud.charCodeAt(0);
-    });
-
-    listener.on('succeeded', function (event) {
-        var requestId = event.requestId,
-            request = requestTable[event.requestId];
-        
-        if(request == null) {
-            delete requestTable[requestId];
-            return;
-        }
-        
-        TraceContextManager.resume(request.ctx._id);
-        request.step.elapsed = event.duration;
-        request.ctx.sql_time += request.step.elapsed;
-
-        var command = event.commandName || '';
-        if(command === 'find' && event.reply) {
-            var cursor = event.reply.cursor;
-            if(cursor != null) {
-                var fetch = cursor.firstBatch.length;
-                var rs_step = new ResultSetStep();
-                rs_step.elapsed = 0;
-                rs_step.dbc = request.step.dbc;
-                rs_step.sqlhash = request.step.hash;
-                rs_step.fetch = fetch;
-                request.ctx.profile.add(rs_step);
+        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");
         }
 
-        if(command === 'update' && event.reply) {
-            request.step.updated = event.reply.nModified;
+        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;
         }
 
-        if(command === 'findandmodify' && event.reply) {
-            var lastErrorObject = event.reply.lastErrorObject;
-            request.step.updated = lastErrorObject.n || 0;
+        if (shouldAddError) {
+            if (!ctx.error) ctx.error = 1;
+            ctx.status = 500;
+            var errors = [errorClass];
+            if (errorMessage) {
+                errors.push(errorMessage);
+            }
+            if (errorStack || err.stack) {
+                errors.push(errorStack || err.stack);
+            }
+
+            AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
         }
+    } catch (e) {
+        Logger.printError('WHATAP-242', 'Error handling MongoDB error', e, false);
+    }
+}
 
-        delete requestTable[requestId];
-    });
+// Collection 메서드 래퍼 생성
+function createCollectionMethodWrapper(methodName) {
+    return function(original) {
+        return function wrappedMethod() {
+            var ctx = TraceContextManager.getCurrentContext();
+            if (!ctx) {
+                return original.apply(this, arguments);
+            }
 
-    listener.on('failed', function (event) {
-        var requestId = event.requestId,
-            request = requestTable[event.requestId];
-        if(request == null) {
-            delete requestTable[requestId];
-            return;
-        }
-        TraceContextManager.resume(request.ctx._id);
-        request.step.elapsed = event.duration;
-        request.ctx.sql_time += request.step.elapsed;
-
-        request.ctx.error_class = event.failure.name || (event.failure.constructor && event.failure.constructor.name) || 'MongoDBError';
-        request.ctx.error_message = event.failure.message || 'MongoDB error';
-
-        var msgObj = { 'class': event.failure.message, 'msg': event.failure.message };
-        request.step.error = StatError.addError("mongodb", event.failure.message,
-            request.ctx.service_hash,  TextTypes.SQL, request.step.hash);
-        if (request.ctx.error.isZero()) {
-            request.ctx.error = request.step.error;
-        }
-        
-        delete requestTable[requestId];
-    });
+            var args = Array.prototype.slice.call(arguments);
+            var collectionName = this.collectionName || this.s?.name || 'unknown';
+            var commandName = MONGODB_COMMANDS[methodName] || methodName.toUpperCase();
+            var _dbc = this.dbName && dbc.indexOf(this.dbName) === -1 ? dbc + '/' + this.dbName : dbc;
 
-    ['cursor', 'insert', 'update', 'remove'].forEach( function(command) {
-        aop.before(mod.Server.prototype, command, function (obj, args) {
-            // Select but... DB name undefined return
-            if(command === 'cursor' && !args[1].find) return;
+            const asyncResource = new AsyncResource('mongodb-command');
 
-            var ctx = TraceContextManager.getCurrentContext();
-            if(ctx == null) { return; }
+            return asyncResource.runInAsyncScope(() => {
+                // DB 연결 패킷 전송
+                ctx.start_time = Date.now();
+                ctx.elapsed = 0;
+                ctx.active_sqlhash = true;
+                AsyncSender.send_packet(PacketTypeEnum.TX_DB_CONN, ctx, [_dbc]);
 
-            var step = new SqlStepX();
-            step.start_time = ctx.getElapsedTime();
-            ctx.profile.add(step);
+                var command_start_time = Date.now();
+                ctx.footprint(`MongoDB ${commandName} Start`);
 
-            var req = nextRequest = {step : step, ctx : ctx};
-            aop.functionHook(args, -1, function (obj, args) {
-                TraceContextManager.resume(ctx._id);
-                var requestId = req.requestId;
-                requestTable[requestId] = undefined;
+                // 쿼리 텍스트 구성
+                var queryParts = [commandName, collectionName];
+                var fieldNames = [];
+
+                try {
+                    // 첫 번째 인자에서 필드명 추출 (filter)
+                    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(',') + ']');
+                    }
+                } catch (e) {
+                    Logger.printError('WHATAP-243', 'Error extracting field names', e, false);
+                }
+
+                var commandText = 'MongoDB ' + queryParts.join(' ');
+
+                function executeCallback(err, result) {
+                    try {
+                        var command_elapsed = Date.now() - command_start_time;
+
+                        if (err) {
+                            handleMongoError(ctx, err);
+                        }
+
+                        ctx.elapsed = command_elapsed;
+                        ctx.active_sqlhash = false;
+                        AsyncSender.send_packet(PacketTypeEnum.TX_SQL, ctx, [dbc, commandText, '0']);
+                        ctx.footprint(`MongoDB ${commandName} Done`);
+                    } catch (e) {
+                        Logger.printError('WHATAP-244', 'Error in MongoDB callback', e, false);
+                    }
+                }
+
+                // 콜백 처리
+                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;
+                    }
+                }
+
+                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;
+                        });
+                    }
+
+                    // 동기적 결과 처리
+                    if (!hasCallback) {
+                        executeCallback(null, result);
+                    }
+
+                    return result;
+                } catch (executeError) {
+                    executeCallback(executeError, null);
+                    throw executeError;
+                }
             });
-        });
-    });
+        };
+    };
+}
+
+// Connection wrapper 함수
+var createConnectionWrapper = function() {
+    return function(original) {
+        return function wrappedConnect() {
+            dbc = this.s && this.s.url ? this.s.url : 'mongodb://localhost:27017';
+            dbc_hash = HashUtil.hashFromString(dbc);
+            return original.apply(this, arguments);
+        };
+    };
 };
 
-exports.MongodbObserver = MongodbObserver;
+MongodbObserver.prototype.inject = function(mod, moduleName) {
+    if (mod.__whatap_observe__) {
+        return;
+    }
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("MongodbObserver");
+
+    if (conf.sql_enabled === false) {
+        return;
+    }
+
+    var self = this;
+
+    if (mod.MongoClient && !mod.MongoClient.__whatap_wrapped__) {
+        // 정적 connect 메서드 래핑
+        if (mod.MongoClient.prototype.connect && !mod.MongoClient.prototype.connect.__whatap_wrapped__) {
+            shimmer.wrap(mod.MongoClient.prototype, 'connect', createConnectionWrapper());
+            mod.MongoClient.connect.__whatap_wrapped__ = true;
+        }
+
+        mod.MongoClient.__whatap_wrapped__ = true;
+    }
+
+    // Collection 메서드들 래핑
+    if (mod.Collection && mod.Collection.prototype && !mod.Collection.__whatap_wrapped__) {
+        Object.keys(MONGODB_COMMANDS).forEach(function(methodName) {
+            if (mod.Collection.prototype[methodName] && !mod.Collection.prototype[methodName].__whatap_wrapped__) {
+                shimmer.wrap(mod.Collection.prototype, methodName, createCollectionMethodWrapper(methodName));
+                mod.Collection.prototype[methodName].__whatap_wrapped__ = true;
+            }
+        });
+        mod.Collection.__whatap_wrapped__ = true;
+    }
+};
 
+exports.MongoObserver = MongodbObserver