whatap 1.0.1 → 1.0.2

package/lib/observers/mongodb-observer.js

@@ -5,253 +5,196 @@
  */
 
 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;
-
-var MongodbObserver = function (agent) {
+    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){
     this.agent = agent;
     this.packages = ['mongodb'];
-};
-
-var dbc_hash = 0;
-var dbc = '';
-
-var hookedConnections = new WeakSet();
+}
 
-// 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'
-};
+MongodbObserver.prototype.inject = function( mod, moduleName ) {
+    var self = this;
+    var aop = self.agent.aop;
 
-// MongoDB 에러 처리
-function handleMongoError(ctx, err) {
-    if (!err) return;
+    if('instrument' in mod == false) {
+        return;
+    }
 
-    try {
-        var errorClass = err.code || err.name || 'MongoError';
-        var errorMessage = err.message || 'mongodb error';
-        var errorStack = '';
+    if(mod.__whatap_observe__) { return; }
+    mod.__whatap_observe__ = true;
 
-        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");
+    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;
         }
 
-        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;
+        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);
         }
-
-        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);
+        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++;
         }
-    } catch (e) {
-        Logger.printError('WHATAP-242', 'Error handling MongoDB error', e, false);
-    }
-}
 
-// Collection 메서드 래퍼 생성
-function createCollectionMethodWrapper(methodName) {
-    return function(original) {
-        return function wrappedMethod() {
-            var ctx = TraceContextManager.getCurrentContext();
-            if (!ctx) {
-                return original.apply(this, arguments);
+        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);
             }
+        }
 
-            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;
-
-            const asyncResource = new AsyncResource('mongodb-command');
-
-            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 command_start_time = Date.now();
-                ctx.footprint(`MongoDB ${commandName} Start`);
-
-                // 쿼리 텍스트 구성
-                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);
-                    }
-                }
+        if(command === 'update' && event.reply) {
+            request.step.updated = event.reply.nModified;
+        }
 
-                // 콜백 처리
-                var hasCallback = false;
-                for (var i = args.length - 1; i >= 0; i--) {
-                    if (typeof args[i] === 'function') {
-                        hasCallback = true;
-                        var originalCallback = args[i];
+        if(command === 'findandmodify' && event.reply) {
+            var lastErrorObject = event.reply.lastErrorObject;
+            request.step.updated = lastErrorObject.n || 0;
+        }
 
-                        args[i] = asyncResource.bind(function() {
-                            var callbackArgs = Array.prototype.slice.call(arguments);
-                            executeCallback(callbackArgs[0], callbackArgs[1]);
+        delete requestTable[requestId];
+    });
 
-                            if (originalCallback && typeof originalCallback === 'function') {
-                                return originalCallback.apply(this, callbackArgs);
-                            }
-                        });
-                        break;
-                    }
-                }
+    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];
+    });
 
-                try {
-                    var result = original.apply(this, args);
+    ['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;
 
-                    // 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;
-                        });
-                    }
+            var ctx = TraceContextManager.getCurrentContext();
+            if(ctx == null) { return; }
 
-                    // 동기적 결과 처리
-                    if (!hasCallback) {
-                        executeCallback(null, result);
-                    }
+            var step = new SqlStepX();
+            step.start_time = ctx.getElapsedTime();
+            ctx.profile.add(step);
 
-                    return result;
-                } catch (executeError) {
-                    executeCallback(executeError, null);
-                    throw executeError;
-                }
+            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;
             });
-        };
-    };
-}
-
-// 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);
-        };
-    };
-};
-
-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
+exports.MongodbObserver = MongodbObserver;
+