whatap 1.0.4 → 1.0.5-canary.1

package/lib/core/agent.js

@@ -29,7 +29,7 @@ var Interceptor      = require('./interceptor').Interceptor,
     IORedisObserver    = require('../observers/ioredis-observer').IORedisObserver,
     MssqlObserver    = require('../observers/mssql-observer').MssqlObserver,
     PgSqlObserver    = require('../observers/pgsql-observer').PgSqlObserver,
-    // GRpcObserver     = require('../observers/grpc-observer').GRpcObserver,
+    GRpcObserver     = require('../observers/grpc-observer').GRpcObserver,
     ApolloObserver   = require('../observers/apollo-server-observer').ApolloServerObserver,
     PrismaObserver  = require('../observers/prisma-observer').PrismaObserver,
     OracleObserver  = require('../observers/oracle-observer').OracleObserver,
@@ -1105,7 +1105,7 @@ NodeAgent.prototype.loadObserves = function() {
     observes.push(IORedisObserver);
     observes.push(MssqlObserver);
     observes.push(PgSqlObserver);
-    // observes.push(GRpcObserver);
+    observes.push(GRpcObserver);
     observes.push(ApolloObserver);
     observes.push(PrismaObserver);
     observes.push(OracleObserver);

package/lib/counter/counter-manager.js

@@ -4,10 +4,7 @@
  * can be found in the LICENSE file.
  */
 
-var TraceContextManager = require('../trace/trace-context-manager'),
-    secuMaster = require('../net/security-master'),
-    conf = require('../conf/configure'),
-    DateUtil = require('./../util/dateutil'),
+var conf = require('../conf/configure'),
     Logger              = require('../logger'),
     GCAction = require('../system/gc-action');
 

package/lib/counter/task/activetransaction.js

@@ -6,15 +6,18 @@
 
 var conf = require('../../conf/configure'),
     TraceContextManager = require('../../trace/trace-context-manager'),
-    KeyGen = require('../../util/keygen'),
-    HashUtil = require('../../util/hashutil'),
-    Logger          = require('../../logger'),
-    Long = require('long');
+    Logger          = require('../../logger');
 
 function ActiveTransaction() {}
 ActiveTransaction.prototype.getActiveStats = function () {
     var stats = new Array(5).fill(0);
     var en = TraceContextManager.getContextEnumeration();
+
+    if(conf.getProperty('debug_activestats_size_enabled', false)){
+        Logger.print("WHATAP-DEBUG-ACTIVESTATS-1", "Size: " + TraceContextManager.size(), false);
+        Logger.print("WHATAP-DEBUG-ACTIVESTATS-2", "Pid: " + process.pid, false);
+    }
+
     try {
         while (en.hasMoreElements()) {
             var ctx = en.nextElement();

package/lib/observers/grpc-observer.js

@@ -0,0 +1,335 @@
+/**
+ * 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'),
+    conf = require('../conf/configure'),
+    Logger = require('../logger');
+const HashUtil = require("../util/hashutil");
+const shimmer = require('../core/shimmer');
+const AsyncSender = require('../udp/async_sender');
+const PacketTypeEnum = require('../udp/packet_type_enum');
+const os = require('os');
+
+var grpc_profile_enabled = conf.getProperty('grpc_profile_enabled', true);
+var grpc_profile_stream_client_enabled = conf.getProperty('grpc_profile_stream_client_enabled', true);
+var grpc_profile_stream_server_enabled = conf.getProperty('grpc_profile_stream_server_enabled', true);
+var grpc_profile_ignore_method = conf.getProperty('grpc_profile_ignore_method', '');
+var ignore_method_set = null;
+conf.on('grpc_profile_enabled', function(newProperty) {
+    grpc_profile_enabled = newProperty;
+});
+conf.on('grpc_profile_stream_client_enabled', function(newProperty) {
+    grpc_profile_stream_client_enabled = newProperty;
+});
+conf.on('grpc_profile_stream_server_enabled', function(newProperty) {
+    grpc_profile_stream_server_enabled = newProperty;
+});
+conf.on('grpc_profile_ignore_method', function(newProperty) {
+    grpc_profile_ignore_method = newProperty;
+});
+
+var GRpcObserver = function(agent) {
+    this.agent = agent;
+    this.packages = ['@grpc/grpc-js'];
+};
+
+const types = {
+    unary: 'unary',
+    client_stream: 'clientStream',
+    server_stream: 'serverStream',
+    bidi: 'bidi'
+};
+
+GRpcObserver.prototype.inject = function(mod, moduleName) {
+    if (mod.__whatap_observe__) {
+        return;
+    }
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("GRpcObserver");
+
+    if (grpc_profile_enabled) {
+        shimmer.wrap(mod.Server.prototype, 'register', wrapRegister);
+        shimmer.wrap(mod.Client.prototype, 'register', wrapRegister);
+    }
+};
+
+function checkIgnoreMethod(ignore_method, method_name){
+    try{
+        if (ignore_method) {
+            ignore_method_set = new Set(ignore_method.split(','));
+        } else {
+            ignore_method_set = null;
+        }
+        if (ignore_method_set && ignore_method_set.has(method_name)) {
+            return true;
+        }
+    }catch (e) {
+        Logger.printError('WHATAP-263', 'gRPC checkIgnoreMethod error: ' + e, false);
+    }
+    return false;
+}
+
+function wrapHandler(handler, methodName, type) {
+    return function(call, callback) {
+        var method_name = methodName.includes('/') ? methodName.substring(methodName.lastIndexOf('/')+1, methodName.length) : methodName;
+
+        if (!grpc_profile_enabled || checkIgnoreMethod(conf.getProperty('grpc_profile_ignore_method', ''), method_name)) {
+            return handler.call(this, call, callback);
+        }
+
+        TraceContextManager._asyncLocalStorage.run(initCtx(call, methodName), () => {
+            var ctx = TraceContextManager._asyncLocalStorage.getStore();
+            if (!ctx) {
+                return handler.call(this, call, callback);
+            }
+
+            try {
+                // TX_START: 트랜잭션 시작
+                let startDatas = [
+                    os.hostname(),
+                    methodName,
+                    ctx.remoteIp || '0.0.0.0',
+                    '', // userAgent
+                    '', // referer
+                    String(ctx.userid || 0),
+                    'false', // isStaticContents
+                    method_name
+                ];
+                AsyncSender.send_packet(PacketTypeEnum.TX_START, ctx, startDatas);
+
+                // TX_MSG: Type 정보
+                let typeDatas = ['Type', 'Type', type];
+                AsyncSender.send_packet(PacketTypeEnum.TX_MSG, ctx, typeDatas);
+
+                // TX_MSG: Method 정보
+                let methodDatas = ['Method', 'Method', method_name];
+                AsyncSender.send_packet(PacketTypeEnum.TX_MSG, ctx, methodDatas);
+
+                // TX_MSG: Parameter 정보
+                if (call.request && Object.keys(call.request).length > 0) {
+                    let paramDatas = ['Parameter', 'Parameter', JSON.stringify(call.request)];
+                    AsyncSender.send_packet(PacketTypeEnum.TX_MSG, ctx, paramDatas);
+                }
+
+                function wrappedCallback(err, response, ctx) {
+                    if (err) {
+                        // TX_ERROR: 에러 발생
+                        let errors = [
+                            err.name || err.constructor?.name || 'GrpcError',
+                            err.message || 'Unknown error'
+                        ];
+                        AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+                        ctx.status = 500;
+                    } else {
+                        ctx.status = 200;
+                    }
+
+                    endTransaction(ctx);
+
+                    if (typeof callback === 'function') {
+                        return callback(err, response);
+                    }
+                }
+
+                return handler.call(this, call, (err, response) => wrappedCallback(err, response, ctx));
+            } catch (err) {
+                Logger.printError('WHATAP-261', 'gRPC wrapHandler error: ' + err, false);
+
+                // TX_ERROR: 예외 발생
+                let errors = [
+                    err.name || err.constructor?.name || 'GrpcError',
+                    err.message || 'Unknown error'
+                ];
+                AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+
+                endTransaction(ctx);
+
+                return handler.call(this, call, callback);
+            }
+        });
+    };
+}
+
+function wrapStreamHandler(handler, methodName, type) {
+    return function(call, callback) {
+        var method_name = methodName.includes('/') ? methodName.substring(methodName.lastIndexOf('/')+1, methodName.length) : methodName;
+
+        if (!grpc_profile_enabled || checkIgnoreMethod(conf.getProperty('grpc_profile_ignore_method', ''), method_name)) {
+            return handler.call(this, call, callback);
+        }
+
+        switch (type) {
+            case 'serverStream':
+                if (!grpc_profile_stream_server_enabled) {
+                    return handler.call(this, call, callback);
+                }
+                break;
+            case 'clientStream':
+                if (!grpc_profile_stream_client_enabled) {
+                    return handler.call(this, call, callback);
+                }
+                break;
+            case 'bidi':
+                if (!grpc_profile_stream_server_enabled || !grpc_profile_stream_client_enabled) {
+                    return handler.call(this, call, callback);
+                }
+                break;
+        }
+
+        TraceContextManager._asyncLocalStorage.run(initCtx(call, methodName), () => {
+            var ctx = TraceContextManager._asyncLocalStorage.getStore();
+            if (!ctx) {
+                return handler.call(this, call, callback);
+            }
+
+            try {
+                // TX_START: 트랜잭션 시작
+                let startDatas = [
+                    os.hostname(),
+                    methodName,
+                    ctx.remoteIp || '0.0.0.0',
+                    '', // userAgent
+                    '', // referer
+                    String(ctx.userid || 0),
+                    'false', // isStaticContents
+                    method_name
+                ];
+                AsyncSender.send_packet(PacketTypeEnum.TX_START, ctx, startDatas);
+
+                // TX_MSG: Type 정보
+                let typeDatas = ['Type', 'Type', type];
+                AsyncSender.send_packet(PacketTypeEnum.TX_MSG, ctx, typeDatas);
+
+                // TX_MSG: Method 정보
+                let methodDatas = ['Method', 'Method', method_name];
+                AsyncSender.send_packet(PacketTypeEnum.TX_MSG, ctx, methodDatas);
+
+                ctx.status = 200;
+
+                call.on('end', () => {
+                    endTransaction(ctx);
+                });
+
+                call.once('cancelled', () => {
+                    // TX_MSG: Cancelled 정보
+                    let cancelDatas = ['Cancelled', 'Cancelled', 'Request cancelled'];
+                    AsyncSender.send_packet(PacketTypeEnum.TX_MSG, ctx, cancelDatas);
+                    ctx.status = 499; // Client Closed Request
+                    endTransaction(ctx);
+                });
+
+                call.on('error', (err) => {
+                    // TX_ERROR: 에러 발생
+                    let errors = [
+                        err.name || err.constructor?.name || 'GrpcError',
+                        err.message || 'Unknown error'
+                    ];
+                    AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+                    ctx.status = 500;
+                    endTransaction(ctx);
+                });
+
+                return handler.call(this, call);
+            } catch (e) {
+                Logger.printError('WHATAP-262', 'gRPC wrapStreamHandler error: ' + e, false);
+
+                // TX_ERROR: 예외 발생
+                let errors = [
+                    e.name || e.constructor?.name || 'GrpcError',
+                    e.message || 'Unknown error'
+                ];
+                AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+
+                endTransaction(ctx);
+
+                return handler.call(this, call);
+            }
+        });
+    };
+}
+
+function wrapRegister(register) {
+    return function(name, handler, serialize, deserialize, type) {
+        if (typeof handler === 'function') {
+            switch (type) {
+                case types.client_stream:
+                    // Client Streaming은 callback이 필요하므로 wrapHandler 사용
+                    handler = wrapHandler(handler, name, 'clientStream');
+                    break;
+                case types.server_stream:
+                    handler = wrapStreamHandler(handler, name, 'serverStream');
+                    break;
+                case types.bidi:
+                    handler = wrapStreamHandler(handler, name, 'bidi');
+                    break;
+                case types.unary:
+                default:
+                    handler = wrapHandler(handler, name, 'unary');
+            }
+        }
+        return register.call(this, name, handler, serialize, deserialize, type);
+    };
+}
+
+function endTransaction(ctx) {
+    if (!ctx || TraceContextManager.isExist(ctx.id) === false) {
+        return;
+    }
+
+    try {
+        ctx.elapsed = Date.now() - ctx.start_time;
+
+        // TX_END: 트랜잭션 종료
+        let endDatas = [
+            os.hostname(),
+            ctx.service_name,
+            ctx.mtid || 0,
+            ctx.mdepth || 0,
+            ctx.mcaller_txid || 0,
+            ctx.mcaller_pcode || 0,
+            ctx.mcaller_spec || '',
+            String(ctx.mcaller_url_hash || 0),
+            ctx.status || 0
+        ];
+        AsyncSender.send_packet(PacketTypeEnum.TX_END, ctx, endDatas);
+
+        TraceContextManager.end(ctx.id);
+    } catch (e) {
+        Logger.printError('WHATAP-265', 'gRPC end transaction error: ' + e, false);
+        TraceContextManager.end(ctx.id);
+        ctx = null;
+    }
+}
+
+function initCtx(call, methodName) {
+    if (!grpc_profile_enabled) {
+        return null;
+    }
+
+    const ctx = TraceContextManager.start();
+    if (!ctx) {
+        return null;
+    }
+
+    // gRPC 메타데이터에서 정보 추출
+    try {
+        if (call.metadata) {
+            // Remote IP 추출 시도
+            const metadata = call.metadata.getMap();
+            ctx.remoteIp = metadata['x-forwarded-for'] || metadata['x-real-ip'] || '0.0.0.0';
+        }
+    } catch (e) {
+        Logger.printError('WHATAP-264', 'gRPC metadata parsing error: ' + e, false);
+    }
+
+    ctx.service_name = methodName;
+    ctx.service_hash = HashUtil.hashFromString(methodName);
+    ctx.start_time = Date.now();
+
+    return ctx;
+}
+
+exports.GRpcObserver = GRpcObserver;

package/lib/observers/http-observer.js

@@ -145,6 +145,31 @@ HttpObserver.prototype.__createTransactionObserver = function (callback, isHttps
                 self.__endTransaction(null, ctx, req, res);
             });
 
+            // 브라우저가 닫히면 진행 중인 외부 HTTP 요청도 정리하고 TX_HTTPC, TX_END 전송
+            res.on('close', function () {
+                if (ctx == null) {
+                    return;
+                }
+
+                // 진행 중인 모든 외부 HTTP 요청에 대해 TX_HTTPC 전송
+                // if (ctx.activeHttpcList && ctx.activeHttpcList.length > 0) {
+                //     ctx.activeHttpcList.forEach(function(httpcInfo) {
+                //         try {
+                //             let urls = `${httpcInfo.host}:${httpcInfo.port}${httpcInfo.url}`;
+                //             let httpcDatas = [urls, httpcInfo.mcallee];
+                //             ctx.elapsed = Date.now() - httpcInfo.start_time;
+                //             TraceHttpc.isSlowHttpc(ctx);
+                //             AsyncSender.send_packet(PacketTypeEnum.TX_HTTPC, ctx, httpcDatas);
+                //         } catch (e) {
+                //             Logger.printError('WHATAP-243', 'Failed to send TX_HTTPC on close', e, false);
+                //         }
+                //     });
+                //     ctx.activeHttpcList = [];
+                // }
+
+                self.__endTransaction(null, ctx, req, res);
+            });
+
             try {
                 AsyncSender.send_packet(PacketTypeEnum.TX_START, ctx, datas)
                 return callback.apply(this, arguments);
@@ -181,6 +206,9 @@ function initCtx(req, res) {
         return null;
     }
 
+    // 진행 중인 외부 HTTP 요청 정보를 저장 (여러 개 동시 추적)
+    ctx.activeHttpcList = [];
+
     // RemoteIP
     var remote_addr;
     try {
@@ -495,10 +523,20 @@ HttpObserver.prototype.inject = function (mod, moduleName) {
                     ctx.httpc_host = options.host || options.hostname || '';
                     ctx.httpc_port = options.port || -1;
                     ctx.active_httpc_hash = true;
-                    
+
                     if (ctx.httpc_port < 0) {
                         ctx.httpc_port = 80
                     }
+
+                    // Send TX_HTTPC at start if enabled (for lost connection cases)
+                    if (conf.getProperty('profile_httpc_start_step_enabled', false)) {
+                        ctx.active_httpc_hash = false;
+                        let urls = `${ctx.httpc_host}:${ctx.httpc_port}${ctx.httpc_url}`;
+                        let httpcDatas = [urls, ctx.mcallee];
+                        ctx.elapsed = 0;
+                        TraceHttpc.isSlowHttpc(ctx);
+                        AsyncSender.send_packet(PacketTypeEnum.TX_HTTPC, ctx, httpcDatas);
+                    }
                 } catch (e) {
                     Logger.printError('WHATAP-240', 'Http Setup Error', e, false);
                     return original.apply(this, arguments);
@@ -507,6 +545,30 @@ HttpObserver.prototype.inject = function (mod, moduleName) {
                 return original.apply(this, arguments);
             }
 
+            // 진행 중인 요청 정보 저장 (여러 개 추적)
+            const httpcInfo = {
+                host: ctx.httpc_host,
+                port: ctx.httpc_port,
+                url: ctx.httpc_url,
+                mcallee: ctx.mcallee,
+                start_time: ctx.start_time
+            };
+
+            // 배열에 추가
+            if (ctx.activeHttpcList) {
+                ctx.activeHttpcList.push(httpcInfo);
+            }
+
+            // 배열에서 제거하는 헬퍼 함수
+            const removeHttpcInfo = function() {
+                if (ctx.activeHttpcList) {
+                    const index = ctx.activeHttpcList.indexOf(httpcInfo);
+                    if (index > -1) {
+                        ctx.activeHttpcList.splice(index, 1);
+                    }
+                }
+            };
+
             var wrappedCallback;
             if (typeof callback === 'function') {
                 wrappedCallback = function (response) {
@@ -515,7 +577,10 @@ HttpObserver.prototype.inject = function (mod, moduleName) {
                     }
 
                     response.on('end', function () {
-                        // HTTP 클라이언트 에러 처리 - Python 스타일로 단순화
+                        // 배열에서 제거
+                        removeHttpcInfo();
+
+                        // HTTP 클라이언트 에러 처리
                         if (response.statusCode >= 400 && transaction_status_error_enable) {
                             let error = {
                                 class: response.statusMessage,
@@ -538,6 +603,9 @@ HttpObserver.prototype.inject = function (mod, moduleName) {
                     return;
                 }
 
+                // 배열에서 제거
+                removeHttpcInfo();
+
                 const isIgnoreHttpc = shouldIgnoreError(err.code, ctx.httpc_url, httpc_status_ignore, httpc_status_ignore_set);
 
                 const networkErrorToStatusCode = {
@@ -574,7 +642,6 @@ HttpObserver.prototype.inject = function (mod, moduleName) {
                                     bodyData = arguments[0].toString('utf8');
                                 }
                                 if (bodyData) {
-                                    console.log(`body Data: ${bodyData}`)
                                     let paramDatas = ['HTTP-PARAMETERS', options.method, bodyData];
                                     AsyncSender.send_packet(PacketTypeEnum.TX_SECURE_MSG, ctx, paramDatas);
                                 }
@@ -591,12 +658,16 @@ HttpObserver.prototype.inject = function (mod, moduleName) {
         }
     });
 
-    // HTTP 클라이언트 종료 처리 - 단순화
     function endHttpc(ctx) {
         if (ctx == null) {
             return;
         }
 
+        // If profile_httpc_start_step_enabled is true, TX_HTTPC was already sent at start
+        if (conf.getProperty('profile_httpc_start_step_enabled', false)) {
+            return;
+        }
+
         ctx.active_httpc_hash = false;
         let urls = `${ctx.httpc_host}:${ctx.httpc_port}${ctx.httpc_url}`;
         let httpcDatas = [urls, ctx.mcallee];

package/lib/observers/socket.io-observer.js

@@ -509,7 +509,7 @@ SocketIOObserver.prototype.__endTransaction = function(error, ctx) {
         AsyncSender.send_packet(PacketTypeEnum.TX_END, ctx, datas);
 
         TraceContextManager.end(ctx.id);
-
+        ctx = null;
     } catch (e) {
         Logger.printError('WHATAP-231', 'Socket.io end transaction error', e, false);
         TraceContextManager.end(ctx.id);

package/lib/observers/websocket-observer.js

@@ -378,7 +378,7 @@ WebsocketObserver.prototype.__endTransaction = function(error, ctx) {
         ctx.elapsed = Date.now() - ctx.start_time;
         AsyncSender.send_packet(PacketTypeEnum.TX_END, ctx, datas);
         TraceContextManager.end(ctx.id);
-
+        ctx = null;
     } catch (e) {
         Logger.printError('WHATAP-222', 'WebSocket end transaction error', e, false);
         TraceContextManager.end(ctx.id);

package/lib/trace/trace-context-manager.js

@@ -5,7 +5,6 @@
  */
 
 var IntKeyMap       = require('../util/intkey-map'),
-    HashUtil        = require('../util/hashutil'),
     TraceContext    = require('./trace-context'),
     Logger          = require('../logger');
 var Long            = require('long');
@@ -19,7 +18,7 @@ function TraceContextManager() {
     this.nextId = 1;
     this.currentId = null;
     this._asyncLocalStorage = new AsyncLocalStorage();
-    this.entry = new IntKeyMap(1021,1).setMax(5000);
+    this.entry = new IntKeyMap(1021,1).setMax(10000);
     this.node = null;
     this.clock_seq = null;
 }

package/lib/util/nodeutil.js

@@ -90,8 +90,7 @@ var NodeUtil = {
         const major = this.getNodeMajorVersion();
         const minor = this.getNodeMinorVersion();
 
-        // Node.js 18+ 또는 16.7+에서 안정적
-        return major >= 18 || (major === 16 && minor >= 7);
+        return major >= 17 || (major >= 16 && minor >= 7);
     },
 
     // 버전 비교 함수

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "whatap",
   "homepage": "http://www.whatap.io",
-  "version": "1.0.4",
-  "releaseDate": "20251016",
+  "version": "1.0.5-canary.1",
+  "releaseDate": "20251030",
   "description": "Monitoring and Profiling Service",
   "main": "index.js",
   "scripts": {},