whatap 1.0.1 → 1.0.2

package/lib/observers/global-observer.js

@@ -4,18 +4,20 @@
  * can be found in the LICENSE file.
  */
 
-var TraceContextManager = require('../trace/trace-context-manager');
+var TraceContextManager = require('../trace/trace-context-manager'),
+    Logger = require('../logger');
 
+var HttpStepX = require('../step/http-stepx');
 const Hexa32 = require("../util/hexa32");
 const SecurityMaster = require("../net/security-master");
 const conf = require("../conf/configure");
 const KeyGen = require("../util/keygen");
-const TraceHelper = require('../util/trace-helper');
+const HashUtil = require("../util/hashutil");
+const DataTextAgent = require("../data/datatext-agent");
 const shimmer = require('../core/shimmer');
-const AsyncSender = require('../udp/async_sender');
-const { PacketTypeEnum } = require("../../lib/udp");
-const Transfer = require('../util/transfer');
-const TraceHttpc = require('../trace/trace-httpc');
+const StatError = require("../stat/stat-error");
+const TextTypes = require("../lang/text-types");
+const URLPatternDetector  = require('../trace/serviceurl-pattern-detector').Detector;
 
 var GlobalObserver = function (agent) {
     this.agent = agent;
@@ -30,28 +32,30 @@ conf.on('transaction_status_error_enable', function (newProps) {
 GlobalObserver.prototype.inject = function (mod, moduleName) {
     var self = this;
 
+    ['setTimeout', 'setInterval', 'setImmediate'].forEach(function (funcName) {
+        self.agent.aop.before(mod, funcName, function (obj, args) {
+            if(args[args.length - 1] === 'whatap') { return; }
+
+            var cached_id = TraceContextManager.getCurrentId();
+            self.agent.aop.functionHook(args, 0, function (obj, args) {
+                TraceContextManager.resume(cached_id);
+                cached_id = null;
+            });
+        });
+    });
+
     shimmer.wrap(mod, 'fetch', function(original) {
         return async function(...args) {
             var info = args[1] ? args[1] : {};
             var ctx = TraceContextManager._asyncLocalStorage.getStore();
 
             if (ctx) {
-                ctx.start_time = Date.now(); // start_time 설정 추가
-
-                TraceHelper.interTxTraceAutoOn(ctx);
+                interTxTraceAutoOn(ctx);
 
                 if (conf.getProperty('mtrace_enabled', false)) {
                     addTraceHeaders(info, ctx);
                     args[1] = info;
                 }
-
-                if (args[0]) {
-                    const url = new URL(args[0]);
-                    ctx.httpc_url = url.pathname + url.search;
-                    ctx.httpc_host = url.hostname;
-                    ctx.httpc_port = url.port || (url.protocol === 'https:' ? 443 : 80);
-                    ctx.active_httpc_hash = true;
-                }
             }
 
             try {
@@ -67,100 +71,171 @@ GlobalObserver.prototype.inject = function (mod, moduleName) {
 };
 
 function addTraceHeaders(info, ctx) {
-    // 헤더 객체 초기화
-    if (!info.headers) {
-        info.headers = {};
+    if (info.headers) {
+        info.headers['x-wtap-po'] = transferPOID(ctx);
+    } else {
+        info.headers = {
+            'x-wtap-po': transferPOID(ctx)
+        };
     }
-
-    info.headers['x-wtap-po'] = Transfer.POID();
-
-    if (conf.stat_mtrace_enabled) {
-        info.headers[conf._trace_mtrace_spec_key1] = Transfer.SPEC_URL(ctx);
+    if (conf.getProperty('stat_mtrace_enabled', false)) {
+        info.headers[conf._trace_mtrace_spec_key1] = transferSPEC_URL(ctx);
     }
-
-    if (!ctx.mtid.isZero()) {
-        info.headers[conf._trace_mtrace_caller_key] = Transfer.MTID_CALLERTX(ctx);
+    if (ctx.mtid.isZero() === false) {
+        info.headers[conf._trace_mtrace_caller_key] = transferMTID_CALLERTX(ctx);
     }
-
-    ctx.mcallee = KeyGen.getMtid();
-    info.headers[conf._trace_mtrace_callee_key] = Hexa32.toString32(ctx.mcallee);
 }
 
 function handleResponse(ctx, args, response) {
     if (!ctx || !args[0]) return;
 
-    // Error handling for 4xx, 5xx responses
-    if (!response.ok && response.status >= 400 && transaction_status_error_enable) {
-        let error = {
-            class: response.statusText,
-            message: ''
-        }
-        interceptorError(response.status, error, ctx);
+    const url = new URL(args[0]);
+    setupContext(ctx, url);
+
+    var step = createStep(ctx, url);
+
+    if (!response.ok && transaction_status_error_enable) {
+        recordError(ctx, step, response);
     }
 
-    endHttpc(ctx);
+    ctx.profile.push(step);
 }
 
 function handleError(ctx, args, err) {
     if (!ctx || !args[0]) return;
+    ctx.error_class = err.name || err.constructor?.name || 'HttpError';
+    ctx.error_message = err.message;
+
+    const url = new URL(args[0]);
+    setupContext(ctx, url);
 
-    const networkErrorToStatusCode = {
-        'ECONNREFUSED': 503,
-        'ETIMEDOUT': 504,
-        'ENOTFOUND': 502,
-        'ECONNRESET': 503,
-        'EPIPE': 503,
-        'EHOSTUNREACH': 503,
-    };
-    const statusCode = networkErrorToStatusCode[err.code] || 500;
+    var step = createStep(ctx, url);
 
     if (transaction_status_error_enable) {
-        let error = {
-            class: err.code || err.name,
-            message: err.message || ''
-        }
-        interceptorError(statusCode, error, ctx);
+        recordError(ctx, step, err);
     }
 
-    endHttpc(ctx);
+    ctx.profile.push(step);
 }
 
-function interceptorError(statusCode, error, ctx) {
-    if (!ctx) {
-        return;
-    }
-
-    ctx.status = statusCode;
-    let errors = [];
-    let error_message = 'Request failed with status code ';
+function setupContext(ctx, url) {
+    ctx.httpc_host = url.hostname;
+    ctx.httpc_url = url.pathname;
+    ctx.httpc_port = url.port || (url.protocol === 'https:' ? 443 : 80);
+}
 
-    if (statusCode >= 400 && !ctx.error) {
-        ctx.error = 1;
+function createStep(ctx, url) {
+    var step = new HttpStepX();
+    step.start_time = ctx.getElapsedTime();
+    step.url = HashUtil.hashFromString(ctx.httpc_url);
+    DataTextAgent.HTTPC_URL.add(step.url, ctx.httpc_url);
+    step.host = HashUtil.hashFromString(ctx.httpc_host);
+    DataTextAgent.HTTPC_HOST.add(step.host, ctx.httpc_host);
+    step.port = ctx.httpc_port;
+    return step;
+}
 
-        errors.push(error.class);
-        if (error.message) {
-            errors.push(error.message);
+function recordError(ctx, step, response) {
+    if (step.error.isZero()) {
+        const errorMessage = ctx.error_message = response.statusText || (response.cause ? response.cause.message : '') || response.message || 'Unknown error';
+        step.error = StatError.addError(response.status || null, errorMessage, ctx.service_hash, TextTypes.HTTPC_URL, step.url);
+
+        if (response.status) {
+            if (response.status >= 400 && response.status < 500) {
+                ctx.error_class = `HttpClientError`;
+            } else if (response.status >= 500) {
+                ctx.error_class = `HttpServerError`;
+            } else {
+                ctx.error_class = `HttpError`;
+            }
         } else {
-            errors.push(error_message + statusCode);
+            ctx.error_class = 'HttpError';
         }
 
-        AsyncSender.send_packet(PacketTypeEnum.TX_ERROR, ctx, errors);
+        if (ctx.error.isZero()) {
+            ctx.error = step.error;
+            ctx.statusCode = response.status || null;
+            ctx.statusMessage = errorMessage;
+        }
     }
 }
 
-function endHttpc(ctx) {
-    if (ctx == null) {
-        return;
-    }
+var transfer_poid;
+function transferPOID(ctx) {
+    if (transfer_poid)
+        return transfer_poid;
+    transfer_poid = Hexa32.toString32(SecurityMaster.PCODE) + ','
+        + Hexa32.toString32(SecurityMaster.OKIND) + ',' + Hexa32.toString32(SecurityMaster.OID);
+    return transfer_poid;
+}
+
+function transferMTID_CALLERTX(ctx) {
+    if (ctx.transfer_id)
+        return ctx.transfer_id;
+    var x = Hexa32.toString32(ctx.mtid) + ',' + (ctx.mdepth + 1) + ',' + Hexa32.toString32(ctx.txid);
+    ctx.transfer_id = x;
+    return ctx.transfer_id;
+}
 
-    ctx.active_httpc_hash = false;
-    let urls = `${ctx.httpc_host}:${ctx.httpc_port}${ctx.httpc_url}`;
-    let httpcDatas = [urls, ctx.mcallee];
-    ctx.elapsed = Date.now() - ctx.start_time;
-    TraceHttpc.isSlowHttpc(ctx);
-    AsyncSender.send_packet(PacketTypeEnum.TX_HTTPC, ctx, httpcDatas);
+function transferSPEC_URL(ctx) {
+    if (ctx.transfer_info)
+        return ctx.transfer_info;
+    var x = conf.mtrace_spec + ',' + ctx.service_hash;
+    ctx.transfer_info = x;
+    return ctx.transfer_info;
 }
 
-// interTxTraceAutoOn function moved to util/trace-helper.js
+var check_seq = 1;
+function interTxTraceAutoOn(ctx) {
+    if (conf.mtrace_enabled == false || ctx.httpc_checked || ctx.mtid.isZero() === false)
+        return;
+    ctx.httpc_checked = true;
+    if (conf.mtrace_rate >= 100) {
+        ctx.mtid = KeyGen.next();
+        return;
+    }
+    check_seq++;
+    switch (Math.floor(conf.mtrace_rate / 10)) {
+        case 10:
+            ctx.mtid = KeyGen.next();
+            break;
+        case 9:
+            if (check_seq % 10 !== 0)
+                ctx.mtid = KeyGen.next();
+            break;
+        case 8:
+            if (check_seq % 5 !== 0)
+                ctx.mtid = KeyGen.next();
+            break;
+        case 7:
+            if (check_seq % 4 !== 0)
+                ctx.mtid = KeyGen.next();
+            break;
+        case 6:
+            if (check_seq % 3 !== 0)
+                ctx.mtid = KeyGen.next();
+            break;
+        case 5:
+            if (check_seq % 2 === 0)
+                ctx.mtid = KeyGen.next();
+            break;
+        case 4:
+            if (check_seq % 3 === 0 || check_seq % 5 === 0)
+                ctx.mtid = KeyGen.next();
+            break;
+        case 3:
+            if (check_seq % 4 === 0 || check_seq % 5 === 0)
+                ctx.mtid = KeyGen.next();
+            break;
+        case 2:
+            if (check_seq % 5 === 0)
+                ctx.mtid = KeyGen.next();
+            break;
+        case 1:
+            if (check_seq % 10 === 0)
+                ctx.mtid = KeyGen.next();
+            break;
+    }
+}
 
 exports.GlobalObserver = GlobalObserver;

package/lib/observers/grpc-observer.js

@@ -0,0 +1,336 @@
+/**
+ * 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');
+const { Detector: URLPatternDetector } = require("../trace/serviceurl-pattern-detector");
+const HashUtil = require("../util/hashutil");
+const DataTextAgent = require("../data/datatext-agent");
+const ResourceProfile = require("../util/resourceprofile");
+const ProfilePack = require('../pack/profile-pack');
+const TxRecord = require('../service/tx-record');
+const DateUtil = require('../util/dateutil');
+const SecurityMaster = require('../net/security-master');
+const DataProfileAgent = require("../data/dataprofile-agent");
+const MessageStep = require("../step/message-step");
+const MeterService = require('../counter/meter/meter-service').MeterService;
+
+const shimmer = require('../core/shimmer');
+const StatError = require("../stat/stat-error");
+
+var grpc_profile_enabled = conf.getProperty('grpc_profile_enabled', true);
+var grpc_profile_stream_client_enabled = conf.getProperty('grpc_profile_stream_client_enabled', true);
+var grpc_profile_stream_server_enabled = conf.getProperty('grpc_profile_stream_server_enabled', true);
+var grpc_profile_ignore_method = conf.getProperty('grpc_profile_ignore_method', '');
+var ignore_method_set = null;
+conf.on('grpc_profile_enabled', function(newProperty) {
+    grpc_profile_enabled = newProperty;
+});
+conf.on('grpc_profile_stream_client_enabled', function(newProperty) {
+    grpc_profile_stream_client_enabled = newProperty;
+});
+conf.on('grpc_profile_stream_server_enabled', function(newProperty) {
+    grpc_profile_stream_server_enabled = newProperty;
+});
+conf.on('grpc_profile_ignore_method', function(newProperty) {
+    grpc_profile_ignore_method = newProperty;
+});
+
+var GRpcObserver = function(agent) {
+    this.agent = agent;
+    this.packages = ['@grpc/grpc-js'];
+};
+
+const types = {
+    unary: 'unary',
+    client_stream: 'clientStream',
+    server_stream: 'serverStream',
+    bidi: 'bidi'
+};
+
+GRpcObserver.prototype.inject = function(mod, moduleName) {
+    if (mod.__whatap_observe__) {
+        return;
+    }
+    mod.__whatap_observe__ = true;
+    Logger.initPrint("GRpcObserver");
+
+    if (grpc_profile_enabled) {
+        shimmer.wrap(mod.Server.prototype, 'register', wrapRegister);
+        shimmer.wrap(mod.Client.prototype, 'register', wrapRegister);
+    }
+};
+
+function checkIgnoreMethod(ignore_method, method_name){
+    try{
+        if (ignore_method) {
+            ignore_method_set = new Set(ignore_method.split(','));
+        } else {
+            ignore_method_set = null;
+        }
+        if (ignore_method_set && ignore_method_set.has(method_name)) {
+            return true;
+        }
+    }catch (e) {
+        Logger.printError('WHATAP-703', 'gRPC checkIgnoreMethod error: ' + e, false);
+    }
+    return false;
+}
+
+function wrapHandler(handler, methodName, type) {
+    return function(call, callback) {
+        var method_name = methodName.includes('/') ? methodName.substring(methodName.lastIndexOf('/')+1, methodName.length) : methodName
+        if (!grpc_profile_enabled || checkIgnoreMethod(conf.getProperty('grpc_profile_ignore_method', ''), method_name)) {
+            return handler.call(this, call, callback);
+        }
+
+        TraceContextManager._asyncLocalStorage.run(initCtx(), () => {
+            var ctx = TraceContextManager._asyncLocalStorage.getStore();
+            try {
+                if (!ctx) {
+                    return handler.call(this, call, callback);
+                }
+
+                ctx.service_name = methodName;
+                ctx.service_hash = HashUtil.hashFromString(methodName);
+
+                var step_type = new MessageStep();
+                step_type.hash = HashUtil.hashFromString('Type');
+                step_type.start_time = ctx.getElapsedTime();
+                step_type.desc = type;
+                DataTextAgent.MESSAGE.add(step_type.hash, "Type");
+                ctx.profile.push(step_type);
+
+                var step_method = new MessageStep();
+                step_method.hash = HashUtil.hashFromString('Method');
+                step_method.start_time = ctx.getElapsedTime();
+                step_method.desc = method_name;
+                DataTextAgent.MESSAGE.add(step_method.hash, "Method");
+                ctx.profile.push(step_method);
+
+                if(call.request && Object.keys(call.request).length > 0){
+                    var step_param = new MessageStep();
+                    step_param.hash = HashUtil.hashFromString('Parameter');
+                    step_param.start_time = ctx.getElapsedTime();
+                    step_param.desc = JSON.stringify(Object.keys(call.request));
+                    DataTextAgent.MESSAGE.add(step_param.hash, "Parameter");
+                    ctx.profile.push(step_param);
+                }
+
+                ctx.grpc_method = method_name;
+
+                function wrappedCallback(err, response, ctx) {
+
+                    if (err) {
+                        ctx.error = err.stack;
+                        ctx.statusCode = 500;
+                        ctx.error_message = err.message;
+                        ctx.error_class = err.name || err.constructor?.name || 'GrpcError';
+
+                        var step_error = new MessageStep();
+                        step_error.hash = HashUtil.hashFromString("EXCEPTION");
+                        step_error.start_time = ctx.getElapsedTime();
+                        step_error.desc = err.stack;
+                        DataTextAgent.MESSAGE.add(step_error.hash, "EXCEPTION");
+                        ctx.profile.push(step_error);
+                    }
+
+                    endTransaction(ctx);
+
+                    if (typeof callback === 'function') {
+                        return callback(err, response);
+                    }
+                }
+
+                return handler.call(this, call, (err, response) => wrappedCallback(err, response, ctx));
+            } catch (err) {
+                Logger.printError('WHATAP-701', 'gRPC wrapHandler error: ' + err, false);
+
+                if(ctx.error.isZero()) {
+                    ctx.error = StatError.addError(err.code, err.message, ctx.service_hash);
+                }
+                ctx.error_message = err.message;
+                ctx.error_class = err.name || err.constructor?.name || 'GrpcError';
+
+                var step_error = new MessageStep();
+                step_error.hash = HashUtil.hashFromString("EXCEPTION");
+                step_error.start_time = ctx.getElapsedTime();
+                step_error.desc = err.stack;
+                DataTextAgent.MESSAGE.add(step_error.hash, "EXCEPTION");
+                ctx.profile.push(step_error);
+
+                endTransaction(ctx);
+
+                return handler.call(this, call, callback);
+            }
+        });
+    };
+}
+
+function wrapStreamHandler(handler, methodName, type) {
+    return function(call, callback) {
+        var method_name = methodName.includes('/') ? methodName.substring(methodName.lastIndexOf('/')+1, methodName.length) : methodName
+        if (!grpc_profile_enabled || checkIgnoreMethod(conf.getProperty('grpc_profile_ignore_method', ''), method_name)) {
+            return handler.call(this, call, callback);
+        }
+
+        switch (type) {
+            case 'server_stream':
+                if (!grpc_profile_stream_server_enabled) {
+                    return handler.call(this, call, callback);
+                }
+                break;
+            case 'client_stream':
+                if (!grpc_profile_stream_client_enabled) {
+                    return handler.call(this, call, callback);
+                }
+                break;
+            case 'bidi':
+                if (!grpc_profile_stream_server_enabled || !grpc_profile_stream_client_enabled) {
+                    return handler.call(this, call, callback);
+                }
+                break;
+        }
+
+        TraceContextManager._asyncLocalStorage.run(initCtx(), () => {
+            try {
+                var ctx = TraceContextManager._asyncLocalStorage.getStore();
+                if (!ctx) {
+                    return handler.call(this, call, callback);
+                }
+
+                ctx.service_name = methodName;
+                ctx.service_hash = HashUtil.hashFromString(methodName);
+
+                var step_type = new MessageStep();
+                step_type.hash = HashUtil.hashFromString('Type');
+                step_type.start_time = ctx.getElapsedTime();
+                step_type.desc = type;
+                DataTextAgent.MESSAGE.add(step_type.hash, "Type");
+                ctx.profile.push(step_type);
+
+                var step_method = new MessageStep();
+                step_method.hash = HashUtil.hashFromString('Method');
+                step_method.start_time = ctx.getElapsedTime();
+                step_method.desc = method_name;
+                DataTextAgent.MESSAGE.add(step_method.hash, "Method");
+                ctx.profile.push(step_method);
+
+                ctx.grpc_method = method_name;
+
+                const startTime = Date.now();
+
+                call.on('end', () => {
+                    const duration = Date.now() - startTime;
+                    endTransaction(ctx);
+                });
+
+                call.once('cancelled', () => {
+                    ctx.cancelled = true;
+                    var step_cancel = new MessageStep();
+                    step_cancel.hash = HashUtil.hashFromString("CANCELLED");
+                    step_cancel.start_time = ctx.getElapsedTime();
+                    step_cancel.desc = "Request cancelled";
+                    DataTextAgent.MESSAGE.add(step_cancel.hash, "CANCELLED");
+                    ctx.profile.push(step_cancel);
+                    endTransaction(ctx);
+                });
+
+                call.on('error', (err) => {
+                    ctx.error = err.stack;
+                    ctx.statusCode = err.code || grpc.status.INTERNAL;
+
+                    var step_error = new MessageStep();
+                    step_error.hash = HashUtil.hashFromString("EXCEPTION");
+                    step_error.start_time = ctx.getElapsedTime();
+                    step_error.desc = err.stack;
+                    DataTextAgent.MESSAGE.add(step_error.hash, "EXCEPTION");
+                    ctx.profile.push(step_error);
+
+                    endTransaction(ctx);
+                });
+
+                return handler.call(this, call);
+            } catch (e) {
+                Logger.printError('WHATAP-702', 'gRPC wrapStreamHandler error: ' + e, false);
+                return handler.call(this, call);
+            }
+        });
+    };
+}
+
+function wrapRegister(register) {
+    return function(name, handler, serialize, deserialize, type) {
+        if (typeof handler === 'function') {
+            switch (type) {
+                case types.client_stream:
+                    handler = wrapStreamHandler(handler, name, 'clientStream');
+                    break;
+                case types.server_stream:
+                    handler = wrapStreamHandler(handler, name, 'serverStream');
+                    break;
+                case types.bidi:
+                    handler = wrapStreamHandler(handler, name, 'bidi');
+                    break;
+                case types.unary:
+                default:
+                    handler = wrapHandler(handler, name, 'unary');
+            }
+        }
+        return register.call(this, name, handler, serialize, deserialize, type);
+    };
+}
+
+function endTransaction(ctx) {
+    try {
+        var profile = new ProfilePack();
+        var wtx = new TxRecord();
+        wtx.endTime = DateUtil.currentTime();
+        profile.time = wtx.endTime;
+        wtx.elapsed = ctx.getElapsedTime();
+
+        DataTextAgent.SERVICE.add(ctx.service_hash, ctx.service_name);
+
+        wtx.seq = ctx.txid;
+        wtx.service = ctx.service_hash;
+        wtx.cpuTime = ResourceProfile.getCPUTime() - ctx.start_cpu;
+        wtx.malloc = ResourceProfile.getUsedHeapSize() - ctx.start_malloc;
+        if (wtx.malloc < 0) { wtx.malloc = 0; }
+        wtx.status = 2;
+        wtx.http_method = ctx.grpc_method;
+
+        wtx.ipaddr = ctx.remoteIp;
+
+        MeterService.add(wtx.service, wtx.elapsed,
+            wtx.errorLevel, ctx.mcaller_pcode, ctx.mcaller_okind, ctx.mcaller_oid);
+
+        profile.oid = SecurityMaster.OID;
+        profile.service = wtx;
+
+        TraceContextManager.end(ctx._id);
+
+        setTimeout(function() {
+            DataProfileAgent.sendProfile(ctx, profile, false);
+            ctx = null;
+        }, 100);
+    } catch (e) {
+        Logger.printError('WHATAP-615', 'Websocket end transaction error..', e, false);
+        TraceContextManager.end(ctx._id);
+        ctx = null;
+    }
+};
+
+function initCtx() {
+    const ctx = TraceContextManager.start();
+    if (!ctx) { return; }
+
+    ctx.start_malloc = ResourceProfile.getUsedHeapSize();
+    ctx.start_cpu = ResourceProfile.getCPUTime();
+    return ctx;
+}
+
+exports.GRpcObserver = GRpcObserver;