whatap 0.5.26 → 1.0.0-canary.0

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

@@ -5,32 +5,21 @@
  */
 
 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 MessageStep = require('../step/message-step');
-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, // 리소스 프로파일링을 10%만 수행
-    profile_batch_size: 20,      // 프로파일 배치 처리 크기
-    flush_interval: 500          // 프로파일 플러시 간격 (ms)
+    resource_sampling_rate: 0.1 // 리소스 프로파일링을 10%만 수행
 };
 
 // 설정 변경 감지를 단일 리스너로 통합
@@ -68,48 +57,10 @@ 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;
@@ -140,41 +91,64 @@ SocketIOObserver.prototype.getProcessedIp = function(address) {
     return result;
 };
 
-SocketIOObserver.prototype.inject = function (mod, moduleName) {
-    if (mod.__whatap_observe__) {
-        return;
-    }
-    mod.__whatap_observe__ = true;
-    Logger.initPrint("SocketIOObserver");
+// 에러 처리 함수
+function handleSocketError(ctx, err) {
+    if (!err) return null;
 
-    var self = this;
+    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");
+        }
 
-    // 공통 emit 래핑 함수
-    const wrapEmitFunction = function(target, emitType, getContextInfo) {
-        if (!target || typeof target.emit !== 'function' || target.emit.__wrapped__) {
-            return false;
+        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;
         }
 
-        const originalEmit = target.emit;
-        target.emit = function(event, ...args) {
-            if (!config.trace_background_socket_enabled) {
-                return originalEmit.apply(this, [event, ...args]);
+        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);
             }
 
-            const contextInfo = getContextInfo ? getContextInfo.call(this) : {};
-            self.__handleSocketEmitEvent(this, event, args, emitType, contextInfo);
-            return originalEmit.apply(this, [event, ...args]);
-        };
+            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;
+}
 
-        // 원본 함수 속성 보존
-        Object.defineProperties(target.emit, {
-            length: { value: originalEmit.length },
-            name: { value: originalEmit.name },
-            __wrapped__: { value: true }
-        });
+SocketIOObserver.prototype.inject = function (mod, moduleName) {
+    if (mod.__whatap_observe__) {
+        return;
+    }
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("SocketIOObserver");
 
-        return true;
-    };
+    var self = this;
 
     const wrapSocketIOEvents = function(target) {
         if (!target || typeof target.on !== 'function') {
@@ -388,141 +362,164 @@ 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;
     }
 
-    // 리소스 프로파일링 샘플링 (전체 이벤트의 일부만 측정)
-    const shouldProfileResource = Math.random() < config.resource_sampling_rate;
+    TraceContextManager._asyncLocalStorage.run(this.__initCtx(socket, args, emitType, contextInfo), () => {
+        var ctx = TraceContextManager._asyncLocalStorage.getStore();
+        if (!ctx) {
+            return;
+        }
 
-    // 컨텍스트 생성 및 실행
-    TraceContextManager._asyncLocalStorage.run(this.__initCtx(socket, args, shouldProfileResource, emitType, contextInfo), () => {
         try {
-            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);
-            }
-
-            // 트랜잭션 종료 및 데이터 전송
+            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);
             this.__endTransaction(null, ctx);
-
         } catch (e) {
-            Logger.printError('WHATAP-616', 'socket.io emit transaction error', e, false);
+            Logger.printError('WHATAP-228', 'socket.io emit transaction error', e, false);
 
-            // 에러 시 컨텍스트 정리 (메모리 누수 방지)
-            var ctx = TraceContextManager._asyncLocalStorage.getStore();
-            if (ctx) {
-                TraceContextManager.end(ctx._id);
-            }
+            var errorInfo = handleSocketError(ctx, e);
+            this.__endTransaction(errorInfo, ctx);
         }
     });
 };
 
-// 트랜잭션 종료 최적화 (배치 처리 및 메모리 사용 감소)
-SocketIOObserver.prototype.__endTransaction = function(error, ctx) {
+SocketIOObserver.prototype.__sendSocketMessage = function(ctx, emitType, contextInfo) {
     try {
-        // 기본 성능 데이터 수집
-        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;
+        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";
         }
 
-        wtx.status = 2;
-        wtx.ipaddr = ctx.remoteIp;
-
-        // 기본 측정 데이터 기록
-        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-229', 'Socket.io send message error', e, false);
+        throw e;
+    }
+};
 
-        profile.oid = SecurityMaster.OID;
-        profile.service = wtx;
+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;
+                        }
+                    }
+                }
+            }
+        }
 
-        // 컨텍스트 ID 보존 후 컨텍스트 종료 (메모리 누수 방지)
-        const ctxId = ctx._id;
-        TraceContextManager.end(ctxId);
+        var elapsed = Date.now() - start_time;
+        ctx.elapsed = elapsed;
 
-        // 프로파일 데이터 버퍼에 추가 (비동기 처리 최적화)
-        this.profileBuffer.push({
-            ctx: ctx,
-            profile: profile,
-            timestamp: Date.now()
-        });
+        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;
+    }
+};
 
-        if (this.profileBuffer.length > 1000) {
-            // 가장 오래된 항목부터 제거
-            this.profileBuffer = this.profileBuffer.slice(-500);
+SocketIOObserver.prototype.__endTransaction = function(error, ctx) {
+    try {
+        if (error) {
+            TraceContextManager.end(ctx != null ? ctx.id : null);
+            ctx = null;
+            return;
         }
 
+        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', 'Socket.io end transaction error', e, false);
-        // 에러 시에도 컨텍스트 정리
-        TraceContextManager.end(ctx._id);
+        Logger.printError('WHATAP-231', 'Socket.io end transaction error', e, false);
+        TraceContextManager.end(ctx.id);
         ctx = null;
     }
 };
 
-// 컨텍스트 초기화 최적화 - broadcast 정보 추가
-SocketIOObserver.prototype.__initCtx = function(socket, args, shouldProfileResource, emitType, contextInfo) {
+SocketIOObserver.prototype.__initCtx = function(socket, args, emitType, contextInfo) {
     const ctx = TraceContextManager.start();
-    if (!ctx) {return;}
+    if (!ctx) return null;
 
     var remote_addr;
     var remoteAddress = contextInfo.remoteAddress || (socket && socket.conn && socket.conn.remoteAddress);
@@ -534,54 +531,18 @@ SocketIOObserver.prototype.__initCtx = function(socket, args, shouldProfileResou
     }
 
     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 = Long.fromNumber(ctx.remoteIp);
-        MeterUsers.add(ctx.userid);
+        ctx.userid = ctx.remoteIp;
     }
 
+    // 기본값 설정
+    ctx.userAgentString = '';
+    ctx.referer = '';
+    ctx.status = 200;
+
     return ctx;
 };