@mhmdhammoud/meritt-utils 1.5.1 → 1.5.3

package/src/lib/logger.ts

@@ -1,7 +1,7 @@
-import {Logger as PinoLogger, pino, stdTimeFunctions} from 'pino'
+import { Logger as PinoLogger, pino, stdTimeFunctions } from 'pino'
 import * as dotenv from 'dotenv'
-import pinoElastic, {Options as ElasticConfig} from 'pino-elasticsearch'
-import {LOG_LEVEL, LogEvent} from '../types'
+import { createElasticTransport } from './elastic-transport'
+import { LOG_LEVEL, LogEvent, ElasticConfig } from '../types'
 
 dotenv.config()
 
@@ -10,50 +10,240 @@ dotenv.config()
  */
 let pinoLogger: PinoLogger
 
+/**
+ * Elasticsearch transport instance - kept for cleanup
+ */
+let esTransport: NodeJS.ReadWriteStream | null = null
+
+/**
+ * Flag to track if shutdown handlers are registered
+ */
+let shutdownHandlersRegistered = false
+
+/**
+ * Validates required Elasticsearch environment variables.
+ * @throws Error if required environment variables are missing.
+ */
+function validateElasticsearchEnv(): void {
+	const required = [
+		'ELASTICSEARCH_NODE',
+		'ELASTICSEARCH_USERNAME',
+		'ELASTICSEARCH_PASSWORD',
+		'SERVER_NICKNAME',
+	]
+	const missing = required.filter((key) => !process.env[key])
+
+	if (missing.length > 0) {
+		throw new Error(
+			`Missing required Elasticsearch environment variables: ${missing.join(', ')}`
+		)
+	}
+}
+
+/**
+ * Safely parses an integer from an environment variable.
+ * @param envValue - The environment variable value to parse.
+ * @param defaultValue - The default value to use if parsing fails.
+ * @param varName - The name of the environment variable (for error messages).
+ * @returns The parsed integer or the default value.
+ * @throws Error if the value is not a valid number.
+ */
+function parseIntEnv(
+	envValue: string | undefined,
+	defaultValue: number,
+	varName: string
+): number {
+	if (!envValue) {
+		return defaultValue
+	}
+
+	const parsed = parseInt(envValue, 10)
+
+	if (isNaN(parsed)) {
+		throw new Error(
+			`Invalid value for ${varName}: "${envValue}" is not a valid number. Using default: ${defaultValue}`
+		)
+	}
+
+	if (parsed < 0) {
+		throw new Error(
+			`Invalid value for ${varName}: "${envValue}" must be a positive number. Using default: ${defaultValue}`
+		)
+	}
+
+	return parsed
+}
+
+/**
+ * Registers shutdown handlers to flush logs before process exits.
+ */
+function registerShutdownHandlers(): void {
+	if (shutdownHandlersRegistered) {
+		return
+	}
+
+	let isShuttingDown = false
+
+	const flushAndExit = async (signal: string, exitCode = 0) => {
+		// Prevent multiple shutdown attempts
+		if (isShuttingDown) {
+			return
+		}
+		isShuttingDown = true
+
+		if (esTransport) {
+			try {
+				// Flush any pending logs
+				await new Promise<void>((resolve) => {
+					const timeout = setTimeout(() => {
+						console.error(`[Logger] Flush timeout after 5s on ${signal}`)
+						resolve()
+					}, 5000) // 5 second timeout
+
+					// Register listener BEFORE calling end() to avoid race condition
+					esTransport?.once('finish', () => {
+						clearTimeout(timeout)
+						resolve()
+					})
+
+					// Now trigger the flush
+					esTransport?.end()
+				})
+			} catch (error) {
+				console.error(`[Logger] Error flushing logs on ${signal}:`, error)
+			}
+		}
+		process.exit(exitCode)
+	}
+
+	process.on('SIGTERM', () => {
+		flushAndExit('SIGTERM', 0).catch((err) => {
+			console.error('[Logger] Flush and exit failed:', err)
+			process.exit(1)
+		})
+	})
+
+	process.on('SIGINT', () => {
+		flushAndExit('SIGINT', 130).catch((err) => {
+			console.error('[Logger] Flush and exit failed:', err)
+			process.exit(1)
+		})
+	})
+
+	process.on('beforeExit', () => {
+		if (esTransport && !isShuttingDown) {
+			esTransport.end()
+		}
+	})
+
+	shutdownHandlersRegistered = true
+}
+
 /**
  * Creates a Pino logger instance with specified Elasticsearch configuration.
  * @param elasticConfig - Optional Elasticsearch configuration.
  * @returns The Pino logger instance.
+ * @throws Error if LOG_LEVEL is invalid or required environment variables are missing.
  */
 function getLogger(elasticConfig?: ElasticConfig): PinoLogger {
 	if (!pinoLogger) {
-		if (isValidLogLevel(process.env.LOG_LEVEL)) {
-			const transports = []
-			if (process.env.NODE_ENV !== 'local' && process.env.NODE_ENV !== 'test') {
-				const esConfig: ElasticConfig = {
-					index: process.env.SERVER_NICKNAME,
-					node: process.env.ELASTICSEARCH_NODE,
-					auth: {
-						username: process.env.ELASTICSEARCH_USERNAME,
-						password: process.env.ELASTICSEARCH_PASSWORD,
-					},
-					flushInterval: 1000,
-					'flush-bytes': 1000,
-				}
-				if (elasticConfig) {
-					Object.assign(esConfig, elasticConfig)
-				}
-
-				const esTransport = pinoElastic(esConfig)
-
-				transports.push(esTransport)
-			} else {
-				transports.push(
-					pino.destination({
-						minLength: 128,
-						sync: false,
-					})
-				)
-			}
+		// Validate log level - will throw if invalid
+		const logLevel = process.env.LOG_LEVEL || 'info'
+		isValidLogLevel(logLevel)
+
+		const transports = []
+		if (process.env.NODE_ENV !== 'local' && process.env.NODE_ENV !== 'test') {
+			// Validate Elasticsearch environment variables
+			validateElasticsearchEnv()
+
+			// Parse flush settings from environment with validation
+			const flushIntervalMs = parseIntEnv(
+				process.env.ES_FLUSH_INTERVAL_MS,
+				2000, // Default: 2 seconds
+				'ES_FLUSH_INTERVAL_MS'
+			)
 
-			pinoLogger = pino(
-				{
-					level: process.env.LOG_LEVEL,
-					timestamp: stdTimeFunctions.isoTime.bind(stdTimeFunctions),
+			const flushBytes = parseIntEnv(
+				process.env.ES_FLUSH_BYTES,
+				100 * 1024, // Default: 100KB
+				'ES_FLUSH_BYTES'
+			)
+
+			const maxRetries = parseIntEnv(
+				process.env.ES_MAX_RETRIES,
+				3, // Default: 3 retries
+				'ES_MAX_RETRIES'
+			)
+
+			const requestTimeout = parseIntEnv(
+				process.env.ES_REQUEST_TIMEOUT_MS,
+				30000, // Default: 30 seconds
+				'ES_REQUEST_TIMEOUT_MS'
+			)
+
+			// Safe to access after validation
+			const esConfig: ElasticConfig = {
+				index: process.env.SERVER_NICKNAME,
+				node: process.env.ELASTICSEARCH_NODE,
+				auth: {
+					username: process.env.ELASTICSEARCH_USERNAME,
+					password: process.env.ELASTICSEARCH_PASSWORD,
 				},
-				...transports
+				// Configurable flush settings
+				flushInterval: flushIntervalMs,
+				'flush-bytes': flushBytes,
+				// Retry configuration for connection resilience
+				maxRetries: maxRetries,
+				requestTimeout: requestTimeout,
+				// Automatically reconnect on connection faults
+				sniffOnConnectionFault: true,
+			}
+			if (elasticConfig) {
+				Object.assign(esConfig, elasticConfig)
+			}
+
+			// Create transport with connection lifecycle fix (pino-elasticsearch #140)
+			esTransport = createElasticTransport(esConfig)
+
+			// Handle Elasticsearch connection errors
+			esTransport.on('error', (err: Error) => {
+				console.error('[Logger] Elasticsearch transport error:', err.message)
+				console.error(
+					'[Logger] Logs may not be reaching Kibana. Check Elasticsearch connection.'
+				)
+			})
+
+			// Handle insert errors (document indexing failures)
+			esTransport.on('insertError', (err: Error) => {
+				console.error('[Logger] Elasticsearch insert error:', err.message)
+				console.error('[Logger] Some logs failed to index to Elasticsearch.')
+			})
+
+			// Log successful connection (for debugging)
+			esTransport.on('insert', () => {
+				// Uncomment for debugging: console.log(`[Logger] Successfully inserted log entries`)
+			})
+
+			// Register shutdown handlers to flush logs on process exit
+			registerShutdownHandlers()
+
+			transports.push(esTransport)
+		} else {
+			transports.push(
+				pino.destination({
+					minLength: 1024,
+					sync: true,
+				})
 			)
 		}
+
+		pinoLogger = pino(
+			{
+				level: logLevel,
+				timestamp: stdTimeFunctions.isoTime.bind(stdTimeFunctions),
+			},
+			...transports
+		)
 	}
 	return pinoLogger
 }
@@ -103,8 +293,7 @@ class Logger {
 		if (process.env.NODE_ENV === 'local' || process.env.NODE_ENV === 'test') {
 			detail = args
 		} else {
-			//@ts-ignore
-			detail = JSON.stringify(...args)
+			detail = JSON.stringify(args)
 		}
 		this._logger[logLevel]({
 			component: this._name,

package/src/lib/pdf.ts

@@ -1,4 +1,4 @@
-import {AxiosInstance} from '../utilities'
+// import { AxiosInstance } from '../utilities'
 /*
 	 Author : Mustafa Halabi https://github.com/mustafahalabi
 	 Date : 2023-06-24
@@ -16,7 +16,7 @@ class Pdf {
 	 * // => 'Hello-World'
 	 * ```
 	 * */
-	getBase64Images = (url: string): string => {
+	getBase64Images = (_url: string): string => {
 		return ''
 	}
 }

package/src/types/logger.ts

@@ -46,4 +46,21 @@ export interface ElasticConfig {
 	 * The interval (in milliseconds) at which logs are flushed to Elasticsearch.
 	 */
 	flushInterval?: number
+	/**
+	 * The number of bytes to buffer before flushing to Elasticsearch.
+	 */
+	'flush-bytes'?: number
+	/**
+	 * Maximum number of retries for failed Elasticsearch requests.
+	 */
+	maxRetries?: number
+	/**
+	 * Request timeout in milliseconds before considering a request failed.
+	 */
+	requestTimeout?: number
+	/**
+	 * Whether to sniff for additional Elasticsearch nodes on connection fault.
+	 * Enables automatic reconnection when a node fails.
+	 */
+	sniffOnConnectionFault?: boolean
 }

package/src/utilities/index.ts

@@ -1 +1 @@
-export {default as AxiosInstance} from './axios'
+export { default as AxiosInstance } from './axios'

package/.eslintignore

@@ -1,2 +0,0 @@
-*.d.ts
-dist

package/.eslintrc.js

@@ -1,28 +0,0 @@
-module.exports = {
-	plugins: ['@typescript-eslint/eslint-plugin', 'eslint-plugin-tsdoc'],
-	extends: ['eslint:recommended', 'plugin:@typescript-eslint/recommended'],
-	parser: '@typescript-eslint/parser',
-	parserOptions: {
-		project: './tsconfig.json',
-		tsconfigRootDir: __dirname,
-		ecmaVersion: 2018,
-		sourceType: 'module',
-	},
-	rules: {
-		'tsdoc/syntax': 'warn',
-		'@typescript-eslint/ban-ts-comment': 'off',
-		'@typescript-eslint/ban-types': 'off',
-		'@typescript-eslint/no-namespace': 'off',
-		'@typescript-eslint/no-unused-vars': [
-			'warn',
-			{
-				vars: 'all',
-				args: 'after-used',
-				ignoreRestSiblings: true,
-			},
-		],
-		'@typescript-eslint/no-explicit-any': 'off',
-		'no-async-promise-executor': 'off',
-	},
-	root: true,
-}