@routr/location 2.0.5-alpha.2 → 2.0.5-alpha.21

package/dist/helper.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRoute = void 0;
+const processor_1 = require("@routr/processor");
+// TODO: Before finalizing this, consider using the old approach of saving the rport
+// and received values (like here:
+//    https://github.com/fonoster/routr/blob/59bc98af86078088aede7e658c0d82a19fa18fa4/mod/registrar/utils.js#L87)
+//
+// Also consider: https://github.com/fonoster/routr/blob/ee5d339888344013939d06c734385f17f0cd75c2/mod/registrar/utils.js#L116
+// and https://github.com/fonoster/routr/blob/ee5d339888344013939d06c734385f17f0cd75c2/mod/registrar/utils.js#L131
+const createRoute = (request) => {
+    const uri = request.message.contact.address.uri;
+    const sessionCount = processor_1.Extensions.getHeaderValue(request, "x-session-count")
+        ? parseInt(processor_1.Extensions.getHeaderValue(request, "x-session-count"))
+        : -1;
+    return {
+        edgePortRef: request.edgePortRef,
+        user: uri.user,
+        host: uri.host,
+        port: uri.port,
+        transport: uri.transportParam,
+        registeredOn: Date.now(),
+        sessionCount,
+        expires: processor_1.Target.getTargetExpires(request),
+        listeningPoint: request.listeningPoint
+    };
+};
+exports.createRoute = createRoute;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import LocationClient from "./client";
+import { ILocationService } from "./types";
+export * as Helper from "./helper";
+export * as Utils from "./utils";
+export * from "./errors";
+export { LocationClient, ILocationService };

package/dist/index.js

@@ -0,0 +1,55 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocationClient = exports.Utils = exports.Helper = 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 client_1 = __importDefault(require("./client"));
+exports.LocationClient = client_1.default;
+exports.Helper = __importStar(require("./helper"));
+exports.Utils = __importStar(require("./utils"));
+__exportStar(require("./errors"), exports);

package/dist/location.d.ts

@@ -0,0 +1,26 @@
+import { AddRouteRequest, Backend, FindRoutesRequest, ILocationService, ILocatorStore, RemoveRoutesRequest } from "./types";
+import { Route } from "@routr/common";
+/**
+ * A locator store that uses the location service to find routes for AORs.
+ */
+export default class Location implements ILocationService {
+    private store;
+    private backends;
+    private rrCount;
+    private affinityStore;
+    /**
+     * Creates a new Location service. Should fail if any backend has sessionAffinity and round-robin
+     *
+     * @param {ILocatorStore} store - The store to use for the location service
+     * @param {Map<string, Backend>} backends - The backends to use for the location service
+     */
+    constructor(store: ILocatorStore, backends?: Map<string, Backend>);
+    /** @inheritdoc */
+    addRoute(request: AddRouteRequest): Promise<void>;
+    /** @inheritdoc */
+    findRoutes(request: FindRoutesRequest): Promise<Route[]>;
+    /** @inheritdoc */
+    removeRoutes(request: RemoveRoutesRequest): Promise<void>;
+    private next;
+    private nextWithAffinity;
+}

package/dist/location.js

@@ -0,0 +1,118 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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.
+ */
+const errors_1 = require("./errors");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+var AOR_SCHEME;
+(function (AOR_SCHEME) {
+    AOR_SCHEME["SIP"] = "sip:";
+    AOR_SCHEME["BACKEND"] = "backend:";
+})(AOR_SCHEME || (AOR_SCHEME = {}));
+/**
+ * A locator store that uses the location service to find routes for AORs.
+ */
+class Location {
+    /**
+     * Creates a new Location service. Should fail if any backend has sessionAffinity and round-robin
+     *
+     * @param {ILocatorStore} store - The store to use for the location service
+     * @param {Map<string, Backend>} backends - The backends to use for the location service
+     */
+    constructor(store, backends = new Map()) {
+        this.store = store;
+        this.backends = backends;
+        this.rrCount = new Map();
+        this.affinityStore = new Map();
+        this.backends.forEach((value, key) => this.rrCount.set(key, 0));
+    }
+    /** @inheritdoc */
+    addRoute(request) {
+        if (!request.aor.startsWith(AOR_SCHEME.SIP) &&
+            !request.aor.startsWith(AOR_SCHEME.BACKEND)) {
+            throw new errors_1.UnsupportedSchema(request.aor);
+        }
+        return this.store.put(request.aor, request.route);
+    }
+    /** @inheritdoc */
+    findRoutes(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const routes = request.labels
+                ? (yield this.store.get(request.aor)).filter((0, utils_1.filterOnlyMatchingLabels)(request.labels))
+                : (yield this.store.get(request.aor)) || [];
+            if (request.aor.startsWith(AOR_SCHEME.SIP)) {
+                return routes;
+            }
+            else if (request.aor.startsWith(AOR_SCHEME.BACKEND)) {
+                const backend = this.backends.get(request.aor);
+                if (!backend) {
+                    throw new errors_1.NotRoutesFoundForAOR(request.aor);
+                }
+                // If it has not affinity sesssion then get next
+                return backend.withSessionAffinity
+                    ? [this.nextWithAffinity(routes, request.sessionAffinityRef)]
+                    : [this.next(routes, backend)];
+            }
+            throw new errors_1.UnsupportedSchema(request.aor);
+        });
+    }
+    /** @inheritdoc */
+    removeRoutes(request) {
+        return this.store.delete(request.aor);
+    }
+    // eslint-disable-next-line require-jsdoc
+    next(routes, backend) {
+        if (backend.balancingAlgorithm === types_1.LB_ALGORITHM.LEAST_SESSIONS) {
+            return routes.sort((r1, r2) => r1.sessionCount - r2.sessionCount)[0];
+        }
+        // Continues using round-robin
+        const nextPosition = this.rrCount.get(`${AOR_SCHEME.BACKEND}${backend.ref}`);
+        const result = routes[nextPosition];
+        if (nextPosition >= routes.length - 1) {
+            // Restarting round-robin counter
+            this.rrCount.set(`${AOR_SCHEME.BACKEND}${backend.ref}`, 0);
+        }
+        else {
+            this.rrCount.set(`${AOR_SCHEME.BACKEND}${backend.ref}`, nextPosition + 1);
+        }
+        return result;
+    }
+    // Backend with session affinity does not support round-robin
+    // eslint-disable-next-line require-jsdoc
+    nextWithAffinity(routes, sessionAffinityRef) {
+        let route = this.affinityStore.get(sessionAffinityRef);
+        if (route) {
+            return route;
+        }
+        route = routes.sort((r1, r2) => r1.sessionCount - r2.sessionCount)[0];
+        this.affinityStore.set(sessionAffinityRef, route);
+        return route;
+    }
+}
+exports.default = Location;

package/dist/memory_store.d.ts

@@ -1,12 +1,26 @@
-import { ILocatorStore, Route } from "./types";
+import { Route } from "@routr/common";
+import { ILocatorStore } from "./types";
+/**
+ * In-memory store for the locator service.
+ */
 export default class MemoryStore implements ILocatorStore {
     private collections;
     private cleanupCount;
     private maxCyclesBeforeCleanup;
+    /**
+     * Creates a new in-memory store.
+     *
+     * @param {number} maxCyclesBeforeCleanup - Maximum number of cycles before cleanup
+     */
     constructor(maxCyclesBeforeCleanup?: number);
+    /** @inheritdoc */
     put(key: string, route: Route): Promise<void>;
+    /** @inheritdoc */
     get(key: string): Promise<Route[]>;
+    /** @inheritdoc */
     delete(key: string): Promise<void>;
+    /** @inheritdoc */
     size(): number;
+    /** @inheritdoc */
     cleanup(): void;
 }

package/dist/memory_store.js

@@ -1,77 +1,66 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-var utils_1 = require("./utils");
-var MAX_CYCLES_BEFORE_CLEANUP = 10000;
-var MemoryStore = /** @class */ (function () {
-    function MemoryStore(maxCyclesBeforeCleanup) {
-        if (maxCyclesBeforeCleanup === void 0) { maxCyclesBeforeCleanup = MAX_CYCLES_BEFORE_CLEANUP; }
+const utils_1 = require("./utils");
+const MAX_CYCLES_BEFORE_CLEANUP = 10000;
+/**
+ * In-memory store for the locator service.
+ */
+class MemoryStore {
+    /**
+     * Creates a new in-memory store.
+     *
+     * @param {number} maxCyclesBeforeCleanup - Maximum number of cycles before cleanup
+     */
+    constructor(maxCyclesBeforeCleanup = MAX_CYCLES_BEFORE_CLEANUP) {
         this.collections = new Map();
         this.maxCyclesBeforeCleanup = maxCyclesBeforeCleanup;
     }
-    MemoryStore.prototype.put = function (key, route) {
-        var routes = __spreadArray([], __read(this.collections.get(key) || []));
+    /** @inheritdoc */
+    put(key, route) {
+        const routes = [...(this.collections.get(key) || [])];
         // Avoids duplicate or expired routes
-        var filteredRoutes = routes
+        const filteredRoutes = routes
             .filter(utils_1.expiredFilter)
-            .filter(function (r) { return utils_1.duplicateFilter(r, route); });
+            .filter((r) => (0, utils_1.duplicateFilter)(r, route));
         if (filteredRoutes.length > 0) {
-            this.collections.set(key, __spreadArray([route], __read(filteredRoutes)));
+            this.collections.set(key, [route, ...filteredRoutes]);
         }
         else {
             this.collections.set(key, [route]);
         }
         return;
-    };
-    MemoryStore.prototype.get = function (key) {
+    }
+    /** @inheritdoc */
+    get(key) {
         // Cleanup every so often to avoid memory build up
         this.cleanupCount++;
         if (this.cleanupCount >= this.maxCyclesBeforeCleanup) {
             this.cleanupCount = 0;
             this.cleanup();
         }
-        return Promise.resolve(this.collections.get(key) || []);
-    };
-    MemoryStore.prototype.delete = function (key) {
+        return Promise.resolve((this.collections.get(key) || []).filter(utils_1.expiredFilter));
+    }
+    /** @inheritdoc */
+    delete(key) {
         this.collections.delete(key);
         return;
-    };
-    MemoryStore.prototype.size = function () {
+    }
+    /** @inheritdoc */
+    size() {
         return this.collections.size;
-    };
-    MemoryStore.prototype.cleanup = function () {
-        var _this = this;
+    }
+    /** @inheritdoc */
+    cleanup() {
         // Remove any expired route from collection
-        this.collections.forEach(function (routes, key) {
-            var filteredRoutes = routes.filter(utils_1.expiredFilter);
+        this.collections.forEach((routes, key) => {
+            const filteredRoutes = routes.filter(utils_1.expiredFilter);
             if (filteredRoutes.length > 0) {
-                _this.collections.set(key, filteredRoutes);
+                this.collections.set(key, filteredRoutes);
             }
             else {
-                _this.collections.delete(key);
+                this.collections.delete(key);
             }
         });
-    };
-    return MemoryStore;
-}());
+    }
+}
 exports.default = MemoryStore;

package/dist/redis_store.d.ts

@@ -0,0 +1,21 @@
+import { Route } from "@routr/common";
+import { ILocatorStore } from "./types";
+import { Redis } from "@routr/common";
+/**
+ * Redis store for the locator service.
+ */
+export default class RedisStore implements ILocatorStore {
+    client: any;
+    /**
+     * Creates a new redis store.
+     *
+     * @param {Redis.RedisStoreConfig} config - Optional store config
+     */
+    constructor(config?: Redis.RedisStoreConfig);
+    /** @inheritdoc */
+    put(key: string, route: Route): Promise<void>;
+    /** @inheritdoc */
+    get(key: string): Promise<Route[]>;
+    /** @inheritdoc */
+    delete(key: string): Promise<void>;
+}

package/dist/redis_store.js

@@ -0,0 +1,99 @@
+"use strict";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const redis_1 = require("redis");
+const common_1 = require("@routr/common");
+const logger_1 = require("@fonoster/logger");
+const logger = (0, logger_1.getLogger)({ service: "location", filePath: __filename });
+/**
+ * Redis store for the locator service.
+ */
+class RedisStore {
+    /**
+     * Creates a new redis store.
+     *
+     * @param {Redis.RedisStoreConfig} config - Optional store config
+     */
+    constructor(config) {
+        this.client = config
+            ? (0, redis_1.createClient)({ url: common_1.Redis.getRedisUrlFromConfig(config) })
+            : (0, redis_1.createClient)();
+        this.client.connect();
+        this.client.on("error", (err) => logger.error("redis client error: ", err));
+    }
+    /** @inheritdoc */
+    put(key, route) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Formatted the key to ensure it is unique
+            yield this.client.set(`${key}:${route.user}${route.host}${route.port}`, JSON.stringify(route), {
+                EX: route.expires
+            });
+            return;
+        });
+    }
+    /** @inheritdoc */
+    get(key) {
+        var e_1, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const routes = [];
+            try {
+                // eslint-disable-next-line no-loops/no-loops
+                for (var _b = __asyncValues(yield this.client.scanIterator({
+                    CURSOR: 0,
+                    MATCH: `${key}:*`
+                })), _c; _c = yield _b.next(), !_c.done;) {
+                    const k = _c.value;
+                    routes.push(JSON.parse(yield this.client.get(k)));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return routes;
+        });
+    }
+    /** @inheritdoc */
+    delete(key) {
+        var e_2, _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // eslint-disable-next-line no-loops/no-loops
+                for (var _b = __asyncValues(yield this.client.scanIterator({
+                    CURSOR: 0,
+                    MATCH: `${key}:*`
+                })), _c; _c = yield _b.next(), !_c.done;) {
+                    const k = _c.value;
+                    yield this.client.del(k);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) yield _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return;
+        });
+    }
+}
+exports.default = RedisStore;

package/dist/runner.js

@@ -22,13 +22,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var logger_1 = __importDefault(require("@fonoster/logger"));
-var service_1 = __importDefault(require("./service"));
-var get_config_1 = require("./config/get_config");
-var result = get_config_1.getConfig(process.env.CONFIG_PATH);
-if (result._tag === 'Right') {
-    service_1.default(result.right);
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+require("./tracer").init("dispatcher");
+const service_1 = __importDefault(require("./service"));
+const get_config_1 = require("./config/get_config");
+const common_1 = require("@routr/common");
+const logger_1 = require("@fonoster/logger");
+const logger = (0, logger_1.getLogger)({ service: "location", 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 { LocationConfig } from "./types";
+/**
+ * Creates a new locator service.
+ *
+ * @param {LocationConfig} config - Service configuration
+ */
 export default function LocationService(config: LocationConfig): void;

package/dist/service.js

@@ -3,12 +3,50 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var common_1 = require("@routr/common");
-var utils_1 = require("./utils");
-var locator_1 = __importDefault(require("./locator"));
-var memory_store_1 = __importDefault(require("./memory_store"));
+/*
+ * 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 types_1 = require("./types");
+const common_1 = require("@routr/common");
+const utils_1 = require("./utils");
+const location_1 = __importDefault(require("./location"));
+const memory_store_1 = __importDefault(require("./memory_store"));
+const redis_store_1 = __importDefault(require("./redis_store"));
+const logger_1 = require("@fonoster/logger");
+const logger = (0, logger_1.getLogger)({ service: "location", filePath: __filename });
+const allowedParameters = ["host", "port", "username", "password", "secure"];
+/**
+ * Creates a new locator service.
+ *
+ * @param {LocationConfig} config - Service configuration
+ */
 function LocationService(config) {
-    var bindAddr = config.bindAddr;
-    common_1.createService(utils_1.getServiceInfo(bindAddr, new locator_1.default(new memory_store_1.default())));
+    const { bindAddr, cache } = config;
+    let store;
+    if (cache.provider === types_1.CACHE_PROVIDER.REDIS) {
+        store = new redis_store_1.default((0, utils_1.configFromString)(cache.parameters, allowedParameters));
+    }
+    else {
+        store = new memory_store_1.default();
+    }
+    const backends = new Map();
+    config.backends.forEach((b) => backends.set(`backend:${b.ref}`, b));
+    (0, common_1.createService)((0, utils_1.getServiceInfo)(bindAddr, new location_1.default(store, backends)));
+    logger.info(`using ${cache.provider} as cache provider`);
 }
 exports.default = LocationService;

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;