@weave-js/core 0.15.1 → 0.15.3

package/lib/broker/context.js

@@ -89,17 +89,7 @@ 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);
-
       let span;
-
       if (this.span) {
         span = this.span.startChildSpan(name, options);
       } else {

package/lib/broker/defaultOptions.js

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

package/lib/broker/public.d.ts

@@ -0,0 +1,120 @@
+export type BulkheadOptions = {
+  enabled?: boolean;
+  concurrentCalls: number;
+  maxQueueSize: number;
+}
+
+export type CacheLockOptions = {
+  enabled: boolean;
+}
+
+export type CacheOptions = {
+  enabled?: boolean;
+  adapter: string | object;
+  ttl: number;
+  lock?: CacheLockOptions;
+}
+
+export type ContextTracking = {
+  enabled: boolean;
+  shutdownTimeout: number;
+}
+
+export type StrictModeOptions = 'remove' | 'error'
+
+export type ValidatorOptions = {
+  strict: boolean;
+  strictMode: StrictModeOptions;
+}
+
+export type BrokerOptions = {
+  nodeId?: string;
+  namespace?: string;
+  bulkhead?: BulkheadOptions;
+  cache?: CacheOptions;
+  contextTracking?: ContextTracking;
+  circuitBreaker?: CircuitBreakerOptions;
+  transport?: TransportOptions;
+  errorHandler?: Function;
+  loadInternalMiddlewares?: boolean;
+  metrics?: MetricsOptions;
+  middlewares?: Array<Middleware>;
+  logger?: LoggerOptions;
+  tracing?: TracingOptions;
+  registry?: RegistryOptions;
+  retryPolicy?: RetryPolicyOptions;
+  validatorOptions?: ValidatorOptions;
+  validateActionParams?: boolean;
+  waitForServiceInterval?: number;
+  beforeRegisterMiddlewares?: Function;
+  uuidFactory?: Function;
+  started?: Function;
+  stopped?: Function;
+}
+
+export type CircuitBreakerOptions = {
+  enabled: boolean;
+  halfOpenTimeout: number;
+  maxFailures: number;
+  windowTime: number;
+}
+
+export type RetryPolicyOptions = {
+  enabled: boolean;
+  delay: number;
+  retries: number;
+}
+
+export type TransportOptions = {
+  adapter?: string | object;
+  maxQueueSize: number;
+  heartbeatInterval: number;
+  heartbeatTimeout: number;
+  localNodeUpdateInterval: number;
+  offlineNodeCheckInterval: number;
+  maxOfflineTime: number;
+  maxChunkSize: number;
+  streams: TransportStreamOptions;
+}
+
+export type TransportStreamOptions = {
+  handleBackpressure: boolean;
+}
+export type Context = {
+  id?: string;
+}
+
+export type Broker = {
+  nodeId: string;
+  namespace?: string;
+  runtime: Runtime;
+  bus: EventEmitter;
+  version: string;
+  options: BrokerOptions;
+  metrics?: MetricRegistry;
+  validator: Validator;
+  start(): Promise<any>;
+  stop(): Promise<any>;
+  createService(schema: ServiceSchema): Service;
+  loadService(path: string): void;
+  loadServices(folder: string, fileMask?: string): void;
+  contextFactory: ContextFactory;
+  log: Logger;
+  createLogger(name: string, params?: any): Logger;
+  cache?: Cache;
+  getUUID(): string;
+  registry: Registry;
+  tracer?: Tracer;
+  transport?: Transport;
+  getNextActionEndpoint(actionName: string): Endpoint | Error;
+  call(actionName: string, params?: any, opts?: CallOptions): Promise<any>;
+  multiCall(calls: Array<CallAction>): Promise<Array<any>>;
+  emit(eventName: string, payload?: any, opts?: EmitOptions): Promise<any>;
+  broadcast(eventName: string, payload?: any, opts?: BroadcastOptions): Promise<any>;
+  broadcastLocal(eventName: string, payload?: any, opts?: BroadcastOptions): Promise<any>;
+  waitForServices(serviceNames: Array<string> | string): Promise<any>;
+  ping(nodeID: string, timeout?: number): Promise<PingResult>;
+  handleError(err: Error): void;
+  fatalError(err: Error): void;
+}
+

package/lib/middlewares/tracing/index.js

@@ -4,56 +4,42 @@
  * Copyright 2021 Fachwerk
  */
 
-const { isPlainObject, isFunction, isObject, dotGet } = require('@weave-js/utils');
-const { buildActionTags, buildEventTags } = require('./tags');
+const { buildActionTags, buildEventTags, addResponseTags } = require('./tags');
+
+function getSpanName (context, actionTracingOptions) {
+  let spanName = `action "${context.action.name}"`;
+
+  try {
+    if (actionTracingOptions.spanName) {
+      switch (typeof actionTracingOptions.spanName) {
+      case 'string':
+        spanName = actionTracingOptions.spanName;
+        break;
+      case 'function':
+        spanName = actionTracingOptions.spanName.call(context.service, context);
+        break;
+      }
+    }
+  } catch (error) {
+    context.service.log.warn({
+      requestId: context.requestId,
+      spanId: context.span.id
+    }, `Error while getting span name: ${error.message}`);
+  }
+
+  return spanName;
+}
 
 const wrapTracingLocalActionMiddleware = function (handler, action) {
   const broker = this;
-  const tracingOptions = broker.options.tracing || {};
+  const globalTracingOptions = broker.options.tracing || {};
   const actionTracingOptions = action.tracing || {};
 
-  if (tracingOptions.enabled) {
-    return function metricsLocalMiddleware (context, serviceInjections) {
-      const tags = buildActionTags(context, tracingOptions);
-
-      if (tracingOptions.actions.data) {
-        tags.data = context.data !== null && isPlainObject(context.data) ? Object.assign({}, context.data) : context.data;
-      }
-
-      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 (globalTracingOptions.enabled) {
+    return function tracingLocalMiddleware (context, serviceInjections) {
+      const tags = buildActionTags(context, globalTracingOptions, actionTracingOptions);
 
-      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 spanName = getSpanName(context, actionTracingOptions);
 
       const span = context.startSpan(spanName, {
         id: context.id,
@@ -73,9 +59,7 @@ const wrapTracingLocalActionMiddleware = function (handler, action) {
             isCachedResult: context.isCachedResult
           };
 
-          if (tracingOptions.actions.response) {
-            tags.response = result !== null && isPlainObject(result) ? Object.assign({}, result) : result;
-          }
+          addResponseTags(context, tags, result, globalTracingOptions.actions, actionTracingOptions);
 
           span.addTags(tags);
           context.finishSpan(span);
@@ -95,10 +79,11 @@ const wrapTracingLocalEventMiddleware = function (handler, event) {
   const broker = this;
   const service = event.service;
   const tracingOptions = broker.options.tracing || {};
+  const eventTracingOptions = event.tracing || {};
 
   if (tracingOptions.enabled) {
     return function metricsLocalMiddleware (context) {
-      const tags = buildEventTags(context);
+      const tags = buildEventTags(context, tracingOptions, eventTracingOptions);
 
       const span = context.startSpan(`event "${context.eventName}"`, {
         id: context.id,

package/lib/middlewares/tracing/tags.js

@@ -3,14 +3,68 @@
  * @typedef {import("../../types.js").TracingOptions} TracingOptions
 */
 
+const { isFunction, dotGet, isObject } = require('@weave-js/utils');
+
+function addPreHandleTagsFromDefinition (context, tags, globalTracingActionOptions, actionTracingOptions) {
+  const globalActionTags = globalTracingActionOptions.tags;
+  let actionTags;
+  if (isFunction(actionTracingOptions.tags)) {
+    actionTags = actionTracingOptions.tags;
+  } else if (!actionTracingOptions.tags && isFunction(globalActionTags)) {
+    actionTags = globalActionTags;
+  } else {
+    actionTags = { data: globalTracingActionOptions.data, ...globalActionTags, ...actionTracingOptions.tags };
+  }
+
+  if (isObject(actionTags)) {
+    if (actionTags.data === true) {
+      tags.data = context.data !== null && isObject(context.data) ? Object.assign({}, context.data) : context.data;
+    } else if (Array.isArray(actionTags.data)) {
+      tags.data = actionTags.data.reduce((acc, current) => {
+        try {
+          acc[current] = dotGet(context.data, current);
+        } catch (error) {
+          const spanId = context.span ? context.span.id : undefined;
+
+          context.service.log.warn({
+            requestId: context.requestId,
+            spanId
+          }, `Unable to get value for tag "${current}" from data`);
+          acc[current] = undefined;
+        }
+        return acc;
+      }, {});
+    }
+
+    if (actionTags.meta === true) {
+      tags.meta = context.meta !== null && isObject(context.meta) ? Object.assign({}, context.meta) : context.meta;
+    } else if (Array.isArray(actionTags.meta)) {
+      tags.meta = actionTags.meta.reduce((acc, current) => {
+        try {
+          acc[current] = dotGet(context.meta, current);
+        } catch (error) {
+          const spanId = context.span ? context.span.id : undefined;
+
+          context.service.log.warn({
+            requestId: context.requestId,
+            spanId
+          }, `Unable to get value for tag "${current}" from metadata`);
+          acc[current] = undefined;
+        }
+        return acc;
+      }, {});
+    }
+  } else if (isFunction(actionTags)) {
+    tags.data = actionTags.call(context.service, context);
+  }
+}
+
 /**
  * Build span tags object
  * @param {Context} context - Context
- * @param {TracingOptions} brokerTracingOptions - Tracing options
- * @param {TracingOptions} actionTracingOptions - Tracing options
  * @returns {object} Tags
 */
-module.exports.buildActionTags = (context, brokerTracingOptions, actionTracingOptions) => {
+module.exports.buildActionTags = (context, globalTracingOptions, actionTracingOptions) => {
   const tags = {
     requestLevel: context.level,
     action: context.action ? { name: context.action.name, shortName: context.action.shortName } : null,
@@ -19,17 +73,26 @@ module.exports.buildActionTags = (context, brokerTracingOptions, actionTracingOp
     requestId: context.requestId
   };
 
+  try {
+    addPreHandleTagsFromDefinition(context, tags, globalTracingOptions.actions, actionTracingOptions);
+  } catch (error) {
+    const spanId = context.span ? context.span.id : undefined;
+
+    context.service.log.warn({
+      requestId: context.requestId,
+      spanId
+    }, `Error while building action tags: ${error.message}`);
+  }
+
   return tags;
 };
 
 /**
  * Build span tags object
  * @param {Context} context - Context
- * @param {TracingOptions} brokerTracingOptions - Tracing options
- * @param {TracingOptions} actionTracingOptions - Tracing options
  * @returns {object} Tags
 */
-module.exports.buildEventTags = (context, brokerTracingOptions, actionTracingOptions) => {
+module.exports.buildEventTags = (context, globalTracingOptions, eventTracingOptions) => {
   const tags = {
     requestLevel: context.level,
     event: context.eventName,
@@ -39,5 +102,40 @@ module.exports.buildEventTags = (context, brokerTracingOptions, actionTracingOpt
     requestId: context.requestId
   };
 
+  try {
+    addPreHandleTagsFromDefinition(context, tags, globalTracingOptions.events, eventTracingOptions);
+  } catch (error) {
+    const spanId = context.span ? context.span.id : undefined;
+
+    context.service.log.warn({
+      requestId: context.requestId,
+      spanId
+    }, `Error while building event tags: ${error.message}`);
+  }
+
   return tags;
 };
+
+module.exports.addResponseTags = (context, tags, result, globalTracingActionOptions, actionTracingOptions) => {
+  const globalActionTags = globalTracingActionOptions.tags;
+  const actionTags = { response: globalTracingActionOptions.response, ...globalActionTags, ...actionTracingOptions.tags };
+
+  if (actionTags.response === true) {
+    tags.response = result !== null && isObject(result) ? Object.assign({}, result) : result;
+  } else if (Array.isArray(actionTags.response)) {
+    tags.response = actionTags.response.reduce((acc, current) => {
+      try {
+        acc[current] = dotGet(result, current);
+      } catch (error) {
+        const spanId = context.span ? context.span.id : undefined;
+
+        context.service.log.warn({
+          requestId: context.requestId,
+          spanId
+        }, `Unable to get response tag "${current}" from result`);
+        acc[current] = undefined;
+      }
+      return acc;
+    }, {});
+  }
+};

package/lib/runtime/initContextFactory.js

@@ -55,10 +55,14 @@ exports.initContextFactory = (runtime) => {
         }
 
         if (opts.parentContext != null) {
-          context.parentId = opts.parentContext.id;
-          context.level = opts.parentContext.level + 1;
           context.tracing = opts.parentContext.tracing;
-          context.span = opts.parentContext.span;
+          context.level = opts.parentContext.level + 1;
+          if (opts.parentContext.span) {
+            // context.span = opts.parentContext.span;
+            context.parentId = opts.parentContext.span.id;
+          } else {
+            context.parentId = opts.parentContext.id;
+          }
         }
 
         if (opts.stream) {

package/lib/runtime/initTracing.js

@@ -1,5 +1,5 @@
 const { resolveCollector } = require('../tracing/collectors');
-const { createSpan } = require('../tracing/span');
+const { Span } = require('../tracing/span');
 
 exports.initTracer = (runtime) => {
   const options = runtime.options.tracing;
@@ -37,16 +37,30 @@ exports.initTracer = (runtime) => {
       invokeCollectorMethod (method, args) {
         collectors.map(collector => collector[method].apply(collector, args));
       },
-      startSpan (name, options) {
+      startSpan (name, spanOptions) {
         const parentOptions = {};
-        if (options.parentSpan) {
-          parentOptions.traceId = options.parentSpan.traceId;
-          parentOptions.parentId = options.parentSpan.id;
-          parentOptions.sampled = options.parentSpan.sampled;
+
+        if (spanOptions.parentSpan) {
+          parentOptions.traceId = spanOptions.parentSpan.traceId;
+          parentOptions.parentId = spanOptions.parentSpan.id;
+          parentOptions.sampled = spanOptions.parentSpan.sampled;
         }
-        const span = createSpan(this, name, Object.assign({
-          type: 'custom'
-        }, options));
+
+        const span = new Span(
+          this,
+          name,
+          Object.assign(
+            {
+              type: 'custom',
+              defaultTags: options.defaultTags
+            },
+            parentOptions,
+            spanOptions,
+            {
+              parentSpan: undefined
+            }
+          )
+        );
 
         span.start();
 

package/lib/tracing/collectors/event.js

@@ -36,7 +36,9 @@ module.exports = (options) => (runtime, tracer) => {
   };
 
   const flushQueue = () => {
-    if (queue.length === 0) return;
+    if (queue.length === 0) {
+      return;
+    };
 
     const data = generateTracingData();
     queue.length = 0;

package/lib/tracing/span.js

@@ -1,69 +1,156 @@
 const hrTime = require('./time');
 
-exports.createSpan = (tracer, name, options) => {
-  const span = Object.assign({}, {
-    name,
-    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: {}
+function defineReadonlyProperty (instance, propName, value, readOnly = false) {
+  Object.defineProperty(instance, propName, {
+    value,
+    writable: !!readOnly,
+    enumerable: false
   });
+}
 
-  if (options.service) {
-    span.service = {
-      name: options.service.name,
-      version: options.service.version,
-      fullyQualifiedName: options.service.fullyQualifiedName
-    };
+// transform this factory function into a class
+exports.Span = class Span {
+  constructor (tracer, name, options) {
+    defineReadonlyProperty(this, 'tracer', tracer, true);
+    // defineReadonlyProperty(this, 'logger', this.tracer.logger, true);
+    defineReadonlyProperty(this, 'options', options || {});
+    defineReadonlyProperty(this, 'meta', {});
+
+    this.name = name;
+    this.id = options.id || tracer.runtime.generateUUID();
+    this.traceId = options.traceId || this.id;
+    this.parentId = options.parentId;
+    this.type = options.type || 'custom';
+    this.sampled = options.sampled || tracer.shouldSample();
+    this.tags = {};
+
+    if (options.service) {
+      this.service = {
+        name: options.service.name,
+        version: options.service.version,
+        fullyQualifiedName: options.service.fullyQualifiedName
+      };
+    }
+
+    if (options.defaultTags) {
+      this.addTags(options.defaultTags);
+    }
+
+    if (options.tags) {
+      this.addTags(options.tags);
+    }
   }
 
-  span.addTags = (tags) => {
-    Object.assign(span.tags, tags);
-    return span;
-  };
+  addTags (tags) {
+    Object.assign(this.tags, tags);
+    return this;
+  }
 
-  span.start = (time) => {
-    span.startTime = time || hrTime();
-    if (span.sampled) {
-      tracer.invokeCollectorMethod('startedSpan', [span]);
+  start (time) {
+    this.startTime = time || hrTime();
+    if (this.sampled) {
+      this.tracer.invokeCollectorMethod('startedSpan', [this]);
     }
-    return span;
-  };
+    return this;
+  }
 
-  span.startChildSpan = (name, options) => {
+  startChildSpan (name, options) {
     const parentOptions = {
-      parentId: options.parentId,
-      sampled: options.sampled
+      parentId: this.id,
+      traceId: this.traceId,
+      sampled: this.sampled,
+      service: this.service
     };
-    return tracer.startSpan(name, Object.assign(parentOptions, options));
-  };
+    return this.tracer.startSpan(name, Object.assign(parentOptions, options));
+  }
 
-  span.finish = (time) => {
-    span.finishTime = time || hrTime();
-    span.duration = span.finishTime - span.startTime;
+  finish (time) {
+    this.finishTime = time || hrTime();
+    this.duration = this.finishTime - this.startTime;
 
-    tracer.log.debug(`Span "${span.id}" finished`);
+    this.tracer.log.debug(`Span "${this.id}" finished`);
 
-    if (span.sampled) {
-      tracer.invokeCollectorMethod('finishedSpan', [span]);
+    if (this.sampled) {
+      this.tracer.invokeCollectorMethod('finishedSpan', [this]);
     }
 
-    return span;
-  };
-
-  span.isActive = () => span.finishTime !== null;
-
-  span.setError = (error) => {
-    span.error = error;
-    return span;
-  };
+    return this;
+  }
 
-  if (options.tags) {
-    span.addTags(options.tags);
+  isActive () {
+    return this.finishTime !== null;
   }
 
-  return span;
+  setError (error) {
+    this.error = error;
+    return this;
+  }
 };
+
+// exports.createSpan = (tracer, name, options) => {
+//   const span = Object.assign({}, {
+//     name,
+//     id: options.id || tracer.runtime.generateUUID(),
+//     traceId: options.traceId || span.id,
+//     parentId: options.parentId,
+//     type: options.type || 'custom',
+//     sampled: options.sampled || tracer.shouldSample(),
+//     service: options.service,
+//     tags: {}
+//   });
+
+//   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;
+//   };
+
+//   span.start = (time) => {
+//     span.startTime = time || hrTime();
+//     if (span.sampled) {
+//       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));
+//   };
+
+//   span.finish = (time) => {
+//     span.finishTime = time || hrTime();
+//     span.duration = span.finishTime - span.startTime;
+
+//     tracer.log.debug(`Span "${span.id}" finished`);
+
+//     if (span.sampled) {
+//       tracer.invokeCollectorMethod('finishedSpan', [span]);
+//     }
+
+//     return span;
+//   };
+
+//   span.isActive = () => span.finishTime !== null;
+
+//   span.setError = (error) => {
+//     span.error = error;
+//     return span;
+//   };
+
+//   if (options.tags) {
+//     span.addTags(options.tags);
+//   }
+
+//   return span;
+// };

package/lib/transport/adapters/adapters.js

@@ -4,6 +4,6 @@
  * Copyright 2019 Fachwerk
  */
 
-exports.BaseAdapter = require('./adapteBase');
+exports.BaseAdapter = require('./adapterBase');
 exports.Dummy = require('./dummy');
 exports.TCP = require('./tcp');

package/lib/transport/adapters/dummy/index.js

@@ -4,7 +4,7 @@
  * Copyright 2021 Fachwerk
  */
 
-const TransportBase = require('../adapteBase');
+const TransportBase = require('../adapterBase');
 const EventEmitter = require('eventemitter2').EventEmitter2;
 
 // create a global eventbus to pass messages between weave service brokers.

package/lib/transport/adapters/tcp/index.js

@@ -1,6 +1,6 @@
 
 const { defaultsDeep } = require('@weave-js/utils');
-const TransportBase = require('../adapteBase');
+const TransportBase = require('../adapterBase');
 const Swim = require('./discovery/index');
 const MessageTypes = require('../../messageTypes');
 const TCPReader = require('./tcpReader');

package/lib/types.js

@@ -167,7 +167,7 @@ const { EventEmitter2: EventEmitter } = require('eventemitter2');
  * @property {Boolean} enabled - Enable tracing middleware. (default = false)
  * @property {Number} samplingRate - Rate of traced actions. (default = 1.0)
  * @property {Array<String|Object>} collectors - Array of tracing collectors.
- * @property {Array<String>} defaultTags - Default tags for spans.
+ * @property {Object.<string, string>} defaultTags - Default tags for spans.
  * @property {TracingErrorOptions} [errors] - Settings for tracing errors.
 */
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weave-js/core",
-  "version": "0.15.1",
+  "version": "0.15.3",
   "description": "The core package of weave",
   "keywords": [
     "Weave",
@@ -39,11 +39,10 @@
   },
   "license": "MIT",
   "dependencies": {
-    "@weave-js/errors": "^0.9.1",
     "@weave-js/utils": "^0.13.0",
     "@weave-js/validator": "^0.14.0",
     "eventemitter2": "^6.4.9",
-    "glob": "^10.2.2"
+    "glob": "^10.3.10"
   },
   "directories": {
     "lib": "lib",