Making Umbraco 13 LogViewer Resilient to Corrupted JSON Logs

Newtonsoft.Json.JsonReaderException: The reader's MaxDepth of 64 has been exceeded.

public static IUmbracoBuilder SetCustomLogViewer(this IUmbracoBuilder builder)
{
    builder.Services.AddSingleton<ILogViewer, UmbracoCustomLogViewer>();

    return builder;
}

Newtonsoft.Json.JsonSerializationException: Unexpected end when deserializing object.
Path '@x', line 1, position 931.

if (File.Exists(filePath + CorruptedMarkerExtension))
    continue;

internal class UmbracoCustomLogViewer : SerilogLogViewerSourceBase
{
    private const int FileSizeCap = 100;
    private const string CorruptedMarkerExtension = ".corrupted-skip";
    
    private readonly ILogger<UmbracoCustomLogViewer> _logger;
    private readonly string _logsPath;

    public UmbracoCustomLogViewer(
        ILogger<UmbracoCustomLogViewer> logger,
        ILogViewerConfig logViewerConfig,
        ILoggingConfiguration loggingConfiguration,
        ILogLevelLoader logLevelLoader,
        ILogger serilogLog)
        : base(logViewerConfig, logLevelLoader, serilogLog)
    {
        _logger = logger;
        _logsPath = loggingConfiguration.LogDirectory;
    }

    public override bool CanHandleLargeLogs => false;

    public override bool CheckCanOpenLogs(LogTimePeriod logTimePeriod)
    {
        // Log Directory
        var logDirectory = _logsPath;

        // Number of entries
        long fileSizeCount = 0;

        // foreach full day in the range - see if we can find one or more filenames that end with
        // yyyyMMdd.json - Ends with due to MachineName in filenames - could be 1 or more due to load balancing
        for (DateTime day = logTimePeriod.StartTime.Date; day.Date <= logTimePeriod.EndTime.Date; day = day.AddDays(1))
        {
            // Filename ending to search for (As could be multiple)
            var filesToFind = GetSearchPattern(day);

            var filesForCurrentDay = Directory.GetFiles(logDirectory, filesToFind);

            fileSizeCount += filesForCurrentDay.Sum(x => new FileInfo(x).Length);
        }

        // The GetLogSize call on JsonLogViewer returns the total file size in bytes
        // Check if the log size is not greater than 100Mb (FileSizeCap)
        var logSizeAsMegabytes = fileSizeCount / 1024 / 1024;
        
        return logSizeAsMegabytes <= FileSizeCap;
    }

    protected override IReadOnlyList<LogEvent> GetLogs(LogTimePeriod logTimePeriod, ILogFilter filter, int skip,
        int take)
    {
        var logs = new List<LogEvent>();

        var count = 0;
        var corruptedFiles = new HashSet<string>();
        
        var serializerSettings = GetJsonSerializerSettings();
        var jsonSerializer =  JsonSerializer.Create(serializerSettings);

        // foreach full day in the range - see if we can find one or more filenames that end with
        // yyyyMMdd.json - Ends with due to MachineName in filenames - could be 1 or more due to load balancing
        for (DateTime day = logTimePeriod.StartTime.Date; day.Date <= logTimePeriod.EndTime.Date; day = day.AddDays(1))
        {
            // Filename ending to search for (As could be multiple)
            var filesToFind = GetSearchPattern(day);

            var filesForCurrentDay = Directory.GetFiles(_logsPath, filesToFind);

            // Foreach file we find - open it
            foreach (var filePath in filesForCurrentDay)
            {
                if (File.Exists(filePath + CorruptedMarkerExtension))
                    continue;
                
                var fileIsCorrupted = false;
                
                // Open log file & add contents to the log collection
                // Which we then use LINQ to page over
                using (var fs = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                {
                    using (var stream = new StreamReader(fs))
                    {
                        var reader = new LogEventReader(stream, jsonSerializer);
                        
                        while (TryRead(reader, filePath, out LogEvent? evt, ref fileIsCorrupted))
                        {
                            // We may get a null if log line is malformed
                            if (evt == null)
                            {
                                continue;
                            }

                            if (count > skip + take)
                            {
                                break;
                            }

                            if (count < skip)
                            {
                                count++;
                                continue;
                            }

                            if (filter.TakeLogEvent(evt))
                            {
                                logs.Add(evt);
                            }

                            count++;
                        }
                    }
                }
                
                if (fileIsCorrupted)
                {
                    corruptedFiles.Add(filePath);
                }
            }
        }
        
        MarkCorruptedFiles(corruptedFiles);

        return logs;
    }

    private string GetSearchPattern(DateTime day) => $"*{day:yyyyMMdd}*.json";

    private bool TryRead(LogEventReader reader, string filePath, out LogEvent? evt, ref bool fileIsCorrupted)
    {
        evt = null;

        try
        {
            return reader.TryRead(out evt);
        }
        catch (JsonReaderException ex)
        {
            fileIsCorrupted = true;
            
            _logger.LogWarning(ex, "JSON Reader error detected in file '{FilePath}'. Corruption marker will be created.", filePath);

            return false;
        }
        catch (JsonSerializationException ex)
        {
            fileIsCorrupted = true;
            
            _logger.LogWarning(ex, "JSON Serialization error detected in file '{FilePath}'. Corruption marker will be created.", filePath);

            return false;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "An unexpected error occurred while reading a log event from file '{FilePath}'.", filePath);

            throw;
        }
    }
    
    private void MarkCorruptedFiles(HashSet<string> corruptedFiles)
    {
        foreach (var filePath in corruptedFiles)
        {
            try
            {
                var markerPath = filePath + CorruptedMarkerExtension;
                
                // Create empty marker file if it doesn't exist
                if (!File.Exists(markerPath))
                {
                    File.WriteAllText(markerPath, string.Empty);
                    
                    _logger.LogWarning("Marked corrupted log file '{FilePath}' with marker '{MarkerPath}'.", filePath, markerPath);
                }
            }
            catch (Exception ex)
            {
                _logger.LogWarning(ex, "Failed to create corruption marker for file '{FilePath}'.", filePath);
            }
        }
    }
    
    private JsonSerializerSettings GetJsonSerializerSettings()
    {
        return new JsonSerializerSettings
        {
            DateParseHandling = DateParseHandling.None,
            Culture = System.Globalization.CultureInfo.InvariantCulture,
            MaxDepth = 128
        };
    }
}