We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Diagnostics \ Log

SSCLI

// ==++==
//
//
//
// The use and distribution terms for this software are contained in the file
// named license.txt, which can be found in the root of this distribution.
// By using this software in any fashion, you are agreeing to be bound by the
// terms of this license.
//
// You must not remove this notice, or any other, from this software.
//
//
// ==--==
namespace System.Diagnostics
{
using System.Runtime.Remoting;
using System;
using System.Security.Permissions;
using System.IO;
using System.Collections;
using System.Runtime.CompilerServices;
using Encoding = System.Text.Encoding;
using System.Runtime.Versioning;
// LogMessageEventHandlers are triggered when a message is generated which is
// "on" per its switch.
//
// By default, the debugger (if attached) is the only event handler.
// There is also a "built-in" console device which can be enabled
// programatically, by registry (specifics....) or environment
// variables.
[Serializable()]
[HostProtection(Synchronization = true, ExternalThreading = true)]
internal delegate void LogMessageEventHandler(LoggingLevels level, LogSwitch category, string message, StackTrace location);
// LogSwitchLevelHandlers are triggered when the level of a LogSwitch is modified
// NOTE: These are NOT triggered when the log switch setting is changed from the
// attached debugger.
//
[Serializable()]
internal delegate void LogSwitchLevelHandler(LogSwitch ls, LoggingLevels newLevel);
static internal class Log
{
// Switches allow relatively fine level control of which messages are
// actually shown. Normally most debugging messages are not shown - the
// user will typically enable those which are relevant to what is being
// investigated.
//
// An attached debugger can enable or disable which messages will
// actually be reported to the user through the COM+ debugger
// services API. This info is communicated to the runtime so only
// desired events are actually reported to the debugger.
static internal Hashtable m_Hashtable;
private static bool m_fConsoleDeviceEnabled;
private static Stream[] m_rgStream;
private static int m_iNumOfStreamDevices;
private static int m_iStreamArraySize;
//private static StreamWriter pConsole;
static internal int iNumOfSwitches;
//private static int iNumOfMsgHandlers;
//private static int iMsgHandlerArraySize;
private static LogMessageEventHandler _LogMessageEventHandler;
private static LogSwitchLevelHandler _LogSwitchLevelHandler;
private static object locker;
// Constant representing the global switch
public static readonly LogSwitch GlobalSwitch;
static Log()
{
m_Hashtable = new Hashtable();
m_fConsoleDeviceEnabled = false;
m_rgStream = null;
m_iNumOfStreamDevices = 0;
m_iStreamArraySize = 0;
//pConsole = null;
//iNumOfMsgHandlers = 0;
//iMsgHandlerArraySize = 0;
locker = new object();
// allocate the GlobalSwitch object
GlobalSwitch = new LogSwitch("Global", "Global Switch for this log");
GlobalSwitch.MinimumLevel = LoggingLevels.ErrorLevel;
}
public static void AddOnLogMessage(LogMessageEventHandler handler)
{
lock (locker)
_LogMessageEventHandler = (LogMessageEventHandler)MulticastDelegate.Combine(_LogMessageEventHandler, handler);
}
public static void RemoveOnLogMessage(LogMessageEventHandler handler)
{
lock (locker)
_LogMessageEventHandler = (LogMessageEventHandler)MulticastDelegate.Remove(_LogMessageEventHandler, handler);
}
public static void AddOnLogSwitchLevel(LogSwitchLevelHandler handler)
{
lock (locker)
_LogSwitchLevelHandler = (LogSwitchLevelHandler)MulticastDelegate.Combine(_LogSwitchLevelHandler, handler);
}
public static void RemoveOnLogSwitchLevel(LogSwitchLevelHandler handler)
{
lock (locker)
_LogSwitchLevelHandler = (LogSwitchLevelHandler)MulticastDelegate.Remove(_LogSwitchLevelHandler, handler);
}
static internal void InvokeLogSwitchLevelHandlers(LogSwitch ls, LoggingLevels newLevel)
{
LogSwitchLevelHandler handler = _LogSwitchLevelHandler;
if (handler != null)
handler(ls, newLevel);
}
// Property to Enable/Disable ConsoleDevice. Enabling the console device
// adds the console device as a log output, causing any
// log messages which make it through filters to be written to the
// application console. The console device is enabled by default if the
// ??? registry entry or ??? environment variable is set.
public static bool IsConsoleEnabled {
get { return m_fConsoleDeviceEnabled; }
set { m_fConsoleDeviceEnabled = value; }
}
// AddStream uses the given stream to create and add a new log
// device. Any log messages which make it through filters will be written
// to the stream.
//
public static void AddStream(Stream stream)
{
if (stream == null)
throw new ArgumentNullException("stream");
if (m_iStreamArraySize <= m_iNumOfStreamDevices) {
// increase array size in chunks of 4
Stream[] newArray = new Stream[m_iStreamArraySize + 4];
// copy the old array objects into the new one.
if (m_iNumOfStreamDevices > 0)
Array.Copy(m_rgStream, newArray, m_iNumOfStreamDevices);
m_iStreamArraySize += 4;
m_rgStream = newArray;
}
m_rgStream[m_iNumOfStreamDevices++] = stream;
}
// Generates a log message. If its switch (or a parent switch) allows the
// level for the message, it is "broadcast" to all of the log
// devices.
//
public static void LogMessage(LoggingLevels level, string message)
{
LogMessage(level, GlobalSwitch, message);
}
// Generates a log message. If its switch (or a parent switch) allows the
// level for the message, it is "broadcast" to all of the log
// devices.
//
[ResourceExposure(ResourceScope.None)]
[ResourceConsumption(ResourceScope.Process, ResourceScope.Process)]
public static void LogMessage(LoggingLevels level, LogSwitch logswitch, string message)
{
if (logswitch == null)
throw new ArgumentNullException("LogSwitch");
if (level < 0)
throw new ArgumentOutOfRangeException("level", Environment.GetResourceString("ArgumentOutOfRange_NeedNonNegNum"));
// Is logging for this level for this switch enabled?
if (logswitch.CheckLevel(level) == true) {
// Send message for logging
// first send it to the debugger
Debugger.Log((int)level, logswitch.strName, message);
// Send to the console device
if (m_fConsoleDeviceEnabled) {
Console.Write(message);
}
// Send it to the streams
for (int i = 0; i < m_iNumOfStreamDevices; i++) {
StreamWriter sw = new StreamWriter(m_rgStream[i]);
sw.Write(message);
sw.Flush();
}
}
}
/*
* Following are convenience entry points; all go through Log()
* Note that the (Switch switch, String message) variations
* are preferred.
*/
public static void Trace(LogSwitch logswitch, string message)
{
LogMessage(LoggingLevels.TraceLevel0, logswitch, message);
}
public static void Trace(string switchname, string message)
{
LogSwitch ls;
ls = LogSwitch.GetSwitch(switchname);
LogMessage(LoggingLevels.TraceLevel0, ls, message);
}
public static void Trace(string message)
{
LogMessage(LoggingLevels.TraceLevel0, GlobalSwitch, message);
}
public static void Status(LogSwitch logswitch, string message)
{
LogMessage(LoggingLevels.StatusLevel0, logswitch, message);
}
public static void Status(string switchname, string message)
{
LogSwitch ls;
ls = LogSwitch.GetSwitch(switchname);
LogMessage(LoggingLevels.StatusLevel0, ls, message);
}
public static void Status(string message)
{
LogMessage(LoggingLevels.StatusLevel0, GlobalSwitch, message);
}
public static void Warning(LogSwitch logswitch, string message)
{
LogMessage(LoggingLevels.WarningLevel, logswitch, message);
}
public static void Warning(string switchname, string message)
{
LogSwitch ls;
ls = LogSwitch.GetSwitch(switchname);
LogMessage(LoggingLevels.WarningLevel, ls, message);
}
public static void Warning(string message)
{
LogMessage(LoggingLevels.WarningLevel, GlobalSwitch, message);
}
public static void Error(LogSwitch logswitch, string message)
{
LogMessage(LoggingLevels.ErrorLevel, logswitch, message);
}
public static void Error(string switchname, string message)
{
LogSwitch ls;
ls = LogSwitch.GetSwitch(switchname);
LogMessage(LoggingLevels.ErrorLevel, ls, message);
}
public static void Error(string message)
{
LogMessage(LoggingLevels.ErrorLevel, GlobalSwitch, message);
}
public static void Panic(string message)
{
LogMessage(LoggingLevels.PanicLevel, GlobalSwitch, message);
}
// Native method to inform the EE about the creation of a new LogSwitch
[MethodImplAttribute(MethodImplOptions.InternalCall)]
static internal extern void AddLogSwitch(LogSwitch logSwitch);
[MethodImplAttribute(MethodImplOptions.InternalCall)]
static internal extern void ModifyLogSwitch(int iNewLevel, string strSwitchName, string strParentName);
}
}