@weave-js/core 0.12.1 → 0.14.0

package/lib/ExtendableError.js

@@ -1,6 +1,6 @@
 class ExtendableError extends Error {
-  constructor (message = '') {
-    super(message);
+  constructor (message = '', options) {
+    super(message, options);
 
     Object.defineProperty(this, 'name', {
       configurable: true,

package/lib/broker/context.js

@@ -21,6 +21,8 @@ const { WeaveMaxCallLevelError, WeaveError } = require('../errors');
  * @returns {Context} Context
 */
 exports.createContext = (runtime) => {
+  const spanStack = [];
+
   /** @type {Context} */
   const context = {
     id: null,
@@ -95,17 +97,33 @@ exports.createContext = (runtime) => {
         sampled: this.tracing
       }, options);
 
+      let span;
+
       if (this.span) {
-        this.span = this.span.startChildSpan(name, options);
+        span = this.span.startChildSpan(name, options);
       } else {
-        this.span = runtime.tracer.startSpan(name, options);
+        span = runtime.tracer.startSpan(name, options);
       }
+      spanStack.push(span);
+      this.span = span;
+
       return this.span;
     },
-    finishSpan () {
-      if (this.span) {
-        this.span.finish();
-        return this.span;
+    finishSpan (span, time) {
+      if (span && !span.isActive()) {
+        return;
+      }
+
+      span.finish(time);
+
+      const idx = spanStack.findIndex((s) => s === span);
+
+      if (idx !== -1) {
+        spanStack.splice(idx, 1);
+        this.span = spanStack[spanStack.length - 1];
+      } else {
+        /* istanbul ignore next */
+        this.service.log.warn('This span is not assigned to this context', span);
       }
     },
     /**
@@ -132,6 +150,8 @@ exports.createContext = (runtime) => {
     }
   };
 
+
+
   // Generate context Id
   if (!context.id) {
     // Use UUID factory from broker options

package/lib/broker/defaultOptions.js

@@ -82,6 +82,7 @@ exports.getDefaultOptions = () => {
       collectors: [],
       actions: {
         data: false,
+        response: false,
         tags: {}
       },
       events: {

package/lib/errors.js

@@ -4,25 +4,30 @@
  * Copyright 2021 Fachwerk
  */
 
+const { defaultsDeep } = require('@weave-js/utils');
 const { ExtendableError } = require('./ExtendableError');
 
 class WeaveError extends ExtendableError {
-  constructor (message, code, type, data) {
-    super(message);
+  constructor (message, options) {
+    options = defaultsDeep(
+      options,
+      {
+        code: 'WEAVE_ERROR',
+        retryable: false
+      }
+    );
+
+    super(message, options);
     this.name = this.constructor.name;
-    this.code = code || 500;
-    this.type = type;
-    this.data = data;
+    this.code = options.code || 'WEAVE_ERROR';
+    this.data = options.data;
     this.retryable = false;
   }
 }
 
 class WeaveRetryableError extends WeaveError {
-  constructor (message, code, type, data) {
-    super(message);
-    this.code = code || 500;
-    this.type = type;
-    this.data = data;
+  constructor (message, options = { code: 'WEAVE_RETRYABLE_ERROR', retryable: true }) {
+    super(message, options);
     this.retryable = true;
   }
 }
@@ -39,11 +44,11 @@ class WeaveServiceNotFoundError extends WeaveRetryableError {
       message = 'Service not found.';
     }
 
-    super(message, 404, 'WEAVE_SERVICE_NOT_FOUND_ERROR', data);
+    super(message, { code: 'WEAVE_SERVICE_NOT_FOUND_ERROR', data });
   }
 }
 
-class WeaveServiceNotAvailableError extends WeaveRetryableError {
+class WeaveServiceNotAvailableError extends WeaveRetryableError { // 503
   constructor (data = {}) {
     let message;
     if (data.nodeId) {
@@ -54,67 +59,69 @@ class WeaveServiceNotAvailableError extends WeaveRetryableError {
       message = 'Service not available.';
     }
 
-    super(message, 503, 'WEAVE_SERVICE_NOT_AVAILABLE_ERROR', data);
+    super(message, { code: 'WEAVE_SERVICE_NOT_AVAILABLE_ERROR', data });
   }
 }
 
-class WeaveRequestTimeoutError extends WeaveRetryableError {
+class WeaveRequestTimeoutError extends WeaveRetryableError { // 504
   constructor (actionName, nodeId, timeout) {
-    const message = `Action ${actionName} timed out node ${nodeId || '<local>'}.`;
-    super(message, 504, 'WEAVE_REQUEST_TIMEOUT_ERROR', {
+    const data = {
       actionName,
       nodeId,
       timeout
-    });
-    this.retryable = true;
+    };
+
+    const message = `Action ${actionName} timed out node ${nodeId || '<local>'}.`;
+    super(message, { code: 'WEAVE_REQUEST_TIMEOUT_ERROR', data });
   }
 }
 
-class WeaveParameterValidationError extends WeaveError {
+class WeaveParameterValidationError extends WeaveError { // 422
   constructor (message, data) {
-    super(message, 422, 'WEAVE_PARAMETER_VALIDATION_ERROR', data);
+    super(message, { code: 'WEAVE_PARAMETER_VALIDATION_ERROR', data });
   }
 }
 
 class WeaveBrokerOptionsError extends WeaveError {
   constructor (message, data) {
-    super(message, 500, 'WEAVE_BROKER_OPTIONS_ERROR', data);
+    super(
+      message,
+      { code: 'WEAVE_BROKER_OPTIONS_ERROR', data }
+    );
   }
 }
 
-class WeaveQueueSizeExceededError extends WeaveError {
+class WeaveQueueSizeExceededError extends WeaveError { // 429
   constructor (data) {
-    super('Queue size limit was exceeded. Request rejected.', 429, 'WEAVE_QUEUE_SIZE_EXCEEDED_ERROR', data);
+    super(
+      'Queue size limit was exceeded. Request rejected.',
+      { code: 'WEAVE_QUEUE_SIZE_EXCEEDED_ERROR', data }
+    );
   }
 }
 
 class WeaveMaxCallLevelError extends WeaveError {
   constructor (data) {
-    super(`Request level has reached the limit (${data.maxCallLevel}) on node "${data.nodeId}".`, 500, 'WEAVE_MAX_CALL_LEVEL_ERROR', data);
+    super(
+      `Request level has reached the limit ${data.maxCallLevel} on node "${data.nodeId}".`,
+      { code: 'WEAVE_MAX_CALL_LEVEL_ERROR', data }
+    );
   }
 }
 
 class WeaveGracefulStopTimeoutError extends WeaveError {
   constructor (service) {
-    super(`Unable to stop service "${service.name}"`, 500, 'GRACEFUL_STOP_TIMEOUT', {
+    const data = {
       name: service.name,
       version: service.version
-    });
-  }
-}
-
-const restoreError = error => {
-  const ErrorClass = module.exports[error.name];
+    };
 
-  if (ErrorClass) {
-    switch (error.name) {
-    case 'WeaveError':
-      return new ErrorClass(error.message, error.code, error.type, error.data);
-            // case 'WeaveParameterValidationError':
-            //     return new ErrorClass(error.message, error.data)
-    }
+    super(
+      `Unable to stop service "${service.name}"`,
+      { code: 'WEAVE_GRACEFUL_STOP_TIMEOUT', data }
+    );
   }
-};
+}
 
 module.exports = {
   WeaveBrokerOptionsError,
@@ -126,6 +133,5 @@ module.exports = {
   WeaveRetryableError,
   WeaveServiceNotAvailableError,
   WeaveServiceNotFoundError,
-  WeaveGracefulStopTimeoutError,
-  restoreError
+  WeaveGracefulStopTimeoutError
 };

package/lib/middlewares/error-handler/index.js

@@ -12,7 +12,7 @@ module.exports = (runtime) => {
       return handler(context, serviceInjections)
         .catch((error) => {
           if (!(error instanceof Error)) {
-            error = new WeaveError(error, 500);
+            error = new WeaveError(error);
           }
 
           if (runtime.nodeId !== context.nodeId) {
@@ -36,7 +36,7 @@ module.exports = (runtime) => {
       return handler(context, serviceInjections)
         .catch((error) => {
           if (!(error instanceof Error)) {
-            error = new WeaveError(error, 500);
+            error = new WeaveError(error.message, { cause: error });
           }
 
           if (runtime.nodeId !== context.nodeId) {

package/lib/middlewares/tracing/index.js

@@ -4,22 +4,56 @@
  * Copyright 2021 Fachwerk
  */
 
-const { isPlainObject } = require('@weave-js/utils');
+const { isPlainObject, isFunction, isObject, dotGet } = require('@weave-js/utils');
 const { buildActionTags, buildEventTags } = require('./tags');
 
-const wrapTracingLocalActionMiddleware = function (handler) {
+const wrapTracingLocalActionMiddleware = function (handler, action) {
   const broker = this;
   const tracingOptions = broker.options.tracing || {};
+  const actionTracingOptions = action.tracing || {};
 
   if (tracingOptions.enabled) {
     return function metricsLocalMiddleware (context, serviceInjections) {
       const tags = buildActionTags(context, tracingOptions);
 
-      if (tracingOptions) {
+      if (tracingOptions.actions.data) {
         tags.data = context.data !== null && isPlainObject(context.data) ? Object.assign({}, context.data) : context.data;
       }
 
-      const spanName = `action "${context.action.name}"`;
+      const globalActionTags = tracingOptions.actions.tags;
+      let actionTags;
+      // local action tags take precedence
+      if (isFunction(actionTracingOptions.tags)) {
+        actionTags = actionTracingOptions.tags;
+      } else if (!actionTracingOptions.tags && isFunction(globalActionTags)) {
+        actionTags = globalActionTags;
+      } else {
+        // By default all params are captured. This can be overridden globally and locally
+        actionTags = { ...{ data: true }, ...globalActionTags, ...actionTracingOptions.tags };
+      }
+
+      if (isObject(actionTracingOptions.tags)) {
+        if (Array.isArray(actionTags.data)) {
+          tags.data = actionTags.data.reduce((acc, current) => {
+            acc[current] = dotGet(context.data, current);
+            return acc;
+          }, {});
+        }
+      }
+
+      // Span name
+      let spanName = `action "${context.action.name}"`;
+
+      if (actionTracingOptions.spanName) {
+        switch (typeof actionTracingOptions.spanName) {
+        case 'string':
+          spanName = actionTracingOptions.spanName;
+          break;
+        case 'function':
+          spanName = actionTracingOptions.spanName.call(context.service, context);
+          break;
+        }
+      }
 
       const span = context.startSpan(spanName, {
         id: context.id,
@@ -39,18 +73,17 @@ const wrapTracingLocalActionMiddleware = function (handler) {
             isCachedResult: context.isCachedResult
           };
 
-          if (tracingOptions) {
+          if (tracingOptions.actions.response) {
             tags.response = result !== null && isPlainObject(result) ? Object.assign({}, result) : result;
           }
 
           span.addTags(tags);
-          span.finish();
+          context.finishSpan(span);
           return result;
         })
         .catch(error => {
-          span
-            .setError(error)
-            .finish();
+          span.setError(error);
+          context.finishSpan(span);
           return Promise.reject(error);
         });
     };
@@ -81,13 +114,12 @@ const wrapTracingLocalEventMiddleware = function (handler, event) {
 
       return handler(context)
         .then(result => {
-          span.finish();
+          context.finishSpan(span);
           return result;
         })
         .catch(error => {
-          span
-            .setError(error)
-            .finish();
+          span.setError(error);
+          context.finishSpan(span);
           return Promise.reject(error);
         });
     };

package/lib/runtime/initServiceManager.js

@@ -93,7 +93,12 @@ exports.initServiceManager = (runtime) => {
             }
 
             if (timeout && (Date.now() - startTimestamp) > timeout) {
-              return reject(new WeaveError('The waiting of the services is interrupted due to a timeout.', 500, 'WAIT_FOR_SERVICE', { services: serviceNames }));
+              return reject(new WeaveError('The waiting of the services is interrupted due to a timeout.', {
+                code: 'WAIT_FOR_SERVICE',
+                data: {
+                  services: serviceNames
+                }
+              }));
             }
 
             options.waitForServiceInterval = setTimeout(serviceCheck, interval);

package/lib/tracing/span.js

@@ -42,7 +42,7 @@ exports.createSpan = (tracer, name, options) => {
   span.finish = (time) => {
     span.finishTime = time || hrTime();
     span.duration = span.finishTime - span.startTime;
-    tracer.log.debug('Span finished');
+    tracer.log.debug(`Span "${span.id}" finished`);
     tracer.invokeCollectorMethod('finishedSpan', [span]);
 
     return span;

package/lib/transport/errorPayloadFactory.js

@@ -6,7 +6,6 @@ const errorPayloadFactory =
         message: error.message,
         nodeId: error.nodeId || runtime.nodeId,
         code: error.code,
-        type: error.type,
         stack: error.stack,
         data: error.data
       };

package/lib/transport/messageHandlers.js

@@ -5,10 +5,11 @@
  */
 
 const { InboundTransformStream } = require('./InboundTransformStream');
-const { WeaveError, restoreError } = require('../errors');
+const { WeaveError } = require('../errors');
 const { createContext } = require('../broker/context');
 const { createMessage } = require('./createMessage');
 const MessageTypes = require('./messageTypes');
+const { restoreError } = require('../utils/restoreError');
 
 /**
  * @typedef {import('../types').Transport} Transport
@@ -291,23 +292,10 @@ module.exports = (runtime, transport) => {
 
     // Response is an error
     if (!payload.success) {
-      let error = restoreError(payload.error);
-
-      if (!error) {
-        error = new Error(payload.error.message);
-        error.name = payload.error.name;
-        error.code = payload.error.code;
-        error.type = payload.error.type;
-        error.data = payload.error.data;
-      }
+      const error = restoreError(payload.error);
 
-      error.retryable = payload.error.retryable;
       error.nodeId = error.nodeId || payload.sender;
 
-      if (payload.error.stack) {
-        error.stack = payload.error.stack;
-      }
-
       request.reject(error);
     }
 
@@ -398,6 +386,7 @@ module.exports = (runtime, transport) => {
   const onHeartbeat = (payload) => {
     transport.log.verbose(`Heartbeat from ${payload.sender}`);
     const node = registry.nodeCollection.get(payload.sender);
+
     // if node is unknown then request a node info message.
     if (node) {
       if (!node.isAvailable) {
@@ -510,7 +499,11 @@ module.exports = (runtime, transport) => {
 
       return true;
     } catch (error) {
-      transport.log.error(error, data);
+      transport.log.error(error, type, data);
+
+      runtime.eventBus.broadcastLocal('$transport.error', {
+        error
+      });
     }
     return false;
   };

package/lib/utils/restoreError.js

@@ -1,12 +1,64 @@
 const errors = require('../errors');
 
-exports.restoreError = (error) => {
-  const ErrorClass = errors[error.name];
+const restoreError = (errorPayload) => {
+  const ErrorClass = errors[errorPayload.name];
+  let error;
 
   if (ErrorClass) {
-    switch (error.name) {
+    switch (errorPayload.name) {
     case 'WeaveError':
-      return new ErrorClass(error.message, error.code, error.type, error.data);
+    case 'WeaveRetryableError': {
+      const { message, ...options } = errorPayload;
+      error = new ErrorClass(message, options);
+      break;
+    }
+
+    case 'WeaveParameterValidationError':
+    case 'WeaveBrokerOptionsError': {
+      const { message, data } = errorPayload;
+      error = new ErrorClass(message, data);
+      break;
+    }
+    case 'WeaveServiceNotFoundError':
+    case 'WeaveServiceNotAvailableError':
+    case 'WeaveQueueSizeExceededError':
+    case 'WeaveMaxCallLevelError': {
+      const { data } = errorPayload;
+      error = new ErrorClass(data);
+      break;
+    }
+    case 'WeaveRequestTimeoutError': {
+      const { data } = errorPayload;
+      error = new ErrorClass(data.actionName, data.nodeId, data.timeout);
+      break;
+    }
+    case 'WeaveGracefulStopTimeoutError': {
+      const { data } = errorPayload;
+      error = new ErrorClass(data.service);
+      break;
+    }
+    }
+  } else {
+    error = new Error(errorPayload.message);
+
+    error.name = errorPayload.name;
+
+    error.nodeId = errorPayload.nodeId;
+
+    if (errorPayload.code) {
+      error.code = errorPayload.code;
+    }
+
+    if (errorPayload.data) {
+      error.data = errorPayload.data;
     }
   }
+
+  if (errorPayload.stack) {
+    error.stack = errorPayload.stack;
+  }
+
+  return error;
 };
+
+module.exports = { restoreError };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weave-js/core",
-  "version": "0.12.1",
+  "version": "0.14.0",
   "description": "The core package of weave",
   "keywords": [
     "Weave",
@@ -40,14 +40,14 @@
   "license": "MIT",
   "dependencies": {
     "@weave-js/errors": "^0.9.1",
-    "@weave-js/utils": "^0.11.1",
-    "@weave-js/validator": "^0.12.0",
-    "eventemitter2": "^6.4.5",
-    "glob": "^7.2.0"
+    "@weave-js/utils": "^0.13.0",
+    "@weave-js/validator": "^0.14.0",
+    "eventemitter2": "^6.4.9",
+    "glob": "^10.2.2"
   },
   "directories": {
     "lib": "lib",
     "test": "test"
   },
-  "gitHead": "3f9662a98caa08d32ba5a181cc5871318aaece23"
+  "gitHead": "c2f63481b2a72ae03a35682c9a6d12800f22dbf2"
 }