@devopsplaybook.io/otel-utils 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./src/Logger";
+export * from "./src/StandardMeter";
+export * from "./src/StandardTracer";
+export * as models from "./src/models/ConfigInterface";

package/dist/index.js

@@ -0,0 +1,45 @@
+"use strict";
+// Entry point for the otel-utils npm package
+// Export all modules from src
+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 __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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.models = void 0;
+__exportStar(require("./src/Logger"), exports);
+__exportStar(require("./src/StandardMeter"), exports);
+__exportStar(require("./src/StandardTracer"), exports);
+exports.models = __importStar(require("./src/models/ConfigInterface"));

package/dist/src/Logger.d.ts

@@ -0,0 +1,12 @@
+import { Span } from "@opentelemetry/sdk-trace-base";
+import { ConfigInterface } from "./models/ConfigInterface";
+export declare function LoggerInit(context: Span, config: ConfigInterface): void;
+export declare class Logger {
+    private module;
+    constructor(module: string);
+    debug(message: Error | string | any): void;
+    info(message: Error | string | any): void;
+    warn(message: Error | string | any): void;
+    error(message: Error | string | any): void;
+    private display;
+}

package/dist/src/Logger.js

@@ -0,0 +1,131 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+exports.LoggerInit = LoggerInit;
+const api_logs_1 = require("@opentelemetry/api-logs");
+const exporter_logs_otlp_http_1 = require("@opentelemetry/exporter-logs-otlp-http");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_logs_1 = require("@opentelemetry/sdk-logs");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const os = __importStar(require("os"));
+const StandardTracer_1 = require("./StandardTracer");
+let loggerOTel;
+function LoggerInit(context, config) {
+    const span = (0, StandardTracer_1.StandardTracerStartSpan)("LoggerInit", context);
+    if (config.OPENTELEMETRY_COLLECTOR_HTTP_LOGS) {
+        const exporterHeaders = {};
+        if (config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER) {
+            exporterHeaders["Authorization"] = `Bearer ${config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER}`;
+        }
+        const exporter = new exporter_logs_otlp_http_1.OTLPLogExporter({
+            url: config.OPENTELEMETRY_COLLECTOR_HTTP_LOGS,
+            headers: exporterHeaders,
+        });
+        const loggerProvider = new sdk_logs_1.LoggerProvider({
+            processors: [
+                new sdk_logs_1.BatchLogRecordProcessor(exporter, {
+                    maxQueueSize: 100,
+                    scheduledDelayMillis: config.OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS * 1000,
+                }),
+            ],
+            resource: (0, resources_1.resourceFromAttributes)({
+                [semantic_conventions_1.ATTR_SERVICE_NAME]: `${config.SERVICE_ID}`,
+                [semantic_conventions_1.ATTR_SERVICE_VERSION]: `${config.VERSION}`,
+                [semantic_conventions_1.ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+            }),
+        });
+        loggerOTel = loggerProvider.getLogger(`${config.SERVICE_ID}:${config.VERSION}`);
+    }
+    span.end();
+}
+const DEV_MODE = (() => {
+    if (process.env.NODE_ENV === "dev") {
+        return true;
+    }
+    return false;
+})();
+class Logger {
+    constructor(module) {
+        this.module = `${module}`;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    debug(message) {
+        if (DEV_MODE) {
+            this.display("debug", message, api_logs_1.SeverityNumber.DEBUG);
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    info(message) {
+        this.display("info", message, api_logs_1.SeverityNumber.WARN);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    warn(message) {
+        this.display("warn", message, api_logs_1.SeverityNumber.WARN);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    error(message) {
+        this.display("error", message, api_logs_1.SeverityNumber.ERROR);
+    }
+    display(level, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    message, severityNumber = api_logs_1.SeverityNumber.INFO) {
+        if (typeof message === "string") {
+            // eslint:disable-next-line:no-console
+            console.log(`[${level}] [${this.module}] ${message}`);
+        }
+        else if (message instanceof Error) {
+            // eslint:disable-next-line:no-console
+            console.log(`${level} [${this.module}] ${message}`);
+            // eslint:disable-next-line:no-console
+            console.log(message.stack);
+        }
+        else if (typeof message === "object") {
+            // eslint:disable-next-line:no-console
+            console.log(`${level} [${this.module}] ${JSON.stringify(message)}`);
+        }
+        if (loggerOTel) {
+            {
+                loggerOTel.emit({
+                    severityNumber,
+                    severityText: level,
+                    body: message,
+                    attributes: { "log.type": "custom" },
+                });
+            }
+        }
+    }
+}
+exports.Logger = Logger;

package/dist/src/PromisePool.d.ts

@@ -0,0 +1,9 @@
+export declare class PromisePool {
+    private maxConcurrency;
+    private currentConcurrency;
+    private queue;
+    private timeout;
+    constructor(maxConcurrency: any, timeout?: number);
+    add(promiseGenerator: any): Promise<unknown>;
+    private runNext;
+}

package/dist/src/PromisePool.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromisePool = void 0;
+class PromisePool {
+    constructor(maxConcurrency, timeout = 3600000) {
+        this.maxConcurrency = maxConcurrency;
+        this.currentConcurrency = 0;
+        this.queue = [];
+        this.timeout = timeout;
+    }
+    add(promiseGenerator) {
+        return new Promise((resolve, reject) => {
+            const controller = new AbortController();
+            const signal = controller.signal;
+            const wrappedPromise = () => {
+                return new Promise((innerResolve, innerReject) => {
+                    const timeoutId = setTimeout(() => {
+                        controller.abort();
+                        innerReject(new Error("Promise cancelled due to timeout"));
+                    }, this.timeout);
+                    promiseGenerator(signal)
+                        .then((result) => {
+                        clearTimeout(timeoutId);
+                        innerResolve(result);
+                    })
+                        .catch((error) => {
+                        clearTimeout(timeoutId);
+                        innerReject(error);
+                    });
+                });
+            };
+            this.queue.push({ wrappedPromise, resolve, reject });
+            this.runNext();
+        });
+    }
+    runNext() {
+        if (this.currentConcurrency < this.maxConcurrency && this.queue.length > 0) {
+            const { wrappedPromise, resolve, reject } = this.queue.shift();
+            this.currentConcurrency++;
+            wrappedPromise()
+                .then((result) => {
+                resolve(result);
+                this.currentConcurrency--;
+                this.runNext();
+            })
+                .catch((error) => {
+                reject(error);
+                this.currentConcurrency--;
+                this.runNext();
+            });
+        }
+    }
+}
+exports.PromisePool = PromisePool;

package/dist/src/SqlDbUtils.d.ts

@@ -0,0 +1,7 @@
+import { Config } from "../Config";
+import { Span } from "@opentelemetry/sdk-trace-base";
+export declare function SqlDbUtilsInit(context: Span, config: Config): Promise<void>;
+export declare function SqlDbUtilsInitGetDatabase(): any;
+export declare function SqlDbUtilsExecSQL(context: Span, sql: string, params?: never[]): Promise<number>;
+export declare function SqlDbUtilsExecSQLFile(context: Span, filename: string): Promise<void>;
+export declare function SqlDbUtilsQuerySQL(context: Span, sql: string, params?: never[], debug?: boolean): Promise<any[]>;

package/dist/src/SqlDbUtils.js

@@ -0,0 +1,132 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlDbUtilsInit = SqlDbUtilsInit;
+exports.SqlDbUtilsInitGetDatabase = SqlDbUtilsInitGetDatabase;
+exports.SqlDbUtilsExecSQL = SqlDbUtilsExecSQL;
+exports.SqlDbUtilsExecSQLFile = SqlDbUtilsExecSQLFile;
+exports.SqlDbUtilsQuerySQL = SqlDbUtilsQuerySQL;
+const sqlite3_1 = require("sqlite3");
+const fs = __importStar(require("fs-extra"));
+const Logger_1 = require("./Logger");
+const api_1 = require("@opentelemetry/api");
+const StandardTracer_1 = require("./StandardTracer");
+const logger = new Logger_1.Logger("SqlDbutils");
+const SQL_DIR = `${__dirname}/../../sql`;
+let database;
+async function SqlDbUtilsInit(context, config) {
+    const span = (0, StandardTracer_1.StandardTracerStartSpan)("SqlDbUtilsInit", context);
+    await fs.ensureDir(config.DATA_DIR);
+    database = new sqlite3_1.Database(`${config.DATA_DIR}/database.db`);
+    await SqlDbUtilsExecSQLFile(span, `${SQL_DIR}/init-0000.sql`);
+    const initFiles = (await await fs.readdir(`${SQL_DIR}`)).sort();
+    let dbVersionApplied = 0;
+    const dbVersionQuery = await SqlDbUtilsQuerySQL(span, "SELECT MAX(value) as maxVerion FROM metadata WHERE type='db_version'");
+    if (dbVersionQuery[0].maxVerion) {
+        dbVersionApplied = Number(dbVersionQuery[0].maxVerion);
+    }
+    logger.info(`Current DB Version: ${dbVersionApplied}`);
+    for (const initFile of initFiles) {
+        const regex = /init-(\d+).sql/g;
+        const match = regex.exec(initFile);
+        if (match) {
+            const dbVersionInitFile = Number(match[1]);
+            if (dbVersionInitFile > dbVersionApplied) {
+                logger.info(`Loading init file: ${initFile}`);
+                await SqlDbUtilsExecSQLFile(span, `${SQL_DIR}/${initFile}`);
+                await SqlDbUtilsQuerySQL(span, 'INSERT INTO metadata (type, value, dateCreated) VALUES ("db_version",?,?)', [dbVersionInitFile, new Date().toISOString()]);
+            }
+        }
+    }
+    span.end();
+}
+function SqlDbUtilsInitGetDatabase() {
+    return database;
+}
+function SqlDbUtilsExecSQL(context, sql, params = []) {
+    const span = (0, StandardTracer_1.StandardTracerStartSpan)("SqlDbUtilsExecSQL", context);
+    return new Promise((resolve, reject) => {
+        database.run(sql, params, function (error) {
+            if (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.end();
+                reject(error);
+            }
+            else {
+                span.addEvent(`Impacted Rows: ${this.changes}`);
+                span.end();
+                resolve(this.changes);
+            }
+        });
+    });
+}
+async function SqlDbUtilsExecSQLFile(context, filename) {
+    const span = (0, StandardTracer_1.StandardTracerStartSpan)("SqlDbUtilsExecSQLFile", context);
+    const sql = (await fs.readFile(filename)).toString();
+    return new Promise((resolve, reject) => {
+        database.exec(sql, (error) => {
+            if (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.end();
+                reject(error);
+            }
+            else {
+                span.end();
+                resolve();
+            }
+        });
+    });
+}
+function SqlDbUtilsQuerySQL(context, sql, params = [], debug = false
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    const span = (0, StandardTracer_1.StandardTracerStartSpan)("SqlDbUtilsQuerySQL", context);
+    if (debug) {
+        console.log(sql);
+    }
+    return new Promise((resolve, reject) => {
+        database.all(sql, params, (error, rows) => {
+            if (error) {
+                span.setStatus({ code: api_1.SpanStatusCode.ERROR, message: error.message });
+                span.end();
+                reject(error);
+            }
+            else {
+                span.end();
+                resolve(rows);
+            }
+        });
+    });
+}

package/dist/src/SqlDbUtilsNoTelemetry.d.ts

@@ -0,0 +1,2 @@
+export declare function SqlDbUtilsNoTelemetryExecSQL(sql: string, params?: never[]): Promise<void>;
+export declare function SqlDbUtilsNoTelemetryQuerySQL(sql: string, params?: never[], debug?: boolean): Promise<any[]>;

package/dist/src/SqlDbUtilsNoTelemetry.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqlDbUtilsNoTelemetryExecSQL = SqlDbUtilsNoTelemetryExecSQL;
+exports.SqlDbUtilsNoTelemetryQuerySQL = SqlDbUtilsNoTelemetryQuerySQL;
+const Logger_1 = require("./Logger");
+const SqlDbUtils_1 = require("./SqlDbUtils");
+const logger = new Logger_1.Logger("SqlDbUtilsNoTelemetry");
+function SqlDbUtilsNoTelemetryExecSQL(sql, params = []) {
+    return new Promise((resolve, reject) => {
+        (0, SqlDbUtils_1.SqlDbUtilsInitGetDatabase)().run(sql, params, (error) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+function SqlDbUtilsNoTelemetryQuerySQL(sql, params = [], debug = false
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    if (debug) {
+        console.log(sql);
+    }
+    return new Promise((resolve, reject) => {
+        (0, SqlDbUtils_1.SqlDbUtilsInitGetDatabase)().all(sql, params, (error, rows) => {
+            if (error) {
+                console.log(error);
+                logger.error(`SQL ERROR: ${sql}`);
+                reject(error);
+            }
+            else {
+                resolve(rows);
+            }
+        });
+    });
+}

package/dist/src/StandardMeter.d.ts

@@ -0,0 +1,7 @@
+import { Counter, Histogram, ObservableGauge } from "@opentelemetry/api";
+import { ConfigInterface } from "./models/ConfigInterface";
+export declare function StandardMeterInitTelemetry(initConfig: ConfigInterface): void;
+export declare function StandardMeterCreateCounter(key: string): Counter;
+export declare function StandardMeterCreateUpDownCounter(key: string): Counter;
+export declare function StandardMeterCreateHistorgram(key: string): Histogram;
+export declare function StandardMeterCreateObservableGauge(key: string, callback: (observableResult: any) => void, description?: any): ObservableGauge;

package/dist/src/StandardMeter.js

@@ -0,0 +1,109 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandardMeterInitTelemetry = StandardMeterInitTelemetry;
+exports.StandardMeterCreateCounter = StandardMeterCreateCounter;
+exports.StandardMeterCreateUpDownCounter = StandardMeterCreateUpDownCounter;
+exports.StandardMeterCreateHistorgram = StandardMeterCreateHistorgram;
+exports.StandardMeterCreateObservableGauge = StandardMeterCreateObservableGauge;
+const exporter_metrics_otlp_http_1 = require("@opentelemetry/exporter-metrics-otlp-http");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_metrics_1 = require("@opentelemetry/sdk-metrics");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const os = __importStar(require("os"));
+let meterProvider;
+let config;
+const METER_NAME = "default";
+//
+function StandardMeterInitTelemetry(initConfig) {
+    config = initConfig;
+    // Metrics
+    if (config.OPENTELEMETRY_COLLECTOR_HTTP_METRICS) {
+        const collectorOptions = {
+            url: config.OPENTELEMETRY_COLLECTOR_HTTP_METRICS,
+            headers: {},
+            concurrencyLimit: 1,
+        };
+        if (config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER) {
+            collectorOptions.headers["Authorization"] = `Bearer ${config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER}`;
+        }
+        const metricExporter = new exporter_metrics_otlp_http_1.OTLPMetricExporter(collectorOptions);
+        meterProvider = new sdk_metrics_1.MeterProvider({
+            resource: (0, resources_1.resourceFromAttributes)({
+                [semantic_conventions_1.ATTR_SERVICE_NAME]: `${config.SERVICE_ID}`,
+                [semantic_conventions_1.ATTR_SERVICE_VERSION]: `${config.VERSION}`,
+                [semantic_conventions_1.ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+            }),
+            readers: [
+                new sdk_metrics_1.PeriodicExportingMetricReader({
+                    exporter: metricExporter,
+                    exportIntervalMillis: config.OPENTELEMETRY_COLLECTOR_EXPORT_METRICS_INTERVAL_SECONDS *
+                        1000,
+                }),
+            ],
+        });
+    }
+    else {
+        meterProvider = new sdk_metrics_1.MeterProvider({
+            resource: (0, resources_1.resourceFromAttributes)({
+                [semantic_conventions_1.ATTR_SERVICE_NAME]: `${config.SERVICE_ID}`,
+                [semantic_conventions_1.ATTR_SERVICE_VERSION]: `${config.VERSION}`,
+                [semantic_conventions_1.ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+            }),
+        });
+    }
+}
+function StandardMeterCreateCounter(key) {
+    const meter = meterProvider.getMeter(METER_NAME);
+    return meter.createCounter(`${config.SERVICE_ID}.${key}`);
+}
+function StandardMeterCreateUpDownCounter(key) {
+    const meter = meterProvider.getMeter(METER_NAME);
+    return meter.createUpDownCounter(`${config.SERVICE_ID}.${key}`);
+}
+function StandardMeterCreateHistorgram(key) {
+    const meter = meterProvider.getMeter(METER_NAME);
+    return meter.createHistogram(`${config.SERVICE_ID}.${key}`);
+}
+function StandardMeterCreateObservableGauge(key, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+callback, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+description = null) {
+    const meter = meterProvider.getMeter(METER_NAME);
+    const observableGauge = meter.createObservableGauge(key, description);
+    observableGauge.addCallback(callback);
+    return observableGauge;
+}

package/dist/src/StandardTracer.d.ts

@@ -0,0 +1,7 @@
+import { Span } from "@opentelemetry/sdk-trace-base";
+import { ConfigInterface } from "./models/ConfigInterface";
+export declare function StandardTracerInitTelemetry(initConfig: ConfigInterface): void;
+export declare function StandardTracerGetSpanFromRequest(req: any): Span;
+export declare function StandardTracerStartSpan(name: string, parentSpan?: Span): Span;
+export declare function StandardTracerGetTracer(): any;
+export declare function StandardTracerAppendHeader(context: Span, headers?: {}): any;

package/dist/src/StandardTracer.js

@@ -0,0 +1,115 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StandardTracerInitTelemetry = StandardTracerInitTelemetry;
+exports.StandardTracerGetSpanFromRequest = StandardTracerGetSpanFromRequest;
+exports.StandardTracerStartSpan = StandardTracerStartSpan;
+exports.StandardTracerGetTracer = StandardTracerGetTracer;
+exports.StandardTracerAppendHeader = StandardTracerAppendHeader;
+const api_1 = __importStar(require("@opentelemetry/api"));
+const context_async_hooks_1 = require("@opentelemetry/context-async-hooks");
+const core_1 = require("@opentelemetry/core");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const id_generator_aws_xray_1 = require("@opentelemetry/id-generator-aws-xray");
+const resources_1 = require("@opentelemetry/resources");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+const sdk_trace_node_1 = require("@opentelemetry/sdk-trace-node");
+const semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+const os = __importStar(require("os"));
+let tracerInstance;
+const propagator = new core_1.W3CTraceContextPropagator();
+let config;
+//
+function StandardTracerInitTelemetry(initConfig) {
+    config = initConfig;
+    const spanProcessors = [];
+    if (config.OPENTELEMETRY_COLLECTOR_HTTP_TRACES) {
+        const exporterHeaders = {};
+        if (config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER) {
+            exporterHeaders["Authorization"] = `Bearer ${config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER}`;
+        }
+        const exporter = new exporter_trace_otlp_http_1.OTLPTraceExporter({
+            url: config.OPENTELEMETRY_COLLECTOR_HTTP_TRACES,
+            headers: exporterHeaders,
+        });
+        spanProcessors.push(new sdk_trace_base_1.BatchSpanProcessor(exporter));
+    }
+    const traceProvider = new sdk_trace_node_1.NodeTracerProvider({
+        idGenerator: new id_generator_aws_xray_1.AWSXRayIdGenerator(),
+        resource: (0, resources_1.resourceFromAttributes)({
+            [semantic_conventions_1.ATTR_SERVICE_NAME]: `${config.SERVICE_ID}`,
+            [semantic_conventions_1.ATTR_SERVICE_VERSION]: `${config.VERSION}`,
+            [semantic_conventions_1.ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+        }),
+        spanProcessors,
+    });
+    traceProvider.register();
+    const contextManager = new context_async_hooks_1.AsyncHooksContextManager();
+    contextManager.enable();
+    api_1.default.context.setGlobalContextManager(contextManager);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function StandardTracerGetSpanFromRequest(req) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return req.tracerSpanApi;
+}
+function StandardTracerStartSpan(name, parentSpan) {
+    const sanitizedName = String(name).replace(/[^a-zA-Z0-9-_/]/g, "_");
+    const tracer = StandardTracerGetTracer();
+    if (parentSpan) {
+        return tracer.startSpan(sanitizedName, undefined, api_1.default.trace.setSpan(api_1.default.context.active(), parentSpan));
+    }
+    const span = tracer.startSpan(sanitizedName);
+    span.setAttribute(semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD, `BACKEND`);
+    span.setAttribute(semantic_conventions_1.ATTR_HTTP_ROUTE, `${config.SERVICE_ID}-${config.VERSION}-${sanitizedName}`);
+    return span;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function StandardTracerGetTracer() {
+    if (!tracerInstance) {
+        tracerInstance = api_1.default.trace.getTracer(`${config.SERVICE_ID}:${config.VERSION}`);
+    }
+    return tracerInstance;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function StandardTracerAppendHeader(context, headers = {}) {
+    if (!headers) {
+        headers = {};
+    }
+    propagator.inject(api_1.trace.setSpanContext(api_1.ROOT_CONTEXT, context.spanContext()), 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    headers, api_1.defaultTextMapSetter);
+    return headers;
+}

package/dist/src/SystemCommand.d.ts

@@ -0,0 +1 @@
+export declare function SystemCommandExecute(command: string, options?: {}): Promise<string>;

package/dist/src/SystemCommand.js

@@ -0,0 +1,50 @@
+"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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemCommandExecute = SystemCommandExecute;
+const childProcess = __importStar(require("child_process"));
+function SystemCommandExecute(command, options = {}) {
+    const exec = childProcess.exec;
+    return new Promise((resolve, reject) => {
+        exec(command, options, (error, stdout) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+    });
+}

package/dist/src/Timeout.d.ts

@@ -0,0 +1 @@
+export declare function TimeoutWait(duration: number): Promise<void>;

package/dist/src/Timeout.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutWait = TimeoutWait;
+function TimeoutWait(duration) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, duration);
+    });
+}

package/dist/src/models/ConfigInterface.d.ts

@@ -0,0 +1,11 @@
+export interface ConfigInterface {
+    SERVICE_ID: string;
+    VERSION: number;
+    OPENTELEMETRY_COLLECTOR_HTTP_TRACES: string;
+    OPENTELEMETRY_COLLECTOR_HTTP_METRICS: string;
+    OPENTELEMETRY_COLLECTOR_HTTP_LOGS: string;
+    OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS: number;
+    OPENTELEMETRY_COLLECTOR_EXPORT_METRICS_INTERVAL_SECONDS: number;
+    OPENTELEMETRY_COLLECTOR_AWS: boolean;
+    OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER: string;
+}

package/dist/src/models/ConfigInterface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/index.ts

@@ -0,0 +1,7 @@
+// Entry point for the otel-utils npm package
+// Export all modules from src
+
+export * from "./src/Logger";
+export * from "./src/StandardMeter";
+export * from "./src/StandardTracer";
+export * as models from "./src/models/ConfigInterface";

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@devopsplaybook.io/otel-utils",
+  "version": "1.0.0",
+  "description": "Utility to simplify integration with Open Telemetry",
+  "keywords": [
+    "Open",
+    "Telemetry",
+    "Traces",
+    "Logs",
+    "Metrics"
+  ],
+  "license": "ISC",
+  "author": "",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/api-logs": "^0.203.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.62.0",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.203.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.203.0",
+    "@opentelemetry/id-generator-aws-xray": "^2.0.0",
+    "@opentelemetry/resources": "^2.0.1",
+    "@opentelemetry/sdk-logs": "^0.203.0",
+    "@opentelemetry/sdk-node": "^0.203.0",
+    "@opentelemetry/sdk-trace-base": "^2.0.1",
+    "@opentelemetry/sdk-trace-web": "^2.0.1",
+    "@opentelemetry/semantic-conventions": "^1.36.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "@types/sqlite3": "^3.1.11"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/Logger.ts

@@ -0,0 +1,120 @@
+import type { Logger as OTelLogger } from "@opentelemetry/api-logs";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+import { OTLPLogExporter } from "@opentelemetry/exporter-logs-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  BatchLogRecordProcessor,
+  LoggerProvider,
+} from "@opentelemetry/sdk-logs";
+import { Span } from "@opentelemetry/sdk-trace-base";
+import {
+  ATTR_NETWORK_LOCAL_ADDRESS,
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION,
+} from "@opentelemetry/semantic-conventions";
+import * as os from "os";
+import { ConfigInterface } from "./models/ConfigInterface";
+import { StandardTracerStartSpan } from "./StandardTracer";
+
+let loggerOTel: OTelLogger;
+
+export function LoggerInit(context: Span, config: ConfigInterface) {
+  const span = StandardTracerStartSpan("LoggerInit", context);
+
+  if (config.OPENTELEMETRY_COLLECTOR_HTTP_LOGS) {
+    const exporterHeaders: Record<string, string> = {};
+    if (config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER) {
+      exporterHeaders[
+        "Authorization"
+      ] = `Bearer ${config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER}`;
+    }
+    const exporter = new OTLPLogExporter({
+      url: config.OPENTELEMETRY_COLLECTOR_HTTP_LOGS,
+      headers: exporterHeaders,
+    });
+
+    const loggerProvider = new LoggerProvider({
+      processors: [
+        new BatchLogRecordProcessor(exporter, {
+          maxQueueSize: 100,
+          scheduledDelayMillis:
+            config.OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS * 1000,
+        }),
+      ],
+      resource: resourceFromAttributes({
+        [ATTR_SERVICE_NAME]: `${config.SERVICE_ID}`,
+        [ATTR_SERVICE_VERSION]: `${config.VERSION}`,
+        [ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+      }),
+    });
+
+    loggerOTel = loggerProvider.getLogger(
+      `${config.SERVICE_ID}:${config.VERSION}`
+    );
+  }
+  span.end();
+}
+
+const DEV_MODE = (() => {
+  if (process.env.NODE_ENV === "dev") {
+    return true;
+  }
+  return false;
+})();
+
+export class Logger {
+  private module: string;
+
+  constructor(module: string) {
+    this.module = `${module}`;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public debug(message: Error | string | any): void {
+    if (DEV_MODE) {
+      this.display("debug", message, SeverityNumber.DEBUG);
+    }
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public info(message: Error | string | any): void {
+    this.display("info", message, SeverityNumber.WARN);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public warn(message: Error | string | any): void {
+    this.display("warn", message, SeverityNumber.WARN);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public error(message: Error | string | any): void {
+    this.display("error", message, SeverityNumber.ERROR);
+  }
+
+  private display(
+    level: string,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    message: any,
+    severityNumber = SeverityNumber.INFO
+  ): void {
+    if (typeof message === "string") {
+      // eslint:disable-next-line:no-console
+      console.log(`[${level}] [${this.module}] ${message}`);
+    } else if (message instanceof Error) {
+      // eslint:disable-next-line:no-console
+      console.log(`${level} [${this.module}] ${message}`);
+      // eslint:disable-next-line:no-console
+      console.log((message as Error).stack);
+    } else if (typeof message === "object") {
+      // eslint:disable-next-line:no-console
+      console.log(`${level} [${this.module}] ${JSON.stringify(message)}`);
+    }
+    if (loggerOTel) {
+      {
+        loggerOTel.emit({
+          severityNumber,
+          severityText: level,
+          body: message,
+          attributes: { "log.type": "custom" },
+        });
+      }
+    }
+  }
+}

package/src/StandardMeter.ts

@@ -0,0 +1,91 @@
+import { Counter, Histogram, ObservableGauge } from "@opentelemetry/api";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import {
+  MeterProvider,
+  PeriodicExportingMetricReader,
+} from "@opentelemetry/sdk-metrics";
+import {
+  ATTR_NETWORK_LOCAL_ADDRESS,
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION,
+} from "@opentelemetry/semantic-conventions";
+import * as os from "os";
+import { ConfigInterface } from "./models/ConfigInterface";
+
+let meterProvider: MeterProvider;
+let config: ConfigInterface;
+const METER_NAME = "default";
+
+//
+export function StandardMeterInitTelemetry(initConfig: ConfigInterface) {
+  config = initConfig;
+
+  // Metrics
+  if (config.OPENTELEMETRY_COLLECTOR_HTTP_METRICS) {
+    const collectorOptions = {
+      url: config.OPENTELEMETRY_COLLECTOR_HTTP_METRICS,
+      headers: {} as Record<string, string>,
+      concurrencyLimit: 1,
+    };
+    if (config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER) {
+      collectorOptions.headers[
+        "Authorization"
+      ] = `Bearer ${config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER}`;
+    }
+    const metricExporter = new OTLPMetricExporter(collectorOptions);
+    meterProvider = new MeterProvider({
+      resource: resourceFromAttributes({
+        [ATTR_SERVICE_NAME]: `${config.SERVICE_ID}`,
+        [ATTR_SERVICE_VERSION]: `${config.VERSION}`,
+        [ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+      }),
+      readers: [
+        new PeriodicExportingMetricReader({
+          exporter: metricExporter,
+          exportIntervalMillis:
+            config.OPENTELEMETRY_COLLECTOR_EXPORT_METRICS_INTERVAL_SECONDS *
+            1000,
+        }),
+      ],
+    });
+  } else {
+    meterProvider = new MeterProvider({
+      resource: resourceFromAttributes({
+        [ATTR_SERVICE_NAME]: `${config.SERVICE_ID}`,
+        [ATTR_SERVICE_VERSION]: `${config.VERSION}`,
+        [ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+      }),
+    });
+  }
+}
+
+export function StandardMeterCreateCounter(key: string): Counter {
+  const meter = meterProvider.getMeter(METER_NAME);
+  return meter.createCounter(`${config.SERVICE_ID}.${key}`);
+}
+
+export function StandardMeterCreateUpDownCounter(key: string): Counter {
+  const meter = meterProvider.getMeter(METER_NAME);
+  return meter.createUpDownCounter(`${config.SERVICE_ID}.${key}`);
+}
+
+export function StandardMeterCreateHistorgram(key: string): Histogram {
+  const meter = meterProvider.getMeter(METER_NAME);
+  return meter.createHistogram(`${config.SERVICE_ID}.${key}`);
+}
+
+export function StandardMeterCreateObservableGauge(
+  key: string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  callback: (observableResult: any) => void,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  description: any = null
+): ObservableGauge {
+  const meter = meterProvider.getMeter(METER_NAME);
+  const observableGauge = meter.createObservableGauge(key, description);
+
+  observableGauge.addCallback(callback);
+
+  return observableGauge;
+}

package/src/StandardTracer.ts

@@ -0,0 +1,111 @@
+import opentelemetry, {
+  defaultTextMapSetter,
+  ROOT_CONTEXT,
+  trace,
+  Tracer,
+} from "@opentelemetry/api";
+import { AsyncHooksContextManager } from "@opentelemetry/context-async-hooks";
+import { W3CTraceContextPropagator } from "@opentelemetry/core";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { AWSXRayIdGenerator } from "@opentelemetry/id-generator-aws-xray";
+import { resourceFromAttributes } from "@opentelemetry/resources";
+import { BatchSpanProcessor, Span } from "@opentelemetry/sdk-trace-base";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import {
+  ATTR_HTTP_REQUEST_METHOD,
+  ATTR_HTTP_ROUTE,
+  ATTR_NETWORK_LOCAL_ADDRESS,
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION,
+} from "@opentelemetry/semantic-conventions";
+import * as os from "os";
+import { ConfigInterface } from "./models/ConfigInterface";
+
+let tracerInstance: Tracer;
+const propagator = new W3CTraceContextPropagator();
+let config: ConfigInterface;
+
+//
+export function StandardTracerInitTelemetry(initConfig: ConfigInterface) {
+  config = initConfig;
+  const spanProcessors = [];
+
+  if (config.OPENTELEMETRY_COLLECTOR_HTTP_TRACES) {
+    const exporterHeaders: Record<string, string> = {};
+    if (config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER) {
+      exporterHeaders[
+        "Authorization"
+      ] = `Bearer ${config.OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER}`;
+    }
+    const exporter = new OTLPTraceExporter({
+      url: config.OPENTELEMETRY_COLLECTOR_HTTP_TRACES,
+      headers: exporterHeaders,
+    });
+    spanProcessors.push(new BatchSpanProcessor(exporter));
+  }
+  const traceProvider = new NodeTracerProvider({
+    idGenerator: new AWSXRayIdGenerator(),
+    resource: resourceFromAttributes({
+      [ATTR_SERVICE_NAME]: `${config.SERVICE_ID}`,
+      [ATTR_SERVICE_VERSION]: `${config.VERSION}`,
+      [ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+    }),
+    spanProcessors,
+  });
+  traceProvider.register();
+  const contextManager = new AsyncHooksContextManager();
+  contextManager.enable();
+  opentelemetry.context.setGlobalContextManager(contextManager);
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function StandardTracerGetSpanFromRequest(req: any): Span {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return (req as any).tracerSpanApi as Span;
+}
+
+export function StandardTracerStartSpan(name: string, parentSpan?: Span): Span {
+  const sanitizedName = String(name).replace(/[^a-zA-Z0-9-_/]/g, "_");
+  const tracer = StandardTracerGetTracer();
+
+  if (parentSpan) {
+    return tracer.startSpan(
+      sanitizedName,
+      undefined,
+      opentelemetry.trace.setSpan(opentelemetry.context.active(), parentSpan)
+    ) as Span;
+  }
+
+  const span = tracer.startSpan(sanitizedName) as Span;
+
+  span.setAttribute(ATTR_HTTP_REQUEST_METHOD, `BACKEND`);
+  span.setAttribute(
+    ATTR_HTTP_ROUTE,
+    `${config.SERVICE_ID}-${config.VERSION}-${sanitizedName}`
+  );
+  return span;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function StandardTracerGetTracer(): any {
+  if (!tracerInstance) {
+    tracerInstance = opentelemetry.trace.getTracer(
+      `${config.SERVICE_ID}:${config.VERSION}`
+    );
+  }
+  return tracerInstance;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function StandardTracerAppendHeader(context: Span, headers = {}): any {
+  if (!headers) {
+    headers = {};
+  }
+  propagator.inject(
+    trace.setSpanContext(ROOT_CONTEXT, context.spanContext()),
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    headers as any,
+    defaultTextMapSetter
+  );
+  return headers;
+}

package/src/models/ConfigInterface.ts

@@ -0,0 +1,11 @@
+export interface ConfigInterface {
+  SERVICE_ID: string;
+  VERSION: number;
+  OPENTELEMETRY_COLLECTOR_HTTP_TRACES: string;
+  OPENTELEMETRY_COLLECTOR_HTTP_METRICS: string;
+  OPENTELEMETRY_COLLECTOR_HTTP_LOGS: string;
+  OPENTELEMETRY_COLLECTOR_EXPORT_LOGS_INTERVAL_SECONDS: number;
+  OPENTELEMETRY_COLLECTOR_EXPORT_METRICS_INTERVAL_SECONDS: number;
+  OPENTELEMETRY_COLLECTOR_AWS: boolean;
+  OPENTELEMETRY_COLLECT_AUTHORIZATION_HEADER: string;
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2019",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["index.ts", "src/**/*"]
+}