whatap 0.5.26 → 1.0.0-canary.0

package/lib/observers/mssql-observer.js

@@ -5,211 +5,110 @@
  */
 
 var TraceContextManager = require('../trace/trace-context-manager'),
-    DataTextAgent       = require('../data/datatext-agent'),
-    ParsedSql           = require('../trace/parsed-sql'),
-    SqlStepX            = require('../step/sql-stepx'),
-    DBCStep             = require('../step/dbc-step'),
-    ResultSetStep       = require('../step/resultset-step'),
-    HashUtil            = require('../util/hashutil'),
-    IntKeyMap           = require('../util/intkey-map'),
-    StatSql             = require('../stat/stat-sql'),
-    StatError           = require('../stat/stat-error'),
-    MeterSql            = require('../counter/meter/meter-sql'),
-    EscapeLiteralSQL    = require('../util/escape-literal-sql'),
-    TextTypes           = require('../lang/text-types'),
-    Long                = require('long'),
-    conf                = require('../conf/configure'),
-    Logger              = require('../logger'),
-    TraceSQL = require('../trace/trace-sql')
-const DateUtil = require('../util/dateutil');
-const MessageStep = require("../step/message-step");
-// const ResourceProfile = require("../util/resourceprofile");
+    ParsedSql = require('../trace/parsed-sql'),
+    conf = require('../conf/configure'),
+    IntKeyMap = require('../util/intkey-map'),
+    EscapeLiteralSQL = require('../util/escape-literal-sql'),
+    HashUtil = require('../util/hashutil'),
+    Logger = require('../logger'),
+    DateUtil = require('../util/dateutil'),
+    AsyncSender = require('../udp/async_sender'),
+    PacketTypeEnum = require('../udp/packet_type_enum'),
+    shimmer = require('../core/shimmer'),
+    TraceSQL = require('../trace/trace-sql'),
+    AsyncResource = require('async_hooks').AsyncResource;
 
 var MssqlObserver = function (agent) {
     this.agent = agent;
-    this.aop = agent.aop;
     this.packages = ['mssql'];
 };
-var dbc_hash=0;
-MssqlObserver.prototype.inject = function (mod, modName) {
 
-    if(mod.__whatap_observe__) {return;}
-    mod.__whatap_observe__ = true;
-
-    Logger.initPrint("MssqlObserver");
-
-    var self = this;
-
-    var requestCommand = ['_bulk', '_query', '_execute'];
-
-    requestCommand.forEach(function (command) {
-        self.aop.both(mod.Request.prototype, command,
-            function (obj, args) {
-
-                var ctx = TraceContextManager.getCurrentContext();
-                if(ctx == null) { return; }
-
-                var sql_step = new SqlStepX();
-                var sql = (typeof args[0] === 'string') ? args[0] : JSON.stringify(args[0]),
-                    psql = null;
-
-
-                if(dbc_hash===0){
-                    if(obj.parent && obj.parent.config) {
-                        var config = obj.parent.config,
-                            dbc = 'mssql://';
-                        try {
-                            dbc += (config.server || '');
-                            dbc += ':';
-                            dbc += (config.port || '');
-                            dbc += '/';
-                            dbc += (config.database || '');
-                            dbc_hash = HashUtil.hashFromString(dbc);
-                            DataTextAgent.DBC.add(dbc_hash, dbc);
-                            DataTextAgent.METHOD.add(dbc_hash, dbc);
-                            DataTextAgent.ERROR.add(dbc_hash, dbc)
-                        } catch(e) {
-                        }
-                    }
-                }
-                var dbc_step = new DBCStep();
-                dbc_step.hash = dbc_hash;
-                dbc_step.start_time = ctx.getElapsedTime();
-                ctx.profile.push(dbc_step);
+var dbc_hash = 0;
+var dbc = 'mssql://';
 
-                sql_step.dbc = dbc_hash;
+var hookedInstances = new WeakSet();
 
-                try {
-                    psql = escapeLiteral(sql);
-                } catch(e) {
-                    Logger.printError("WHATAP-192", "MssqlObserver escapeliteral error", e);
-                }
-
-                if(psql != null) {
-                    DataTextAgent.SQL.add(sql_step.hash, sql);
-                    // = psql.type.charCodeAt(0);
-                    sql_step.hash = psql.sql;
-                }
-                sql_step.start_time = ctx.getElapsedTime();
-                ctx.profile.push(sql_step);
-                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;
-
-                            var errorStack = args[0].stack.split("\n");
-                            if (errorStack.length > traceDepth) {
-                                errorStack = errorStack.slice(0, traceDepth + 1);
-                            }
-                            ctx.error_message = errorStack.join("\n");
-                            sql_step.error = ctx.error = StatError.addError('mssql-' + args[0].code, args[0].message, ctx.service_hash, TextTypes.SQL, null);
-                        }
-                        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( 'mssql-'+args[0].code, args[0].message|| 'mssql error', ctx.service_hash,  TextTypes.SQL, sql_step.hash); /*long*/
-                            if (ctx.error.isZero()) { ctx.error = sql_step.error; }
-                        } else if(conf._is_trace_ignore_err_msg_contains === true && args[0].message.indexOf(conf.trace_ignore_err_msg_contains) < 0){
-                            sql_step.error = StatError.addError( 'mssql-'+args[0].code, args[0].message|| 'mssql error', ctx.service_hash,  TextTypes.SQL, sql_step.hash); /*long*/
-                            if (ctx.error.isZero()) { ctx.error = sql_step.error; }
-                        } else if(conf._is_trace_ignore_err_cls_contains === false && conf._is_trace_ignore_err_msg_contains === false) {
-                            sql_step.error = StatError.addError( 'mssql-'+args[0].code, args[0].message|| 'mssql error', ctx.service_hash,  TextTypes.SQL, sql_step.hash); /*long*/
-                            if (ctx.error.isZero()) { ctx.error = sql_step.error; }
-                        }
-                    }
-
-                    sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
-                    TraceSQL.isSlowSQL(ctx);
-
-                    MeterSql.add(dbc_hash, sql_step.elapsed, args[0] != null);
-                    StatSql.addSqlTime(ctx.service_hash, sql_step.dbc,
-                        sql_step.hash, sql_step.elapsed, args[0] != null, 0);
-
-                    if(psql && psql.type == 'S') {
-                        var result_step = new ResultSetStep();
-                        result_step.dbc = sql_step.dbc;
-                        result_step.sqlhash =  sql_step.hash;
-                        try {
-                            result_step.fetch = args[1][0].length;
-                            ctx.rs_count = ctx.rs_count ? ctx.rs_count + args[1][0].length : args[1][0].length;
-                        } catch(e) {
-                        }
-                        ctx.profile.push(result_step);
+var checkedSql = new IntKeyMap(2000).setMax(2000);
+var nonLiteSql = new IntKeyMap(5000).setMax(5000);
+var date = DateUtil.yyyymmdd();
 
-                        MeterSql.addFetch(dbc_hash, result_step.fetch, 0);
-                        StatSql.addFetch(dbc_hash, result_step.sqlhash, result_step.fetch, 0);
+function handleSqlError(ctx, err) {
+    if (!err) return;
 
-                        TraceSQL.isTooManyRecords(sql_step, result_step.fetch, ctx);
-                    } else if(psql && psql.type == 'U') {
+    try {
+        var errorClass = err.code || err.name || err.constructor?.name || 'MSSQLError';
+        var errorMessage = err.message || 'mssql error';
+        var errorStack = '';
 
-                    }
-                });
-            }, function (obj, args, ret, lctx) {
-            });
-    });
-    var conn_dbc_hash=0;
-    self.aop.both(mod, 'connect',
-        function (obj, args, lctx) {
-
-            var ctx = TraceContextManager.getCurrentContext();
-            if(ctx == null) { return; }
-            lctx.context = ctx;
-
-            var conn = '';
-            if(args[0]) { //좀더 로직 개선 필요...
-                conn += args[0]['server'] || '';
-                conn += args[0]['database'] || '';
+        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);
             }
-            if(conn.length === 0) { return; }
-            if(conn_dbc_hash==0){ //한번만 전송되게 함.
-                conn = 'mssql://' + conn;
-                conn_dbc_hash = HashUtil.hashFromString(conn);
-                DataTextAgent.DBC.add(conn_dbc_hash, conn);
-                DataTextAgent.METHOD.add(conn_dbc_hash, dbc);
-                DataTextAgent.ERROR.add(conn_dbc_hash, dbc)
+            errorStack = stackLines.join("\n");
+        }
+
+        var shouldAddError = false;
+        if (conf._is_trace_ignore_err_cls_contains === true && errorClass &&
+            errorClass.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 (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);
             }
 
-            var dbc_step = new DBCStep();
-            dbc_step.hash = conn_dbc_hash;
-            dbc_step.start_time = ctx.getElapsedTime();
-
-            lctx.step = dbc_step;
-        },
-        function (obj, args, ret, lctx) {
-            var pool = ret;
-            var ctx  = lctx.context,
-                step = lctx.step;
-
-            if(ctx == null || step == null) { return; }
-            step.elapsed = ctx.getElapsedTime() - step.start_time;
-            ctx.profile.push(step);
-        });
-};
+            AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+        }
+    } catch (e) {
+        Logger.printError('WHATAP-209', 'Error handling MSSQL error', e, false);
+    }
+}
 
-var checkedSql = new IntKeyMap(2000).setMax(2000);
-var nonLiteSql = new IntKeyMap(5000).setMax(5000);
-var date = DateUtil.yyyymmdd();
+function setupDbcInfo(config) {
+    if (dbc_hash === 0 && config) {
+        dbc = 'mssql://';
+        dbc += (config.server || '') + ':';
+        dbc += (config.port || '') + '/';
+        dbc += config.database || '';
+        dbc_hash = HashUtil.hashFromString(dbc);
+    }
+}
 
 function escapeLiteral(sql) {
-    if(sql == null) { sql = ''; }
+    if (sql == null) {
+        sql = '';
+    }
 
-    if(date !== DateUtil.yyyymmdd()) {
+    if (date !== DateUtil.yyyymmdd()) {
         checkedSql.clear();
         nonLiteSql.clear();
         date = DateUtil.yyyymmdd();
-        Logger.print('WHATAP-SQL-CLEAR', 'MssqlObserver CLEAR OK!!!!!!!!!!!!!!!!', false);
     }
 
     var sqlHash = HashUtil.hashFromString(sql);
     var psql = nonLiteSql.get(sqlHash);
 
-    if(psql != null) {
+    if (psql != null) {
         return psql;
     }
     psql = checkedSql.get(sqlHash);
 
-    if(psql != null) {
+    if (psql != null) {
         return psql;
     }
 
@@ -217,9 +116,8 @@ function escapeLiteral(sql) {
     els.process();
 
     var hash = HashUtil.hashFromString(els.getParsedSql());
-    DataTextAgent.SQL.add(hash, els.getParsedSql());
 
-    if(hash === sqlHash) {
+    if (hash === sqlHash) {
         psql = new ParsedSql(els.sqlType, hash, null);
         nonLiteSql.put(sqlHash, psql);
     } else {
@@ -229,4 +127,347 @@ function escapeLiteral(sql) {
     return psql;
 }
 
+function createRequestWrapper(agent, dbcUrl, command) {
+    return function(original) {
+        return function wrappedRequest() {
+            var args = Array.prototype.slice.call(arguments);
+            var ctx = TraceContextManager.getCurrentContext();
+
+            if (ctx == null || args[0] == null) {
+                return original.apply(this, arguments);
+            }
+
+            if (dbcUrl === 'mssql://' || !dbc_hash) {
+                return original.apply(this, arguments);
+            }
+
+            const asyncResource = new AsyncResource('mssql-request');
+            const callbackResource = new AsyncResource('mssql-callback');
+
+            return asyncResource.runInAsyncScope(() => {
+                ctx.start_time = Date.now();
+                ctx.elapsed = 0;
+                AsyncSender.send_packet(PacketTypeEnum.TX_DB_CONN, ctx, [dbcUrl]);
+
+                var sql_start_time = Date.now();
+                ctx.footprint('MsSQL ' + command + ' Start');
+                ctx.sql_count++;
+
+                var sql = args.length > 0 ? args[0] : undefined;
+                var finalSql = '';
+
+                try {
+                    if (typeof sql === 'string') {
+                        finalSql = sql;
+                    } else if (sql !== null && typeof sql === 'object') {
+                        finalSql = JSON.stringify(sql);
+                    }
+                } catch (formatError) {
+                    Logger.printError('WHATAP-210', 'Error formatting MSSQL query', formatError, false);
+                    finalSql = '';
+                }
+
+                if (typeof finalSql !== 'string' || finalSql.length === 0) {
+                    finalSql = '';
+                }
+
+                var psql = null;
+                if (typeof finalSql === 'string' && finalSql.length > 0) {
+                    try {
+                        psql = escapeLiteral(finalSql);
+                        Logger.print('WHATAP-203', 'Processing SQL: ' + finalSql.substring(0, 200), false);
+                    } catch (e) {
+                        Logger.printError('WHATAP-211', 'MssqlObserver escapeliteral error', e, false);
+                    }
+                } else {
+                    psql = escapeLiteral(finalSql);
+                }
+
+                ctx.active_sqlhash = true;
+                ctx.active_dbc = dbc_hash;
+
+                function requestCallback(err, results) {
+                    var currentCtx = TraceContextManager.getCurrentContext();
+                    if (currentCtx == null) {
+                        return;
+                    }
+
+                    TraceContextManager.resume(currentCtx.id);
+
+                    var sql_elapsed = Date.now() - sql_start_time;
+                    var resultCount = 0;
+
+                    if (err) {
+                        handleSqlError(currentCtx, err);
+                    }
+
+                    if (!err && results) {
+                        if (Array.isArray(results) && results.length > 0) {
+                            if (results[0] && Array.isArray(results[0])) {
+                                resultCount = results[0].length;
+                            } else if (results[0] && results[0].recordset && Array.isArray(results[0].recordset)) {
+                                resultCount = results[0].recordset.length;
+                            }
+                        } else if (results.recordset && Array.isArray(results.recordset)) {
+                            resultCount = results.recordset.length;
+                        } else if (results.rowsAffected && Array.isArray(results.rowsAffected)) {
+                            resultCount = results.rowsAffected.reduce((sum, count) => sum + count, 0);
+                        }
+                    }
+
+                    try {
+                        TraceSQL.isSlowSQL(currentCtx);
+                        if (!err && psql != null && psql.type === 'S') {
+                            TraceSQL.isTooManyRecords(resultCount, currentCtx);
+                        }
+                    } catch (e) {
+                        Logger.printError('WHATAP-212', 'Error in TraceSQL processing', e, false);
+                    }
+
+                    currentCtx.elapsed = sql_elapsed;
+                    currentCtx.active_sqlhash = false;
+                    AsyncSender.send_packet(PacketTypeEnum.TX_SQL, currentCtx, [dbcUrl, finalSql, String(resultCount)]);
+
+                    currentCtx.footprint('MsSQL ' + command + ' Done');
+                }
+
+                var callbackWrapped = 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] = callbackResource.bind(function() {
+                            var callbackArgs = Array.prototype.slice.call(arguments);
+                            try {
+                                requestCallback(callbackArgs[0], callbackArgs[1]);
+                            } catch (e) {
+                                Logger.printError('WHATAP-213', 'Error in callback hook', e, false);
+                            }
+                            if (originalCallback && typeof originalCallback === 'function') {
+                                return originalCallback.apply(this, callbackArgs);
+                            }
+                        });
+                        callbackWrapped = true;
+                        break;
+                    }
+                }
+
+                try {
+                    const result = original.apply(this, args);
+
+                    // Promise 기반 처리
+                    if (!hasCallback && result && typeof result.then === 'function') {
+                        return result.then(function(res) {
+                            requestCallback(null, res);
+                            return res;
+                        }).catch(function(err) {
+                            requestCallback(err, null);
+                            throw err;
+                        });
+                    }
+
+                    return result;
+                } catch (requestError) {
+                    requestCallback(requestError, null);
+                    throw requestError;
+                }
+            });
+        };
+    };
+}
+
+MssqlObserver.prototype.inject = function (mod, moduleName) {
+    if (mod.__whatap_observe__) {
+        return;
+    }
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("MssqlObserver");
+
+    if (conf.sql_enabled === false) {
+        return;
+    }
+
+    var self = this;
+
+    // Request 클래스의 메서드들 후킹
+    if (mod.Request && mod.Request.prototype) {
+        var requestCommands = ['_bulk', '_query', '_execute'];
+
+        requestCommands.forEach(function(command) {
+            if (mod.Request.prototype[command] && !mod.Request.prototype[command].__whatap_wrapped__) {
+                shimmer.wrap(mod.Request.prototype, command, function(original) {
+                    return function wrappedRequestCommand() {
+                        var args = Array.prototype.slice.call(arguments);
+                        var ctx = TraceContextManager.getCurrentContext();
+
+                        if (ctx == null) {
+                            return original.apply(this, arguments);
+                        }
+
+                        // DBC 정보 설정
+                        if (dbc_hash === 0 && this.parent && this.parent.config) {
+                            setupDbcInfo(this.parent.config);
+                        }
+
+                        return createRequestWrapper(self.agent, dbc, command)(original).apply(this, args);
+                    };
+                });
+                mod.Request.prototype[command].__whatap_wrapped__ = true;
+            }
+        });
+    }
+
+    // connect 함수 후킹
+    if (mod.connect && !mod.connect.__whatap_wrapped__) {
+        shimmer.wrap(mod, 'connect', function(original) {
+            return function wrappedConnect() {
+                var args = Array.prototype.slice.call(arguments);
+                var ctx = TraceContextManager.getCurrentContext();
+
+                if (ctx == null) {
+                    return original.apply(this, arguments);
+                }
+
+                // 연결 정보 설정
+                if (args[0]) {
+                    setupDbcInfo(args[0]);
+                }
+
+                const connectionResource = new AsyncResource('mssql-connect');
+
+                return connectionResource.runInAsyncScope(() => {
+                    ctx.start_time = Date.now();
+                    ctx.db_opening = true;
+                    ctx.footprint('MsSQL Connecting Start');
+
+                    // 콜백 래핑
+                    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) {
+                                    TraceContextManager.resume(ctx.id);
+                                    ctx.elapsed = Date.now() - ctx.start_time;
+
+                                    if (err) {
+                                        handleSqlError(ctx, err);
+                                        ctx.footprint('MsSQL Connecting Error');
+                                    } else {
+                                        ctx.footprint('MsSQL Connecting Done');
+                                    }
+                                }
+
+                                return originalCallback.apply(this, callbackArgs);
+                            });
+                            break;
+                        }
+                    }
+
+                    var result = original.apply(this, args);
+
+                    // Promise 기반 처리
+                    if (result && typeof result.then === 'function') {
+                        return result.then(connectionResource.bind(function(pool) {
+                            if (ctx) {
+                                TraceContextManager.resume(ctx.id);
+                                ctx.elapsed = Date.now() - ctx.start_time;
+                                ctx.db_opening = false;
+                                ctx.footprint('MsSQL Connecting Done');
+                            }
+                            return pool;
+                        })).catch(connectionResource.bind(function(err) {
+                            if (ctx) {
+                                TraceContextManager.resume(ctx.id);
+                                ctx.elapsed = Date.now() - ctx.start_time;
+                                ctx.db_opening = false;
+                                ctx.footprint('MsSQL Connecting Error');
+                                handleSqlError(ctx, err);
+                            }
+                            throw err;
+                        }));
+                    }
+
+                    return result;
+                });
+            };
+        });
+        mod.connect.__whatap_wrapped__ = true;
+    }
+
+    // ConnectionPool 클래스 후킹 (있는 경우)
+    if (mod.ConnectionPool && !mod.ConnectionPool.__whatap_wrapped__) {
+        shimmer.wrap(mod, 'ConnectionPool', function(original) {
+            return function wrappedConnectionPool() {
+                var args = Array.prototype.slice.call(arguments);
+
+                // 연결 정보 설정
+                if (args[0]) {
+                    setupDbcInfo(args[0]);
+                }
+
+                var pool = new (Function.prototype.bind.apply(original, [null].concat(args)));
+
+                if (pool && !hookedInstances.has(pool)) {
+                    hookedInstances.add(pool);
+
+                    // connect 메서드 후킹
+                    if (pool.connect && !pool.connect.__whatap_wrapped__) {
+                        shimmer.wrap(pool, 'connect', function(original) {
+                            return function wrappedPoolConnect() {
+                                var args = Array.prototype.slice.call(arguments);
+                                var ctx = TraceContextManager.getCurrentContext();
+
+                                if (ctx == null) {
+                                    return original.apply(this, arguments);
+                                }
+
+                                const connectionResource = new AsyncResource('mssql-pool-connect');
+
+                                return connectionResource.runInAsyncScope(() => {
+                                    ctx.start_time = Date.now();
+                                    ctx.footprint('MsSQL Pool Connecting Start');
+
+                                    var result = original.apply(this, args);
+
+                                    // Promise 기반 처리
+                                    if (result && typeof result.then === 'function') {
+                                        return result.then(connectionResource.bind(function(res) {
+                                            if (ctx) {
+                                                TraceContextManager.resume(ctx.id);
+                                                ctx.elapsed = Date.now() - ctx.start_time;
+                                                ctx.footprint('MsSQL Pool Connecting Done');
+                                            }
+                                            return res;
+                                        })).catch(connectionResource.bind(function(err) {
+                                            if (ctx) {
+                                                TraceContextManager.resume(ctx.id);
+                                                ctx.elapsed = Date.now() - ctx.start_time;
+                                                ctx.footprint('MsSQL Pool Connecting Error');
+                                                handleSqlError(ctx, err);
+                                            }
+                                            throw err;
+                                        }));
+                                    }
+
+                                    return result;
+                                });
+                            };
+                        });
+                        pool.connect.__whatap_wrapped__ = true;
+                    }
+                }
+
+                return pool;
+            };
+        });
+        mod.ConnectionPool.__whatap_wrapped__ = true;
+    }
+};
+
 exports.MssqlObserver = MssqlObserver;