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
});
}
}
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));
}
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 (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();
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 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 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 void AppendMessage(AnalogyLogMessage message, string dataSource)
{
if (message.Text.StartsWith(Environment.NewLine))
{
//message.Text.
}
_messagesHandler.AppendMessage(message, dataSource);
}
public async Task <IEnumerable <AnalogyLogMessage> > ReadFromFile(string fileName, CancellationToken token, ILogMessageCreatedHandler messageHandler)
{
if (string.IsNullOrEmpty(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = Process.GetCurrentProcess().ProcessName
};
messageHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage>()
{
empty
});
}
return(await Task <IEnumerable <AnalogyLogMessage> > .Factory.StartNew(() =>
{
try
{
byte[] data = File.ReadAllBytes(fileName);
var messages = MessagePackSerializer.Deserialize <List <AnalogyLogMessage> >(data, MessagePack.Resolvers.ContractlessStandardResolver.Options);
messageHandler.AppendMessages(messages, Utils.GetFileNameAsDataSource(fileName));
return messages;
}
catch (Exception ex)
{
AnalogyLogMessage empty =
new AnalogyLogMessage($"File {fileName} is empty or corrupted. Error: {ex.Message}",
AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = Process.GetCurrentProcess().ProcessName
};
AnalogyLogManager.Instance.LogErrorMessage(empty);
messageHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return new List <AnalogyLogMessage>()
{
empty
};
}
}, token));
}
public async Task <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 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> > ReadFromFile(string fileName, CancellationToken token, ILogMessageCreatedHandler messageHandler)
{
if (string.IsNullOrEmpty(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None");
empty.Source = "Analogy";
empty.Module = Process.GetCurrentProcess().ProcessName;
messageHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage>()
{
empty
});
}
return(await Task <IEnumerable <AnalogyLogMessage> > .Factory.StartNew(() =>
{
try
{
string data = File.ReadAllText(fileName);
List <AnalogyLogMessage> messages = JsonConvert.DeserializeObject <List <AnalogyLogMessage> >(data);
messageHandler.AppendMessages(messages, Utils.GetFileNameAsDataSource(fileName));
return messages;
}
catch (Exception ex)
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File {fileName} is empty or corrupted. Error: {ex.Message}", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None");
empty.Source = "Analogy";
empty.Module = Process.GetCurrentProcess().ProcessName;
messageHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return new List <AnalogyLogMessage>()
{
empty
};
}
}, token));
}
public override async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler)
{
if (fileName.EndsWith(".axml", StringComparison.InvariantCultureIgnoreCase))
{
AnalogyXmlLogFile logFile = new AnalogyXmlLogFile();
var messages = await logFile.ReadFromFile(fileName, token, messagesHandler);
return(messages);
}
if (fileName.EndsWith(".ajson", StringComparison.InvariantCultureIgnoreCase))
{
AnalogyJsonLogFile logFile = new AnalogyJsonLogFile();
var messages = await logFile.ReadFromFile(fileName, token, messagesHandler);
return(messages);
}
if (fileName.EndsWith(".abin", StringComparison.InvariantCultureIgnoreCase))
{
AnalogyMessagePackFormat logFile = new AnalogyMessagePackFormat();
var messages = await logFile.ReadFromFile(fileName, token, messagesHandler);
return(messages);
}
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,
MachineName = Environment.MachineName,
Class = AnalogyLogClass.General,
User = Environment.UserName,
Date = DateTime.Now
};
messagesHandler.AppendMessage(m, Environment.MachineName);
return(new List <AnalogyLogMessage>()
{
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, 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 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));
}
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 async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler)
{
if (string.IsNullOrEmpty(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
if (!_logFileSettings.IsConfigured)
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File Parser is not configured. Please set it first in the settings Window",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
if (!_logFileSettings.CanOpenFile(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File {fileName} Is not supported or not configured correctly in the windows settings",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>();
try
{
using (var stream = File.OpenRead(fileName))
{
using (var reader = new StreamReader(stream))
{
while (!reader.EndOfStream)
{
var line = await reader.ReadLineAsync() ?? "";
var items = line.Split(_parser.splitters, StringSplitOptions.RemoveEmptyEntries);
while (items.Length < _logFileSettings.ValidItemsCount)
{
line = line + Environment.NewLine + await reader.ReadLineAsync();
items = line.Split(_parser.splitters, StringSplitOptions.RemoveEmptyEntries);
}
var entry = _parser.Parse(line);
messages.Add(entry);
}
}
}
messagesHandler.AppendMessages(messages, fileName);
return(messages);
}
catch (Exception e)
{
AnalogyLogMessage empty = new AnalogyLogMessage($"Error occured processing file {fileName}. Reason: {e.Message}",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token,
ILogMessageCreatedHandler messagesHandler)
{
if (string.IsNullOrEmpty(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
if (!_logFileSettings.IsConfigured)
{
AnalogyLogMessage empty = new AnalogyLogMessage(
$"File Parser is not configured. Please set it first in the settings Window",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
if (!_logFileSettings.CanOpenFile(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage(
$"File {fileName} Is not supported or not configured correctly in the windows settings",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>();
try
{
string xmlData = File.ReadAllText(fileName);
List <List <(string, string)> > ParseData(string data) => ParserInternal(data);
try
{
var rows = ParseData(xmlData);
foreach (var items in rows)
{
List <(string, string)> tuples = new List <(string, string)>(items.Count);
foreach (var(key, value) in items)
{
var keyProperty = _logFileSettings.GetAnalogyPropertyName(key);
tuples.Add(keyProperty.HasValue
? (keyProperty.Value.ToString(), value)
: (key, value));
}
var m = AnalogyLogMessage.Parse(tuples);
messages.Add(m);
}
}
catch (Exception e)
{
string data = TryFix(xmlData);
ParseData(data);
}
messagesHandler.AppendMessages(messages, fileName);
return(messages);
}
catch (Exception e)
{
AnalogyLogMessage empty = new AnalogyLogMessage($"Error occured processing file {fileName}. Reason: {e.Message}",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
}
public async Task <List <AnalogyLogMessage> > ParseLog(string fileName, CancellationToken token,
ILogMessageCreatedHandler messagesHandler)
{
_messages.Clear();
try
{
using (FileStream logFileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (StreamReader reader = new StreamReader(logFileStream))
{
string line;
while ((line = await reader.ReadLineAsync()) != null)
{
AnalogyLogMessage entry = null;
foreach (var logPattern in LogPatterns)
{
if (TryParse(line, logPattern, out entry))
{
break;
}
}
if (entry != null)
{
if (updateUIAfterEachParsedLine)
{
messagesHandler.AppendMessage(entry, fileName);
}
_current = entry;
_messages.Add(_current);
}
else
{
if (_current == null)
{
_current = new AnalogyLogMessage {
Text = line
};
}
else
{
_current.Text += Environment.NewLine + line;
}
}
if (token.IsCancellationRequested)
{
messagesHandler.AppendMessages(_messages, fileName);
return(_messages);
}
}
}
}
if (!updateUIAfterEachParsedLine) //update only at the end
{
messagesHandler.AppendMessages(_messages, fileName);
}
// Reset so that any settings-changes are reflected next time we run
_lastUsedPattern = null;
return(_messages);
}
catch (Exception e)
{
Logger.LogException($"Error reading file: {e.Message}", e, nameof(ParseLog));
AnalogyLogMessage error = new AnalogyLogMessage($"Error reading file: {e.Message}", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "Analogy");
messagesHandler.AppendMessages(_messages, fileName);
_messages.Add(error);
return(_messages);
}
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler)
{
if (string.IsNullOrEmpty(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
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 (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 <List <AnalogyLogMessage> > ParseLog(string fileName, CancellationToken token,
ILogMessageCreatedHandler messagesHandler)
{
_messages.Clear();
using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
bool TryParseInternal(string line, out AnalogyLogMessage msg)
{
if (_matchedPattern != null)
{
if (TryParse(line, _matchedPattern, out var m1))
{
msg = m1;
return(true);
}
msg = null;
return(false);
}
foreach (var logPattern in _logPatterns)
{
if (TryParse(line, logPattern, out var m2))
{
msg = m2;
_matchedPattern = logPattern;
return(true);
}
}
msg = null;
return(false);
}
using (var streamReader = new StreamReader(fileStream, Encoding.UTF8))
{
string line = string.Empty;
string currentLine;
while ((currentLine = await streamReader.ReadLineAsync().ConfigureAwait(false)) != null)
{
line += currentLine;
if (TryParseInternal(line, out var entry))
{
line = string.Empty;
}
else
{
if (string.IsNullOrEmpty(line))
{
line = currentLine;
}
continue;
}
if (entry != null)
{
if (updateUIAfterEachParsedLine)
{
messagesHandler.AppendMessage(entry, fileName);
}
_current = entry;
_messages.Add(_current);
}
else
{
if (_current == null)
{
_current = new AnalogyLogMessage {
Text = line
};
}
else
{
_current.Text += Environment.NewLine + line;
}
}
if (token.IsCancellationRequested)
{
messagesHandler.AppendMessages(_messages, fileName);
return(_messages);
}
}
}
}
if (!updateUIAfterEachParsedLine) //update only at the end
{
messagesHandler.AppendMessages(_messages, fileName);
}
return(_messages);
}
public override async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token,
ILogMessageCreatedHandler messagesHandler)
{
List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>();
void FileReceiverNewMessages(object sender, IReadOnlyCollection <Logazmic.Core.Log.LogMessage> e)
{
var newMessages = new List <AnalogyLogMessage>();
foreach (LogMessage log in e)
{
AnalogyLogMessage m = new AnalogyLogMessage(log.Message, GetLogLevel(log.LogLevel), AnalogyLogClass.General,
log.CallSiteClass, "", "", "", 0, 0, null, "", log.CallSiteMethod, log.SourceFileName, (int)log.SourceFileLineNr);
FillProperties(m, log);
newMessages.Add(m);
}
messages.AddRange(newMessages);
messagesHandler.AppendMessages(newMessages, fileName);
}
void FileReceiverNewMessage(object sender, Logazmic.Core.Log.LogMessage log)
{
AnalogyLogMessage m = new AnalogyLogMessage(log.Message, GetLogLevel(log.LogLevel), AnalogyLogClass.General,
log.CallSiteClass, "", "", "", 0, 0, null, "", log.CallSiteMethod, log.SourceFileName, (int)log.SourceFileLineNr);
messages.Add(m);
messagesHandler.AppendMessage(m, fileName);
}
var fileReceiver = new FileReceiver
{
LogReaderFactory = _logReaderFactory,
FileToWatch = fileName,
LogFormat = _logReaderFactory.GetLogFormatByFileExtension(Path.GetExtension(fileName))
};
try
{
var tcs = new TaskCompletionSource <IEnumerable <AnalogyLogMessage> >();
fileReceiver.NewMessage += FileReceiverNewMessage;
fileReceiver.NewMessages += FileReceiverNewMessages;
fileReceiver.OnDoneReadingFile += (s, e) =>
{
tcs.SetResult(messages);
};
fileReceiver.Initialize();
var result = await tcs.Task.ConfigureAwait(false);
return(result);
}
catch (Exception e)
{
Analogy.LogViewer.Template.Managers.LogManager.Instance.LogException($"Error reading file: {e.Message}", e, nameof(Process));
return(messages);
}
finally
{
fileReceiver.NewMessage -= FileReceiverNewMessage;
fileReceiver.NewMessages -= FileReceiverNewMessages;
}
}
