@weave-js/core 0.10.0 → 0.11.0

package/lib/cache/base.js

@@ -39,8 +39,8 @@ function registerCacheMetrics (metrics) {
 
 exports.createCacheBase = (runtime, options) => {
   const cache = {
+    isConnected: false,
     runtime,
-    options,
     options: Object.assign({
       ttl: null
     }, options),
@@ -107,36 +107,41 @@ exports.createCacheBase = (runtime, options) => {
     }
   }
 
-  cache.middleware = () => {
-    return {
-      localAction: (handler, action) => {
-        const cacheOptions = Object.assign({ enabled: true }, isObject(action.cache) ? action.cache : { enabled: !!action.cache })
-        if (cacheOptions.enabled) {
-          return function cacheMiddleware (context, serviceInjections) {
-            const cacheHashKey = cache.getCachingHash(action.name, context.data, context.meta, action.cache.keys)
-            context.isCachedResult = false
+  // cache.middleware = (runtime) => {
+  //   return {
+  //     localAction: (handler, action) => {
+  //       const cacheOptions = Object.assign({ enabled: true }, isObject(action.cache) ? action.cache : { enabled: !!action.cache })
+  //       if (cacheOptions.enabled) {
+  //         return function cacheMiddleware (context, serviceInjections) {
+  //           const cacheHashKey = runtime.cache.getCachingHash(action.name, context.data, context.meta, action.cache.keys)
+  //           context.isCachedResult = false
 
-            if (context.meta.$noCache === true) {
-              return handler(context, serviceInjections)
-            }
+  //           if (context.meta.$noCache === true) {
+  //             return handler(context, serviceInjections)
+  //           }
 
-            return cache.get(cacheHashKey).then((content) => {
-              if (content !== null) {
-                context.isCachedResult = true
-                return content
-              }
+  //           if (runtime.cache.isConnected === false) {
+  //             runtime.cache.log('Cache adapter is not connected yet. Call handler...')
+  //             return handler(context, serviceInjections)
+  //           }
 
-              return handler(context, serviceInjections).then((result) => {
-                cache.set(cacheHashKey, result, action.cache.ttl)
-                return result
-              })
-            })
-          }
-        }
-        return handler
-      }
-    }
-  }
+  //           return runtime.cache.get(cacheHashKey).then((cachedResult) => {
+  //             if (cachedResult !== null) {
+  //               context.isCachedResult = true
+  //               return cachedResult
+  //             }
+
+  //             return handler(context, serviceInjections).then((result) => {
+  //               runtime.cache.set(cacheHashKey, result, action.cache.ttl)
+  //               return result
+  //             })
+  //           })
+  //         }
+  //       }
+  //       return handler
+  //     }
+  //   }
+  // }
 
   return cache
 }

package/lib/cache/inMemory.js

@@ -0,0 +1,140 @@
+/*
+ * Author: Kevin Ries (kevin@fachw3rk.de)
+ * -----
+ * Copyright 2021 Fachwerk
+ */
+
+const { match } = require('@weave-js/utils')
+const { createCacheBase } = require('./base')
+const { createLock } = require('./lock')
+const Constants = require('../metrics/constants')
+
+const makeInMemoryCache = (runtime, options = {}) => {
+  const base = createCacheBase(runtime, options)
+  const storage = new Map()
+  const name = 'Memory'
+
+  const lock = createLock()
+
+  const timer = setInterval(() => {
+    checkTtl()
+  }, 3000)
+
+  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()
+  })
+
+  const checkTtl = () => {
+    const now = Date.now()
+
+    storage.forEach((item, hashKey) => {
+      if (item.expire && item.expire < now) {
+        cache.log.debug(`Delete ${hashKey}`)
+        storage.delete(hashKey)
+      }
+    })
+  }
+
+  const cache = Object.assign(
+    {},
+    base,
+    {
+      name,
+      init () {
+        base.init()
+        cache.isConnected = true
+      },
+      get (cacheKey) {
+        base.log.debug(`Get ${cacheKey}`)
+
+        if (base.metrics) {
+          base.metrics.increment(Constants.CACHE_GET_TOTAL)
+        }
+
+        const item = storage.get(cacheKey)
+
+        if (item) {
+          cache.log.debug(`Found ${cacheKey}`)
+
+          if (base.metrics) {
+            base.metrics.increment(Constants.CACHE_FOUND_TOTAL)
+          }
+
+          if (item.expire && item.expire < Date.now()) {
+            cache.log.debug(`Delete ${cacheKey}`)
+            storage.delete(cacheKey)
+            if (base.metrics) {
+              base.metrics.increment(Constants.CACHE_EXPIRED_TOTAL)
+            }
+            return Promise.resolve(null)
+          }
+
+          return Promise.resolve(item.data)
+        }
+        return Promise.resolve(null)
+      },
+      set (hashKey, data, ttl) {
+        if (base.metrics) {
+          base.metrics.increment(Constants.CACHE_SET_TOTAL)
+        }
+
+        if (ttl == null) {
+          ttl = options.ttl
+        }
+
+        storage.set(hashKey, {
+          data,
+          expire: ttl ? Date.now() + ttl : null
+        })
+
+        base.log.debug(`Set ${hashKey}`)
+
+        return Promise.resolve(data)
+      },
+      remove (hashKey) {
+        if (base.metrics) {
+          base.metrics.increment(Constants.CACHE_DELETED_TOTAL)
+        }
+        storage.delete(hashKey)
+        base.log.debug(`Delete ${hashKey}`)
+
+        return Promise.resolve()
+      },
+      clear (pattern = '**') {
+        if (base.metrics) {
+          base.metrics.increment(Constants.CACHE_DELETED_TOTAL)
+        }
+        storage.forEach((_, key) => {
+          if (match(key, pattern)) {
+            base.log.debug(`Delete ${key}`)
+            this.remove(key)
+          }
+        })
+        return Promise.resolve()
+      },
+      lock (key, ttl) {
+        return lock.acquire(key, ttl).then(() => {
+          return () => lock.release(key)
+        })
+      },
+      tryLock (key, ttl) {
+        if (lock.isLocked(key)) {
+          return Promise.reject(new Error('Locked'))
+        }
+
+        return lock.acquire(key, ttl).then(() => {
+          return () => lock.release(key)
+        })
+      },
+      stop () {
+        clearInterval(timer)
+      }
+    })
+  return cache
+}
+
+module.exports = makeInMemoryCache

package/lib/cache/index.js

@@ -8,7 +8,7 @@ const { isString, isFunction } = require('@weave-js/utils')
 const { WeaveBrokerOptionsError } = require('../errors')
 
 const adapters = {
-  Memory: require('./memory')
+  Memory: require('./inMemory')
 }
 
 exports.adapters = adapters

package/lib/cache/lock.js

@@ -1,14 +1,31 @@
-exports.ttlcreateLock = () => {
+const createLock = () => {
   const locked = new Map()
+
   return {
     acquire (key, ttl) {
-      const lock = locked.get(key)
-      if (!lock) {
-        lock.set(key, [])
+      const lockedItems = locked.get(key)
+      if (!lockedItems) {
+        locked.set(key, [])
+        return Promise.resolve()
+      } else {
+        return new Promise((resolve) => lockedItems.push(resolve))
       }
     },
     isLocked (key) {
       return !!locked.has(key)
+    },
+    release (key) {
+      const lockedItems = locked.get(key)
+      if (lockedItems) {
+        if (lockedItems.length > 0) {
+          lockedItems.shift()()
+        } else {
+          locked.delete(key)
+        }
+      }
+      return Promise.resolve()
     }
   }
 }
+
+module.exports = { createLock }

package/lib/constants.js

@@ -11,6 +11,13 @@ exports.loadBalancingStrategy = {
   RANDOM: 'random'
 }
 
+exports.circuitBreakerStates = {
+  CIRCUIT_CLOSED: 'closed',
+  CIRCUIT_HALF_OPENED: 'half_opened',
+  CIRCUIT_HALF_OPEN_WAITING: 'half_open_waiting',
+  CIRCUIT_OPENED: 'opened'
+}
+
 exports.level = {
   trace: 'trace',
   debug: 'debug',
@@ -19,7 +26,3 @@ exports.level = {
   error: 'error',
   fatal: 'fatal'
 }
-
-exports.SYNC_MIDDLEWARE_HOOKS = {
-  STARTING: 'starting'
-}

package/lib/errors.js

@@ -4,7 +4,9 @@
  * Copyright 2021 Fachwerk
  */
 
-class WeaveError extends Error {
+const { ExtendableError } = require('./ExtendableError')
+
+class WeaveError extends ExtendableError {
   constructor (message, code, type, data) {
     super(message)
     this.name = this.constructor.name
@@ -15,7 +17,7 @@ class WeaveError extends Error {
   }
 }
 
-class WeaveRetrieableError extends WeaveError {
+class WeaveRetryableError extends WeaveError {
   constructor (message, code, type, data) {
     super(message)
     this.code = code || 500
@@ -25,7 +27,7 @@ class WeaveRetrieableError extends WeaveError {
   }
 }
 
-class WeaveServiceNotFoundError extends WeaveRetrieableError {
+class WeaveServiceNotFoundError extends WeaveRetryableError {
   constructor (data = {}) {
     let message
 
@@ -33,31 +35,36 @@ class WeaveServiceNotFoundError extends WeaveRetrieableError {
       message = `Service "${data.actionName}" not found on node "${data.nodeId}".`
     } else if (data.actionName) {
       message = `Service "${data.actionName}" not found.`
+    } else {
+      message = 'Service not found.'
     }
 
     super(message, 404, 'WEAVE_SERVICE_NOT_FOUND_ERROR', data)
   }
 }
 
-class WeaveServiceNotAvailableError extends WeaveRetrieableError {
+class WeaveServiceNotAvailableError extends WeaveRetryableError {
   constructor (data = {}) {
     let message
     if (data.nodeId) {
       message = `Service "${data.actionName}" not available on node "${data.nodeId}".`
-    } else {
+    } else if (data.actionName) {
       message = `Service "${data.actionName}" not available.`
+    } else {
+      message = 'Service not available.'
     }
 
-    super(message, 405, 'WEAVE_SERVICE_NOT_AVAILABLE_ERROR', data)
+    super(message, 503, 'WEAVE_SERVICE_NOT_AVAILABLE_ERROR', data)
   }
 }
 
-class WeaveRequestTimeoutError extends WeaveRetrieableError {
+class WeaveRequestTimeoutError extends WeaveRetryableError {
   constructor (actionName, nodeId, timeout) {
     const message = `Action ${actionName} timed out node ${nodeId || '<local>'}.`
     super(message, 504, 'WEAVE_REQUEST_TIMEOUT_ERROR', {
       actionName,
-      nodeId
+      nodeId,
+      timeout
     })
     this.retryable = true
   }
@@ -116,7 +123,7 @@ module.exports = {
   WeaveParameterValidationError,
   WeaveQueueSizeExceededError,
   WeaveRequestTimeoutError,
-  WeaveRetrieableError,
+  WeaveRetryableError,
   WeaveServiceNotAvailableError,
   WeaveServiceNotFoundError,
   WeaveGracefulStopTimeoutError,

package/lib/helper/{define-action.js → defineAction.js}

@@ -1,3 +1,5 @@
+/* istanbul ignore next */
+
 /**
  * @typedef {import('../types.js').ServiceActionDefinition} ServiceActionDefinition
 */
@@ -6,7 +8,7 @@
  * Create and register a new service action.
  * @param {ServiceActionDefinition} actionDefinition - Schema of the the action
  * @returns {ServiceActionDefinition} Action definition
- */
+*/
 module.exports = function (actionDefinition) {
   return actionDefinition
 }

package/lib/helper/{define-broker-options.js → defineBrokerOptions.js}

@@ -1,3 +1,5 @@
+/* istanbul ignore next */
+
 /**
  * @typedef {import('../types.js').BrokerOptions} BrokerOptions
  */

package/lib/helper/{define-service.js → defineService.js}

@@ -1,3 +1,6 @@
+
+/* istanbul ignore next */
+
 /**
  * @typedef {import('../types.js').ServiceSchema} ServiceSchema
 */
@@ -6,7 +9,7 @@
  * Create and register a new service
  * @param {ServiceSchema} serviceSchema - Schema of the Service
  * @returns {ServiceSchema} Service schema
- */
+*/
 module.exports = function (serviceSchema) {
   return serviceSchema
 }

package/lib/index.js

@@ -4,15 +4,15 @@
  * @typedef {import('./types.js').Broker} Broker
 */
 
-const { getDefaultOptions } = require('./broker/default-options')
+const { getDefaultOptions } = require('./broker/defaultOptions')
 const { defaultsDeep } = require('@weave-js/utils')
-const { buildRuntime } = require('./build-runtime')
+const { initRuntime } = require('./buildRuntime')
 const { createBrokerInstance } = require('./broker')
 
 /**
  * @type {BrokerOptions} options Broker options
 */
-exports.defaultOptions = require('./broker/default-options')
+exports.defaultOptions = getDefaultOptions()
 
 /**
  * Build runtime object
@@ -27,13 +27,12 @@ exports.createBroker = (options) => {
   options = defaultsDeep(options, defaultOptions)
 
   // Init runtime
-  const runtime = buildRuntime(options)
+  const runtime = initRuntime(options)
 
   // Create broker instance
   return createBrokerInstance(runtime)
 }
 
-// eslint-disable-next-line valid-jsdoc
 /**
  * @deprecated since version 0.9.0
  * @param {import('./types.js').BrokerOptions} options Broker options.
@@ -45,15 +44,20 @@ exports.Weave = exports.createBroker
 exports.Errors = require('./errors')
 
 exports.Constants = require('./constants')
+
 // Transport
 exports.TransportAdapters = require('./transport/adapters')
 
 // Caching
 exports.Cache = require('./cache')
-exports.createBaseTracingCollector = require('./tracing/collectors/base')
+
+/**
+ * @deprecated since version 0.10.0
+*/
+exports.createBaseTracingCollector = require('./tracing/collectors/base').createBaseTracingCollector
 exports.TracingAdapters = require('./tracing/collectors')
 
 // Helper
-exports.defineBrokerOptions = require('./helper/define-broker-options')
-exports.defineService = require('./helper/define-service')
-exports.defineAction = require('./helper/define-action')
+exports.defineBrokerOptions = require('./helper/defineBrokerOptions')
+exports.defineService = require('./helper/defineService')
+exports.defineAction = require('./helper/defineAction')

package/lib/logger/format/asHumanReadable.js

@@ -1,4 +1,4 @@
-const { green, magenta, red, yellow, white, gray, cyan } = require('../utils/colorize')
+const { green, magenta, red, yellow, gray, cyan } = require('../utils/colorize')
 const os = require('os')
 
 exports.asHumanReadable = ({ levels, options }, originObj, message, number, time) => {
@@ -15,8 +15,9 @@ exports.asHumanReadable = ({ levels, options }, originObj, message, number, time
 
   const currentLabel = levels.labels[number]
 
+  const color = logLevelColors[currentLabel] || yellow
   // Log level label
-  logResult += logLevelColors[currentLabel](currentLabel.toUpperCase())
+  logResult += color(currentLabel.toUpperCase())
 
   // date time
   logResult += ' [' + new Date(time).toISOString() + '] '
@@ -26,7 +27,7 @@ exports.asHumanReadable = ({ levels, options }, originObj, message, number, time
   }
 
   if (message) {
-    logResult += ' ' + logLevelColors[currentLabel](message)
+    logResult += ' ' + color(message)
   }
 
   if (Object.keys(originObj).length > 0) {

package/lib/logger/index.js

@@ -18,7 +18,10 @@ const defaultOptions = {
   level: 'info',
   messageKey: 'message',
   customLevels: null,
-  base: { pid, hostname },
+  base: {
+    pid,
+    hostname
+  },
   hooks: {
     logMethod: undefined
   },

package/lib/logger/levels.js

@@ -51,8 +51,9 @@ exports.mappings = (customLevels = null, useOnlyCustomLevels = false) => {
     customNums
   )
 
+  // Merge log levels with "silent" log level.
   const values = Object.assign(
-    Object.create(Object.prototype, { silent: { value: Infinity }}),
+    Object.create(Object.prototype, { silent: { value: 0 }}),
     useOnlyCustomLevels ? null : levels,
     customLevels
   )

package/lib/logger/tools.js

@@ -7,6 +7,10 @@ exports.generateLogMethod = (runtime, level, hook) => {
     return log
   }
 
+  return function hookWrappedLog (...args) {
+    hook.call(runtime, args, log, level)
+  }
+
   function log (origin, ...n) {
     if (typeof origin === 'object') {
       let message = origin

package/lib/logger/utils/format.js

@@ -52,29 +52,43 @@ exports.format = (f, args, opts) => {
       case 79: // 'O'
       case 111: // 'o'
       case 106: // 'j'
-        if (a >= argumentLength) { break }
-        if (lastPos < i) { str += f.slice(lastPos, i) }
-        if (args[a] === undefined) break
+        if (a >= argumentLength) {
+          break
+        }
+
+        if (lastPos < i) {
+          str += f.slice(lastPos, i)
+        }
+
+        if (args[a] === undefined) {
+          break
+        }
+
         const type = typeof args[a]
+
         if (type === 'string') {
           str += '\'' + args[a] + '\''
           lastPos = i + 2
           i++
           break
         }
+
         if (type === 'function') {
           str += args[a].name || '<anonymous>'
           lastPos = i + 2
           i++
           break
         }
+
         str += ss(args[a])
         lastPos = i + 2
         i++
         break
       case 115: // 's'
         if (a >= argumentLength) { break }
-        if (lastPos < i) { str += f.slice(lastPos, i) }
+        if (lastPos < i) {
+          str += f.slice(lastPos, i)
+        }
         str += String(args[a])
         lastPos = i + 2
         i++

package/lib/metrics/constants.js

@@ -29,7 +29,7 @@ exports.TRANSPORTER_PACKETS_RECEIVED = 'weave.transport.packets.received'
 exports.TRANSPORT_IN_FLIGHT_STREAMS = 'weave.transport.streams.in-flight'
 
 // Bulkhead
-exports.REQUESTS_BULKHEAD_IN_FLIGHT = 'weave.bulkhead.requests.in-flight'
+exports.BULKHEAD_REQUESTS_IN_FLIGHT = 'weave.bulkhead.requests.in-flight'
 
 // OS Metrics
 exports.OS_HOSTNAME = 'os.hostname'

package/lib/metrics/types/gauge.js

@@ -6,7 +6,7 @@ exports.createGauge = (registry, obj) => {
   base.value = 0
 
   base.increment = (labels, value, timestamp) => {
-    const item = base.values.get(labels)
+    const item = base.get(labels)
     base.set((item ? item.value : 0) + value, labels, timestamp)
   }