whatap 0.5.22 → 0.5.24

package/lib/conf/config-default.js

@@ -281,10 +281,9 @@ var ConfigDefault = {
     "profile_mongodb_param_enabled": bool("profile_mongodb_param_enabled", false),
 
     "trace_mtrace_traceparent_key": str("trace_mtrace_traceparent_key", "traceparent"),
-
     "txtext_txname_enabled": bool("txtext_txname_enabled", true),
-
-    "ignore_env_variable_set": str("ignore_env_variable_set", "")
+    "ignore_env_variable_set": str("ignore_env_variable_set", ""),
+    "profile_httpc_start_step_enabled": bool("profile_httpc_start_step_enabled", false)
 
 };
 

package/lib/observers/http-observer.js

@@ -194,6 +194,15 @@ HttpObserver.prototype.__createTransactionObserver = function(callback, isHttps,
                 ctx.profile.add(step);
             }
 
+            // res.on('aborted', () => {
+            //     self.__endTransaction(null, ctx, req, res)
+            // })
+
+            res.on('close', () => {
+                // 강제로 종료할 경우
+                self.__endTransaction(null, ctx, req, res)
+            });
+
             aop.after(res, 'end', function(obj, args) {
                 if(ctx == null) { return; }
                 PluginLoaderManager.do('httpserviceend', ctx, req, res);
@@ -537,6 +546,8 @@ function initCtx(req, res) {
 };
 
 HttpObserver.prototype.__endTransaction = function(error, ctx, req, res) {
+    if(ctx == null || TraceContextManager.isExist(ctx._id) === false) { return; }
+
     var param_enabled = false;
     if(conf.profile_http_parameter_enabled === true) {
         param_enabled = true;
@@ -591,7 +602,7 @@ HttpObserver.prototype.__endTransaction = function(error, ctx, req, res) {
         return;
     }
 
-    if(ctx == null || TraceContextManager.isExist(ctx._id) === false) { return; }
+    // if(ctx == null || TraceContextManager.isExist(ctx._id) === false) { return; }
 
     if(ctx.isStaticContents !== true && conf._trace_ignore_url_set[ctx.service_hash]){
         ctx.isStaticContents = true;
@@ -841,6 +852,19 @@ HttpObserver.prototype.inject = function( mod, moduleName ) {
                     ctx.footprint('Http Call Start');
 
                     if (ctx.httpc_port < 0) { ctx.httpc_port = 80 };
+
+                    if(conf.getProperty('profile_httpc_start_step_enabled', false)){
+                        step.elapsed = ctx.getElapsedTime() - step.start_time;
+                        step.url = HashUtil.hashFromString(ctx.httpc_url);
+                        DataTextAgent.HTTPC_URL.add(step.url, ctx.httpc_url);
+                        step.host = HashUtil.hashFromString(ctx.httpc_host);
+                        DataTextAgent.HTTPC_HOST.add(step.host, ctx.httpc_host);
+                        step.port = ctx.httpc_port;
+
+                        ctx.active_httpc_hash = step.url;
+                        ctx.profile.push(step);
+                        endHttpc(ctx, step);
+                    }
                 }catch (e) {
                     Logger.printError('WHATAP-852', 'Http Repeat ', e, true);
                     return original.apply(this, arguments);

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

@@ -20,6 +20,8 @@ const DataProfileAgent    = require('../data/dataprofile-agent');
 const MeterUsers = require("../counter/meter/meter-users");
 const MeterService        = require('../counter/meter/meter-service').MeterService;
 const shimmer = require('../core/shimmer');
+const MessageStep = require('../step/message-step');
+const HashUtil = require('../util/hashutil');
 
 // 설정을 객체로 통합하여 관리 (참조 성능 향상)
 var config = {
@@ -147,50 +149,254 @@ SocketIOObserver.prototype.inject = function (mod, moduleName) {
 
     var self = this;
 
-    shimmer.wrap(mod.prototype, 'on', function (original) {
-        return function (event, listener) {
-            if (event === 'connection') {
-                return original.call(this, event, function (socket) {
-                    // 효율적인 이벤트 핸들러 래핑
-                    const wrappedEmit = function (origEmit) {
-                        // 클로저 최소화 (메모리 사용 감소)
-                        const emitFn = function (emitEvent, ...args) {
-                            // 빠른 조건 검사 (조기 반환)
-                            if (!config.trace_background_socket_enabled) {
+    // 공통 emit 래핑 함수
+    const wrapEmitFunction = function(target, emitType, getContextInfo) {
+        if (!target || typeof target.emit !== 'function' || target.emit.__wrapped__) {
+            return false;
+        }
+
+        const originalEmit = target.emit;
+        target.emit = function(event, ...args) {
+            if (!config.trace_background_socket_enabled) {
+                return originalEmit.apply(this, [event, ...args]);
+            }
+
+            const contextInfo = getContextInfo ? getContextInfo.call(this) : {};
+            self.__handleSocketEmitEvent(this, event, args, emitType, contextInfo);
+            return originalEmit.apply(this, [event, ...args]);
+        };
+
+        // 원본 함수 속성 보존
+        Object.defineProperties(target.emit, {
+            length: { value: originalEmit.length },
+            name: { value: originalEmit.name },
+            __wrapped__: { value: true }
+        });
+
+        return true;
+    };
+
+    const wrapSocketIOEvents = function(target) {
+        if (!target || typeof target.on !== 'function') {
+            return false;
+        }
+
+        shimmer.wrap(target, 'on', function (original) {
+            return function (event, listener) {
+                if (event === 'connection') {
+                    return original.call(this, event, function (socket) {
+                        // 1. 개별 소켓 emit 래핑
+                        const wrappedEmit = function (origEmit) {
+                            const emitFn = function (emitEvent, ...args) {
+                                if (!config.trace_background_socket_enabled) {
+                                    return origEmit.apply(this, [emitEvent, ...args]);
+                                }
+
+                                self.__handleSocketEmitEvent(socket, emitEvent, args, 'socket', {
+                                    socketId: socket.id,
+                                    remoteAddress: socket.conn ? socket.conn.remoteAddress : null
+                                });
                                 return origEmit.apply(this, [emitEvent, ...args]);
-                            }
+                            };
 
-                            self.__handleSocketEmitEvent(socket, emitEvent, args);
-                            return origEmit.apply(this, [emitEvent, ...args]);
+                            Object.defineProperties(emitFn, {
+                                length: { value: origEmit.length },
+                                name: { value: origEmit.name }
+                            });
+
+                            return emitFn;
                         };
 
-                        // 원본 함수 속성 유지
-                        Object.defineProperties(emitFn, {
-                            length: { value: origEmit.length },
-                            name: { value: origEmit.name }
+                        if (typeof socket.emit === 'function' && !socket.emit.__whatap_wrapped__) {
+                            const originalEmit = socket.emit;
+                            socket.emit = wrappedEmit(originalEmit);
+                            socket.emit.__whatap_wrapped__ = true;
+                        }
+
+                        // 2. socket.broadcast.emit 래핑
+                        if (socket.broadcast && typeof socket.broadcast.emit === 'function' && !socket.broadcast.emit.__whatap_wrapped__) {
+                            const originalBroadcastEmit = socket.broadcast.emit;
+                            socket.broadcast.emit = function(emitEvent, ...args) {
+                                if (!config.trace_background_socket_enabled) {
+                                    return originalBroadcastEmit.apply(this, [emitEvent, ...args]);
+                                }
+
+                                self.__handleSocketEmitEvent(socket, emitEvent, args, 'broadcast', {
+                                    socketId: socket.id,
+                                    broadcastType: 'all_except_sender',
+                                    remoteAddress: socket.conn ? socket.conn.remoteAddress : null
+                                });
+                                return originalBroadcastEmit.apply(this, [emitEvent, ...args]);
+                            };
+                            socket.broadcast.emit.__whatap_wrapped__ = true;
+                        }
+
+                        // 3. socket.to() 래핑 (room broadcast)
+                        if (typeof socket.to === "function" && !socket.to.__whatap_wrapped__) {
+                            const originalTo = socket.to;
+                            socket.to = function(room) {
+                                const roomObj = originalTo.call(this, room);
+
+                                if (roomObj && typeof roomObj.emit === 'function' && !roomObj.emit.__whatap_wrapped__) {
+                                    const originalRoomEmit = roomObj.emit;
+                                    roomObj.emit = function(emitEvent, ...args) {
+                                        if (!config.trace_background_socket_enabled) {
+                                            return originalRoomEmit.apply(this, [emitEvent, ...args]);
+                                        }
+
+                                        self.__handleSocketEmitEvent(socket, emitEvent, args, 'room_broadcast', {
+                                            socketId: socket.id,
+                                            broadcastType: 'room',
+                                            room: room,
+                                            remoteAddress: socket.conn ? socket.conn.remoteAddress : null
+                                        });
+                                        return originalRoomEmit.apply(this, [emitEvent, ...args]);
+                                    };
+                                    roomObj.emit.__whatap_wrapped__ = true;
+                                }
+
+                                return roomObj;
+                            };
+                            socket.to.__whatap_wrapped__ = true;
+                        }
+
+                        // 4. socket.in() 래핑 (room broadcast - 다른 방식)
+                        if (typeof socket.in === "function" && !socket.in.__whatap_wrapped__) {
+                            const originalIn = socket.in;
+                            socket.in = function(room) {
+                                const roomObj = originalIn.call(this, room);
+
+                                if (roomObj && typeof roomObj.emit === 'function' && !roomObj.emit.__whatap_wrapped__) {
+                                    const originalRoomEmit = roomObj.emit;
+                                    roomObj.emit = function(emitEvent, ...args) {
+                                        if (!config.trace_background_socket_enabled) {
+                                            return originalRoomEmit.apply(this, [emitEvent, ...args]);
+                                        }
+
+                                        self.__handleSocketEmitEvent(socket, emitEvent, args, 'room_broadcast', {
+                                            socketId: socket.id,
+                                            broadcastType: 'room',
+                                            room: room,
+                                            remoteAddress: socket.conn ? socket.conn.remoteAddress : null
+                                        });
+                                        return originalRoomEmit.apply(this, [emitEvent, ...args]);
+                                    };
+                                    roomObj.emit.__whatap_wrapped__ = true;
+                                }
+
+                                return roomObj;
+                            };
+                            socket.in.__whatap_wrapped__ = true;
+                        }
+
+                        return listener.apply(this, [socket]);
+                    });
+                }
+
+                return original.call(this, event, listener);
+            };
+        });
+
+        // 5. io.emit 래핑 (전체 브로드캐스트)
+        if (target.emit && typeof target.emit === 'function' && !target.emit.__whatap_wrapped__) {
+            const originalIoEmit = target.emit;
+            target.emit = function(emitEvent, ...args) {
+                if (!config.trace_background_socket_enabled) {
+                    return originalIoEmit.apply(this, [emitEvent, ...args]);
+                }
+
+                self.__handleSocketEmitEvent(null, emitEvent, args, 'global_broadcast', {
+                    broadcastType: 'global',
+                    connectedSockets: this.sockets ? (this.sockets.sockets ? this.sockets.sockets.size : 0) : 0
+                });
+                return originalIoEmit.apply(this, [emitEvent, ...args]);
+            };
+            target.emit.__whatap_wrapped__ = true;
+        }
+
+        // 6. io.to() 래핑 (서버 레벨 룸 브로드캐스트)
+        if (typeof target.to === "function" && !target.to.__whatap_wrapped__) {
+            const originalIoTo = target.to;
+            target.to = function(room) {
+                const roomObj = originalIoTo.call(this, room);
+                if (roomObj && typeof roomObj.emit === 'function') {
+                    const originalRoomEmit = roomObj.emit;
+                    roomObj.emit = function(emitEvent, ...args) {
+                        if (!config.trace_background_socket_enabled) {
+                            return originalRoomEmit.apply(this, [emitEvent, ...args]);
+                        }
+
+                        // 해당 룸의 소켓 연결 개수 계산
+                        let roomSocketCount = 0;
+                        if (this.adapter && this.adapter.rooms) {
+                            const roomSockets = this.adapter.rooms.get(room);
+                            roomSocketCount = roomSockets ? roomSockets.size : 0;
+                        }
+
+                        self.__handleSocketEmitEvent(null, emitEvent, args, 'server_room_broadcast', {
+                            broadcastType: 'server_room',
+                            room: room,
+                            connectedSockets: roomSocketCount
                         });
+                        return originalRoomEmit.apply(this, [emitEvent, ...args]);
+                    };
+                    roomObj.emit.__whatap_wrapped__ = true;
+                }
 
-                        return emitFn;
+                return roomObj;
+            };
+            target.to.__whatap_wrapped__ = true;
+        }
+
+        // 7. io.in() 래핑 (서버 레벨 룸 브로드캐스트 - 다른 방식)
+        if (typeof target.in === "function" && !target.in.__whatap_wrapped__) {
+            const originalIoIn = target.in;
+            target.in = function(room) {
+                const roomObj = originalIoIn.call(this, room);
+
+                if (roomObj && typeof roomObj.emit === 'function' && !roomObj.emit.__whatap_wrapped__) {
+                    const originalRoomEmit = roomObj.emit;
+                    roomObj.emit = function(emitEvent, ...args) {
+                        if (!config.trace_background_socket_enabled) {
+                            return originalRoomEmit.apply(this, [emitEvent, ...args]);
+                        }
+
+                        self.__handleSocketEmitEvent(null, emitEvent, args, 'server_room_broadcast', {
+                            broadcastType: 'server_room',
+                            room: room,
+                            connectedSockets: this.sockets ? (this.sockets.sockets ? this.sockets.sockets.size : 0) : 0
+                        });
+                        return originalRoomEmit.apply(this, [emitEvent, ...args]);
                     };
+                    roomObj.emit.__whatap_wrapped__ = true;
+                }
 
-                    // emit 함수에만 래핑 적용 (불필요한 래핑 제거)
-                    if (typeof socket.emit === 'function' && !socket.emit.__wrapped__) {
-                        const original = socket.emit;
-                        socket.emit = wrappedEmit(original);
-                        socket.emit.__wrapped__ = true;
-                    }
+                return roomObj;
+            };
+            target.in.__whatap_wrapped__ = true;
+        }
 
-                    return listener.apply(this, [socket]);
-                });
-            }
+        return true;
+    };
 
-            return original.call(this, event, listener);
-        };
-    });
+    // 1. Socket.IO v2.x 스타일 (mod.prototype)
+    if (mod.prototype) {
+        wrapSocketIOEvents(mod.prototype);
+    }
+
+    // 2. Socket.IO v4.x 스타일 (mod.Server.prototype)
+    if (mod.Server && mod.Server.prototype) {
+        wrapSocketIOEvents(mod.Server.prototype);
+    }
+
+    // 3. 직접 모듈 래핑 (일부 버전에서 필요할 수 있음)
+    // if (typeof mod.on === 'function') {
+    //     wrapSocketIOEvents(mod);
+    // }
 };
 
-// 소켓 이벤트 처리 최적화 (CPU 및 메모리 사용 감소)
-SocketIOObserver.prototype.__handleSocketEmitEvent = function(socket, event, args) {
+// 소켓 이벤트 처리 최적화 (CPU 및 메모리 사용 감소) - broadcast 지원 추가
+SocketIOObserver.prototype.__handleSocketEmitEvent = function(socket, event, args, emitType, contextInfo) {
     // 빠른 샘플링 체크 (조기 반환으로 성능 향상)
     if (config.trace_sampling_enabled && !this.socketCounter.checkSampling()) {
         MeterService.add(0, 1, 0, SecurityMaster.PCODE, SecurityMaster.OKIND, SecurityMaster.OID);
@@ -201,15 +407,17 @@ SocketIOObserver.prototype.__handleSocketEmitEvent = function(socket, event, arg
     const shouldProfileResource = Math.random() < config.resource_sampling_rate;
 
     // 컨텍스트 생성 및 실행
-    TraceContextManager._asyncLocalStorage.run(this.__initCtx(socket, args, shouldProfileResource), () => {
+    TraceContextManager._asyncLocalStorage.run(this.__initCtx(socket, args, shouldProfileResource, emitType, contextInfo), () => {
         try {
             var ctx = TraceContextManager._asyncLocalStorage.getStore();
             if (!ctx) return;
 
             // IP 주소 처리 최적화
             var host = null;
-            if (socket.conn && socket.conn.remoteAddress) {
-                const ipInfo = this.getProcessedIp(socket.conn.remoteAddress);
+            var remoteAddress = contextInfo.remoteAddress || (socket && socket.conn && socket.conn.remoteAddress);
+
+            if (remoteAddress) {
+                const ipInfo = this.getProcessedIp(remoteAddress);
                 if (ipInfo) {
                     host = ipInfo.host;
                     // 이미 처리된 IP 바이트 사용
@@ -217,8 +425,23 @@ SocketIOObserver.prototype.__handleSocketEmitEvent = function(socket, event, arg
                     step.start_time = ctx.getElapsedTime();
                     step.ipaddr = ipInfo.ipBytes;
                     step.elapsed = 0; // 즉시 종료 (측정 최소화)
+
+                    // 브로드캐스트 타입 정보 추가
+                    if (emitType !== 'socket') {
+                        step.broadcast_type = emitType;
+                        step.broadcast_info = contextInfo;
+                    }
+
                     ctx.profile.push(step);
                 }
+            } else {
+                const ipBytes = Buffer.from(IPUtil.stringToBytes("0.0.0.0"));
+                var step = new SocketStep();
+                step.start_time = ctx.getElapsedTime();
+                step.ipaddr = ipBytes;
+                step.elapsed = 0;
+
+                ctx.profile.push(step);
             }
 
             // 트랜잭션 종료 및 데이터 전송
@@ -246,7 +469,9 @@ SocketIOObserver.prototype.__endTransaction = function(error, ctx) {
         profile.time  = wtx.endTime;
         wtx.elapsed = ctx.getElapsedTime();
 
-        DataTextAgent.SERVICE.add(ctx.service_hash, ctx.service_name);
+        // 서비스 이름에 브로드캐스트 타입 정보 추가
+        let serviceName = ctx.service_name;
+        DataTextAgent.SERVICE.add(ctx.service_hash, serviceName);
 
         wtx.seq = ctx.txid;
         wtx.service = ctx.service_hash;
@@ -294,19 +519,55 @@ SocketIOObserver.prototype.__endTransaction = function(error, ctx) {
     }
 };
 
-// 컨텍스트 초기화 최적화
-SocketIOObserver.prototype.__initCtx = function(socket, args, shouldProfileResource) {
+// 컨텍스트 초기화 최적화 - broadcast 정보 추가
+SocketIOObserver.prototype.__initCtx = function(socket, args, shouldProfileResource, emitType, contextInfo) {
     const ctx = TraceContextManager.start();
     if (!ctx) {return;}
 
     var remote_addr;
-    if (socket.conn && socket.conn.remoteAddress) {
-        const address = socket.conn.remoteAddress;
-        if(address && address.includes(':')){
-            remote_addr = address.substring(address.lastIndexOf(':')+1);
+    var remoteAddress = contextInfo.remoteAddress || (socket && socket.conn && socket.conn.remoteAddress);
+
+    if (remoteAddress) {
+        if(remoteAddress && remoteAddress.includes(':')){
+            remote_addr = remoteAddress.substring(remoteAddress.lastIndexOf(':')+1);
         }
     }
 
+    ctx.service_name = "/socket.io";
+    ctx.service_hash = HashUtil.hashFromString(ctx.service_name);
+
+    // MessageStep 생성 - 브로드캐스트 타입별 정보
+    var step = new MessageStep();
+    var title, message;
+
+    switch (emitType) {
+        case 'broadcast':
+            title = "Broadcast";
+            message = "Broadcast to all clients except sender";
+            break;
+        case 'room_broadcast':
+            title = "Room Broadcast";
+            message = `Broadcast to room: ${contextInfo.room || 'unknown'}`;
+            break;
+        case 'global_broadcast':
+            title = "Global Broadcast";
+            message = `Total clients: ${contextInfo.connectedSockets || 0}`;
+            break;
+        case 'server_room_broadcast':
+            title = "Server Room Broadcast";
+            message = `Room: ${contextInfo.room || 'unknown'}, Total clients: ${contextInfo.connectedSockets || 0}`;
+            break;
+        default:
+            title = "Socket";
+            message = "Direct socket message";
+    }
+
+    step.hash = HashUtil.hashFromString(title);
+    step.start_time = ctx.getElapsedTime();
+    step.desc = message;
+    DataTextAgent.MESSAGE.add(step.hash, title);
+    ctx.profile.push(step);
+
     // 리소스 측정은 샘플링된 경우에만 수행
     ctx.shouldProfileResource = shouldProfileResource;
     if (shouldProfileResource) {

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "whatap",
   "homepage": "http://www.whatap.io",
-  "version": "0.5.22",
-  "releaseDate": "20250630",
+  "version": "0.5.24",
+  "releaseDate": "20250805",
   "description": "Monitoring and Profiling Service",
   "main": "index.js",
   "scripts": {},