@weave-js/core 0.10.0 → 0.11.0

package/lib/ExtendableError.js

@@ -0,0 +1,33 @@
+class ExtendableError extends Error {
+  constructor (message = '') {
+    super(message)
+
+    Object.defineProperty(this, 'name', {
+      configurable: true,
+      enumerable: false,
+      value: this.constructor.name,
+      writable: true
+    })
+
+    Object.defineProperty(this, 'message', {
+      configurable: true,
+      enumerable: false,
+      value: message,
+      writable: true
+    })
+
+    if (Object.prototype.hasOwnProperty.call(Error, 'captureStackTrace')) {
+      Error.captureStackTrace(this, this.constructor)
+      return
+    }
+
+    Object.defineProperty(this, 'stack', {
+      configurable: true,
+      enumerable: false,
+      value: new Error(message).stack,
+      writable: true
+    })
+  }
+}
+
+module.exports = { ExtendableError }

package/lib/broker/context.js

@@ -9,6 +9,7 @@
  * @typedef {import('../types').Context} Context
  * @typedef {import('../types').Runtime} Runtime
  * @typedef {import('../types').ContextPromise} ContextPromise
+ * @typedef {import('../types').Endpoint} Endpoint
 */
 
 const { uuid, isFunction, isStream, isStreamObjectMode } = require('@weave-js/utils')
@@ -85,6 +86,15 @@ exports.createContext = (runtime) => {
       })
     },
     startSpan (name, options) {
+      options = Object.assign({
+        id: this.id,
+        traceId: this.requestId,
+        parentId: this.parentId,
+        type: 'action',
+        service: this.service,
+        sampled: this.tracing
+      }, options)
+
       if (this.span) {
         this.span = this.span.startChildSpan(name, options)
       } else {
@@ -111,6 +121,8 @@ exports.createContext = (runtime) => {
       contextCopy.meta = this.meta
       contextCopy.parentContext = this.parentContext
       contextCopy.callerNodeId = this.callerNodeId
+      contextCopy.requestId = this.requestId
+      contextCopy.tracing = this.tracing
       contextCopy.level = this.level
       contextCopy.eventName = this.eventName
       contextCopy.eventType = this.eventType

package/lib/broker/{default-options.js → defaultOptions.js}

@@ -29,7 +29,10 @@ exports.getDefaultOptions = () => {
     cache: {
       enabled: false,
       adapter: 'memory',
-      ttl: 3000
+      ttl: 3000,
+      lock: {
+        enabled: false
+      }
     },
     circuitBreaker: {
       enabled: false,
@@ -49,7 +52,10 @@ exports.getDefaultOptions = () => {
       heartbeatTimeout: 10 * 1000,
       offlineNodeCheckInterval: 30 * 1000,
       maxOfflineTime: 1000 * 60 * 10,
-      maxChunkSize: 256 * 1024
+      maxChunkSize: 256 * 1024,
+      streams: {
+        handleBackpressure: true
+      }
     },
     errorHandler: null,
     loadInternalMiddlewares: true,
@@ -58,7 +64,7 @@ exports.getDefaultOptions = () => {
       collectCommonMetrics: true,
       collectInterval: 5000,
       adapters: [],
-      defaultBuckets: [1, 5, 10, 20, 25, 30, 50, 100, 250, 500, 1000, 2500, 5000, 10000]
+      defaultBuckets: [1, 5, 10, 20, 25, 30, 40, 50, 100, 250, 500, 1000, 2500, 5000, 10000]
     },
     middlewares: null,
     logger: {
@@ -72,7 +78,19 @@ exports.getDefaultOptions = () => {
     tracing: {
       enabled: false,
       samplingRate: 1.0,
-      collectors: []
+      collectors: [],
+      actions: {
+        data: false,
+        tags: {}
+      },
+      events: {
+        data: false,
+        tags: {}
+      },
+      errors: {
+        fields: ['name', 'message', 'code', 'type', 'data'],
+        stackTrace: false
+      }
     },
     namespace: '',
     registry: {

package/lib/broker/index.js

@@ -6,9 +6,9 @@
 */
 
 // node packages
+const { isFunction } = require('@weave-js/utils')
 const path = require('path')
 const glob = require('glob')
-const { isFunction } = require('@weave-js/utils')
 const Middlewares = require('../middlewares')
 
 /**
@@ -37,235 +37,260 @@ exports.createBrokerInstance = (runtime) => {
   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 (metrics) {
     metrics.init()
   }
 
+  // Init cache
   if (cache) {
     cache.init()
   }
 
   // broker object
   /** @type {Broker} */
-  const broker = {
-    nodeId: options.nodeId,
-    version,
-    options,
-    runtime,
-    bus,
-    validator,
-    contextFactory,
-    log,
-    createLogger: runtime.createLogger,
-    getUUID: () => runtime.generateUUID(),
-    registry,
-    getNextActionEndpoint (actionName, options = {}) {
-      return registry.getNextAvailableActionEndpoint(actionName, options)
-    },
-    emit: eventBus.emit.bind(this),
-    broadcast: eventBus.broadcast.bind(this),
-    broadcastLocal: eventBus.broadcastLocal.bind(this),
-    call: runtime.actionInvoker.call.bind(this),
-    multiCall: runtime.actionInvoker.multiCall.bind(this),
-    waitForServices: services.waitForServices.bind(this),
-    createService: services.createService.bind(this),
-    /**
-     * Load and register a service from file.
-     * @param {string} fileName Path to the service file.
-     * @returns {Service} Service
-    */
-    loadService (fileName) {
-      const filePath = path.resolve(fileName)
-      const schema = require(filePath)
-      const service = this.createService(schema)
-
-      // If the "watchSevrices" option is set - add service to service watcher.
-      if (options.watchServices) {
-        service.filename = fileName
-        services.watchService.call(this, service)
-      }
+  const broker = Object.create(null)
+
+  broker.runtime = runtime
+  broker.registry = registry
+  broker.bus = bus
+  broker.nodeId = options.nodeId
+  broker.version = version
+  broker.options = options
+  broker.validator = validator
+  broker.contextFactory = contextFactory
+  broker.log = log
+  broker.createLogger = runtime.createLogger
+
+  broker.getUUID = function () {
+    return runtime.generateUUID()
+  }
 
-      return service
-    },
-    /**
-     * Load services from a folder.
-     * @param {string} [folder='./services'] Path of the folder.
-     * @param {string} [fileMask='*.service.js'] Pattern of the service files
-     * @returns {number} Amount of services
-    */
-    loadServices (folder = './services', fileMask = '*.service.js') {
-      const serviceFiles = glob.sync(path.join(folder, fileMask))
-
-      log.info(`Searching services in folder '${folder}' with name pattern '${fileMask}'.`)
-      log.info(`${serviceFiles.length} services found.`)
-
-      serviceFiles.forEach(fileName => this.loadService(fileName))
-      return serviceFiles.length
-    },
-    /**
-     * Starts the broker.
-     * @returns {Promise} Promise
-    */
-    async start () {
-      const startTime = Date.now()
-      await middlewareHandler.callHandlersAsync('starting', [runtime], true)
-
-      if (transport) {
-        await transport.connect()
-      }
+  broker.getNextActionEndpoint = function (actionName, options = {}) {
+    return registry.getNextAvailableActionEndpoint(actionName, options)
+  }
 
-      try {
-        await Promise.all(services.serviceList.map(service => service.start()))
-      } catch (error) {
-        log.error(error, 'Unable to start all services')
-        clearInterval(options.waitForServiceInterval)
-        throw error
-      }
+  broker.emit = eventBus.emit.bind(broker)
 
-      runtime.state.isStarted = true
-      eventBus.broadcastLocal('$broker.started')
-      registry.generateLocalNodeInfo(true)
+  broker.broadcast = eventBus.broadcast.bind(broker)
 
-      if (transport) {
-        await transport.setReady()
-      }
+  broker.broadcastLocal = eventBus.broadcastLocal.bind(broker)
 
-      await middlewareHandler.callHandlersAsync('started', [runtime], true)
+  broker.call = runtime.actionInvoker.call.bind(broker)
 
-      if (runtime.state.isStarted && isFunction(options.started)) {
-        options.started.call(this)
-      }
+  broker.multiCall = runtime.actionInvoker.multiCall.bind(broker)
 
-      const duration = Date.now() - startTime
-      log.info(`Node "${options.nodeId}" with ${services.serviceList.length} services successfully started in ${duration}ms.`)
-    },
-    /**
-     * Stops the broker.
-     * @returns {Promise} Promise
-    */
-    async stop () {
-      runtime.state.isStarted = false
-      log.info('Shutting down the node...')
-
-      await middlewareHandler.callHandlersAsync('stopping', [runtime], true)
-
-      try {
-        await Promise.all(services.serviceList.map(service => service.stop()))
-      } catch (error) {
-        log.error(error, 'Unable to stop all services.')
-        throw error
-      }
+  broker.waitForServices = services.waitForServices.bind(broker)
 
-      if (transport) {
-        await transport.disconnect()
-      }
+  broker.createService = services.createService.bind(broker)
 
-      if (runtime.cache) {
-        log.debug('Stopping caching adapters.')
-        await runtime.cache.stop()
-      }
+  /**
+   * Global error handler of the broker.
+   * @param {*} error Error
+   * @returns {void}
+  */
+  broker.handleError = runtime.handleError
 
-      if (runtime.metrics) {
-        log.debug('Stopping metrics.')
-        await runtime.metrics.stop()
-      }
+  broker.fatalError = runtime.fatalError
 
-      if (runtime.tracer) {
-        log.debug('Stopping tracing adapters.')
-        await runtime.tracer.stop()
-      }
+  /**
+  * Load and register a service from file.
+  * @param {string} fileName Path to the service file.
+  * @returns {Service} Service
+  */
+  broker.loadService = function (fileName) {
+    const filePath = path.resolve(fileName)
+    const schema = require(filePath)
+    const service = broker.createService(schema)
+
+    // If the "watchSevrices" option is set - add service to service watcher.
+    if (options.watchServices) {
+      service.filename = fileName
+      services.watchService.call(broker, service)
+    }
 
-      await middlewareHandler.callHandlersAsync('stopped', [runtime], true)
+    return service
+  }
 
-      if (!runtime.state.isStarted && isFunction(options.stopped)) {
-        options.stopped.call(runtime)
-      }
+  broker.loadServices = function (folder = './services', fileMask = '*.service.js') {
+    const serviceFiles = glob.sync(path.join(folder, fileMask))
 
-      log.info('The node was successfully shut down. Bye bye! 👋')
-
-      eventBus.broadcastLocal('$broker.stopped')
-
-      process.removeListener('beforeExit', onClose)
-      process.removeListener('exit', onClose)
-      process.removeListener('SIGINT', onClose)
-      process.removeListener('SIGTERM', onClose)
-
-      // todo: handle errors
-    },
-    /**
-     * Send a ping to connected nodes.
-     * @param {*} nodeId Node id
-     * @param {number} [timeout=3000] Ping timeout
-     * @returns {Array} Ping result
-    */
-    ping (nodeId, timeout = 3000) {
-      if (transport && transport.isConnected) {
-        if (nodeId) {
-          return new Promise((resolve) => {
-            const timeoutTimer = setTimeout(() => {
-              bus.off('$node.pong', pongHandler)
-              return resolve(null)
-            }, timeout)
+    log.info(`Searching services in folder '${folder}' with name pattern '${fileMask}'.`)
+    log.info(`${serviceFiles.length} services found.`)
 
-            const pongHandler = pong => {
-              clearTimeout(timeoutTimer)
-              bus.off('$node.pong', pongHandler)
-              resolve(pong)
-            }
+    serviceFiles.forEach(fileName => broker.loadService(fileName))
+    return serviceFiles.length
+  }
+
+  /**
+  * Starts the broker.
+  * @returns {Promise} Promise
+  */
+  broker.start = async function () {
+    const startTime = Date.now()
+    await middlewareHandler.callHandlersAsync('starting', [runtime], true)
+
+    // If transport is used, we connect the transport adapter.
+    if (transport) {
+      await transport.connect()
+    }
+
+    try {
+      await Promise.all(services.serviceList.map(service => service.start()))
+    } catch (error) {
+      log.error(error, 'Unable to start all services')
+      clearInterval(options.waitForServiceInterval)
+      throw error
+    }
+
+    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()
+    }
+
+    await middlewareHandler.callHandlersAsync('started', [runtime], true)
+
+    if (runtime.state.isStarted && isFunction(options.started)) {
+      options.started.call(broker)
+    }
+
+    const duration = Date.now() - startTime
+    log.info(`Node "${options.nodeId}" with ${services.serviceList.length} services successfully started in ${duration}ms.`)
+  }
+
+  /**
+    * Stops the broker.
+    * @returns {Promise} Promise
+  */
+  broker.stop = async function () {
+    runtime.state.isStarted = false
+    log.info('Shutting down the node...')
+
+    await middlewareHandler.callHandlersAsync('stopping', [runtime], true)
+
+    // Stop services
+    try {
+      await Promise.all(services.serviceList.map(service => service.stop()))
+    } catch (error) {
+      log.error(error, 'Unable to stop all services.')
+      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)
+    }
 
-            bus.on('$node.pong', pongHandler)
-            transport.sendPing(nodeId)
-          })
-        } else {
-          // handle arrays
-          const pongs = {}
+    log.info('The node was successfully shut down. Bye bye! 👋')
 
-          const nodes = registry.getNodeList({})
-            .filter(node => !node.isLocal)
-            .map(node => node.id)
+    eventBus.broadcastLocal('$broker.stopped')
 
-          const onFlight = new Set(nodes)
+    process.removeListener('beforeExit', onClose)
+    process.removeListener('exit', onClose)
+    process.removeListener('SIGINT', onClose)
+    process.removeListener('SIGTERM', onClose)
 
-          nodes.forEach(nodeId => {
-            pongs[nodeId] = null
-          })
+    // todo: handle errors
+  }
 
-          return new Promise((resolve) => {
-            // todo: handle timeout
-            const timeoutTimer = setTimeout(() => {
+  /**
+   * Ping other nodes
+   * @param {string=} nodeId Node ID
+   * @param {number} timeout Timeout
+   * @returns {Object<string, number>} Result
+  */
+  broker.ping = function (nodeId, timeout = 3000) {
+    if (transport && transport.isConnected) {
+      if (nodeId) {
+        return new Promise((resolve) => {
+          const timeoutTimer = setTimeout(() => {
+            bus.off('$node.pong', pongHandler)
+            return resolve(null)
+          }, timeout)
+
+          const pongHandler = pong => {
+            clearTimeout(timeoutTimer)
+            bus.off('$node.pong', pongHandler)
+            resolve(pong)
+          }
+
+          bus.on('$node.pong', pongHandler)
+          transport.sendPing(nodeId)
+        })
+      } else {
+        // handle arrays
+        const pongs = {}
+
+        const nodes = registry.getNodeList({})
+          .filter(node => !node.isLocal)
+          .map(node => node.id)
+
+        const onFlight = new Set(nodes)
+
+        nodes.forEach(nodeId => {
+          pongs[nodeId] = null
+        })
+
+        return new Promise((resolve) => {
+          // todo: handle timeout
+          const timeoutTimer = setTimeout(() => {
+            bus.off('$node.pong', pongHandler)
+            resolve(pongs)
+          }, timeout)
+
+          const pongHandler = pong => {
+            pongs[pong.nodeId] = pong
+            onFlight.delete(pong.nodeId)
+            if (onFlight.size === 0) {
+              clearTimeout(timeoutTimer)
               bus.off('$node.pong', pongHandler)
               resolve(pongs)
-            }, timeout)
-
-            const pongHandler = pong => {
-              pongs[pong.nodeId] = pong
-              onFlight.delete(pong.nodeId)
-              if (onFlight.size === 0) {
-                clearTimeout(timeoutTimer)
-                bus.off('$node.pong', pongHandler)
-                resolve(pongs)
-              }
             }
+          }
 
-            bus.on('$node.pong', pongHandler)
-            nodes.map(nodeId => transport.sendPing(nodeId))
-          })
-        }
+          bus.on('$node.pong', pongHandler)
+          nodes.map(nodeId => transport.sendPing(nodeId))
+        })
       }
+    }
 
-      return Promise.resolve(nodeId ? null : {})
-    },
-    /**
-     * Global error handler of the broker.
-     * @param {*} error Error
-     * @returns {void}
-     */
-    handleError: runtime.handleError,
-    fatalError: runtime.fatalError
+    return Promise.resolve(nodeId ? null : {})
   }
 
   // Register internal broker events
@@ -301,7 +326,7 @@ exports.createBrokerInstance = (runtime) => {
 
       // Cache
       if (runtime.cache) {
-        middlewareHandler.add(runtime.cache.middleware)
+        middlewareHandler.add(Middlewares.Cache)
       }
 
       // Context tracking
@@ -343,10 +368,11 @@ exports.createBrokerInstance = (runtime) => {
     runtime.eventBus.broadcast = middlewareHandler.wrapMethod('broadcast', runtime.eventBus.broadcast)
     runtime.eventBus.broadcastLocal = middlewareHandler.wrapMethod('broadcastLocal', runtime.eventBus.broadcastLocal)
 
-    // Wrap Brober methods
+    // 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

package/lib/{build-runtime.js → buildRuntime.js}

@@ -4,30 +4,30 @@
  * @typedef {import('./types.js').Broker} Broker
 */
 
-const { initLogger } = require('./runtime/init-logger')
-const { initMiddlewareHandler } = require('./runtime/init-middleware-manager')
-const { initRegistry } = require('./runtime/init-registry')
-const { initContextFactory } = require('./runtime/init-context-factory')
-const { initEventbus } = require('./runtime/init-eventbus')
-const { initValidator } = require('./runtime/init-validator')
-const { initTransport } = require('./runtime/init-transport')
-const { initCache } = require('./runtime/init-cache')
-const { initActionInvoker } = require('./runtime/init-action-invoker')
-const { initServiceManager } = require('./runtime/init-service-manager')
-const { initMetrics } = require('./runtime/init-metrics')
-const { initTracer } = require('./runtime/init-tracing')
-const { initUUIDFactory } = require('./runtime/init-uuid-factory')
+const { initLogger } = require('./runtime/initLogger')
+const { initMiddlewareHandler } = require('./runtime/initMiddlewareManager')
+const { initRegistry } = require('./runtime/initRegistry')
+const { initContextFactory } = require('./runtime/initContextFactory')
+const { initEventbus } = require('./runtime/initEventbus')
+const { initValidator } = require('./runtime/initValidator')
+const { initTransport } = require('./runtime/initTransport')
+const { initCache } = require('./runtime/initCache')
+const { initActionInvoker } = require('./runtime/initActionInvoker')
+const { initServiceManager } = require('./runtime/initServiceManager')
+const { initMetrics } = require('./runtime/initMetrics')
+const { initTracer } = require('./runtime/initTracing')
+const { initUUIDFactory } = require('./runtime/initUuidFactory')
+const { errorHandler, fatalErrorHandler } = require('./errorHandler')
+const { uuid } = require('@weave-js/utils')
 const { version } = require('../package.json')
-const { errorHandler, fatalErrorHandler } = require('./error-handler')
 const EventEmitter = require('eventemitter2')
-const { uuid } = require('@weave-js/utils')
 
 /**
  * Build runtime object
  * @param {BrokerOptions} options Broker options
  * @return {Runtime} Runtime
 */
-exports.buildRuntime = (options) => {
+exports.initRuntime = (options) => {
   /**
    * Event bus
    * @returns {EventEmitter} Service object.