@routr/dispatcher 2.0.5-alpha.9 → 2.0.6-alpha.0

package/dist/config/get_config.d.ts

@@ -1,3 +1,3 @@
 import { MessageDispatcherConfig } from "../types";
-import * as E from 'fp-ts/Either';
+import * as E from "fp-ts/Either";
 export declare const getConfig: (path: string) => E.Either<Error, MessageDispatcherConfig>;

package/dist/config/get_config.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -36,8 +40,8 @@ const getConfig = (path) => {
     }
     // convert funcMatch to actual functions
     const processors = c.spec.processors.map((p) => {
-        const { ref, isFallback, addr, methods, matchFunc } = p;
-        return { ref, isFallback, addr, methods, matchFunc: eval(`(${p.matchFunc})`) };
+        const { ref, addr, methods, matchFunc } = p;
+        return { ref, addr, methods, matchFunc: eval(`(${matchFunc})`) };
     });
     // Re-insert processors with matchFunc now as a function
     c.spec.processors = processors;

package/dist/config/schema.d.ts

@@ -57,9 +57,6 @@ export declare const schema: {
                         ref: {
                             type: string;
                         };
-                        isFallback: {
-                            type: string;
-                        };
                         addr: {
                             type: string;
                         };

package/dist/config/schema.js

@@ -20,84 +20,81 @@ exports.schema = void 0;
  * limitations under the License.
  */
 exports.schema = {
-    "$id": "https://json-schema.org/draft/2020-12/schema",
-    "title": "Message Dispatcher configuration",
-    "description": "Configuration for a Message Dispatcher instance",
-    "type": "object",
-    "properties": {
-        "kind": {
-            "description": "Resouce type",
-            "type": "string"
+    $id: "https://json-schema.org/draft/2020-12/schema",
+    title: "Message Dispatcher configuration",
+    description: "Configuration for a Message Dispatcher instance",
+    type: "object",
+    properties: {
+        kind: {
+            description: "Resouce type",
+            type: "string"
         },
-        "apiVersion": {
-            "description": "Resource version",
-            "type": "string"
+        apiVersion: {
+            description: "Resource version",
+            type: "string"
         },
-        "metadata": {
-            "description": "Resource metadata",
-            "type": "object",
-            "properties": {
-                "ref": {
-                    "description": "EdgePort reference",
-                    "type": "string"
+        metadata: {
+            description: "Resource metadata",
+            type: "object",
+            properties: {
+                ref: {
+                    description: "EdgePort reference",
+                    type: "string"
                 }
             },
-            "required": ["ref"]
+            required: ["ref"]
         },
-        "spec": {
-            "description": "Operations spec for EdgePort",
-            "type": "object",
-            "properties": {
-                "bindAddr": {
-                    "description": "Ipv4 interface to accept request on",
-                    "type": "string"
+        spec: {
+            description: "Operations spec for EdgePort",
+            type: "object",
+            properties: {
+                bindAddr: {
+                    description: "Ipv4 interface to accept request on",
+                    type: "string"
                 },
-                "middlewares": {
-                    "description": "Middleware Processors",
-                    "type": "array",
-                    "items": {
-                        "type": "object"
+                middlewares: {
+                    description: "Middleware Processors",
+                    type: "array",
+                    items: {
+                        type: "object"
                     },
-                    "properties": {
-                        "ref": {
-                            "type": "string"
+                    properties: {
+                        ref: {
+                            type: "string"
                         },
-                        "addr": {
-                            "type": "string"
+                        addr: {
+                            type: "string"
                         }
                     },
-                    "required": ["ref", "addr"]
+                    required: ["ref", "addr"]
                 },
-                "processors": {
-                    "description": "Message Processors",
-                    "type": "array",
-                    "items": {
-                        "type": "object"
+                processors: {
+                    description: "Message Processors",
+                    type: "array",
+                    items: {
+                        type: "object"
                     },
-                    "properties": {
-                        "ref": {
-                            "type": "string"
+                    properties: {
+                        ref: {
+                            type: "string"
                         },
-                        "isFallback": {
-                            "type": "boolean"
+                        addr: {
+                            type: "string"
                         },
-                        "addr": {
-                            "type": "string"
+                        matchFunc: {
+                            type: "string"
                         },
-                        "matchFunc": {
-                            "type": "string"
-                        },
-                        "methods": {
-                            "type": "array",
-                            "items": {
-                                "type": "string"
+                        methods: {
+                            type: "array",
+                            items: {
+                                type: "string"
                             }
                         }
                     },
-                    "required": ["ref", "addr", "methods", "matchFunc"]
+                    required: ["ref", "addr", "methods", "matchFunc"]
                 }
             }
         }
     },
-    "required": ["kind", "metadata", "spec", "apiVersion"]
+    required: ["kind", "metadata", "spec", "apiVersion"]
 };

package/dist/connections.d.ts

@@ -1,12 +1,11 @@
 import { ProcessorGPRCConnection } from "./types";
+import { ProcessorConfig } from "@routr/common";
+import { MiddlewareConfig } from "@routr/common/src/types";
 /**
  * Creates a connection to all the backend processors. The function will
  * fail if any of the backends is unavailable during initialization.
  *
- * @param processors list of backend processors
- * @returns list of connections
+ * @param {ProcessorConfig} processors list of backend processors
+ * @return {ProcessorGPRCConnection}
  */
-export default function connectToBackend(processors: {
-    ref: string;
-    addr: string;
-}[]): Map<string, ProcessorGPRCConnection>;
+export default function connectToBackend(processors: ProcessorConfig[] | MiddlewareConfig[]): Map<string, ProcessorGPRCConnection>;

package/dist/connections.js

@@ -1,19 +1,45 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const common_1 = require("@routr/common");
-const grpc = require("@grpc/grpc-js");
+const grpc = __importStar(require("@grpc/grpc-js"));
 /**
  * Creates a connection to all the backend processors. The function will
  * fail if any of the backends is unavailable during initialization.
  *
- * @param processors list of backend processors
- * @returns list of connections
+ * @param {ProcessorConfig} processors list of backend processors
+ * @return {ProcessorGPRCConnection}
  */
 function connectToBackend(processors) {
     const procs = processors ? [...processors] : [];
     const connections = new Map();
+    // eslint-disable-next-line no-loops/no-loops
     for (const processor of procs) {
-        connections.set(processor.ref, new common_1.PROCESSOR_OBJECT_PROTO.Processor(processor.addr, grpc.credentials.createInsecure()));
+        connections.set(processor.ref, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        new common_1.PROCESSOR_OBJECT_PROTO.Processor(processor.addr, grpc.credentials.createInsecure()));
     }
     return connections;
 }

package/dist/errors.d.ts

@@ -1,13 +1,37 @@
-import grpc = require("@grpc/grpc-js");
+import * as grpc from "@grpc/grpc-js";
+/**
+ * Thrown when no backened matches the request.
+ */
 export declare class NotMatchingProcessorFound extends Error {
     code: grpc.status;
+    /**
+     * Creates a new instance of NotMatchingProcessorFound.
+     *
+     * @param {string} ref - The reference of the processor
+     */
     constructor(ref: string);
 }
+/**
+ * Thrown when the processor is not available.
+ */
 export declare class ProcessorUnavailableError extends Error {
     code: number;
+    /**
+     * Creates a new instance of NotMatchingProcessorFound.
+     *
+     * @param {string} ref - The reference of the processor
+     */
     constructor(ref: string);
 }
+/**
+ * Thrown when the middleware is not available.
+ */
 export declare class MiddlewareUnavailableError extends Error {
     code: number;
+    /**
+     * Creates a new instance of NotMatchingProcessorFound.
+     *
+     * @param {string} ref - The reference of the processor
+     */
     constructor(ref: string);
 }

package/dist/errors.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MiddlewareUnavailableError = exports.ProcessorUnavailableError = exports.NotMatchingProcessorFound = void 0;
 /*
@@ -19,8 +42,16 @@ exports.MiddlewareUnavailableError = exports.ProcessorUnavailableError = exports
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const grpc = require("@grpc/grpc-js");
+const grpc = __importStar(require("@grpc/grpc-js"));
+/**
+ * Thrown when no backened matches the request.
+ */
 class NotMatchingProcessorFound extends Error {
+    /**
+     * Creates a new instance of NotMatchingProcessorFound.
+     *
+     * @param {string} ref - The reference of the processor
+     */
     constructor(ref) {
         super(`not matching processor found for request ref: ${ref}`);
         this.code = grpc.status.NOT_FOUND;
@@ -29,7 +60,15 @@ class NotMatchingProcessorFound extends Error {
     }
 }
 exports.NotMatchingProcessorFound = NotMatchingProcessorFound;
+/**
+ * Thrown when the processor is not available.
+ */
 class ProcessorUnavailableError extends Error {
+    /**
+     * Creates a new instance of NotMatchingProcessorFound.
+     *
+     * @param {string} ref - The reference of the processor
+     */
     constructor(ref) {
         super(`processor ref = ${ref} is unavailable`);
         this.code = grpc.status.UNAVAILABLE;
@@ -38,7 +77,15 @@ class ProcessorUnavailableError extends Error {
     }
 }
 exports.ProcessorUnavailableError = ProcessorUnavailableError;
+/**
+ * Thrown when the middleware is not available.
+ */
 class MiddlewareUnavailableError extends Error {
+    /**
+     * Creates a new instance of NotMatchingProcessorFound.
+     *
+     * @param {string} ref - The reference of the processor
+     */
     constructor(ref) {
         super(`middleware ref = ${ref} is unavailable`);
         this.code = grpc.status.UNAVAILABLE;

package/dist/find_processor.js

@@ -5,9 +5,10 @@ const errors_1 = require("./errors");
 const hasMethod = (config, request) => config.methods.includes(request.method);
 exports.hasMethod = hasMethod;
 // TODO: We need a way to test the matching function
-const filter = (request, config) => exports.hasMethod(config, request)
-    && (config.isFallback || config.matchFunc(request));
+const filter = (request, config) => (0, exports.hasMethod)(config, request) && (config === null || config === void 0 ? void 0 : config.matchFunc(request));
 exports.filter = filter;
-const findProcessor = (list) => (request) => list.find((config) => exports.filter(request, config))
-    || new errors_1.NotMatchingProcessorFound(request.ref);
+const findProcessor = (list) => (request) => {
+    var _a;
+    return (_a = list.find((config) => (0, exports.filter)(request, config))) !== null && _a !== void 0 ? _a : new errors_1.NotMatchingProcessorFound(request === null || request === void 0 ? void 0 : request.ref);
+};
 exports.findProcessor = findProcessor;

package/dist/processor.d.ts

@@ -1,7 +1,13 @@
 import { ProcessorConfig } from "@routr/common";
-import { ProcessorCallback } from "./types";
-import { MiddlewareConfig } from "@routr/common/src/types";
+import { RunProcessorParams } from "./types";
+import { CommonTypes as CT } from "@routr/common";
+/**
+ * Creates a new instance of Processor.
+ *
+ * @param {object} params - The parameters of the processor
+ * @return {Processor}
+ */
 export default function processor(params: {
     processors: ProcessorConfig[];
-    middlewares?: MiddlewareConfig[];
-}): (call: any, callback: ProcessorCallback) => void;
+    middlewares?: CT.MiddlewareConfig[];
+}): (call: RunProcessorParams, callback: any) => void;

package/dist/processor.js

@@ -23,27 +23,46 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 const connections_1 = __importDefault(require("./connections"));
 const run_processor_1 = require("./run_processor");
+const common_1 = require("@routr/common");
 const run_middlewares_1 = require("./run_middlewares");
-const logger_1 = __importDefault(require("@fonoster/logger"));
+const logger_1 = require("@fonoster/logger");
+const logger = (0, logger_1.getLogger)({ service: "dispatcher", filePath: __filename });
+/**
+ * Creates a new instance of Processor.
+ *
+ * @param {object} params - The parameters of the processor
+ * @return {Processor}
+ */
 function processor(params) {
     const { processors, middlewares } = params;
-    const procConns = connections_1.default(processors);
-    const middConns = connections_1.default(middlewares);
+    const procConns = (0, connections_1.default)(processors);
+    const middConns = (0, connections_1.default)(middlewares);
     // Upstream request and callback
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     return (call, callback) => {
         const { request } = call;
         // Messages type reponse will not be sent to middleware chain
-        if (request.message.messageType === 'responseType') {
-            return run_processor_1.runProcessor({ callback, request, processors, connections: procConns });
+        if (request.message.messageType === common_1.CommonTypes.MessageType.RESPONSE) {
+            return (0, run_processor_1.runProcessor)({
+                callback,
+                request,
+                processors,
+                connections: procConns
+            });
         }
-        run_middlewares_1.runMiddlewares({ callback, request, middlewares, connections: middConns })
+        (0, run_middlewares_1.runMiddlewares)({ callback, request, middlewares, connections: middConns })
             .then((req) => {
             // Since the chain was broken we need to skip the processor and return the updated request
-            if (req.message.messageType === "responseType") {
-                logger_1.default.verbose("skipped processsing request ref " + req.ref);
+            if (req.message.messageType === common_1.CommonTypes.MessageType.RESPONSE) {
+                logger.silly("skipped processsing request", { ref: req.ref });
                 return callback(null, req);
             }
-            run_processor_1.runProcessor({ callback, request: req, processors, connections: procConns });
+            (0, run_processor_1.runProcessor)({
+                callback,
+                request: req,
+                processors,
+                connections: procConns
+            });
         })
             .catch(callback);
     };

package/dist/run_middlewares.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -8,9 +31,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runMiddlewares = void 0;
 /*
@@ -32,8 +52,11 @@ exports.runMiddlewares = void 0;
  * limitations under the License.
  */
 const errors_1 = require("./errors");
-const grpc = require("@grpc/grpc-js");
-const logger_1 = __importDefault(require("@fonoster/logger"));
+const common_1 = require("@routr/common");
+const grpc = __importStar(require("@grpc/grpc-js"));
+const logger_1 = require("@fonoster/logger");
+const logger = (0, logger_1.getLogger)({ service: "dispatcher", filePath: __filename });
+// eslint-disable-next-line require-jsdoc
 function processMessage(middlewareRef, conn, request) {
     return __awaiter(this, void 0, void 0, function* () {
         return new Promise((resolve, reject) => {
@@ -45,20 +68,32 @@ function processMessage(middlewareRef, conn, request) {
         });
     });
 }
+// eslint-disable-next-line require-jsdoc
 function runMiddlewares(params) {
     return __awaiter(this, void 0, void 0, function* () {
         const { connections, request, middlewares = [] } = params;
         const req = Object.assign({}, request);
+        // eslint-disable-next-line no-async-promise-executor
         return new Promise((resolve, rejects) => __awaiter(this, void 0, void 0, function* () {
+            // eslint-disable-next-line no-loops/no-loops
             for (const midd of middlewares) {
-                logger_1.default.verbose("forwarding request to middleware with ref => " + midd.ref);
+                logger.silly("sending request to middleware", {
+                    ref: request.ref,
+                    middlewareRef: midd.ref,
+                    addr: midd.addr
+                });
                 // Get the next middleware
                 const conn = connections.get(midd.ref);
                 // Send message and re-insert response for next middleware
                 try {
-                    req.message = (yield processMessage(midd.ref, conn, req)).message;
-                    if (req.message.messageType === "responseType") {
-                        logger_1.default.verbose("found messageType to be responseType and broke the chain");
+                    req.message = (yield processMessage(midd.ref, conn, req))
+                        .message;
+                    if (req.message.messageType === common_1.CommonTypes.MessageType.RESPONSE) {
+                        logger.silly("found messageType to be responseType and broke the chain", {
+                            ref: request.ref,
+                            middlewareRef: midd.ref,
+                            addr: midd.addr
+                        });
                         break;
                     }
                 }

package/dist/run_processor.d.ts

@@ -1,2 +1,8 @@
 import { RunProcessorParams } from "./types";
-export declare function runProcessor(params: RunProcessorParams): any;
+/**
+ * Runs the processor.
+ *
+ * @param {RunProcessorParams} params - The parameters for the run processor
+ * @return {Promise<any>}
+ */
+export declare function runProcessor(params: RunProcessorParams): void;

package/dist/run_processor.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -24,15 +47,31 @@ exports.runProcessor = void 0;
  */
 const errors_1 = require("./errors");
 const find_processor_1 = require("./find_processor");
-const grpc = require("@grpc/grpc-js");
-const logger_1 = __importDefault(require("@fonoster/logger"));
+const api_1 = __importDefault(require("@opentelemetry/api"));
+const grpc = __importStar(require("@grpc/grpc-js"));
+const logger_1 = require("@fonoster/logger");
+const logger = (0, logger_1.getLogger)({ service: "dispatcher", filePath: __filename });
+/**
+ * Runs the processor.
+ *
+ * @param {RunProcessorParams} params - The parameters for the run processor
+ * @return {Promise<any>}
+ */
 function runProcessor(params) {
+    const currentSpan = api_1.default.trace.getSpan(api_1.default.context.active());
+    // display traceid in the terminal
+    logger.silly(`traceid: ${currentSpan === null || currentSpan === void 0 ? void 0 : currentSpan.spanContext().traceId}`);
+    const tracer = api_1.default.trace.getTracer("routr-tracer");
+    const span = tracer.startSpan("server.js:sayHello()", { kind: 1 });
+    span.addEvent("invoking sayHello() to...");
     const { callback, connections, processors, request } = params;
-    const matchResult = find_processor_1.findProcessor(processors)(request);
-    if ('code' in matchResult) {
+    const matchResult = (0, find_processor_1.findProcessor)(processors)(request);
+    if ("code" in matchResult) {
         return callback(matchResult);
     }
-    logger_1.default.verbose("forwarding request to processor with ref => " + matchResult.ref);
+    logger.silly("forwarding request to processor", {
+        processorRef: matchResult.ref
+    });
     const conn = connections.get(matchResult.ref);
     // Connects to downstream processor
     conn.processMessage(request, (err, response) => {

package/dist/runner.js

@@ -24,11 +24,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
  */
 const service_1 = __importDefault(require("./service"));
 const get_config_1 = require("./config/get_config");
-const logger_1 = __importDefault(require("@fonoster/logger"));
-const result = get_config_1.getConfig(process.env.CONFIG_PATH);
-if (result._tag === 'Right') {
-    service_1.default(result.right);
+const common_1 = require("@routr/common");
+const logger_1 = require("@fonoster/logger");
+const logger = (0, logger_1.getLogger)({ service: "dispatcher", filePath: __filename });
+common_1.Assertions.assertEnvsAreSet(["CONFIG_PATH"]);
+const result = (0, get_config_1.getConfig)(process.env.CONFIG_PATH);
+if (result._tag === "Right") {
+    (0, service_1.default)(result.right);
 }
 else {
-    logger_1.default.error(result.left);
+    logger.error(result.left);
 }

package/dist/service.d.ts

@@ -1,2 +1,7 @@
 import { MessageDispatcherConfig } from "./types";
-export default function MessageDispatcher(config: MessageDispatcherConfig): void;
+/**
+ * Creates a service that can be used to dispatch messages to the backend processors.
+ *
+ * @param {MessageDispatcherConfig} config - Configuration for the dispatcher
+ */
+export default function messageDispatcher(config: MessageDispatcherConfig): void;

package/dist/service.js

@@ -1,9 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr
+ *
+ * Licensed under the MIT License (the "License")
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+require("./tracer").init("dispatcher");
 const common_1 = require("@routr/common");
 const util_1 = require("./util");
-function MessageDispatcher(config) {
+/**
+ * Creates a service that can be used to dispatch messages to the backend processors.
+ *
+ * @param {MessageDispatcherConfig} config - Configuration for the dispatcher
+ */
+function messageDispatcher(config) {
     const { bindAddr, processors, middlewares } = config;
-    common_1.createService(util_1.getServiceInfo(bindAddr, { processors, middlewares }));
+    (0, common_1.createService)((0, util_1.getServiceInfo)(bindAddr, { processors, middlewares }));
 }
-exports.default = MessageDispatcher;
+exports.default = messageDispatcher;

package/dist/tracer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * This function registers the instrumentations for the service.
+ *
+ * @param {string} serviceName - The name of the service.
+ * @return {Tracer} The tracer object.
+ */
+export declare function init(serviceName: string): import("@opentelemetry/api").Tracer;

package/dist/tracer.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = void 0;
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr
+ *
+ * Licensed under the MIT License (the "License")
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const api_1 = __importDefault(require("@opentelemetry/api"));
+const instrumentation_1 = require("@opentelemetry/instrumentation");
+const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+const resources_1 = require("@opentelemetry/resources");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+const exporter_jaeger_1 = require("@opentelemetry/exporter-jaeger");
+const instrumentation_grpc_1 = require("@opentelemetry/instrumentation-grpc");
+/**
+ * This function registers the instrumentations for the service.
+ *
+ * @param {string} serviceName - The name of the service.
+ * @return {Tracer} The tracer object.
+ */
+function init(serviceName) {
+    const provider = new sdk_trace_node_1.NodeTracerProvider({
+        resource: new resources_1.Resource({
+            [semantic_conventions_1.SemanticResourceAttributes.SERVICE_NAME]: serviceName
+        })
+    });
+    const exporter = new exporter_jaeger_1.JaegerExporter();
+    provider.addSpanProcessor(new sdk_trace_base_1.SimpleSpanProcessor(exporter));
+    provider.register();
+    (0, instrumentation_1.registerInstrumentations)({
+        instrumentations: [new instrumentation_grpc_1.GrpcInstrumentation()]
+    });
+    return api_1.default.trace.getTracer("routr-tracer");
+}
+exports.init = init;

package/dist/types.d.ts

@@ -1,25 +1,27 @@
-import { MessageRequest, ProcessorConfig } from "@routr/common";
-import { MiddlewareConfig } from "@routr/common/src/types";
+import { MessageRequest, ProcessorConfig, CommonTypes as CT } from "@routr/common";
 import { NotMatchingProcessorFound, ProcessorUnavailableError } from "./errors";
 export interface MessageDispatcherConfig {
     bindAddr: string;
     processors: ProcessorConfig[];
-    middlewares: MiddlewareConfig[];
+    middlewares: CT.MiddlewareConfig[];
 }
 export interface ProcessorGPRCConnection {
-    processMessage: (request: unknown, callback: Function) => void;
+    processMessage: (request: unknown, callback: CT.GrpcCallback) => void;
 }
-export declare type CallbackErrors = NotMatchingProcessorFound | ProcessorUnavailableError | Error;
+export declare type CallbackErrors = NotMatchingProcessorFound | ProcessorUnavailableError | Error | {
+    code: number;
+    message?: string;
+} | null;
 export declare type ProcessorCallback = (err: CallbackErrors, reponse?: MessageRequest) => void;
 export interface RunProcessorParams {
-    callback: Function;
+    callback: CT.GrpcCallback;
     connections: Map<string, ProcessorGPRCConnection>;
     processors: ProcessorConfig[];
     request: MessageRequest;
 }
 export interface RunMiddlewaresParams {
-    callback: Function;
+    callback: CT.GrpcCallback;
     connections: Map<string, ProcessorGPRCConnection>;
-    middlewares: MiddlewareConfig[];
+    middlewares: CT.MiddlewareConfig[];
     request: MessageRequest;
 }

package/dist/util.d.ts

@@ -1,6 +1,12 @@
-import { ProcessorConfig, ServiceInfo } from "@routr/common";
-import { MiddlewareConfig } from "@routr/common/src/types";
+import { ProcessorConfig, ServiceInfo, CommonTypes as CT } from "@routr/common";
+/**
+ * Gets the service metadata for the dispatcher.
+ *
+ * @param {string} bindAddr - The address to bind to
+ * @param {object} backends - The backends to use
+ * @return {ServiceInfo}
+ */
 export declare function getServiceInfo(bindAddr: string, backends: {
-    middlewares: MiddlewareConfig[];
+    middlewares: CT.MiddlewareConfig[];
     processors: ProcessorConfig[];
 }): ServiceInfo;

package/dist/util.js

@@ -24,13 +24,21 @@ exports.getServiceInfo = void 0;
  */
 const processor_1 = __importDefault(require("./processor"));
 const common_1 = require("@routr/common");
+/**
+ * Gets the service metadata for the dispatcher.
+ *
+ * @param {string} bindAddr - The address to bind to
+ * @param {object} backends - The backends to use
+ * @return {ServiceInfo}
+ */
 function getServiceInfo(bindAddr, backends) {
     return {
         name: "dispatcher",
         bindAddr,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         service: common_1.PROCESSOR_OBJECT_PROTO.Processor.service,
         handlers: {
-            processMessage: processor_1.default(backends)
+            processMessage: (0, processor_1.default)(backends)
         }
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@routr/dispatcher",
-  "version": "2.0.5-alpha.9",
+  "version": "2.0.6-alpha.0",
   "description": "Receives SIP messages and forwards them to the corresponding Message Processor",
   "author": "Pedro Sanders <psanders@fonoster.com>",
   "homepage": "https://github.com/fonoster/routr#readme",
@@ -25,8 +25,17 @@
     "access": "public"
   },
   "dependencies": {
+    "@fonoster/logger": "0.3.17-alpha.2",
     "@grpc/grpc-js": "^1.5.9",
-    "@routr/common": "^2.0.5-alpha.9",
+    "@opentelemetry/api": "^1.0.4",
+    "@opentelemetry/exporter-jaeger": "^1.0.4",
+    "@opentelemetry/instrumentation": "^0.27.0",
+    "@opentelemetry/instrumentation-grpc": "^0.27.0",
+    "@opentelemetry/resources": "^1.0.4",
+    "@opentelemetry/sdk-trace-base": "^1.0.4",
+    "@opentelemetry/sdk-trace-node": "^1.0.4",
+    "@opentelemetry/semantic-conventions": "^1.0.4",
+    "@routr/common": "^2.0.6-alpha.0",
     "ajv": "^6.12.6",
     "fp-ts": "^2.11.8"
   },
@@ -37,5 +46,5 @@
   "bugs": {
     "url": "https://github.com/fonoster/routr/issues"
   },
-  "gitHead": "9eeafebb3f16625aca520268ed6f44896656f3a6"
+  "gitHead": "0829f7e9b5b3ebba7eb984da5436d7c07689d776"
 }