whatap 1.0.1 → 1.0.2

package/lib/observers/promise-observer.js

@@ -0,0 +1,31 @@
+/**
+ * Created by yunhoi on 12/06/2017.
+ */
+
+var TraceContextManager = require('../trace/trace-context-manager'),
+Logger              = require('../logger');
+
+var PromiseObserver = function (agent) {
+    this.agent = agent;
+    this.packages = ['promise', 'bluebird'];
+};
+
+PromiseObserver.prototype.inject = function (mod, moduleName) {
+
+    var self = this;
+    var aop = self.agent.aop;
+
+    if(mod.__whatap_observe__) {return;}
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("PromiseObserver");
+    aop.both(mod.prototype, 'then'
+        , function (obj, args, lctx) {
+            var ctx = TraceContextManager.getCurrentContext();
+            aop.functionHook(args, -1, function (obj, args) {
+                TraceContextManager.resume(ctx);
+            })
+        });
+
+};
+
+exports.PromiseObserver = PromiseObserver;

package/lib/observers/redis-observer.js

@@ -1,18 +1,17 @@
 var TraceContextManager = require('../trace/trace-context-manager'),
+    DataTextAgent = require('../data/datatext-agent'),
+    SqlStepX = require('../step/sql-stepx'),
+    DBCStep = require('../step/dbc-step'),
     HashUtil = require('../util/hashutil'),
-    Long = require('long'),
     Logger = require('../logger'),
     conf = require('../conf/configure'),
-    DateUtil = require('../util/dateutil'),
-    AsyncSender = require('../udp/async_sender'),
-    PacketTypeEnum = require('../udp/packet_type_enum'),
-    shimmer = require('../core/shimmer');
-const { AsyncResource } = require('async_hooks');
+    ParamSecurity = require('../util/paramsecurity');
+const shimmer = require('../core/shimmer');
+const {Buffer} = require("buffer");
 
 var RedisObserver = function (agent) {
     this.agent = agent;
-    this.aop = agent.aop;
-    this.packages = ['redis'];
+    this.packages = ['redis', 'ioredis'];
 };
 
 RedisObserver.prototype.inject = function (mod, modName) {
@@ -22,361 +21,197 @@ RedisObserver.prototype.inject = function (mod, modName) {
     mod.__whatap_observe__ = true;
     Logger.initPrint("RedisObserver");
 
-    if (conf.sql_enabled === false) {
-        return;
+    if (modName === 'redis') {
+        this._injectRedis(mod);
+    } else if (modName === 'ioredis') {
+        this._injectIORedis(mod);
     }
+};
 
-    var self = this;
+RedisObserver.prototype._injectRedis = function (mod) {
     var dbc_hash = 0;
-    var dbc = 'redis://';
-
-    // Redis 명령어 매핑 (한 번만 정의)
-    var REDIS_COMMANDS = {
-        // 기본 명령어들
-        'ping': 'PING', 'get': 'GET', 'set': 'SET', 'del': 'DEL', 'exists': 'EXISTS', 'keys': 'KEYS',
-        'setex': 'SETEX', 'setEx': 'SETEX', 'expire': 'EXPIRE', 'expireAt': 'EXPIREAT', 'expireat': 'EXPIREAT',
-        'ttl': 'TTL', 'incr': 'INCR', 'decr': 'DECR', 'incrBy': 'INCRBY', 'incrby': 'INCRBY',
-        'decrBy': 'DECRBY', 'decrby': 'DECRBY', 'mGet': 'MGET', 'mget': 'MGET', 'mSet': 'MSET', 'mset': 'MSET',
-
-        // Hash 명령어들
-        'hSet': 'HSET', 'hset': 'HSET', 'hGet': 'HGET', 'hget': 'HGET', 'hGetAll': 'HGETALL', 'hgetall': 'HGETALL',
-        'hMGet': 'HMGET', 'hmget': 'HMGET', 'hMSet': 'HMSET', 'hmset': 'HMSET', 'hDel': 'HDEL', 'hdel': 'HDEL',
-
-        // List 명령어들
-        'lPush': 'LPUSH', 'lpush': 'LPUSH', 'rPush': 'RPUSH', 'rpush': 'RPUSH', 'lPop': 'LPOP', 'lpop': 'LPOP',
-        'rPop': 'RPOP', 'rpop': 'RPOP', 'lRange': 'LRANGE', 'lrange': 'LRANGE', 'lLen': 'LLEN', 'llen': 'LLEN',
-        'lSet': 'LSET', 'lset': 'LSET', 'lRem': 'LREM', 'lrem': 'LREM',
-
-        // Set 명령어들
-        'sAdd': 'SADD', 'sadd': 'SADD', 'sMembers': 'SMEMBERS', 'smembers': 'SMEMBERS', 'sRem': 'SREM', 'srem': 'SREM',
-        'sCard': 'SCARD', 'scard': 'SCARD',
-
-        // Sorted Set 명령어들
-        'zAdd': 'ZADD', 'zadd': 'ZADD', 'zRange': 'ZRANGE', 'zrange': 'ZRANGE', 'zRem': 'ZREM', 'zrem': 'ZREM'
-    };
-
-    // DBC 정보 설정
-    function setupDbcInfo(connectionOptions) {
-        if (dbc_hash === 0 && connectionOptions) {
-            dbc = 'redis://';
-            dbc += connectionOptions.host || 'localhost';
-            dbc += ':';
-            dbc += connectionOptions.port || 6379;
-            dbc += '/';
-            dbc += connectionOptions.db || 0;
-            dbc_hash = HashUtil.hashFromString(dbc);
-        }
-    }
-
-    // 에러 처리 함수
-    function handleRedisError(ctx, err) {
-        if (!err) return;
-
-        try {
-            var errorClass = err.code || err.name || 'RedisError';
-            var errorMessage = err.message || 'redis error';
-
-            if (!ctx.error) ctx.error = 1;
-            ctx.status = 500;
-            var errors = [errorClass, errorMessage];
-
-            AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
-        } catch (e) {
-            Logger.printError('WHATAP-216', 'Error handling Redis error', e, false);
-        }
-    }
-
-    // 통합 모니터링 함수 (한 번만 정의, 모든 명령어에서 재사용)
-    function createRedisWrapper(originalFunction, commandName) {
-        return function wrappedMethod() {
-            var ctx = TraceContextManager.getCurrentContext();
-            if (!ctx) {
-                return originalFunction.apply(this, arguments);
-            }
-
-            var args = Array.prototype.slice.call(arguments);
-            var callback = null;
-            var hasCallback = false;
-
-            // 콜백 함수 찾기
-            if (args.length > 0 && typeof args[args.length - 1] === 'function') {
-                callback = args[args.length - 1];
-                hasCallback = true;
-            }
-
-            const asyncResource = new AsyncResource('redis-command');
-
-            return asyncResource.runInAsyncScope(() => {
-                // DB 연결 패킷 전송
-                ctx.start_time = Date.now();
-                ctx.elapsed = 0;
-                ctx.active_sqlhash = true;
-                AsyncSender.send_packet(PacketTypeEnum.TX_DB_CONN, ctx, [dbc]);
-
-                // Redis 명령 시작
-                var command_start_time = Date.now();
-                ctx.footprint(`Redis ${commandName} Start`);
-
-                // Redis에서는 args에서 쿼리 조합 (Python APM 방식 참고)
-                var queryParts = [commandName];
-                if (args && args.length > 0) {
-                    // 콜백 함수 제외하고 실제 Redis 인자들만 처리
-                    var redisArgs = hasCallback ? args.slice(0, -1) : args;
-                    // 각 인자를 문자열로 변환하고 20자로 제한
-                    var argStrings = redisArgs.map(function(arg) {
-                        var argStr = String(arg);
-                        return argStr.length > 20 ? argStr.substring(0, 20) + '...' : argStr;
-                    });
-                    queryParts = queryParts.concat(argStrings);
+    var dbc = '';
+
+    const selectCommand = new Set(['get', 'hGet', 'hmGet']);
+    const insertCommand = new Set(['set', 'hSet', 'hset', 'hmSet', 'hmset', 'zAdd', 'zadd', 'lSet', 'lset']);
+    const updateCommand = new Set(['set', 'lSet', 'lset', 'hSet', 'hset', 'zAdd', 'zadd']);
+    const deleteCommand = new Set(['del', 'lRem', 'sRem', 'srem', 'hDel', 'hdel', 'zRem', 'zrem']);
+    const commands = new Set([...selectCommand, ...insertCommand, ...updateCommand, ...deleteCommand]);
+
+    shimmer.wrap(mod, 'createClient', function (original) {
+        return function wrappedCreateClient() {
+            if (dbc_hash === 0) {
+                if (arguments.length > 0) {
+                    var info = (arguments[0] || {});
+                    dbc = info.url || '';
+                    dbc_hash = HashUtil.hashFromString(dbc);
+
+                    DataTextAgent.DBC.add(dbc_hash, dbc);
+                    DataTextAgent.METHOD.add(dbc_hash, dbc);
+                    DataTextAgent.ERROR.add(dbc_hash, dbc);
                 }
-                var commandText = `Redis ` + queryParts.join(' ');
+            }
 
-                if (hasCallback) {
-                    // 비동기 콜백 처리
-                    const callbackResource = new AsyncResource('redis-callback');
-                    args[args.length - 1] = asyncResource.bind(function(err, result) {
-                        var command_elapsed = Date.now() - command_start_time;
-                        var resultCount = 0;
+            var client = original.apply(this, arguments);
 
-                        if (err) {
-                            handleRedisError(ctx, err);
-                        } else if (result !== undefined) {
-                            if (Array.isArray(result)) {
-                                resultCount = result.length;
-                            } else if (typeof result === 'string' || typeof result === 'number') {
-                                resultCount = 1;
+            const commandsArray = Array.from(commands);
+            commandsArray.forEach(cmdName => {
+                shimmer.wrap(client, cmdName, function (originalMethod) {
+                    const wrappedFunction = function wrappedSendCommand() {
+                        try{
+                            var ctx = TraceContextManager.getCurrentContext();
+                            if (!ctx) {
+                                return originalMethod.apply(this, arguments);
                             }
-                        }
 
-                        ctx.elapsed = command_elapsed;
-                        ctx.active_sqlhash = false;
-                        AsyncSender.send_packet(PacketTypeEnum.TX_SQL, ctx, [dbc, commandText, String(resultCount)]);
-                        ctx.footprint(`Redis ${commandName} Done`);
-
-                        if (callback && typeof callback === 'function') {
-                            return callbackResource.bind(callback).apply(this, arguments);
-                        }
-                    });
-
-                    try {
-                        return originalFunction.apply(this, args);
-                    } catch (err) {
-                        handleRedisError(ctx, err);
-                        throw err;
-                    }
-                } else {
-                    // Promise 또는 동기 처리
-                    try {
-                        var result = originalFunction.apply(this, args);
-
-                        // Promise 결과 처리
-                        if (result && typeof result.then === 'function') {
-                            return result.then(
-                                function(res) {
-                                    var command_elapsed = Date.now() - command_start_time;
-                                    var resultCount = 0;
-
-                                    if (res !== undefined) {
-                                        if (Array.isArray(res)) {
-                                            resultCount = res.length;
-                                        } else if (typeof res === 'string' || typeof res === 'number') {
-                                            resultCount = 1;
-                                        }
-                                    }
-
-                                    ctx.elapsed = command_elapsed;
-                                    ctx.active_sqlhash = false;
-                                    AsyncSender.send_packet(PacketTypeEnum.TX_SQL, ctx, [dbc, commandText, String(resultCount)]);
-                                    ctx.footprint(`Redis ${commandName} Done`);
-                                    return res;
-                                },
-                                function(err) {
-                                    handleRedisError(ctx, err);
-                                    var command_elapsed = Date.now() - command_start_time;
-                                    ctx.elapsed = command_elapsed;
-                                    ctx.active_sqlhash = false;
-                                    AsyncSender.send_packet(PacketTypeEnum.TX_SQL, ctx, [dbc, commandText, '0']);
-                                    ctx.footprint(`Redis ${commandName} Done`);
-                                    throw err;
+                            var dbc_step = new DBCStep();
+                            dbc_step.hash = dbc_hash;
+                            ctx.profile.push(dbc_step);
+
+                            ctx.footprint('Redis Command Start');
+
+                            var command = wrappedFunction._commandName || 'unknown';
+                            var sql = `${command.toUpperCase()}`;
+                            var sql_step = new SqlStepX();
+                            sql_step.start_time = ctx.getElapsedTime();
+                            sql_step.dbc = dbc_hash;
+
+                            if(conf.getProperty('profile_redis_param_enabled', false)){
+                                if (arguments[0] && typeof arguments[0] === 'string')
+                                    sql += ' ' + arguments[0];
+                                else if (arguments[0] && Array.isArray(arguments[0]))
+                                    sql += ' ' + JSON.stringify(arguments[0]);
+                                else if (arguments[0] && typeof arguments[0] === 'object'){
+                                    sql += ' ' + JSON.stringify(Object.keys(arguments[0]))
                                 }
-                            );
-                        } else {
-                            // 동기 결과 처리
-                            var command_elapsed = Date.now() - command_start_time;
-                            var resultCount = 0;
 
-                            if (result !== undefined) {
-                                if (Array.isArray(result)) {
-                                    resultCount = result.length;
-                                } else if (typeof result === 'string' || typeof result === 'number') {
-                                    resultCount = 1;
+                                if(arguments[1] && arguments[1].length > 0){
+                                    var args = Array.isArray(arguments[1]) ? arguments[1] : [arguments[1]];
+                                    sql_step.setTrue(1);
+                                    var crc = {value: 0};
+                                    const result = args.map((arg) => {
+                                        if (typeof arg === 'string') {
+                                            return `'${arg}'`
+                                        }
+                                        return arg
+                                    }).toString()
+                                    sql_step.p2 = toParamBytes(result, crc);
+                                    sql_step.pcrc = crc.value;
                                 }
                             }
+                            sql_step.hash = HashUtil.hashFromString(sql);
+                            ctx.profile.push(sql_step);
+
+                            DataTextAgent.SQL.add(sql_step.hash, sql);
 
-                            ctx.elapsed = command_elapsed;
-                            AsyncSender.send_packet(PacketTypeEnum.TX_SQL, ctx, [dbc, commandText, String(resultCount)]);
-                            ctx.footprint(`Redis ${commandName} Done`);
+                            var result = originalMethod.apply(this, arguments);
+                            sql_step.elapsed = ctx.getElapsedTime();
+
+                            ctx.footprint('Redis Command Done');
                             return result;
+                        }catch (e) {
+                            Logger.printError("WHATAP-605", "Redis CRUD error", e, false);
+                            return originalMethod.apply(this, arguments);
                         }
-                    } catch (commandError) {
-                        handleRedisError(ctx, commandError);
-                        var command_elapsed = Date.now() - command_start_time;
-                        ctx.elapsed = command_elapsed;
-                        AsyncSender.send_packet(PacketTypeEnum.TX_SQL, ctx, [dbc, commandText, '0']);
-                        ctx.footprint(`Redis ${commandName} Done`);
-                        throw commandError;
-                    }
-                }
+                    };
+                    wrappedFunction._commandName = cmdName;
+                    return wrappedFunction;
+                });
             });
+            return client;
         };
-    }
+    });
 
-    function wrapRedisMethods(client) {
-        var wrappedCount = 0;
-        var skippedCount = 0;
-        var notFoundCount = 0;
-        var alreadyWrappedCount = 0;
+    return this;
+};
 
-        // 클라이언트에 실제로 존재하는 메서드들 확인
-        var availableMethods = Object.getOwnPropertyNames(client)
-            .concat(Object.getOwnPropertyNames(Object.getPrototypeOf(client)))
-            .filter(name => typeof client[name] === 'function' && !name.startsWith('_'))
-            .sort();
+RedisObserver.prototype._injectIORedis = function (mod) {
+    var ioredis_dbc_hash = 0;
+    var ioredis_dbc = '';
 
-        // 한 번의 루프로 모든 메서드 처리
-        Object.keys(REDIS_COMMANDS).forEach(function(methodName) {
+    const selectCommand = new Set(['get', 'hget', 'hmget', 'zrange', 'smembers', 'lrange']);
+    const insertCommand = new Set(['set', 'hset', 'hmset', 'zadd', 'lset', 'sadd', 'lpush', 'rpush', 'evalsha']);
+    const updateCommand = new Set(['set', 'lset', 'hset', 'zadd']);
+    const deleteCommand = new Set(['del', 'lrem', 'srem', 'hdel', 'zrem']);
+    const commands = new Set([...selectCommand, ...insertCommand, ...updateCommand, ...deleteCommand]);
 
-            if (!client[methodName]) {
-                notFoundCount++;
-                skippedCount++;
-                return;
-            }
-            if (client[methodName].__whatap_wrapped__) {
-                alreadyWrappedCount++;
-                skippedCount++;
-                return;
+    shimmer.wrap(mod.prototype, 'sendCommand', function (original) {
+        return function wrappedSendCommand(command) {
+            // Get trace context
+            var ctx = TraceContextManager.getCurrentContext();
+            if (!ctx) {
+                return original.apply(this, arguments);
             }
 
-            try {
-                // 원본 함수 참조 저장
-                var originalFunction = client[methodName];
-                client[methodName] = createRedisWrapper(originalFunction, REDIS_COMMANDS[methodName]);
-                client[methodName].__whatap_wrapped__ = true;
-                wrappedCount++;
-            } catch (e) {
-                skippedCount++;
-                Logger.printError('WHATAP-217', `Error wrapping ${methodName}`, e, false);
+            if (ioredis_dbc_hash === 0 && this.options) {
+                ioredis_dbc = 'redis://';
+                ioredis_dbc += this.options.host || '';
+                ioredis_dbc += ':';
+                ioredis_dbc += this.options.port || '';
+                ioredis_dbc_hash = HashUtil.hashFromString(ioredis_dbc);
+                DataTextAgent.DBC.add(ioredis_dbc_hash, ioredis_dbc);
             }
-        });
-
-        return wrappedCount > 0;
-    }
-
-    // createClient 래핑
-    if (mod.createClient && !mod.createClient.__whatap_wrapped__) {
-        shimmer.wrap(mod, 'createClient', function(original) {
-            return function wrappedCreateClient() {
-                var args = Array.prototype.slice.call(arguments);
-                var ctx = TraceContextManager.getCurrentContext();
-
-                if (ctx) {
-                    ctx.start_time = Date.now();
-                    ctx.footprint('IORedis Client Created');
-                    ctx.db_opening = true;
-                }
-
-                if (args.length > 0) {
-                    var options = args[0] || {};
-                    // URL에서 연결 정보 추출
-                    if (typeof options === 'string') {
-                        try {
-                            var url = new URL(options);
-                            setupDbcInfo({
-                                host: url.hostname,
-                                port: parseInt(url.port) || 6379,
-                                db: url.pathname.slice(1) || 0
-                            });
-                        } catch (e) {
-                            setupDbcInfo({ host: 'localhost', port: 6379, db: 0 });
-                        }
-                    } else if (options.url) {
-                        try {
-                            var url = new URL(options.url);
-                            setupDbcInfo({
-                                host: url.hostname,
-                                port: parseInt(url.port) || 6379,
-                                db: options.database || url.pathname.slice(1) || 0
-                            });
-                        } catch (e) {
-                            setupDbcInfo(options);
-                        }
-                    } else {
-                        setupDbcInfo(options);
-                    }
-                }
-
-                var client = original.apply(this, args);
 
-                // Redis 클라이언트 후킹
-                if (client) {
-                    var wrapAttempts = 0;
-                    var maxAttempts = 3;
-                    var wrapCompleted = false;  // 완료 플래그 추가
-
-                    function attemptBatchWrap(reason) {
-                        if (wrapCompleted) {
-                            return true;
-                        }
-
-                        wrapAttempts++;
-
-                        if (wrapRedisMethods(client)) {
-                            wrapCompleted = true;  // 완료 마킹
-                            return true;
-                        }
-
-                        if (wrapAttempts >= maxAttempts) {
-                            return false;
+            if (command && command.name && commands.has(command.name.toLowerCase())) {
+                var dbc_step = new DBCStep();
+                dbc_step.hash = ioredis_dbc_hash;
+                dbc_step.start_time = ctx.getElapsedTime();
+                ctx.profile.push(dbc_step);
+
+                try {
+                    var sql_step = new SqlStepX();
+                    var sql = command.name.toUpperCase();
+                    if(conf.getProperty('profile_redis_param_enabled', false)){
+                        var args = command.args;
+                        var key = args.shift();
+                        if (key && typeof key === 'string')
+                            sql += ' ' + key;
+
+                        if(args && args.length > 0){
+                            sql_step.setTrue(1);
+                            var crc = {value: 0};
+                            const result = args.map((arg) => {
+                                if (typeof arg === 'string') {
+                                    return `'${arg}'`
+                                }
+                                return arg;
+                            }).toString()
+                            sql_step.p2 = toParamBytes(result, crc);
+                            sql_step.pcrc = crc.value;
                         }
-
-                        return false;
                     }
 
-                    // 이벤트 기반 래핑
-                    if (client.on && typeof client.on === 'function') {
-                        client.on('connect', function() {
-                            attemptBatchWrap('Redis connect event');
-                        });
-
-                        client.on('ready', function() {
-                            attemptBatchWrap('Redis ready event');
-                        });
-                    }
+                    sql_step.hash = HashUtil.hashFromString(sql);
+                    sql_step.start_time = ctx.getElapsedTime();
+                    DataTextAgent.SQL.add(sql_step.hash, sql);
+                    ctx.profile.push(sql_step);
 
-                    // 즉시 시도
-                    if (!attemptBatchWrap('Immediate attempt')) {
-                        // 지연 시도
-                        setImmediate(function() {
-                            if (!attemptBatchWrap('setImmediate attempt')) {
-                                // 1초 후 마지막 시도
-                                setTimeout(function() {
-                                    attemptBatchWrap('Final timeout attempt');
-                                }, 1000);
-                            }
-                        });
-                    }
+                    var originalPromise = original.apply(this, arguments);
+                    return originalPromise.finally(function () {
+                        dbc_step.elapsed = ctx.getElapsedTime() - dbc_step.start_time;
+                        sql_step.elapsed = ctx.getElapsedTime() - sql_step.start_time;
+                    });
+                } catch (e) {
+                    Logger.printError("WHATAP-605", "ioredis CRUD error", e, false);
+                    return original.apply(this, arguments);
                 }
+            }
 
-                if (ctx) {
-                    ctx.elapsed = Date.now() - ctx.start_time;
-                    ctx.footprint('Redis Connecting Done');
-                    ctx.db_opening = false;
-                }
+            return original.apply(this, arguments);
+        };
+    });
+
+    return this;
+};
 
-                return client;
-            };
-        });
-        mod.createClient.__whatap_wrapped__ = true;
+var toParamBytes = function (p, crc) {
+    if (p == null || p.length === 0) {
+        return null;
+    }
+    try {
+        return ParamSecurity.encrypt(Buffer.from(p, 'utf8'), crc);
+    } catch (e) {
+        return null;
     }
 };
 

package/lib/observers/schedule-observer.js

@@ -0,0 +1,67 @@
+/**
+ * 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'),
+ DataTextAgent       = require('../data/datatext-agent'),
+ DataProfileAgent    = require('../data/dataprofile-agent'),
+ EventLevel          = require('../data/event-level'),
+ TxRecord          = require('../service/tx-record'),
+ ProfilePack         = require('../pack/profile-pack'),
+ SecurityMaster      = require('../net/security-master'),
+ HashUtil            = require('../util/hashutil'),
+ DateUtil            = require('../util/dateutil'),
+ ResourceProfile     = require('../util/resourceprofile'),
+ MessageStep         = require('../step/message-step'),
+ Logger              = require('../logger');
+
+var ScheduleObserver = function(agent){
+ this.agent = agent;
+ this.packages = ['node-schedule'];
+};
+
+ScheduleObserver.prototype.inject = function (mod, moduleName) {
+    if(mod.__whatap_observe__) { return; }
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("ScheduleObserver");
+    var self = this;
+    var aop = self.agent.aop;
+
+    aop.after(mod, 'scheduleJob',
+    function (obj, args, ret) {
+        var orig = ret.job;
+        if(!orig) return;
+        ret.job = async () => {
+            var ctx = null;
+            if(conf['trace_node_schedule_enabled']) {
+                ctx = TraceContextManager.startTrace('ScheduleJob');
+            }
+            var result = null;
+            try {
+                result = await orig.apply(this, arguments);   
+            } catch(err) {
+                Logger.printError('WHATAP-607', 'End batch error..', err, false);
+            }
+            if(conf['trace_node_schedule_enabled'] && ctx != null) {
+                try {
+                    var step = new MessageStep();
+                    step.msg = 'Node ScheduleJob finished!!!!!'
+                    step.hash =  HashUtil.hashFromString(step.msg);;
+                    step.start_time = ctx.getElapsedTime();
+                    step.desc = '';
+                    DataTextAgent.MESSAGE.add(step.hash, step.msg);
+                    ctx.profile.add(step);
+                    TraceContextManager.endTrace(ctx);
+                    if(ctx != null) ctx = null;
+                } catch(err) {}
+             }
+            return result;
+        };
+    }
+);
+};
+
+exports.ScheduleObserver = ScheduleObserver;