/// <summary>
/// Gets the specified log entries from the active log file.
/// </summary>
/// <param name="origin">
/// An enumeration indicating where the query operation starts.
/// </param>
/// <param name="direction">
/// An enumeration indicating the direction of the query task.
/// </param>
/// <param name="count">
/// The number of event log entries to retrieve.
/// </param>
/// <returns>
/// A collection of the entries contained within the active log file.
/// </returns>
public static EventLogEntryCollection GetEntries(EventLogOrigin origin, EventLogDirection direction, int count)
{
var entries = new EventLogEntryCollection( );
// Load the active log entries
EventLogEntryCollection activeEntries = LoadActiveLog( );
// Check for valid query options
if ((origin == EventLogOrigin.First) && (direction == EventLogDirection.FirstToLast))
{
count = (activeEntries.Count < count) ? activeEntries.Count : count;
// Copy the specified log entries (oldest to newest)
for (int x = 0; x < count; ++x)
{
if (x >= 0 && x < activeEntries.Count) //assert true .. but something is failing intermittently
{
entries.Add(activeEntries[x]);
}
}
}
else if ((origin == EventLogOrigin.Last) && (direction == EventLogDirection.LastToFirst))
{
count = (activeEntries.Count < count) ? activeEntries.Count : count;
// Copy the specified log entries (newest to oldest)
for (int x = count - 1; x >= 0; --x)
{
if (x >= 0 && x < activeEntries.Count) //assert true .. but something is failing intermittently
{
entries.Add(activeEntries[x]);
}
}
}
return(entries);
}
/// <summary>
/// Gets the specified log entries from the active log file.
/// </summary>
/// <param name="id">
/// An id identifying the log entry where the query operation starts.
/// </param>
/// <param name="direction">
/// An enumeration indicating the direction of the query task.
/// </param>
/// <param name="count">
/// The number of event log entries to retrieve.
/// </param>
/// <returns>
/// A collection of the entries contained within the active log file.
/// </returns>
public static EventLogEntryCollection GetEntries(Guid id, EventLogDirection direction, int count)
{
var entries = new EventLogEntryCollection( );
// Check for valid query options
if (id != Guid.Empty)
{
// Load the active log entries
EventLogEntryCollection activeEntries = LoadActiveLog( );
// Check if the specified entry exists (using LINQ)
int index = activeEntries.FindIndex(entry => entry.Id == id);
if (index >= 0)
{
if (direction == EventLogDirection.FirstToLast)
{
// Move the index forward by one position (i.e. next position)
index = index + 1;
// Determine the number of log entries to retreive
count = (activeEntries.Count - index < count) ? activeEntries.Count - index : count;
// Copy the specified log entries (oldest to newest)
for (int x = 0; x < count; ++x)
{
var i = index + x;
if (i >= 0 && i < activeEntries.Count) //assert true .. but something is failing intermittently
{
entries.Add(activeEntries[i]);
}
}
}
else if (direction == EventLogDirection.LastToFirst)
{
// ToDo: Implement
}
}
}
return(entries);
}
/// <summary>
/// Loads the log entries from the specified log file.
/// </summary>
/// <param name="path">
/// A string containing the path of the log file to examine.
/// </param>
/// <returns>
/// A dictionary of the entries contained within the specified log file.
/// </returns>
private static EventLogEntryCollection LoadLog_Impl(string path)
{
var eventLogEntries = new EventLogEntryCollection( );
// Attempt to open the log file
FileStream logStream = FileHelper.TryOpenFile(path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite, 10000);
if (logStream != null)
{
try
{
var xrs = new XmlReaderSettings
{
ConformanceLevel = ConformanceLevel.Fragment
};
using (XmlReader xr = XmlReader.Create(logStream, xrs))
{
while (xr.Read( ))
{
if (xr.NodeType == XmlNodeType.Element &&
xr.Name == "entry")
{
// ReSharper disable EmptyGeneralCatchClause
try
{
XElement entry = XElement.Load(xr.ReadSubtree( ));
Guid id;
DateTime date;
long timestamp;
EventLogLevel level;
string machine;
string process;
int thread;
string source;
string message;
long tenantId = -1;
string userName = string.Empty;
string tenantName = string.Empty;
XElement element = entry.Element("id");
if (element != null)
{
id = new Guid(element.Value);
}
else
{
continue;
}
XElement dateElement = entry.Element("date");
if (dateElement != null)
{
date = DateTime.Parse(dateElement.Value);
timestamp = long.Parse(dateElement.Attribute("timestamp").Value);
}
else
{
continue;
}
XElement levelElement = entry.Element("level");
if (levelElement != null)
{
level = ( EventLogLevel )Enum.Parse(typeof(EventLogLevel), levelElement.Value, true);
}
else
{
continue;
}
XElement machineElement = entry.Element("machine");
if (machineElement != null)
{
machine = machineElement.Value;
}
else
{
continue;
}
XElement processElement = entry.Element("process");
if (processElement != null)
{
process = processElement.Value;
}
else
{
continue;
}
XElement threadElement = entry.Element("thread");
if (threadElement != null)
{
thread = int.Parse(threadElement.Value);
}
else
{
continue;
}
XElement sourceElement = entry.Element("source");
if (sourceElement != null)
{
source = sourceElement.Value;
}
else
{
continue;
}
XElement messageElement = entry.Element("message");
if (messageElement != null)
{
message = messageElement.Value;
}
else
{
continue;
}
XElement tenantIdElement = entry.Element("tenantId");
if (tenantIdElement != null)
{
if (!long.TryParse(tenantIdElement.Value, out tenantId))
{
tenantId = -1;
}
}
XElement tenantNameElement = entry.Element("tenantName");
if (tenantNameElement != null)
{
tenantName = tenantNameElement.Value;
}
XElement userNameElement = entry.Element("userName");
if (userNameElement != null)
{
userName = userNameElement.Value;
}
var eventLogEntry = new EventLogEntry(id, date, timestamp, level, machine, process, thread, source, message, tenantId, tenantName, userName, path);
eventLogEntries.Add(eventLogEntry);
}
catch
{
// Do nothing
}
// ReSharper restore EmptyGeneralCatchClause
}
}
}
}
finally
{
logStream.Close( );
}
}
return(eventLogEntries);
}