whatap 1.0.1 → 1.0.2

package/lib/observers/websocket-observer.js

@@ -4,28 +4,36 @@
  * 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 DateUtil = require('../util/dateutil');
-const SecurityMaster = require('../net/security-master');
+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 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 // 리소스 프로파일링을 10%만 수행
+    resource_sampling_rate: 0.1,
+    profile_batch_size: 20,
+    flush_interval: 500
 };
 
-// 설정 변경 감지를 단일 리스너로 통합
 conf.on('trace_background_socket_enabled', function (newProps) {
     config.trace_background_socket_enabled = newProps;
 });
@@ -60,89 +68,50 @@ var WebsocketObserver = function(agent){
         }
     };
 
-    // IP 주소 캐싱 (성능 최적화)
-    this.ipCache = new Map();
-};
-
-// IP 주소 처리 최적화 함수
-WebsocketObserver.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);
-    }
+    this.profileBuffer = [];
 
-    host = IPUtil.checkIp4(host);
-    const ipInt = IPUtil.stringToInt(host);
-    const ipBytes = Buffer.from(IPUtil.stringToBytes(host));
+    // 주기적 플러시 설정
+    setInterval(() => this.flushProfileBuffer(), config.flush_interval);
 
-    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;
+    this.ipCache = new Map();
 };
 
-// 에러 처리 함수
-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");
+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);
         }
+    });
 
-        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-218', 'Error handling WebSocket error', e, false);
+    if (this.profileBuffer.length > 1000) {
+        // 가장 오래된 항목부터 제거
+        this.profileBuffer = this.profileBuffer.slice(-500);
     }
-    return null;
-}
+};
 
 WebsocketObserver.prototype.inject = function (mod, moduleName) {
     if (mod.__whatap_observe__) {
@@ -152,267 +121,172 @@ WebsocketObserver.prototype.inject = function (mod, moduleName) {
     Logger.initPrint("WebsocketObserver");
 
     var self = this;
+    var aop = self.agent.aop;
 
-    // 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);
-                };
-            });
-
-            return true;
-        };
+    // IP 주소 변환 캐시 (동일한 IP 변환 작업 최소화)
+    const ipCache = new Map();
 
-        wrapWebSocketServer(mod.server.prototype);
-    }
+    function getProcessedIp(remoteAddress) {
+        if (!remoteAddress) return null;
 
-    // 2. WebSocketConnection 직접 래핑 (구버전 호환성)
-    if (mod.connection && mod.connection.prototype) {
-        self.__wrapWebSocketConnection(mod.connection.prototype, null);
-    }
-};
+        if (ipCache.has(remoteAddress)) {
+            return ipCache.get(remoteAddress);
+        }
 
-WebsocketObserver.prototype.__wrapWebSocketConnection = function(connection, request) {
-    var self = this;
+        let host = remoteAddress;
+        if (remoteAddress.includes(':')) {
+            host = remoteAddress.substring(remoteAddress.lastIndexOf(':') + 1);
+        }
 
-    if (!connection) return;
+        host = IPUtil.checkIp4(host);
+        const ipInt = IPUtil.stringToInt(host);
+        const ipBytes = Buffer.from(IPUtil.stringToBytes(host));
 
-    // send, sendUTF, sendBytes 메서드들 래핑
-    const methods = ['send', 'sendUTF', 'sendBytes'];
+        const result = { host, ipInt, ipBytes };
+        ipCache.set(remoteAddress, result);
 
-    methods.forEach(function(methodName) {
-        if (typeof connection[methodName] === 'function' && !connection[methodName].__whatap_wrapped__) {
-            const originalMethod = connection[methodName];
+        return result;
+    }
 
-            connection[methodName] = function(data) {
-                if (!config.trace_background_socket_enabled) {
-                    return originalMethod.apply(this, arguments);
-                }
+    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;
+            }
 
-                // 빠른 샘플링 체크 (조기 반환으로 성능 향상)
-                if (config.trace_sampling_enabled && !self.socketCounter.checkSampling()) {
-                    return originalMethod.apply(this, arguments);
+            if(config.trace_sampling_enabled) {
+                if(!self.socketCounter.checkSampling()) {
+                    MeterService.add(0, 1, 0, 0, 0, 0);
+                    return;
                 }
+            }
 
-                // 브로드캐스트 감지 시도
-                const emitType = self.__detectBroadcastType();
+            var protocol = obj.protocol;
+            var remoteAddress = obj.remoteAddress;
 
-                const remoteAddress = this.remoteAddress ||
-                    (this.socket ? this.socket.remoteAddress : null) ||
-                    (request && request.remoteAddress ? request.remoteAddress : null);
+            // 리소스 프로파일링 최적화 - 모든 트랜잭션 대신 샘플링
+            const shouldProfileResource = Math.random() < config.resource_sampling_rate; // 10%만 리소스 프로파일링
 
-                TraceContextManager._asyncLocalStorage.run(self.__initCtx(this, data, emitType, {
-                    remoteAddress: remoteAddress,
-                    protocol: this.protocol,
-                    request: request
-                }), () => {
+            TraceContextManager._asyncLocalStorage.run(initCtx(obj, args, shouldProfileResource), () => {
+                try {
                     var ctx = TraceContextManager._asyncLocalStorage.getStore();
                     if (!ctx) {
-                        return originalMethod.apply(this, arguments);
+                        return;
                     }
 
-                    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);
-                    }
-                });
-            };
+                    // IP 주소 처리 최적화
+                    const ipInfo = getProcessedIp(remoteAddress);
+                    if (!ipInfo) return;
+
+                    // 불필요한 footprint 로깅 제거 (메모리 사용 감소)
+                    ctx.socket_connecting = true;
 
-            connection[methodName].__whatap_wrapped__ = 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;
 
-            // 속성 복사
-            Object.defineProperties(connection[methodName], {
-                length: { value: originalMethod.length },
-                name: { value: originalMethod.name }
+                        DataTextAgent.MESSAGE.add(protocol_hash, 'Protocol');
+                        ctx.profile.add(step);
+                    }
+
+                    // 소켓 단계 기록 (메모리 사용 최적화)
+                    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;
+                }
             });
-        }
+        });
     });
 };
 
-WebsocketObserver.prototype.__detectBroadcastType = function() {
+WebsocketObserver.prototype.__endTransaction = function(error, ctx) {
     try {
-        // 스택 트레이스를 통해 브로드캐스트 패턴 감지
-        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';
-            }
+        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;
         }
-        return 'websocket';
-    } catch (e) {
-        return 'websocket';
-    }
-};
 
-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}`;
-        }
+        wtx.status = 2;
+        wtx.ipaddr = ctx.remoteIp;
 
-        AsyncSender.send_packet(PacketTypeEnum.TX_MSG, ctx, [title, '', message]);
-    } catch (e) {
-        Logger.printError('WHATAP-220', 'WebSocket send message error', e, false);
-        throw e;
-    }
-};
+        MeterService.add(0, wtx.elapsed, 0, SecurityMaster.PCODE, SecurityMaster.OKIND, SecurityMaster.OID);
 
-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;
-    }
-};
+        profile.oid = SecurityMaster.OID;
+        profile.service = wtx;
 
-WebsocketObserver.prototype.__endTransaction = function(error, ctx) {
-    try {
-        if (error) {
-            TraceContextManager.end(ctx != null ? ctx.id : null);
-            ctx = null;
-            return;
-        }
+        // 트랜잭션 컨텍스트 종료 (메모리 누수 방지)
+        TraceContextManager.end(ctx._id);
 
-        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);
+        // 프로파일 데이터 버퍼에 추가 (비동기 처리 최적화)
+        this.profileBuffer.push({
+            ctx: ctx,
+            profile: profile,
+            timestamp: Date.now()
+        });
 
     } catch (e) {
-        Logger.printError('WHATAP-222', 'WebSocket end transaction error', e, false);
-        TraceContextManager.end(ctx.id);
+        Logger.printError('WHATAP-615', 'Websocket end transaction error', e, false);
+        // 에러 발생 시에도 컨텍스트 정리
+        TraceContextManager.end(ctx._id);
         ctx = null;
     }
 };
 
-WebsocketObserver.prototype.__initCtx = function(connection, data, emitType, contextInfo) {
+// 컨텍스트 초기화 최적화
+function initCtx(socket, args, shouldProfileResource) {
     const ctx = TraceContextManager.start();
-    if (!ctx) return null;
+    if (!ctx) {return;}
 
     var remote_addr;
-    var remoteAddress = contextInfo.remoteAddress;
-
-    if (remoteAddress) {
-        if(remoteAddress && remoteAddress.includes(':')){
-            remote_addr = remoteAddress.substring(remoteAddress.lastIndexOf(':')+1);
-        }
+    const address = socket.remoteAddress;
+    if(address && address.includes(':')){
+        remote_addr = address.substring(address.lastIndexOf(':')+1);
     }
 
-    ctx.service_name = "/websocket";
-
-    if (remote_addr) {
-        remote_addr = IPUtil.checkIp4(remote_addr);
-        ctx.remoteIp = IPUtil.stringToInt(remote_addr);
-        ctx.userid = ctx.remoteIp;
+    // 리소스 측정은 샘플링된 트랜잭션에만 수행 (CPU 사용 감소)
+    ctx.shouldProfileResource = shouldProfileResource;
+    if (shouldProfileResource) {
+        ctx.start_malloc = ResourceProfile.getUsedHeapSize();
+        ctx.start_cpu = ResourceProfile.getCPUTime();
     }
 
-    // 기본값 설정
-    ctx.userAgentString = '';
-    ctx.referer = '';
-    ctx.status = 200;
+    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.WebsocketObserver = WebsocketObserver;

package/lib/pack/activestack-pack.js

@@ -0,0 +1,55 @@
+/**
+ * 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 Pack = require('./pack'),
+    PackEnum = require('./packenum'),
+    Long = require('long');
+
+function ActiveStackPack() {
+    Pack.call(this);
+
+    this.seq = Long.ZERO;
+    this.txid = Long.ZERO;
+    this.service = 0;
+    this.elapsed = 0;
+
+    this.callstack = [];
+    this.callstack_hash = 0;
+}
+
+ActiveStackPack.prototype = new Pack();
+ActiveStackPack.prototype.constructor = ActiveStackPack;
+ActiveStackPack.prototype.getPackType = function () {
+    return PackEnum.ACTIVESTACK_1;
+};
+ActiveStackPack.prototype.write = function(dout) {
+    Pack.prototype.write.call(this, dout);
+    dout.writeByte(1);
+    dout.writeLong(this.seq);
+    dout.writeLong(this.txid);
+    dout.writeDecimal(this.service);
+    dout.writeDecimal(this.callstack_hash);
+    dout.writeIntArray(this.callstack);
+    dout.writeDecimal(this.elapsed);
+};
+ActiveStackPack.prototype.read = function(din) {
+
+    Pack.prototype.read.call(this, din);
+    var ver= din.readByte();
+    this.seq = din.readLong();
+    this.txid = din.readLong();
+    this.service = din.readDecNumber();
+
+    this.callstack_hash = din.readDecNumber();
+    this.callstack = din.readIntArray();
+    if(ver>0){
+        this.elapsed = din.readDecNumber();
+    }
+    return this;
+};
+
+
+module.exports = ActiveStackPack;

package/lib/pack/apenum.js

@@ -0,0 +1,8 @@
+exports.AP_JAVA     = 1;
+exports.AP_NODE     = 2;
+exports.AP_PYTHON   = 3;
+exports.AP_PHP      = 4;
+exports.AP_URL_ADM  = 5;
+exports.BSM         = 6;
+exports.WEB_CHECK   = 9;
+exports.OTEL        = 10;

package/lib/pack/counter-pack.js

@@ -11,6 +11,8 @@ 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'),
@@ -71,6 +73,7 @@ function CounterPack() {
 
     this.db_num_active = null;
     this.db_num_idle = null;
+    this.netstat = null;
 
     this.host_ip = 0;
     this.proc_fd = 0;