whatap 1.0.1 → 1.0.2

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

@@ -5,21 +5,32 @@
  */
 
 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 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 MeterUsers = require("../counter/meter/meter-users");
+const MeterService        = require('../counter/meter/meter-service').MeterService;
 const shimmer = require('../core/shimmer');
-const AsyncSender = require('../udp/async_sender');
-const PacketTypeEnum = require('../udp/packet_type_enum');
-const os = require('os');
+const MessageStep = require('../step/message-step');
+const HashUtil = require('../util/hashutil');
 
 // 설정을 객체로 통합하여 관리 (참조 성능 향상)
 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%만 수행
+    resource_sampling_rate: 0.1, // 리소스 프로파일링을 10%만 수행
+    profile_batch_size: 20,      // 프로파일 배치 처리 크기
+    flush_interval: 500          // 프로파일 플러시 간격 (ms)
 };
 
 // 설정 변경 감지를 단일 리스너로 통합
@@ -57,10 +68,48 @@ var SocketIOObserver = function(agent){
         }
     };
 
+    // 프로파일 데이터 버퍼링 (배치 처리)
+    this.profileBuffer = [];
+
+    // 주기적 플러시 설정
+    setInterval(() => this.flushProfileBuffer(), config.flush_interval);
+
     // IP 주소 캐싱 (성능 최적화)
     this.ipCache = new Map();
 };
 
+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;
@@ -91,56 +140,6 @@ SocketIOObserver.prototype.getProcessedIp = function(address) {
     return result;
 };
 
-// 에러 처리 함수
-function handleSocketError(ctx, err) {
-    if (!err) return null;
-
-    try {
-        var errorClass = err.code || err.name || err.constructor?.name || 'SocketIOError';
-        var errorMessage = err.message || 'socket.io 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 (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-227', 'Error handling Socket.IO error', e, false);
-    }
-    return null;
-}
-
 SocketIOObserver.prototype.inject = function (mod, moduleName) {
     if (mod.__whatap_observe__) {
         return;
@@ -150,6 +149,33 @@ SocketIOObserver.prototype.inject = function (mod, moduleName) {
 
     var self = this;
 
+    // 공통 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;
@@ -362,164 +388,141 @@ SocketIOObserver.prototype.inject = function (mod, moduleName) {
     if (mod.Server && mod.Server.prototype) {
         wrapSocketIOEvents(mod.Server.prototype);
     }
+
+    // 3. 직접 모듈 래핑 (일부 버전에서 필요할 수 있음)
+    // if (typeof mod.on === 'function') {
+    //     wrapSocketIOEvents(mod);
+    // }
 };
 
+// 소켓 이벤트 처리 최적화 (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);
         return;
     }
 
-    TraceContextManager._asyncLocalStorage.run(this.__initCtx(socket, args, emitType, contextInfo), () => {
-        var ctx = TraceContextManager._asyncLocalStorage.getStore();
-        if (!ctx) {
-            return;
-        }
+    // 리소스 프로파일링 샘플링 (전체 이벤트의 일부만 측정)
+    const shouldProfileResource = Math.random() < config.resource_sampling_rate;
 
+    // 컨텍스트 생성 및 실행
+    TraceContextManager._asyncLocalStorage.run(this.__initCtx(socket, args, shouldProfileResource, emitType, contextInfo), () => {
         try {
-            ctx.service_name = "/socket.io";
-            let hostname = '';
-
-            let datas = [
-                hostname,
-                ctx.service_name,
-                ctx.remoteIp || 0,
-                ctx.userAgentString || '',
-                ctx.referer || '',
-                String(ctx.userid || 0),
-                String(false), // isStaticContents
-                ''
-            ];
-
-            AsyncSender.send_packet(PacketTypeEnum.TX_START, ctx, datas);
-
-            this.__sendSocketMessage(ctx, emitType, contextInfo);
-            this.__sendSocketEvent(ctx, socket, event, args, emitType, contextInfo);
+            var ctx = TraceContextManager._asyncLocalStorage.getStore();
+            if (!ctx) return;
+
+            // IP 주소 처리 최적화
+            var host = null;
+            var remoteAddress = contextInfo.remoteAddress || (socket && socket.conn && socket.conn.remoteAddress);
+
+            if (remoteAddress) {
+                const ipInfo = this.getProcessedIp(remoteAddress);
+                if (ipInfo) {
+                    host = ipInfo.host;
+                    // 이미 처리된 IP 바이트 사용
+                    var step = new SocketStep();
+                    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);
+            }
+
+            // 트랜잭션 종료 및 데이터 전송
             this.__endTransaction(null, ctx);
+
         } catch (e) {
-            Logger.printError('WHATAP-228', 'socket.io emit transaction error', e, false);
+            Logger.printError('WHATAP-616', 'socket.io emit transaction error', e, false);
 
-            var errorInfo = handleSocketError(ctx, e);
-            this.__endTransaction(errorInfo, ctx);
+            // 에러 시 컨텍스트 정리 (메모리 누수 방지)
+            var ctx = TraceContextManager._asyncLocalStorage.getStore();
+            if (ctx) {
+                TraceContextManager.end(ctx._id);
+            }
         }
     });
 };
 
-SocketIOObserver.prototype.__sendSocketMessage = function(ctx, emitType, contextInfo) {
+// 트랜잭션 종료 최적화 (배치 처리 및 메모리 사용 감소)
+SocketIOObserver.prototype.__endTransaction = function(error, ctx) {
     try {
-        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";
+        // 기본 성능 데이터 수집
+        var profile = new ProfilePack();
+        var wtx = new TxRecord();
+        wtx.endTime = DateUtil.currentTime();
+        profile.time  = wtx.endTime;
+        wtx.elapsed = ctx.getElapsedTime();
+
+        // 서비스 이름에 브로드캐스트 타입 정보 추가
+        let serviceName = ctx.service_name;
+        DataTextAgent.SERVICE.add(ctx.service_hash, serviceName);
+
+        wtx.seq = ctx.txid;
+        wtx.service = ctx.service_hash;
+
+        // 리소스 프로파일링은 샘플링된 경우에만 수행
+        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;
         }
 
-        AsyncSender.send_packet(PacketTypeEnum.TX_MSG, ctx, [title, '', message]);
-    } catch (e) {
-        Logger.printError('WHATAP-229', 'Socket.io send message error', e, false);
-        throw e;
-    }
-};
+        wtx.status = 2;
+        wtx.ipaddr = ctx.remoteIp;
 
-SocketIOObserver.prototype.__sendSocketEvent = function(ctx, socket, event, args, emitType, contextInfo) {
-    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;
-        var remoteAddress = contextInfo.remoteAddress || (socket && socket.conn && socket.conn.remoteAddress);
-
-        if (remoteAddress) {
-            const ipInfo = this.getProcessedIp(remoteAddress);
-            if (ipInfo) {
-                ipString = ipInfo.host;
-                ctx.remoteIp = ipInfo.ipInt;
-
-                if (socket && socket.conn && socket.conn.remotePort) {
-                    port = Number(socket.conn.remotePort);
-                } else if (remoteAddress.includes(':')) {
-                    // remoteAddress에서 포트 추출 시도
-                    const parts = remoteAddress.split(':');
-                    if (parts.length > 1) {
-                        const portStr = parts[parts.length - 1];
-                        const parsedPort = parseInt(portStr, 10);
-                        if (!isNaN(parsedPort)) {
-                            port = parsedPort;
-                        }
-                    }
-                }
-            }
-        }
+        // 기본 측정 데이터 기록
+        MeterService.add(0, wtx.elapsed, 0, SecurityMaster.PCODE, SecurityMaster.OKIND, SecurityMaster.OID);
 
-        var elapsed = Date.now() - start_time;
-        ctx.elapsed = elapsed;
+        profile.oid = SecurityMaster.OID;
+        profile.service = wtx;
 
-        var datas = [ipString, port, elapsed, 0];
-        AsyncSender.send_packet(PacketTypeEnum.TX_WEB_SOCKET, ctx, datas);
-    } catch (e) {
-        Logger.printError('WHATAP-230', 'Socket.io send event error', e, false);
-        throw e;
-    }
-};
+        // 컨텍스트 ID 보존 후 컨텍스트 종료 (메모리 누수 방지)
+        const ctxId = ctx._id;
+        TraceContextManager.end(ctxId);
 
-SocketIOObserver.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);
+        if (this.profileBuffer.length > 1000) {
+            // 가장 오래된 항목부터 제거
+            this.profileBuffer = this.profileBuffer.slice(-500);
+        }
 
     } catch (e) {
-        Logger.printError('WHATAP-231', 'Socket.io end transaction error', e, false);
-        TraceContextManager.end(ctx.id);
+        Logger.printError('WHATAP-615', 'Socket.io end transaction error', e, false);
+        // 에러 시에도 컨텍스트 정리
+        TraceContextManager.end(ctx._id);
         ctx = null;
     }
 };
 
-SocketIOObserver.prototype.__initCtx = function(socket, args, emitType, contextInfo) {
+// 컨텍스트 초기화 최적화 - broadcast 정보 추가
+SocketIOObserver.prototype.__initCtx = function(socket, args, shouldProfileResource, emitType, contextInfo) {
     const ctx = TraceContextManager.start();
-    if (!ctx) return null;
+    if (!ctx) {return;}
 
     var remote_addr;
     var remoteAddress = contextInfo.remoteAddress || (socket && socket.conn && socket.conn.remoteAddress);
@@ -531,18 +534,54 @@ SocketIOObserver.prototype.__initCtx = function(socket, args, emitType, contextI
     }
 
     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) {
+        ctx.start_malloc = ResourceProfile.getUsedHeapSize();
+        ctx.start_cpu = ResourceProfile.getCPUTime();
+    }
 
     if (remote_addr) {
         remote_addr = IPUtil.checkIp4(remote_addr);
         ctx.remoteIp = IPUtil.stringToInt(remote_addr);
-        ctx.userid = ctx.remoteIp;
+        ctx.userid = Long.fromNumber(ctx.remoteIp);
+        MeterUsers.add(ctx.userid);
     }
 
-    // 기본값 설정
-    ctx.userAgentString = '';
-    ctx.referer = '';
-    ctx.status = 200;
-
     return ctx;
 };
 

package/lib/observers/stream-observer.js

@@ -0,0 +1,19 @@
+/**
+ * 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 StreamObserver = function(agent) {
+    this.agent = agent;
+    this.aop = agent.aop;
+    this.packages = ['stream'];
+};
+StreamObserver.prototype.inject = function (mod, moduleName) {
+    if(mod.__whatap_observe__) { return; }
+    mod.__whatap_observe__ = true;
+    
+};
+
+exports.StreamObserver = StreamObserver;