whatap 1.0.14 → 2.0.0-canary.0

package/.claude/settings.local.json

@@ -1,7 +1,13 @@
 {
   "permissions": {
     "allow": [
-      "Bash(grep -n \"ECONNREFUSED\" /Users/seunghunlee/agent_workspace/nodejs_agent/lib/observers/*.js /Users/seunghunlee/agent_workspace/nodejs_agent/lib/core/agent.js 2>/dev/null)"
+      "Bash(grep -n \"ECONNREFUSED\" /Users/seunghunlee/agent_workspace/nodejs_agent/lib/observers/*.js /Users/seunghunlee/agent_workspace/nodejs_agent/lib/core/agent.js 2>/dev/null)",
+      "WebSearch",
+      "Bash(go env *)",
+      "Bash(ls -l \"$\\(go env GOPATH\\)/bin/govulncheck\")",
+      "Bash(brew list *)",
+      "Bash(brew search *)",
+      "Bash(brew info *)"
     ]
   }
 }

package/build.txt

@@ -1,4 +1,4 @@
 app = 'NodeJS'
 name = 'whatap_nodejs'
-version = '1.0.13'
-build_date = '20260224'
+version = '1.0.15'
+build_date = '20260423'

package/lib/conf/config-default.js

@@ -285,7 +285,13 @@ var ConfigDefault = {
     "trace_kafka_enabled": bool("trace_kafka_enabled", false),
     "trace_kafka_consumer_enabled": bool("trace_kafka_consumer_enabled", false),
 
-    "agent_per_instance_enabled": bool("agent_per_instance_enabled", false)
+    "agent_per_instance_enabled": bool("agent_per_instance_enabled", false),
+
+    // LLM monitoring
+    "llm_enabled": bool("llm_enabled", false),
+    "trace_llm_log_enabled": bool("trace_llm_log_enabled", false),
+    "llm_net_udp_port": num("llm_net_udp_port", 0),
+    "llm_model_pricing": str("llm_model_pricing", "")
 
 };
 

package/lib/core/agent.js

@@ -37,7 +37,8 @@ var Interceptor      = require('./interceptor').Interceptor,
     OracleObserver  = require('../observers/oracle-observer').OracleObserver,
     CustomMethodObserver = require('../observers/custom-method-observer').CustomMethodObserver,
     CronObserver = require('../observers/cron-observer').CronObserver,
-    KafkaObserver = require('../observers/kafka-observer').KafkaObserver;
+    KafkaObserver = require('../observers/kafka-observer').KafkaObserver,
+    OpenAIObserver = require('../observers/openai-observer').OpenAIObserver;
 
 
 var Configuration    = require('./../conf/configure'),
@@ -1249,6 +1250,107 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
     }
 };
 
+/**
+ * Start a separate Go Agent for LLM monitoring (with --llm flag)
+ * Python equivalent: go(llm=True)
+ */
+NodeAgent.prototype.startLlmGoAgent = function () {
+    var self = this;
+    var whatapHome = process.env.WHATAP_HOME;
+    if (!whatapHome) return;
+
+    try {
+        var platform = process.platform;
+        var agentBinaryName = platform === 'win32' ? AGENT_NAME + '.exe' : AGENT_NAME;
+        var agentPath = path.join(whatapHome, agentBinaryName);
+
+        if (!fs.existsSync(agentPath)) {
+            Logger.print("WHATAP-LLM-020", "Agent binary not found for LLM agent: " + agentPath, false);
+            return;
+        }
+
+        // LLM UDP port
+        var basePort = parseInt(self._conf.getProperty('net_udp_port', 6600)) || 6600;
+        var llmPort = parseInt(self._conf.getProperty('llm_net_udp_port', 0)) || (basePort + 100);
+        self._conf['llm_net_udp_port'] = llmPort;
+
+        // Write to whatap.conf so Go Agent can read it
+        try {
+            var confFile = path.join(whatapHome, 'whatap.conf');
+            if (fs.existsSync(confFile)) {
+                var confContent = fs.readFileSync(confFile, 'utf8');
+                if (confContent.indexOf('llm_net_udp_port') < 0) {
+                    fs.appendFileSync(confFile, '\nllm_net_udp_port=' + llmPort + '\n');
+                }
+            }
+        } catch (e) {
+            Logger.printError("WHATAP-LLM-021", "Error writing llm_net_udp_port to whatap.conf", e, false);
+        }
+
+        // Check existing LLM agent
+        var llmPidFile = path.join(whatapHome, AGENT_NAME + '.pid.llm');
+        if (fs.existsSync(llmPidFile)) {
+            try {
+                var existingPid = parseInt(fs.readFileSync(llmPidFile, 'utf8').trim());
+                if (existingPid && self.isGoAgentRunning(existingPid)) {
+                    Logger.print("WHATAP-LLM-022", "LLM Go Agent already running (PID: " + existingPid + ")", false);
+                    return;
+                }
+            } catch (e) {}
+        }
+
+        // Build environment (python equivalent: WHATAP_NET_UDP_PORT, WHATAP_PID_FILE, *_PARENT_APP_PID)
+        var newEnv = Object.assign({}, process.env);
+        newEnv['WHATAP_NET_UDP_PORT'] = String(llmPort);
+        newEnv['WHATAP_PID_FILE'] = AGENT_NAME + '.pid.llm';
+        newEnv['NODEJS_PARENT_APP_PID'] = process.pid.toString();
+        newEnv['whatap.enabled'] = 'true';
+
+        // Spawn: whatap_nodejs -t 2 -d 1 --llm  (normal agent와 동일 -t/-d, --llm만 추가)
+        var spawnArgs = platform === 'win32'
+            ? ['-t', '2', '--llm', 'foreground']
+            : ['-t', '2', '-d', '1', '--llm'];
+
+        var spawnOptions = {
+            cwd: whatapHome,
+            env: newEnv,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: true, // python: start_new_session=True
+        };
+
+        if (platform === 'win32') {
+            spawnOptions.windowsHide = true;
+        }
+
+        var llmProcess = child_process.spawn(agentPath, spawnArgs, spawnOptions);
+
+        llmProcess.on('spawn', function () {
+            Logger.print("WHATAP-LLM-023", "executed LLM golang module in background (PID: " + llmProcess.pid + ")", false);
+            try {
+                fs.writeFileSync(llmPidFile, String(llmProcess.pid));
+            } catch (e) {}
+            Logger.print("WHATAP-LLM-028", "WHATAP: AGENT UP! (process name: " + AGENT_NAME + " --llm)", false);
+        });
+
+        llmProcess.on('error', function (err) {
+            Logger.printError("WHATAP-LLM-024", "Failed to spawn LLM Go Agent", err, false);
+        });
+
+        llmProcess.on('close', function (code) {
+            Logger.print("WHATAP-LLM-025", "LLM Go Agent exited with code: " + code, false);
+        });
+
+        // Capture stderr for logging
+        llmProcess.stderr.on('data', function (data) {
+            var msg = data.toString().trim();
+            if (msg) Logger.print("WHATAP-LLM-026", "[LLM Agent] " + msg, false);
+        });
+
+    } catch (e) {
+        Logger.printError("WHATAP-LLM-027", "Error starting LLM Go Agent", e, false);
+    }
+};
+
 // 프로세스 종료 시 정리 작업 개선
 process.on('exit', () => {
     if (!process.env.WHATAP_HOME || !NodeAgent.prototype.getApplicationIdentifier || !NodeAgent.prototype.isPM2ClusterMode) {
@@ -1374,6 +1476,12 @@ NodeAgent.prototype.init = function(cb) {
         // Start Node.js agent with proper port configuration
         WhatapUtil.printWhatap();
         self.startGoAgent();
+
+        // Start LLM Go Agent if llm_enabled
+        if (self._conf.getProperty('llm_enabled', false)) {
+            self.startLlmGoAgent();
+        }
+
         TraceContextManager.initialized = true;
 
         self.initUdp();
@@ -1413,6 +1521,7 @@ NodeAgent.prototype.loadObserves = function() {
     observes.push(OracleObserver);
     observes.push(CronObserver);
     observes.push(KafkaObserver);
+    observes.push(OpenAIObserver);
 
     var packageToObserve = {};
     observes.forEach(function(observeObj) {

package/lib/counter/counter-manager.js

@@ -6,7 +6,8 @@
 
 var conf = require('../conf/configure'),
     Logger              = require('../logger'),
-    GCAction = require('../system/gc-action');
+    GCAction = require('../system/gc-action'),
+    LlmStatTasks = require('./task/llm-stat-tasks');
 
 function CounterManager(agent) {
     this.agent = agent;
@@ -21,6 +22,15 @@ CounterManager.prototype.run = function () {
         var tasks = [];
         tasks.push(new GCAction());
 
+        // LLM 메트릭 6종 (5초 주기). llm_meter는 python-apm과 일치 — 제거됨.
+        // 호출 카운트는 ACTIVE_STATS 꼬리의 "LLM:count=N"으로 전송 (_llmMeterCount).
+        tasks.push(new LlmStatTasks.LLMActiveStatTask());
+        tasks.push(new LlmStatTasks.LLMApiStatusTask());
+        tasks.push(new LlmStatTasks.LLMErrorStatTask());
+        tasks.push(new LlmStatTasks.LLMFeatureStatTask());
+        tasks.push(new LlmStatTasks.LLMPerfStatTask());
+        tasks.push(new LlmStatTasks.LLMTokenUsageTask());
+
         self.intervalIndex = setInterval(function(){
             self.process(tasks);
         },5000);

package/lib/counter/task/llm-stat-tasks.js

@@ -0,0 +1,270 @@
+'use strict';
+
+/**
+ * LLM Metric counter tasks (7 categories):
+ *  - llm_active_stat
+ *  - llm_api_status
+ *  - llm_error_stat
+ *  - llm_feature_stat
+ *  - llm_perf_stat   (sketch fields omitted; Node has no datasketches)
+ *  - llm_token_usage
+ *  - meter (LLM_TRANSACTION)
+ *
+ * Each task exposes a process() method invoked by counter-manager.
+ * Packs are sent via async_sender.send_llm_relaypack to the LLM Go agent.
+ */
+
+const TagCountPack = require('../../pack/tagcount-pack');
+const DataOutputX = require('../../io/data-outputx');
+const AsyncSender = require('../../udp/async_sender');
+const conf = require('../../conf/configure');
+const Logger = require('../../logger');
+const HashUtil = require('../../util/hashutil');
+const collector = require('../../llm/llm-stat-collector');
+const { getLlmPcode } = require('../../llm/llm-pcode');
+
+const _PID = process.pid;
+
+function _enabled() {
+    // python-apm과 일치: llm_enabled 단일 gate
+    return conf.getProperty('llm_enabled', false);
+}
+
+function _bucketTime(ms) {
+    return Math.floor(ms / 5000) * 5000;
+}
+
+function _send(p) {
+    try {
+        p.pcode = getLlmPcode();
+        const bout = new DataOutputX();
+        bout.writePack(p, null);
+        AsyncSender.send_llm_relaypack(bout.toByteArray());
+    } catch (e) {
+        Logger.printError('WHATAP-LLM-STAT-001', 'send pack failed', e, false);
+    }
+}
+
+function _newPack(category, model, provider, opType, url) {
+    const p = new TagCountPack();
+    p.time = _bucketTime(Date.now());
+    p.category = category;
+    p.tags.putLong('pid', _PID);
+    p.tags.putString('model', model || 'unknown');
+    p.tags.putString('provider', provider || '');
+    p.tags.putString('operation_type', opType || 'unknown');
+    p.tags.putString('url', url || '');
+    return p;
+}
+
+// ---------------------------------------------------------
+// 1) llm_active_stat
+// ---------------------------------------------------------
+function LLMActiveStatTask() {}
+LLMActiveStatTask.prototype.process = function () {
+    if (!_enabled()) return;
+    // 매 tick에 model cache TTL 만료 entry 제거 (10분/500개 cap)
+    try { collector.pruneModelCache(); } catch (e) {}
+
+    const snap = collector.snapshotAndResetActive();
+    if (snap.active.size === 0) return;
+    snap.active.forEach((count, k) => {
+        try {
+            const parsed = collector.parseKey(k);
+            const info = snap.modelInfo.get(parsed.model);
+            const provider = info ? info.provider : '';
+            const url = info ? info.url : '';
+            const p = _newPack('llm_active_stat', parsed.model, provider, parsed.op_type, url);
+            p.fields.putLong('count', count);
+            _send(p);
+        } catch (e) {
+            Logger.printError('WHATAP-LLM-STAT-010', 'active stat error', e, false);
+        }
+    });
+};
+
+// ---------------------------------------------------------
+// 2) llm_api_status
+// ---------------------------------------------------------
+function LLMApiStatusTask() {}
+LLMApiStatusTask.prototype.process = function () {
+    if (!_enabled()) return;
+    const snap = collector.snapshotAndResetApiStatus();
+    if (snap.x4.size === 0 && snap.x5.size === 0) return;
+
+    // Set spread → Map iteration으로 GC 압박 감소 (intermediate array 제거)
+    const seen = new Set();
+    const emit = (k) => {
+        if (seen.has(k)) return;
+        seen.add(k);
+        try {
+            const parsed = collector.parseKey(k);
+            const p = _newPack('llm_api_status', parsed.model, parsed.provider, parsed.op_type, parsed.url);
+            p.fields.putLong('4xx_total_count', snap.x4.get(k) || 0);
+            p.fields.putLong('5xx_total_count', snap.x5.get(k) || 0);
+            _send(p);
+        } catch (e) {
+            Logger.printError('WHATAP-LLM-STAT-020', 'api status error', e, false);
+        }
+    };
+    snap.x4.forEach((_, k) => emit(k));
+    snap.x5.forEach((_, k) => emit(k));
+};
+
+// ---------------------------------------------------------
+// 3) llm_error_stat
+// ---------------------------------------------------------
+function LLMErrorStatTask() {}
+LLMErrorStatTask.prototype.process = function () {
+    if (!_enabled()) return;
+    const snap = collector.snapshotAndResetErrors();
+    if (snap.api.size === 0 && snap.program.size === 0 && snap.lastApi.size === 0) return;
+
+    const seen = new Set();
+    const emit = (k) => {
+        if (seen.has(k)) return;
+        seen.add(k);
+        try {
+            const parsed = collector.parseKey(k);
+            const apiE = snap.api.get(k) || 0;
+            const progE = snap.program.get(k) || 0;
+            const p = _newPack('llm_error_stat', parsed.model, parsed.provider, parsed.op_type, parsed.url);
+            p.fields.putLong('error_count', apiE + progE);
+            p.fields.putLong('api_error_count', apiE);
+            p.fields.putLong('program_error_count', progE);
+            p.fields.putLong('last_api_error_count', snap.lastApi.get(k) || 0);
+            _send(p);
+        } catch (e) {
+            Logger.printError('WHATAP-LLM-STAT-030', 'error stat error', e, false);
+        }
+    };
+    snap.api.forEach((_, k) => emit(k));
+    snap.program.forEach((_, k) => emit(k));
+    snap.lastApi.forEach((_, k) => emit(k));
+};
+
+// ---------------------------------------------------------
+// 4) llm_feature_stat (리스트형 → !rectype=2)
+// ---------------------------------------------------------
+function LLMFeatureStatTask() {}
+LLMFeatureStatTask.prototype.process = function () {
+    if (!_enabled()) return;
+    const snap = collector.snapshotAndResetFeatures();
+    if (snap.calls.size === 0) return;
+    snap.calls.forEach((callCount, k) => {
+        try {
+            const parsed = collector.parseKey(k);
+            const p = _newPack('llm_feature_stat', parsed.model, parsed.provider, parsed.op_type, parsed.url);
+            p.tags.putLong('!rectype', 2);
+            p.fields.putLong('call_count', callCount);
+
+            const idList = p.fields.newList('@id');
+            const fList = p.fields.newList('features');
+            const fCntList = p.fields.newList('features_count');
+            const counts = snap.counts.get(k) || {};
+            for (const feat of collector.FEATURES) {
+                const c = counts[feat] || 0;
+                if (c > 0) {
+                    idList.addLong(HashUtil.hashFromString(`${parsed.model}:${parsed.provider}:${parsed.op_type}:${feat}`));
+                    fList.addString(feat);
+                    fCntList.addLong(c);
+                }
+            }
+            _send(p);
+        } catch (e) {
+            Logger.printError('WHATAP-LLM-STAT-040', 'feature stat error', e, false);
+        }
+    });
+};
+
+// ---------------------------------------------------------
+// 5) llm_perf_stat (sketch 미지원 — sum/count만 전송)
+// ---------------------------------------------------------
+function LLMPerfStatTask() {}
+LLMPerfStatTask.prototype.process = function () {
+    if (!_enabled()) return;
+    const snap = collector.snapshotAndResetPerf();
+    if (snap.callCount.size === 0) return;
+    snap.callCount.forEach((call, k) => {
+        try {
+            const parsed = collector.parseKey(k);
+            const p = _newPack('llm_perf_stat', parsed.model, parsed.provider, parsed.op_type, parsed.url);
+            p.fields.putLong('call_count', call);
+            p.fields.putFloat('latency_sum', snap.latencySum.get(k) || 0);
+            p.fields.putFloat('ttft_sum', snap.ttftSum.get(k) || 0);
+            p.fields.putLong('ttft_count', snap.ttftCount.get(k) || 0);
+            p.fields.putFloat('tpot_sum', snap.tpotSum.get(k) || 0);
+            p.fields.putLong('tpot_count', snap.tpotCount.get(k) || 0);
+            // sketch 필드는 datasketches 미지원으로 omit
+            _send(p);
+        } catch (e) {
+            Logger.printError('WHATAP-LLM-STAT-050', 'perf stat error', e, false);
+        }
+    });
+};
+
+// ---------------------------------------------------------
+// 6) llm_token_usage (리스트형 → !rectype=2)
+// ---------------------------------------------------------
+const _TOKEN_TYPES = ['input_tokens', 'output_tokens', 'cached_tokens', 'reasoning_tokens',
+    'cache_creation_input_tokens', 'cache_read_input_tokens'];
+const _TOKEN_COST_MAP = {
+    'input_tokens': 'input_cost',
+    'output_tokens': 'output_cost',
+    'cached_tokens': 'cached_cost',
+};
+
+function LLMTokenUsageTask() {}
+LLMTokenUsageTask.prototype.process = function () {
+    if (!_enabled()) return;
+    const snap = collector.snapshotAndResetTokens();
+    if (snap.calls.size === 0) return;
+    snap.calls.forEach((call, k) => {
+        try {
+            const parsed = collector.parseKey(k);
+            const counts = snap.counts.get(k) || {};
+            const costs = snap.costs.get(k) || {};
+            const totalTokens = (counts.input_tokens || 0) + (counts.output_tokens || 0);
+            const totalCost = (costs.input_cost || 0) + (costs.output_cost || 0);
+
+            const p = _newPack('llm_token_usage', parsed.model, parsed.provider, parsed.op_type, parsed.url);
+            p.tags.putLong('!rectype', 2);
+            p.fields.putLong('call_count', call);
+            p.fields.putLong('total_tokens', totalTokens);
+            p.fields.putFloat('total_cost', +totalCost.toFixed(6));
+            p.fields.putLong('error_count', snap.error.get(k) || 0);
+            p.fields.putLong('stream_count', snap.stream.get(k) || 0);
+
+            const idList = p.fields.newList('@id');
+            const tokList = p.fields.newList('tokens');
+            const cntList = p.fields.newList('tokens_count');
+            const costList = p.fields.newList('tokens_cost');
+            for (const tt of _TOKEN_TYPES) {
+                const c = counts[tt] || 0;
+                if (c > 0) {
+                    idList.addLong(HashUtil.hashFromString(`${parsed.model}:${parsed.provider}:${parsed.op_type}:${tt}`));
+                    tokList.addString(tt);
+                    cntList.addLong(c);
+                    const costKey = _TOKEN_COST_MAP[tt];
+                    costList.addFloat(costKey ? +(costs[costKey] || 0).toFixed(6) : 0);
+                }
+            }
+            _send(p);
+        } catch (e) {
+            Logger.printError('WHATAP-LLM-STAT-060', 'token usage error', e, false);
+        }
+    });
+};
+
+// NOTE: llm_meter TagCountPack은 python-apm에서도 제거됨.
+// LLM 호출 카운트는 _llmMeterCount로 유지되어 ACTIVE_STATS 패킷 꼬리에
+// "LLM:count=N" 형태로 append 송신됨 (udp_session.js:161).
+
+module.exports = {
+    LLMActiveStatTask,
+    LLMApiStatusTask,
+    LLMErrorStatTask,
+    LLMFeatureStatTask,
+    LLMPerfStatTask,
+    LLMTokenUsageTask,
+};

package/lib/llm/llm-id-util.js

@@ -0,0 +1,35 @@
+'use strict';
+
+/**
+ * BigInt 변환 캐싱 유틸.
+ * JS Number의 53bit 초과 정수 정밀도 손실 방지용 BigInt 변환은 비용이 있는 작업이므로
+ * 한 라이프사이클 내 동일 값에 대해 1회만 수행.
+ */
+
+function bigStr(v) {
+    if (v == null) return '';
+    try {
+        return BigInt(v).toString();
+    } catch (e) {
+        return String(v);
+    }
+}
+
+/**
+ * ctx.id를 BigInt-precise string으로 반환. ctx에 _txidStr로 캐싱.
+ */
+function ctxTxidStr(ctx) {
+    if (!ctx) return '';
+    if (ctx._txidStr) return ctx._txidStr;
+    ctx._txidStr = bigStr(ctx.id);
+    return ctx._txidStr;
+}
+
+/**
+ * 임의 step_id를 BigInt-precise string으로 반환. 라이프사이클 짧으면 캐싱 안 함.
+ */
+function stepIdStr(stepIdRaw) {
+    return bigStr(stepIdRaw);
+}
+
+module.exports = { bigStr, ctxTxidStr, stepIdStr };