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> > 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 { byte[] data = File.ReadAllBytes(fileName); var messages = MessagePackSerializer.Deserialize <List <AnalogyLogMessage> >(data, MessagePack.Resolvers.ContractlessStandardResolver.Options); 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> > 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"); empty.Source = "Analogy"; empty.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 = File.ReadAllText(fileName); 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"); empty.Source = "Analogy"; empty.Module = Process.GetCurrentProcess().ProcessName; 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 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) { 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 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 <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); } }
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> > 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); }
private List <AnalogyLogMessage> ProcessJsonData(string json, string fileName, ILogMessageCreatedHandler messagesHandler, bool reportProgress) { List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>(); try { var items = JsonConvert.DeserializeObject <dynamic>(json); if (items is JArray jArray) { for (var i = 0; i < jArray.Count; i++) { var item = jArray[i]; var itemProperties = item.Children <JProperty>().ToList(); List <(string, string)> tuples = new List <(string, string)>(itemProperties.Count); List <(string, string)> nonAnalogyTuples = new List <(string, string)>(itemProperties.Count); foreach (var jprop in itemProperties) { if (UserSettingsManager.UserSettings.Settings.TryGetAnalogyValue(jprop.Name, out var prop)) { tuples.Add((prop.ToString(), jprop.Value.ToString())); } else { nonAnalogyTuples.Add((jprop.Name, jprop.Value.ToString())); } } var m = AnalogyLogMessage.Parse(tuples); m.RawText = item.ToString(); m.RawTextType = AnalogyRowTextType.JSON; m.AdditionalInformation = new Dictionary <string, string>(); foreach (var t in nonAnalogyTuples) { m.AdditionalInformation.Add(t.Item1, t.Item2); } messages.Add(m); if (reportProgress) { messagesHandler.ReportFileReadProgress(new AnalogyFileReadProgress(AnalogyFileReadProgressType.Percentage, 1, i, jArray.Count)); } } } else if (items is JObject jObject) { var itemProperties = jObject.Children <JProperty>().ToList(); List <(string, string)> tuples = new List <(string, string)>(itemProperties.Count); List <(string, string)> nonAnalogyTuples = new List <(string, string)>(itemProperties.Count); foreach (var jprop in itemProperties) { if (UserSettingsManager.UserSettings.Settings.TryGetAnalogyValue(jprop.Name, out var prop)) { tuples.Add((prop.ToString(), jprop.Value.ToString())); } else { nonAnalogyTuples.Add((jprop.Name, jprop.Value.ToString())); } } var m = AnalogyLogMessage.Parse(tuples); m.RawText = json; m.RawTextType = AnalogyRowTextType.JSON; m.AdditionalInformation = new Dictionary <string, string>(); foreach (var t in nonAnalogyTuples) { m.AdditionalInformation.Add(t.Item1, t.Item2); } messages.Add(m); if (reportProgress) { messagesHandler.ReportFileReadProgress(new AnalogyFileReadProgress(AnalogyFileReadProgressType.Percentage, 1, 1, 1)); } } messagesHandler.AppendMessages(messages, fileName); return(messages); } catch (Exception e) { AnalogyLogMessage empty = new AnalogyLogMessage($"Error occurred 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 }); } }
private List <AnalogyLogMessage> TryProcessFile(Stream dataStream, CancellationToken token) { if (dataStream == null || LogWindow == null) { return(new List <AnalogyLogMessage>()); } XmlNodeType ndType = XmlNodeType.Element; XmlParserContext xp = new XmlParserContext(null, null, null, XmlSpace.Default); XmlTextReader xr = new XmlTextReader(dataStream, ndType, xp); List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>(); while (xr.Read()) { if (xr.IsStartElement("Message")) { bool allOldFields = false; AnalogyLogMessage logM = new AnalogyLogMessage(); while (xr.Read()) { if (xr.IsStartElement("ID")) { } else if (xr.IsStartElement("Date")) { logM.Date = DateTime.ParseExact(xr.ReadElementContentAsString(), "yyyy-MM-dd HH:mm:ss.ff", null); } else if (xr.IsStartElement("Text")) { logM.Text = xr.ReadElementContentAsString(); } else if (xr.IsStartElement("Category")) { logM.Category = xr.ReadElementContentAsString(); } else if (xr.IsStartElement("Source")) { logM.Source = xr.ReadElementContentAsString(); } else if (xr.IsStartElement("Level")) { logM.Level = (AnalogyLogLevel)Enum.Parse(typeof(AnalogyLogLevel), xr.ReadElementContentAsString(), true); } else if (xr.IsStartElement("Class")) { logM.Class = (AnalogyLogClass)Enum.Parse(typeof(AnalogyLogClass), xr.ReadElementContentAsString(), true); } else if (xr.IsStartElement("Module")) { logM.Module = xr.ReadElementContentAsString(); } else if (xr.IsStartElement("MethodName")) { logM.MethodName = xr.ReadElementContentAsString(); } else if (xr.IsStartElement("MachineName")) { logM.MachineName = xr.ReadElementContentAsString(); } else if (xr.IsStartElement("AuditType")) { } else if (xr.IsStartElement("Method")) { logM.MethodName = xr.ReadElementContentAsString(); } else if (xr.IsStartElement("FileName")) { logM.FileName = xr.ReadElementContentAsString(); } else if (xr.IsStartElement("LineNumber")) { try { logM.LineNumber = int.Parse(xr.ReadElementContentAsString()); } catch { } } else if (xr.IsStartElement("ProcessID")) { try { logM.ProcessId = int.Parse(xr.ReadElementContentAsString()); } catch { } //break; allOldFields = true; } else if (xr.IsStartElement("User")) { logM.User = xr.ReadElementContentAsString(); break; } else if (allOldFields) { break; } } // while messages.Add(logM); } if (token.IsCancellationRequested) { string msg = "Processing cancelled by User."; messages.Add(new AnalogyLogMessage(msg, AnalogyLogLevel.Information, AnalogyLogClass.General, "Analogy", "None")); break; } } xr.Close(); if (!messages.Any()) { AnalogyLogMessage empty = new AnalogyLogMessage($"File {FileName} is empty or corrupted", 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); }
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 <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); } }
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 }); } 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, 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, GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { empty }); } List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>(); try { string xmlData = File.ReadAllText(fileName); List <List <(string, string)> > ParseData(string data) => ParserInternal(data); try { var rows = ParseData(xmlData); foreach (var items in rows) { List <(string, string)> tuples = new List <(string, string)>(items.Count); foreach (var(key, value) in items) { var keyProperty = _logFileSettings.GetAnalogyPropertyName(key); tuples.Add(keyProperty.HasValue ? (keyProperty.Value.ToString(), value) : (key, value)); } var m = AnalogyLogMessage.Parse(tuples); messages.Add(m); } } catch (Exception e) { string data = TryFix(xmlData); ParseData(data); } 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> > 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 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 override async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler) { List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>(); void FileReceiverNewMessages(object sender, IReadOnlyCollection <Logazmic.Core.Log.LogMessage> e) { var newMessages = new List <AnalogyLogMessage>(); foreach (LogMessage log in e) { AnalogyLogMessage m = new AnalogyLogMessage(log.Message, GetLogLevel(log.LogLevel), AnalogyLogClass.General, log.CallSiteClass, "", "", "", 0, 0, null, "", log.CallSiteMethod, log.SourceFileName, (int)log.SourceFileLineNr); FillProperties(m, log); newMessages.Add(m); } messages.AddRange(newMessages); messagesHandler.AppendMessages(newMessages, fileName); } void FileReceiverNewMessage(object sender, Logazmic.Core.Log.LogMessage log) { AnalogyLogMessage m = new AnalogyLogMessage(log.Message, GetLogLevel(log.LogLevel), AnalogyLogClass.General, log.CallSiteClass, "", "", "", 0, 0, null, "", log.CallSiteMethod, log.SourceFileName, (int)log.SourceFileLineNr); messages.Add(m); messagesHandler.AppendMessage(m, fileName); } var fileReceiver = new FileReceiver { LogReaderFactory = _logReaderFactory, FileToWatch = fileName, LogFormat = _logReaderFactory.GetLogFormatByFileExtension(Path.GetExtension(fileName)) }; try { var tcs = new TaskCompletionSource <IEnumerable <AnalogyLogMessage> >(); fileReceiver.NewMessage += FileReceiverNewMessage; fileReceiver.NewMessages += FileReceiverNewMessages; fileReceiver.OnDoneReadingFile += (s, e) => { tcs.SetResult(messages); }; fileReceiver.Initialize(); var result = await tcs.Task.ConfigureAwait(false); return(result); } catch (Exception e) { Analogy.LogViewer.Template.Managers.LogManager.Instance.LogException($"Error reading file: {e.Message}", e, nameof(Process)); return(messages); } finally { fileReceiver.NewMessage -= FileReceiverNewMessage; fileReceiver.NewMessages -= FileReceiverNewMessages; } }