whatap 1.0.9 → 1.0.10

package/lib/conf/config-default.js

@@ -278,7 +278,9 @@ var ConfigDefault = {
     "prisma_read_func_name": str("prisma_read_func_name", "read"),
     "prisma_database_url_name": str("prisma_database_url_name", "DATABASE_URL"),
 
-    "metering_tagcount_enabled": bool("metering_tagcount_enabled", false)
+    "metering_tagcount_enabled": bool("metering_tagcount_enabled", false),
+
+    "trace_cron_enabled": bool("trace_cron_enabled", true)
 };
 
 ConfigDefault._hook_method_ignore_prefix = ConfigDefault.hook_method_ignore_prefixes.split(',');

package/lib/control/packagectr-helper.js

@@ -191,15 +191,15 @@ PackageCtrHelper.hookMethod = function(obj, modulePath, methodName, className) {
                 return originalMethod.apply(this, arguments);
             }
 
-            var startTime = Date.now();
+            var startTime = ctx.start_time = Date.now();
             var error = null;
             var result = null;
 
             // Capture original arguments once for later use
             var originalArgs = arguments;
 
-            // Format: "ClassName.methodName" if className exists, otherwise "modulePath/methodName"
-            var methodFullPath = className ? className + '.' + methodName : modulePath + '/' + methodName;
+            // Format: "ClassName.methodName" if className exists, otherwise "NULL.methodName"
+            var methodFullPath = className ? className + '.' + methodName : 'NULL.' + methodName;
 
             // Convert arguments to string once
             var argsString = '';

package/lib/core/agent.js

@@ -35,7 +35,8 @@ var Interceptor      = require('./interceptor').Interceptor,
     ApolloObserver   = require('../observers/apollo-server-observer').ApolloServerObserver,
     PrismaObserver  = require('../observers/prisma-observer').PrismaObserver,
     OracleObserver  = require('../observers/oracle-observer').OracleObserver,
-    CustomMethodObserver = require('../observers/custom-method-observer').CustomMethodObserver;
+    CustomMethodObserver = require('../observers/custom-method-observer').CustomMethodObserver,
+    CronObserver = require('../observers/cron-observer').CronObserver;
 
 
 var Configuration    = require('./../conf/configure'),
@@ -965,12 +966,19 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
     if (pid) {
         try {
             if (this.isGoAgentRunning(pid)) {
-                Logger.print("WHATAP-106", `Found existing agent with PID ${pid}, terminating...`, false);
-                try {
-                    process.kill(parseInt(pid), 'SIGKILL');
-                    Logger.print("WHATAP-107", `Successfully terminated existing agent with PID ${pid}`, false);
-                } catch (killError) {
-                    Logger.printError("WHATAP-108", `Error terminating process with PID ${pid}`, killError, false);
+                // Windows: 기존 프로세스가 실행 중이면 스킵 (Python agent와 동일한 동작)
+                // Unix/Linux: 기존 프로세스 종료 후 새로 시작
+                if (process.platform === 'win32') {
+                    Logger.print("WHATAP-106", `Agent already running (PID: ${pid}). Skipping duplicate execution.`, false);
+                    return;
+                } else {
+                    Logger.print("WHATAP-106", `Found existing agent with PID ${pid}, terminating...`, false);
+                    try {
+                        process.kill(parseInt(pid), 'SIGKILL');
+                        Logger.print("WHATAP-107", `Successfully terminated existing agent with PID ${pid}`, false);
+                    } catch (killError) {
+                        Logger.printError("WHATAP-108", `Error terminating process with PID ${pid}`, killError, false);
+                    }
                 }
             }
         } catch (e) {
@@ -983,10 +991,16 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
 
     try {
         // 바이너리 경로 설정
-        const agentPath = path.join(whatapHome, AGENT_NAME);
         const platform = process.platform;
         const architecture = ARCH[process.arch] || process.arch;
-        const sourcePath = path.join(__dirname, '..', '..', 'agent', platform, architecture, AGENT_NAME);
+
+        const binaryName = platform === 'win32' ? AGENT_NAME + '.exe' : AGENT_NAME;
+        const agentPath = path.join(whatapHome, binaryName);
+
+        // Windows는 architecture 하위 디렉토리 없이 단일 바이너리 사용
+        const sourcePath = platform === 'win32'
+            ? path.join(__dirname, '..', '..', 'agent', 'windows', binaryName)
+            : path.join(__dirname, '..', '..', 'agent', platform, architecture, AGENT_NAME);
 
         // sourcePath 존재 여부 확인
         if (!fs.existsSync(sourcePath)) {
@@ -1004,8 +1018,10 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
                     Logger.print("WHATAP-037", `Symlink failed (${e.code}), copying binary instead`, false);
                     try {
                         fs.copyFileSync(sourcePath, agentPath);
-                        // 실행 권한 부여
-                        fs.chmodSync(agentPath, 0o755);
+                        // 실행 권한 부여 (Windows는 불필요)
+                        if (platform !== 'win32') {
+                            fs.chmodSync(agentPath, 0o755);
+                        }
                         Logger.print("WHATAP-221", `Binary copied and made executable at ${agentPath}`, false);
                     } catch (copyErr) {
                         throw new Error(`Failed to copy agent binary: ${copyErr.message}`);
@@ -1014,12 +1030,14 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
             }
         }
 
-        // agentPath 실행 권한 확인
-        try {
-            fs.accessSync(agentPath, fs.constants.X_OK);
-        } catch (e) {
-            Logger.print("WHATAP-222", `Agent binary not executable, adding execute permission`, false);
-            fs.chmodSync(agentPath, 0o755);
+        // agentPath 실행 권한 확인 (Windows는 스킵)
+        if (platform !== 'win32') {
+            try {
+                fs.accessSync(agentPath, fs.constants.X_OK);
+            } catch (e) {
+                Logger.print("WHATAP-222", `Agent binary not executable, adding execute permission`, false);
+                fs.chmodSync(agentPath, 0o755);
+            }
         }
 
         // run 디렉토리 생성
@@ -1068,16 +1086,27 @@ NodeAgent.prototype.startGoAgent = function(opts = {}) {
         Object.assign(newEnv, opts);
 
         // 에이전트 프로세스 시작
-        const agentProcess = child_process.spawn(
-            agentPath,
-            ['-t', '2', '-d', '1'],
-            {
-                cwd: whatapHome,
-                env: newEnv,
-                stdio: ['pipe', 'pipe', 'pipe'],
-                detached: false
-            }
-        );
+        // Windows: -t 2 foreground (detached 모드)
+        // Unix/Linux: -t 2 -d 1 (daemon 모드)
+        const spawnArgs = platform === 'win32'
+            ? ['-t', '2', 'foreground']
+            : ['-t', '2', '-d', '1'];
+
+        const spawnOptions = {
+            cwd: whatapHome,
+            env: newEnv,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            detached: platform === 'win32' // Windows에서는 detached 모드
+        };
+
+        // Windows에서는 DETACHED_PROCESS 플래그 추가
+        if (platform === 'win32') {
+            spawnOptions.detached = true;
+            // Windows 전용: 새로운 콘솔 윈도우 생성 방지
+            spawnOptions.windowsHide = true;
+        }
+
+        const agentProcess = child_process.spawn(agentPath, spawnArgs, spawnOptions);
 
         const MAX_BUFFER_SIZE = 50000; // 50KB - prevent memory leak
         let stdout = '';
@@ -1322,6 +1351,7 @@ NodeAgent.prototype.loadObserves = function() {
     observes.push(ApolloObserver);
     observes.push(PrismaObserver);
     observes.push(OracleObserver);
+    observes.push(CronObserver);
 
     var packageToObserve = {};
     observes.forEach(function(observeObj) {

package/lib/observers/cron-observer.js

@@ -0,0 +1,279 @@
+/**
+ * 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 TraceContextManager = require('../trace/trace-context-manager'),
+    conf = require('../conf/configure'),
+    Logger = require('../logger'),
+    AsyncSender = require('../udp/async_sender'),
+    PacketTypeEnum = require('../udp/packet_type_enum');
+const shimmer = require('../core/shimmer');
+
+var CronObserver = function (agent) {
+    this.agent = agent;
+    this.packages = ['node-cron', 'cron', 'node-schedule'];
+};
+
+CronObserver.prototype.__createCronJobObserver = function (callback, cronExpression, jobName) {
+    var self = this;
+
+    // callback이 async 함수인지 확인
+    const isAsync = callback.constructor.name === 'AsyncFunction';
+
+    return function wrappedCronCallback() {
+        return TraceContextManager._asyncLocalStorage.run(self.__initCtx(cronExpression, jobName), () => {
+            var ctx = TraceContextManager._asyncLocalStorage.getStore();
+
+            if (!ctx) {
+                return callback.apply(this, arguments);
+            }
+
+            try {
+                ctx.service_name = jobName || '/';
+                let hostname = '0.0.0.0';
+
+                let startDatas = [
+                    hostname,
+                    ctx.service_name,
+                    '0.0.0.0',
+                    '',
+                    '',
+                    String(0),
+                    String(false),
+                    ''
+                ];
+
+                AsyncSender.send_packet(PacketTypeEnum.TX_START, ctx, startDatas);
+
+                // 원본 callback 실행
+                const result = callback.apply(this, arguments);
+
+                // async 함수인 경우 Promise 처리
+                if (isAsync || (result && typeof result.then === 'function')) {
+                    return Promise.resolve(result)
+                        .then((res) => {
+                            self.__endTransaction(null, ctx);
+                            return res;
+                        })
+                        .catch((error) => {
+                            self.__handleError(error, ctx);
+                            self.__endTransaction(null, ctx);
+                            throw error;
+                        });
+                } else {
+                    // 동기 함수인 경우 바로 종료
+                    self.__endTransaction(null, ctx);
+                    return result;
+                }
+            } catch (error) {
+                // 동기 에러 처리
+                self.__handleError(error, ctx);
+                self.__endTransaction(null, ctx);
+                throw error;
+            }
+        });
+    };
+};
+
+CronObserver.prototype.__handleError = function (error, ctx) {
+    if (!ctx) return;
+
+    try {
+        ctx.error = 1;
+        ctx.status = 500;
+
+        var errorClass = error.code || error.name || error.constructor?.name || 'CronJobError';
+        var errorMessage = error.message || 'Cron job execution failed';
+        var errorStack = '';
+
+        if (conf.trace_sql_error_stack && conf.trace_sql_error_depth && error.stack) {
+            var traceDepth = conf.trace_sql_error_depth;
+            var stackLines = error.stack.split("\n");
+            if (stackLines.length > traceDepth) {
+                stackLines = stackLines.slice(0, traceDepth + 1);
+            }
+            errorStack = stackLines.join("\n");
+        }
+
+        var errors = [errorClass, errorMessage];
+        if (errorStack || error.stack) {
+            errors.push(errorStack || error.stack);
+        }
+
+        AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+    } catch (e) {
+        Logger.printError('WHATAP-301', 'Error handling cron job error', e, false);
+    }
+};
+
+CronObserver.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;
+        }
+
+        let endDatas = [
+            '0.0.0.0',
+            ctx.service_name,
+            0,  // mtid
+            0,  // mdepth
+            0,  // mcaller_txid
+            0,  // mcaller_pcode
+            '', // mcaller_spec
+            String(0), // mcaller_url_hash
+            ctx.status || 200
+        ];
+
+        ctx.start_time = Date.now();
+        // ctx.elapsed = Date.now() - ctx.start_time;
+        AsyncSender.send_packet(PacketTypeEnum.TX_END, ctx, endDatas);
+
+        TraceContextManager.end(ctx.id);
+        ctx = null;
+    } catch (e) {
+        Logger.printError('WHATAP-302', 'End cron transaction error', e, false);
+        TraceContextManager.end(ctx != null ? ctx.id : null);
+        ctx = null;
+    }
+};
+
+CronObserver.prototype.__initCtx = function (cronExpression, jobName) {
+    if (conf.getProperty('profile_enabled', true) === false) {
+        return null;
+    }
+
+    // 크론잡 모니터링 비활성화 옵션 체크
+    if (conf.getProperty('trace_cron_enabled', true) === false) {
+        return null;
+    }
+
+    var ctx = TraceContextManager.start();
+    if (ctx == null) {
+        return null;
+    }
+
+    ctx.service_name = jobName || '/';
+    ctx.remoteIp = 0;
+    ctx.userid = 0;
+    ctx.userAgentString = '';
+    ctx.referer = '';
+    ctx.status = 200;
+    ctx.error = 0;
+
+    return ctx;
+};
+
+/**
+ * node-cron 라이브러리 후킹
+ */
+CronObserver.prototype.inject = function (mod, moduleName) {
+    var self = this;
+
+    if (mod.__whatap_observe__) {
+        return;
+    }
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("CronObserver");
+
+    if (conf.getProperty('profile_enabled', true) === false) {
+        return;
+    }
+
+    // node-cron의 schedule 메서드 후킹
+    if (typeof mod.schedule === 'function') {
+        shimmer.wrap(mod, 'schedule', function (original) {
+            return function wrappedSchedule(cronExpression, callback, options) {
+                // 크론잡 이름 추출 (옵션에서 가져오거나 자동 생성)
+                var jobName = '/';
+
+                if (options && options.name) {
+                    jobName = `/${options.name}`;
+                } else if (typeof cronExpression === 'string') {
+                    jobName = `/${cronExpression.replace(/\s+/g, '-')}`;
+                }
+
+                // callback을 래핑
+                var wrappedCallback = self.__createCronJobObserver(callback, cronExpression, jobName);
+
+                // 원본 schedule 호출 (래핑된 callback으로)
+                return original.call(this, cronExpression, wrappedCallback, options);
+            };
+        });
+
+    }
+
+    // node-schedule 라이브러리 지원
+    if (mod.scheduleJob && typeof mod.scheduleJob === 'function') {
+        shimmer.wrap(mod, 'scheduleJob', function (original) {
+            return function wrappedScheduleJob(nameOrSpec, specOrCallback, callback) {
+                var jobName = '/';
+                var spec, actualCallback;
+
+                // 오버로딩 처리
+                if (typeof nameOrSpec === 'string') {
+                    jobName = `/${nameOrSpec}`;
+                    spec = specOrCallback;
+                    actualCallback = callback;
+                } else {
+                    spec = nameOrSpec;
+                    actualCallback = specOrCallback;
+                }
+
+                // callback 래핑
+                var wrappedCallback = self.__createCronJobObserver(
+                    actualCallback,
+                    JSON.stringify(spec),
+                    jobName
+                );
+
+                // 원본 scheduleJob 호출
+                if (typeof nameOrSpec === 'string') {
+                    return original.call(this, nameOrSpec, spec, wrappedCallback);
+                } else {
+                    return original.call(this, spec, wrappedCallback);
+                }
+            };
+        });
+    }
+
+    // cron 라이브러리 지원 (CronJob 클래스)
+    if (mod.CronJob && typeof mod.CronJob === 'function') {
+        // mod 객체의 'CronJob' 프로퍼티를 래핑
+        shimmer.wrap(mod, 'CronJob', function(OriginalCronJob) {
+            return function WrappedCronJob(cronTime, onTick, onComplete, start, timezone, context, runOnInit, utcOffset, unrefTimeout) {
+                // onTick 콜백 래핑
+                var wrappedOnTick = null;
+                if (typeof onTick === 'function') {
+                    wrappedOnTick = self.__createCronJobObserver(
+                        onTick,
+                        typeof cronTime === 'string' ? cronTime : 'custom',
+                        '/'
+                    );
+                }
+
+                // 원본 생성자 호출
+                return new OriginalCronJob(
+                    cronTime,
+                    wrappedOnTick || onTick,
+                    onComplete,
+                    start,
+                    timezone,
+                    context,
+                    runOnInit,
+                    utcOffset,
+                    unrefTimeout
+                );
+            };
+        });
+    }
+};
+
+exports.CronObserver = CronObserver;

package/lib/observers/custom-method-observer.js

@@ -128,6 +128,16 @@ CustomMethodObserver.prototype.inject = function(mod, moduleName) {
                                 Logger.print('WHATAP-224',
                                     'Hooked class method: ' + className + '.' + methodName,
                                     false);
+                            } else if (typeof moduleExports === 'function' && moduleExports.name === className) {
+                                // CommonJS default export: module.exports = ExternalService
+                                if (moduleExports.prototype && typeof moduleExports.prototype[methodName] === 'function') {
+                                    PackageCtrHelper.hookMethod(moduleExports.prototype, tryPath, methodName, className);
+                                } else {
+                                    PackageCtrHelper.hookMethod(moduleExports, tryPath, methodName, className);
+                                }
+                                Logger.print('WHATAP-224-CJS',
+                                    'Hooked CommonJS default class method: ' + className + '.' + methodName,
+                                    false);
                             } else if (moduleExports.default) {
                                 // ESM default export
                                 if (typeof moduleExports.default === 'function' && moduleExports.default.name === className) {

package/lib/observers/http-observer.js

@@ -128,6 +128,11 @@ HttpObserver.prototype.__createTransactionObserver = function (callback, isHttps
             }
 
             ctx.service_name = req.url ? req.url : "";
+            ctx.isStaticContents = isStatic(ctx.service_name);
+            if(ctx.isStaticContents){
+                return callback(req, res);
+            }
+
             let hostname = ctx.host && ctx.host.includes(':') ? ctx.host.split(':')[0] : '';
             let datas = [
                 hostname,
@@ -247,17 +252,6 @@ function initCtx(req, res) {
     // Host
     ctx.host = req.headers.host;
 
-    /************************************/
-    /*   Header / param Trace           */
-    /************************************/
-    var header_enabled = false;
-    if(conf.profile_http_header_enabled === true && req.headers) {
-        header_enabled = true;
-        var prefix = conf.profile_header_url_prefix;
-        if(prefix && ctx.service_name.indexOf(prefix) < 0) {
-            header_enabled = false;
-        }
-    }
     /************************************/
     /*   Header / param Trace           */
     /************************************/

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "whatap",
   "homepage": "http://www.whatap.io",
-  "version": "1.0.9",
-  "releaseDate": "20251111",
+  "version": "1.0.10",
+  "releaseDate": "20251212",
   "description": "Monitoring and Profiling Service",
   "main": "index.js",
   "scripts": {},