nestjs-temporal-core
Version:
Complete NestJS integration for Temporal.io with auto-discovery, declarative scheduling, enhanced monitoring, and enterprise-ready features
208 lines • 7.63 kB
JavaScript
;
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var TemporalLoggerManager_1;
Object.defineProperty(exports, "__esModule", { value: true });
exports.LoggerUtils = exports.TemporalLogger = exports.TemporalLoggerManager = void 0;
exports.createLogger = createLogger;
exports.LogExecution = LogExecution;
const common_1 = require("@nestjs/common");
let TemporalLoggerManager = TemporalLoggerManager_1 = class TemporalLoggerManager {
constructor() {
this.globalConfig = {
enableLogger: true,
logLevel: 'info',
appName: 'NestJS-Temporal',
};
}
static getInstance() {
if (!TemporalLoggerManager_1.instance) {
TemporalLoggerManager_1.instance = new TemporalLoggerManager_1();
}
return TemporalLoggerManager_1.instance;
}
configure(config) {
this.globalConfig = { ...this.globalConfig, ...config };
}
getGlobalConfig() {
return { ...this.globalConfig };
}
createLogger(context, localConfig = {}) {
const mergedConfig = {
...this.globalConfig,
...localConfig,
};
return new TemporalLogger(context, mergedConfig);
}
};
exports.TemporalLoggerManager = TemporalLoggerManager;
exports.TemporalLoggerManager = TemporalLoggerManager = TemporalLoggerManager_1 = __decorate([
(0, common_1.Injectable)({ scope: common_1.Scope.DEFAULT })
], TemporalLoggerManager);
class TemporalLogger {
constructor(context, config = {}) {
this.context = context;
this.nestLogger = new common_1.Logger(context);
this.config = {
enableLogger: config.enableLogger ?? true,
logLevel: config.logLevel ?? 'info',
};
}
shouldLog(level) {
if (this.config.enableLogger === false) {
return false;
}
const levels = ['error', 'warn', 'info', 'debug', 'verbose'];
const currentLevelIndex = levels.indexOf(this.config.logLevel);
const requestedLevelIndex = levels.indexOf(level);
return requestedLevelIndex <= currentLevelIndex;
}
error(message, trace, context) {
if (this.shouldLog('error')) {
const errorContext = context || this.context;
if (trace instanceof Error) {
this.nestLogger.error(message, trace.stack, errorContext);
}
else {
this.nestLogger.error(message, trace, errorContext);
}
}
}
warn(message, context) {
if (this.shouldLog('warn')) {
this.nestLogger.warn(message, context || this.context);
}
}
log(message, context) {
if (this.shouldLog('info')) {
this.nestLogger.log(message, context || this.context);
}
}
info(message, context) {
this.log(message, context);
}
debug(message, context) {
if (this.shouldLog('debug')) {
this.nestLogger.debug(message, context || this.context);
}
}
verbose(message, context) {
if (this.shouldLog('verbose')) {
this.nestLogger.verbose(message, context || this.context);
}
}
logExecutionTime(methodName, startTime, context) {
const executionTime = Date.now() - startTime;
this.debug(`${methodName} executed in ${executionTime}ms`, context || this.context);
}
logWithLevel(level, message, context) {
switch (level) {
case 'error':
this.error(message, undefined, context);
break;
case 'warn':
this.warn(message, context);
break;
case 'info':
this.log(message, context);
break;
case 'debug':
this.debug(message, context);
break;
case 'verbose':
this.verbose(message, context);
break;
}
}
createChildLogger(childContext, config) {
const combinedContext = `${this.context}:${childContext}`;
const childConfig = config ? { ...this.config, ...config } : this.config;
return new TemporalLogger(combinedContext, childConfig);
}
getConfig() {
return { ...this.config };
}
isEnabled() {
return this.config.enableLogger ?? true;
}
getLogLevel() {
return this.config.logLevel ?? 'info';
}
getContext() {
return this.context;
}
updateConfig(newConfig) {
this.config.enableLogger = newConfig.enableLogger ?? this.config.enableLogger;
this.config.logLevel = newConfig.logLevel ?? this.config.logLevel;
}
}
exports.TemporalLogger = TemporalLogger;
function createLogger(context, config) {
const manager = TemporalLoggerManager.getInstance();
return manager.createLogger(context, config);
}
function LogExecution(_logLevel = 'debug') {
return function (target, propertyName, descriptor) {
const method = descriptor.value;
descriptor.value = function (...args) {
const logger = createLogger(target.constructor.name);
const startTime = Date.now();
try {
const result = method.apply(this, args);
if (result instanceof Promise) {
return result
.then((res) => {
logger.logExecutionTime(propertyName, startTime);
return res;
})
.catch((error) => {
logger.error(`Error in ${propertyName}:`, error);
throw error;
});
}
else {
logger.logExecutionTime(propertyName, startTime);
return result;
}
}
catch (error) {
logger.error(`Error in ${propertyName}:`, error);
throw error;
}
};
return descriptor;
};
}
class LoggerUtils {
static logServiceInit(logger, serviceName, config) {
logger.log(`Initializing ${serviceName}...`);
if (config && logger.getLogLevel() === 'debug') {
logger.debug(`${serviceName} configuration:`, JSON.stringify(config, null, 2));
}
}
static logServiceShutdown(logger, serviceName) {
logger.log(`Shutting down ${serviceName}...`);
}
static logConnection(logger, target, success, error) {
if (success) {
logger.log(`Successfully connected to ${target}`);
}
else {
logger.error(`Failed to connect to ${target}`, error);
}
}
static logOperation(logger, operation, success, details, error) {
if (success) {
logger.log(`${operation} completed successfully${details ? `: ${details}` : ''}`);
}
else {
logger.error(`${operation} failed${details ? `: ${details}` : ''}`, error);
}
}
}
exports.LoggerUtils = LoggerUtils;
//# sourceMappingURL=logger.js.map