public RowPrototype(LogEntry p_row)
{
MyIdString = (p_row.Info + p_row.ErrorInfo);
m_strOrigString = (p_row.Info + p_row.ErrorInfo);
MyDataRow = p_row;
m_colTrigrams = GetStringTrigrams(m_strIdString);
}
public void ConstructorTest()
{
var number = "55";
var entryText = "Error is database!";
var entry = new LogEntry(number, entryText);
Assert.AreEqual(number, entry.LineNumber);
Assert.AreEqual(entryText, entry.EntryText);
}
public void ToArrayTest()
{
string number = "734";
string entryText = "restarting NSD, please wait...";
string[] logEntryArray = new string[] { "734", "restarting NSD, please wait..." };
var entry = new LogEntry(number, entryText);
Assert.AreEqual(logEntryArray, entry.ToArray());
Assert.AreEqual(2, entry.ToArray().Length);
}
public void ConstructorTest(
[Values("34534", "11222", "234534667", null, "")]
string number,
[Values("hi", "whats up", "errors559", null, "")]
string entryText
)
{
var entry = new LogEntry(number, entryText);
Assert.AreEqual(number, entry.LineNumber);
Assert.AreEqual(entryText, entry.EntryText);
}
public static void Save(string filePath, LogEntry[] logEntries)
{
using(var stream = File.Open(filePath, FileMode.Create))
{
WriteUTF8EncodingHeader(stream);
using(var sw = new StreamWriter(stream))
{
foreach(LogEntry logEntry in logEntries)
{
sw.WriteLine(ToString(logEntry));
}
}
}
}
public static LogEntry ParseLogEntry(string serializedLogEntry)
{
string[] parts = serializedLogEntry.Split((char)65533);
if (parts.Length != 8)
{
parts = serializedLogEntry.Split((char)160);
}
if (parts.Length != 8)
{
return null;
}
var result = new LogEntry();
try
{
string date = parts[0] + parts[1];
result.TimeStamp = DateTime.ParseExact(date, "yyyyMMddhh:mm:ss.ffff",
CultureInfo.InvariantCulture.DateTimeFormat);
result.ApplicationDomainId = int.Parse(parts[2]);
result.ThreadId = int.Parse(parts[3]);
result.Severity = parts[4];
result.Title = parts[5];
result.DisplayOptions = parts[6];
result.Message = parts[7];
}
catch (Exception)
{
return null;
}
return result;
}
private void ReadNDC(XmlReader xmlreader, Names names, LogEntry logentry)
{
if (xmlreader.Read()){
switch (xmlreader.NodeType){
case XmlNodeType.Whitespace:
break;
case XmlNodeType.Element:
if (Object.ReferenceEquals(xmlreader.LocalName, names.ndc)){
}
else{
throw new NotImplementedException("!");
}
break;
case XmlNodeType.EndElement:
if (Object.ReferenceEquals(xmlreader.LocalName, names.ndc)){
return;
}
throw new NotImplementedException("! " + xmlreader.Name);
default:
throw new NotImplementedException("! " + xmlreader.NodeType);
}
}
}
private void ReadProperties(XmlReader xmlreader, Names names, LogEntry logentry)
{
while (xmlreader.Read()) {
switch (xmlreader.NodeType) {
case XmlNodeType.Whitespace:
break;
case XmlNodeType.Element:
if (Object.ReferenceEquals (xmlreader.LocalName, names.data)) {
ReadDataAttributes (xmlreader, names, logentry);
} else {
throw new NotImplementedException ("!");
}
break;
case XmlNodeType.EndElement:
if (Object.ReferenceEquals (xmlreader.LocalName, names.data)) {
} else if (Object.ReferenceEquals (xmlreader.LocalName, names.properties)) {
return;
} else {
throw new NotImplementedException ("! " + xmlreader.Name);
}
break;
default:
throw new NotImplementedException ("! " + xmlreader.NodeType);
}
}
}
private void ReadDataAttributes(XmlReader xmlreader, Names names, LogEntry logentry)
{
var name = string.Empty;
var val = string.Empty;
if (xmlreader.HasAttributes) {
while (xmlreader.MoveToNextAttribute()) {
if (Object.ReferenceEquals (xmlreader.LocalName, names.name)) {
name = xmlreader.Value;
} else if (Object.ReferenceEquals (xmlreader.LocalName, names.value)) {
val = xmlreader.Value;
} else {
throw new NotImplementedException (xmlreader.LocalName);
}
}
// move back to the element node that contains
// the attributes we just traversed
xmlreader.MoveToElement ();
if (logentry.Data.Properties == null)
{
logentry.Data.Properties = new PropertiesDictionary();
}
logentry.Data.Properties[name] = val;
switch (name) {
case ("log4net:UserName"):
logentry.Data.UserName = val;
break;
case ("log4japp"):
logentry.Data.Domain = val;
break;
}
}
}
private void ReadLocationInfo(XmlReader xmlreader, Names names, LogEntry logentry)
{
var className = string.Empty;
var methodName = string.Empty;
var fileName = string.Empty;
var lineNumber = string.Empty;
if (xmlreader.HasAttributes) {
while (xmlreader.MoveToNextAttribute()) {
if (Object.ReferenceEquals (xmlreader.LocalName, names.@class)) {
className = xmlreader.Value;
} else if (Object.ReferenceEquals (xmlreader.LocalName, names.method)) {
methodName = xmlreader.Value;
} else if (Object.ReferenceEquals (xmlreader.LocalName, names.file)) {
fileName = xmlreader.Value;
} else if (Object.ReferenceEquals (xmlreader.LocalName, names.line)) {
lineNumber = xmlreader.Value;
} else {
throw new NotImplementedException (xmlreader.LocalName);
}
}
logentry.Data.LocationInfo = new LocationInfo(className, methodName, fileName, lineNumber);
xmlreader.MoveToElement ();
}
}
private void AddToGrid(LogEntry entry)
{
Color? displayOptions = ParseDisplayOptions(entry);
string[] messageLines = entry.Message.Split(new[] { '\n' });
string firstLine = messageLines.Length > 0 ? messageLines[0] : string.Empty;
AddToGrid(new LogEntryGridRow
{
Date = entry.TimeStamp.ToString(DateFormatString),
Time = entry.TimeStamp.ToString(TimeFormatString),
AppDomainId = entry.ApplicationDomainId.ToString(),
ThreadId = entry.ThreadId.ToString(),
Severity = entry.Severity,
Title = entry.Title,
Message = firstLine
}, displayOptions);
for (int i = 1; i < messageLines.Length; i++)
{
AddToGrid(new LogEntryGridRow
{
Message = messageLines[i]
}, displayOptions);
}
}
private void EventChildren(XmlReader xmlreader, Names names, LogEntry logentry)
{
while (xmlreader.Read()) {
switch (xmlreader.NodeType) {
case XmlNodeType.Whitespace:
break;
case XmlNodeType.Element:
if (Object.ReferenceEquals (xmlreader.LocalName, names.message))
{
logentry.Data.Message = xmlreader.ReadInnerXml ();
}
else if (Object.ReferenceEquals (xmlreader.LocalName, names.throwable)
|| Object.ReferenceEquals (xmlreader.LocalName, names.exception))
{
logentry.Data.ExceptionString = xmlreader.ReadInnerXml ();
}
else if (Object.ReferenceEquals (xmlreader.LocalName, names.properties)) {
ReadProperties (xmlreader, names, logentry);
} else if (Object.ReferenceEquals (xmlreader.LocalName, names.locationinfo)) {
ReadLocationInfo (xmlreader, names, logentry);
} else if (Object.ReferenceEquals (xmlreader.LocalName, names.data)) {
ReadDataAttributes (xmlreader, names, logentry);
} else if (Object.ReferenceEquals(xmlreader.LocalName, names.ndc)) {
ReadNDC(xmlreader, names, logentry);
} else {
throw new NotImplementedException ("1! " + xmlreader.Name);
}
break;
case XmlNodeType.EndElement:
if (Object.ReferenceEquals (xmlreader.LocalName, names.@event)) {
return;
} else if (Object.ReferenceEquals (xmlreader.LocalName, names.message)
|| Object.ReferenceEquals (xmlreader.LocalName, names.throwable)
|| Object.ReferenceEquals (xmlreader.LocalName, names.exception)
|| Object.ReferenceEquals (xmlreader.LocalName, names.properties)
) {
//Ignore it
} else {
throw new NotImplementedException ("3! " + xmlreader.Name);
}
break;
default:
throw new NotImplementedException ("2! " + xmlreader.NodeType);
//break;
}
}
}
//gui
bool IsLineInFilter(string strLogFile, LogEntry row)
{
string a = row.Info;
string b = row.ErrorInfo;
string c = row.UserName;
string d = row.LogLevel;
string line = a + " " + b + " " + c + " " + d;
return IsLineInFilter(strLogFile, line);
}
private void AddToEntries(LogEntry entry)
{
Entries.Add(entry);
}
private Color? ParseDisplayOptions(LogEntry entry)
{
string displayOptions = entry.DisplayOptions;
if (displayOptions != null
&& displayOptions.Length > 8
&& displayOptions.StartsWith("RGB(")
&& displayOptions.EndsWith(")"))
{
string[] colors = displayOptions.Substring(4, displayOptions.Length - 5).Split(new[] { ',' });
byte R, G, B;
if (colors.Length == 3
&& byte.TryParse(colors[0], out R)
&& byte.TryParse(colors[1], out G)
&& byte.TryParse(colors[2], out B))
{
return Color.FromArgb(R, G, B);
}
}
if (entry.Severity == InformationPriority)
{
return Color.LightGreen;
}
if (entry.Severity == WarningPriority)
{
return Color.Yellow;
}
if (entry.Severity == CriticalPriority || entry.Severity == ErrorPriority)
{
return Color.Red;
}
return null;
}
public IEnumerable<LogEntry> Parse(Stream s)
{
var nt = new NameTable ();
var nsmgr = new XmlNamespaceManager (nt);
nsmgr.AddNamespace ("log4j", "http://jakarta.apache.org/log4j/");
nsmgr.AddNamespace ("log4net", "http://logging.apache.org/log4net/");
// Create the XmlParserContext.
var context = new XmlParserContext (null, nsmgr, null, XmlSpace.None);
// Create the reader.
var settings = new XmlReaderSettings
{
ConformanceLevel = ConformanceLevel.Fragment,
CheckCharacters = false,
XmlResolver = null,
DtdProcessing = DtdProcessing.Ignore
};
var list = new List<LogEntry> ();
var encoding = Encoding.UTF8;
var xmlreader = XmlReader.Create (new StreamReader (s, encoding), settings, context);
Names names = new Names{
@event = xmlreader.NameTable.Add ("event"),
message = xmlreader.NameTable.Add ("message"),
properties = xmlreader.NameTable.Add ("properties"),
data = xmlreader.NameTable.Add ("data"),
ndc = xmlreader.NameTable.Add("NDC"),
name = xmlreader.NameTable.Add ("name"),
@value = xmlreader.NameTable.Add ("value"),
throwable = xmlreader.NameTable.Add ("throwable"),
exception = xmlreader.NameTable.Add ("exception"),
timestamp = xmlreader.NameTable.Add ("timestamp"),
thread = xmlreader.NameTable.Add ("thread"),
domain = xmlreader.NameTable.Add ("domain"),
level = xmlreader.NameTable.Add ("level"),
logger = xmlreader.NameTable.Add ("logger"),
locationinfo = xmlreader.NameTable.Add ("locationInfo"),
@class = xmlreader.NameTable.Add ("class"),
method = xmlreader.NameTable.Add ("method"),
file = xmlreader.NameTable.Add ("file"),
line = xmlreader.NameTable.Add ("line"),
username = xmlreader.NameTable.Add ("username")};
while (xmlreader.Read()) {
switch (xmlreader.NodeType) {
case XmlNodeType.Whitespace:
break;
case XmlNodeType.Element:
if (Object.ReferenceEquals (xmlreader.LocalName, names.@event)) {
LogEntry logentry = null;
logentry = new LogEntry ();
if (xmlreader.HasAttributes) {
while (xmlreader.MoveToNextAttribute()) {
if (Object.ReferenceEquals (xmlreader.LocalName, names.timestamp)) {
var timestamp = xmlreader.Value;
if (!string.IsNullOrEmpty (timestamp)) {
double dSeconds;
logentry.Data.TimeStamp = Double.TryParse (timestamp, out dSeconds)
? _dt.AddMilliseconds (dSeconds).ToLocalTime ()
: DateTime.Parse (timestamp).ToLocalTime ();
}
} else if (Object.ReferenceEquals (xmlreader.LocalName, names.thread))
{
logentry.Data.ThreadName = xmlreader.Value;
}
else if (Object.ReferenceEquals (xmlreader.LocalName, names.domain))
{
logentry.Data.Domain = xmlreader.Value;
}
else if (Object.ReferenceEquals (xmlreader.LocalName, names.level)) {
logentry.Data.Level = LogEntry.GetLevel(xmlreader.Value);
logentry.Image = LogEntryParser.ParseImageType (logentry.Data.Level.Name);
} else if (Object.ReferenceEquals (xmlreader.LocalName, names.logger))
{
logentry.Data.LoggerName = xmlreader.Value;
}
else if (Object.ReferenceEquals (xmlreader.LocalName, names.username))
{
logentry.Data.UserName = xmlreader.Value;
}
else {
throw new NotImplementedException (xmlreader.LocalName);
}
}
xmlreader.MoveToElement ();
}
EventChildren (xmlreader, names, logentry);
list.Add (logentry);
} else {
Console.WriteLine (xmlreader.NodeType + ", " + xmlreader.Name + ": " + xmlreader.Value);
throw new NotImplementedException ();
}
break;
default:
Console.WriteLine (xmlreader.NodeType + ", " + xmlreader.Name + ": " + xmlreader.Value);
throw new NotImplementedException (xmlreader.NodeType.ToString ());
}
}
return list;
}
private void button1_Click(object sender, EventArgs e)
{
var entry1 = new LogEntry
{
Severity = "Information",
TimeStamp = DateTime.Now,
DisplayOptions = "RGB(250,50,50)",
Message = "uiosdfkljsdfl; sdl;fksd;f,",
Title = "Hello world!!!"
};
var entry2 = new LogEntry
{
Severity = "Critical",
Message = "[iosdfkljsdfl; ",
DisplayOptions = "RGB(50,250,150)",
TimeStamp = DateTime.Now.AddDays(-1).AddSeconds(2.5),
Title = "ERsdfkljsdlfj asiofje!!!"
};
var entry3 = new LogEntry
{
Severity = "Verbose",
Message = "sdfklsdfsdfjsdfl; ",
DisplayOptions = "RGB(50,150,150)",
TimeStamp = DateTime.Now.AddDays(-1).AddSeconds(2.7),
Title = "ERsdfkljssdfsdfdlfj asiofje!!!"
};
var entry4 = new LogEntry
{
Severity = "Warning",
Message = "bvnvsdfkljsdfl; ",
DisplayOptions = "RGB(170,20,10)",
TimeStamp = DateTime.Now.AddDays(-1).AddSeconds(2.9),
Title = "ERsdfssdfkljsdlfj asiot565fje!!!"
};
PopulateGrid(new[] { entry1, entry2, entry3, entry4, entry2, entry1, entry3 });
}
private void LoadFile()
{
textboxFileName.Text = FileName;
_Entries.Clear();
listView1.ItemsSource = null;
DateTime dt = new DateTime(1970, 1, 1, 0, 0, 0, 0);
string sXml = string.Empty;
string sBuffer = string.Empty;
int iIndex = 1;
Clear();
try
{
FileStream oFileStream = new FileStream(FileName, FileMode.OpenOrCreate, FileAccess.Read, FileShare.ReadWrite);
StreamReader oStreamReader = new StreamReader(oFileStream);
sBuffer = string.Format("<root>{0}</root>", oStreamReader.ReadToEnd());
oStreamReader.Close();
oFileStream.Close();
#region Read File Buffer
////////////////////////////////////////////////////////////////////////////////
StringReader oStringReader = new StringReader(sBuffer);
XmlTextReader oXmlTextReader = new XmlTextReader(oStringReader);
oXmlTextReader.Namespaces = false;
while (oXmlTextReader.Read())
{
if ((oXmlTextReader.NodeType == XmlNodeType.Element) && (oXmlTextReader.Name == "log4j:event"))
{
LogEntry logentry = new LogEntry();
logentry.Item = iIndex;
double dSeconds = Convert.ToDouble(oXmlTextReader.GetAttribute("timestamp"));
logentry.TimeStamp = dt.AddMilliseconds(dSeconds).ToLocalTime();
logentry.Thread = oXmlTextReader.GetAttribute("thread");
#region get level
////////////////////////////////////////////////////////////////////////////////
logentry.Level = oXmlTextReader.GetAttribute("level");
switch (logentry.Level)
{
case "ERROR":
{
logentry.Image = LogEntry.Images(LogEntry.IMAGE_TYPE.ERROR);
break;
}
case "INFO":
{
logentry.Image = LogEntry.Images(LogEntry.IMAGE_TYPE.INFO);
break;
}
case "DEBUG":
{
logentry.Image = LogEntry.Images(LogEntry.IMAGE_TYPE.DEBUG);
break;
}
case "WARN":
{
logentry.Image = LogEntry.Images(LogEntry.IMAGE_TYPE.WARN);
break;
}
case "FATAL":
{
logentry.Image = LogEntry.Images(LogEntry.IMAGE_TYPE.FATAL);
break;
}
default:
{
logentry.Image = LogEntry.Images(LogEntry.IMAGE_TYPE.CUSTOM);
break;
}
}
////////////////////////////////////////////////////////////////////////////////
#endregion
#region read xml
////////////////////////////////////////////////////////////////////////////////
while (oXmlTextReader.Read())
{
if (oXmlTextReader.Name == "log4j:event") // end element
break;
else
{
switch (oXmlTextReader.Name)
{
case ("log4j:message"):
{
logentry.Message = oXmlTextReader.ReadString();
break;
}
case ("log4j:data"):
{
switch (oXmlTextReader.GetAttribute("name"))
{
case ("log4jmachinename"):
{
logentry.MachineName = oXmlTextReader.GetAttribute("value");
break;
}
case ("log4net:HostName"):
{
logentry.HostName = oXmlTextReader.GetAttribute("value");
break;
}
case ("log4net:UserName"):
{
logentry.UserName = oXmlTextReader.GetAttribute("value");
break;
}
case ("log4japp"):
{
logentry.App = oXmlTextReader.GetAttribute("value");
break;
}
}
break;
}
case ("log4j:throwable"):
{
logentry.Throwable = oXmlTextReader.ReadString();
break;
}
case ("log4j:locationInfo"):
{
logentry.Class = oXmlTextReader.GetAttribute("class");
logentry.Method = oXmlTextReader.GetAttribute("method");
logentry.File = oXmlTextReader.GetAttribute("file");
logentry.Line = oXmlTextReader.GetAttribute("line");
break;
}
}
}
}
////////////////////////////////////////////////////////////////////////////////
#endregion
_Entries.Add(logentry);
iIndex++;
#region Show Counts
////////////////////////////////////////////////////////////////////////////////
int ErrorCount =
(
from entry in Entries
where entry.Level == "ERROR"
select entry
).Count();
if (ErrorCount > 0)
{
labelErrorCount.Content = string.Format("{0:#,#} ", ErrorCount);
labelErrorCount.Visibility = Visibility.Visible;
imageError.Visibility = Visibility.Visible;
}
else
{
labelErrorCount.Visibility = Visibility.Hidden;
imageError.Visibility = Visibility.Hidden;
}
int InfoCount =
(
from entry in Entries
where entry.Level == "INFO"
select entry
).Count();
if (InfoCount > 0)
{
labelInfoCount.Content = string.Format("{0:#,#} ", InfoCount);
labelInfoCount.Visibility = Visibility.Visible;
imageInfo.Visibility = Visibility.Visible;
}
else
{
labelInfoCount.Visibility = Visibility.Hidden;
imageInfo.Visibility = Visibility.Hidden;
}
int WarnCount =
(
from entry in Entries
where entry.Level == "WARN"
select entry
).Count();
if (WarnCount > 0)
{
labelWarnCount.Content = string.Format("{0:#,#} ", WarnCount);
labelWarnCount.Visibility = Visibility.Visible;
imageWarn.Visibility = Visibility.Visible;
}
else
{
labelWarnCount.Visibility = Visibility.Hidden;
imageWarn.Visibility = Visibility.Hidden;
}
int DebugCount =
(
from entry in Entries
where entry.Level == "DEBUG"
select entry
).Count();
if (DebugCount > 0)
{
labelDebugCount.Content = string.Format("{0:#,#} ", DebugCount);
labelDebugCount.Visibility = Visibility.Visible;
imageDebug.Visibility = Visibility.Visible;
}
else
{
labelDebugCount.Visibility = Visibility.Hidden;
labelDebugCount.Visibility = Visibility.Hidden;
}
////////////////////////////////////////////////////////////////////////////////
#endregion
}
}
////////////////////////////////////////////////////////////////////////////////
#endregion
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
this.listView1.ItemsSource = _Entries;
}
private void ReadProperties(XmlReader xmlreader, Names names, LogEntry logentry)
{
while (xmlreader.Read())
{
switch (xmlreader.NodeType)
{
case XmlNodeType.Whitespace:
break;
case XmlNodeType.Element:
if (Object.ReferenceEquals(xmlreader.LocalName, names.data))
{
ReadDataAttributes(xmlreader, names, logentry);
}
else
{
throw new Exception("READPROPERTIES1: Expected data but was: " + xmlreader.LocalName);
}
break;
case XmlNodeType.EndElement:
if (Object.ReferenceEquals(xmlreader.LocalName, names.data))
{
}
else if (Object.ReferenceEquals(xmlreader.LocalName, names.properties))
{
return;
}
else
{
throw new Exception("READPROPERTIES2: Expected localname to be data or properties: " + xmlreader.Name);
}
break;
default:
throw new Exception("READPROPERTIES3: Expected type to be element, whitespace or endelement but was: " + xmlreader.NodeType);
}
}
}
private void ReadNDC(XmlReader xmlreader, Names names, LogEntry logentry)
{
if (xmlreader.Read())
{
switch (xmlreader.NodeType)
{
case XmlNodeType.Whitespace:
break;
case XmlNodeType.Element:
if (Object.ReferenceEquals(xmlreader.LocalName, names.ndc))
{
}
else
{
throw new Exception("READNDC1: Expected localname to be ndc but was: " + xmlreader.LocalName);
}
break;
case XmlNodeType.EndElement:
if (Object.ReferenceEquals(xmlreader.LocalName, names.ndc))
{
return;
}
throw new Exception("READNDC2: Expected localname to be ndc but was: " + xmlreader.LocalName);
default:
throw new Exception("READNDC2: Expected type to be whitespace, element or endelement but was: " + xmlreader.NodeType);
}
}
}
private void EventChildren(XmlReader xmlreader, Names names, LogEntry logentry)
{
while (xmlreader.Read())
{
switch (xmlreader.NodeType)
{
case XmlNodeType.Whitespace:
break;
case XmlNodeType.Element:
if (Object.ReferenceEquals(xmlreader.LocalName, names.message))
{
logentry.Data.Message = xmlreader.ReadInnerXml();
}
else if (Object.ReferenceEquals(xmlreader.LocalName, names.throwable)
|| Object.ReferenceEquals(xmlreader.LocalName, names.exception))
{
logentry.Data.ExceptionString = xmlreader.ReadInnerXml();
}
else if (Object.ReferenceEquals(xmlreader.LocalName, names.properties))
{
ReadProperties(xmlreader, names, logentry);
}
else if (Object.ReferenceEquals(xmlreader.LocalName, names.locationinfo))
{
ReadLocationInfo(xmlreader, names, logentry);
}
else if (Object.ReferenceEquals(xmlreader.LocalName, names.data))
{
ReadDataAttributes(xmlreader, names, logentry);
}
else if (Object.ReferenceEquals(xmlreader.LocalName, names.ndc))
{
ReadNDC(xmlreader, names, logentry);
}
else
{
throw new Exception("EVENTCHILDREN1: Expected a known name but was: " + xmlreader.Name);
}
break;
case XmlNodeType.EndElement:
if (Object.ReferenceEquals(xmlreader.LocalName, names.@event))
{
return;
}
else if (Object.ReferenceEquals(xmlreader.LocalName, names.message)
|| Object.ReferenceEquals(xmlreader.LocalName, names.throwable)
|| Object.ReferenceEquals(xmlreader.LocalName, names.exception)
|| Object.ReferenceEquals(xmlreader.LocalName, names.properties)
)
{
//Ignore it
}
else
{
throw new Exception(
"EVENTCHILDREN2: expected end element to be either event, message, throwable, exception or properties, but was: " +
xmlreader.Name);
}
break;
case XmlNodeType.Text:
// Ignore it
break;
default:
throw new Exception(
"EVENTCHILDREN4: Expected either whitespace, element or end element but was: " +
xmlreader.NodeType);
//break;
}
}
}
//move to engine
/// <summary>
/// parses log file from the given position and on
/// </summary>
/// <param name="p_strLogFileName"></param>
/// <param name="p_intStartPos"></param>
/// <returns></returns>
public long ParseLogFileRegExp(string p_strLogFileName, long p_intStartPos, LogBehavior behaviorForCurrentFile)
{
//m_dtlogEntries.BeginLoadData();
long lngFileTotalBytes = 0;
long progressbytes = 0;
try
{
using (FileStream objFStream = new FileStream(p_strLogFileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
objFStream.Position = p_intStartPos;
using (StreamReader objReader = new StreamReader(objFStream, CurrentEncoding))
{
string strAllText = objReader.ReadToEnd();
lngFileTotalBytes = strAllText.Length;
//m_drPrevRow = drRow;
MatchCollection colMatches = behaviorForCurrentFile.ParserRegex.Matches(strAllText);
foreach (Match match in colMatches)
{
int increment = (int)((double)lngFileTotalBytes / (double)colMatches.Count);
progressbytes += increment;
ProgressBarManager.IncrementProgress(increment);
if (!IsLineInFilter(p_strLogFileName, match.Value))
{
continue;
}
LogEntry drRow = new LogEntry();
string strDate = match.Groups["date"].Value;
string strThread = match.Groups["thread"].Value;
string strLevel = match.Groups["level"].Value;
string strComputer = match.Groups["computer"].Value;
string strUser = match.Groups["user"].Value;
string strInfo = match.Groups["info"].Value;
string strInfoEx = match.Groups["exinfo"].Value.TrimEnd();
string strMachine = match.Groups["machine"].Value;
LogEntry row = new LogEntry();
drRow.ErrorInfo = strInfoEx;
//"14/11 16:39:03,236"
DateTime dtmTemp = DateTime.Now;
bool ok = System.DateTime.TryParseExact(strDate, behaviorForCurrentFile.DateFormat, Application.CurrentCulture, System.Globalization.DateTimeStyles.None, out dtmTemp);
if (!ok)
ok = System.DateTime.TryParseExact(strDate + "0", behaviorForCurrentFile.DateFormat, Application.CurrentCulture, System.Globalization.DateTimeStyles.None, out dtmTemp);
if (!ok)
ok = System.DateTime.TryParseExact(strDate + "00", behaviorForCurrentFile.DateFormat, Application.CurrentCulture, System.Globalization.DateTimeStyles.None, out dtmTemp);
if (!ok)
drRow.EntryTime = DateTime.MinValue;
else
drRow.EntryTime = dtmTemp;
if (strLevel.ToLower().StartsWith("trac"))
strLevel = "TRACE";
else if (strLevel.ToLower().StartsWith("inf"))
strLevel = "INFO";
else if (strLevel.ToLower().StartsWith("deb"))
strLevel = "DEBUG";
else if (strLevel.ToLower().StartsWith("err"))
strLevel = "ERROR";
else if (strLevel.ToLower().StartsWith("fat"))
strLevel = "FATAL";
else if (strLevel.ToLower().StartsWith("warn"))
strLevel = "WARN";
//drRow.EntryTime = DateTime.Parse(strDate);
drRow.ComputerName = strComputer;
drRow.UserName = strUser;
drRow.ThreadName = strThread;
drRow.Info = strInfo;
drRow.LogLevel = strLevel;
drRow.SourceLogFile = Path.GetFileName(p_strLogFileName);
drRow.UserName = strUser;
drRow.ComputerName = strMachine;
if (p_strLogFileName.StartsWith("\\\\"))
{
drRow.ServerName = p_strLogFileName.Substring(2, p_strLogFileName.IndexOf('\\', 3) - 2);
}
else
drRow.ServerName = "localhost";
//if (IsLineInFilter(p_strLogFileName, drRow.Info + " " + drRow.RowError))
//m_dtlogEntries.AddLogEntriesRow(drRow);
//if (IsLineInFilter(p_strLogFileName, match.Value))
//{
_dtlogEntries.Add(drRow);
drRow.Key = _dtlogEntries.Count;
//}
}
ProgressBarManager.IncrementProgress(lngFileTotalBytes - progressbytes);
}
}
}
catch
{
//only open a file in notepad if it's a new file causing the problem...
if (p_intStartPos == 0)
{
FRMVanishingAlert.ShowForm(2, "Wrong Log Format", "Not a known log,\r\n\rOpening Notepad", "", "", 0, 0, true, FormStartPosition.Manual, false);
string strWinDir = Environment.GetEnvironmentVariable("SystemRoot");
Process.Start(strWinDir + "\\notepad.exe", p_strLogFileName);
//this.Visible = false;
}
return long.MinValue;
}
return lngFileTotalBytes;
}
private bool ShouldBeFiltered(LogEntry entry)
{
IEnumerable<string> searchTexts = tb_Search.Text.Split(',').Select(f => f.Trim()).Where(f => f != string.Empty);
bool containingSearchText = false;
foreach (string searchText in searchTexts)
{
if (entry.Title.IndexOf(searchText, StringComparison.InvariantCultureIgnoreCase) >= 0 ||
entry.Message.IndexOf(searchText, StringComparison.InvariantCultureIgnoreCase) >= 0)
{
containingSearchText = true;
}
}
if (searchTexts.Count() > 0 && !containingSearchText) return true;
return (!chkShowVerbose.Checked && entry.Severity == VerbosePriority)
|| (!chkShowInfo.Checked && entry.Severity == InformationPriority)
|| (!chkShowWarnings.Checked && entry.Severity == WarningPriority)
|| (!chkShowCritical.Checked && entry.Severity == CriticalPriority);
}
private void PopulateGrid(LogEntry[] entries)
{
_currentLogEntriesSet = new List<LogEntry>(entries);
RefreshGrid();
}
private static ImageSource GetImage(LogEntry.ImageType image)
{
return _ImageList[image];
}
private void saveToolStripMenuItem_Click(object sender, EventArgs e)
{
LogEntry[] toSave = null;
lock (_syncRoot)
{
if (_currentLogEntriesSet != null && _currentLogEntriesSet.Count > 0)
{
toSave = new LogEntry[_currentLogEntriesSet.Count];
_currentLogEntriesSet.CopyTo(toSave);
}
}
if (toSave == null)
{
MessageBox.Show("No log entries has been loaded");
return;
}
if (saveFileDialog1.ShowDialog() == DialogResult.OK)
{
LogFile.Save(saveFileDialog1.FileName, toSave);
}
}
private static string ToString(LogEntry logEntry)
{
// Copied from Composite.Logging.WCF.LogEntry.ToString()
var sb = new StringBuilder();
sb.Append(logEntry.TimeStamp.ToString("yyyyMMdd"));
sb.Append(NonBreakingSpace).Append(logEntry.TimeStamp.ToString("hh:mm:ss.ffff"));
sb.Append(NonBreakingSpace).Append(logEntry.ApplicationDomainId);
sb.Append(NonBreakingSpace).Append(logEntry.ThreadId < 10 ? " " : string.Empty).Append(logEntry.ThreadId);
sb.Append(NonBreakingSpace).Append(logEntry.Severity);
sb.Append(NonBreakingSpace).Append(logEntry.Title);
sb.Append(NonBreakingSpace).Append(logEntry.DisplayOptions);
sb.Append(NonBreakingSpace).Append(logEntry.Message/*.Replace("\n", @"\n")*/);
return sb.ToString();
}
