public async Task <IEnumerable <AnalogyLogMessage> > ReadFromFile(string fileName, CancellationToken token, ILogMessageCreatedHandler messageHandler)
{
if (string.IsNullOrEmpty(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = Process.GetCurrentProcess().ProcessName
};
messageHandler?.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage>()
{
empty
});
}
return(await Task <IEnumerable <AnalogyLogMessage> > .Factory.StartNew(() =>
{
try
{
string data = string.Empty;
using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (var textReader = new StreamReader(fileStream))
{
data = textReader.ReadToEnd();
}
List <AnalogyLogMessage> messages = JsonConvert.DeserializeObject <List <AnalogyLogMessage> >(data);
messageHandler?.AppendMessages(messages, Utils.GetFileNameAsDataSource(fileName));
return messages;
}
catch (Exception ex)
{
AnalogyLogMessage empty =
new AnalogyLogMessage($"File {fileName} is empty or corrupted. Error: {ex.Message}",
AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = Process.GetCurrentProcess().ProcessName
};
AnalogyLogManager.Instance.LogErrorMessage(empty);
messageHandler?.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return new List <AnalogyLogMessage>()
{
empty
};
}
}, token));
}
public async Task <IEnumerable <AnalogyLogMessage> > ReadFromFile(string fileName, CancellationToken token, ILogMessageCreatedHandler messageHandler)
{
if (string.IsNullOrEmpty(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = Process.GetCurrentProcess().ProcessName
};
messageHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage>()
{
empty
});
}
return(await Task <IEnumerable <AnalogyLogMessage> > .Factory.StartNew(() =>
{
try
{
byte[] data = File.ReadAllBytes(fileName);
var messages = MessagePackSerializer.Deserialize <List <AnalogyLogMessage> >(data, MessagePack.Resolvers.ContractlessStandardResolver.Options);
messageHandler.AppendMessages(messages, Utils.GetFileNameAsDataSource(fileName));
return messages;
}
catch (Exception ex)
{
AnalogyLogMessage empty =
new AnalogyLogMessage($"File {fileName} is empty or corrupted. Error: {ex.Message}",
AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = Process.GetCurrentProcess().ProcessName
};
AnalogyLogManager.Instance.LogErrorMessage(empty);
messageHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return new List <AnalogyLogMessage>()
{
empty
};
}
}, token));
}
public async Task <IEnumerable <AnalogyLogMessage> > ReadFromFile(string fileName, CancellationToken token, ILogMessageCreatedHandler messageHandler)
{
if (string.IsNullOrEmpty(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None");
empty.Source = "Analogy";
empty.Module = Process.GetCurrentProcess().ProcessName;
messageHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage>()
{
empty
});
}
return(await Task <IEnumerable <AnalogyLogMessage> > .Factory.StartNew(() =>
{
try
{
string data = File.ReadAllText(fileName);
List <AnalogyLogMessage> messages = JsonConvert.DeserializeObject <List <AnalogyLogMessage> >(data);
messageHandler.AppendMessages(messages, Utils.GetFileNameAsDataSource(fileName));
return messages;
}
catch (Exception ex)
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File {fileName} is empty or corrupted. Error: {ex.Message}", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None");
empty.Source = "Analogy";
empty.Module = Process.GetCurrentProcess().ProcessName;
messageHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return new List <AnalogyLogMessage>()
{
empty
};
}
}, token));
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler)
{
var messages = await Task <IEnumerable <AnalogyLogMessage> > .Factory.StartNew(() =>
{
List <AnalogyLogMessage> parsedMessages = new List <AnalogyLogMessage>();
try
{
using (var analogy = new LoggerConfiguration()
.WriteTo.Analogy()
.CreateLogger())
{
using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
string jsonData;
if (fileName.EndsWith(".gz", StringComparison.InvariantCultureIgnoreCase))
{
using (var gzStream = new GZipStream(fileStream, CompressionMode.Decompress))
{
using (var streamReader = new StreamReader(gzStream, encoding: Encoding.UTF8))
{
jsonData = streamReader.ReadToEnd();
}
}
}
else
{
using (var streamReader = new StreamReader(fileStream, Encoding.UTF8))
{
jsonData = streamReader.ReadToEnd();
}
}
var data = JsonConvert.DeserializeObject(jsonData);
if (data is JObject jo)
{
var evt = LogEventReader.ReadFromJObject(jo, messageFields);
analogy.Write(evt);
AnalogyLogMessage m = CommonParser.ParseLogEventProperties(evt);
parsedMessages.Add(m);
}
else if (data is JArray arr)
{
foreach (var obj in arr.ToList())
{
if (obj is JObject j)
{
var evt = LogEventReader.ReadFromJObject(j, messageFields);
analogy.Write(evt);
AnalogyLogMessage m = CommonParser.ParseLogEventProperties(evt);
parsedMessages.Add(m);
}
}
}
}
}
messagesHandler.AppendMessages(parsedMessages, fileName);
return(parsedMessages);
}
catch (Exception e)
{
AnalogyLogMessage empty = new AnalogyLogMessage($"Error reading file {fileName}: Error: {e.Message}",
AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None");
empty.Source = nameof(CompactJsonFormatParser);
empty.Module = "Analogy.LogViewer.Serilog";
parsedMessages.Add(empty);
messagesHandler.AppendMessages(parsedMessages, fileName);
return(parsedMessages);
}
});
return(messages);
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler)
{
if (string.IsNullOrEmpty(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
if (!_logFileSettings.IsConfigured)
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File Parser is not configured. Please set it first in the settings Window",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
if (!_logFileSettings.CanOpenFile(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File {fileName} Is not supported or not configured correctly in the windows settings",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>();
try
{
using (var stream = File.OpenRead(fileName))
{
using (var reader = new StreamReader(stream))
{
while (!reader.EndOfStream)
{
var line = await reader.ReadLineAsync() ?? "";
var items = line.Split(_parser.splitters, StringSplitOptions.RemoveEmptyEntries);
while (items.Length < _logFileSettings.ValidItemsCount)
{
line = line + Environment.NewLine + await reader.ReadLineAsync();
items = line.Split(_parser.splitters, StringSplitOptions.RemoveEmptyEntries);
}
var entry = _parser.Parse(line);
messages.Add(entry);
}
}
}
messagesHandler.AppendMessages(messages, fileName);
return(messages);
}
catch (Exception e)
{
AnalogyLogMessage empty = new AnalogyLogMessage($"Error occured processing file {fileName}. Reason: {e.Message}",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler)
{
var messages = await Task <IEnumerable <AnalogyLogMessage> > .Factory.StartNew(() =>
{
List <AnalogyLogMessage> parsedMessages = new List <AnalogyLogMessage>();
try
{
using (var analogy = new LoggerConfiguration()
.WriteTo.Analogy()
.CreateLogger())
{
using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
using (var streamReader = new StreamReader(fileStream, Encoding.UTF8))
{
var json = streamReader.ReadToEnd();
var data = JsonConvert.DeserializeObject(json);
if (data is JObject jo)
{
var m = ParserJObject(jo, analogy);
parsedMessages.Add(m);
}
else if (data is JArray arr)
{
foreach (var obj in arr.ToList())
{
if (obj is JObject j)
{
var m = ParserJObject(j, analogy);
parsedMessages.Add(m);
}
}
}
}
}
if (TimeStampTimeZone != null)
{
foreach (var m in parsedMessages)
{
m.Date = TimeZoneInfo.ConvertTimeFromUtc(m.Date, TimeStampTimeZone);
}
}
messagesHandler.AppendMessages(parsedMessages, fileName);
return(parsedMessages);
}
catch (Exception e)
{
AnalogyLogMessage empty = new AnalogyLogMessage($"Error reading file {fileName}: Error: {e.Message}",
AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None");
empty.Source = nameof(ClefParser);
empty.Module = "Analogy.LogViewer.Serilog";
parsedMessages.Add(empty);
messagesHandler.AppendMessages(parsedMessages, fileName);
return(parsedMessages);
}
});
return(messages);
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token,
ILogMessageCreatedHandler messagesHandler)
{
//var formatter = new JsonFormatter();
List <AnalogyLogMessage> parsedMessages = new List <AnalogyLogMessage>();
try
{
using (var analogy = new LoggerConfiguration().WriteTo.Analogy()
.CreateLogger())
{
using (var fileStream =
new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
if (fileName.EndsWith(".gz", StringComparison.InvariantCultureIgnoreCase))
{
using (var gzStream = new GZipStream(fileStream, CompressionMode.Decompress))
{
using (var streamReader = new StreamReader(gzStream, encoding: Encoding.UTF8))
{
string json;
while ((json = await streamReader.ReadLineAsync()) != null)
{
var data = JsonConvert.DeserializeObject(json, JsonSerializerSettings);
var evt = LogEventReader.ReadFromJObject(data as JObject, messageFields);
{
analogy.Write(evt);
AnalogyLogMessage m = CommonParser.ParseLogEventProperties(evt);
parsedMessages.Add(m);
}
}
}
}
}
using (var streamReader = new StreamReader(fileStream, Encoding.UTF8))
{
string json;
while ((json = await streamReader.ReadLineAsync()) != null)
{
var data = JsonConvert.DeserializeObject(json);
var evt = LogEventReader.ReadFromJObject(data as JObject, messageFields);
{
analogy.Write(evt);
AnalogyLogMessage m = CommonParser.ParseLogEventProperties(evt);
parsedMessages.Add(m);
}
}
}
}
messagesHandler.AppendMessages(parsedMessages, fileName);
return(parsedMessages);
}
}
catch (Exception e)
{
AnalogyLogMessage empty = new AnalogyLogMessage($"Error reading file {fileName}: Error: {e.Message}",
AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None");
empty.Source = nameof(CompactJsonFormatParser);
empty.Module = "Analogy.LogViewer.Serilog";
parsedMessages.Add(empty);
messagesHandler.AppendMessages(parsedMessages, fileName);
return(parsedMessages);
}
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler)
{
var messages = await Task <IEnumerable <AnalogyLogMessage> > .Factory.StartNew(() =>
{
List <AnalogyLogMessage> parsedMessages = new List <AnalogyLogMessage>();
try
{
using (var analogy = new LoggerConfiguration()
.WriteTo.Analogy()
.CreateLogger())
{
using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
if (fileName.EndsWith(".gz", StringComparison.InvariantCultureIgnoreCase))
{
using (var gzStream = new GZipStream(fileStream, CompressionMode.Decompress))
{
using (var clef = new StreamReader(gzStream, encoding: Encoding.UTF8))
{
var reader = new LogEventReader(clef);
while (reader.TryRead(out var evt))
{
analogy.Write(evt);
AnalogyLogMessage m = CommonParser.ParseLogEventProperties(evt);
parsedMessages.Add(m);
}
messagesHandler.AppendMessages(parsedMessages, fileName);
return(parsedMessages);
}
}
}
else
{
using (var clef = new StreamReader(fileStream, encoding: Encoding.UTF8))
{
var reader = new LogEventReader(clef);
while (reader.TryRead(out var evt))
{
analogy.Write(evt);
AnalogyLogMessage m = CommonParser.ParseLogEventProperties(evt);
parsedMessages.Add(m);
}
messagesHandler.AppendMessages(parsedMessages, fileName);
return(parsedMessages);
}
}
}
}
}
catch (Exception e)
{
AnalogyLogMessage empty = new AnalogyLogMessage($"Error reading file {fileName}: Error: {e.Message}",
AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None");
empty.Source = nameof(ClefParser);
empty.Module = "Analogy.LogViewer.Serilog";
parsedMessages.Add(empty);
messagesHandler.AppendMessages(parsedMessages, fileName);
return(parsedMessages);
}
});
return(messages);
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token,
ILogMessageCreatedHandler messagesHandler)
{
List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>();
try
{
using (var stream = File.OpenRead(fileName))
{
using (var streamReader = new StreamReader(stream, Encoding.UTF8))
{
while (!streamReader.EndOfStream)
{
try
{
string line = await streamReader.ReadLineAsync();
var items = line.Split(new[] { '\t' }, StringSplitOptions.RemoveEmptyEntries);
AnalogyLogMessage m = new AnalogyLogMessage();
if (DateTime.TryParse(items[0], out DateTime dt))
{
m.Date = dt;
}
m.ProcessId = int.Parse(items[2]);
switch (items[3])
{
case "INFO":
m.Level = AnalogyLogLevel.Information;
break;
case "WARN":
m.Level = AnalogyLogLevel.Warning;
break;
case "ERROR":
m.Level = AnalogyLogLevel.Error;
break;
case "FATAL":
m.Level = AnalogyLogLevel.Critical;
break;
default:
m.Level = AnalogyLogLevel.Information;
break;
}
m.Source = items[5];
m.Module = items[6];
if (int.TryParse(items[4], out int threadID))
{
m.ThreadId = threadID;
}
if (items.Length == 7)
{
m.Module = items[5];
m.Text = items[6];
}
else if (items.Length == 8)
{
m.Text = $"{items[1]}: {items[7]}";
}
else if (items.Length > 8)
{
string text = items[7];
for (int i = 8; i <= items.Length - 1; i++)
{
text += items[i];
}
m.Text = $"{items[1]}: {text}";
}
messages.Add(m);
}
catch (Exception e)
{
string msg = $"Error processing line: {e}";
messages.Add(new AnalogyLogMessage(msg, AnalogyLogLevel.Error, AnalogyLogClass.General,
"Analogy", "None"));
}
if (token.IsCancellationRequested)
{
string msg = "Processing cancelled by User.";
messages.Add(new AnalogyLogMessage(msg, AnalogyLogLevel.Information, AnalogyLogClass.General,
"Analogy", "None"));
messagesHandler.AppendMessages(messages, GetFileNameAsDataSource(fileName));
return(messages);
}
}
}
}
}
catch (Exception e)
{
string msg = $"Error processing line: {e}";
messages.Add(new AnalogyLogMessage(msg, AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy",
"None"));
}
if (!messages.Any())
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File {fileName} is empty or corrupted", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None");
empty.Source = "Analogy";
empty.Module = "Analogy";
messages.Add(empty);
}
messagesHandler.AppendMessages(messages, GetFileNameAsDataSource(fileName));
return(messages);
}
private List <AnalogyLogMessage> ProcessJsonData(string json, string fileName, ILogMessageCreatedHandler messagesHandler, bool reportProgress)
{
List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>();
try
{
var items = JsonConvert.DeserializeObject <dynamic>(json);
if (items is JArray jArray)
{
for (var i = 0; i < jArray.Count; i++)
{
var item = jArray[i];
var itemProperties = item.Children <JProperty>().ToList();
List <(string, string)> tuples = new List <(string, string)>(itemProperties.Count);
List <(string, string)> nonAnalogyTuples = new List <(string, string)>(itemProperties.Count);
foreach (var jprop in itemProperties)
{
if (UserSettingsManager.UserSettings.Settings.TryGetAnalogyValue(jprop.Name, out var prop))
{
tuples.Add((prop.ToString(), jprop.Value.ToString()));
}
else
{
nonAnalogyTuples.Add((jprop.Name, jprop.Value.ToString()));
}
}
var m = AnalogyLogMessage.Parse(tuples);
m.RawText = item.ToString();
m.RawTextType = AnalogyRowTextType.JSON;
m.AdditionalInformation = new Dictionary <string, string>();
foreach (var t in nonAnalogyTuples)
{
m.AdditionalInformation.Add(t.Item1, t.Item2);
}
messages.Add(m);
if (reportProgress)
{
messagesHandler.ReportFileReadProgress(new AnalogyFileReadProgress(AnalogyFileReadProgressType.Percentage, 1, i, jArray.Count));
}
}
}
else if (items is JObject jObject)
{
var itemProperties = jObject.Children <JProperty>().ToList();
List <(string, string)> tuples = new List <(string, string)>(itemProperties.Count);
List <(string, string)> nonAnalogyTuples = new List <(string, string)>(itemProperties.Count);
foreach (var jprop in itemProperties)
{
if (UserSettingsManager.UserSettings.Settings.TryGetAnalogyValue(jprop.Name, out var prop))
{
tuples.Add((prop.ToString(), jprop.Value.ToString()));
}
else
{
nonAnalogyTuples.Add((jprop.Name, jprop.Value.ToString()));
}
}
var m = AnalogyLogMessage.Parse(tuples);
m.RawText = json;
m.RawTextType = AnalogyRowTextType.JSON;
m.AdditionalInformation = new Dictionary <string, string>();
foreach (var t in nonAnalogyTuples)
{
m.AdditionalInformation.Add(t.Item1, t.Item2);
}
messages.Add(m);
if (reportProgress)
{
messagesHandler.ReportFileReadProgress(new AnalogyFileReadProgress(AnalogyFileReadProgressType.Percentage, 1, 1, 1));
}
}
messagesHandler.AppendMessages(messages, fileName);
return(messages);
}
catch (Exception e)
{
AnalogyLogMessage empty = new AnalogyLogMessage($"Error occurred processing file {fileName}. Reason: {e.Message}",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, Utils.GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
}
private List <AnalogyLogMessage> TryProcessFile(Stream dataStream, CancellationToken token)
{
if (dataStream == null || LogWindow == null)
{
return(new List <AnalogyLogMessage>());
}
XmlNodeType ndType = XmlNodeType.Element;
XmlParserContext xp = new XmlParserContext(null, null, null, XmlSpace.Default);
XmlTextReader xr = new XmlTextReader(dataStream, ndType, xp);
List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>();
while (xr.Read())
{
if (xr.IsStartElement("Message"))
{
bool allOldFields = false;
AnalogyLogMessage logM = new AnalogyLogMessage();
while (xr.Read())
{
if (xr.IsStartElement("ID"))
{
}
else if (xr.IsStartElement("Date"))
{
logM.Date = DateTime.ParseExact(xr.ReadElementContentAsString(), "yyyy-MM-dd HH:mm:ss.ff", null);
}
else if (xr.IsStartElement("Text"))
{
logM.Text = xr.ReadElementContentAsString();
}
else if (xr.IsStartElement("Category"))
{
logM.Category = xr.ReadElementContentAsString();
}
else if (xr.IsStartElement("Source"))
{
logM.Source = xr.ReadElementContentAsString();
}
else if (xr.IsStartElement("Level"))
{
logM.Level = (AnalogyLogLevel)Enum.Parse(typeof(AnalogyLogLevel), xr.ReadElementContentAsString(), true);
}
else if (xr.IsStartElement("Class"))
{
logM.Class = (AnalogyLogClass)Enum.Parse(typeof(AnalogyLogClass), xr.ReadElementContentAsString(), true);
}
else if (xr.IsStartElement("Module"))
{
logM.Module = xr.ReadElementContentAsString();
}
else if (xr.IsStartElement("MethodName"))
{
logM.MethodName = xr.ReadElementContentAsString();
}
else if (xr.IsStartElement("MachineName"))
{
logM.MachineName = xr.ReadElementContentAsString();
}
else if (xr.IsStartElement("AuditType"))
{
}
else if (xr.IsStartElement("Method"))
{
logM.MethodName = xr.ReadElementContentAsString();
}
else if (xr.IsStartElement("FileName"))
{
logM.FileName = xr.ReadElementContentAsString();
}
else if (xr.IsStartElement("LineNumber"))
{
try
{
logM.LineNumber = int.Parse(xr.ReadElementContentAsString());
}
catch
{
}
}
else if (xr.IsStartElement("ProcessID"))
{
try
{
logM.ProcessId = int.Parse(xr.ReadElementContentAsString());
}
catch
{
}
//break;
allOldFields = true;
}
else if (xr.IsStartElement("User"))
{
logM.User = xr.ReadElementContentAsString();
break;
}
else if (allOldFields)
{
break;
}
} // while
messages.Add(logM);
}
if (token.IsCancellationRequested)
{
string msg = "Processing cancelled by User.";
messages.Add(new AnalogyLogMessage(msg, AnalogyLogLevel.Information, AnalogyLogClass.General, "Analogy", "None"));
break;
}
}
xr.Close();
if (!messages.Any())
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File {FileName} is empty or corrupted", AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None");
empty.Source = "Analogy";
empty.Module = Process.GetCurrentProcess().ProcessName;
messages.Add(empty);
}
LogWindow.AppendMessages(messages, Utils.GetFileNameAsDataSource(FileName));
return(messages);
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token,
ILogMessageCreatedHandler messagesHandler)
{
if (string.IsNullOrEmpty(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.",
AnalogyLogLevel.Critical, AnalogyLogClass.General, source, "None")
{
Source = source,
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>();
try
{
var messagesInternal = new List <Message>();
var chatLog = File.ReadAllLines(fileName);
foreach (var chatLine in chatLog)
{
var messageInternal = GetMessage(messagesInternal, chatLine, UserSettingsManager.UserSettings.CultureInfo);
if (messageInternal != null)
{
messagesInternal.Add(messageInternal);
}
}
for (var i = 0; i < messagesInternal.Count; i++)
{
var mi = messagesInternal[i];
AnalogyLogMessage m = new AnalogyLogMessage
{
Text = mi.Text, Date = mi.TimeStamp, User = mi.MessageBy ?? ""
};
m.Source = m.User;
messages.Add(m);
messagesHandler.ReportFileReadProgress(
new AnalogyFileReadProgress(AnalogyFileReadProgressType.Percentage, 1, i, messagesInternal.Count));
}
messagesHandler.AppendMessages(messages, fileName);
return(messages);
}
catch (Exception e)
{
AnalogyLogMessage empty = new AnalogyLogMessage(
$"Error occured processing file {fileName}. Reason: {e.Message}",
AnalogyLogLevel.Critical, AnalogyLogClass.General, source, "None")
{
Source = source,
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token, ILogMessageCreatedHandler messagesHandler)
{
if (string.IsNullOrEmpty(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>();
try
{
AnalogyLogMessage?entry = null;
using (var stream = File.OpenRead(fileName))
{
using (var reader = new StreamReader(stream))
{
long count = 0;
while (!reader.EndOfStream)
{
var line = await reader.ReadLineAsync();
var indexOfFirstSpace = line.IndexOf(' ');
if (indexOfFirstSpace == 28 && DateTime.TryParse(line.Substring(0, indexOfFirstSpace), out var dateTime))
{
if (entry != null)
{
messages.Add(entry);
count++;
messagesHandler.ReportFileReadProgress(new AnalogyFileReadProgress(AnalogyFileReadProgressType.Incremental, 1, count, count));
}
string data = line.Substring(indexOfFirstSpace + 1);
entry = new AnalogyLogMessage();
entry.Text = data;
entry.Date = dateTime;
entry.Level = GetLogLevel(data);
entry.Id = Guid.NewGuid();
entry.Source = GetFileNameAsDataSource(fileName);
entry.Module = "";
}
else if (entry != null)
{
if (entry.Text == "")
{
entry.Text = line;
}
else
{
entry.Text += Environment.NewLine + line;
}
}
}
}
}
messagesHandler.AppendMessages(messages, fileName);
return(messages);
}
catch (Exception e)
{
AnalogyLogMessage empty = new AnalogyLogMessage($"Error occured processing file {fileName}. Reason: {e.Message}",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
}
public async Task <List <AnalogyLogMessage> > ParseLog(string fileName, CancellationToken token,
ILogMessageCreatedHandler messagesHandler)
{
_messages.Clear();
try
{
using (FileStream logFileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
using (StreamReader reader = new StreamReader(logFileStream))
{
string line;
while ((line = await reader.ReadLineAsync()) != null)
{
AnalogyLogMessage entry = null;
foreach (var logPattern in LogPatterns)
{
if (TryParse(line, logPattern, out entry))
{
break;
}
}
if (entry != null)
{
if (updateUIAfterEachParsedLine)
{
messagesHandler.AppendMessage(entry, fileName);
}
_current = entry;
_messages.Add(_current);
}
else
{
if (_current == null)
{
_current = new AnalogyLogMessage {
Text = line
};
}
else
{
_current.Text += Environment.NewLine + line;
}
}
if (token.IsCancellationRequested)
{
messagesHandler.AppendMessages(_messages, fileName);
return(_messages);
}
}
}
}
if (!updateUIAfterEachParsedLine) //update only at the end
{
messagesHandler.AppendMessages(_messages, fileName);
}
// Reset so that any settings-changes are reflected next time we run
_lastUsedPattern = null;
return(_messages);
}
catch (Exception e)
{
Logger.LogException($"Error reading file: {e.Message}", e, nameof(ParseLog));
AnalogyLogMessage error = new AnalogyLogMessage($"Error reading file: {e.Message}", AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "Analogy");
messagesHandler.AppendMessages(_messages, fileName);
_messages.Add(error);
return(_messages);
}
}
public async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token,
ILogMessageCreatedHandler messagesHandler)
{
if (string.IsNullOrEmpty(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File is null or empty. Aborting.",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
if (!_logFileSettings.IsConfigured)
{
AnalogyLogMessage empty = new AnalogyLogMessage(
$"File Parser is not configured. Please set it first in the settings Window",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
if (!_logFileSettings.CanOpenFile(fileName))
{
AnalogyLogMessage empty = new AnalogyLogMessage(
$"File {fileName} Is not supported or not configured correctly in the windows settings",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>();
try
{
string xmlData = File.ReadAllText(fileName);
List <List <(string, string)> > ParseData(string data) => ParserInternal(data);
try
{
var rows = ParseData(xmlData);
foreach (var items in rows)
{
List <(string, string)> tuples = new List <(string, string)>(items.Count);
foreach (var(key, value) in items)
{
var keyProperty = _logFileSettings.GetAnalogyPropertyName(key);
tuples.Add(keyProperty.HasValue
? (keyProperty.Value.ToString(), value)
: (key, value));
}
var m = AnalogyLogMessage.Parse(tuples);
messages.Add(m);
}
}
catch (Exception e)
{
string data = TryFix(xmlData);
ParseData(data);
}
messagesHandler.AppendMessages(messages, fileName);
return(messages);
}
catch (Exception e)
{
AnalogyLogMessage empty = new AnalogyLogMessage($"Error occured processing file {fileName}. Reason: {e.Message}",
AnalogyLogLevel.Critical, AnalogyLogClass.General, "Analogy", "None")
{
Source = "Analogy",
Module = System.Diagnostics.Process.GetCurrentProcess().ProcessName
};
messagesHandler.AppendMessage(empty, GetFileNameAsDataSource(fileName));
return(new List <AnalogyLogMessage> {
empty
});
}
}
public async Task <IEnumerable <AnalogyLogMessage> > ReadFromFile(string fileName,
ILogMessageCreatedHandler logWindow)
{
if (!File.Exists(fileName))
{
await Task.CompletedTask;
return(new List <AnalogyLogMessage>());
}
List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>();
return(await Task.Factory.StartNew(() =>
{
try
{
using (var reader = new EventLogReader(fileName, PathType.FilePath))
{
EventRecord record;
while ((record = reader.ReadEvent()) != null)
{
if (Token.IsCancellationRequested)
{
break;
}
using (record)
{
AnalogyLogMessage m = new AnalogyLogMessage
{
Date = record.TimeCreated ?? DateTime.MinValue,
Source = record.ProviderName,
Module = record.ProviderName,
Level = AnalogyLogLevel.Information,
Id = record.ActivityId ?? Guid.Empty,
ProcessId = record.ProcessId ?? 0,
MachineName = record.MachineName,
ThreadId = record.ThreadId ?? 0,
FileName = fileName,
User = record.UserId?.Value
};
string properties = string.Join(Environment.NewLine,
record.Properties.Select(p => p.Value));
try
{
m.Text =
$"{record.MachineName} :({record.LogName}) - {record.FormatDescription()}{properties}{(record.ThreadId != null ? " Thread id:" + record.ThreadId.Value : string.Empty)}";
if (record.LevelDisplayName != null)
{
switch (record.LevelDisplayName)
{
case "Information":
m.Level = AnalogyLogLevel.Information;
break;
case "Error":
m.Level = AnalogyLogLevel.Error;
break;
case "Critical Error":
m.Level = AnalogyLogLevel.Critical;
break;
case "Warning":
m.Level = AnalogyLogLevel.Warning;
break;
case "Verbose":
m.Level = AnalogyLogLevel.Verbose;
break;
}
}
}
catch (Exception)
{
var items = record.Properties[0].Value.ToString()
.Split(_separators, StringSplitOptions.RemoveEmptyEntries);
if (items.Any() && items.Length == 4)
{
m.Text =
$"{record.MachineName} :({record.LogName}) - {items[3]} . Message ID: {items[2]}";
m.Category = items[1];
switch (items[0])
{
case "Informational":
m.Level = AnalogyLogLevel.Information;
break;
case "Information":
m.Level = AnalogyLogLevel.Information;
break;
case "Error":
m.Level = AnalogyLogLevel.Error;
break;
case "Critical":
m.Level = AnalogyLogLevel.Critical;
break;
case "Critical Error":
m.Level = AnalogyLogLevel.Critical;
break;
case "Warning":
m.Level = AnalogyLogLevel.Warning;
break;
case "Verbose":
m.Level = AnalogyLogLevel.Verbose;
break;
default:
m.Level = AnalogyLogLevel.Information;
break;
}
}
else
{
m.Text =
$"{record.MachineName} :({record.LogName}) - {record.FormatDescription()}{properties}{(record.ThreadId.HasValue ? " Thread id:" + record.ThreadId.Value : string.Empty)}";
if (record.Level != null)
{
switch (record.Level.Value)
{
case 2:
m.Level = AnalogyLogLevel.Error;
break;
case 3:
m.Level = AnalogyLogLevel.Warning;
break;
case 4:
m.Level = AnalogyLogLevel.Information;
break;
default:
m.Level = AnalogyLogLevel.Information;
break;
}
}
}
}
messages.Add(m);
logWindow.AppendMessage(m, GetFileNameAsDataSource(fileName));
}
}
}
}
catch (Exception e)
{
string fail = "Failed To parse: " + fileName + " Error:" + e;
AnalogyLogMessage m = new AnalogyLogMessage
{
Text = fail,
Level = AnalogyLogLevel.Critical,
Class = AnalogyLogClass.General,
Source = "Analogy"
};
LogManager.Instance.LogException($"Error reading file:{e.Message}", e, nameof(ReadFromFile));
messages.Add(m);
logWindow.AppendMessages(messages, GetFileNameAsDataSource(fileName));
}
if (!messages.Any())
{
AnalogyLogMessage empty = new AnalogyLogMessage($"File {fileName} is empty or corrupted",
AnalogyLogLevel.Error, AnalogyLogClass.General, "Analogy", "None");
messages.Add(empty);
logWindow.AppendMessage(empty, GetFileNameAsDataSource(fileName));
}
return messages;
}, Token));
}
public async Task <List <AnalogyLogMessage> > ParseLog(string fileName, CancellationToken token,
ILogMessageCreatedHandler messagesHandler)
{
_messages.Clear();
using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
bool TryParseInternal(string line, out AnalogyLogMessage msg)
{
if (_matchedPattern != null)
{
if (TryParse(line, _matchedPattern, out var m1))
{
msg = m1;
return(true);
}
msg = null;
return(false);
}
foreach (var logPattern in _logPatterns)
{
if (TryParse(line, logPattern, out var m2))
{
msg = m2;
_matchedPattern = logPattern;
return(true);
}
}
msg = null;
return(false);
}
using (var streamReader = new StreamReader(fileStream, Encoding.UTF8))
{
string line = string.Empty;
string currentLine;
while ((currentLine = await streamReader.ReadLineAsync().ConfigureAwait(false)) != null)
{
line += currentLine;
if (TryParseInternal(line, out var entry))
{
line = string.Empty;
}
else
{
if (string.IsNullOrEmpty(line))
{
line = currentLine;
}
continue;
}
if (entry != null)
{
if (updateUIAfterEachParsedLine)
{
messagesHandler.AppendMessage(entry, fileName);
}
_current = entry;
_messages.Add(_current);
}
else
{
if (_current == null)
{
_current = new AnalogyLogMessage {
Text = line
};
}
else
{
_current.Text += Environment.NewLine + line;
}
}
if (token.IsCancellationRequested)
{
messagesHandler.AppendMessages(_messages, fileName);
return(_messages);
}
}
}
}
if (!updateUIAfterEachParsedLine) //update only at the end
{
messagesHandler.AppendMessages(_messages, fileName);
}
return(_messages);
}
public override async Task <IEnumerable <AnalogyLogMessage> > Process(string fileName, CancellationToken token,
ILogMessageCreatedHandler messagesHandler)
{
List <AnalogyLogMessage> messages = new List <AnalogyLogMessage>();
void FileReceiverNewMessages(object sender, IReadOnlyCollection <Logazmic.Core.Log.LogMessage> e)
{
var newMessages = new List <AnalogyLogMessage>();
foreach (LogMessage log in e)
{
AnalogyLogMessage m = new AnalogyLogMessage(log.Message, GetLogLevel(log.LogLevel), AnalogyLogClass.General,
log.CallSiteClass, "", "", "", 0, 0, null, "", log.CallSiteMethod, log.SourceFileName, (int)log.SourceFileLineNr);
FillProperties(m, log);
newMessages.Add(m);
}
messages.AddRange(newMessages);
messagesHandler.AppendMessages(newMessages, fileName);
}
void FileReceiverNewMessage(object sender, Logazmic.Core.Log.LogMessage log)
{
AnalogyLogMessage m = new AnalogyLogMessage(log.Message, GetLogLevel(log.LogLevel), AnalogyLogClass.General,
log.CallSiteClass, "", "", "", 0, 0, null, "", log.CallSiteMethod, log.SourceFileName, (int)log.SourceFileLineNr);
messages.Add(m);
messagesHandler.AppendMessage(m, fileName);
}
var fileReceiver = new FileReceiver
{
LogReaderFactory = _logReaderFactory,
FileToWatch = fileName,
LogFormat = _logReaderFactory.GetLogFormatByFileExtension(Path.GetExtension(fileName))
};
try
{
var tcs = new TaskCompletionSource <IEnumerable <AnalogyLogMessage> >();
fileReceiver.NewMessage += FileReceiverNewMessage;
fileReceiver.NewMessages += FileReceiverNewMessages;
fileReceiver.OnDoneReadingFile += (s, e) =>
{
tcs.SetResult(messages);
};
fileReceiver.Initialize();
var result = await tcs.Task.ConfigureAwait(false);
return(result);
}
catch (Exception e)
{
Analogy.LogViewer.Template.Managers.LogManager.Instance.LogException($"Error reading file: {e.Message}", e, nameof(Process));
return(messages);
}
finally
{
fileReceiver.NewMessage -= FileReceiverNewMessage;
fileReceiver.NewMessages -= FileReceiverNewMessages;
}
}