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