@weave-js/core 0.10.0 → 0.12.0

package/lib/runtime/initServiceManager.js

@@ -0,0 +1,145 @@
+const { createServiceFromSchema } = require('../registry/service/service.js');
+const { WeaveError } = require('../errors');
+
+exports.initServiceManager = (runtime) => {
+  const { options, log, eventBus, transport, state, registry, handleError } = runtime;
+
+  // Internal service list
+  const serviceList = [];
+
+  const serviceChanged = (isLocalService = false) => {
+    // Send local notification.
+    eventBus.broadcastLocal('$services.changed', { isLocalService });
+
+    // If the service is a local service - send current node information to other nodes
+    if (state.isStarted && isLocalService && transport) {
+      transport.sendNodeInfo();
+    }
+  };
+
+  // const destroyService = (service) => Promise.resolve()
+  //   .then(() => service.stop())
+  //   .then(() => log.info(`Service "${service.name}" was stopped.`))
+  //   .then(() => {
+  //     registry.deregisterService(service.name, service.version)
+  //     log.info(`Service "${service.name}" was deregistered.`)
+  //     // Remove service from service store.
+  //     serviceList.splice(serviceList.indexOf(service), 1)
+  //     // Fire services changed event
+  //     serviceChanged(true)
+  //     return Promise.resolve()
+  //   })
+  //   .catch(error => log.error(error, `Unable to stop service "${service.name}"`))
+
+  // `onServiceFileChanged` only triggered by the file watcher
+  // const onServiceFileChanged = async (service) => {
+  //   const filename = service.filename;
+
+  //   // Clear the require cache
+  //   Object.keys(require.cache).forEach(key => {
+  //     if (key === filename) {
+  //       delete require.cache[key];
+  //     }
+  //   });
+
+  //   // Service has changed - 1. destroy the service, then reload it
+  //   await destroyService(service);
+  //   await runtime.broker.loadService(filename);
+  // };
+
+  Object.defineProperty(runtime, 'services', {
+    value: {
+      serviceList,
+      serviceChanged,
+      createService (schema) {
+        try {
+          const newService = createServiceFromSchema(runtime, schema);
+
+          // if the broker is already started, we need to start the service.
+          if (runtime.state.isStarted) {
+            newService.start().catch(error => log.error(`Unable to start service ${newService.name}: ${error}`));
+          }
+
+          return newService;
+        } catch (error) {
+          log.error(error);
+          handleError(error);
+        }
+      },
+      /**
+       * Wait for services before continuing startup.
+       * @param {Array.<string>} serviceNames Names of the services
+       * @param {Number} timeout Time in Miliseconds before the broker stops.
+       * @param {Number} interval Time in Miliseconds to check for services.
+       * @returns {Promise} Promise
+      */
+      waitForServices (serviceNames, timeout, interval = 500) {
+        if (!Array.isArray(serviceNames)) {
+          serviceNames = [serviceNames];
+        }
+
+        const startTimestamp = Date.now();
+        return new Promise((resolve, reject) => {
+          // todo: add timout for service waiter
+          log.warn(`Waiting for services '${serviceNames.join(',')}'`);
+
+          const serviceCheck = () => {
+            const count = serviceNames.filter(serviceName => registry.hasService(serviceName));
+
+            log.warn(`${count.length} services of ${serviceNames.length} available. Waiting...`);
+
+            if (count.length === serviceNames.length) {
+              return resolve();
+            }
+
+            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 }));
+            }
+
+            options.waitForServiceInterval = setTimeout(serviceCheck, interval);
+          };
+
+          serviceCheck();
+        });
+      },
+      /**
+       * Destroy a service
+       * @param {Service} service Service
+       * @returns {Promise<any>} result
+       */
+      async destroyService (service) {
+        try {
+          // Stop the service
+          await service.stop();
+          log.info(`Service "${service.name}" was stopped.`);
+
+          // Deregister the service and remove it from the service list
+          registry.deregisterService(service.name, service.version);
+          serviceList.splice(serviceList.indexOf(service), 1);
+          log.info(`Service "${service.name}" was deregistered.`);
+          serviceChanged(true);
+        } catch (error) {
+          log.error(error, `Unable to stop service "${service.name}"`);
+        }
+      }
+      /**
+       * Watch a Service object for changes.
+       * @param {Service} service Service object
+       * @return {void}
+      */
+      // watchService: (service) => {
+      //   if (service.filename && onServiceFileChanged) {
+      //     // Create debounced service changed reference
+      //     const debouncedOnServiceChange = debounce(onServiceFileChanged, 500);
+
+      //     // Watch file changes
+      //     const watcher = fs.watch(service.filename, (eventType, filename) => {
+      //       log.info(`The Service ${service.name} has been changed. (${eventType}, ${filename})`);
+      //       watcher.close();
+      //       debouncedOnServiceChange(service);
+      //     });
+      //   }
+      // }
+    }
+  });
+};

package/lib/runtime/{init-tracing.js → initTracing.js}

@@ -1,64 +1,65 @@
-const { resolveCollector } = require('../tracing/collectors')
-const { createSpan } = require('../tracing/span')
+const { resolveCollector } = require('../tracing/collectors');
+const { createSpan } = require('../tracing/span');
 
 exports.initTracer = (runtime) => {
-  const options = runtime.options.tracing
-  const log = runtime.createLogger('TRACER')
-  let collectors = []
-  let samplingCounter = 0
+  const options = runtime.options.tracing;
+  const log = runtime.createLogger('TRACER');
+  let collectors = [];
+  let samplingCounter = 0;
 
   Object.defineProperty(runtime, 'tracer', {
     value: {
+      runtime,
+      options,
       log,
       async stop () {
         if (collectors.length > 0) {
-          return await Promise.all(collectors.map(collector => collector.stop()))
+          return await Promise.all(collectors.map(collector => collector.stop()));
         }
       },
       shouldSample (span) {
         // check span priority
         if (options.samplingRate === 0) {
-          return false
+          return false;
         }
 
         if (options.samplingRate === 1) {
-          return true
+          return true;
         }
 
         if (++samplingCounter * this.options.samplingRate >= 1) {
-          samplingCounter = 0
-          return true
+          samplingCounter = 0;
+          return true;
         }
 
-        return false
+        return false;
       },
       invokeCollectorMethod (method, args) {
-        collectors.map(collector => collector[method].apply(collector, args))
+        collectors.map(collector => collector[method].apply(collector, args));
       },
       startSpan (name, options) {
         const span = createSpan(this, name, Object.assign({
           type: 'custom'
-        }, options))
+        }, options));
 
-        span.start()
+        span.start();
 
-        return span
+        return span;
       }
     }
-  })
+  });
 
   // Init collectors
   if (options.enabled) {
-    log.info('Tracer initialized.')
+    log.info('Tracer initialized.');
 
     if (options.collectors) {
       collectors = options.collectors
         .map(entry => {
-          const initCollector = resolveCollector(runtime, entry, this)
-          // collector.init(this)
-          initCollector.init(runtime)
-          return initCollector
-        })
+          const initCollector = resolveCollector(runtime, entry, this);
+          initCollector.init(runtime);
+          return initCollector;
+        });
     }
   }
-}
+};

package/lib/runtime/{init-transport.js → initTransport.js}

@@ -2,16 +2,16 @@
  * @typedef {import('../types').TransportAdapter} TransportAdapter
 **/
 
-const { createTransport } = require('../transport/createTransport')
-const TransportAdapters = require('../transport/adapters')
+const { createTransport } = require('../transport/createTransport');
+const TransportAdapters = require('../transport/adapters');
 
 exports.initTransport = (runtime) => {
   if (runtime.options.transport.adapter) {
     /** @type {TransportAdapter} */
-    const adapter = TransportAdapters.resolve(runtime, runtime.options.transport)
+    const adapter = TransportAdapters.resolve(runtime, runtime.options.transport);
 
     Object.defineProperty(runtime, 'transport', {
       value: createTransport(runtime, adapter)
-    })
+    });
   }
-}
+};

package/lib/runtime/{init-uuid-factory.js → initUuidFactory.js}

@@ -2,7 +2,7 @@
  * @typedef {import('../types.js').Runtime} Runtime
 */
 
-const { isFunction, uuid } = require('@weave-js/utils')
+const { isFunction, uuid } = require('@weave-js/utils');
 
 /**
  * Init uuid Generator and attach it to our runtime object.
@@ -10,7 +10,7 @@ const { isFunction, uuid } = require('@weave-js/utils')
  * @returns {void}
 */
 exports.initUUIDFactory = (runtime) => {
-  const { options } = runtime
+  const { options } = runtime;
 
-  runtime.generateUUID = (options.uuidFactory && isFunction(options.uuidFactory)) ? () => options.uuidFactory(runtime) : uuid
-}
+  runtime.generateUUID = (options.uuidFactory && isFunction(options.uuidFactory)) ? () => options.uuidFactory(runtime) : uuid;
+};

package/lib/runtime/{init-validator.js → initValidator.js}

@@ -1,5 +1,5 @@
 /*
- * Author: Kevin Ries (kevin@fachw3rk.de)
+ * Author: Kevin Ries (kevin.ries@fachwerk.io)
  * -----
  * Copyright 2021 Fachwerk
 */
@@ -8,7 +8,7 @@
  * @typedef {import('../types.js').Runtime} Runtime
 */
 
-const ObjectValidator = require('@weave-js/validator')
+const ObjectValidator = require('@weave-js/validator');
 
 /**
  * Init validator and attach it to our runtime object.
@@ -16,11 +16,11 @@ const ObjectValidator = require('@weave-js/validator')
  * @returns {void}
 */
 exports.initValidator = (runtime) => {
-  const validator = ObjectValidator()
+  const validator = ObjectValidator();
 
   Object.defineProperty(runtime, 'validator', {
     value: {
       ...validator
     }
-  })
-}
+  });
+};

package/lib/tracing/collectors/base.js

@@ -1,60 +1,52 @@
-const { isObject } = require('@weave-js/utils')
-const { WeaveError } = require('../../errors')
+const { isObject, pick } = require('@weave-js/utils');
 
-exports.createBaseTracingCollector = (options) => {
-  const baseTracingCollector = Object.create(null)
+exports.createBaseTracingCollector = (runtime) => {
+  const baseTracingCollector = Object.create(null);
 
-  baseTracingCollector.options = options
+  baseTracingCollector.options = runtime.tracer.options;
 
-  baseTracingCollector.init = (runtime, tracer) => {
-    baseTracingCollector.runtime = runtime
-    baseTracingCollector.tracer = tracer
-  }
+  baseTracingCollector.init = (runtime) => {
+    baseTracingCollector.runtime = runtime;
+    baseTracingCollector.tracer = runtime.tracer;
+  };
 
   baseTracingCollector.startedSpan = () => {
-    throw new WeaveError('not implemented.')
-  }
+    // throw new WeaveError('not implemented.')
+  };
 
   baseTracingCollector.finishedSpan = () => {
-    throw new WeaveError('not implemented.')
-  }
+    // throw new WeaveError('not implemented.')
+  };
 
   baseTracingCollector.stop = () => {
-    throw new WeaveError('not implemented.')
-  }
+    // throw new WeaveError('not implemented.')
+  };
 
   baseTracingCollector.flattenTags = (obj, convertToString = false, path = '') => {
     if (!obj) {
-      return null
+      return null;
     }
 
     return Object.keys(obj).reduce((res, k) => {
-      const o = obj[k]
-      const pp = (path ? path + '.' : '') + k
+      const o = obj[k];
+      const pp = (path ? path + '.' : '') + k;
 
       if (isObject(o)) {
-        Object.assign(res, baseTracingCollector.flattenTags(o, convertToString, pp))
+        Object.assign(res, baseTracingCollector.flattenTags(o, convertToString, pp));
       } else if (o !== undefined) {
-        res[pp] = convertToString ? String(o) : o
+        res[pp] = convertToString ? String(o) : o;
       }
 
-      return res
-    }, {})
-  }
+      return res;
+    }, {});
+  };
 
-  baseTracingCollector.getErrorFields = (error, ...fields) => {
-    if (!error) {
-      return null
+  baseTracingCollector.getErrorFields = (err, fields) => {
+    if (!err) {
+      return null;
     }
+    return pick(err, fields);
+  };
 
-    const picked = {}
-
-    for (const field of fields) {
-      picked[field] = error[field]
-    }
-
-    return picked
-  }
-
-  return baseTracingCollector
-}
+  return baseTracingCollector;
+};

package/lib/tracing/collectors/event.js

@@ -1,4 +1,4 @@
-const { createBaseTracingCollector } = require('./base')
+const { createBaseTracingCollector } = require('./base');
 
 const mergeDefaultOptions = (options) => {
   return Object.assign({
@@ -7,80 +7,80 @@ const mergeDefaultOptions = (options) => {
     sendStartSpan: false,
     sendFinishedSpan: true,
     broadcast: false
-  }, options)
-}
+  }, options);
+};
 
 module.exports = (options) => (runtime, tracer) => {
-  options = mergeDefaultOptions(options)
+  options = mergeDefaultOptions(options);
 
-  const exporter = createBaseTracingCollector(options)
+  const exporter = createBaseTracingCollector(runtime);
 
-  exporter.init(runtime, tracer)
+  exporter.init(runtime, tracer);
 
-  const queue = []
+  const queue = [];
 
-  let timer
+  let timer;
 
   const generateTracingData = () => {
     return Array
       .from(queue)
       .map(span => {
-        const newSpan = Object.assign({}, span)
+        const newSpan = Object.assign({}, span);
 
         if (newSpan.error) {
-          newSpan.error = exporter.getErrorFields(newSpan.error)
+          newSpan.error = exporter.getErrorFields(newSpan.error, exporter.options.errors.fields);
         }
 
-        return newSpan
-      })
-  }
+        return newSpan;
+      });
+  };
 
   const flushQueue = () => {
-    if (queue.length === 0) return
+    if (queue.length === 0) return;
 
-    const data = generateTracingData()
-    queue.length = 0
+    const data = generateTracingData();
+    queue.length = 0;
 
     if (options.broadcast) {
-      exporter.runtime.eventBus.broadcast(options.eventName, data)
+      exporter.runtime.eventBus.broadcast(options.eventName, data);
     } else {
-      exporter.runtime.eventBus.emit(options.eventName, data)
+      exporter.runtime.eventBus.emit(options.eventName, data);
     }
-  }
+  };
 
   if (options.interval > 0) {
-    timer = setInterval(() => flushQueue(), options.interval)
-    timer.unref()
+    timer = setInterval(() => flushQueue(), options.interval);
+    timer.unref();
   }
 
   exporter.init = (runtime) => {
 
-  }
+  };
 
   exporter.startedSpan = (span) => {
     if (options.sendStartSpan) {
-      queue.push(span)
+      queue.push(span);
       if (!timer) {
-        flushQueue()
+        flushQueue();
       }
     }
-  }
+  };
 
   exporter.finishedSpan = (span) => {
     if (options.sendFinishedSpan) {
-      queue.push(span)
+      queue.push(span);
       if (!timer) {
-        flushQueue()
+        flushQueue();
       }
     }
-  }
+  };
 
   exporter.stop = async () => {
     if (timer) {
-      clearInterval(timer)
-      timer = null
+      clearInterval(timer);
+      timer = null;
     }
-  }
+  };
 
-  return exporter
-}
+  return exporter;
+};

package/lib/tracing/collectors/index.js

@@ -1,39 +1,39 @@
-const { isFunction } = require('@weave-js/utils')
+const { isFunction } = require('@weave-js/utils');
 
 const collectors = {
   // Console: require('./console'),
   Event: require('./event'),
   BaseCollector: require('./base')
-}
+};
 
 const getByName = name => {
-  const n = Object.keys(collectors).find(collectorName => collectorName.toLowerCase() === name.toLowerCase())
-  return collectors[n]
-}
+  const n = Object.keys(collectors).find(collectorName => collectorName.toLowerCase() === name.toLowerCase());
+  return collectors[n];
+};
 
-exports.resolveCollector = (runtime, collector, tracer) => {
-  let CollectorClass
+exports.resolveCollector = (runtime, collector) => {
+  let CollectorClass;
   if (typeof collector === 'string') {
-    CollectorClass = getByName(collector)
+    CollectorClass = getByName(collector);
   }
 
   if (isFunction(collector)) {
-    return collector(runtime, tracer)
+    return collector(runtime);
   }
 
   if (typeof collector === 'object') {
-    return collector
+    return collector;
   }
 
   if (!CollectorClass) {
-    runtime.handleError(new Error('Tracer not found'))
+    runtime.handleError(new Error('Tracer not found'));
   }
 
-  return new CollectorClass(collector)
-}
+  return new CollectorClass(collector);
+};
 
-exports.Base = collectors.BaseCollector
+exports.Base = collectors.BaseCollector;
 
-exports.Console = collectors.Console
+exports.Console = collectors.Console;
 
-exports.Event = collectors.Event
+exports.Event = collectors.Event;

package/lib/tracing/span.js

@@ -1,61 +1,63 @@
-const hrTime = require('./time')
+const hrTime = require('./time');
 
 exports.createSpan = (tracer, name, options) => {
   const span = Object.assign({}, {
     name,
-    id: options.id || tracer.broker.getUUID(),
-    traceId: options.traceId || tracer.broker.getUUID(),
+    id: options.id || tracer.runtime.generateUUID(),
+    traceId: options.traceId || tracer.runtime.generateUUID(),
     parentId: options.parentId,
     type: options.type,
     sampled: options.sampled || tracer.shouldSample(),
     service: options.service,
     tags: {}
-  })
-
-  span.service = {
-    name: options.service.name,
-    version: options.service.version,
-    fullyQualifiedName: options.service.fullyQualifiedName
+  });
+
+  if (options.service) {
+    span.service = {
+      name: options.service.name,
+      version: options.service.version,
+      fullyQualifiedName: options.service.fullyQualifiedName
+    };
   }
 
   span.addTags = (tags) => {
-    Object.assign(span.tags, tags)
-    return span
-  }
+    Object.assign(span.tags, tags);
+    return span;
+  };
 
   span.start = (time) => {
-    span.startTime = time || hrTime()
-    tracer.invokeCollectorMethod('startedSpan', [span])
-    return span
-  }
+    span.startTime = time || hrTime();
+    tracer.invokeCollectorMethod('startedSpan', [span]);
+    return span;
+  };
 
   span.startChildSpan = (name, options) => {
     const parentOptions = {
       parentId: options.parentId,
       sampled: options.sampled
-    }
-    return tracer.startSpan(name, Object.assign(parentOptions, options))
-  }
+    };
+    return tracer.startSpan(name, Object.assign(parentOptions, options));
+  };
 
   span.finish = (time) => {
-    span.finishTime = time || hrTime()
-    span.duration = span.finishTime - span.startTime
-    tracer.log.debug('Span finished')
-    tracer.invokeCollectorMethod('finishedSpan', [span])
+    span.finishTime = time || hrTime();
+    span.duration = span.finishTime - span.startTime;
+    tracer.log.debug('Span finished');
+    tracer.invokeCollectorMethod('finishedSpan', [span]);
 
-    return span
-  }
+    return span;
+  };
 
-  span.isActive = () => span.finishTime !== null
+  span.isActive = () => span.finishTime !== null;
 
   span.setError = (error) => {
-    span.error = error
-    return span
-  }
+    span.error = error;
+    return span;
+  };
 
   if (options.tags) {
-    span.addTags(options.tags)
+    span.addTags(options.tags);
   }
 
-  return span
-}
+  return span;
+};