whatap 1.0.2 → 1.0.3-canary.0

package/lib/observers/websocket-observer.js

@@ -4,36 +4,28 @@
  * can be found in the LICENSE file.
  */
 
-
 var TraceContextManager = require('../trace/trace-context-manager'),
-    SocketStep = require('../step/socket-step'),
     conf = require('../conf/configure'),
     IPUtil = require('../util/iputil'),
     Logger = require('../logger');
 const {Detector: URLPatternDetector} = require("../trace/serviceurl-pattern-detector");
-const HashUtil = require("../util/hashutil");
-const DataTextAgent = require("../data/datatext-agent");
-const ResourceProfile = require("../util/resourceprofile");
-const ProfilePack         = require('../pack/profile-pack');
-const TxRecord            = require('../service/tx-record');
-const DateUtil            = require('../util/dateutil');
-const SecurityMaster      = require('../net/security-master');
-const DataProfileAgent    = require('../data/dataprofile-agent');
-const MessageStep = require("../step/message-step");
-const MeterUsers = require("../counter/meter/meter-users");
-const MeterService        = require('../counter/meter/meter-service').MeterService;
+const DateUtil = require('../util/dateutil');
+const SecurityMaster = require('../net/security-master');
 const shimmer = require('../core/shimmer');
+const HashUtil = require('../util/hashutil');
+const AsyncSender = require('../udp/async_sender');
+const PacketTypeEnum = require('../udp/packet_type_enum');
+const os = require('os');
 
 // 설정을 객체로 통합하여 관리 (참조 성능 향상)
 var config = {
     trace_background_socket_enabled: conf.getProperty('trace_background_socket_enabled', true),
     trace_sampling_enabled: conf.getProperty('trace_sampling_enabled', true),
     trace_sampling_tps: conf.getProperty('trace_sampling_tps', 1000),
-    resource_sampling_rate: 0.1,
-    profile_batch_size: 20,
-    flush_interval: 500
+    resource_sampling_rate: 0.1 // 리소스 프로파일링을 10%만 수행
 };
 
+// 설정 변경 감지를 단일 리스너로 통합
 conf.on('trace_background_socket_enabled', function (newProps) {
     config.trace_background_socket_enabled = newProps;
 });
@@ -68,50 +60,89 @@ var WebsocketObserver = function(agent){
         }
     };
 
-    this.profileBuffer = [];
+    // IP 주소 캐싱 (성능 최적화)
+    this.ipCache = new Map();
+};
 
-    // 주기적 플러시 설정
-    setInterval(() => this.flushProfileBuffer(), config.flush_interval);
+// IP 주소 처리 최적화 함수
+WebsocketObserver.prototype.getProcessedIp = function(address) {
+    if (!address) return null;
 
-    this.ipCache = new Map();
+    if (this.ipCache.has(address)) {
+        return this.ipCache.get(address);
+    }
+
+    let host = address;
+    if (address.includes(':')) {
+        host = address.substring(address.lastIndexOf(':') + 1);
+    }
+
+    host = IPUtil.checkIp4(host);
+    const ipInt = IPUtil.stringToInt(host);
+    const ipBytes = Buffer.from(IPUtil.stringToBytes(host));
+
+    const result = { host, ipInt, ipBytes };
+    this.ipCache.set(address, result);
+
+    // 캐시 크기 관리 (메모리 누수 방지)
+    if (this.ipCache.size > 10000) {
+        // 오래된 항목부터 20% 제거
+        const keysToDelete = Array.from(this.ipCache.keys()).slice(0, Math.floor(this.ipCache.size * 0.2));
+        keysToDelete.forEach(key => this.ipCache.delete(key));
+    }
+
+    return result;
 };
 
-WebsocketObserver.prototype.flushProfileBuffer = function() {
-    if (this.profileBuffer.length === 0) return;
-
-    const now = Date.now();
-    // 100ms 이상 지난 항목만 처리
-    const bufferToFlush = this.profileBuffer.filter(item => (now - item.timestamp) >= 100);
-    if (bufferToFlush.length === 0) return;
-
-    // 최대 batch_size까지만 처리
-    let batchToProcess;
-    if(bufferToFlush.length > config.profile_batch_size)
-        batchToProcess = bufferToFlush.slice(0, config.profile_batch_size);
-    else
-        batchToProcess = bufferToFlush;
-
-    // 버퍼에서 처리할 항목 제거
-    this.profileBuffer = this.profileBuffer.filter(item =>
-        !batchToProcess.some(batch => batch.ctx._id === item.ctx._id)
-    );
-
-    // 배치 처리
-    batchToProcess.forEach(item => {
-        try {
-            DataProfileAgent.sendProfile(item.ctx, item.profile, false);
-            // 컨텍스트 정리 (메모리 누수 방지)
-            item.ctx = null;
-        } catch (e) {
-            Logger.printError('WHATAP-615', 'Websocket buffer flush error', e, false);
+// 에러 처리 함수
+function handleWebSocketError(ctx, err) {
+    if (!err) return null;
+
+    try {
+        var errorClass = err.code || err.name || err.constructor?.name || 'WebSocketError';
+        var errorMessage = err.message || 'websocket error';
+        var errorStack = '';
+
+        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");
+        }
+
+        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 (this.profileBuffer.length > 1000) {
-        // 가장 오래된 항목부터 제거
-        this.profileBuffer = this.profileBuffer.slice(-500);
+        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);
+            return errorClass; // 에러 정보 반환
+        }
+    } catch (e) {
+        Logger.printError('WHATAP-218', 'Error handling WebSocket error', e, false);
     }
-};
+    return null;
+}
 
 WebsocketObserver.prototype.inject = function (mod, moduleName) {
     if (mod.__whatap_observe__) {
@@ -121,172 +152,267 @@ WebsocketObserver.prototype.inject = function (mod, moduleName) {
     Logger.initPrint("WebsocketObserver");
 
     var self = this;
-    var aop = self.agent.aop;
 
-    // IP 주소 변환 캐시 (동일한 IP 변환 작업 최소화)
-    const ipCache = new Map();
+    // 1. WebSocketServer 래핑 - request 이벤트 후킹
+    if (mod.server && mod.server.prototype) {
+        const wrapWebSocketServer = function(target) {
+            if (!target || typeof target.on !== 'function') {
+                return false;
+            }
+
+            shimmer.wrap(target, 'on', function (original) {
+                return function (event, listener) {
+                    if (event === 'request') {
+                        return original.call(this, event, function (request) {
+                            // WebSocketConnection의 메시지 전송 메서드들 래핑
+                            request.on('requestAccepted', function(connection) {
+                                self.__wrapWebSocketConnection(connection, request);
+                            });
+                            return listener.apply(this, [request]);
+                        });
+                    }
+                    return original.call(this, event, listener);
+                };
+            });
 
-    function getProcessedIp(remoteAddress) {
-        if (!remoteAddress) return null;
+            return true;
+        };
 
-        if (ipCache.has(remoteAddress)) {
-            return ipCache.get(remoteAddress);
-        }
+        wrapWebSocketServer(mod.server.prototype);
+    }
 
-        let host = remoteAddress;
-        if (remoteAddress.includes(':')) {
-            host = remoteAddress.substring(remoteAddress.lastIndexOf(':') + 1);
-        }
+    // 2. WebSocketConnection 직접 래핑 (구버전 호환성)
+    if (mod.connection && mod.connection.prototype) {
+        self.__wrapWebSocketConnection(mod.connection.prototype, null);
+    }
+};
 
-        host = IPUtil.checkIp4(host);
-        const ipInt = IPUtil.stringToInt(host);
-        const ipBytes = Buffer.from(IPUtil.stringToBytes(host));
+WebsocketObserver.prototype.__wrapWebSocketConnection = function(connection, request) {
+    var self = this;
 
-        const result = { host, ipInt, ipBytes };
-        ipCache.set(remoteAddress, result);
+    if (!connection) return;
 
-        return result;
-    }
+    // send, sendUTF, sendBytes 메서드들 래핑
+    const methods = ['send', 'sendUTF', 'sendBytes'];
 
-    aop.after(mod.server.prototype, 'on', function (obj, args, ret, lctx){
-        aop.after(mod.connection.prototype, ['send', 'sendUTF', 'sendBytes'], function (obj, args, ret, lctx) {
-            if(!config.trace_background_socket_enabled) {
-                return;
-            }
+    methods.forEach(function(methodName) {
+        if (typeof connection[methodName] === 'function' && !connection[methodName].__whatap_wrapped__) {
+            const originalMethod = connection[methodName];
 
-            if(config.trace_sampling_enabled) {
-                if(!self.socketCounter.checkSampling()) {
-                    MeterService.add(0, 1, 0, 0, 0, 0);
-                    return;
+            connection[methodName] = function(data) {
+                if (!config.trace_background_socket_enabled) {
+                    return originalMethod.apply(this, arguments);
+                }
+
+                // 빠른 샘플링 체크 (조기 반환으로 성능 향상)
+                if (config.trace_sampling_enabled && !self.socketCounter.checkSampling()) {
+                    return originalMethod.apply(this, arguments);
                 }
-            }
 
-            var protocol = obj.protocol;
-            var remoteAddress = obj.remoteAddress;
+                // 브로드캐스트 감지 시도
+                const emitType = self.__detectBroadcastType();
 
-            // 리소스 프로파일링 최적화 - 모든 트랜잭션 대신 샘플링
-            const shouldProfileResource = Math.random() < config.resource_sampling_rate; // 10%만 리소스 프로파일링
+                const remoteAddress = this.remoteAddress ||
+                    (this.socket ? this.socket.remoteAddress : null) ||
+                    (request && request.remoteAddress ? request.remoteAddress : null);
 
-            TraceContextManager._asyncLocalStorage.run(initCtx(obj, args, shouldProfileResource), () => {
-                try {
+                TraceContextManager._asyncLocalStorage.run(self.__initCtx(this, data, emitType, {
+                    remoteAddress: remoteAddress,
+                    protocol: this.protocol,
+                    request: request
+                }), () => {
                     var ctx = TraceContextManager._asyncLocalStorage.getStore();
                     if (!ctx) {
-                        return;
+                        return originalMethod.apply(this, arguments);
                     }
 
-                    // IP 주소 처리 최적화
-                    const ipInfo = getProcessedIp(remoteAddress);
-                    if (!ipInfo) return;
-
-                    // 불필요한 footprint 로깅 제거 (메모리 사용 감소)
-                    ctx.socket_connecting = true;
-
-                    // 프로토콜 정보 수집 최적화
-                    if (protocol) {
-                        var protocol_hash = HashUtil.hashFromString('Protocol');
-                        var step = new MessageStep();
-                        step.hash = protocol_hash;
-                        step.start_time = ctx.getElapsedTime();
-                        step.desc = protocol;
-
-                        DataTextAgent.MESSAGE.add(protocol_hash, 'Protocol');
-                        ctx.profile.add(step);
+                    try {
+                        ctx.service_name = "/websocket";
+                        let hostname = '';
+
+                        let datas = [
+                            hostname,
+                            ctx.service_name,
+                            ctx.remoteIp || 0,
+                            ctx.userAgentString || '',
+                            ctx.referer || '',
+                            String(ctx.userid || 0),
+                            String(false), // isStaticContents
+                            emitType
+                        ];
+
+                        AsyncSender.send_packet(PacketTypeEnum.TX_START, ctx, datas);
+
+                        self.__sendWebSocketMessage(ctx, emitType, data, methodName);
+                        self.__sendWebSocketEvent(ctx, this, data, emitType, remoteAddress);
+                        self.__endTransaction(null, ctx);
+
+                        return originalMethod.apply(this, arguments);
+                    } catch (e) {
+                        Logger.printError('WHATAP-219', 'websocket send transaction error', e, false);
+                        var errorInfo = handleWebSocketError(ctx, e);
+                        self.__endTransaction(errorInfo, ctx);
+                        return originalMethod.apply(this, arguments);
                     }
+                });
+            };
 
-                    // 소켓 단계 기록 (메모리 사용 최적화)
-                    var step = new SocketStep();
-                    step.start_time = ctx.getElapsedTime();
-                    step.ipaddr = ipInfo.ipBytes;
-
-                    ctx.socket_connecting = false;
-                    step.elapsed = ctx.getElapsedTime() - step.start_time;
-                    ctx.profile.push(step);
-
-                    // 트랜잭션 종료 처리 최적화
-                    self.__endTransaction(null, ctx);
-                    return;
-                } catch (e) {
-                    Logger.printError('WHATAP-616', 'Websocket transaction error', e, false);
-                    return;
-                }
+            connection[methodName].__whatap_wrapped__ = true;
+
+            // 속성 복사
+            Object.defineProperties(connection[methodName], {
+                length: { value: originalMethod.length },
+                name: { value: originalMethod.name }
             });
-        });
+        }
     });
 };
 
-WebsocketObserver.prototype.__endTransaction = function(error, ctx) {
+WebsocketObserver.prototype.__detectBroadcastType = function() {
     try {
-        var profile = new ProfilePack();
-        var wtx = new TxRecord();
-        wtx.endTime = DateUtil.currentTime();
-        profile.time = wtx.endTime;
-        wtx.elapsed = ctx.getElapsedTime();
-
-        DataTextAgent.SERVICE.add(ctx.service_hash, ctx.service_name);
-
-        wtx.seq = ctx.txid;
-        wtx.service = ctx.service_hash;
-
-        // CPU와 메모리 측정은 샘플링된 트랜잭션에만 수행
-        if (ctx.shouldProfileResource) {
-            wtx.cpuTime = ResourceProfile.getCPUTime() - ctx.start_cpu;
-            wtx.malloc = ResourceProfile.getUsedHeapSize() - ctx.start_malloc;
-            if(wtx.malloc < 0) { wtx.malloc = 0; }
-        } else {
-            wtx.cpuTime = 0;
-            wtx.malloc = 0;
+        // 스택 트레이스를 통해 브로드캐스트 패턴 감지
+        const stack = (new Error()).stack;
+        if (stack) {
+            // connections.forEach, broadcast 패턴 감지
+            if (stack.includes('connections.forEach') ||
+                stack.includes('connections.map') ||
+                stack.includes('broadcast') ||
+                stack.includes('sendToAll')) {
+                return 'broadcast';
+            }
         }
+        return 'websocket';
+    } catch (e) {
+        return 'websocket';
+    }
+};
 
-        wtx.status = 2;
-        wtx.ipaddr = ctx.remoteIp;
+WebsocketObserver.prototype.__sendWebSocketMessage = function(ctx, emitType, data, methodName) {
+    try {
+        var title, message;
+
+        switch (emitType) {
+            case 'broadcast':
+                title = "Broadcast";
+                message = `Broadcast to all connections using ${methodName}`;
+                break;
+            default:
+                title = "WebSocket";
+                message = `Direct WebSocket message using ${methodName}`;
+        }
 
-        MeterService.add(0, wtx.elapsed, 0, SecurityMaster.PCODE, SecurityMaster.OKIND, SecurityMaster.OID);
+        AsyncSender.send_packet(PacketTypeEnum.TX_MSG, ctx, [title, '', message]);
+    } catch (e) {
+        Logger.printError('WHATAP-220', 'WebSocket send message error', e, false);
+        throw e;
+    }
+};
 
-        profile.oid = SecurityMaster.OID;
-        profile.service = wtx;
+WebsocketObserver.prototype.__sendWebSocketEvent = function(ctx, connection, data, emitType, remoteAddress) {
+    try {
+        var start_time = Date.now();
+        ctx.start_time = start_time;
+        ctx.elapsed = 0;
+        ctx.error = 0;
+
+        // IP 주소 및 포트 처리
+        var ipString = "0.0.0.0";
+        var port = 0;
+
+        if (remoteAddress) {
+            const ipInfo = this.getProcessedIp(remoteAddress);
+            if (ipInfo) {
+                ipString = ipInfo.host;
+                ctx.remoteIp = ipInfo.ipInt;
+
+                // 포트 정보 추출
+                if (connection.socket && connection.socket.remotePort) {
+                    port = Number(connection.socket.remotePort);
+                } else if (remoteAddress.includes(':')) {
+                    const parts = remoteAddress.split(':');
+                    if (parts.length > 1) {
+                        const portStr = parts[parts.length - 1];
+                        const parsedPort = parseInt(portStr, 10);
+                        if (!isNaN(parsedPort)) {
+                            port = parsedPort;
+                        }
+                    }
+                }
+            }
+        }
+
+        var elapsed = Date.now() - start_time;
+        ctx.elapsed = elapsed;
+
+        let datas = [ipString, port, elapsed, 0];
+        AsyncSender.send_packet(PacketTypeEnum.TX_WEB_SOCKET, ctx, datas);
+    } catch (e) {
+        Logger.printError('WHATAP-221', 'WebSocket send event error', e, false);
+        throw e;
+    }
+};
 
-        // 트랜잭션 컨텍스트 종료 (메모리 누수 방지)
-        TraceContextManager.end(ctx._id);
+WebsocketObserver.prototype.__endTransaction = function(error, ctx) {
+    try {
+        if (error) {
+            TraceContextManager.end(ctx != null ? ctx.id : null);
+            ctx = null;
+            return;
+        }
 
-        // 프로파일 데이터 버퍼에 추가 (비동기 처리 최적화)
-        this.profileBuffer.push({
-            ctx: ctx,
-            profile: profile,
-            timestamp: Date.now()
-        });
+        if (ctx == null || TraceContextManager.isExist(ctx.id) === false)
+            return;
+
+        ctx.start_time = Date.now();
+        let datas = [
+            os.hostname(), // hostname
+            ctx.service_name,
+            0,  // mtid
+            0,  // mdepth
+            0,  // mcaller_txid
+            0,  // mcaller_pcode
+            '', // mcaller_spec
+            String(0), // mcaller_url_hash
+            200
+        ];
+        ctx.elapsed = Date.now() - ctx.start_time;
+        AsyncSender.send_packet(PacketTypeEnum.TX_END, ctx, datas);
+        TraceContextManager.end(ctx.id);
 
     } catch (e) {
-        Logger.printError('WHATAP-615', 'Websocket end transaction error', e, false);
-        // 에러 발생 시에도 컨텍스트 정리
-        TraceContextManager.end(ctx._id);
+        Logger.printError('WHATAP-222', 'WebSocket end transaction error', e, false);
+        TraceContextManager.end(ctx.id);
         ctx = null;
     }
 };
 
-// 컨텍스트 초기화 최적화
-function initCtx(socket, args, shouldProfileResource) {
+WebsocketObserver.prototype.__initCtx = function(connection, data, emitType, contextInfo) {
     const ctx = TraceContextManager.start();
-    if (!ctx) {return;}
+    if (!ctx) return null;
 
     var remote_addr;
-    const address = socket.remoteAddress;
-    if(address && address.includes(':')){
-        remote_addr = address.substring(address.lastIndexOf(':')+1);
+    var remoteAddress = contextInfo.remoteAddress;
+
+    if (remoteAddress) {
+        if(remoteAddress && remoteAddress.includes(':')){
+            remote_addr = remoteAddress.substring(remoteAddress.lastIndexOf(':')+1);
+        }
     }
 
-    // 리소스 측정은 샘플링된 트랜잭션에만 수행 (CPU 사용 감소)
-    ctx.shouldProfileResource = shouldProfileResource;
-    if (shouldProfileResource) {
-        ctx.start_malloc = ResourceProfile.getUsedHeapSize();
-        ctx.start_cpu = ResourceProfile.getCPUTime();
+    ctx.service_name = "/websocket";
+
+    if (remote_addr) {
+        remote_addr = IPUtil.checkIp4(remote_addr);
+        ctx.remoteIp = IPUtil.stringToInt(remote_addr);
+        ctx.userid = ctx.remoteIp;
     }
 
-    remote_addr = IPUtil.checkIp4(remote_addr);
-    ctx.remoteIp = IPUtil.stringToInt(remote_addr);
-    ctx.userid = Long.fromNumber(ctx.remoteIp);
-    MeterUsers.add(ctx.userid);
+    // 기본값 설정
+    ctx.userAgentString = '';
+    ctx.referer = '';
+    ctx.status = 200;
 
     return ctx;
-}
+};
 
 exports.WebsocketObserver = WebsocketObserver;

package/lib/pack/counter-pack.js

@@ -11,8 +11,6 @@ var Pack = require('./pack'),
     IntMapValue = require('./../value/int-map-value'),
     IntValue = require('./../value/int-value'),
     FloatValue = require('./../value/float-value'),
-    NETSTAT = require('./netstat'),
-    WEBSOCKET = require('./websocket'),
     IntIntMap = require('../util/intint-map'),
     IntKeyLinkedMap = require('../util/intkey-linkedmap'),
     LongKeyLinkedMap = require('../util/longkey-linkedmap'),
@@ -73,7 +71,6 @@ function CounterPack() {
 
     this.db_num_active = null;
     this.db_num_idle = null;
-    this.netstat = null;
 
     this.host_ip = 0;
     this.proc_fd = 0;