whatap 0.5.26 → 1.0.0-canary.0

package/lib/observers/redis-observer.js

@@ -1,17 +1,18 @@
 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'),
-    ParamSecurity = require('../util/paramsecurity');
-const shimmer = require('../core/shimmer');
-const {Buffer} = require("buffer");
+    DateUtil = require('../util/dateutil'),
+    AsyncSender = require('../udp/async_sender'),
+    PacketTypeEnum = require('../udp/packet_type_enum'),
+    shimmer = require('../core/shimmer');
+const { AsyncResource } = require('async_hooks');
 
 var RedisObserver = function (agent) {
     this.agent = agent;
-    this.packages = ['redis', 'ioredis'];
+    this.aop = agent.aop;
+    this.packages = ['redis'];
 };
 
 RedisObserver.prototype.inject = function (mod, modName) {
@@ -21,197 +22,361 @@ RedisObserver.prototype.inject = function (mod, modName) {
     mod.__whatap_observe__ = true;
     Logger.initPrint("RedisObserver");
 
-    if (modName === 'redis') {
-        this._injectRedis(mod);
-    } else if (modName === 'ioredis') {
-        this._injectIORedis(mod);
+    if (conf.sql_enabled === false) {
+        return;
     }
-};
 
-RedisObserver.prototype._injectRedis = function (mod) {
+    var self = this;
     var dbc_hash = 0;
-    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 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 client = original.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 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);
+            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 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;
+
+                        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;
                             }
+                        }
 
-                            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]))
-                                }
+                        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(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}'`
+                        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;
                                         }
-                                        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;
+                                    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;
+                                }
+                            );
+                        } else {
+                            // 동기 결과 처리
+                            var command_elapsed = Date.now() - command_start_time;
+                            var resultCount = 0;
 
-                            var result = originalMethod.apply(this, arguments);
-                            sql_step.elapsed = ctx.getElapsedTime();
+                            if (result !== undefined) {
+                                if (Array.isArray(result)) {
+                                    resultCount = result.length;
+                                } else if (typeof result === 'string' || typeof result === 'number') {
+                                    resultCount = 1;
+                                }
+                            }
 
-                            ctx.footprint('Redis Command Done');
+                            ctx.elapsed = command_elapsed;
+                            AsyncSender.send_packet(PacketTypeEnum.TX_SQL, ctx, [dbc, commandText, String(resultCount)]);
+                            ctx.footprint(`Redis ${commandName} Done`);
                             return result;
-                        }catch (e) {
-                            Logger.printError("WHATAP-605", "Redis CRUD error", e, false);
-                            return originalMethod.apply(this, arguments);
                         }
-                    };
-                    wrappedFunction._commandName = cmdName;
-                    return wrappedFunction;
-                });
+                    } 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;
+                    }
+                }
             });
-            return client;
         };
-    });
+    }
 
-    return this;
-};
+    function wrapRedisMethods(client) {
+        var wrappedCount = 0;
+        var skippedCount = 0;
+        var notFoundCount = 0;
+        var alreadyWrappedCount = 0;
 
-RedisObserver.prototype._injectIORedis = function (mod) {
-    var ioredis_dbc_hash = 0;
-    var ioredis_dbc = '';
+        // 클라이언트에 실제로 존재하는 메서드들 확인
+        var availableMethods = Object.getOwnPropertyNames(client)
+            .concat(Object.getOwnPropertyNames(Object.getPrototypeOf(client)))
+            .filter(name => typeof client[name] === 'function' && !name.startsWith('_'))
+            .sort();
 
-    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]);
+        // 한 번의 루프로 모든 메서드 처리
+        Object.keys(REDIS_COMMANDS).forEach(function(methodName) {
 
-    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);
+            if (!client[methodName]) {
+                notFoundCount++;
+                skippedCount++;
+                return;
+            }
+            if (client[methodName].__whatap_wrapped__) {
+                alreadyWrappedCount++;
+                skippedCount++;
+                return;
             }
 
-            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);
+            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 (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 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);
                     }
+                }
 
-                    sql_step.hash = HashUtil.hashFromString(sql);
-                    sql_step.start_time = ctx.getElapsedTime();
-                    DataTextAgent.SQL.add(sql_step.hash, sql);
-                    ctx.profile.push(sql_step);
+                var client = original.apply(this, args);
 
-                    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);
-                }
-            }
+                // Redis 클라이언트 후킹
+                if (client) {
+                    var wrapAttempts = 0;
+                    var maxAttempts = 3;
+                    var wrapCompleted = false;  // 완료 플래그 추가
 
-            return original.apply(this, arguments);
-        };
-    });
+                    function attemptBatchWrap(reason) {
+                        if (wrapCompleted) {
+                            return true;
+                        }
 
-    return this;
-};
+                        wrapAttempts++;
 
-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;
+                        if (wrapRedisMethods(client)) {
+                            wrapCompleted = true;  // 완료 마킹
+                            return true;
+                        }
+
+                        if (wrapAttempts >= maxAttempts) {
+                            return false;
+                        }
+
+                        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');
+                        });
+                    }
+
+                    // 즉시 시도
+                    if (!attemptBatchWrap('Immediate attempt')) {
+                        // 지연 시도
+                        setImmediate(function() {
+                            if (!attemptBatchWrap('setImmediate attempt')) {
+                                // 1초 후 마지막 시도
+                                setTimeout(function() {
+                                    attemptBatchWrap('Final timeout attempt');
+                                }, 1000);
+                            }
+                        });
+                    }
+                }
+
+                if (ctx) {
+                    ctx.elapsed = Date.now() - ctx.start_time;
+                    ctx.footprint('Redis Connecting Done');
+                    ctx.db_opening = false;
+                }
+
+                return client;
+            };
+        });
+        mod.createClient.__whatap_wrapped__ = true;
     }
 };