whatap 0.5.11 → 0.5.13

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

@@ -21,27 +21,121 @@ const MeterUsers = require("../counter/meter/meter-users");
 const MeterService        = require('../counter/meter/meter-service').MeterService;
 const shimmer = require('../core/shimmer');
 
-var trace_background_socket_enabled = conf.getProperty('trace_background_socket_enabled', true);
+// 설정을 객체로 통합하여 관리 (참조 성능 향상)
+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, // 리소스 프로파일링을 10%만 수행
+    profile_batch_size: 20,      // 프로파일 배치 처리 크기
+    flush_interval: 500          // 프로파일 플러시 간격 (ms)
+};
+
+// 설정 변경 감지를 단일 리스너로 통합
 conf.on('trace_background_socket_enabled', function (newProps) {
-    trace_background_socket_enabled = newProps;
-})
-var trace_sampling_enabled = conf.getProperty('trace_sampling_enabled', true);
+    config.trace_background_socket_enabled = newProps;
+});
+
 conf.on('trace_sampling_enabled', function (newProps) {
-    trace_sampling_enabled = newProps;
-})
-var trace_sampling_tps = conf.getProperty('trace_sampling_tps', 1000);
+    config.trace_sampling_enabled = newProps;
+});
+
 conf.on('trace_sampling_tps', function (newProps) {
-    trace_sampling_tps = newProps;
-})
+    config.trace_sampling_tps = newProps;
+});
 
 var SocketIOObserver = function(agent){
     this.agent = agent;
     this.packages = ['socket.io'];
+
+    this.socketCounter = {
+        count: 0,
+        start_time: Date.now(),
+        window_size: 5000,
+
+        checkSampling: function() {
+            const now = Date.now();
+            if ((now - this.start_time) >= this.window_size) {
+                this.start_time = now;
+                this.count = 0;
+                return true;
+            }
+
+            this.count++;
+            return this.count <= config.trace_sampling_tps;
+        }
+    };
+
+    // 프로파일 데이터 버퍼링 (배치 처리)
+    this.profileBuffer = [];
+
+    // 주기적 플러시 설정
+    setInterval(() => this.flushProfileBuffer(), config.flush_interval);
+
+    // IP 주소 캐싱 (성능 최적화)
+    this.ipCache = new Map();
 };
 
-var socket_count = {
-    count: 0,
-    start_time: null
+SocketIOObserver.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', 'Socket.io buffer flush error', e, false);
+        }
+    });
+};
+
+// IP 주소 처리 최적화 함수
+SocketIOObserver.prototype.getProcessedIp = function(address) {
+    if (!address) return null;
+
+    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;
 };
 
 SocketIOObserver.prototype.inject = function (mod, moduleName) {
@@ -57,15 +151,34 @@ SocketIOObserver.prototype.inject = function (mod, moduleName) {
         return function (event, listener) {
             if (event === 'connection') {
                 return original.call(this, event, function (socket) {
-                    shimmer.wrap(socket, 'emit', function (origEmit) {
-                        return function (emitEvent, ...args) {
-                            if (trace_background_socket_enabled) {
-                                self.__handleSocketEmitEvent(socket, emitEvent, args);
+                    // 효율적인 이벤트 핸들러 래핑
+                    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);
                             return origEmit.apply(this, [emitEvent, ...args]);
                         };
-                    });
+
+                        // 원본 함수 속성 유지
+                        Object.defineProperties(emitFn, {
+                            length: { value: origEmit.length },
+                            name: { value: origEmit.name }
+                        });
+
+                        return emitFn;
+                    };
+
+                    // emit 함수에만 래핑 적용 (불필요한 래핑 제거)
+                    if (typeof socket.emit === 'function' && !socket.emit.__wrapped__) {
+                        const original = socket.emit;
+                        socket.emit = wrappedEmit(original);
+                        socket.emit.__wrapped__ = true;
+                    }
 
                     return listener.apply(this, [socket]);
                 });
@@ -76,59 +189,57 @@ SocketIOObserver.prototype.inject = function (mod, moduleName) {
     });
 };
 
+// 소켓 이벤트 처리 최적화 (CPU 및 메모리 사용 감소)
 SocketIOObserver.prototype.__handleSocketEmitEvent = function(socket, event, args) {
-    if (trace_sampling_enabled) {
-        var now = Date.now();
-        // if ((now - socket_count.start_time) > 1000) {
-        //     socket_count.start_time = now;
-        //     socket_count.count = 0;
-        // }
-        if (!socket_count.start_time || (now - socket_count.start_time) >= 1000) {
-            socket_count.start_time = now;
-            socket_count.count = 0;
-        }
-
-        socket_count.count++;
-        if (socket_count.count > trace_sampling_tps) {
-            MeterService.add(0, 1, 0, SecurityMaster.PCODE, SecurityMaster.OKIND, SecurityMaster.OID);
-            return;
-        }
+    // 빠른 샘플링 체크 (조기 반환으로 성능 향상)
+    if (config.trace_sampling_enabled && !this.socketCounter.checkSampling()) {
+        MeterService.add(0, 1, 0, SecurityMaster.PCODE, SecurityMaster.OKIND, SecurityMaster.OID);
+        return;
     }
 
-    TraceContextManager._asyncLocalStorage.run(initCtx(socket, args), () => {
+    // 리소스 프로파일링 샘플링 (전체 이벤트의 일부만 측정)
+    const shouldProfileResource = Math.random() < config.resource_sampling_rate;
+
+    // 컨텍스트 생성 및 실행
+    TraceContextManager._asyncLocalStorage.run(this.__initCtx(socket, args, shouldProfileResource), () => {
         try {
             var ctx = TraceContextManager._asyncLocalStorage.getStore();
             if (!ctx) return;
 
-            ctx.footprint('Socket Emit Event: ' + event);
-
-            var host;
-            if (socket.conn && socket.conn.remoteAddress && socket.conn.remoteAddress.includes(':')) {
-                host = socket.conn.remoteAddress.substring(socket.conn.remoteAddress.lastIndexOf(':') + 1);
+            // IP 주소 처리 최적화
+            var host = null;
+            if (socket.conn && socket.conn.remoteAddress) {
+                const ipInfo = this.getProcessedIp(socket.conn.remoteAddress);
+                if (ipInfo) {
+                    host = ipInfo.host;
+                    // 이미 처리된 IP 바이트 사용
+                    var step = new SocketStep();
+                    step.start_time = ctx.getElapsedTime();
+                    step.ipaddr = ipInfo.ipBytes;
+                    step.elapsed = 0; // 즉시 종료 (측정 최소화)
+                    ctx.profile.push(step);
+                }
             }
 
-            ctx.socket_connecting = true;
-            ctx.footprint('Socket Connecting: ' + host);
-
-            var step = new SocketStep();
-            step.start_time = ctx.getElapsedTime();
-            step.ipaddr = Buffer.from(IPUtil.stringToBytes(host));
-            // step.port = port;
-
-            ctx.socket_connecting = false;
-            step.elapsed = ctx.getElapsedTime() - step.start_time;
-            ctx.profile.push(step)
-
+            // 트랜잭션 종료 및 데이터 전송
             this.__endTransaction(null, ctx);
 
         } catch (e) {
-            Logger.printError('WHATAP-616', 'socket.io emit transaction error..', e, false);
+            Logger.printError('WHATAP-616', 'socket.io emit transaction error', e, false);
+
+            // 에러 시 컨텍스트 정리 (메모리 누수 방지)
+            var ctx = TraceContextManager._asyncLocalStorage.getStore();
+            if (ctx) {
+                TraceContextManager.end(ctx._id);
+            }
         }
     });
 };
 
+// 트랜잭션 종료 최적화 (배치 처리 및 메모리 사용 감소)
 SocketIOObserver.prototype.__endTransaction = function(error, ctx) {
     try {
+        // 기본 성능 데이터 수집
         var profile = new ProfilePack();
         var wtx = new TxRecord();
         wtx.endTime = DateUtil.currentTime();
@@ -139,50 +250,78 @@ SocketIOObserver.prototype.__endTransaction = function(error, ctx) {
 
         wtx.seq = ctx.txid;
         wtx.service = ctx.service_hash;
-        wtx.cpuTime = ResourceProfile.getCPUTime() - ctx.start_cpu;
-        wtx.malloc = ResourceProfile.getUsedHeapSize()-ctx.start_malloc;
-        if(wtx.malloc < 0) { wtx.malloc = 0; }
-        wtx.status = 2;
 
+        // 리소스 프로파일링은 샘플링된 경우에만 수행
+        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;
+        }
+
+        wtx.status = 2;
         wtx.ipaddr = ctx.remoteIp;
 
+        // 기본 측정 데이터 기록
         MeterService.add(0, wtx.elapsed, 0, SecurityMaster.PCODE, SecurityMaster.OKIND, SecurityMaster.OID);
 
         profile.oid = SecurityMaster.OID;
         profile.service = wtx;
 
-        setTimeout(function () {
-            DataProfileAgent.sendProfile(ctx, profile, false);
-            TraceContextManager.end(ctx._id);
-            ctx = null;
-        }, 100);
+        // 컨텍스트 ID 보존 후 컨텍스트 종료 (메모리 누수 방지)
+        const ctxId = ctx._id;
+        TraceContextManager.end(ctxId);
+
+        // 프로파일 데이터 버퍼에 추가 (비동기 처리 최적화)
+        this.profileBuffer.push({
+            ctx: ctx,
+            profile: profile,
+            timestamp: Date.now()
+        });
+
+        if (this.profileBuffer.length > 1000) {
+            // 가장 오래된 항목부터 제거
+            this.profileBuffer = this.profileBuffer.slice(-500);
+        }
+
     } catch (e) {
-        Logger.printError('WHATAP-615', 'Socket.io end transaction error..', e, false);
+        Logger.printError('WHATAP-615', 'Socket.io end transaction error', e, false);
+        // 에러 시에도 컨텍스트 정리
         TraceContextManager.end(ctx._id);
         ctx = null;
     }
-
 };
 
-function initCtx(socket, args) {
+// 컨텍스트 초기화 최적화
+SocketIOObserver.prototype.__initCtx = function(socket, args, shouldProfileResource) {
     const ctx = TraceContextManager.start();
     if (!ctx) {return;}
 
     var remote_addr;
-    const address = socket.conn.remoteAddress;
-    if(address && address.includes(':')){
-        remote_addr = address.substring(address.lastIndexOf(':')+1);
+    if (socket.conn && socket.conn.remoteAddress) {
+        const address = socket.conn.remoteAddress;
+        if(address && address.includes(':')){
+            remote_addr = address.substring(address.lastIndexOf(':')+1);
+        }
     }
 
-    ctx.start_malloc = ResourceProfile.getUsedHeapSize();
-    ctx.start_cpu = ResourceProfile.getCPUTime();
+    // 리소스 측정은 샘플링된 경우에만 수행
+    ctx.shouldProfileResource = shouldProfileResource;
+    if (shouldProfileResource) {
+        ctx.start_malloc = ResourceProfile.getUsedHeapSize();
+        ctx.start_cpu = ResourceProfile.getCPUTime();
+    }
 
-    remote_addr=IPUtil.checkIp4(remote_addr);
-    ctx.remoteIp = IPUtil.stringToInt(remote_addr);
-    ctx.userid = Long.fromNumber(ctx.remoteIp);
-    MeterUsers.add(ctx.userid);
+    if (remote_addr) {
+        remote_addr = IPUtil.checkIp4(remote_addr);
+        ctx.remoteIp = IPUtil.stringToInt(remote_addr);
+        ctx.userid = Long.fromNumber(ctx.remoteIp);
+        MeterUsers.add(ctx.userid);
+    }
 
     return ctx;
-}
+};
 
 exports.SocketIOObserver = SocketIOObserver;