public Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { XmlSerializer serializer = new XmlSerializer(typeof(activity)); List <AnalogyLogMessage> msg = new List <AnalogyLogMessage>(); using (StreamReader reader = new StreamReader(fileName)) { var entries = (activity)serializer.Deserialize(reader); reader.Close(); foreach (activityEntry entry in entries.entry) { AnalogyLogLevel level = entry.type == "Information" ? AnalogyLogLevel.Information : (entry.type == "Warning" ? AnalogyLogLevel.Warning : AnalogyLogLevel.Error); AnalogyLogMessage m = new AnalogyLogMessage(entry.description, level, AnalogyLogClass.General, ""); if (DateTime.TryParse(entry.time, out var time)) { m.Date = time; } m.Source = entry.source; m.AdditionalInformation = new Dictionary <string, string>(); m.AdditionalInformation.Add("GUID", entry.guid); m.AdditionalInformation.Add("HR", entry.hr.ToString()); m.AdditionalInformation.Add("Is Specific", entry.hrSpecified.ToString()); m.AdditionalInformation.Add("Path", entry.path); messagesHandler.AppendMessage(m, fileName); msg.Add(m); } } return(Task.FromResult(msg.AsEnumerable())); }
public FileProcessor(ILogMessageCreatedHandler dataWindow) { DataWindow = dataWindow; if (dataWindow is UCLogs logs) { LogWindow = logs; } }
public override async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { if (CanOpenFile(fileName)) { return(await PlainTextLogFileParser.Process(fileName, token, messagesHandler)); } return(new List <AnalogyLogMessage>(0)); }
public async Task <List <AnalogyLogMessage> > ParseLog(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { _messages.Clear(); using (StreamReader reader = File.OpenText(fileName)) { string line; while ((line = await reader.ReadLineAsync()) != null) { AnalogyLogMessage entry = null; foreach (var logPattern in LogPatterns) { if (TryParse(line, logPattern, out entry)) { break; } } if (entry != null) { if (updateUIAfterEachParsedLine) { messagesHandler.AppendMessage(entry, fileName); } _current = entry; _messages.Add(_current); } else { if (_current == null) { _current = new AnalogyLogMessage { Text = line }; } else { _current.Text += Environment.NewLine + line; } } if (token.IsCancellationRequested) { messagesHandler.AppendMessages(_messages, fileName); return(_messages); } } } if (!updateUIAfterEachParsedLine) //update only at the end { messagesHandler.AppendMessages(_messages, fileName); } return(_messages); }
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { if (string.IsNullOrEmpty(fileName)) { AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None") { Source = "Analogy", Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName }; messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { empty }); } switch (JsonSettings.Format) { case FileFormat.Unknown: AnalogyLogMessage empty = new AnalogyLogMessage($"File Format is unknown. Unable to read file", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None") { Source = "Analogy", Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName }; messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { empty }); break; case FileFormat.JsonFormatPerLine: return(ProcessJsonPerLine(fileName, token, messagesHandler)); break; case FileFormat.JsonFormatFile: return(ProcessJsonFile(fileName, token, messagesHandler)); break; default: AnalogyLogMessage none = new AnalogyLogMessage($"Unknown file format", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None") { Source = "Analogy", Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName }; messagesHandler.AppendMessage(none, Utils.GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { none }); } }
private List <AnalogyLogMessage> ProcessJsonPerLine(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>(); var jsons = File.ReadAllLines(fileName); for (var i = 0; i < jsons.Length; i++) { var json = jsons[i]; var msgs = ProcessJsonData(json, fileName, messagesHandler, false); messages.AddRange(msgs); messagesHandler.ReportFileReadProgress(new AnalogyFileReadProgress(AnalogyFileReadProgressType.Percentage, 1, i, jsons.Length)); } return(messages); }
public RemoveLeadingNewLine(ILogMessageCreatedHandler nominalMessagesHandler) { _messagesHandler = nominalMessagesHandler; ForceNoFileCaching = _messagesHandler.ForceNoFileCaching; DoNotAddToRecentHistory = _messagesHandler.DoNotAddToRecentHistory; }
public override Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) => parser.Process(fileName, token, messagesHandler);
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { var messages = await Task <IEnumerable <AnalogyLogMessage> > .Factory.StartNew(() => { List <AnalogyLogMessage> parsedMessages = new List <AnalogyLogMessage>(); try { using (var analogy = new LoggerConfiguration() .WriteTo.Analogy() .CreateLogger()) { using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) using (var streamReader = new StreamReader(fileStream, Encoding.UTF8)) { var json = streamReader.ReadToEnd(); var data = JsonConvert.DeserializeObject(json); if (data is JObject jo) { var m = ParserJObject(jo, analogy); parsedMessages.Add(m); } else if (data is JArray arr) { foreach (var obj in arr.ToList()) { if (obj is JObject j) { var m = ParserJObject(j, analogy); parsedMessages.Add(m); } } } } } if (TimeStampTimeZone != null) { foreach (var m in parsedMessages) { m.Date = TimeZoneInfo.ConvertTimeFromUtc(m.Date, TimeStampTimeZone); } } messagesHandler.AppendMessages(parsedMessages, fileName); return(parsedMessages); } catch (Exception e) { AnalogyLogMessage empty = new AnalogyLogMessage($"Error reading file {fileName}: Error: {e.Message}", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None"); empty.Source = nameof(ClefParser); empty.Module = "Analogy.LogViewer.Serilog"; parsedMessages.Add(empty); messagesHandler.AppendMessages(parsedMessages, fileName); return(parsedMessages); } }); return(messages); }
public async Task <List <AnalogyLogMessage> > ParseLog(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { _messages.Clear(); try { using (FileStream logFileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { using (StreamReader reader = new StreamReader(logFileStream)) { string line; while ((line = await reader.ReadLineAsync()) != null) { AnalogyLogMessage entry = null; foreach (var logPattern in LogPatterns) { if (TryParse(line, logPattern, out entry)) { break; } } if (entry != null) { if (updateUIAfterEachParsedLine) { messagesHandler.AppendMessage(entry, fileName); } _current = entry; _messages.Add(_current); } else { if (_current == null) { _current = new AnalogyLogMessage { Text = line }; } else { _current.Text += Environment.NewLine + line; } } if (token.IsCancellationRequested) { messagesHandler.AppendMessages(_messages, fileName); return(_messages); } } } } if (!updateUIAfterEachParsedLine) //update only at the end { messagesHandler.AppendMessages(_messages, fileName); } // Reset so that any settings-changes are reflected next time we run _lastUsedPattern = null; return(_messages); } catch (Exception e) { Logger.LogException($"Error reading file: {e.Message}", e, nameof(ParseLog)); AnalogyLogMessage error = new AnalogyLogMessage($"Error reading file: {e.Message}", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "Analogy"); messagesHandler.AppendMessages(_messages, fileName); _messages.Add(error); return(_messages); } }
internal Task <List <AnalogyLogMessage> > ReadFromFile(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { return(Task.Factory.StartNew(() => { XmlSerializer ser = new XmlSerializer(typeof(List <AnalogyLogMessage>)); using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { try { var messages = (List <AnalogyLogMessage>)ser.Deserialize(fs); messagesHandler.AppendMessages(messages, fileName); return messages; } catch (Exception e) { AnalogyLogMessage errMessage = new AnalogyLogMessage( $"Error reading file {fileName}: {e.Message}", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None") { Source = "Analogy", Module = Process.GetCurrentProcess().ProcessName }; AnalogyLogManager.Instance.LogErrorMessage(errMessage); messagesHandler.AppendMessage(errMessage, fileName); return new List <AnalogyLogMessage>() { errMessage }; } } }, token)); }
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { if (string.IsNullOrEmpty(fileName)) { AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.", AnalogyLogLevel.Critical, AnalogyLogClass.General, source, "None") { Source = source, Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName }; messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { empty }); } List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>(); try { var messagesInternal = new List <Message>(); var chatLog = File.ReadAllLines(fileName); foreach (var chatLine in chatLog) { var messageInternal = GetMessage(messagesInternal, chatLine, UserSettingsManager.UserSettings.CultureInfo); if (messageInternal != null) { messagesInternal.Add(messageInternal); } } for (var i = 0; i < messagesInternal.Count; i++) { var mi = messagesInternal[i]; AnalogyLogMessage m = new AnalogyLogMessage { Text = mi.Text, Date = mi.TimeStamp, User = mi.MessageBy ?? "" }; m.Source = m.User; messages.Add(m); messagesHandler.ReportFileReadProgress( new AnalogyFileReadProgress(AnalogyFileReadProgressType.Percentage, 1, i, messagesInternal.Count)); } messagesHandler.AppendMessages(messages, fileName); return(messages); } catch (Exception e) { AnalogyLogMessage empty = new AnalogyLogMessage( $"Error occured processing file {fileName}. Reason: {e.Message}", AnalogyLogLevel.Critical, AnalogyLogClass.General, source, "None") { Source = source, Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName }; messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { empty }); } }
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { if (string.IsNullOrEmpty(fileName)) { AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None") { Source = "Analogy", Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName }; messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { empty }); } List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>(); try { AnalogyLogMessage?entry = null; using (var stream = File.OpenRead(fileName)) { using (var reader = new StreamReader(stream)) { long count = 0; while (!reader.EndOfStream) { var line = await reader.ReadLineAsync(); var indexOfFirstSpace = line.IndexOf(' '); if (indexOfFirstSpace == 28 && DateTime.TryParse(line.Substring(0, indexOfFirstSpace), out var dateTime)) { if (entry != null) { messages.Add(entry); count++; messagesHandler.ReportFileReadProgress(new AnalogyFileReadProgress(AnalogyFileReadProgressType.Incremental, 1, count, count)); } string data = line.Substring(indexOfFirstSpace + 1); entry = new AnalogyLogMessage(); entry.Text = data; entry.Date = dateTime; entry.Level = GetLogLevel(data); entry.Id = Guid.NewGuid(); entry.Source = GetFileNameAsDataSource(fileName); entry.Module = ""; } else if (entry != null) { if (entry.Text == "") { entry.Text = line; } else { entry.Text += Environment.NewLine + line; } } } } } messagesHandler.AppendMessages(messages, fileName); return(messages); } catch (Exception e) { AnalogyLogMessage empty = new AnalogyLogMessage($"Error occured processing file {fileName}. Reason: {e.Message}", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None") { Source = "Analogy", Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName }; messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { empty }); } }
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { if (CanOpenFile(fileName)) { EventViewerLogLoader logLoader = new EventViewerLogLoader(token); var messages = await logLoader.ReadFromFile(fileName, messagesHandler).ConfigureAwait(false); return(messages); } AnalogyLogMessage m = new AnalogyLogMessage(); m.Text = $"Unsupported file: {fileName}. Skipping file"; m.Level = AnalogyLogLevel.Critical; m.Source = "Analogy"; m.Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName; m.ProcessID = System.Diagnostics.Process.GetCurrentProcess().Id; m.Class = AnalogyLogClass.General; m.User = Environment.UserName; m.Date = DateTime.Now; messagesHandler.AppendMessage(m, Environment.MachineName); return(new List <AnalogyLogMessage>() { m }); }
public FileProcessor(ILogMessageCreatedHandler dataWindow) { DataWindow = dataWindow; }
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { if (string.IsNullOrEmpty(fileName)) { AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None") { Source = "Analogy", Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName }; messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { empty }); } if (!_logFileSettings.IsConfigured) { AnalogyLogMessage empty = new AnalogyLogMessage($"File Parser is not configured. Please set it first in the settings Window", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None") { Source = "Analogy", Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName }; messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { empty }); } if (!_logFileSettings.CanOpenFile(fileName)) { AnalogyLogMessage empty = new AnalogyLogMessage($"File {fileName} Is not supported or not configured correctly in the windows settings", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None") { Source = "Analogy", Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName }; messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { empty }); } List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>(); try { using (var stream = File.OpenRead(fileName)) { using (var reader = new StreamReader(stream)) { while (!reader.EndOfStream) { var line = await reader.ReadLineAsync() ?? ""; var items = line.Split(_parser.splitters, StringSplitOptions.RemoveEmptyEntries); while (items.Length < _logFileSettings.ValidItemsCount) { line = line + Environment.NewLine + await reader.ReadLineAsync(); items = line.Split(_parser.splitters, StringSplitOptions.RemoveEmptyEntries); } var entry = _parser.Parse(line); messages.Add(entry); } } } messagesHandler.AppendMessages(messages, fileName); return(messages); } catch (Exception e) { AnalogyLogMessage empty = new AnalogyLogMessage($"Error occured processing file {fileName}. Reason: {e.Message}", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None") { Source = "Analogy", Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName }; messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { empty }); } }
public override Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { return(base.Process(fileName, token, new RemoveLeadingNewLine(messagesHandler))); }
public async Task <List <AnalogyLogMessage> > ParseLog(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { _messages.Clear(); using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { bool TryParseInternal(string line, out AnalogyLogMessage msg) { if (_matchedPattern != null) { if (TryParse(line, _matchedPattern, out var m1)) { msg = m1; return(true); } msg = null; return(false); } foreach (var logPattern in _logPatterns) { if (TryParse(line, logPattern, out var m2)) { msg = m2; _matchedPattern = logPattern; return(true); } } msg = null; return(false); } using (var streamReader = new StreamReader(fileStream, Encoding.UTF8)) { string line = string.Empty; string currentLine; while ((currentLine = await streamReader.ReadLineAsync().ConfigureAwait(false)) != null) { line += currentLine; if (TryParseInternal(line, out var entry)) { line = string.Empty; } else { if (string.IsNullOrEmpty(line)) { line = currentLine; } continue; } if (entry != null) { if (updateUIAfterEachParsedLine) { messagesHandler.AppendMessage(entry, fileName); } _current = entry; _messages.Add(_current); } else { if (_current == null) { _current = new AnalogyLogMessage { Text = line }; } else { _current.Text += Environment.NewLine + line; } } if (token.IsCancellationRequested) { messagesHandler.AppendMessages(_messages, fileName); return(_messages); } } } } if (!updateUIAfterEachParsedLine) //update only at the end { messagesHandler.AppendMessages(_messages, fileName); } return(_messages); }
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { if (string.IsNullOrEmpty(fileName)) { AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.", AnalogyLogLevel.Critical, AnalogyLogClass.General, source, "None") { Source = source, Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName }; messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { empty }); } //if (!LogParserSettings.CanOpenFile(fileName)) //{ // AnalogyLogMessage empty = new AnalogyLogMessage( // $"File {fileName} Is not supported or not configured correctly in the windows settings", // AnalogyLogLevel.Critical, AnalogyLogClass.General, source, "None") // { // Source = source, // Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName // }; // messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName)); // return new List<AnalogyLogMessage> { empty }; //} List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>(); try { using (var stream = File.OpenRead(fileName)) { using (var reader = new StreamReader(stream)) { string firstLine = string.Empty; string otherdata = string.Empty; while (!reader.EndOfStream) { if (string.IsNullOrEmpty(firstLine)) { firstLine = await reader.ReadLineAsync(); } if (reader.EndOfStream) { var m = Parse(firstLine); messages.Add(m); messagesHandler.AppendMessage(m, Utils.GetFileNameAsDataSource(fileName)); continue; } var line = await reader.ReadLineAsync(); if (line.Contains(" => ")) { string lineToProcess = string.IsNullOrEmpty(firstLine) ? otherdata : firstLine + Environment.NewLine + otherdata; var m = Parse(lineToProcess); messages.Add(m); messagesHandler.AppendMessage(m, Utils.GetFileNameAsDataSource(fileName)); firstLine = line; otherdata = string.Empty; } else { otherdata += line + Environment.NewLine; } } if (!string.IsNullOrEmpty(firstLine)) { var m = Parse(firstLine); messages.Add(m); messagesHandler.AppendMessage(m, Utils.GetFileNameAsDataSource(fileName)); } } } return(messages); } catch (Exception e) { AnalogyLogMessage empty = new AnalogyLogMessage( $"Error occured processing file {fileName}. Reason: {e.Message}", AnalogyLogLevel.Critical, AnalogyLogClass.General, source, "None") { Source = source, Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName }; messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { empty }); } }
public override async Task <IEnumerable <AnalogyLogMessage> > ReadFromStream(Stream dataStream, CancellationToken token, ILogMessageCreatedHandler logWindow) { return(await Task <IEnumerable <AnalogyLogMessage> > .Factory.StartNew(() => { List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>(); try { return TryProcessFile(dataStream, token); } catch (Exception e) { if (MessageBox.Show( $"the file {FileName} is corrupted. Do you want to attempt to fix it and read it again?{Environment.NewLine}{Environment.NewLine} Error:{e.Message}", "Error Reading File", MessageBoxButtons.YesNo) == DialogResult.Yes) { string filename = Path.GetFileNameWithoutExtension(FileName); string final = Path.Combine(Path.GetDirectoryName(FileName), filename + "_Fixed.Log"); var fixedData = FixFile(FileName, token, new Progress <string>(s => { })).Result; File.WriteAllText(final, fixedData); bool loaded = false; using (FileStream fs = new FileStream(final, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { try { messages = TryProcessFile(fs, token); loaded = true; } catch (Exception e2) { loaded = false; MessageBox.Show( $"Unable to fix file.{Environment.NewLine}{Environment.NewLine}Error: {e2.Message}", "Error Reading File", MessageBoxButtons.OK); } } if (loaded) { MessageBox.Show($"File was fixed and saved to {final}", "File Fixed Successfully", MessageBoxButtons.OK); } } } return messages; })); }
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { var messages = await Task <IEnumerable <AnalogyLogMessage> > .Factory.StartNew(() => { List <AnalogyLogMessage> parsedMessages = new List <AnalogyLogMessage>(); try { using (var analogy = new LoggerConfiguration() .WriteTo.Analogy() .CreateLogger()) { using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { string jsonData; if (fileName.EndsWith(".gz", StringComparison.InvariantCultureIgnoreCase)) { using (var gzStream = new GZipStream(fileStream, CompressionMode.Decompress)) { using (var streamReader = new StreamReader(gzStream, encoding: Encoding.UTF8)) { jsonData = streamReader.ReadToEnd(); } } } else { using (var streamReader = new StreamReader(fileStream, Encoding.UTF8)) { jsonData = streamReader.ReadToEnd(); } } var data = JsonConvert.DeserializeObject(jsonData); if (data is JObject jo) { var evt = LogEventReader.ReadFromJObject(jo, messageFields); analogy.Write(evt); AnalogyLogMessage m = CommonParser.ParseLogEventProperties(evt); parsedMessages.Add(m); } else if (data is JArray arr) { foreach (var obj in arr.ToList()) { if (obj is JObject j) { var evt = LogEventReader.ReadFromJObject(j, messageFields); analogy.Write(evt); AnalogyLogMessage m = CommonParser.ParseLogEventProperties(evt); parsedMessages.Add(m); } } } } } messagesHandler.AppendMessages(parsedMessages, fileName); return(parsedMessages); } catch (Exception e) { AnalogyLogMessage empty = new AnalogyLogMessage($"Error reading file {fileName}: Error: {e.Message}", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None"); empty.Source = nameof(CompactJsonFormatParser); empty.Module = "Analogy.LogViewer.Serilog"; parsedMessages.Add(empty); messagesHandler.AppendMessages(parsedMessages, fileName); return(parsedMessages); } }); return(messages); }
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>(); try { using (var stream = File.OpenRead(fileName)) { using (var streamReader = new StreamReader(stream, Encoding.UTF8)) { while (!streamReader.EndOfStream) { try { string line = await streamReader.ReadLineAsync(); var items = line.Split(new[] { '\t' }, StringSplitOptions.RemoveEmptyEntries); AnalogyLogMessage m = new AnalogyLogMessage(); if (DateTime.TryParse(items[0], out DateTime dt)) { m.Date = dt; } m.ProcessId = int.Parse(items[2]); switch (items[3]) { case "INFO": m.Level = AnalogyLogLevel.Information; break; case "WARN": m.Level = AnalogyLogLevel.Warning; break; case "ERROR": m.Level = AnalogyLogLevel.Error; break; case "FATAL": m.Level = AnalogyLogLevel.Critical; break; default: m.Level = AnalogyLogLevel.Information; break; } m.Source = items[5]; m.Module = items[6]; if (int.TryParse(items[4], out int threadID)) { m.ThreadId = threadID; } if (items.Length == 7) { m.Module = items[5]; m.Text = items[6]; } else if (items.Length == 8) { m.Text = $"{items[1]}: {items[7]}"; } else if (items.Length > 8) { string text = items[7]; for (int i = 8; i <= items.Length - 1; i++) { text += items[i]; } m.Text = $"{items[1]}: {text}"; } messages.Add(m); } catch (Exception e) { string msg = $"Error processing line: {e}"; messages.Add(new AnalogyLogMessage(msg, AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None")); } if (token.IsCancellationRequested) { string msg = "Processing cancelled by User."; messages.Add(new AnalogyLogMessage(msg, AnalogyLogLevel.Information, AnalogyLogClass.General, "Analogy", "None")); messagesHandler.AppendMessages(messages, GetFileNameAsDataSource(fileName)); return(messages); } } } } } catch (Exception e) { string msg = $"Error processing line: {e}"; messages.Add(new AnalogyLogMessage(msg, AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None")); } if (!messages.Any()) { AnalogyLogMessage empty = new AnalogyLogMessage($"File {fileName} is empty or corrupted", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None"); empty.Source = "Analogy"; empty.Module = "Analogy"; messages.Add(empty); } messagesHandler.AppendMessages(messages, GetFileNameAsDataSource(fileName)); return(messages); }
public async Task <IEnumerable <AnalogyLogMessage> > ReadFromFile(string fileName, ILogMessageCreatedHandler logWindow) { if (!File.Exists(fileName)) { await Task.CompletedTask; return(new List <AnalogyLogMessage>()); } List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>(); return(await Task.Factory.StartNew(() => { try { using (var reader = new EventLogReader(fileName, PathType.FilePath)) { EventRecord record; while ((record = reader.ReadEvent()) != null) { if (Token.IsCancellationRequested) { break; } using (record) { AnalogyLogMessage m = new AnalogyLogMessage { Date = record.TimeCreated ?? DateTime.MinValue, Source = record.ProviderName, Module = record.ProviderName, Level = AnalogyLogLevel.Information, Id = record.ActivityId ?? Guid.Empty, ProcessId = record.ProcessId ?? 0, MachineName = record.MachineName, ThreadId = record.ThreadId ?? 0, FileName = fileName, User = record.UserId?.Value }; string properties = string.Join(Environment.NewLine, record.Properties.Select(p => p.Value)); try { m.Text = $"{record.MachineName} :({record.LogName}) - {record.FormatDescription()}{properties}{(record.ThreadId != null ? " Thread id:" + record.ThreadId.Value : string.Empty)}"; if (record.LevelDisplayName != null) { switch (record.LevelDisplayName) { case "Information": m.Level = AnalogyLogLevel.Information; break; case "Error": m.Level = AnalogyLogLevel.Error; break; case "Critical Error": m.Level = AnalogyLogLevel.Critical; break; case "Warning": m.Level = AnalogyLogLevel.Warning; break; case "Verbose": m.Level = AnalogyLogLevel.Verbose; break; } } } catch (Exception) { var items = record.Properties[0].Value.ToString() .Split(_separators, StringSplitOptions.RemoveEmptyEntries); if (items.Any() && items.Length == 4) { m.Text = $"{record.MachineName} :({record.LogName}) - {items[3]} . Message ID: {items[2]}"; m.Category = items[1]; switch (items[0]) { case "Informational": m.Level = AnalogyLogLevel.Information; break; case "Information": m.Level = AnalogyLogLevel.Information; break; case "Error": m.Level = AnalogyLogLevel.Error; break; case "Critical": m.Level = AnalogyLogLevel.Critical; break; case "Critical Error": m.Level = AnalogyLogLevel.Critical; break; case "Warning": m.Level = AnalogyLogLevel.Warning; break; case "Verbose": m.Level = AnalogyLogLevel.Verbose; break; default: m.Level = AnalogyLogLevel.Information; break; } } else { m.Text = $"{record.MachineName} :({record.LogName}) - {record.FormatDescription()}{properties}{(record.ThreadId.HasValue ? " Thread id:" + record.ThreadId.Value : string.Empty)}"; if (record.Level != null) { switch (record.Level.Value) { case 2: m.Level = AnalogyLogLevel.Error; break; case 3: m.Level = AnalogyLogLevel.Warning; break; case 4: m.Level = AnalogyLogLevel.Information; break; default: m.Level = AnalogyLogLevel.Information; break; } } } } messages.Add(m); logWindow.AppendMessage(m, GetFileNameAsDataSource(fileName)); } } } } catch (Exception e) { string fail = "Failed To parse: " + fileName + " Error:" + e; AnalogyLogMessage m = new AnalogyLogMessage { Text = fail, Level = AnalogyLogLevel.Critical, Class = AnalogyLogClass.General, Source = "Analogy" }; LogManager.Instance.LogException($"Error reading file:{e.Message}", e, nameof(ReadFromFile)); messages.Add(m); logWindow.AppendMessages(messages, GetFileNameAsDataSource(fileName)); } if (!messages.Any()) { AnalogyLogMessage empty = new AnalogyLogMessage($"File {fileName} is empty or corrupted", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None"); messages.Add(empty); logWindow.AppendMessage(empty, GetFileNameAsDataSource(fileName)); } return messages; }, Token)); }
public override async Task <IEnumerable <AnalogyLogMessage> > ReadFromStream(Stream dataStream, CancellationToken token, ILogMessageCreatedHandler logWindow) { if (dataStream == null || logWindow == null) { return(new List <AnalogyLogMessage>()); } return(await Task <IEnumerable <AnalogyLogMessage> > .Factory.StartNew(() => { using (StreamReader streamReader = new StreamReader(dataStream, Encoding.UTF8)) { try { string data = streamReader.ReadToEnd(); if (data.Contains("Platform_ModuleID") && data.Contains("HumanReadableModuleID")) { List <LogInfoWithJsonAttributes> logInfos = (List <LogInfoWithJsonAttributes>)JsonConvert.DeserializeObject(data, typeof(List <LogInfoWithJsonAttributes>)); List <AnalogyLogMessage> messages = logInfos.Select(Utils.LogMessageFromLogInfo).ToList(); if (!messages.Any()) { AnalogyLogMessage empty = new AnalogyLogMessage($"File {FileName} is empty or corrupted", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None"); messages.Add(empty); } logWindow.AppendMessages(messages, Utils.GetFileNameAsDataSource(FileName)); return messages; } else { List <AnalogyLogMessage> messages = (List <AnalogyLogMessage>)JsonConvert.DeserializeObject(data, typeof(List <AnalogyLogMessage>)); if (!messages.Any()) { AnalogyLogMessage empty = new AnalogyLogMessage($"File {FileName} is empty or corrupted", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None"); messages.Add(empty); } logWindow.AppendMessages(messages, Utils.GetFileNameAsDataSource(FileName)); return messages; } } catch (Exception ex) { List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>(); AnalogyLogMessage empty = new AnalogyLogMessage($"File {FileName} is empty or corrupted. Error: {ex.Message}", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None"); empty.Source = "Analogy"; empty.Module = Process.GetCurrentProcess().ProcessName; messages.Add(empty); LogWindow.AppendMessages(messages, Utils.GetFileNameAsDataSource(FileName)); return messages; } } }, token)); }
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { if (fileName.EndsWith(".log", StringComparison.InvariantCultureIgnoreCase)) { AnalogyXmlLogFile logFile = new AnalogyXmlLogFile(); var messages = await logFile.ReadFromFile(fileName, token, messagesHandler); return(messages); } if (fileName.EndsWith(".json", StringComparison.InvariantCultureIgnoreCase)) { AnalogyJsonLogFile logFile = new AnalogyJsonLogFile(); var messages = await logFile.ReadFromFile(fileName, token, messagesHandler); return(messages); } else { AnalogyLogMessage m = new AnalogyLogMessage { Text = $"Unsupported file: {fileName}. Skipping file", Level = AnalogyLogLevel.Critical, Source = "Analogy", Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName, ProcessID = System.Diagnostics.Process.GetCurrentProcess().Id, Class = AnalogyLogClass.General, User = Environment.UserName, Date = DateTime.Now }; messagesHandler.AppendMessage(m, Environment.MachineName); return(new List <AnalogyLogMessage>() { m }); } }
public override async Task <IEnumerable <AnalogyLogMessage> > ReadFromFile(string filename, CancellationToken token, ILogMessageCreatedHandler logWindow) { LogWindow = logWindow; FileName = filename; return(await base.ReadFromFile(filename, token, logWindow)); }
public override async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { if (CanOpenFile(fileName)) { Parser.SetRegexPatterns(UserSettingsManager.UserSettings.Settings.RegexPatterns); return(await Parser.ParseLog(fileName, token, messagesHandler)); } AnalogyLogMessage m = new AnalogyLogMessage($"File {fileName} is not supported", AnalogyLogLevel.Warning, AnalogyLogClass.General, OptionalTitle); messagesHandler.AppendMessage(m, OptionalTitle); return(new List <AnalogyLogMessage> { m }); }
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { var messages = await Task <IEnumerable <AnalogyLogMessage> > .Factory.StartNew(() => { List <AnalogyLogMessage> parsedMessages = new List <AnalogyLogMessage>(); try { using (var analogy = new LoggerConfiguration() .WriteTo.Analogy() .CreateLogger()) { using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { if (fileName.EndsWith(".gz", StringComparison.InvariantCultureIgnoreCase)) { using (var gzStream = new GZipStream(fileStream, CompressionMode.Decompress)) { using (var clef = new StreamReader(gzStream, encoding: Encoding.UTF8)) { var reader = new LogEventReader(clef); while (reader.TryRead(out var evt)) { analogy.Write(evt); AnalogyLogMessage m = CommonParser.ParseLogEventProperties(evt); parsedMessages.Add(m); } messagesHandler.AppendMessages(parsedMessages, fileName); return(parsedMessages); } } } else { using (var clef = new StreamReader(fileStream, encoding: Encoding.UTF8)) { var reader = new LogEventReader(clef); while (reader.TryRead(out var evt)) { analogy.Write(evt); AnalogyLogMessage m = CommonParser.ParseLogEventProperties(evt); parsedMessages.Add(m); } messagesHandler.AppendMessages(parsedMessages, fileName); return(parsedMessages); } } } } } catch (Exception e) { AnalogyLogMessage empty = new AnalogyLogMessage($"Error reading file {fileName}: Error: {e.Message}", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None"); empty.Source = nameof(ClefParser); empty.Module = "Analogy.LogViewer.Serilog"; parsedMessages.Add(empty); messagesHandler.AppendMessages(parsedMessages, fileName); return(parsedMessages); } }); return(messages); }
public async Task <IEnumerable <AnalogyLogMessage> > ReadFromFile(string fileName, CancellationToken token, ILogMessageCreatedHandler messageHandler) { if (string.IsNullOrEmpty(fileName)) { AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None") { Source = "Analogy", Module = Process.GetCurrentProcess().ProcessName }; messageHandler?.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage>() { empty }); } return(await Task <IEnumerable <AnalogyLogMessage> > .Factory.StartNew(() => { try { string data = string.Empty; using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) using (var textReader = new StreamReader(fileStream)) { data = textReader.ReadToEnd(); } List <AnalogyLogMessage> messages = JsonConvert.DeserializeObject <List <AnalogyLogMessage> >(data); messageHandler?.AppendMessages(messages, Utils.GetFileNameAsDataSource(fileName)); return messages; } catch (Exception ex) { AnalogyLogMessage empty = new AnalogyLogMessage($"File {fileName} is empty or corrupted. Error: {ex.Message}", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None") { Source = "Analogy", Module = Process.GetCurrentProcess().ProcessName }; AnalogyLogManager.Instance.LogErrorMessage(empty); messageHandler?.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName)); return new List <AnalogyLogMessage>() { empty }; } }, token)); }
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { //var formatter = new JsonFormatter(); List <AnalogyLogMessage> parsedMessages = new List <AnalogyLogMessage>(); try { using (var analogy = new LoggerConfiguration().WriteTo.Analogy() .CreateLogger()) { using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { if (fileName.EndsWith(".gz", StringComparison.InvariantCultureIgnoreCase)) { using (var gzStream = new GZipStream(fileStream, CompressionMode.Decompress)) { using (var streamReader = new StreamReader(gzStream, encoding: Encoding.UTF8)) { string json; while ((json = await streamReader.ReadLineAsync()) != null) { var data = JsonConvert.DeserializeObject(json, JsonSerializerSettings); var evt = LogEventReader.ReadFromJObject(data as JObject, messageFields); { analogy.Write(evt); AnalogyLogMessage m = CommonParser.ParseLogEventProperties(evt); parsedMessages.Add(m); } } } } } using (var streamReader = new StreamReader(fileStream, Encoding.UTF8)) { string json; while ((json = await streamReader.ReadLineAsync()) != null) { var data = JsonConvert.DeserializeObject(json); var evt = LogEventReader.ReadFromJObject(data as JObject, messageFields); { analogy.Write(evt); AnalogyLogMessage m = CommonParser.ParseLogEventProperties(evt); parsedMessages.Add(m); } } } } messagesHandler.AppendMessages(parsedMessages, fileName); return(parsedMessages); } } catch (Exception e) { AnalogyLogMessage empty = new AnalogyLogMessage($"Error reading file {fileName}: Error: {e.Message}", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None"); empty.Source = nameof(CompactJsonFormatParser); empty.Module = "Analogy.LogViewer.Serilog"; parsedMessages.Add(empty); messagesHandler.AppendMessages(parsedMessages, fileName); return(parsedMessages); } }