Add cleanup for slow downloads (#110)

code/Infrastructure/Extensions/DelugeExtensions.cs

@@ -4,7 +4,7 @@ namespace Infrastructure.Extensions;
 
 public static class DelugeExtensions
 {
-    public static bool ShouldIgnore(this TorrentStatus download, IReadOnlyList<string> ignoredDownloads)
+    public static bool ShouldIgnore(this DownloadStatus download, IReadOnlyList<string> ignoredDownloads)
     {
         foreach (string value in ignoredDownloads)
         {

code/Infrastructure/Helpers/CacheKeys.cs

@@ -10,7 +10,7 @@ public static class CacheKeys
     public static string BlocklistPatterns(InstanceType instanceType) => $"{instanceType.ToString()}_patterns";
     public static string BlocklistRegexes(InstanceType instanceType) => $"{instanceType.ToString()}_regexes";
     
-    public static string Item(string hash) => $"item_{hash}";
+    public static string StrikeItem(string hash, StrikeType strikeType) => $"item_{hash}_{strikeType.ToString()}";
     
     public static string IgnoredDownloads(string name) => $"{name}_ignored";
 }

code/Infrastructure/Verticals/DownloadClient/Deluge/DelugeClient.cs

@@ -27,7 +27,9 @@ public sealed class DelugeClient
         "label",
         "seeding_time",
         "ratio",
-        "trackers"
+        "trackers",
+        "download_payload_rate",
+        "total_size"
     ];
     
     public DelugeClient(IOptions<DelugeConfig> config, IHttpClientFactory httpClientFactory)
@@ -78,11 +80,11 @@ public sealed class DelugeClient
         return torrents.FirstOrDefault();
     }
     
-    public async Task<TorrentStatus?> GetTorrentStatus(string hash)
+    public async Task<DownloadStatus?> GetTorrentStatus(string hash)
     {
         try
         {
-            return await SendRequest<TorrentStatus?>(
+            return await SendRequest<DownloadStatus?>(
                 "web.get_torrent_status",
                 hash,
                 Fields
@@ -100,9 +102,9 @@ public sealed class DelugeClient
         }
     }
     
-    public async Task<List<TorrentStatus>?> GetStatusForAllTorrents()
+    public async Task<List<DownloadStatus>?> GetStatusForAllTorrents()
     {
-        Dictionary<string, TorrentStatus>? downloads = await SendRequest<Dictionary<string, TorrentStatus>?>(
+        Dictionary<string, DownloadStatus>? downloads = await SendRequest<Dictionary<string, DownloadStatus>?>(
             "core.get_torrents_status",
             "",
             Fields

code/Infrastructure/Verticals/DownloadClient/Deluge/DelugeService.cs

@@ -1,10 +1,12 @@
 using System.Collections.Concurrent;
+using System.Globalization;
 using System.Text.RegularExpressions;
 using Common.Attributes;
 using Common.Configuration.ContentBlocker;
 using Common.Configuration.DownloadCleaner;
 using Common.Configuration.DownloadClient;
 using Common.Configuration.QueueCleaner;
+using Common.CustomDataTypes;
 using Domain.Enums;
 using Domain.Models.Deluge.Response;
 using Infrastructure.Extensions;
@@ -50,14 +52,14 @@ public class DelugeService : DownloadService, IDelugeService
     }
 
     /// <inheritdoc/>
-    public override async Task<StalledResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads)
+    public override async Task<DownloadCheckResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads)
     {
         hash = hash.ToLowerInvariant();
         
         DelugeContents? contents = null;
-        StalledResult result = new();
+        DownloadCheckResult result = new();
 
-        TorrentStatus? download = await _client.GetTorrentStatus(hash);
+        DownloadStatus? download = await _client.GetTorrentStatus(hash);
         
         if (download?.Hash is null)
         {
@@ -102,7 +104,7 @@ public class DelugeService : DownloadService, IDelugeService
         }
         
         // remove if download is stuck
-        (result.ShouldRemove, result.DeleteReason) = await IsItemStuckAndShouldRemove(download);
+        (result.ShouldRemove, result.DeleteReason) = await EvaluateDownloadRemoval(download);
 
         return result;
     }
@@ -115,7 +117,7 @@ public class DelugeService : DownloadService, IDelugeService
     {
         hash = hash.ToLowerInvariant();
 
-        TorrentStatus? download = await _client.GetTorrentStatus(hash);
+        DownloadStatus? download = await _client.GetTorrentStatus(hash);
         BlockFilesResult result = new();
         
         if (download?.Hash is null)
@@ -124,9 +126,6 @@ public class DelugeService : DownloadService, IDelugeService
             return result;
         }
         
-        var ceva = await _client.GetTorrentExtended(hash);
-        
-        
         if (ignoredDownloads.Count > 0 && download.ShouldIgnore(ignoredDownloads))
         {
             _logger.LogInformation("skip | download is ignored | {name}", download.Name);
@@ -223,7 +222,7 @@ public class DelugeService : DownloadService, IDelugeService
     public override async Task CleanDownloads(List<object> downloads, List<Category> categoriesToClean, HashSet<string> excludedHashes,
         IReadOnlyList<string> ignoredDownloads)
     {
-        foreach (TorrentStatus download in downloads)
+        foreach (DownloadStatus download in downloads)
         {
             if (string.IsNullOrEmpty(download.Hash))
             {
@@ -296,33 +295,90 @@ public class DelugeService : DownloadService, IDelugeService
         await _client.ChangeFilesPriority(hash, sortedPriorities);
     }
     
-    private async Task<(bool, DeleteReason)> IsItemStuckAndShouldRemove(TorrentStatus status)
+    private async Task<(bool, DeleteReason)> EvaluateDownloadRemoval(DownloadStatus status)
+    {
+        (bool ShouldRemove, DeleteReason Reason) result = await CheckIfSlow(status);
+
+        if (result.ShouldRemove)
+        {
+            return result;
+        }
+
+        return await CheckIfStuck(status);
+    }
+    
+    private async Task<(bool ShouldRemove, DeleteReason Reason)> CheckIfSlow(DownloadStatus download)
+    {
+        if (_queueCleanerConfig.SlowMaxStrikes is 0)
+        {
+            return (false, DeleteReason.None);
+        }
+        
+        if (download.State is null || !download.State.Equals("Downloading", StringComparison.InvariantCultureIgnoreCase))
+        {
+            return (false, DeleteReason.None);
+        }
+        
+        if (download.DownloadSpeed <= 0)
+        {
+            return (false, DeleteReason.None);
+        }
+        
+        if (_queueCleanerConfig.SlowIgnorePrivate && download.Private)
+        {
+            // ignore private trackers
+            _logger.LogDebug("skip slow check | download is private | {name}", download.Name);
+            return (false, DeleteReason.None);
+        }
+        
+        if (download.Size > (_queueCleanerConfig.SlowIgnoreAboveSizeByteSize?.Bytes ?? long.MaxValue))
+        {
+            _logger.LogDebug("skip slow check | download is too large | {name}", download.Name);
+            return (false, DeleteReason.None);
+        }
+        
+        ByteSize minSpeed = _queueCleanerConfig.SlowMinSpeedByteSize;
+        ByteSize currentSpeed = new ByteSize(download.DownloadSpeed);
+        SmartTimeSpan maxTime = SmartTimeSpan.FromHours(_queueCleanerConfig.SlowMaxTime);
+        SmartTimeSpan currentTime = SmartTimeSpan.FromSeconds(download.Eta);
+
+        return await CheckIfSlow(
+            download.Hash!,
+            download.Name!,
+            minSpeed,
+            currentSpeed,
+            maxTime,
+            currentTime
+        );
+    }
+    
+    private async Task<(bool ShouldRemove, DeleteReason Reason)> CheckIfStuck(DownloadStatus status)
     {
         if (_queueCleanerConfig.StalledMaxStrikes is 0)
         {
-            return (false, default);
+            return (false, DeleteReason.None);
         }
         
         if (_queueCleanerConfig.StalledIgnorePrivate && status.Private)
         {
             // ignore private trackers
             _logger.LogDebug("skip stalled check | download is private | {name}", status.Name);
-            return (false, default);
+            return (false, DeleteReason.None);
         }
         
         if (status.State is null || !status.State.Equals("Downloading", StringComparison.InvariantCultureIgnoreCase))
         {
-            return (false, default);
+            return (false, DeleteReason.None);
         }
 
         if (status.Eta > 0)
         {
-            return (false, default);
+            return (false, DeleteReason.None);
         }
         
-        ResetStrikesOnProgress(status.Hash!, status.TotalDone);
-
-        return (await StrikeAndCheckLimit(status.Hash!, status.Name!, StrikeType.Stalled), DeleteReason.Stalled);
+        ResetStalledStrikesOnProgress(status.Hash!, status.TotalDone);
+        
+        return (await _striker.StrikeAndCheckLimit(status.Hash!, status.Name!, _queueCleanerConfig.StalledMaxStrikes, StrikeType.Stalled), DeleteReason.Stalled);
     }
     
     private static void ProcessFiles(Dictionary<string, DelugeFileOrDirectory>? contents, Action<string, DelugeFileOrDirectory> processFile)

code/Infrastructure/Verticals/DownloadClient/DownloadCheckResult.cs

@@ -2,7 +2,7 @@
 
 namespace Infrastructure.Verticals.DownloadClient;
 
-public sealed record StalledResult
+public sealed record DownloadCheckResult
 {
     /// <summary>
     /// True if the download should be removed; otherwise false.

code/Infrastructure/Verticals/DownloadClient/DownloadService.cs

@@ -3,6 +3,7 @@ using System.Text.RegularExpressions;
 using Common.Configuration.ContentBlocker;
 using Common.Configuration.DownloadCleaner;
 using Common.Configuration.QueueCleaner;
+using Common.CustomDataTypes;
 using Common.Helpers;
 using Domain.Enums;
 using Domain.Models.Cache;
@@ -60,7 +61,7 @@ public abstract class DownloadService : IDownloadService
 
     public abstract Task LoginAsync();
 
-    public abstract Task<StalledResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads);
+    public abstract Task<DownloadCheckResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads);
 
     /// <inheritdoc/>
     public abstract Task<BlockFilesResult> BlockUnwantedFilesAsync(string hash,
@@ -78,33 +79,104 @@ public abstract class DownloadService : IDownloadService
     public abstract Task CleanDownloads(List<object> downloads, List<Category> categoriesToClean, HashSet<string> excludedHashes,
         IReadOnlyList<string> ignoredDownloads);
 
-    protected void ResetStrikesOnProgress(string hash, long downloaded)
+    protected void ResetStalledStrikesOnProgress(string hash, long downloaded)
     {
         if (!_queueCleanerConfig.StalledResetStrikesOnProgress)
         {
             return;
         }
-        
-        if (_cache.TryGetValue(CacheKeys.Item(hash), out CacheItem? cachedItem) && cachedItem is not null && downloaded > cachedItem.Downloaded)
+
+        if (_cache.TryGetValue(CacheKeys.StrikeItem(hash, StrikeType.Stalled), out StalledCacheItem? cachedItem) &&
+            cachedItem is not null && downloaded > cachedItem.Downloaded)
         {
             // cache item found
             _cache.Remove(CacheKeys.Strike(StrikeType.Stalled, hash));
-            _logger.LogDebug("resetting strikes for {hash} due to progress", hash);
+            _logger.LogDebug("resetting stalled strikes for {hash} due to progress", hash);
         }
         
-        _cache.Set(CacheKeys.Item(hash), new CacheItem { Downloaded = downloaded }, _cacheOptions);
+        _cache.Set(CacheKeys.StrikeItem(hash, StrikeType.Stalled), new StalledCacheItem { Downloaded = downloaded }, _cacheOptions);
+    }
+    
+    protected void ResetSlowSpeedStrikesOnProgress(string downloadName, string hash)
+    {
+        if (!_queueCleanerConfig.SlowResetStrikesOnProgress)
+        {
+            return;
+        }
+
+        string key = CacheKeys.Strike(StrikeType.SlowSpeed, hash);
+
+        if (!_cache.TryGetValue(key, out object? value) || value is null)
+        {
+            return;
+        }
+        
+        _cache.Remove(key);
+        _logger.LogDebug("resetting slow speed strikes due to progress | {name}", downloadName);
+    }
+    
+    protected void ResetSlowTimeStrikesOnProgress(string downloadName, string hash)
+    {
+        if (!_queueCleanerConfig.SlowResetStrikesOnProgress)
+        {
+            return;
+        }
+
+        string key = CacheKeys.Strike(StrikeType.SlowTime, hash);
+
+        if (!_cache.TryGetValue(key, out object? value) || value is null)
+        {
+            return;
+        }
+        
+        _cache.Remove(key);
+        _logger.LogDebug("resetting slow time strikes due to progress | {name}", downloadName);
     }
 
-    /// <summary>
-    /// Strikes an item and checks if the limit has been reached.
-    /// </summary>
-    /// <param name="hash">The torrent hash.</param>
-    /// <param name="itemName">The name or title of the item.</param>
-    /// <param name="strikeType"></param>
-    /// <returns>True if the limit has been reached; otherwise, false.</returns>
-    protected async Task<bool> StrikeAndCheckLimit(string hash, string itemName, StrikeType strikeType)
+    protected async Task<(bool ShouldRemove, DeleteReason Reason)> CheckIfSlow(
+        string downloadHash,
+        string downloadName,
+        ByteSize minSpeed,
+        ByteSize currentSpeed,
+        SmartTimeSpan maxTime,
+        SmartTimeSpan currentTime
+    )
     {
-        return await _striker.StrikeAndCheckLimit(hash, itemName, _queueCleanerConfig.StalledMaxStrikes, strikeType);
+        if (minSpeed.Bytes > 0 && currentSpeed < minSpeed)
+        {
+            _logger.LogTrace("slow speed | {speed}/s | {name}", currentSpeed.ToString(), downloadName);
+            
+            bool shouldRemove = await _striker
+                .StrikeAndCheckLimit(downloadHash, downloadName, _queueCleanerConfig.SlowMaxStrikes, StrikeType.SlowSpeed);
+
+            if (shouldRemove)
+            {
+                return (true, DeleteReason.SlowSpeed);
+            }
+        }
+        else
+        {
+            ResetSlowSpeedStrikesOnProgress(downloadName, downloadHash);
+        }
+        
+        if (maxTime.Time > TimeSpan.Zero && currentTime > maxTime)
+        {
+            _logger.LogTrace("slow estimated time | {time} | {name}", currentTime.ToString(), downloadName);
+            
+            bool shouldRemove = await _striker
+                .StrikeAndCheckLimit(downloadHash, downloadName, _queueCleanerConfig.SlowMaxStrikes, StrikeType.SlowTime);
+
+            if (shouldRemove)
+            {
+                return (true, DeleteReason.SlowTime);
+            }
+        }
+        else
+        {
+            ResetSlowTimeStrikesOnProgress(downloadName, downloadHash);
+        }
+        
+        return (false, DeleteReason.None);
     }
     
     protected SeedingCheckResult ShouldCleanDownload(double ratio, TimeSpan seedingTime, Category category)

code/Infrastructure/Verticals/DownloadClient/DummyDownloadService.cs

@@ -28,7 +28,7 @@ public class DummyDownloadService : DownloadService
         return Task.CompletedTask;
     }
 
-    public override Task<StalledResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads)
+    public override Task<DownloadCheckResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads)
     {
         throw new NotImplementedException();
     }

code/Infrastructure/Verticals/DownloadClient/IDownloadService.cs

@@ -15,7 +15,7 @@ public interface IDownloadService : IDisposable
     /// </summary>
     /// <param name="hash">The download hash.</param>
     /// <param name="ignoredDownloads">Downloads to ignore from processing.</param>
-    public Task<StalledResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads);
+    public Task<DownloadCheckResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads);
 
     /// <summary>
     /// Blocks unwanted files from being fully downloaded.

code/Infrastructure/Verticals/DownloadClient/QBittorrent/QBitService.cs

@@ -5,6 +5,7 @@ using Common.Configuration.ContentBlocker;
 using Common.Configuration.DownloadCleaner;
 using Common.Configuration.DownloadClient;
 using Common.Configuration.QueueCleaner;
+using Common.CustomDataTypes;
 using Common.Helpers;
 using Domain.Enums;
 using Infrastructure.Extensions;
@@ -63,9 +64,9 @@ public class QBitService : DownloadService, IQBitService
     }
 
     /// <inheritdoc/>
-    public override async Task<StalledResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads)
+    public override async Task<DownloadCheckResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads)
     {
-        StalledResult result = new();
+        DownloadCheckResult result = new();
         TorrentInfo? download = (await _client.GetTorrentListAsync(new TorrentListQuery { Hashes = [hash] }))
             .FirstOrDefault();
 
@@ -114,8 +115,7 @@ public class QBitService : DownloadService, IQBitService
             return result;
         }
 
-        // remove if download is stuck
-        (result.ShouldRemove, result.DeleteReason) = await IsItemStuckAndShouldRemove(download, result.IsPrivate);
+        (result.ShouldRemove, result.DeleteReason) = await EvaluateDownloadRemoval(download, result.IsPrivate);
 
         return result;
     }
@@ -333,35 +333,96 @@ public class QBitService : DownloadService, IQBitService
         _client.Dispose();
     }
 
-    private async Task<(bool, DeleteReason)> IsItemStuckAndShouldRemove(TorrentInfo torrent, bool isPrivate)
+    private async Task<(bool, DeleteReason)> EvaluateDownloadRemoval(TorrentInfo torrent, bool isPrivate)
+    {
+        (bool ShouldRemove, DeleteReason Reason) result = await CheckIfSlow(torrent, isPrivate);
+
+        if (result.ShouldRemove)
+        {
+            return result;
+        }
+
+        return await CheckIfStuck(torrent, isPrivate);
+    }
+
+    private async Task<(bool ShouldRemove, DeleteReason Reason)> CheckIfSlow(TorrentInfo download, bool isPrivate)
+    {
+        if (_queueCleanerConfig.SlowMaxStrikes is 0)
+        {
+            return (false, DeleteReason.None);
+        }
+        
+        if (download.State is not (TorrentState.Downloading or TorrentState.ForcedDownload))
+        {
+            return (false, DeleteReason.None);
+        }
+        
+        if (download.DownloadSpeed <= 0)
+        {
+            return (false, DeleteReason.None);
+        }
+        
+        if (_queueCleanerConfig.SlowIgnorePrivate && isPrivate)
+        {
+            // ignore private trackers
+            _logger.LogDebug("skip slow check | download is private | {name}", download.Name);
+            return (false, DeleteReason.None);
+        }
+
+        if (download.Size > (_queueCleanerConfig.SlowIgnoreAboveSizeByteSize?.Bytes ?? long.MaxValue))
+        {
+            _logger.LogDebug("skip slow check | download is too large | {name}", download.Name);
+            return (false, DeleteReason.None);
+        }
+        
+        ByteSize minSpeed = _queueCleanerConfig.SlowMinSpeedByteSize;
+        ByteSize currentSpeed = new ByteSize(download.DownloadSpeed);
+        SmartTimeSpan maxTime = SmartTimeSpan.FromHours(_queueCleanerConfig.SlowMaxTime);
+        SmartTimeSpan currentTime = new SmartTimeSpan(download.EstimatedTime ?? TimeSpan.Zero);
+
+        return await CheckIfSlow(
+            download.Hash,
+            download.Name,
+            minSpeed,
+            currentSpeed,
+            maxTime,
+            currentTime
+        );
+    }
+
+    private async Task<(bool ShouldRemove, DeleteReason Reason)> CheckIfStuck(TorrentInfo torrent, bool isPrivate)
     {
         if (_queueCleanerConfig.StalledMaxStrikes is 0)
         {
-            return (false, default);
-        }
-        
-        if (_queueCleanerConfig.StalledIgnorePrivate && isPrivate)
-        {
-            // ignore private trackers
-            _logger.LogDebug("skip stalled check | download is private | {name}", torrent.Name);
-            return (false, default);
+            return (false, DeleteReason.None);
         }
         
         if (torrent.State is not TorrentState.StalledDownload and not TorrentState.FetchingMetadata
             and not TorrentState.ForcedFetchingMetadata)
         {
             // ignore other states
-            return (false, default);
+            return (false, DeleteReason.None);
         }
-
-        ResetStrikesOnProgress(torrent.Hash, torrent.Downloaded ?? 0);
-
+        
+        if (_queueCleanerConfig.StalledIgnorePrivate && isPrivate)
+        {
+            // ignore private trackers
+            _logger.LogDebug("skip stalled check | download is private | {name}", torrent.Name);
+            return (false, DeleteReason.None);
+        }
+        
         if (torrent.State is TorrentState.StalledDownload)
         {
-            return (await StrikeAndCheckLimit(torrent.Hash, torrent.Name, StrikeType.Stalled), DeleteReason.Stalled);
+            _logger.LogTrace("stalled download | {name}", torrent.Name);
+            
+            ResetStalledStrikesOnProgress(torrent.Hash, torrent.Downloaded ?? 0);
+            
+            return (await _striker.StrikeAndCheckLimit(torrent.Hash, torrent.Name, _queueCleanerConfig.StalledMaxStrikes, StrikeType.Stalled), DeleteReason.Stalled);
         }
 
-        return (await StrikeAndCheckLimit(torrent.Hash, torrent.Name, StrikeType.DownloadingMetadata), DeleteReason.DownloadingMetadata);
+        _logger.LogTrace("downloading metadata | {name}", torrent.Name);
+        
+        return (await _striker.StrikeAndCheckLimit(torrent.Hash, torrent.Name, _queueCleanerConfig.StalledMaxStrikes, StrikeType.DownloadingMetadata), DeleteReason.DownloadingMetadata);
     }
 
     private async Task<IReadOnlyList<TorrentTracker>> GetTrackersAsync(string hash)

code/Infrastructure/Verticals/DownloadClient/Transmission/TransmissionService.cs

@@ -5,6 +5,7 @@ using Common.Configuration.ContentBlocker;
 using Common.Configuration.DownloadCleaner;
 using Common.Configuration.DownloadClient;
 using Common.Configuration.QueueCleaner;
+using Common.CustomDataTypes;
 using Common.Helpers;
 using Domain.Enums;
 using Infrastructure.Extensions;
@@ -41,7 +42,9 @@ public class TransmissionService : DownloadService, ITransmissionService
         TorrentFields.DOWNLOAD_DIR,
         TorrentFields.SECONDS_SEEDING,
         TorrentFields.UPLOAD_RATIO,
-        TorrentFields.TRACKERS
+        TorrentFields.TRACKERS,
+        TorrentFields.RATE_DOWNLOAD,
+        TorrentFields.TOTAL_SIZE
     ];
 
     public TransmissionService(
@@ -81,9 +84,9 @@ public class TransmissionService : DownloadService, ITransmissionService
     }
 
     /// <inheritdoc/>
-    public override async Task<StalledResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads)
+    public override async Task<DownloadCheckResult> ShouldRemoveFromArrQueueAsync(string hash, IReadOnlyList<string> ignoredDownloads)
     {
-        StalledResult result = new();
+        DownloadCheckResult result = new();
         TorrentInfo? download = await GetTorrentAsync(hash);
 
         if (download is null)
@@ -125,7 +128,7 @@ public class TransmissionService : DownloadService, ITransmissionService
         }
 
         // remove if download is stuck
-        (result.ShouldRemove, result.DeleteReason) = await IsItemStuckAndShouldRemove(download);
+        (result.ShouldRemove, result.DeleteReason) = await EvaluateDownloadRemoval(download);
 
         return result;
     }
@@ -335,34 +338,92 @@ public class TransmissionService : DownloadService, ITransmissionService
         });
     }
     
-    private async Task<(bool, DeleteReason)> IsItemStuckAndShouldRemove(TorrentInfo torrent)
+    private async Task<(bool, DeleteReason)> EvaluateDownloadRemoval(TorrentInfo torrent)
+    {
+        (bool ShouldRemove, DeleteReason Reason) result = await CheckIfSlow(torrent);
+
+        if (result.ShouldRemove)
+        {
+            return result;
+        }
+
+        return await CheckIfStuck(torrent);
+    }
+
+    private async Task<(bool ShouldRemove, DeleteReason Reason)> CheckIfSlow(TorrentInfo download)
+    {
+        if (_queueCleanerConfig.SlowMaxStrikes is 0)
+        {
+            return (false, DeleteReason.None);
+        }
+        
+        if (download.Status is not 4)
+        {
+            // not in downloading state
+            return (false, DeleteReason.None);
+        }
+        
+        if (download.RateDownload <= 0)
+        {
+            return (false, DeleteReason.None);
+        }
+        
+        if (_queueCleanerConfig.SlowIgnorePrivate && download.IsPrivate is true)
+        {
+            // ignore private trackers
+            _logger.LogDebug("skip slow check | download is private | {name}", download.Name);
+            return (false, DeleteReason.None);
+        }
+
+        if (download.TotalSize > (_queueCleanerConfig.SlowIgnoreAboveSizeByteSize?.Bytes ?? long.MaxValue))
+        {
+            _logger.LogDebug("skip slow check | download is too large | {name}", download.Name);
+            return (false, DeleteReason.None);
+        }
+        
+        ByteSize minSpeed = _queueCleanerConfig.SlowMinSpeedByteSize;
+        ByteSize currentSpeed = new ByteSize(download.RateDownload ?? long.MaxValue);
+        SmartTimeSpan maxTime = SmartTimeSpan.FromHours(_queueCleanerConfig.SlowMaxTime);
+        SmartTimeSpan currentTime = SmartTimeSpan.FromSeconds(download.Eta ?? 0);
+
+        return await CheckIfSlow(
+            download.HashString!,
+            download.Name!,
+            minSpeed,
+            currentSpeed,
+            maxTime,
+            currentTime
+        );
+    }
+
+    private async Task<(bool ShouldRemove, DeleteReason Reason)> CheckIfStuck(TorrentInfo download)
     {
         if (_queueCleanerConfig.StalledMaxStrikes is 0)
         {
-            return (false, default);
+            return (false, DeleteReason.None);
         }
         
-        if (_queueCleanerConfig.StalledIgnorePrivate && (torrent.IsPrivate ?? false))
-        {
-            // ignore private trackers
-            _logger.LogDebug("skip stalled check | download is private | {name}", torrent.Name);
-            return (false, default);
-        }
-        
-        if (torrent.Status is not 4)
+        if (download.Status is not 4)
         {
             // not in downloading state
-            return (false, default);
-        }
-
-        if (torrent.Eta > 0)
-        {
-            return (false, default);
+            return (false, DeleteReason.None);
         }
         
-        ResetStrikesOnProgress(torrent.HashString!, torrent.DownloadedEver ?? 0);
-
-        return (await StrikeAndCheckLimit(torrent.HashString!, torrent.Name!, StrikeType.Stalled), DeleteReason.Stalled);
+        if (download.RateDownload > 0 || download.Eta > 0)
+        {
+            return (false, DeleteReason.None);
+        }
+        
+        if (_queueCleanerConfig.StalledIgnorePrivate && (download.IsPrivate ?? false))
+        {
+            // ignore private trackers
+            _logger.LogDebug("skip stalled check | download is private | {name}", download.Name);
+            return (false, DeleteReason.None);
+        }
+        
+        ResetStalledStrikesOnProgress(download.HashString!, download.DownloadedEver ?? 0);
+        
+        return (await _striker.StrikeAndCheckLimit(download.HashString!, download.Name!, _queueCleanerConfig.StalledMaxStrikes, StrikeType.Stalled), DeleteReason.Stalled);
     }
 
     private async Task<TorrentInfo?> GetTorrentAsync(string hash) =>

code/Infrastructure/Verticals/QueueCleaner/QueueCleaner.cs

@@ -77,6 +77,8 @@ public sealed class QueueCleaner : GenericHandler
                 
                 QueueRecord record = group.First();
                 
+                _logger.LogTrace("processing | {title} | {id}", record.Title, record.DownloadId);
+                
                 if (!arrClient.IsRecordValid(record))
                 {
                     continue;
@@ -91,7 +93,7 @@ public sealed class QueueCleaner : GenericHandler
                 // push record to context
                 ContextProvider.Set(nameof(QueueRecord), record);
 
-                StalledResult stalledCheckResult = new();
+                DownloadCheckResult downloadCheckResult = new();
 
                 if (record.Protocol is "torrent" && _downloadClientConfig.DownloadClient is not Common.Enums.DownloadClient.Disabled)
                 {
@@ -102,14 +104,14 @@ public sealed class QueueCleaner : GenericHandler
                     }
                     
                     // stalled download check
-                    stalledCheckResult = await _downloadService.ShouldRemoveFromArrQueueAsync(record.DownloadId, ignoredDownloads);
+                    downloadCheckResult = await _downloadService.ShouldRemoveFromArrQueueAsync(record.DownloadId, ignoredDownloads);
                 }
                 
                 // failed import check
-                bool shouldRemoveFromArr = await arrClient.ShouldRemoveFromQueue(instanceType, record, stalledCheckResult.IsPrivate);
-                DeleteReason deleteReason = stalledCheckResult.ShouldRemove ? stalledCheckResult.DeleteReason : DeleteReason.ImportFailed;
+                bool shouldRemoveFromArr = await arrClient.ShouldRemoveFromQueue(instanceType, record, downloadCheckResult.IsPrivate);
+                DeleteReason deleteReason = downloadCheckResult.ShouldRemove ? downloadCheckResult.DeleteReason : DeleteReason.ImportFailed;
 
-                if (!shouldRemoveFromArr && !stalledCheckResult.ShouldRemove)
+                if (!shouldRemoveFromArr && !downloadCheckResult.ShouldRemove)
                 {
                     _logger.LogInformation("skip | {title}", record.Title);
                     continue;
@@ -119,14 +121,20 @@ public sealed class QueueCleaner : GenericHandler
 
                 bool removeFromClient = true;
 
-                if (stalledCheckResult.IsPrivate)
+                if (downloadCheckResult.IsPrivate)
                 {
-                    if (stalledCheckResult.ShouldRemove && !_config.StalledDeletePrivate)
-                    {
-                        removeFromClient = false;
-                    }
+                    bool isStalledWithoutPruneFlag = 
+                        downloadCheckResult.DeleteReason is DeleteReason.Stalled && 
+                        !_config.StalledDeletePrivate;
+    
+                    bool isSlowWithoutPruneFlag = 
+                        downloadCheckResult.DeleteReason is DeleteReason.SlowSpeed or DeleteReason.SlowTime && 
+                        !_config.SlowDeletePrivate;
+    
+                    bool shouldKeepDueToDeleteRules = downloadCheckResult.ShouldRemove && (isStalledWithoutPruneFlag || isSlowWithoutPruneFlag);
+                    bool shouldKeepDueToImportRules = shouldRemoveFromArr && !_config.ImportFailedDeletePrivate;
 
-                    if (shouldRemoveFromArr && !_config.ImportFailedDeletePrivate)
+                    if (shouldKeepDueToDeleteRules || shouldKeepDueToImportRules)
                     {
                         removeFromClient = false;
                     }