public override async Task <IEnumerable <AnalogyLogMessage> > ReadFromStream(Stream dataStream, CancellationToken token, ILogMessageCreatedHandler logWindow) { if ((dataStream == null) || (logWindow == null)) { return(new List <AnalogyLogMessage>()); } List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>(); try { using (StreamReader streamReader = new StreamReader(dataStream, 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")); logWindow.AppendMessages(messages, Utils.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 = Process.GetCurrentProcess().ProcessName; messages.Add(empty); } logWindow.AppendMessages(messages, Utils.GetFileNameAsDataSource(FileName)); return(messages); }
public JsonViewerForm(AnalogyLogMessage message) : this() { this.message = message; }
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 void AppendMessage(AnalogyLogMessage message, string dataSource) { ucLogs1.AppendMessage(message, dataSource); }
public void AppendMessage(AnalogyLogMessage message, string dataSource) { messages.Add(message); }
private static string GetCsvFromMessage(AnalogyLogMessage m) => $"ID:{m.ID};Text:{m.Text};Category:{m.Category};Source:{m.Source};Level:{m.Level};Class:{m.Class};Module:{m.Module};Method:{m.MethodName};FileName:{m.FileName};LineNumber:{m.LineNumber};ProcessID:{m.ProcessID};User:{m.User};Parameters:{(m.Parameters == null ? string.Empty : string.Join(",", m.Parameters))}";
public JsonViewerForm(AnalogyLogMessage message) : this() { this.message = message; _useRawField = message.RawTextType == AnalogyRowTextType.JSON; }
public object GetValueForCellColumn(AnalogyLogMessage message, string columnName) { return("None"); }
public void NewMessage(AnalogyLogMessage message) { // }
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 }); } }
public void NewMessage(AnalogyLogMessage message) { (UserControl as UserControlExtensionExample)?.UserClickMessage(message); }
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; } }
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() .MinimumLevel.Verbose() .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 jo = data as JObject; var evt = LogEventReader.ReadFromJObject(jo, messageFields); { analogy.Write(evt); AnalogyLogMessage m = CommonParser.ParseLogEventProperties(evt); m.RawText = jo.ToString(Formatting.None); m.RawTextType = AnalogyRowTextType.JSON; 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 jo = data as JObject; var evt = LogEventReader.ReadFromJObject(jo, messageFields); { analogy.Write(evt); AnalogyLogMessage m = CommonParser.ParseLogEventProperties(evt); m.RawText = jo.ToString(Formatting.None); m.RawTextType = AnalogyRowTextType.JSON; 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) { 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)) { var line = await reader.ReadLineAsync(); while (!reader.EndOfStream) { var nextLine = await reader.ReadLineAsync(); var hasSeparators = _parser.splitters.Any(nextLine.Contains); if (!hasSeparators) // handle multi-line messages { line = line + Environment.NewLine + nextLine; } else { var entry = _parser.Parse(line); messages.Add(entry); line = nextLine; } } var entry1 = _parser.Parse(line); messages.Add(entry1); } } 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) { 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 { AnalogyLogMessage?entry = null; 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.None); if (items.Length == 4 && DateTime.TryParse(items[0], out var dateTime)) { if (entry != null) { messages.Add(entry); entry = null; } entry = _parser.Parse(line); } else if (entry != null) { if (entry.Text == "") { entry.Text = line; } else { entry.Text += Environment.NewLine + line; } } } } if (entry != null) { 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, GetFileNameAsDataSource(fileName)); return(new List <AnalogyLogMessage> { empty }); } }
public CheckListItemForSending(AnalogyLogMessage message, string sourceData) { Message = message; SourceData = sourceData; }
private void Consumer_OnNewMessage(object sender, AnalogyLogMessage message) { MessageReady(this, new AnalogyLogMessageArgs(message, Environment.MachineName, OptionalTitle, Id)); }
private static string GetCSVFromMessage(AnalogyLogMessage m) => $"ID:{m.Id};Text:{m.Text};Category:{m.Category};Source:{m.Source};Level:{m.Level};Class:{m.Class};Module:{m.Module};Method:{m.MethodName};FileName:{m.FileName};LineNumber:{m.LineNumber};ProcessID:{m.ProcessId};User:{m.User}";
public void LogErrorMessage(AnalogyLogMessage error) { messages.Add(error); OnNewError?.Invoke(this, new EventArgs()); }
public void UserClickMessage(AnalogyLogMessage msg) => lblMsg.Text = msg.Text;
private void RemoveMessage(AnalogyLogMessage msgMessage) { ucLogs1.RemoveMessage(msgMessage); }
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() .MinimumLevel.Verbose() .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); m.RawText = jo.ToString(Formatting.None); m.RawTextType = AnalogyRowTextType.JSON; 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); m.RawText = j.ToString(Formatting.None); m.RawTextType = AnalogyRowTextType.JSON; 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 AnalogyAddCommentsToMessage(AnalogyLogMessage m) : this() { Message = m; }
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 void AppendMessage(DataRow dtr, string dataSource) { AnalogyLogMessage message = (AnalogyLogMessage)dtr["Object"]; AppendMessage(message, dataSource); }
public void SendMessage(AnalogyLogMessage message, string source) { ClientProxy.SendMessage(message, source); }
public AnalogyExcludeMessage(AnalogyLogMessage m) : this() { txtbMessage.Text = m.Text; }
//public void WriteMessage(byte[] data) //{ // this.WriteMessage(AnalogyLogMessage.Deserialize(data)); //} public void WriteMessage(AnalogyLogMessage message) { string jsonMessage; this.WriteMessage(message, out jsonMessage); }
public bool TryParse(string line, RegexPattern regex, out AnalogyLogMessage message) { try { Match match = Regex.Match(line, regex.Pattern, RegexOptions.Compiled | RegexOptions.IgnorePatternWhitespace); if (match.Success) { var m = new AnalogyLogMessage(); foreach (var regexMember in regexMapper) { string value = match.Groups[regexMember.Key].Success ? match.Groups[regexMember.Key].Value : string.Empty; switch (regexMember.Value) { case AnalogyLogMessagePropertyName.Date: if (!string.IsNullOrEmpty(value) && DateTime.TryParseExact(value, regex.DateTimeFormat, CultureInfo.InvariantCulture, DateTimeStyles.None, out var date)) { m.Date = date; } continue; case AnalogyLogMessagePropertyName.Id: if (!string.IsNullOrEmpty(value) && Guid.TryParseExact(value, regex.GuidFormat, out var guidValue)) { m.Id = guidValue; } continue; case AnalogyLogMessagePropertyName.Text: m.Text = value; continue; case AnalogyLogMessagePropertyName.Category: m.Category = value; continue; case AnalogyLogMessagePropertyName.Source: m.Source = value; continue; case AnalogyLogMessagePropertyName.Module: m.Module = value; continue; case AnalogyLogMessagePropertyName.MethodName: m.MethodName = value; continue; case AnalogyLogMessagePropertyName.FileName: m.FileName = value; continue; case AnalogyLogMessagePropertyName.User: m.User = value; continue; case AnalogyLogMessagePropertyName.LineNumber: if (!string.IsNullOrEmpty(value) && int.TryParse(value, out var lineNum)) { m.LineNumber = lineNum; } continue; case AnalogyLogMessagePropertyName.ProcessId: if (!string.IsNullOrEmpty(value) && int.TryParse(value, out var processNum)) { m.ProcessId = processNum; } continue; case AnalogyLogMessagePropertyName.ThreadId: if (!string.IsNullOrEmpty(value) && int.TryParse(value, out var threadNum)) { m.ThreadId = threadNum; } continue; case AnalogyLogMessagePropertyName.Level: switch (value) { case "OFF": m.Level = AnalogyLogLevel.None; break; case "TRACE": m.Level = AnalogyLogLevel.Trace; break; case "DEBUG": m.Level = AnalogyLogLevel.Debug; break; 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.Unknown; break; } continue; case AnalogyLogMessagePropertyName.Class: if (string.IsNullOrEmpty(value)) { m.Class = AnalogyLogClass.General; } else { m.Class = Enum.TryParse(value, true, out AnalogyLogClass cls) && Enum.IsDefined(typeof(AnalogyLogClass), cls) ? cls : AnalogyLogClass.General; } continue; case AnalogyLogMessagePropertyName.MachineName: m.MachineName = value; break; case AnalogyLogMessagePropertyName.RawText: m.RawText = value; break; case AnalogyLogMessagePropertyName.RawTextType: m.RawTextType = AnalogyRowTextType.PlainText; break; default: throw new ArgumentOutOfRangeException(); } } message = m; return(true); } message = null; return(false); } catch (Exception e) { string error = $"Error parsing line: {e.Message}"; Logger?.LogException(error, e, nameof(RegexParser)); message = new AnalogyLogMessage(error, AnalogyLogLevel.Error, AnalogyLogClass.General, nameof(RegexParser)); return(false); } }
public MessageDetailsUC(AnalogyLogMessage msg, List <AnalogyLogMessage> messages, string dataSource) : this() { Message = msg; Messages = messages; DataSource = dataSource; }