/// <summary>
/// Create a new evaluator using the specified <see cref="Level"/> threshold.
/// </summary>
/// <param name="threshold">the threshold to trigger at</param>
/// <remarks>
/// <para>
/// Create a new evaluator using the specified <see cref="Level"/> threshold.
/// </para>
/// <para>
/// This evaluator will trigger if the level of the event
/// passed to <see cref="IsTriggeringEvent(LoggingEvent)"/>
/// is equal to or greater than the <see cref="Threshold"/>
/// level.
/// </para>
/// </remarks>
public LevelEvaluator(Level threshold) {
if (threshold == null) {
throw new ArgumentNullException("threshold");
}
m_threshold = threshold;
}
/// <summary>
/// Lookup the mapping for the specified level
/// </summary>
/// <param name="level">the level to lookup</param>
/// <returns>the <see cref="LevelMappingEntry"/> for the level or <c>null</c> if no mapping found</returns>
/// <remarks>
/// <para>
/// Lookup the value for the specified level. Finds the nearest
/// mapping value for the level that is equal to or less than the
/// <paramref name="level"/> specified.
/// </para>
/// <para>
/// If no mapping could be found then <c>null</c> is returned.
/// </para>
/// </remarks>
public LevelMappingEntry Lookup(Level level) {
if (m_entries != null) {
foreach (LevelMappingEntry entry in m_entries) {
if (level >= entry.Level) {
return entry;
}
}
}
return null;
}
/// <summary>
/// Construct the repository using specific properties
/// </summary>
/// <param name="properties">the properties to set for this repository</param>
/// <remarks>
/// <para>
/// Initializes the repository with specified properties.
/// </para>
/// </remarks>
protected LoggerRepositorySkeleton(PropertiesDictionary properties) {
m_properties = properties;
m_rendererMap = new RendererMap();
m_pluginMap = new PluginMap(this);
m_levelMap = new LevelMap();
m_configurationMessages = EmptyCollection.Instance;
m_configured = false;
AddBuiltinLevels();
// Don't disable any levels by default.
m_threshold = Level.All;
}
/// <summary>
/// Initializes a new instance of the <see cref="LoggingEvent" /> class
/// from the supplied parameters.
/// </summary>
/// <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
/// the stack boundary into the logging system for this call.</param>
/// <param name="repository">The repository this event is logged in.</param>
/// <param name="loggerName">The name of the logger of this event.</param>
/// <param name="level">The level of this event.</param>
/// <param name="message">The message of this event.</param>
/// <param name="exception">The exception for this event.</param>
/// <remarks>
/// <para>
/// Except <see cref="TimeStamp"/>, <see cref="Level"/> and <see cref="LoggerName"/>,
/// all fields of <c>LoggingEvent</c> are filled when actually needed. Call
/// <see cref="FixVolatileData()"/> to cache all data locally
/// to prevent inconsistencies.
/// </para>
/// <para>This method is called by the GodLesZ.Library.Logging framework
/// to create a logging event.
/// </para>
/// </remarks>
public LoggingEvent(Type callerStackBoundaryDeclaringType, GodLesZ.Library.Logging.Repository.ILoggerRepository repository, string loggerName, Level level, object message, Exception exception) {
m_callerStackBoundaryDeclaringType = callerStackBoundaryDeclaringType;
m_message = message;
m_repository = repository;
m_thrownException = exception;
m_data.LoggerName = loggerName;
m_data.Level = level;
// Store the event creation time
m_data.TimeStamp = DateTime.Now;
}
/// <summary>
/// Inserts an element into the <c>LevelCollection</c> at the specified index.
/// </summary>
/// <param name="index">The zero-based index at which <paramref name="item"/> should be inserted.</param>
/// <param name="item">The <see cref="Level"/> to insert.</param>
/// <exception cref="ArgumentOutOfRangeException">
/// <para><paramref name="index"/> is less than zero</para>
/// <para>-or-</para>
/// <para><paramref name="index"/> is equal to or greater than <see cref="LevelCollection.Count"/>.</para>
/// </exception>
public virtual void Insert(int index, Level item) {
ValidateIndex(index, true); // throws
if (m_count == m_array.Length) {
EnsureCapacity(m_count + 1);
}
if (index < m_count) {
Array.Copy(m_array, index, m_array, index + 1, m_count - index);
}
m_array[index] = item;
m_count++;
m_version++;
}
public override int AddRange(Level[] x) {
throw new NotSupportedException("This is a Read Only Collection and can not be modified");
}
/// <summary>
/// Lookup a named level from the map
/// </summary>
/// <param name="defaultLevel">the name of the level to lookup is taken from this level.
/// If the level is not set on the map then this level is added</param>
/// <returns>the level in the map with the name specified</returns>
/// <remarks>
/// <para>
/// Lookup a named level from the map. The name of the level to lookup is taken
/// from the <see cref="Level.Name"/> property of the <paramref name="defaultLevel"/>
/// argument.
/// </para>
/// <para>
/// If no level with the specified name is found then the
/// <paramref name="defaultLevel"/> argument is added to the level map
/// and returned.
/// </para>
/// </remarks>
public Level LookupWithDefault(Level defaultLevel) {
if (defaultLevel == null) {
throw new ArgumentNullException("defaultLevel");
}
lock (this) {
Level level = (Level)m_mapName2Level[defaultLevel.Name];
if (level == null) {
m_mapName2Level[defaultLevel.Name] = defaultLevel;
return defaultLevel;
}
return level;
}
}
public override void CopyTo(Level[] array, int start) {
m_collection.CopyTo(array, start);
}
public override int IndexOf(Level x) {
return m_collection.IndexOf(x);
}
/// <summary>
/// Construct a <see cref="RootLogger"/>
/// </summary>
/// <param name="level">The level to assign to the root logger.</param>
/// <remarks>
/// <para>
/// Initializes a new instance of the <see cref="RootLogger" /> class with
/// the specified logging level.
/// </para>
/// <para>
/// The root logger names itself as "root". However, the root
/// logger cannot be retrieved by name.
/// </para>
/// </remarks>
public RootLogger(Level level)
: base("root") {
this.Level = level;
}
/// <summary>
/// Adds the elements of a <see cref="Level"/> array to the current <c>LevelCollection</c>.
/// </summary>
/// <param name="x">The <see cref="Level"/> array whose elements should be added to the end of the <c>LevelCollection</c>.</param>
/// <returns>The new <see cref="LevelCollection.Count"/> of the <c>LevelCollection</c>.</returns>
public virtual int AddRange(Level[] x) {
if (m_count + x.Length >= m_array.Length) {
EnsureCapacity(m_count + x.Length);
}
Array.Copy(x, 0, m_array, m_count, x.Length);
m_count += x.Length;
m_version++;
return m_count;
}
/// <summary>
/// This is the most generic printing method. This generic form is intended to be used by wrappers
/// </summary>
/// <param name="level">The level of the message to be logged.</param>
/// <param name="message">The message object to log.</param>
/// <param name="exception">The exception to log, including its stack trace.</param>
/// <remarks>
/// <para>
/// Generate a logging event for the specified <paramref name="level"/> using
/// the <paramref name="message"/>.
/// </para>
/// </remarks>
virtual public void Log(Level level, object message, Exception exception) {
if (IsEnabledFor(level)) {
ForcedLog(declaringType, level, message, exception);
}
}
/// <summary>
/// Creates a new logging event and logs the event without further checks.
/// </summary>
/// <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
/// the stack boundary into the logging system for this call.</param>
/// <param name="level">The level of the message to be logged.</param>
/// <param name="message">The message object to log.</param>
/// <param name="exception">The exception to log, including its stack trace.</param>
/// <remarks>
/// <para>
/// Generates a logging event and delivers it to the attached
/// appenders.
/// </para>
/// </remarks>
virtual protected void ForcedLog(Type callerStackBoundaryDeclaringType, Level level, object message, Exception exception) {
CallAppenders(new LoggingEvent(callerStackBoundaryDeclaringType, this.Hierarchy, this.Name, level, message, exception));
}
/// <summary>
/// Checks if this logger is enabled for a given <see cref="Level"/> passed as parameter.
/// </summary>
/// <param name="level">The level to check.</param>
/// <returns>
/// <c>true</c> if this logger is enabled for <c>level</c>, otherwise <c>false</c>.
/// </returns>
/// <remarks>
/// <para>
/// Test if this logger is going to log events of the specified <paramref name="level"/>.
/// </para>
/// <para>
/// This method must not throw any exception to the caller.
/// </para>
/// </remarks>
virtual public bool IsEnabledFor(Level level) {
try {
if (level != null) {
if (m_hierarchy.IsDisabled(level)) {
return false;
}
return level >= this.EffectiveLevel;
}
} catch (Exception ex) {
GodLesZ.Library.Logging.Util.LogLog.Error(declaringType, "Exception while logging", ex);
}
#if !NET_2_0 && !MONO_2_0
catch
{
GodLesZ.Library.Logging.Util.LogLog.Error(declaringType, "Exception while logging");
}
#endif
return false;
}
/// <summary>
/// This generic form is intended to be used by wrappers.
/// </summary>
/// <param name="callerStackBoundaryDeclaringType">The declaring type of the method that is
/// the stack boundary into the logging system for this call.</param>
/// <param name="level">The level of the message to be logged.</param>
/// <param name="message">The message object to log.</param>
/// <param name="exception">The exception to log, including its stack trace.</param>
/// <remarks>
/// <para>
/// Generate a logging event for the specified <paramref name="level"/> using
/// the <paramref name="message"/> and <paramref name="exception"/>.
/// </para>
/// <para>
/// This method must not throw any exception to the caller.
/// </para>
/// </remarks>
virtual public void Log(Type callerStackBoundaryDeclaringType, Level level, object message, Exception exception) {
try {
if (IsEnabledFor(level)) {
ForcedLog((callerStackBoundaryDeclaringType != null) ? callerStackBoundaryDeclaringType : declaringType, level, message, exception);
}
} catch (Exception ex) {
GodLesZ.Library.Logging.Util.LogLog.Error(declaringType, "Exception while logging", ex);
}
#if !NET_2_0 && !MONO_2_0
catch
{
GodLesZ.Library.Logging.Util.LogLog.Error(declaringType, "Exception while logging");
}
#endif
}
/// <summary>
/// Initialize options
/// </summary>
/// <remarks>
/// <para>
/// Caches the sorted list of <see cref="LevelMappingEntry"/> in an array
/// </para>
/// </remarks>
public void ActivateOptions() {
Level[] sortKeys = new Level[m_entriesMap.Count];
LevelMappingEntry[] sortValues = new LevelMappingEntry[m_entriesMap.Count];
m_entriesMap.Keys.CopyTo(sortKeys, 0);
m_entriesMap.Values.CopyTo(sortValues, 0);
// Sort in level order
Array.Sort(sortKeys, sortValues, 0, sortKeys.Length, null);
// Reverse list so that highest level is first
Array.Reverse(sortValues, 0, sortValues.Length);
foreach (LevelMappingEntry entry in sortValues) {
entry.ActivateOptions();
}
m_entries = sortValues;
}
/// <summary>
/// Removes the first occurrence of a specific <see cref="Level"/> from the <c>LevelCollection</c>.
/// </summary>
/// <param name="item">The <see cref="Level"/> to remove from the <c>LevelCollection</c>.</param>
/// <exception cref="ArgumentException">
/// The specified <see cref="Level"/> was not found in the <c>LevelCollection</c>.
/// </exception>
public virtual void Remove(Level item) {
int i = IndexOf(item);
if (i < 0) {
throw new System.ArgumentException("Cannot remove the specified item because it was not found in the specified Collection.");
}
++m_version;
RemoveAt(i);
}
/// <summary>
/// Initializes a new instance of the <c>LevelCollection</c> class
/// that contains elements copied from the specified <see cref="Level"/> array.
/// </summary>
/// <param name="a">The <see cref="Level"/> array whose elements are copied to the new list.</param>
public LevelCollection(Level[] a) {
m_array = new Level[a.Length];
AddRange(a);
}
/// <summary>
/// Removes the element at the specified index of the <c>LevelCollection</c>.
/// </summary>
/// <param name="index">The zero-based index of the element to remove.</param>
/// <exception cref="ArgumentOutOfRangeException">
/// <para><paramref name="index"/> is less than zero</para>
/// <para>-or-</para>
/// <para><paramref name="index"/> is equal to or greater than <see cref="LevelCollection.Count"/>.</para>
/// </exception>
public virtual void RemoveAt(int index) {
ValidateIndex(index); // throws
m_count--;
if (index < m_count) {
Array.Copy(m_array, index + 1, m_array, index, m_count - index);
}
// We can't set the deleted entry equal to null, because it might be a value type.
// Instead, we'll create an empty single-element array of the right type and copy it
// over the entry we want to erase.
Level[] temp = new Level[1];
Array.Copy(temp, 0, m_array, m_count, 1);
m_version++;
}
/// <summary>
/// Copies the entire <c>LevelCollection</c> to a one-dimensional
/// <see cref="Level"/> array.
/// </summary>
/// <param name="array">The one-dimensional <see cref="Level"/> array to copy to.</param>
public virtual void CopyTo(Level[] array) {
this.CopyTo(array, 0);
}
public override void CopyTo(Level[] array) {
m_collection.CopyTo(array);
}
/// <summary>
/// Copies the entire <c>LevelCollection</c> to a one-dimensional
/// <see cref="Level"/> array, starting at the specified index of the target array.
/// </summary>
/// <param name="array">The one-dimensional <see cref="Level"/> array to copy to.</param>
/// <param name="start">The zero-based index in <paramref name="array"/> at which copying begins.</param>
public virtual void CopyTo(Level[] array, int start) {
if (m_count > array.GetUpperBound(0) + 1 - start) {
throw new System.ArgumentException("Destination array was not long enough.");
}
Array.Copy(m_array, 0, array, start, m_count);
}
public override bool Contains(Level x) {
return m_collection.Contains(x);
}
/// <summary>
/// Adds a <see cref="Level"/> to the end of the <c>LevelCollection</c>.
/// </summary>
/// <param name="item">The <see cref="Level"/> to be added to the end of the <c>LevelCollection</c>.</param>
/// <returns>The index at which the value has been added.</returns>
public virtual int Add(Level item) {
if (m_count == m_array.Length) {
EnsureCapacity(m_count + 1);
}
m_array[m_count] = item;
m_version++;
return m_count++;
}
public override void Remove(Level x) {
throw new NotSupportedException("This is a Read Only Collection and can not be modified");
}
/// <summary>
/// Checks if the message level is below this appender's threshold.
/// </summary>
/// <param name="level"><see cref="Level"/> to test against.</param>
/// <remarks>
/// <para>
/// If there is no threshold set, then the return value is always <c>true</c>.
/// </para>
/// </remarks>
/// <returns>
/// <c>true</c> if the <paramref name="level"/> meets the <see cref="Threshold"/>
/// requirements of this appender.
/// </returns>
virtual protected bool IsAsSevereAsThreshold(Level level) {
return ((m_threshold == null) || level >= m_threshold);
}
/// <summary>
/// Add a Level to the map
/// </summary>
/// <param name="level">the Level to add</param>
/// <remarks>
/// <para>
/// Add a Level to the map
/// </para>
/// </remarks>
public void Add(Level level) {
if (level == null) {
throw new ArgumentNullException("level");
}
lock (this) {
m_mapName2Level[level.Name] = level;
}
}
/// <summary>
/// Returns the zero-based index of the first occurrence of a <see cref="Level"/>
/// in the <c>LevelCollection</c>.
/// </summary>
/// <param name="item">The <see cref="Level"/> to locate in the <c>LevelCollection</c>.</param>
/// <returns>
/// The zero-based index of the first occurrence of <paramref name="item"/>
/// in the entire <c>LevelCollection</c>, if found; otherwise, -1.
/// </returns>
public virtual int IndexOf(Level item) {
for (int i = 0; i != m_count; ++i) {
if (m_array[i].Equals(item)) {
return i;
}
}
return -1;
}
/// <summary>
/// Determines whether a given <see cref="Level"/> is in the <c>LevelCollection</c>.
/// </summary>
/// <param name="item">The <see cref="Level"/> to check for.</param>
/// <returns><c>true</c> if <paramref name="item"/> is found in the <c>LevelCollection</c>; otherwise, <c>false</c>.</returns>
public virtual bool Contains(Level item) {
for (int i = 0; i != m_count; ++i) {
if (m_array[i].Equals(item)) {
return true;
}
}
return false;
}
/// <summary>
/// Get the equivalent <see cref="EventLogEntryType"/> for a <see cref="Level"/> <paramref name="level"/>
/// </summary>
/// <param name="level">the Level to convert to an EventLogEntryType</param>
/// <returns>The equivalent <see cref="EventLogEntryType"/> for a <see cref="Level"/> <paramref name="level"/></returns>
/// <remarks>
/// Because there are fewer applicable <see cref="EventLogEntryType"/>
/// values to use in logging levels than there are in the
/// <see cref="Level"/> this is a one way mapping. There is
/// a loss of information during the conversion.
/// </remarks>
virtual protected EventLogEntryType GetEntryType(Level level) {
// see if there is a specified lookup.
Level2EventLogEntryType entryType = m_levelMapping.Lookup(level) as Level2EventLogEntryType;
if (entryType != null) {
return entryType.EventLogEntryType;
}
// Use default behavior
if (level >= Level.Error) {
return EventLogEntryType.Error;
} else if (level == Level.Warn) {
return EventLogEntryType.Warning;
}
// Default setting
return EventLogEntryType.Information;
}