@weave-js/core 0.13.0 → 0.14.1

package/lib/broker/context.js

@@ -21,12 +21,14 @@ const { WeaveMaxCallLevelError, WeaveError } = require('../errors');
  * @returns {Context} Context
 */
 exports.createContext = (runtime) => {
+  const spanStack = [];
+
   /** @type {Context} */
   const context = {
     id: null,
     nodeId: runtime.nodeId || null,
+    parentId: null,
     callerNodeId: null,
-    parentContext: null,
     endpoint: null,
     data: {},
     meta: {},
@@ -42,6 +44,7 @@ exports.createContext = (runtime) => {
     },
     duration: 0,
     stopTime: 0,
+    isCachedResult: false,
     setData (newParams) {
       this.data = newParams || {};
     },
@@ -95,17 +98,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);
       }
     },
     /**
@@ -119,14 +138,16 @@ exports.createContext = (runtime) => {
       contextCopy.options = this.options;
       contextCopy.data = this.data;
       contextCopy.meta = this.meta;
-      contextCopy.parentContext = this.parentContext;
+      contextCopy.parentId = this.parentId;
       contextCopy.callerNodeId = this.callerNodeId;
       contextCopy.requestId = this.requestId;
       contextCopy.tracing = this.tracing;
+      contextCopy.span = this.span;
       contextCopy.level = this.level;
       contextCopy.eventName = this.eventName;
       contextCopy.eventType = this.eventType;
       contextCopy.eventGroups = this.eventGroups;
+      contextCopy.isCachedResult = this.isCachedResult;
 
       return contextCopy;
     }

package/lib/broker/defaultOptions.js

@@ -80,8 +80,10 @@ exports.getDefaultOptions = () => {
       enabled: false,
       samplingRate: 1.0,
       collectors: [],
+      defaultTags: null,
       actions: {
         data: false,
+        response: false,
         tags: {}
       },
       events: {

package/lib/broker/index.js

@@ -5,7 +5,6 @@
  * @typedef {import('../types.js').Transport} Transport
 */
 
-// node packages
 const { isFunction } = require('@weave-js/utils');
 const path = require('path');
 const glob = require('glob');
@@ -31,26 +30,21 @@ exports.createBrokerInstance = (runtime) => {
     transport
   } = runtime;
 
-  // Log Messages
   log.info(`Initializing #weave node version ${version}`);
   log.info(`Node Id: ${options.nodeId}`);
 
-  // Output namespace
   if (options.namespace) {
     log.info(`Namespace: ${options.namespace}`);
   }
 
-  // Init metrics
   if (runtime.metrics) {
     runtime.metrics.init();
   }
 
-  // Init cache
   if (runtime.cache) {
     runtime.cache.init();
   }
 
-  // broker object
   /** @type {Broker} */
   const broker = Object.create(null);
 
@@ -131,7 +125,6 @@ exports.createBrokerInstance = (runtime) => {
     const startTime = Date.now();
     await middlewareHandler.callHandlersAsync('starting', [runtime], true);
 
-    // If transport is used, we connect the transport adapter.
     if (transport) {
       await transport.connect();
     }
@@ -146,10 +139,8 @@ exports.createBrokerInstance = (runtime) => {
 
     runtime.state.isStarted = true;
     eventBus.broadcastLocal('$broker.started');
-    // refresh local node information
     registry.generateLocalNodeInfo(true);
 
-    // If transport is used, we set the transport ready to inform the other nodes
     if (transport) {
       await transport.setReady();
     }
@@ -174,7 +165,6 @@ exports.createBrokerInstance = (runtime) => {
 
     await middlewareHandler.callHandlersAsync('stopping', [runtime], true);
 
-    // Stop services
     try {
       await Promise.all(services.serviceList.map(service => service.stop()));
     } catch (error) {
@@ -182,33 +172,27 @@ exports.createBrokerInstance = (runtime) => {
       throw error;
     }
 
-    // Disconnect transports
     if (transport) {
       await transport.disconnect();
     }
 
-    // Stop cache
     if (runtime.cache) {
       log.debug('Stopping caching adapters.');
       await runtime.cache.stop();
     }
 
-    // Stop metrics
     if (runtime.metrics) {
       log.debug('Stopping metrics.');
       await runtime.metrics.stop();
     }
 
-    // Stop tracers
     if (runtime.tracer) {
       log.debug('Stopping tracing adapters.');
       await runtime.tracer.stop();
     }
 
-    // Call "stopped" middleware method.
     await middlewareHandler.callHandlersAsync('stopped', [runtime], true);
 
-    // Call "stopped" lifecycle hook
     if (!runtime.state.isStarted && isFunction(options.stopped)) {
       options.stopped.call(runtime);
     }
@@ -229,7 +213,7 @@ exports.createBrokerInstance = (runtime) => {
    * Ping other nodes
    * @param {string=} nodeId Node ID
    * @param {number} timeout Timeout
-   * @returns {Object<string, number>} Result
+   * @returns {Promise<Object<string, number>>} Result
   */
   broker.ping = function (nodeId, timeout = 3000) {
     if (transport && transport.isConnected) {
@@ -250,7 +234,6 @@ exports.createBrokerInstance = (runtime) => {
           transport.sendPing(nodeId);
         });
       } else {
-        // handle arrays
         const pongs = {};
 
         const nodes = registry.nodeCollection.list({})
@@ -289,7 +272,6 @@ exports.createBrokerInstance = (runtime) => {
     return Promise.resolve(nodeId ? null : {});
   };
 
-  // Register internal broker events
   broker.bus.on('$node.disconnected', ({ nodeId }) => {
     runtime.transport.removePendingRequestsByNodeId(nodeId);
     services.serviceChanged(false);
@@ -301,101 +283,81 @@ exports.createBrokerInstance = (runtime) => {
    * @returns {void}
    */
   const registerMiddlewares = (customMiddlewares) => {
-    // Register custom middlewares
     if (Array.isArray(customMiddlewares) && customMiddlewares.length > 0) {
       customMiddlewares.forEach(middleware => middlewareHandler.add(middleware));
     }
 
-    // Add the built-in middlewares. (The order is important)
     if (options.loadInternalMiddlewares) {
       middlewareHandler.add(Middlewares.ActionHooks);
 
-      // Validator middleware
       if (options.validateActionParams && validator) {
         middlewareHandler.add(Middlewares.Validator);
       }
 
-      // Bulkhead
       if (options.bulkhead.enabled) {
         middlewareHandler.add(Middlewares.Bulkhead);
       }
 
-      // Cache
       if (runtime.cache) {
         middlewareHandler.add(Middlewares.Cache);
       }
 
-      // Context tracking
       if (options.contextTracking.enabled) {
         middlewareHandler.add(Middlewares.ContextTracker);
       }
 
-      // Circuit breaker
       if (options.circuitBreaker.enabled) {
         middlewareHandler.add(Middlewares.CircuitBreaker);
       }
 
-      // timeout middleware
       middlewareHandler.add(Middlewares.Timeout);
 
-      // Retry policy
       if (options.retryPolicy.enabled) {
         middlewareHandler.add(Middlewares.Retry);
       }
 
-      // Error handler
       middlewareHandler.add(Middlewares.ErrorHandler);
 
-      // Tracing
       if (options.tracing.enabled) {
         middlewareHandler.add(Middlewares.Tracing);
       }
 
-      // Metrics
       if (options.metrics.enabled) {
         middlewareHandler.add(Middlewares.Metrics);
       }
     }
 
-    // Wrap runtime and broker methods for middlewares
     runtime.actionInvoker.call = middlewareHandler.wrapMethod('call', runtime.actionInvoker.call);
     runtime.actionInvoker.multiCall = middlewareHandler.wrapMethod('multiCall', broker.multiCall);
     runtime.eventBus.emit = middlewareHandler.wrapMethod('emit', runtime.eventBus.emit);
     runtime.eventBus.broadcast = middlewareHandler.wrapMethod('broadcast', runtime.eventBus.broadcast);
     runtime.eventBus.broadcastLocal = middlewareHandler.wrapMethod('broadcastLocal', runtime.eventBus.broadcastLocal);
 
-    // Wrap broker methods
     broker.createService = middlewareHandler.wrapMethod('createService', broker.createService);
     broker.loadService = middlewareHandler.wrapMethod('loadService', broker.loadService);
     broker.loadServices = middlewareHandler.wrapMethod('loadServices', broker.loadServices);
     broker.ping = middlewareHandler.wrapMethod('ping', broker.ping);
   };
 
-  // Run "beforeRegisterMiddlewares" hook
   if (isFunction(options.beforeRegisterMiddlewares)) {
     options.beforeRegisterMiddlewares.call(broker, { broker, runtime });
   }
 
-  // Register middlewares
   registerMiddlewares(options.middlewares);
 
-  // Stop the broker greaceful
   /* istanbul ignore next */
   const onClose = () => broker.stop()
     .catch(error => broker.log.error(error))
     .then(() => process.exit(0));
 
-  // SIGTERM listener
   process.setMaxListeners(0);
   process.on('beforeExit', onClose);
   process.on('exit', onClose);
   process.on('SIGINT', onClose);
   process.on('SIGTERM', onClose);
 
-  // Add broker reference to runtime
   Object.assign(runtime, { broker });
 
-  // Call middleware hook for broker created.
   middlewareHandler.callHandlersSync('created', [runtime]);
 
   return broker;

package/lib/buildRuntime.js

@@ -37,7 +37,6 @@ exports.initRuntime = (options) => {
     maxListeners: 1000
   });
 
-  // Create base runtime object
   const runtime = {
     nodeId: options.nodeId,
     version,
@@ -51,7 +50,6 @@ exports.initRuntime = (options) => {
     fatalError: (message, error, killProcess) => fatalErrorHandler(runtime, message, error, killProcess)
   };
 
-  // Init modules
   initLogger(runtime);
   initUUIDFactory(runtime);
   initMiddlewareHandler(runtime);

package/lib/cache/adapters/base.js

@@ -39,7 +39,6 @@ const createCacheBase = (name, runtime, adapterOptions, options) => {
       ttl: null
     }, options),
     init () {
-      // register metrics
       if (runtime.metrics) {
         this.metrics = runtime.metrics;
         registerCacheMetrics(runtime.metrics);
@@ -79,7 +78,6 @@ const createCacheBase = (name, runtime, adapterOptions, options) => {
         const prefix = actionName + '.';
 
         if (keys) {
-          // fast path for single keys
           if (keys.length === 1) {
             const cacheKeyData = getPropertyFromDataOrMetadata(data, metadata, keys[0]);
             const key = getCacheKeyByObject(cacheKeyData);
@@ -87,7 +85,6 @@ const createCacheBase = (name, runtime, adapterOptions, options) => {
             return prefix + generateHash(value);
           }
 
-          // Handle data cache keys
           if (keys.length > 0) {
             const valueString = keys.reduce((pre, property, index) => {
               let value = getPropertyFromDataOrMetadata(data, metadata, property);

package/lib/cache/adapters/inMemory.js

@@ -36,7 +36,6 @@ const createInMemoryCache = (adapterOptions = {}) => (runtime, options = {}) =>
 
   ttlTimerHandle.unref();
 
-  // if a new broker gets connected, we need to clear the cache
   runtime.bus.on('$transport.connected', () => {
     base.log.debug('Transport adapter connected. Cache will be cleared.');
     cache.clear();
@@ -95,7 +94,6 @@ const createInMemoryCache = (adapterOptions = {}) => (runtime, options = {}) =>
           base.metrics.increment(Constants.CACHE_SET_TOTAL);
         }
 
-        // if ttl is not set in action cache settings, use options ttl
         if (ttl == null) {
           ttl = options.ttl;
         }

package/lib/cache/adapters/inMemoryLru.js

@@ -22,7 +22,6 @@ const createInMemoryLruCache = (adapterOptions) => (runtime, options = {}) => {
 
   timer.unref();
 
-  // if a new broker gets connected, we need to clear the cache
   runtime.bus.on('$transport.connected', () => {
     base.log.debug('Transport adapter connected. Cache will be cleared.');
     cache.clear();

package/lib/cache/getCacheKeyByObject.js

@@ -9,7 +9,6 @@ const getCacheKeyByObject = (value) => {
   if (Array.isArray(value)) {
     return '[' + value.map(object => getCacheKeyByObject(object)).join(',') + ']';
   } else if (isObject(value)) {
-    // Handle date objects
     if (value instanceof Date) {
       return value.toISOString();
     }

package/lib/cache/getPropertyFromDataOrMetadata.js

@@ -8,9 +8,7 @@ const { dotGet } = require('@weave-js/utils');
  * @returns {any} Result
  */
 const getPropertyFromDataOrMetadata = (data, metadata, key) => {
-  // if a key starts with ":", the property is picked from metadata
   if (key.startsWith(':')) {
-    // remove ':' from key.
     key = key.replace(':', '');
     return dotGet(metadata, key);
   }

package/lib/errors.js

@@ -7,8 +7,21 @@
 const { defaultsDeep } = require('@weave-js/utils');
 const { ExtendableError } = require('./ExtendableError');
 
+/**
+ * @typedef {object} ErrorOptions
+ * @property {string} code Error code
+ * @property {boolean} retryable Retryable error
+ * @property {*} data Error data
+ * @property {string} name Error name
+*/
+
 class WeaveError extends ExtendableError {
-  constructor (message, options) { // code, type, data
+  /**
+   * Create a new WeaveRetryableError
+   * @param {string} message Error message
+   * @param {ErrorOptions} options? Error options
+  */
+  constructor (message, options = {}) {
     options = defaultsDeep(
       options,
       {
@@ -22,14 +35,15 @@ class WeaveError extends ExtendableError {
     this.code = options.code || 'WEAVE_ERROR';
     this.data = options.data;
     this.retryable = false;
-
-    if (options.statusCode) {
-      this.statusCode = options.statusCode;
-    }
   }
 }
 
 class WeaveRetryableError extends WeaveError {
+  /**
+   * Create a new WeaveRetryableError
+   * @param {string} message Error message
+   * @param {ErrorOptions} options Error options
+  */
   constructor (message, options = { code: 'WEAVE_RETRYABLE_ERROR', retryable: true }) {
     super(message, options);
     this.retryable = true;

package/lib/index.js

@@ -20,16 +20,12 @@ exports.defaultOptions = getDefaultOptions();
  * @return {Broker} Broker instance
 */
 exports.createBroker = (options) => {
-  // get default options
   const defaultOptions = getDefaultOptions();
 
-  // merge options with default options
   options = defaultsDeep(options, defaultOptions);
 
-  // Init runtime
   const runtime = initRuntime(options);
 
-  // Create broker instance
   return createBrokerInstance(runtime);
 };
 
@@ -40,12 +36,10 @@ exports.createBroker = (options) => {
 */
 exports.Weave = exports.createBroker;
 
-// Errors
 exports.Errors = require('./errors');
 
 exports.Constants = require('./constants');
 
-// Caching
 exports.Cache = require('./cache/adapters');
 
 /**
@@ -56,7 +50,6 @@ exports.TransportAdapters = require('./transport/adapters');
 exports.TracingAdapters = require('./tracing/collectors');
 exports.CacheAdapters = require('./cache/adapters');
 
-// Helper
 exports.defineBrokerOptions = require('./helper/defineBrokerOptions');
 exports.defineService = require('./helper/defineService');
 exports.defineAction = require('./helper/defineAction');

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,
@@ -31,7 +65,7 @@ const wrapTracingLocalActionMiddleware = function (handler) {
         sampled: context.tracing
       });
 
-      context.span = span;
+      context.tracing = span.sampled;
 
       return handler(context, serviceInjections)
         .then(result => {
@@ -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);
         });
     };
@@ -77,17 +110,16 @@ const wrapTracingLocalEventMiddleware = function (handler, event) {
         sampled: context.tracing
       });
 
-      context.span = span;
+      context.tracing = span.sampled;
 
       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/initActionInvoker.js

@@ -20,24 +20,23 @@ exports.initActionInvoker = (runtime) => {
 
     const action = endpoint.action;
     const nodeId = endpoint.node.id;
-    let context;
+    let contextToUse;
 
-    // If a context is passed, we use this
     if (opts.context !== undefined) {
-      context = opts.context;
-      context.nodeId = nodeId;
+      contextToUse = opts.context;
+      contextToUse.nodeId = nodeId;
     } else {
-      context = contextFactory.create(endpoint, data, opts);
+      contextToUse = contextFactory.create(endpoint, data, opts);
     }
 
     if (endpoint.isLocal) {
-      log.debug({ action: context.action.name, requestId: context.requestId }, 'Call action local.');
+      log.debug({ action: contextToUse.action.name, requestId: contextToUse.requestId }, 'Call action local.');
     } else {
-      log.debug({ action: context.action.name, nodeId, requestId: context.requestId }, 'Call action on remote node.');
+      log.debug({ action: contextToUse.action.name, nodeId, requestId: contextToUse.requestId }, 'Call action on remote node.');
     }
 
-    const p = action.handler(context, { service: context.action.service, runtime, errors });
-    p.context = context;
+    const p = action.handler(contextToUse, { service: contextToUse.action.service, runtime, errors });
+    p.context = contextToUse;
 
     return p;
   };

package/lib/runtime/initCache.js

@@ -7,7 +7,6 @@ exports.initCache = (runtime) => {
       throw new WeaveError('Invalid cache adapter.');
     }
 
-    // Init cache adapter
     const cache = runtime.options.cache.adapter(runtime, runtime.options.cache);
 
     runtime.log.info(`Cache: ${cache.name}`);