feat: add SkipMetricsTracking property to DbSettings

src/Nethermind/Nethermind.Db.Test/DbTrackerTests.cs

@@ -77,6 +77,73 @@ public void TestUpdateDbMetric(bool isProcessing)
         Assert.That(Metrics.DbReads["TestDb"], isProcessing ? Is.EqualTo(0) : Is.EqualTo(10));
     }
 
+    [Test]
+    public void TestSkipMetricsTracking()
+    {
+        using IContainer container = new ContainerBuilder()
+            .AddSingleton<DbMonitoringModule.DbTracker>()
+            .AddSingleton<IDbConfig>(new DbConfig())
+            .AddSingleton<HyperClockCacheWrapper>()
+            .AddSingleton<IMetricsConfig>(new MetricsConfig())
+            .AddSingleton<ILogManager>(LimboLogs.Instance)
+            .AddSingleton<IMonitoringService>(NoopMonitoringService.Instance)
+            .AddDecorator<IDbFactory, DbMonitoringModule.DbTracker.DbFactoryInterceptor>()
+            .AddSingleton<IDbFactory, MemDbFactory>()
+            .Build();
+
+        IDbFactory dbFactory = container.Resolve<IDbFactory>();
+        DbMonitoringModule.DbTracker tracker = container.Resolve<DbMonitoringModule.DbTracker>();
+
+        DbSettings skipped = new("SkippedDb", "SkippedDb") { SkipMetricsTracking = true };
+        DbSettings tracked = new("TrackedDb", "TrackedDb");
+
+        dbFactory.CreateDb(skipped);
+        dbFactory.CreateDb(tracked);
+
+        tracker.GetAllDbMeta().Count().Should().Be(1);
+        tracker.GetAllDbMeta().First().Key.Should().Be("TrackedDb");
+    }
+
+    [Parallelizable(ParallelScope.None)]
+    [Test]
+    public void ExceptionInGatherMetricDoesNotAbortOtherDbs()
+    {
+        IMonitoringService monitoringService = Substitute.For<IMonitoringService>();
+        Action updateAction = null!;
+        monitoringService
+            .When(m => m.AddMetricsUpdateAction(Arg.Any<Action>()))
+            .Do(c => updateAction = (Action)c[0]);
+
+        IDbFactory fakeDbFactory = Substitute.For<IDbFactory>();
+
+        using IContainer container = new ContainerBuilder()
+            .AddSingleton<DbMonitoringModule.DbTracker>()
+            .AddSingleton<IDbConfig>(new DbConfig())
+            .AddSingleton<HyperClockCacheWrapper>()
+            .AddSingleton<IMetricsConfig>(new MetricsConfig())
+            .AddSingleton<ILogManager>(LimboLogs.Instance)
+            .AddSingleton<IMonitoringService>(monitoringService)
+            .AddDecorator<IDbFactory, DbMonitoringModule.DbTracker.DbFactoryInterceptor>()
+            .AddSingleton<IDbFactory>(fakeDbFactory)
+            .Build();
+
+        ThrowingDb throwingDb = new();
+        FakeDb goodDb = new(new IDbMeta.DbMetric { TotalReads = 42 });
+        fakeDbFactory.CreateDb(Arg.Is<DbSettings>(s => s.DbName == "ThrowingDb")).Returns(throwingDb);
+        fakeDbFactory.CreateDb(Arg.Is<DbSettings>(s => s.DbName == "GoodDb")).Returns(goodDb);
+
+        IDbFactory intercepted = container.Resolve<IDbFactory>();
+        intercepted.CreateDb(new DbSettings("ThrowingDb", "ThrowingDb"));
+        intercepted.CreateDb(new DbSettings("GoodDb", "GoodDb"));
+
+        Metrics.DbReads["GoodDb"] = 0;
+
+        updateAction!();
+
+        Assert.That(Metrics.DbReads.ContainsKey("GoodDb"), Is.True);
+        Assert.That(Metrics.DbReads["GoodDb"], Is.EqualTo(42));
+    }
+
     [Parallelizable(ParallelScope.None)]
     [Test]
     public void DoesNotUpdateIfIntervalHasNotPassed()
@@ -149,4 +216,9 @@ private class FakeDb(IDbMeta.DbMetric metric) : TestMemDb, IDbMeta
 
         internal void SetMetric(IDbMeta.DbMetric metric) => _metric = metric;
     }
+
+    private class ThrowingDb : TestMemDb, IDbMeta
+    {
+        public override IDbMeta.DbMetric GatherMetric() => throw new InvalidOperationException("Simulated GatherMetric failure");
+    }
 }

src/Nethermind/Nethermind.Db.Test/Nethermind.Db.Test.csproj

@@ -13,6 +13,7 @@
     <ProjectReference Include="..\Nethermind.Db.Rocks\Nethermind.Db.Rocks.csproj" />
     <ProjectReference Include="..\Nethermind.Db.Rpc\Nethermind.Db.Rpc.csproj" />
     <ProjectReference Include="..\Nethermind.Db\Nethermind.Db.csproj" />
+    <ProjectReference Include="..\Nethermind.Init\Nethermind.Init.csproj" />
   </ItemGroup>
   <ItemGroup>
     <None Update="InputFiles\CompactionStatsExample_MissingIntervalCompaction.txt">

src/Nethermind/Nethermind.Db/DbSettings.cs

@@ -12,6 +12,7 @@ public class DbSettings(string name, string path)
 
         public bool DeleteOnStart { get; set; }
         public bool CanDeleteFolder { get; set; } = true;
+        public bool SkipMetricsTracking { get; set; }
 
         public IMergeOperator? MergeOperator { get; set; }
         public Dictionary<string, IMergeOperator>? ColumnsMergeOperators { get; set; }

src/Nethermind/Nethermind.Db/FullPruning/FullPruningInnerDbFactory.cs

@@ -63,6 +63,9 @@ private DbSettings GetRocksDbSettings(DbSettings originalSetting)
             string dbPath = firstDb ? originalSetting.DbPath : _fileSystem.Path.Combine(originalSetting.DbPath, _index.ToString());
             DbSettings dbSettings = originalSetting.Clone(dbName, dbPath);
             dbSettings.CanDeleteFolder = !firstDb; // we cannot delete main db folder, only indexed subfolders
+            // Inner DBs are tracked via the FullPruningDb wrapper (registered with a stable name)
+            // so we skip tracking these indexed sub-DBs to avoid stale references after pruning.
+            dbSettings.SkipMetricsTracking = true;
             return dbSettings;
         }
 

src/Nethermind/Nethermind.Init/Modules/DbMonitoringModule.cs

@@ -84,14 +84,21 @@ private void UpdateDbMetrics()
 
                 foreach (KeyValuePair<string, IDbMeta> kv in GetAllDbMeta())
                 {
-                    // Note: At the moment, the metric for a columns db is combined across column.
-                    IDbMeta.DbMetric dbMetric = kv.Value.GatherMetric();
-                    Db.Metrics.DbSize[kv.Key] = dbMetric.Size;
-                    Db.Metrics.DbBlockCacheSize[kv.Key] = dbMetric.CacheSize;
-                    Db.Metrics.DbMemtableSize[kv.Key] = dbMetric.MemtableSize;
-                    Db.Metrics.DbIndexFilterSize[kv.Key] = dbMetric.IndexSize;
-                    Db.Metrics.DbReads[kv.Key] = dbMetric.TotalReads;
-                    Db.Metrics.DbWrites[kv.Key] = dbMetric.TotalWrites;
+                    try
+                    {
+                        // Note: At the moment, the metric for a columns db is combined across column.
+                        IDbMeta.DbMetric dbMetric = kv.Value.GatherMetric();
+                        Db.Metrics.DbSize[kv.Key] = dbMetric.Size;
+                        Db.Metrics.DbBlockCacheSize[kv.Key] = dbMetric.CacheSize;
+                        Db.Metrics.DbMemtableSize[kv.Key] = dbMetric.MemtableSize;
+                        Db.Metrics.DbIndexFilterSize[kv.Key] = dbMetric.IndexSize;
+                        Db.Metrics.DbReads[kv.Key] = dbMetric.TotalReads;
+                        Db.Metrics.DbWrites[kv.Key] = dbMetric.TotalWrites;
+                    }
+                    catch (Exception e)
+                    {
+                        if (_logger.IsWarn) _logger.Warn($"Failed to gather metrics for DB '{kv.Key}': {e}");
+                    }
                 }
 
                 Db.Metrics.DbBlockCacheSize["Shared"] = _sharedBlockCache.Value.GetUsage();
@@ -109,7 +116,7 @@ public class DbFactoryInterceptor(DbTracker tracker, IDbFactory baseFactory) : I
             public IDb CreateDb(DbSettings dbSettings)
             {
                 IDb db = baseFactory.CreateDb(dbSettings);
-                if (db is IDbMeta dbMeta)
+                if (!dbSettings.SkipMetricsTracking && db is IDbMeta dbMeta)
                 {
                     tracker.AddDb(dbSettings.DbName, dbMeta);
                 }
@@ -119,7 +126,7 @@ public IDb CreateDb(DbSettings dbSettings)
             public IColumnsDb<T> CreateColumnsDb<T>(DbSettings dbSettings) where T : struct, Enum
             {
                 IColumnsDb<T> db = baseFactory.CreateColumnsDb<T>(dbSettings);
-                if (db is IDbMeta dbMeta)
+                if (!dbSettings.SkipMetricsTracking && db is IDbMeta dbMeta)
                 {
                     tracker.AddDb(dbSettings.DbName, dbMeta);
                 }

src/Nethermind/Nethermind.Init/Modules/WorldStateModule.cs

@@ -33,12 +33,17 @@ protected override void Load(ContainerBuilder builder)
                 DbSettings stateDbSettings = new(GetTitleDbName(DbNames.State), DbNames.State);
                 IFileSystem fileSystem = ctx.Resolve<IFileSystem>();
                 IDbFactory dbFactory = ctx.Resolve<IDbFactory>();
-                return new FullPruningDb(
+                FullPruningDb db = new(
                     stateDbSettings,
                     dbFactory is not MemDbFactory
                         ? new FullPruningInnerDbFactory(dbFactory, fileSystem, stateDbSettings.DbPath)
                         : dbFactory,
                     () => Interlocked.Increment(ref Nethermind.Db.Metrics.StateDbInPruningWrites));
+                // Register the outer wrapper so GatherMetric() always reflects the currently active
+                // inner DB, even across full-pruning cycles. Inner DBs are excluded from tracking
+                // via SkipMetricsTracking (set by FullPruningInnerDbFactory) to avoid stale entries.
+                ctx.ResolveOptional<DbMonitoringModule.DbTracker>()?.AddDb(stateDbSettings.DbName, db);
+                return db;
             })
 
             .AddSingleton<INodeStorageFactory>(ctx =>