public static IEnumerable <AbstractDashboardNotification> FetchDatabasesInfo(ServerStore serverStore, Func <string, bool> isValidFor, CancellationTokenSource cts)
        {
            var databasesInfo = new DatabasesInfo();
            var indexingSpeed = new IndexingSpeed();
            var trafficWatch  = new TrafficWatch();
            var drivesUsage   = new DrivesUsage();

            trafficWatch.AverageRequestDuration = serverStore.Server.Metrics.Requests.AverageDuration.GetRate();

            using (serverStore.ContextPool.AllocateOperationContext(out TransactionOperationContext transactionContext))
                using (transactionContext.OpenReadTransaction())
                {
                    // 1. Fetch databases info
                    foreach (var databaseTuple in serverStore.Cluster.ItemsStartingWith(transactionContext, Constants.Documents.Prefix, 0, int.MaxValue))
                    {
                        var databaseName = databaseTuple.ItemName.Substring(Constants.Documents.Prefix.Length);
                        if (cts.IsCancellationRequested)
                        {
                            yield break;
                        }

                        if (isValidFor != null && isValidFor(databaseName) == false)
                        {
                            continue;
                        }

                        if (serverStore.DatabasesLandlord.DatabasesCache.TryGetValue(databaseName, out var databaseTask) == false)
                        {
                            // database does not exist on this server, is offline or disabled
                            SetOfflineDatabaseInfo(serverStore, transactionContext, databaseName, databasesInfo, drivesUsage, disabled: DatabasesLandlord.IsDatabaseDisabled(databaseTuple.Value));
                            continue;
                        }

                        try
                        {
                            var databaseOnline = IsDatabaseOnline(databaseTask, out var database);
                            if (databaseOnline == false)
                            {
                                SetOfflineDatabaseInfo(serverStore, transactionContext, databaseName, databasesInfo, drivesUsage, disabled: false);
                                continue;
                            }

                            var indexingSpeedItem = new IndexingSpeedItem
                            {
                                Database         = database.Name,
                                IndexedPerSecond = database.Metrics.MapIndexes.IndexedPerSec.OneSecondRate,
                                MappedPerSecond  = database.Metrics.MapReduceIndexes.MappedPerSec.OneSecondRate,
                                ReducedPerSecond = database.Metrics.MapReduceIndexes.ReducedPerSec.OneSecondRate
                            };
                            indexingSpeed.Items.Add(indexingSpeedItem);

                            var replicationFactor = GetReplicationFactor(databaseTuple.Value);
                            var documentsStorage  = database.DocumentsStorage;
                            var indexStorage      = database.IndexStore;


                            var trafficWatchItem = new TrafficWatchItem
                            {
                                Database                       = database.Name,
                                RequestsPerSecond              = (int)database.Metrics.Requests.RequestsPerSec.OneSecondRate,
                                AverageRequestDuration         = database.Metrics.Requests.AverageDuration.GetRate(),
                                DocumentWritesPerSecond        = (int)database.Metrics.Docs.PutsPerSec.OneSecondRate,
                                AttachmentWritesPerSecond      = (int)database.Metrics.Attachments.PutsPerSec.OneSecondRate,
                                CounterWritesPerSecond         = (int)database.Metrics.Counters.PutsPerSec.OneSecondRate,
                                DocumentsWriteBytesPerSecond   = database.Metrics.Docs.BytesPutsPerSec.OneSecondRate,
                                AttachmentsWriteBytesPerSecond = database.Metrics.Attachments.BytesPutsPerSec.OneSecondRate,
                                CountersWriteBytesPerSecond    = database.Metrics.Counters.BytesPutsPerSec.OneSecondRate
                            };
                            trafficWatch.Items.Add(trafficWatchItem);

                            var currentEnvironmentsHash = database.GetEnvironmentsHash();
                            if (CachedDatabaseInfo.TryGetValue(database.Name, out var item) && item.Hash == currentEnvironmentsHash)
                            {
                                databasesInfo.Items.Add(item.Item);

                                if (item.NextDiskSpaceCheck < SystemTime.UtcNow)
                                {
                                    item.MountPoints = new List <Client.ServerWide.Operations.MountPointUsage>();
                                    DiskUsageCheck(item, database, drivesUsage, cts);
                                }
                                else
                                {
                                    foreach (var cachedMountPoint in item.MountPoints)
                                    {
                                        UpdateMountPoint(database.Configuration.Storage, cachedMountPoint, database.Name, drivesUsage);
                                    }
                                }
                            }
                            else
                            {
                                using (documentsStorage.ContextPool.AllocateOperationContext(out DocumentsOperationContext documentsContext))
                                    using (documentsContext.OpenReadTransaction())
                                    {
                                        var databaseInfoItem = new DatabaseInfoItem
                                        {
                                            Database            = database.Name,
                                            DocumentsCount      = documentsStorage.GetNumberOfDocuments(documentsContext),
                                            IndexesCount        = database.IndexStore.Count,
                                            AlertsCount         = database.NotificationCenter.GetAlertCount(),
                                            ReplicationFactor   = replicationFactor,
                                            ErroredIndexesCount = indexStorage.GetIndexes().Count(index => index.GetErrorCount() > 0),
                                            Online = true
                                        };
                                        databasesInfo.Items.Add(databaseInfoItem);
                                        CachedDatabaseInfo[database.Name] = item = new DatabaseInfoCache
                                        {
                                            Hash = currentEnvironmentsHash,
                                            Item = databaseInfoItem
                                        };
                                    }

                                DiskUsageCheck(item, database, drivesUsage, cts);
                            }
                        }
                        catch (Exception)
                        {
                            SetOfflineDatabaseInfo(serverStore, transactionContext, databaseName, databasesInfo, drivesUsage, disabled: false);
                        }
                    }

                    // 2. Fetch <system> info
                    if (isValidFor == null)
                    {
                        var currentSystemHash    = serverStore._env.CurrentReadTransactionId;
                        var cachedSystemInfoCopy = CachedSystemInfo;

                        if (currentSystemHash != cachedSystemInfoCopy.Hash || cachedSystemInfoCopy.NextDiskSpaceCheck < SystemTime.UtcNow)
                        {
                            var systemInfo = new SystemInfoCache()
                            {
                                Hash = currentSystemHash,
                                NextDiskSpaceCheck = SystemTime.UtcNow.AddSeconds(30),
                                MountPoints        = new List <Client.ServerWide.Operations.MountPointUsage>()
                            };

                            // Get new data
                            var systemEnv         = new StorageEnvironmentWithType("<System>", StorageEnvironmentWithType.StorageEnvironmentType.System, serverStore._env);
                            var systemMountPoints = ServerStore.GetMountPointUsageDetailsFor(systemEnv, includeTempBuffers: true);

                            foreach (var systemPoint in systemMountPoints)
                            {
                                UpdateMountPoint(serverStore.Configuration.Storage, systemPoint, "<System>", drivesUsage);
                                systemInfo.MountPoints.Add(systemPoint);
                            }

                            // Update the cache
                            Interlocked.Exchange(ref CachedSystemInfo, systemInfo);
                        }
                        else
                        {
                            // Use existing data
                            foreach (var systemPoint in cachedSystemInfoCopy.MountPoints)
                            {
                                UpdateMountPoint(serverStore.Configuration.Storage, systemPoint, "<System>", drivesUsage);
                            }
                        }
                    }
                }

            yield return(databasesInfo);

            yield return(indexingSpeed);

            yield return(trafficWatch);

            yield return(drivesUsage);
        }