@devopsplaybook.io/otel-utils 1.0.1-beta3 → 1.0.1-beta5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 devopsplaybook.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# otel-utils

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export * from "./src/Logger";
+export * from "./src/models/ConfigOTelInterface";
+export * from "./src/ModuleLogger";
+export * from "./src/StandardLogger";
 export * from "./src/StandardMeter";
 export * from "./src/StandardTracer";
-export * from "./src/models/ConfigInterfaceOTel";

package/dist/index.js

@@ -1,6 +1,4 @@
 "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);
@@ -16,7 +14,8 @@ 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);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./src/Logger"), exports);
+__exportStar(require("./src/models/ConfigOTelInterface"), exports);
+__exportStar(require("./src/ModuleLogger"), exports);
+__exportStar(require("./src/StandardLogger"), exports);
 __exportStar(require("./src/StandardMeter"), exports);
 __exportStar(require("./src/StandardTracer"), exports);
-__exportStar(require("./src/models/ConfigInterfaceOTel"), exports);

package/dist/src/ModuleLogger.d.ts

@@ -0,0 +1,10 @@
+import type { Logger } from "@opentelemetry/api-logs";
+export declare class ModuleLogger {
+    private module;
+    private logger?;
+    constructor(module: string, logger?: Logger);
+    info(message: Error | string | any): void;
+    warn(message: Error | string | any): void;
+    error(message: Error | string | any): void;
+    private display;
+}

package/dist/src/ModuleLogger.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleLogger = void 0;
+const api_logs_1 = require("@opentelemetry/api-logs");
+class ModuleLogger {
+    constructor(module, logger) {
+        this.module = module;
+        this.logger = logger;
+    }
+    // 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 (!this.logger) {
+            return;
+        }
+        this.logger.emit({
+            severityNumber,
+            severityText: level,
+            body: message,
+            attributes: { "log.type": "custom" },
+        });
+    }
+}
+exports.ModuleLogger = ModuleLogger;

package/dist/src/StandardLogger.d.ts

@@ -0,0 +1,9 @@
+import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
+import { ModuleLogger } from "./ModuleLogger";
+export declare class StandardLogger {
+    private logger?;
+    private serviceVersion;
+    private serviceName;
+    constructor(config: ConfigOTelInterface);
+    createModuleLogger(moduleName: string): ModuleLogger;
+}

package/dist/src/StandardLogger.js

@@ -0,0 +1,77 @@
+"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.StandardLogger = void 0;
+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 ModuleLogger_1 = require("./ModuleLogger");
+class StandardLogger {
+    constructor(config) {
+        this.serviceName = config.SERVICE_ID;
+        this.serviceVersion = config.VERSION;
+        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]: `${this.serviceName}`,
+                    [semantic_conventions_1.ATTR_SERVICE_VERSION]: `${this.serviceVersion}`,
+                    [semantic_conventions_1.ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+                }),
+            });
+            this.logger = loggerProvider.getLogger(`${this.serviceName}:${this.serviceVersion}`);
+        }
+    }
+    createModuleLogger(moduleName) {
+        return new ModuleLogger_1.ModuleLogger(moduleName, this.logger);
+    }
+}
+exports.StandardLogger = StandardLogger;

package/dist/src/StandardMeter.d.ts

@@ -1,7 +1,12 @@
 import { Counter, Histogram, ObservableGauge } from "@opentelemetry/api";
-import { ConfigInterfaceOTel } from "./models/ConfigInterfaceOTel";
-export declare function StandardMeterInitTelemetry(initConfig: ConfigInterfaceOTel): 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;
+import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
+export declare class StandardMeter {
+    private meter;
+    private serviceVersion;
+    private serviceName;
+    constructor(config: ConfigOTelInterface);
+    createCounter(key: string): Counter;
+    createUpDownCounter(key: string): Counter;
+    createHistogram(key: string): Histogram;
+    createObservableGauge(key: string, callback: (observableResult: any) => void, description?: any): ObservableGauge;
+}

package/dist/src/StandardMeter.js

@@ -33,77 +33,70 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StandardMeterInitTelemetry = StandardMeterInitTelemetry;
-exports.StandardMeterCreateCounter = StandardMeterCreateCounter;
-exports.StandardMeterCreateUpDownCounter = StandardMeterCreateUpDownCounter;
-exports.StandardMeterCreateHistorgram = StandardMeterCreateHistorgram;
-exports.StandardMeterCreateObservableGauge = StandardMeterCreateObservableGauge;
+exports.StandardMeter = void 0;
 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}`;
+class StandardMeter {
+    constructor(config) {
+        this.serviceName = config.SERVICE_ID;
+        this.serviceVersion = config.VERSION;
+        let meterProvider;
+        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]: `${this.serviceName}`,
+                    [semantic_conventions_1.ATTR_SERVICE_VERSION]: `${this.serviceVersion}`,
+                    [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,
+                    }),
+                ],
+            });
         }
-        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]: `${this.serviceName}`,
+                    [semantic_conventions_1.ATTR_SERVICE_VERSION]: `${this.serviceVersion}`,
+                    [semantic_conventions_1.ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
                 }),
-            ],
-        });
+            });
+        }
+        this.meter = meterProvider.getMeter(`${this.serviceName}:${this.serviceVersion}`);
     }
-    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(),
-            }),
-        });
+    createCounter(key) {
+        return this.meter.createCounter(`${this.serviceName}.${key}`);
+    }
+    createUpDownCounter(key) {
+        return this.meter.createUpDownCounter(`${this.serviceName}.${key}`);
+    }
+    createHistogram(key) {
+        return this.meter.createHistogram(`${this.serviceName}.${key}`);
+    }
+    createObservableGauge(key, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    callback, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    description = null) {
+        const observableGauge = this.meter.createObservableGauge(key, description);
+        observableGauge.addCallback(callback);
+        return observableGauge;
     }
 }
-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;
-}
+exports.StandardMeter = StandardMeter;

package/dist/src/StandardTracer.d.ts

@@ -1,6 +1,10 @@
 import { Span } from "@opentelemetry/sdk-trace-base";
-import { ConfigInterfaceOTel } from "./models/ConfigInterfaceOTel";
-export declare function StandardTracerInitTelemetry(initConfig: ConfigInterfaceOTel): void;
-export declare function StandardTracerStartSpan(name: string, parentSpan?: Span): Span;
-export declare function StandardTracerGetTracer(): any;
-export declare function StandardTracerAppendHeader(context: Span, headers?: {}): any;
+import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
+export declare class StandardTracer {
+    private tracer;
+    private serviceVersion;
+    private serviceName;
+    constructor(config: ConfigOTelInterface);
+    startSpan(name: string, parentSpan?: Span): Span;
+    static updateHttpHeader(context: Span, headers?: {}): any;
+}

package/dist/src/StandardTracer.js

@@ -33,10 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StandardTracerInitTelemetry = StandardTracerInitTelemetry;
-exports.StandardTracerStartSpan = StandardTracerStartSpan;
-exports.StandardTracerGetTracer = StandardTracerGetTracer;
-exports.StandardTracerAppendHeader = StandardTracerAppendHeader;
+exports.StandardTracer = void 0;
 const api_1 = __importStar(require("@opentelemetry/api"));
 const context_async_hooks_1 = require("@opentelemetry/context-async-hooks");
 const core_1 = require("@opentelemetry/core");
@@ -47,63 +44,57 @@ 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}`;
+class StandardTracer {
+    constructor(config) {
+        this.serviceName = config.SERVICE_ID;
+        this.serviceVersion = config.VERSION;
+        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 exporter = new exporter_trace_otlp_http_1.OTLPTraceExporter({
-            url: config.OPENTELEMETRY_COLLECTOR_HTTP_TRACES,
-            headers: exporterHeaders,
+        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]: `${this.serviceName}`,
+                [semantic_conventions_1.ATTR_SERVICE_VERSION]: `${this.serviceVersion}`,
+                [semantic_conventions_1.ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+            }),
+            spanProcessors,
         });
-        spanProcessors.push(new sdk_trace_base_1.BatchSpanProcessor(exporter));
+        traceProvider.register();
+        const contextManager = new context_async_hooks_1.AsyncHooksContextManager();
+        contextManager.enable();
+        api_1.default.context.setGlobalContextManager(contextManager);
+        this.tracer = api_1.default.trace.getTracer(`${this.serviceName}:${this.serviceVersion}`);
     }
-    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);
-}
-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 = {};
+    startSpan(name, parentSpan) {
+        const sanitizedName = String(name).replace(/[^a-zA-Z0-9-_/]/g, "_");
+        if (parentSpan) {
+            return this.tracer.startSpan(sanitizedName, undefined, api_1.default.trace.setSpan(api_1.default.context.active(), parentSpan));
+        }
+        const span = this.tracer.startSpan(sanitizedName);
+        span.setAttribute(semantic_conventions_1.ATTR_HTTP_REQUEST_METHOD, `BACKEND`);
+        span.setAttribute(semantic_conventions_1.ATTR_HTTP_ROUTE, `${this.serviceName}-${this.serviceVersion}-${sanitizedName}`);
+        return span;
     }
-    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;
+    static updateHttpHeader(context, headers = {}) {
+        if (!headers) {
+            headers = {};
+        }
+        const propagator = new core_1.W3CTraceContextPropagator();
+        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;
+    }
 }
+exports.StandardTracer = StandardTracer;

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

@@ -0,0 +1,11 @@
+export interface ConfigOTelInterface {
+    SERVICE_ID: string;
+    VERSION: string;
+    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/ConfigOTelInterface.js

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

package/eslint.config.mjs

@@ -0,0 +1,10 @@
+// @ts-check
+
+import eslint from "@eslint/js";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.strict,
+  ...tseslint.configs.stylistic
+);

package/index.ts

@@ -1,7 +1,5 @@
-// Entry point for the otel-utils npm package
-// Export all modules from src
-
-export * from "./src/Logger";
+export * from "./src/models/ConfigOTelInterface";
+export * from "./src/ModuleLogger";
+export * from "./src/StandardLogger";
 export * from "./src/StandardMeter";
 export * from "./src/StandardTracer";
-export * from "./src/models/ConfigInterfaceOTel";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devopsplaybook.io/otel-utils",
-  "version": "1.0.1-beta3",
+  "version": "1.0.1-beta5",
   "description": "Utility to simplify integration with Open Telemetry",
   "keywords": [
     "Open",
@@ -33,8 +33,12 @@
     "@opentelemetry/semantic-conventions": "^1.36.0"
   },
   "devDependencies": {
+    "@eslint/js": "^9.34.0",
     "@types/node": "^24.3.0",
-    "@types/sqlite3": "^5.1.0"
+    "@types/sqlite3": "^5.1.0",
+    "ts-node": "^10.9.2",
+    "typescript-eslint": "^8.40.0",
+    "typescript": "^5.9.2"
   },
   "publishConfig": {
     "access": "public"

package/prettierrc.json

@@ -0,0 +1,5 @@
+{
+  "tabWidth": 2,
+  "semi": true,
+  "singleQuote": false
+}

package/src/ModuleLogger.ts

@@ -0,0 +1,54 @@
+import type { Logger } from "@opentelemetry/api-logs";
+import { SeverityNumber } from "@opentelemetry/api-logs";
+
+export class ModuleLogger {
+  private module: string;
+  private logger?: Logger;
+
+  constructor(module: string, logger?: Logger) {
+    this.module = module;
+    this.logger = logger;
+  }
+
+  // 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 (!this.logger) {
+      return;
+    }
+    this.logger.emit({
+      severityNumber,
+      severityText: level,
+      body: message,
+      attributes: { "log.type": "custom" },
+    });
+  }
+}

package/src/StandardLogger.ts

@@ -0,0 +1,65 @@
+import type { Logger, 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 { ConfigOTelInterface } from "./models/ConfigOTelInterface";
+import { ModuleLogger } from "./ModuleLogger";
+
+export class StandardLogger {
+  private logger?: Logger;
+  private serviceVersion: string;
+  private serviceName: string;
+
+  constructor(config: ConfigOTelInterface) {
+    this.serviceName = config.SERVICE_ID;
+    this.serviceVersion = config.VERSION;
+
+    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]: `${this.serviceName}`,
+          [ATTR_SERVICE_VERSION]: `${this.serviceVersion}`,
+          [ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+        }),
+      });
+
+      this.logger = loggerProvider.getLogger(
+        `${this.serviceName}:${this.serviceVersion}`
+      );
+    }
+  }
+
+  public createModuleLogger(moduleName: string): ModuleLogger {
+    return new ModuleLogger(moduleName, this.logger);
+  }
+}

package/src/StandardMeter.ts

@@ -1,4 +1,4 @@
-import { Counter, Histogram, ObservableGauge } from "@opentelemetry/api";
+import { Counter, Histogram, Meter, ObservableGauge } from "@opentelemetry/api";
 import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
 import { resourceFromAttributes } from "@opentelemetry/resources";
 import {
@@ -11,81 +11,79 @@ import {
   ATTR_SERVICE_VERSION,
 } from "@opentelemetry/semantic-conventions";
 import * as os from "os";
-import { ConfigInterfaceOTel } from "./models/ConfigInterfaceOTel";
+import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
 
-let meterProvider: MeterProvider;
-let config: ConfigInterfaceOTel;
-const METER_NAME = "default";
+export class StandardMeter {
+  private meter: Meter;
+  private serviceVersion: string;
+  private serviceName: string;
 
-//
-export function StandardMeterInitTelemetry(initConfig: ConfigInterfaceOTel) {
-  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,
+  constructor(config: ConfigOTelInterface) {
+    this.serviceName = config.SERVICE_ID;
+    this.serviceVersion = config.VERSION;
+    let meterProvider;
+    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]: `${this.serviceName}`,
+          [ATTR_SERVICE_VERSION]: `${this.serviceVersion}`,
+          [ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
         }),
-      ],
-    });
-  } else {
-    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]: `${this.serviceName}`,
+          [ATTR_SERVICE_VERSION]: `${this.serviceVersion}`,
+          [ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+        }),
+      });
+    }
+    this.meter = meterProvider.getMeter(
+      `${this.serviceName}:${this.serviceVersion}`
+    );
   }
-}
-
-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}`);
-}
+  public createCounter(key: string): Counter {
+    return this.meter.createCounter(`${this.serviceName}.${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);
+  public createUpDownCounter(key: string): Counter {
+    return this.meter.createUpDownCounter(`${this.serviceName}.${key}`);
+  }
 
-  observableGauge.addCallback(callback);
+  public createHistogram(key: string): Histogram {
+    return this.meter.createHistogram(`${this.serviceName}.${key}`);
+  }
 
-  return observableGauge;
+  public createObservableGauge(
+    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 observableGauge = this.meter.createObservableGauge(key, description);
+    observableGauge.addCallback(callback);
+    return observableGauge;
+  }
 }

package/src/StandardTracer.ts

@@ -19,87 +19,79 @@ import {
   ATTR_SERVICE_VERSION,
 } from "@opentelemetry/semantic-conventions";
 import * as os from "os";
-import { ConfigInterfaceOTel } from "./models/ConfigInterfaceOTel";
+import { ConfigOTelInterface } from "./models/ConfigOTelInterface";
 
-let tracerInstance: Tracer;
-const propagator = new W3CTraceContextPropagator();
-let config: ConfigInterfaceOTel;
+export class StandardTracer {
+  private tracer: Tracer;
+  private serviceVersion: string;
+  private serviceName: string;
 
-//
-export function StandardTracerInitTelemetry(initConfig: ConfigInterfaceOTel) {
-  config = initConfig;
-  const spanProcessors = [];
+  constructor(config: ConfigOTelInterface) {
+    this.serviceName = config.SERVICE_ID;
+    this.serviceVersion = config.VERSION;
+    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}`;
+    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 exporter = new OTLPTraceExporter({
-      url: config.OPENTELEMETRY_COLLECTOR_HTTP_TRACES,
-      headers: exporterHeaders,
+    const traceProvider = new NodeTracerProvider({
+      idGenerator: new AWSXRayIdGenerator(),
+      resource: resourceFromAttributes({
+        [ATTR_SERVICE_NAME]: `${this.serviceName}`,
+        [ATTR_SERVICE_VERSION]: `${this.serviceVersion}`,
+        [ATTR_NETWORK_LOCAL_ADDRESS]: os.hostname(),
+      }),
+      spanProcessors,
     });
-    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);
-}
-
-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;
+    traceProvider.register();
+    const contextManager = new AsyncHooksContextManager();
+    contextManager.enable();
+    opentelemetry.context.setGlobalContextManager(contextManager);
+    this.tracer = opentelemetry.trace.getTracer(
+      `${this.serviceName}:${this.serviceVersion}`
+    );
   }
 
-  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}`
+  public startSpan(name: string, parentSpan?: Span): Span {
+    const sanitizedName = String(name).replace(/[^a-zA-Z0-9-_/]/g, "_");
+    if (parentSpan) {
+      return this.tracer.startSpan(
+        sanitizedName,
+        undefined,
+        opentelemetry.trace.setSpan(opentelemetry.context.active(), parentSpan)
+      ) as Span;
+    }
+    const span = this.tracer.startSpan(sanitizedName) as Span;
+    span.setAttribute(ATTR_HTTP_REQUEST_METHOD, `BACKEND`);
+    span.setAttribute(
+      ATTR_HTTP_ROUTE,
+      `${this.serviceName}-${this.serviceVersion}-${sanitizedName}`
     );
+    return span;
   }
-  return tracerInstance;
-}
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function StandardTracerAppendHeader(context: Span, headers = {}): any {
-  if (!headers) {
-    headers = {};
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  public static updateHttpHeader(context: Span, headers = {}): any {
+    if (!headers) {
+      headers = {};
+    }
+    const propagator = new W3CTraceContextPropagator();
+    propagator.inject(
+      trace.setSpanContext(ROOT_CONTEXT, context.spanContext()),
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      headers as any,
+      defaultTextMapSetter
+    );
+    return 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/{ConfigInterfaceOTel.ts → ConfigOTelInterface.ts}

@@ -1,6 +1,6 @@
-export interface ConfigInterfaceOTel {
+export interface ConfigOTelInterface {
   SERVICE_ID: string;
-  VERSION: number;
+  VERSION: string;
   OPENTELEMETRY_COLLECTOR_HTTP_TRACES: string;
   OPENTELEMETRY_COLLECTOR_HTTP_METRICS: string;
   OPENTELEMETRY_COLLECTOR_HTTP_LOGS: string;

package/src/Logger.ts

@@ -1,120 +0,0 @@
-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 { ConfigInterfaceOTel } from "./models/ConfigInterfaceOTel";
-import { StandardTracerStartSpan } from "./StandardTracer";
-
-let loggerOTel: OTelLogger;
-
-export function LoggerInit(context: Span, config: ConfigInterfaceOTel) {
-  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" },
-        });
-      }
-    }
-  }
-}