@arnob-b/observability 1.0.0

package/README.md

@@ -0,0 +1 @@
+# Observability 

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@arnob-b/observability",
+  "version": "1.0.0",
+  "description": "observability for nodejs application using winston and opentelemetry",
+  "keywords": ["observability", "nodejs", "winston", "opentelemetry", "electron", "desktop application"],
+  "license": "MIT",
+  "author": "Arnob Bhakta",
+  "main": "./src/index.js",
+  "type": "commonjs",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "peerDependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/instrumentation-undici": "^0.21.0",
+    "@opentelemetry/sdk-node": "^0.212.0",
+    "winston": "^3.19.0",
+    "winston-daily-rotate-file": "^5.0.0"
+  },
+  "devDependencies": {
+    "@opentelemetry/instrumentation-express": "^0.59.0",
+    "@opentelemetry/instrumentation-http": "^0.212.0"
+  }
+}

package/src/formats/index.js

@@ -0,0 +1,6 @@
+const {traceContextFormat} = require("./traceContext.format.js");
+
+
+module.exports = {
+	traceContextFormat
+}

package/src/formats/traceContext.format.js

@@ -0,0 +1,12 @@
+const winston = require('winston');
+const {getActiveIds} = require('./../otel');
+
+const traceContextFormat = winston.format((info) => {
+  const context = getActiveIds();
+  if (context) {
+		info.context = context
+  }
+  return info;
+});
+
+module.exports = {traceContextFormat};

package/src/helper/index.js

@@ -0,0 +1,17 @@
+function normalizeData(data){
+	if (data === null || data === undefined) {
+		return '';
+	}
+	if (data instanceof Error) {
+		data = {
+			name: data.name,
+			message: data.message,
+			stack: data.stack
+		};
+	}
+	return data;
+}
+
+module.exports = { 
+	normalizeData
+};

package/src/helper/instrumentBuilder.otel.js

@@ -0,0 +1,24 @@
+const { HttpInstrumentation } = require("@opentelemetry/instrumentation-http");
+const { ExpressInstrumentation } = require("@opentelemetry/instrumentation-express");
+
+const { UndiciInstrumentation } = require('@opentelemetry/instrumentation-undici');
+
+
+function buildInstrumentations(INSTRUMENT_CONFIG = {}) {
+  const list = [];
+
+	if (INSTRUMENT_CONFIG.HTTP) {
+		list.push(new HttpInstrumentation());
+	}
+	if (INSTRUMENT_CONFIG.EXPRESS) {
+		list.push(new ExpressInstrumentation());
+	}
+	if (INSTRUMENT_CONFIG.UNDICI) {
+		list.push(new UndiciInstrumentation());
+	}
+
+  return list;
+}
+
+
+module.exports = { buildInstrumentations };

package/src/helper/transport.builder.js

@@ -0,0 +1,25 @@
+const winston = require('winston')
+const { WatcherTransport, StreamTransport, FileRotationTransport } = require("../transports");
+
+
+function buildTransports(CONFIG = {}) {
+  const list = {};
+
+	if (CONFIG.CONSOLE && CONFIG.CONSOLE.ENABLED) {
+		list[CONFIG.CONSOLE.NAME] = new winston.transports.Console(CONFIG.CONSOLE);
+	}
+	if (CONFIG.WATCHER && CONFIG.WATCHER.ENABLED) {
+		list[CONFIG.WATCHER.NAME] = new WatcherTransport(CONFIG.WATCHER);
+	}
+	if (CONFIG.FILE && CONFIG.FILE.ENABLED) {
+		list[CONFIG.FILE.NAME] = FileRotationTransport(CONFIG.FILE)
+	}
+	if (CONFIG.STREAM && CONFIG.STREAM.ENABLED) {
+		list[CONFIG.STREAM.NAME] = new StreamTransport(CONFIG.STREAM);
+	}
+
+  return list;
+}
+
+
+module.exports = { buildTransports };

package/src/index.js

@@ -0,0 +1,12 @@
+const { traceExecution, traceAsyncExecution, startTracedExecution } = require("./otel");
+const {attachHooksOnTransport} = require("./logger");
+const Observability = require("./observability");
+
+
+module.exports = {
+	Observability,
+	traceExecution,
+	traceAsyncExecution,
+	startTracedExecution,
+	attachHooksOnTransport
+}

package/src/logger.js

@@ -0,0 +1,45 @@
+const winston = require("winston");
+const {traceContextFormat} = require("./formats");
+const { buildTransports } = require("./helper/transport.builder");
+
+
+let logger = null;
+let transports = null;
+
+function initLogger(LOG_CONFIG){
+	if (logger) {
+		console.warn("Logger already initialized. Returning existing instance.");
+		return logger;
+	}
+
+	transports = buildTransports(LOG_CONFIG.TRANSPORTS);
+	logger = winston.createLogger({
+		level: LOG_CONFIG.LEVEL,
+		format: winston.format.combine(
+			traceContextFormat(),
+			winston.format.timestamp(),
+			winston.format.json()
+		),
+		transports: Object.values(transports)
+	})
+	console.log("Logger initialized");
+	return logger
+};
+
+
+function attachHooksOnTransport(transportName, hooks = {}){
+	if (!transports || !transports[transportName]) {
+		console.warn(`Transport ${transportName} not found. Cannot attach hooks.`);
+		return;
+	}
+	const transport = transports[transportName];
+	for(const event of Object.keys(hooks)){
+		transport.on(event, hooks[event]);
+	}
+}
+
+
+module.exports = {
+	initLogger,
+	attachHooksOnTransport
+}

package/src/observability.js

@@ -0,0 +1,34 @@
+const {initOtel} = require("./otel");
+const {initLogger} = require("./logger");
+const { LoggerFactory } = require("./wrappers");
+class Observability {The
+	constructor() {
+		if (Observability.instance) {
+			console.warn("Observability instance already exists. Returning existing instance.");
+			return Observability.instance;
+		}
+
+		this.initialized = false;
+		Observability.instance = this;
+	}
+	async init(config){
+		if (this.initialized) {
+			console.warn("Observability already initialized");
+			return;
+		}
+		initOtel(config.OTEL);
+		this.logger = initLogger(config.LOG);
+
+		this.initialized = true;
+	}
+	getLogger(loggerName){
+		if (!this.initialized) {
+			console.warn("Observability not initialized. Call init() first.");
+			return null;
+		}
+		return LoggerFactory(loggerName, this.logger);
+	}
+}
+
+
+module.exports = new Observability;

package/src/otel/context.otel.js

@@ -0,0 +1,74 @@
+const api = require('@opentelemetry/api');
+const {getTracer, getActiveSpan} = require('./init.otel');
+
+function startTracedExecution(name, fn) {
+  const tracer = getTracer();
+  return tracer.startActiveSpan(name, async span => {
+    try {
+      return await fn();
+    } finally {
+      span.end();
+    }
+  });
+}
+
+function traceExecution(name, fn) {
+	const tracer = getTracer();
+	return function(...args) {
+		return tracer.startActiveSpan(name, (span) => {
+			try{
+				const result = fn.apply(this, args);
+				return result;
+			}catch(err){
+				// span.recordException(err);
+				// span.setStatus({ code: api.SpanStatusCode.ERROR, message: err.message });
+				throw err;
+			}
+			finally{
+				span.end()
+			}
+		});
+	}
+}
+function traceAsyncExecution(name, fn) {
+	const tracer = getTracer();
+	return async function(...args) {
+		return tracer.startActiveSpan(name, async (span) => {
+			try{
+				const result = await fn.apply(this, args);
+				return result;
+			}catch(err){
+				// span.recordException(err);
+				// span.setStatus({ code: api.SpanStatusCode.ERROR, message: err.message });
+				throw err;
+			}
+			finally{
+				span.end()
+			}
+		});
+	}
+}
+
+function getActiveIds() {
+  const span = getActiveSpan();
+  if (!span) return {};
+
+  const ctx = span.spanContext();
+	const parent = span.parentSpanContext;
+
+  return {
+		name:span.name,
+    executionId: ctx.traceId,
+    operationId: ctx.spanId,
+		parentExecutionId: parent?.traceId || null,
+		parentOperationId: parent?.spanId || null,
+  };
+}
+
+
+module.exports = {
+	startTracedExecution,
+	traceExecution,
+	traceAsyncExecution,
+	getActiveIds
+}

package/src/otel/index.js

@@ -0,0 +1,10 @@
+const { initOtel, getTracer , getActiveSpan, shutdownOtel } = require("./init.otel");
+const { startTracedExecution, traceExecution, traceAsyncExecution, getActiveIds } = require("./context.otel");
+
+module.exports = {
+	initOtel, getTracer , getActiveSpan, shutdownOtel,
+	startTracedExecution,
+	traceExecution,
+	traceAsyncExecution,
+	getActiveIds
+}

package/src/otel/init.otel.js

@@ -0,0 +1,48 @@
+const { NodeSDK } = require('@opentelemetry/sdk-node');
+const { trace } = require('@opentelemetry/api');
+const { resourceFromAttributes } = require('@opentelemetry/resources');
+const {
+  ATTR_SERVICE_NAME,
+  ATTR_SERVICE_VERSION,
+} = require('@opentelemetry/semantic-conventions');
+const { UndiciInstrumentation } = require('@opentelemetry/instrumentation-undici');
+const { buildInstrumentations } = require('../helper/instrumentBuilder.otel');
+
+
+let sdk;
+let tracer;
+
+function initOtel(CONFIG) {
+  if (sdk) return;
+
+	const instruments = buildInstrumentations(CONFIG.INSTRUMENTS);
+  sdk = new NodeSDK({
+    resource: resourceFromAttributes({
+      [ATTR_SERVICE_NAME]: CONFIG.SERVICE_NAME,
+      [ATTR_SERVICE_VERSION]: CONFIG.SERVICE_VERSION,
+    }),
+		instrumentations:instruments
+  });
+
+  sdk.start();
+	console.log("Otel initialized for service:", CONFIG.SERVICE_NAME);
+  tracer = trace.getTracer(CONFIG.SERVICE_NAME);
+}
+
+function shutdownOtel() {
+	if (sdk) { sdk.shutdown(); }
+}
+
+function getTracer() {
+  if (!tracer) {
+    throw new Error("Otel not initialized");
+  }
+  return tracer;
+}
+
+function getActiveSpan(){
+	return trace.getActiveSpan()
+}
+
+
+module.exports = {initOtel, getTracer , getActiveSpan, shutdownOtel};

package/src/transports/file.rotation.transport.js

@@ -0,0 +1,40 @@
+const path = require('path');
+const fs = require('fs');
+const DailyRotateFile = require('winston-daily-rotate-file');
+
+const FileRotationTransport = (CONFIG) =>{
+	const transport = new DailyRotateFile({
+		dirname: CONFIG.DIR,
+		filename: CONFIG.PATH,
+		maxSize: CONFIG.SIZE,
+		maxFiles: '14d',
+		zippedArchive: CONFIG.ZIP_ARCHIVE
+	});
+	transport.on('archive', (oldFilename, newFilename) => {
+		const logPath = oldFilename;
+		const info = path.parse(logPath);
+
+		const date = new Date();
+		const timestamp = [
+			date.getUTCHours(),
+			date.getUTCMinutes(),
+			date.getUTCSeconds(),
+			date.getUTCDate(),
+			date.getUTCMonth() + 1,
+			date.getUTCFullYear()
+		]
+			.map(n => String(n).padStart(2, '0'))
+			.join('-');
+
+		try {
+			const fileName = path.join(info.dir, timestamp);
+			const finalPath = fileName + '.log' + info.ext;
+			fs.renameSync(oldFilename, finalPath);
+		} catch (e) {
+			// logger object avoided o prevent recursive logging
+			console.error('Error during log file archiving:', e);
+		}
+	});
+return transport
+}
+module.exports = FileRotationTransport;

package/src/transports/index.js

@@ -0,0 +1,9 @@
+const WatcherTransport = require("./watcher.transport");
+const FileRotationTransport = require("./file.rotation.transport");
+const StreamTransport = require("./stream.transport");
+
+module.exports = {
+	WatcherTransport,
+	StreamTransport,
+	FileRotationTransport,
+}

package/src/transports/stream.transport.js

@@ -0,0 +1,30 @@
+const Transport = require("winston-transport");
+const fs = require("fs");
+
+class StreamTransport extends Transport {
+	constructor(opts = {}) {
+		super(opts);
+		this.url = opts.URL;
+	}
+
+	log(info, callback) {
+		setImmediate(() => this.emit("logged", info));
+
+		try {
+			fetch(this.url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+				},
+				body: JSON.stringify(info),
+			})
+		} catch (e) {
+			// swallow errors to avoid recursive logging
+			console.error("Failed to stream logs", e);[]
+		}
+
+		callback();
+	}
+}
+
+module.exports = StreamTransport;

package/src/transports/watcher.transport.js

@@ -0,0 +1,33 @@
+const Transport = require("winston-transport");
+const fs = require("fs");
+
+class WatcherTransport extends Transport {
+	constructor(opts = {}) {
+		super(opts);
+		this.file = opts.PATH;
+		this.maxSize = opts.SIZE ?? 2 * 1024 * 1024; // 2MB
+	}
+
+	log(info, callback) {
+		setImmediate(() => this.emit("logged", info));
+
+		const line = JSON.stringify(info) + "\n";
+
+		try {
+			if (fs.existsSync(this.file)) {
+				const { size } = fs.statSync(this.file);
+				if (size > this.maxSize) {
+					fs.truncateSync(this.file, 0); // reset
+				}
+			}
+
+			fs.appendFileSync(this.file, line);
+		} catch (e) {
+			// swallow errors to avoid recursive logging
+		}
+
+		callback();
+	}
+}
+
+module.exports = WatcherTransport;

package/src/wrappers/backend.wrapper.js

@@ -0,0 +1,10 @@
+const { normalizeData } = require('../helper');
+
+const log = (logFunction)=> {return {
+	info: (msg, data = null) => logFunction('info', msg, {data:normalizeData(data)}),
+	warn: (msg, data = null) => logFunction('warn', msg, {data:normalizeData(data)}),
+	error: (msg, data = null) => logFunction('error', msg, {data:normalizeData(data)}),
+	debug: (msg, data = null) => logFunction('debug', msg, {data:normalizeData(data)}),
+}};
+
+module.exports =  log;

package/src/wrappers/electron.wrapper.js

@@ -0,0 +1,19 @@
+const {normalizeData} = require('../helper');
+
+const log = (logFunction)=>{
+	return {
+		info: (msg, data = null) => logFunction('info', msg, {process:'main', data:normalizeData(data)}),
+		error: (msg, data = null) => logFunction('warn', msg, {process:'main', data:normalizeData(data)}),
+		debug: (msg, data = null) => logFunction('debug', msg, {process:'main', data:normalizeData(data)}),
+		warn: (msg, data = null) => logFunction('warn', msg, {process:'main', data:normalizeData(data)}),
+
+		renderer: {
+			info: (msg, data) => logFunction('info', msg, {process:'renderer', data:normalizeData(data)}),
+			error: (msg, data) => logFunction('error', msg, {process:'renderer', data:normalizeData(data)}),
+			warn: (msg, data) => logFunction('warn', msg, {process:'renderer', data:normalizeData(data)}),
+			debug: (msg, data) => logFunction('debug', msg, {process:'renderer', data:normalizeData(data)}),
+		}
+	};
+} 
+
+module.exports = log;

package/src/wrappers/factory.js

@@ -0,0 +1,28 @@
+const electronLogger = require("./electron.wrapper");
+const backendLogger = require("./backend.wrapper");
+
+
+
+const LoggerFactory = function (loggerName, logger){
+	const logFunction = (level, message, extra = {}) =>{
+		logger.log({
+			level,
+			message,
+			...extra
+		});
+	}
+	if (loggerName === "default") {
+		return logFunction;
+	}
+	if (loggerName === "electron-application") {
+		return electronLogger(logFunction);
+	}
+	if (loggerName === "backend"){
+		return backendLogger(logFunction);
+	}
+	return logFunction;
+}
+
+
+
+module.exports = LoggerFactory;

package/src/wrappers/index.js

@@ -0,0 +1,4 @@
+const LoggerFactory = require('./factory');
+module.exports = {
+	LoggerFactory
+}