@nest-omni/core 4.1.3-10 → 4.1.3-11

package/redis-lock/redis-lock.service.js

@@ -72,13 +72,16 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
         this.redis = null;
         this.defaultOptions = {
             ttl: 300000, // 5 minutes
-            retryCount: 0,
-            retryDelay: 100,
+            retryCount: 3, // Increased from 0 to provide reasonable retry attempts
+            retryDelay: 500, // Increased from 100 to reduce retry frequency
             keyPrefix: 'lock',
             throwOnFailure: false,
             strategy: LockStrategy.SKIP,
             waitTimeout: undefined,
             autoExtend: 0, // No auto-extension by default
+            useExponentialBackoff: true, // Enable exponential backoff by default
+            maxRetryDelay: 30000, // Maximum retry delay of 30 seconds
+            retryJitter: 100, // Add random jitter to avoid synchronized retries
         };
         // Set global instance when created
         if (!RedisLockService_1.globalInstance) {
@@ -169,6 +172,7 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
      */
     acquireLock(key_1) {
         return __awaiter(this, arguments, void 0, function* (key, options = {}) {
+            var _a, _b, _c, _d, _e;
             const redis = yield this.getRedis();
             const opts = Object.assign(Object.assign({}, this.defaultOptions), options);
             // Handle backward compatibility: if throwOnFailure is true, use THROW strategy
@@ -229,16 +233,42 @@ let RedisLockService = RedisLockService_1 = class RedisLockService {
                     }
                     // Wait before next attempt (except for last attempt)
                     if (attempts < maxAttempts) {
-                        yield this.sleep(opts.retryDelay);
+                        // Add random jitter to avoid synchronized retries
+                        const jitter = opts.retryJitter ? Math.random() * opts.retryJitter : 0;
+                        const totalDelay = opts.retryDelay + jitter;
+                        yield this.sleep(totalDelay);
                     }
                 }
                 catch (error) {
-                    const errorMessage = `Error acquiring lock for ${lockKey}: ${error.message}`;
-                    this.logger.error(errorMessage, error.stack);
-                    if (opts.strategy === LockStrategy.THROW) {
-                        throw new Error(errorMessage);
+                    // Enhanced error classification and handling
+                    if (((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('ECONNREFUSED')) ||
+                        ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes('ECONNRESET')) ||
+                        error.code === 'ECONNREFUSED') {
+                        // Connection error, will retry - log at debug level
+                        this.logger.debug(`Redis connection error, will retry: ${error.message}`);
+                    }
+                    else if (((_c = error.message) === null || _c === void 0 ? void 0 : _c.includes('READONLY')) ||
+                        ((_d = error.message) === null || _d === void 0 ? void 0 : _d.includes('LOADING')) ||
+                        ((_e = error.message) === null || _e === void 0 ? void 0 : _e.includes('MASTERDOWN'))) {
+                        // Redis server error, log at warn level
+                        this.logger.warn(`Redis server error: ${error.message}`);
+                    }
+                    else {
+                        // Other errors, log at error level
+                        const errorMessage = `Error acquiring lock for ${lockKey}: ${error.message}`;
+                        this.logger.error(errorMessage, error.stack);
+                        if (opts.strategy === LockStrategy.THROW) {
+                            throw new Error(errorMessage);
+                        }
+                        return { acquired: false, error: errorMessage };
+                    }
+                    // For retryable errors, continue with retry logic
+                    attempts++;
+                    if (attempts < maxAttempts) {
+                        const jitter = opts.retryJitter ? Math.random() * opts.retryJitter : 0;
+                        const totalDelay = opts.retryDelay + jitter;
+                        yield this.sleep(totalDelay);
                     }
-                    return { acquired: false, error: errorMessage };
                 }
             }
             // Max attempts reached

package/setup/schedule.decorator.js

@@ -106,8 +106,18 @@ function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, op
                 }
                 // Get or create global instance - auto-configures from environment variables
                 const lockService = redis_lock_1.RedisLockService.getOrCreateGlobalInstance();
-                const { lockTtl = 3600000, // 1 hour default
-                retryCount = 0, retryDelay = 1000, useExponentialBackoff = false, maxRetryDelay = 60000, logExecution = true, lockKeyPrefix = 'schedule', autoExtendLock = 0, onSuccess, onError, skipIfLocked = true, } = options;
+                const { lockTtl = 600000, // 10 minutes default (reduced from 1 hour)
+                retryCount = 3, retryDelay = 500, useExponentialBackoff = true, maxRetryDelay = 30000, logExecution = true, lockKeyPrefix = 'schedule', autoExtendLock = 0, onSuccess, onError, skipIfLocked = true, } = options;
+                // Configuration validation and adjustment
+                const validatedLockTtl = lockTtl >= 3600000
+                    ? (logger.warn(`lockTtl (${lockTtl}ms) is quite long for a scheduled task, consider if this is appropriate for ${className}.${methodName}`), lockTtl)
+                    : lockTtl;
+                const validatedRetryCount = retryCount > 10
+                    ? (logger.warn(`retryCount (${retryCount}) is too high, limiting to 10 for task ${className}.${methodName}`), 10)
+                    : retryCount;
+                const validatedRetryDelay = retryDelay < 100
+                    ? (logger.warn(`retryDelay (${retryDelay}ms) is too low, setting to 100ms for task ${className}.${methodName}`), 100)
+                    : retryDelay;
                 const fullLockKey = `${lockKeyPrefix}:${resolvedLockKey}`;
                 const startTime = Date.now();
                 // Log task start
@@ -117,7 +127,7 @@ function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, op
                 try {
                     // Acquire lock
                     const lockResult = yield lockService.acquireLock(resolvedLockKey, {
-                        ttl: lockTtl,
+                        ttl: validatedLockTtl,
                         keyPrefix: lockKeyPrefix,
                         autoExtend: autoExtendLock,
                     });
@@ -133,8 +143,8 @@ function createWorkerDecoratorWithLock(baseDecorator, decoratorName, lockKey, op
                     try {
                         // Execute with retry logic
                         const result = yield executeWithRetry(() => originalMethod.apply(this, args), {
-                            retryCount,
-                            retryDelay,
+                            retryCount: validatedRetryCount,
+                            retryDelay: validatedRetryDelay,
                             useExponentialBackoff,
                             maxRetryDelay,
                             logger,
@@ -309,11 +319,11 @@ function WorkerIntervalWithLock(timeout, lockKeyOrOptions, lockTtl) {
         let options;
         if (typeof lockKeyOrOptions === 'string') {
             lockKey = lockKeyOrOptions;
-            options = { lockTtl: lockTtl || Math.floor(timeout * 0.8) };
+            options = { lockTtl: lockTtl || Math.max(Math.floor(timeout * 0.8), 10000) };
         }
         else {
             lockKey = generateLockKey(target.constructor.name, String(propertyKey));
-            options = Object.assign({ lockTtl: Math.floor(timeout * 0.8) }, lockKeyOrOptions);
+            options = Object.assign({ lockTtl: Math.max(Math.floor(timeout * 0.8), 10000) }, lockKeyOrOptions);
         }
         return createWorkerDecoratorWithLock((0, schedule_1.Interval)(timeout), 'WorkerIntervalWithLock', lockKey, options)(target, propertyKey, descriptor);
     };
@@ -406,7 +416,7 @@ function WorkerCronSmart(cronTime, options = {}, cronOptions) {
 function WorkerIntervalSmart(timeout, options = {}) {
     return function (target, propertyKey, descriptor) {
         const lockKey = generateLockKey(target.constructor.name, String(propertyKey));
-        return createWorkerDecoratorWithLock((0, schedule_1.Interval)(timeout), 'WorkerIntervalSmart', lockKey, Object.assign({ lockTtl: Math.floor(timeout * 0.8), logExecution: true }, options))(target, propertyKey, descriptor);
+        return createWorkerDecoratorWithLock((0, schedule_1.Interval)(timeout), 'WorkerIntervalSmart', lockKey, Object.assign({ lockTtl: Math.max(Math.floor(timeout * 0.8), 10000), logExecution: true }, options))(target, propertyKey, descriptor);
     };
 }
 /**

package/shared/serviceRegistryModule.js

@@ -61,19 +61,6 @@ const modules = [
         expandVariables: false,
         envFilePath: [process.env.ENV_FILE_PATH, process.env.BASE_ENV_FILE_PATH],
     }),
-    nestjs_cls_1.ClsModule.forRoot({
-        global: true,
-        middleware: { mount: true, saveReq: true },
-        plugins: [
-            new transactional_1.ClsPluginTransactional({
-                imports: [typeorm_1.TypeOrmModule],
-                adapter: new transactional_adapter_typeorm_1.TransactionalAdapterTypeOrm({
-                    dataSourceToken: typeorm_2.DataSource,
-                }),
-                enableTransactionProxy: true,
-            }),
-        ],
-    }),
     nestjs_pino_1.LoggerModule.forRootAsync({
         inject: [services_1.ApiConfigService],
         useFactory: (config) => config.pinoConfig,
@@ -105,6 +92,24 @@ if (services_1.ApiConfigService.toBoolean(process.env.DB_ENABLED, true)) {
         inject: [services_1.ApiConfigService],
         useFactory: (config) => config.typeormConfig,
     }));
+    modules.push(nestjs_cls_1.ClsModule.forRootAsync({
+        imports: [typeorm_1.TypeOrmModule],
+        useFactory(args) {
+            return {
+                middleware: { mount: true, saveReq: true },
+            };
+        },
+        global: true,
+        plugins: [
+            new transactional_1.ClsPluginTransactional({
+                imports: [typeorm_1.TypeOrmModule],
+                adapter: new transactional_adapter_typeorm_1.TransactionalAdapterTypeOrm({
+                    dataSourceToken: (0, typeorm_1.getDataSourceToken)(),
+                }),
+                enableTransactionProxy: true,
+            }),
+        ]
+    }));
 }
 if (services_1.ApiConfigService.toBoolean(process.env.BULL_ENABLED)) {
     modules.push(bull_1.BullModule.forRootAsync({