@weave-js/core 0.9.2 → 0.11.0

package/lib/logger/base.js

@@ -1,5 +1,5 @@
 const { isStandardLevel, levelMethods } = require('./levels')
-const { noop, generateLogMethod, asJsonString } = require('./tools')
+const { noop, generateLogMethod } = require('./tools')
 
 exports.initBase = (runtime) => {
   runtime.setLevel = (level) => {
@@ -16,7 +16,7 @@ exports.initBase = (runtime) => {
     const hook = runtime.options.hooks.logMethod
 
     for (const key in values) {
-      if (levelVal > values[key]) {
+      if (levelVal < values[key]) {
         runtime.logMethods[key] = noop
         continue
       }
@@ -47,7 +47,7 @@ exports.initBase = (runtime) => {
       }
     }
 
-    const logString = asJsonString(runtime, object, message, number, time)
+    const logString = runtime.formatter(runtime, object, message, number, time)
 
     runtime.destination.write(logString)
   }

package/lib/logger/format/asHumanReadable.js

@@ -0,0 +1,42 @@
+const { green, magenta, red, yellow, gray, cyan } = require('../utils/colorize')
+const os = require('os')
+
+exports.asHumanReadable = ({ levels, options }, originObj, message, number, time) => {
+  let logResult = ''
+
+  const logLevelColors = {
+    fatal: magenta,
+    error: red,
+    warn: yellow,
+    info: green,
+    debug: cyan,
+    verbose: gray
+  }
+
+  const currentLabel = levels.labels[number]
+
+  const color = logLevelColors[currentLabel] || yellow
+  // Log level label
+  logResult += color(currentLabel.toUpperCase())
+
+  // date time
+  logResult += ' [' + new Date(time).toISOString() + '] '
+
+  if (options.base.pid && options.base.hostname) {
+    logResult += ` (${options.base.pid} on ${options.base.hostname})`
+  }
+
+  if (message) {
+    logResult += ' ' + color(message)
+  }
+
+  if (Object.keys(originObj).length > 0) {
+    // logResult += gray(' Json:')
+    logResult += os.EOL
+    logResult += gray(JSON.stringify(originObj, null, 2))
+  }
+
+  logResult += os.EOL
+
+  return logResult
+}

package/lib/logger/format/asJson.js

@@ -0,0 +1,25 @@
+const os = require('os')
+
+exports.asJson = (runtime, originObj, message, number, time) => {
+  const data = {
+    level: number,
+    time,
+    ...runtime.fixtures
+  }
+
+  if (message !== undefined) {
+    data[runtime.options.messageKey] = message
+  }
+
+  const notHasOwnProperty = originObj.hasOwnProperty === undefined
+
+  let value
+  for (const key in originObj) {
+    value = originObj[key]
+    if ((notHasOwnProperty || originObj.hasOwnProperty(key)) && value !== undefined) {
+      data[key] = value
+    }
+  }
+
+  return JSON.stringify(data) + os.EOL
+}

package/lib/logger/format/index.js

@@ -0,0 +1,4 @@
+const { asJson } = require('./asJson')
+const { asHumanReadable } = require('./asHumanReadable')
+
+module.exports = { asJson, asHumanReadable }

package/lib/logger/index.js

@@ -6,6 +6,7 @@
 
 const os = require('os')
 const { initBase } = require('./base')
+const { asJson, asHumanReadable } = require('./format')
 const { mappings } = require('./levels')
 const { coreFixtures } = require('./tools')
 
@@ -17,10 +18,16 @@ const defaultOptions = {
   level: 'info',
   messageKey: 'message',
   customLevels: null,
-  base: { pid, hostname },
+  base: {
+    pid,
+    hostname
+  },
   hooks: {
     logMethod: undefined
   },
+  formatter: {
+    messageFormat: false
+  },
   destination: process.stdout
 }
 
@@ -31,7 +38,8 @@ exports.createLogger = (options) => {
   const runtime = {
     options,
     logMethods: {},
-    destination: options.destination
+    destination: options.destination,
+    formatter: process.stdout.isTTY ? asHumanReadable : asJson
   }
 
   if (options.enabled === false) {
@@ -54,9 +62,8 @@ exports.createLogger = (options) => {
 
   const levels = mappings(options.customLevels)
 
-  Object.assign(runtime, {
-    levels
-  })
+  // merge levels in logger runtime
+  Object.assign(runtime, { levels })
 
   initBase(runtime)
 

package/lib/logger/levels.js

@@ -1,14 +1,15 @@
 const { generateLogMethod } = require('./tools')
 
 const levels = {
-  verbose: 10,
-  debug: 20,
-  info: 30,
-  warn: 40,
-  error: 50,
-  fatal: 60
+  verbose: 60,
+  debug: 50,
+  info: 40,
+  warn: 30,
+  error: 20,
+  fatal: 10
 }
 
+// wrap log methods
 const levelMethods = {
   fatal: (runtime, hook) => {
     const logFatal = generateLogMethod(runtime, levels.fatal, hook)
@@ -50,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
   )
@@ -76,4 +78,3 @@ exports.isStandardLevel = (level, useOnlyCustomLevels) => {
     return false
   }
 }
-

package/lib/logger/tools.js

@@ -1,4 +1,3 @@
-const os = require('os')
 const { format } = require('./utils/format')
 
 exports.noop = () => {}
@@ -8,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
@@ -25,30 +28,6 @@ exports.generateLogMethod = (runtime, level, hook) => {
   }
 }
 
-exports.asJsonString = (runtime, originObj, message, number, time) => {
-  const data = {
-    level: number,
-    time,
-    ...runtime.fixtures
-  }
-
-  if (message !== undefined) {
-    data[runtime.options.messageKey] = message
-  }
-
-  const notHasOwnProperty = originObj.hasOwnProperty === undefined
-
-  let value
-  for (const key in originObj) {
-    value = originObj[key]
-    if ((notHasOwnProperty || originObj.hasOwnProperty(key)) && value !== undefined) {
-      data[key] = value
-    }
-  }
-
-  return JSON.stringify(data) + os.EOL
-}
-
 exports.coreFixtures = (object) => {
   return object
 }

package/lib/logger/utils/colorize.js

@@ -0,0 +1,32 @@
+const init = (x, y) => {
+  const regex = new RegExp(`\\x1b\\[${y}m`, 'g')
+  const open = `\x1b[${x}m`; const close = `\x1b[${y}m`
+
+  return function (txt) {
+    return open + (~('' + txt).indexOf(close) ? txt.replace(regex, close + open) : txt) + close
+  }
+}
+
+// modifiers
+exports.bold = init(1, 22)
+exports.dim = init(2, 22)
+exports.hidden = init(8, 28)
+exports.inverse = init(7, 27)
+exports.italic = init(3, 23)
+exports.reset = init(0, 0)
+exports.strikeThrough = init(9, 29)
+exports.underline = init(4, 24)
+
+// colors
+exports.black = init(30, 39)
+exports.blue = init(34, 39)
+exports.cyan = init(36, 39)
+exports.gray = init(90, 39)
+exports.green = init(32, 39)
+exports.grey = init(90, 39)
+exports.magenta = init(35, 39)
+exports.red = init(31, 39)
+exports.white = init(37, 39)
+exports.yellow = init(33, 39)
+
+// todo: bg colors

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.requests.bulkhead.in-flight'
+exports.BULKHEAD_REQUESTS_IN_FLIGHT = 'weave.bulkhead.requests.in-flight'
 
 // OS Metrics
 exports.OS_HOSTNAME = 'os.hostname'
@@ -50,8 +50,10 @@ exports.OS_CPU_LOAD_1 = 'os.cpu-load.1'
 exports.OS_CPU_LOAD_5 = 'os.cpu-load.5'
 exports.OS_CPU_LOAD_15 = 'os.cpu-load.15'
 
-// Metric types
-exports.TYPE_INFO = 'info'
-exports.TYPE_GAUGE = 'gauge'
-exports.TYPE_COUNTER = 'counter'
-exports.TYPE_HISTOGRAM = 'counter'
+// Cache
+exports.CACHE_GET_TOTAL = 'weave.cache.items.get'
+exports.CACHE_SET_TOTAL = 'weave.cache.items.set'
+exports.CACHE_DELETED_TOTAL = 'weave.cache.items.deleted'
+exports.CACHE_FOUND_TOTAL = 'weave.cache.items.found'
+exports.CACHE_CLEANED_TOTAL = 'weave.cache.items.cleaned'
+exports.CACHE_EXPIRED_TOTAL = 'weave.cache.items.expired'

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)
   }
 

package/lib/middlewares/action-hooks/index.js

@@ -1,14 +1,26 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
 
 function callHook (hook, service, context, result) {
   if (typeof hook === 'function') {
     return hook.call(service, context, result)
   } else if (Array.isArray(hook)) {
-    return hook.reduce((promise, fn) => promise.then(res => fn.call(service, context, res)), Promise.resolve(result))
+    return hook.reduce(
+      (promise, fn) => promise.then(res => fn.call(service, context, res)),
+      Promise.resolve(result))
+  }
+}
+
+function callErrorHook (hook, service, context, error) {
+  if (typeof hook === 'function') {
+    return hook.call(service, context, error)
+  } else if (Array.isArray(hook)) {
+    return hook.reduce(
+      (promise, fn) => promise.catch(err => fn.call(service, context, err)),
+      Promise.reject(error))
   }
 }
 
@@ -19,6 +31,7 @@ function sanitizeHooks (hooks, service) {
 
   if (Array.isArray(hooks)) {
     return hooks.map((hook) => {
+      // resolve the method name
       if (typeof hook === 'string') {
         return (service && typeof service[hook] === 'function') ? service[hook] : null
       }
@@ -32,16 +45,34 @@ const makeActionHookMiddleware = function (handler, action) {
   const name = action.shortName
   const hooks = (action.service && action.service.schema) ? action.service.schema.hooks : null
 
-  if (hooks) {
-    const beforeWildcardHook = hooks.before ? sanitizeHooks(hooks.before['*'], action.service) : null
-    const afterWildcardHook = hooks.after ? sanitizeHooks(hooks.after['*'], action.service) : null
-    const errorWildcardHook = hooks.error ? sanitizeHooks(hooks.error['*'], action.service) : null
-    const beforeHook = hooks.before ? sanitizeHooks(hooks.before[name], action.service) : null
-    const afterHook = hooks.after ? sanitizeHooks(hooks.after[name], action.service) : null
-    const errorHook = hooks.error ? sanitizeHooks(hooks.error[name], action.service) : null
+  if (hooks || action.hooks) {
+    // Wildcard hooks
+    const beforeWildcardHook = hooks && hooks.before ? sanitizeHooks(hooks.before['*'], action.service) : null
+    const afterWildcardHook = hooks && hooks.after ? sanitizeHooks(hooks.after['*'], action.service) : null
+    const errorWildcardHook = hooks && hooks.error ? sanitizeHooks(hooks.error['*'], action.service) : null
+
+    // Action name-related hooks
+    const beforeHook = hooks && hooks.before ? sanitizeHooks(hooks.before[name], action.service) : null
+    const afterHook = hooks && hooks.after ? sanitizeHooks(hooks.after[name], action.service) : null
+    const errorHook = hooks && hooks.error ? sanitizeHooks(hooks.error[name], action.service) : null
 
-    if (beforeWildcardHook || afterWildcardHook || errorWildcardHook || beforeHook || afterHook || errorHook) {
-      return function actionHookMiddleware (context) {
+    // Hooks in action definition
+    const actionBeforeHook = action.hooks && action.hooks.before ? sanitizeHooks(action.hooks.before, action.service) : null
+    const actionAfterHook = action.hooks && action.hooks.after ? sanitizeHooks(action.hooks.after, action.service) : null
+    const actionErrorHook = action.hooks && action.hooks.error ? sanitizeHooks(action.hooks.error, action.service) : null
+
+    if (
+      beforeWildcardHook ||
+      afterWildcardHook ||
+      errorWildcardHook ||
+      beforeHook ||
+      afterHook ||
+      errorHook ||
+      actionBeforeHook ||
+      actionAfterHook ||
+      actionErrorHook
+    ) {
+      return function actionHookMiddleware (context, serviceInjections) {
         let promise = Promise.resolve()
 
         // before all hook
@@ -54,8 +85,18 @@ const makeActionHookMiddleware = function (handler, action) {
           promise = promise.then(() => callHook(beforeHook, action.service, context))
         }
 
+        // Before hook
+        if (actionBeforeHook) {
+          promise = promise.then(() => callHook(actionBeforeHook, action.service, context))
+        }
+
         // Call action handler
-        promise = promise.then(() => handler(context))
+        promise = promise.then(() => handler(context, serviceInjections))
+
+        // After hook in action definition
+        if (actionAfterHook) {
+          promise = promise.then(result => callHook(actionAfterHook, action.service, context, result))
+        }
 
         // After hook
         if (afterHook) {
@@ -67,13 +108,20 @@ const makeActionHookMiddleware = function (handler, action) {
           promise = promise.then(result => callHook(afterWildcardHook, action.service, context, result))
         }
 
+        // Error hooks
+        // Error hook in action definition
+        if (actionErrorHook) {
+          promise = promise.catch(error => callErrorHook(actionErrorHook, action.service, context, error))
+        }
+
         // Error hook
         if (errorHook) {
-          promise = promise.catch(error => callHook(errorHook, action.service, context, error))
+          promise = promise.catch(error => callErrorHook(errorHook, action.service, context, error))
         }
+
         // Error wildcard hook
         if (errorWildcardHook) {
-          promise = promise.catch(error => callHook(errorWildcardHook, action.service, context, error))
+          promise = promise.catch(error => callErrorHook(errorWildcardHook, action.service, context, error))
         }
 
         return promise

package/lib/middlewares/bulkhead/index.js

@@ -1,9 +1,9 @@
 /*
  * Author: Kevin Ries (kevin@fachw3rk.de)
  * -----
- * Copyright 2020 Fachwerk
+ * Copyright 2021 Fachwerk
  */
-
+const { Constants } = require('../../metrics')
 const { WeaveQueueSizeExceededError } = require('../../errors')
 
 /**
@@ -44,11 +44,11 @@ module.exports = (runtime) => {
           })
       }
 
-      return function bulkheadMiddlware (context) {
+      return function bulkheadMiddlware (context, serviceInjections) {
         // Execute action immediately
         if (currentlyInFlight < bulkheadOptions.concurrentCalls) {
           currentlyInFlight++
-          return handler(context)
+          return handler(context, serviceInjections)
             .then(result => {
               currentlyInFlight--
               callNext()
@@ -81,6 +81,7 @@ module.exports = (runtime) => {
     created () {
       if (runtime.options.metrics.enabled) {
         // todo: add bulkhead metrics
+        runtime.metrics.register({ type: 'gauge', name: Constants.BULKHEAD_REQUESTS_IN_FLIGHT, description: 'Number of in flight requests.' })
       }
     },
     localAction: wrapBulkheadMiddleware

package/lib/middlewares/cache/index.js

@@ -0,0 +1,80 @@
+const { isObject } = require('@weave-js/utils')
+
+module.exports = (runtime) => {
+  return {
+    localAction: (handler, action) => {
+      const cacheOptions = Object.assign(
+        isObject(action.cache) ? action.cache : { enabled: !!action.cache },
+        runtime.options.cache
+      )
+      if (cacheOptions.enabled) {
+        return function cacheMiddleware (context, serviceInjections) {
+          const cache = runtime.cache
+          const cacheHashKey = cache.getCachingHash(action.name, context.data, context.meta, action.cache.keys)
+          context.isCachedResult = false
+
+          if (context.meta.$noCache === true) {
+            return handler(context, serviceInjections)
+          }
+
+          if (cache.isConnected === false) {
+            cache.log('Cache adapter is not connected yet. Call handler...')
+            return handler(context, serviceInjections)
+          }
+
+          if (cacheOptions.lock.enabled) {
+            let cacheProm
+            if (cacheOptions.lock.staleTime && cache.getWithTTl) {
+
+            } else {
+              cacheProm = runtime.cache.get(cacheHashKey)
+            }
+
+            return cacheProm.then((cachedResult) => {
+              if (cachedResult !== null) {
+                // Found a cached value. Skip calling handler and return our value
+                context.isCachedResult = true
+                return cachedResult
+              }
+
+              return cache.lock(cacheHashKey).then((release) => {
+                return cache.get(cacheHashKey).then(cachedResult => {
+                  if (cachedResult !== null) {
+                    // Found a cached value. Skip calling handler and return our value
+                    context.isCachedResult = true
+                    return release().then(() => {
+                      return cachedResult
+                    })
+                  }
+
+                  return handler(context).then((result) => {
+                    // Cache the value
+                    cache.set(cacheHashKey, result, action.cache.ttl).then(() => {
+                      // release the lock
+                      release()
+                    })
+                    return result
+                  })
+                })
+              })
+            })
+          }
+
+          // Not using cache lock
+          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
+    }
+  }
+}