@devopsplaybook.io/otel-utils 1.0.1-beta4 → 1.0.1-beta6

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/{ConfigInterfaceOTel.d.ts → ConfigOTelInterface.d.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/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-beta4",
+  "version": "1.0.1-beta6",
   "description": "Utility to simplify integration with Open Telemetry",
   "keywords": [
     "Open",

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);
+  }
+}