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;
}
