whatap 0.5.19 → 0.5.20

package/lib/conf/config-default.js

@@ -278,6 +278,13 @@ var ConfigDefault = {
 
     "metering_tagcount_enabled": bool("metering_tagcount_enabled", false),
     "profile_redis_param_enabled": bool("profile_redis_param_enabled", false),
+    "profile_mongodb_param_enabled": bool("profile_mongodb_param_enabled", false),
+
+    "trace_mtrace_traceparent_key": str("trace_mtrace_traceparent_key", "traceparent"),
+
+    "txtext_txname_enabled": bool("txtext_txname_enabled", true),
+
+    "ignore_env_variable_set": str("ignore_env_variable_set", "")
 
 };
 

package/lib/control/control-handler.js

@@ -17,7 +17,8 @@ var PackageCtrHelper = require('./packagectr-helper'),
     TraceContextManager = require('../trace/trace-context-manager'),
     Logger = require('../logger'),
     StatusDetector = require('../topology/status-detector'),
-    BlobValue = require('../value/blob-value');
+    BlobValue = require('../value/blob-value'),
+    conf = require('../conf/configure');
 
 var ControlHandler = function () {
     this.queue = new RequestQueue(100);
@@ -136,10 +137,14 @@ ControlHandler.prototype.handle = async function (p) {
             self._dataPackSender.sendResponseHide(p.getResponse());
             break;
         case ParamDef.GET_ENV:
-
             try {
                 var mv = new MapValue();
+                let ignore_env_variable = conf.get('ignore_env_variable_set', '');
+                let ignore_env_variable_set = ignore_env_variable ? new Set(ignore_env_variable.split(',').map(item => item.trim())) : new Set();
                 for (var k in process.env) {
+                    if(ignore_env_variable_set.has(k)) {
+                        continue;
+                    }
                     var v = process.env[k];
                     mv.putString(k, v);
                 }
@@ -152,23 +157,27 @@ ControlHandler.prototype.handle = async function (p) {
 
         case ParamDef.SYSTEM_GC:
             try {
-                var total1 = os.totalmem();
-                var used1 = total1 - os.freemem();
-                if (global.gc) {
+                var mem1 = process.memoryUsage();
+                var total1 = mem1.heapTotal;
+                var used1 = mem1.heapUsed;
+
+                if (global && global.gc && typeof global.gc === 'function') {
                     global.gc();
                 } else {
                     Logger.printError('WHATAP-177', 'Garbage collection unavailable.  Pass --expose-gc '
                         + 'when launching node to enable forced garbage collection.', new Error());
                 }
-                var total2 = os.totalmem();
-                var used2 = total2 - os.freemem();
+
+                var mem2 = process.memoryUsage();
+                var total2 = mem2.heapTotal;
+                var used2 = mem2.heapUsed;
 
                 var mv = new MapValue();
-                mv.put("before-t", total1);
-                mv.put("before-u", used1);
-                mv.put("after-t", total2);
-                mv.put("after-u", used2);
-                p.putValue("gc", m);
+                mv.putLong("before-t", total1);
+                mv.putLong("before-u", used1);
+                mv.putLong("after-t", total2);
+                mv.putLong("after-u", used2);
+                p.putValue("gc", mv);
             } catch (e) {
                 p.putValue("error", e.toString());
             }

package/lib/core/agent.js

@@ -17,6 +17,7 @@ var Interceptor      = require('./interceptor').Interceptor,
     ExpressObserver  = require('../observers/express-observer').ExpressObserver,
     GlobalObserver   = require('../observers/global-observer').GlobalObserver,
     MysqlObserver    = require('../observers/mysql-observer').MysqlObserver,
+    Mysql2Observer    = require('../observers/mysql2-observer').Mysql2Observer,
     MariaObserver    = require('../observers/maria-observer').MariaObserver,
     SocketioObserver = require('../observers/socket.io-observer').SocketIOObserver,
     WebsocketObserver = require('../observers/websocket-observer').WebsocketObserver,
@@ -265,6 +266,7 @@ NodeAgent.prototype.loadObserves = function() {
     observes.push(NetObserver);
     observes.push(ClusterObserver);
     observes.push(MysqlObserver);
+    observes.push(Mysql2Observer);
     observes.push(MariaObserver);
     observes.push(SocketioObserver);
     observes.push(WebsocketObserver);

package/lib/error/error-handler.js

@@ -0,0 +1,437 @@
+/**
+ * 메시지/알림 오류 처리
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - Message Step
+ * @param {Error} error - 오류 객체
+ */
+function handleMessageError(ctx, step, error) {
+    setCommonErrorInfo(ctx, step, error, {
+        prefix: 'msg-',
+        textType: TextTypes.MESSAGE,
+        defaultMessage: 'Message processing error',
+        includeStack: false,
+        logPrefix: 'MESSAGE-ERROR'
+    });
+}
+
+/**
+ * 오류 정보를 Context에만 설정 (StatError 생성 없이)
+ * @param {Object} ctx - Trace Context
+ * @param {Error} error - 오류 객체
+ * @param {string} prefix - 오류 접두사
+ */
+function setContextErrorOnly(ctx, error, prefix = '') {
+    if (!ctx || !error) return;
+
+    try {
+        // 오류 클래스 정보 설정
+        ctx.error_class = error.name || (error.constructor && error.constructor.name) || 'UnknownError';
+
+        // 오류 메시지 설정
+        ctx.error_message = error.message || error.stack || 'Unknown error';
+
+        // 상태 코드 설정 (있는 경우)
+        if (error.status || error.statusCode || error.code) {
+            ctx.statusCode = error.status || error.statusCode || error.code;
+        }
+
+    } catch (e) {
+        Logger.printError(
+            'WHATAP-CONTEXT-ERROR',
+            'Error setting context error info',
+            e,
+            false
+        );
+    }
+}/**
+ * Step 타입에 따라 TextType 자동 추론
+ * @param {Object} step - Step 객체
+ * @returns {number} - TextTypes 상수
+ */
+function inferTextTypeFromStep(step) {
+    if (!step) return TextTypes.MESSAGE;
+
+    // Step 클래스명 또는 타입으로 판단
+    const stepName = step.constructor?.name || '';
+
+    if (stepName.includes('Http') || step.url !== undefined) {
+        return TextTypes.HTTPC_URL;
+    }
+    if (stepName.includes('Socket') || stepName.includes('Websocket')) {
+        return TextTypes.MESSAGE;
+    }
+    if (stepName.includes('Message') || step.desc !== undefined) {
+        return TextTypes.MESSAGE;
+    }
+    if (stepName.includes('Sql') || step.hash !== undefined) {
+        return TextTypes.SQL;
+    }
+
+    // 기본값
+    return TextTypes.MESSAGE;
+}/**
+ * 공통 오류 처리 유틸리티
+ * 모든 Observer에서 사용할 수 있는 통합 오류 처리 함수들
+ */
+
+const StatError = require('../stat/stat-error');
+const TextTypes = require('../lang/text-types');
+const Logger = require('../logger');
+const conf = require('../conf/configure');
+
+/**
+ * 공통 오류 정보 설정 함수 (범용)
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - Step 객체 (SQL, HTTP, Message 등)
+ * @param {Error} error - 오류 객체
+ * @param {Object} options - 추가 옵션
+ * @param {string} options.prefix - 오류 코드 접두사 (예: 'mysql-', 'httpc-', 'redis-')
+ * @param {number} options.textType - TextTypes 상수 (기본값: null, step 타입에 따라 자동 결정)
+ * @param {boolean} options.includeStack - 스택 트레이스 포함 여부 (기본값: true)
+ * @param {string} options.defaultMessage - 기본 오류 메시지
+ * @param {boolean} options.setStatError - StatError 생성 여부 (기본값: true)
+ * @param {string} options.logPrefix - 로그 접두사 (기본값: 'COMMON-ERROR')
+ */
+function setCommonErrorInfo(ctx, step, error, options = {}) {
+    if (!ctx || !error) {
+        return;
+    }
+
+    const {
+        prefix = '',
+        textType = null,
+        includeStack = true,
+        defaultMessage = 'Error',
+        setStatError = true,
+        logPrefix = 'COMMON-ERROR'
+    } = options;
+
+    try {
+        // 오류 클래스 정보 설정
+        const errorClass = error.name || (error.constructor && error.constructor.name) || 'UnknownError';
+        ctx.error_class = errorClass;
+
+        // 오류 코드 생성
+        const errorCode = error.code || error.errno || error.errorNum || 'UNKNOWN';
+        const fullErrorCode = prefix ? `${prefix}${errorCode}` : errorCode;
+
+        // 오류 메시지 설정
+        const errorMessage = error.message || error.sqlMessage || defaultMessage;
+
+        // 스택 트레이스 처리
+        if (includeStack && conf.trace_sql_error_stack && conf.trace_sql_error_depth && error.stack) {
+            const traceDepth = conf.trace_sql_error_depth;
+            const errorStack = error.stack.split("\n");
+
+            if (errorStack.length > traceDepth) {
+                ctx.error_message = errorStack.slice(0, traceDepth + 1).join("\n");
+            } else {
+                ctx.error_message = error.stack;
+            }
+        } else {
+            ctx.error_message = errorMessage;
+        }
+
+        // StatError 생성 (step이 있고 설정이 활성화된 경우)
+        if (step && setStatError) {
+            const shouldAddError = shouldIgnoreError(errorCode, errorMessage);
+
+            if (shouldAddError) {
+                // textType이 null이면 step 타입에 따라 자동 결정
+                const finalTextType = textType || inferTextTypeFromStep(step);
+
+                step.error = StatError.addError(
+                    fullErrorCode,
+                    errorMessage,
+                    ctx.service_hash,
+                    finalTextType,
+                    step.hash || step.url || null
+                );
+
+                // Context 오류가 아직 설정되지 않았다면 설정
+                if (ctx.error && ctx.error.isZero && ctx.error.isZero()) {
+                    ctx.error = step.error;
+                }
+            }
+        }
+
+        Logger.printError(
+            `WHATAP-${logPrefix.toUpperCase()}`,
+            `${prefix || 'SYSTEM'} Error: ${fullErrorCode} - ${errorMessage}`,
+            error,
+            false
+        );
+
+    } catch (e) {
+        Logger.printError(
+            'WHATAP-ERROR-HANDLER',
+            'Error in common error handler',
+            e,
+            false
+        );
+    }
+}
+
+/**
+ * 오류 무시 여부 확인
+ * @param {string} errorCode - 오류 코드
+ * @param {string} errorMessage - 오류 메시지
+ * @returns {boolean} - 오류를 처리할지 여부
+ */
+function shouldIgnoreError(errorCode, errorMessage) {
+    try {
+        // 오류 클래스 무시 설정 확인
+        if (conf._is_trace_ignore_err_cls_contains === true &&
+            conf.trace_ignore_err_cls_contains &&
+            errorCode &&
+            errorCode.indexOf(conf.trace_ignore_err_cls_contains) >= 0) {
+            return false;
+        }
+
+        // 오류 메시지 무시 설정 확인
+        if (conf._is_trace_ignore_err_msg_contains === true &&
+            conf.trace_ignore_err_msg_contains &&
+            errorMessage &&
+            errorMessage.indexOf(conf.trace_ignore_err_msg_contains) >= 0) {
+            return false;
+        }
+
+        // 기본적으로 오류 처리
+        return true;
+    } catch (e) {
+        Logger.printError(
+            'WHATAP-ERROR-IGNORE-CHECK',
+            'Error checking ignore conditions',
+            e,
+            false
+        );
+        return true;
+    }
+}
+
+/**
+ * MySQL 전용 오류 처리
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - SQL Step
+ * @param {Error} error - MySQL 오류 객체
+ */
+function handleMysqlError(ctx, step, error) {
+    setCommonErrorInfo(ctx, step, error, {
+        prefix: 'mysql-',
+        textType: TextTypes.SQL,
+        defaultMessage: 'mysql error'
+    });
+}
+
+/**
+ * PostgreSQL 전용 오류 처리
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - SQL Step
+ * @param {Error} error - PostgreSQL 오류 객체
+ */
+function handlePgsqlError(ctx, step, error) {
+    setCommonErrorInfo(ctx, step, error, {
+        prefix: 'pgsql-',
+        textType: TextTypes.SQL,
+        defaultMessage: 'postgresql error'
+    });
+}
+
+/**
+ * Oracle 전용 오류 처리
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - SQL Step
+ * @param {Error} error - Oracle 오류 객체
+ */
+function handleOracleError(ctx, step, error) {
+    setCommonErrorInfo(ctx, step, error, {
+        prefix: 'oracle-',
+        textType: TextTypes.SQL,
+        defaultMessage: 'Oracle error'
+    });
+}
+
+/**
+ * MongoDB 전용 오류 처리
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - SQL Step
+ * @param {Error} error - MongoDB 오류 객체
+ */
+function handleMongoError(ctx, step, error) {
+    setCommonErrorInfo(ctx, step, error, {
+        prefix: 'mongodb-',
+        textType: TextTypes.SQL,
+        defaultMessage: 'MongoDB error'
+    });
+}
+
+/**
+ * Redis 전용 오류 처리
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - SQL Step
+ * @param {Error} error - Redis 오류 객체
+ */
+function handleRedisError(ctx, step, error) {
+    setCommonErrorInfo(ctx, step, error, {
+        prefix: 'redis-',
+        textType: TextTypes.SQL,
+        defaultMessage: 'Redis error'
+    });
+}
+
+/**
+ * HTTP 클라이언트 오류 처리
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - HTTP Step
+ * @param {Error} error - HTTP 오류 객체
+ */
+function handleHttpcError(ctx, step, error) {
+    setCommonErrorInfo(ctx, step, error, {
+        prefix: 'httpc-',
+        textType: TextTypes.HTTPC_URL,
+        defaultMessage: 'HTTP client error',
+        includeStack: false,
+        logPrefix: 'HTTPC-ERROR'
+    });
+}
+
+/**
+ * 일반적인 시스템 오류 처리
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - Step 객체 (선택사항)
+ * @param {Error} error - 오류 객체
+ * @param {string} prefix - 오류 접두사
+ */
+function handleSystemError(ctx, step, error, prefix = 'system') {
+    setCommonErrorInfo(ctx, step, error, {
+        prefix: `${prefix}-`,
+        textType: null, // 자동 추론
+        defaultMessage: 'System error',
+        includeStack: true,
+        logPrefix: 'SYSTEM-ERROR'
+    });
+}
+
+/**
+ * gRPC 전용 오류 처리
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - gRPC Step (MessageStep)
+ * @param {Error} error - gRPC 오류 객체
+ */
+function handleGrpcError(ctx, step, error) {
+    setCommonErrorInfo(ctx, step, error, {
+        prefix: 'grpc-',
+        textType: TextTypes.MESSAGE,
+        defaultMessage: 'gRPC error',
+        includeStack: true,
+        logPrefix: 'GRPC-ERROR'
+    });
+}
+
+/**
+ * WebSocket 전용 오류 처리
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - WebSocket Step (SocketStep)
+ * @param {Error} error - WebSocket 오류 객체
+ */
+function handleWebsocketError(ctx, step, error) {
+    setCommonErrorInfo(ctx, step, error, {
+        prefix: 'websocket-',
+        textType: TextTypes.MESSAGE,
+        defaultMessage: 'WebSocket error',
+        includeStack: false,
+        logPrefix: 'WEBSOCKET-ERROR'
+    });
+}
+
+/**
+ * Socket.IO 전용 오류 처리
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - Socket.IO Step (SocketStep)
+ * @param {Error} error - Socket.IO 오류 객체
+ */
+function handleSocketIOError(ctx, step, error) {
+    setCommonErrorInfo(ctx, step, error, {
+        prefix: 'socketio-',
+        textType: TextTypes.MESSAGE,
+        defaultMessage: 'Socket.IO error',
+        includeStack: false,
+        logPrefix: 'SOCKETIO-ERROR'
+    });
+}
+
+/**
+ * Global Fetch API 오류 처리
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - HTTP Step (HttpStepX)
+ * @param {Error|Response} error - Fetch 오류 객체 또는 Response 객체
+ */
+function handleFetchError(ctx, step, error) {
+    // Response 객체인 경우와 Error 객체인 경우 구분
+    const isResponse = error && typeof error.status === 'number';
+
+    setCommonErrorInfo(ctx, step, error, {
+        prefix: 'fetch-',
+        textType: TextTypes.HTTPC_URL,
+        defaultMessage: isResponse ? 'Fetch HTTP error' : 'Fetch network error',
+        includeStack: !isResponse, // Response 객체는 스택 없음
+        logPrefix: 'FETCH-ERROR'
+    });
+}
+
+/**
+ * Process 관련 오류 처리 (stdout/stderr)
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - Process Step
+ * @param {Error} error - Process 오류 객체
+ */
+function handleProcessError(ctx, step, error) {
+    setCommonErrorInfo(ctx, step, error, {
+        prefix: 'process-',
+        textType: TextTypes.MESSAGE,
+        defaultMessage: 'Process error',
+        includeStack: true,
+        logPrefix: 'PROCESS-ERROR'
+    });
+}
+
+/**
+ * Prisma 전용 오류 처리
+ * @param {Object} ctx - Trace Context
+ * @param {Object} step - SQL Step
+ * @param {Error} error - Prisma 오류 객체
+ */
+function handlePrismaError(ctx, step, error) {
+    setCommonErrorInfo(ctx, step, error, {
+        prefix: 'prisma-',
+        textType: TextTypes.SQL,
+        defaultMessage: 'Prisma error'
+    });
+}
+
+module.exports = {
+    setCommonErrorInfo,
+    shouldIgnoreError,
+    inferTextTypeFromStep,
+    setContextErrorOnly,
+
+    // 데이터베이스 관련
+    handleMysqlError,
+    handlePgsqlError,
+    handleOracleError,
+    handleMongoError,
+    handleRedisError,
+    handlePrismaError,
+
+    // 네트워크/통신 관련
+    handleHttpcError,
+    handleFetchError,
+    handleGrpcError,
+    handleWebsocketError,
+    handleSocketIOError,
+
+    // 시스템 관련
+    handleSystemError,
+    handleProcessError,
+    handleMessageError
+};

package/lib/observers/apollo-server-observer.js

@@ -11,6 +11,8 @@ const HashUtil = require('../util/hashutil');
 const DataTextAgent = require('../data/datatext-agent');
 const MessageStep = require('../step/message-step');
 const shimmer = require('../core/shimmer');
+const StatError = require("whatap/lib/stat/stat-error");
+const TextTypes = require("whatap/lib/lang/text-types");
 
 var profile_graphql_enabled = conf.getProperty('profile_graphql_enabled', true);
 var profile_graphql_variable_enabled = conf.getProperty('profile_graphql_variable_enabled', false);
@@ -114,8 +116,13 @@ function wrapExecuteHTTPGraphQLRequest(original) {
                     const result = JSON.parse(response.body.string);
                     if (result.errors && result.errors.length > 0) {
                         const errorMessages = result.errors.map(error => error.message).join('\n');
-                        ctx.statusCode = 500;
+                        ctx.statusCode = response.status;
                         ctx.error_message = errorMessages;
+                        ctx.error_class = 'GraphQLError';
+
+                        if(ctx.error.isZero()){
+                            ctx.error = StatError.addError(response.status, errorMessages, ctx.service_hash, TextTypes.SQL, HashUtil.hashFromString(ctx.service_name));
+                        }
                     }
                 } catch (e) {
                     Logger.printError('WHATAP-802', 'GraphQL error parsing failed', e, false);
@@ -128,7 +135,8 @@ function wrapExecuteHTTPGraphQLRequest(original) {
             Logger.printError('WHATAP-801', 'GraphQL executeHTTPGraphQLRequest error: ' + err, false);
             if (ctx) {
                 ctx.statusCode = 500;
-                ctx.error_message = err.stack;
+                ctx.error_message = err.message;
+                ctx.error_class = err.name || err.constructor?.name || 'UnknownError'
             }
             return original.apply(this, arguments);
         }

package/lib/observers/global-observer.js

@@ -101,8 +101,10 @@ function handleResponse(ctx, args, response) {
     ctx.profile.push(step);
 }
 
-function handleError(ctx, args, error) {
+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);
@@ -110,7 +112,7 @@ function handleError(ctx, args, error) {
     var step = createStep(ctx, url);
 
     if (transaction_status_error_enable) {
-        recordError(ctx, step, error);
+        recordError(ctx, step, err);
     }
 
     ctx.profile.push(step);
@@ -135,13 +137,21 @@ function createStep(ctx, url) {
 
 function recordError(ctx, step, response) {
     if (step.error.isZero()) {
-        var cleanUrl = ctx.httpc_url.split('?')[0];
-        ctx.service_name = URLPatternDetector.normalize(cleanUrl);
-        ctx.service_hash = HashUtil.hashFromString(ctx.service_name);
-
-        const errorMessage = response.statusText || (response.cause ? response.cause.message : '') || response.message || 'Unknown error';
+        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 {
+            ctx.error_class = 'HttpError';
+        }
+
         if (ctx.error.isZero()) {
             ctx.error = step.error;
             ctx.statusCode = response.status || null;

package/lib/observers/grpc-observer.js

@@ -20,6 +20,7 @@ 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);
@@ -88,8 +89,8 @@ function wrapHandler(handler, methodName, type) {
         }
 
         TraceContextManager._asyncLocalStorage.run(initCtx(), () => {
+            var ctx = TraceContextManager._asyncLocalStorage.getStore();
             try {
-                var ctx = TraceContextManager._asyncLocalStorage.getStore();
                 if (!ctx) {
                     return handler.call(this, call, callback);
                 }
@@ -120,8 +121,6 @@ function wrapHandler(handler, methodName, type) {
                     ctx.profile.push(step_param);
                 }
 
-                console.log(call.pendingStatus)
-
                 ctx.grpc_method = method_name;
 
                 function wrappedCallback(err, response, ctx) {
@@ -129,6 +128,8 @@ function wrapHandler(handler, methodName, type) {
                     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");
@@ -146,15 +147,14 @@ function wrapHandler(handler, methodName, type) {
                 }
 
                 return handler.call(this, call, (err, response) => wrappedCallback(err, response, ctx));
-                // return handler.call(this, call, (err, response) => {
-                //     if (!err) {
-                //         err = new Error('Exception error occured');
-                //     }
-                //     wrappedCallback(err, response, ctx);
             } catch (err) {
                 Logger.printError('WHATAP-701', 'gRPC wrapHandler error: ' + err, false);
 
-                ctx.error = err.stack;
+                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");