@bernierllc/logging
Version:
A comprehensive logging package with Winston integration for audit and system logging
220 lines (219 loc) • 7.67 kB
JavaScript
;
/*
Copyright (c) 2025 Bernier LLC
This file is licensed to the client under a limited-use license.
The client may use and modify this code *only within the scope of the project it was delivered for*.
Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.CoreLoggerBridge = void 0;
exports.createCoreSystemLogger = createCoreSystemLogger;
exports.logSystemWithCore = logSystemWithCore;
exports.logErrorWithCore = logErrorWithCore;
exports.logWarnWithCore = logWarnWithCore;
exports.logInfoWithCore = logInfoWithCore;
exports.logDebugWithCore = logDebugWithCore;
const coreLogger_1 = require("./mocks/coreLogger");
/**
* Bridge between Winston-based system logger and core logger with runtime configuration
* This provides backward compatibility while enabling runtime configuration
*/
class CoreLoggerBridge {
coreLogger;
isInitialized = false;
constructor(config) {
// Initialize with default core logger for now
// Runtime configuration will be loaded when first used
this.coreLogger = this.createCoreLoggerFromWinstonConfig(config);
}
/**
* Initialize the bridge with runtime configuration
* This should be called once at application startup
*/
async initializeWithRuntimeConfig() {
if (this.isInitialized)
return;
try {
this.coreLogger = await (0, coreLogger_1.createLoggerFromConfig)();
this.isInitialized = true;
}
catch (error) {
console.warn('Failed to load runtime configuration, using default logger:', error);
// Keep the default logger if runtime config fails
}
}
/**
* Convert Winston config to core logger config
*/
createCoreLoggerFromWinstonConfig(config) {
const { createLogger } = require('./mocks/coreLogger');
// Map Winston config to core logger config
const coreConfig = {
level: this.mapWinstonLevelToCoreLevel(config?.level || process.env.LOG_LEVEL || 'info'),
enableCorrelation: true,
sanitize: true,
context: {
service: 'service-logging',
version: '0.1.12',
environment: process.env.NODE_ENV || 'development',
...config?.defaultMeta
},
transports: {
console: {
enabled: config?.enableConsole ?? (process.env.NODE_ENV !== 'production'),
level: this.mapWinstonLevelToCoreLevel(config?.level || 'debug'),
formatter: 'text'
},
file: {
enabled: config?.enableFile ?? (process.env.NODE_ENV === 'production'),
filename: config?.filePath || './logs/system.log',
level: this.mapWinstonLevelToCoreLevel(config?.level || 'info'),
formatter: 'json',
maxSize: this.parseSizeToBytes(config?.maxSize || '10m'),
maxFiles: typeof config?.maxFiles === 'string' ? parseInt(config.maxFiles) : (config?.maxFiles || 5),
createDir: true
}
}
};
return createLogger(coreConfig);
}
/**
* Map Winston log levels to core logger levels
*/
mapWinstonLevelToCoreLevel(winstonLevel) {
const levelMap = {
'error': coreLogger_1.LogLevel.ERROR,
'warn': coreLogger_1.LogLevel.WARN,
'info': coreLogger_1.LogLevel.INFO,
'http': coreLogger_1.LogLevel.HTTP,
'verbose': coreLogger_1.LogLevel.VERBOSE,
'debug': coreLogger_1.LogLevel.DEBUG,
'silly': coreLogger_1.LogLevel.SILLY
};
return levelMap[winstonLevel.toLowerCase()] || coreLogger_1.LogLevel.INFO;
}
/**
* Map core logger levels to Winston log levels
*/
mapCoreLevelToWinstonLevel(coreLevel) {
const levelMap = {
[coreLogger_1.LogLevel.ERROR]: 'error',
[coreLogger_1.LogLevel.WARN]: 'warn',
[coreLogger_1.LogLevel.INFO]: 'info',
[coreLogger_1.LogLevel.HTTP]: 'http',
[coreLogger_1.LogLevel.VERBOSE]: 'verbose',
[coreLogger_1.LogLevel.DEBUG]: 'debug',
[coreLogger_1.LogLevel.SILLY]: 'silly'
};
return levelMap[coreLevel] || 'info';
}
/**
* Parse size string to bytes
*/
parseSizeToBytes(size) {
const units = {
'b': 1,
'k': 1024,
'm': 1024 * 1024,
'g': 1024 * 1024 * 1024
};
const match = size.toLowerCase().match(/^(\d+(?:\.\d+)?)([bkmg]?)$/);
if (!match)
return 10 * 1024 * 1024; // Default 10MB
const value = parseFloat(match[1]);
const unit = match[2] || 'b';
return Math.floor(value * (units[unit] || 1));
}
/**
* Winston-compatible log method
*/
log(level, message, meta) {
const coreLevel = this.mapWinstonLevelToCoreLevel(level);
this.coreLogger.log(coreLevel, message, meta || {});
}
/**
* Winston-compatible error method
*/
error(message, meta) {
this.coreLogger.error(message, meta?.error, meta);
}
/**
* Winston-compatible warn method
*/
warn(message, meta) {
this.coreLogger.warn(message, meta);
}
/**
* Winston-compatible info method
*/
info(message, meta) {
this.coreLogger.info(message, meta);
}
/**
* Winston-compatible debug method
*/
debug(message, meta) {
this.coreLogger.debug(message, meta);
}
/**
* Winston-compatible add method (no-op for compatibility)
*/
add() {
// No-op for Winston compatibility
}
/**
* Get the underlying core logger
*/
getCoreLogger() {
return this.coreLogger;
}
/**
* Get logger configuration
*/
getConfig() {
return this.coreLogger.getConfig();
}
}
exports.CoreLoggerBridge = CoreLoggerBridge;
/**
* Create a Winston-compatible logger using core logger with runtime configuration
*/
async function createCoreSystemLogger(config) {
const bridge = new CoreLoggerBridge(config);
await bridge.initializeWithRuntimeConfig();
return bridge;
}
/**
* Log a system entry using core logger
*/
function logSystemWithCore(bridge, entry) {
const { level, message, error, metadata, ...otherMeta } = entry;
const coreLevel = bridge['mapWinstonLevelToCoreLevel'](level);
if (error) {
bridge.getCoreLogger().log(coreLevel, message, {
error: error.message,
stack: error.stack,
...metadata,
...otherMeta
});
}
else {
bridge.getCoreLogger().log(coreLevel, message, { ...metadata, ...otherMeta });
}
}
/**
* Convenience functions for different log levels using core logger
*/
function logErrorWithCore(bridge, message, error, metadata) {
logSystemWithCore(bridge, { level: 'error', message, error, metadata });
}
function logWarnWithCore(bridge, message, metadata) {
logSystemWithCore(bridge, { level: 'warn', message, metadata });
}
function logInfoWithCore(bridge, message, metadata) {
logSystemWithCore(bridge, { level: 'info', message, metadata });
}
function logDebugWithCore(bridge, message, metadata) {
logSystemWithCore(bridge, { level: 'debug', message, metadata });
}
//# sourceMappingURL=coreLoggerBridge.js.map