@lido-nestjs/execution 1.15.0 → 1.16.0

package/dist/interfaces/simple-fallback-provider-config.d.ts

@@ -15,4 +15,5 @@ export interface SimpleFallbackProviderConfig {
     fetchMiddlewares?: MiddlewareCallback<Promise<any>>[];
     maxTimeWithoutNewBlocksMs?: number;
     requestTimeoutMs?: number;
+    instanceLabel?: string;
 }

package/dist/provider/simple-fallback-json-rpc-batch-provider.d.ts

@@ -46,6 +46,7 @@ export declare class SimpleFallbackJsonRpcBatchProvider extends BaseProvider {
     constructor(config: SimpleFallbackProviderConfig, logger: LoggerService);
     static _formatter: Formatter | null;
     static getFormatter(): Formatter;
+    protected formatLog(message: string, providerIndex?: number): string;
     on(eventName: EventType, listener: Listener): this;
     getFeeHistory(blockCount: number, newestBlock?: string | null | number, rewardPercentiles?: number[]): Promise<FeeHistory>;
     getDebugTraceBlockByHash(blockHash: string, traceConfig: Partial<TraceConfig>): Promise<TraceResult[]>;

package/dist/provider/simple-fallback-json-rpc-batch-provider.js

@@ -19,6 +19,7 @@ var events = require('events');
 
 exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchProvider extends providers.BaseProvider {
     constructor(config, logger) {
+        var _a;
         super(config.network);
         this.detectNetworkFirstRun = true;
         this.resetTimer = null;
@@ -55,6 +56,22 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
             };
         });
         this.activeFallbackProviderIndex = 0;
+        // Log initialization info
+        const configInfo = {
+            providers: conns.length,
+            network: this.config.network,
+            requestPolicy: this.config.requestPolicy,
+            maxRetries: this.config.maxRetries,
+            minBackoffMs: this.config.minBackoffMs,
+            maxBackoffMs: this.config.maxBackoffMs,
+            logRetries: this.config.logRetries,
+            resetIntervalMs: this.config.resetIntervalMs,
+            fetchMiddlewares: ((_a = this.config.fetchMiddlewares) === null || _a === void 0 ? void 0 : _a.length) || 0,
+            maxTimeWithoutNewBlocksMs: this.config.maxTimeWithoutNewBlocksMs,
+            requestTimeoutMs: this.config.requestTimeoutMs || 'disabled',
+            instanceLabel: this.config.instanceLabel || 'none',
+        };
+        this.logger.log(this.formatLog(`Initialized SimpleFallbackJsonRpcBatchProvider: ${JSON.stringify(configInfo)}`));
     }
     static getFormatter() {
         if (this._formatter == null) {
@@ -62,6 +79,19 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         }
         return this._formatter;
     }
+    formatLog(message, providerIndex) {
+        const parts = [];
+        if (this.config.instanceLabel) {
+            parts.push(`[${this.config.instanceLabel}]`);
+        }
+        if (providerIndex !== undefined) {
+            parts.push(`[provider:${providerIndex}]`);
+        }
+        if (parts.length > 0) {
+            return `${parts.join('')} ${message}`;
+        }
+        return message;
+    }
     on(eventName, listener) {
         let dieTimer = null;
         const startDieTimer = (latestObservedBlockNumber) => {
@@ -110,11 +140,13 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
     }
     switchToNextProvider() {
         if (this.fallbackProviders.length === 1) {
-            this.logger.warn('Will not switch to next provider. No valid backup provider provided.');
+            this.logger.warn(this.formatLog('Will not switch to next provider. No valid backup provider provided.'));
             return;
         }
-        this.activeFallbackProviderIndex++;
-        this.logger.log(`Switched to next provider for execution layer`);
+        const oldIndex = this.activeFallbackProviderIndex;
+        this.activeFallbackProviderIndex =
+            (this.activeFallbackProviderIndex + 1) % this.fallbackProviders.length;
+        this.logger.log(this.formatLog(`Switched provider: [${oldIndex}] -> [${this.activeFallbackProviderIndex}] (total: ${this.fallbackProviders.length})`));
     }
     isNonRetryableError(error) {
         return (!errors.isEthersServerError(error) &&
@@ -141,9 +173,11 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
             try {
                 let performRetryAttempt = 0;
                 attempt++;
+                // Log which provider we're attempting to use
+                this.logger.log(this.formatLog(`Attempting request (attempt ${attempt}/${this.fallbackProviders.length})`, this.activeFallbackProviderIndex));
                 // awaiting is extremely important here
                 // without it, the error will not be caught in current try-catch scope
-                return await retry(() => {
+                const result = await retry(() => {
                     const provider = this.provider;
                     const event = {
                         action: 'fallback-provider:request',
@@ -162,6 +196,9 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
                     }
                     return performPromise;
                 });
+                // Log successful request
+                this.logger.log(this.formatLog(`Request successful after ${performRetryAttempt} retry attempt(s)`, this.activeFallbackProviderIndex));
+                return result;
             }
             catch (e) {
                 this.lastError = e;
@@ -173,10 +210,22 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
                         error: e,
                     };
                     this._eventEmitter.emit('rpc', event);
+                    // Log context (label + provider index) synchronously before error object
+                    // to ensure proper ordering in async logging systems
+                    this.logger.error(this.formatLog(`Non-retryable error occurred`, this.activeFallbackProviderIndex));
+                    this.logger.error(e);
                     throw e;
                 }
-                this.logger.error('Error while doing ETH1 RPC request. Will try to switch to another provider');
-                this.logger.error(e);
+                // Log context (label + provider index) synchronously before error object
+                // to ensure proper ordering in async logging systems
+                if (e instanceof requestTimeout_error.RequestTimeoutError) {
+                    this.logger.error(this.formatLog(`Request timeout after ${e.timeoutMs}ms. Will switch to next provider.`, this.activeFallbackProviderIndex));
+                    this.logger.error(e);
+                }
+                else {
+                    this.logger.error(this.formatLog(`Error occurred. Will switch to next provider.`, this.activeFallbackProviderIndex));
+                    this.logger.error(e);
+                }
                 // This check is needed to avoid multiple `switchToNextProvider` calls when doing one JSON-RPC batch.
                 // This can happen when multiple N calls to `perform` are batched in one JSON-RPC request and
                 // that request fails and throws `Error`. This `Error` is bubbled N times to corresponding `perform` calls.
@@ -234,7 +283,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
                     if (this.detectNetworkFirstRun) {
                         throw new Error(`Fallback provider [${index}] network is different to other provider's networks`);
                     }
-                    this.logger.warn(`Fallback provider [${index}] network is different to other provider's networks`);
+                    this.logger.warn(this.formatLog(`Fallback provider [${index}] network is different to other provider's networks`));
                 }
             }
             else {
@@ -261,7 +310,7 @@ exports.SimpleFallbackJsonRpcBatchProvider = class SimpleFallbackJsonRpcBatchPro
         if (this.resetTimer) {
             clearTimeout(this.resetTimer);
         }
-        this.fallbackProviders.forEach((fallbackProvider, index) => {
+        this.fallbackProviders.forEach((_, index) => {
             var _a;
             if (!((_a = this.fallbackProviders[index].network) === null || _a === void 0 ? void 0 : _a.chainId)) {
                 this.fallbackProviders[index].unreachable = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lido-nestjs/execution",
-  "version": "1.15.0",
+  "version": "1.16.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "MIT",