internal void LogMessage(string message, log4net.Core.Level level)
{
LogMessage logMessage = new LogMessage
{
LogLevel = level,
Message = message
};
LoggingEventData logdata = new LoggingEventData()
{
Message = message,
Level = level,
TimeStampUtc = DateTime.UtcNow
};
if (LoggerPaneViewModel.Instance != null)
{
LoggerPaneViewModel.Instance.AddMessage(logMessage);
}
if (_log != null)
{
LoggingEvent le = new LoggingEvent(logdata);
_log.Logger.Log(le);
}
}
/// <summary>
/// Helper method to convert <see cref="Level"/> into a string ID that is mapped based upon the TOPS Syslog standard: https://confluence.mw.inc/display/TO/TOps+Syslog+Standard
/// </summary>
/// <param name="level"><see cref="Level"/> to convert to string</param>
/// <returns>string representing the syslog priority code as defined in the TOPS Syslog standard</returns>
public static string ConvertLevelToPriority(Level level)
{
if (level >= Level.Emergency)
{
return "128";
}
else if (level >= Level.Fatal)
{
return "130";
}
else if (level >= Level.Error)
{
return "131";
}
else if (level >= Level.Warn)
{
return "132";
}
else if (level >= Level.Info)
{
return "134";
}
else
{
return "135"; // debug
}
}
public static void BindConsole(PatternLayout layout = null, Level level = null)
{
layout = layout ?? new PatternLayout
{
ConversionPattern = "%date{ISO8601} %level %logger - %message%newline"
};
layout.ActivateOptions();
var consoleAppender = new ConsoleAppender
{
Name = "console",
Layout = layout
};
consoleAppender.ActivateOptions();
var hierarchy = (Hierarchy)LogManager.GetRepository();
if (hierarchy.Root.GetAppender("console") != null)
{
return;
}
hierarchy.Root.AddAppender(consoleAppender);
hierarchy.Root.Level = level ?? Level.Info;
hierarchy.Configured = true;
}
public void InfoFormat(string format, IMessage message, MessageId messageId, int messageSize, IList<Peer> peers, Level logLevel = null)
{
if (peers.Count == 0)
{
InfoFormat(format, message, messageId, messageSize);
return;
}
if (peers.Count == 1)
{
InfoFormat(format, message, messageId, messageSize, peerId: peers[0].Id);
return;
}
var logInfo = GetLogInfo(message);
if (!logInfo.Logger.IsInfoEnabled)
return;
var messageText = logInfo.GetMessageText(message);
var otherPeersCount = peers.Count - 1;
var peerIdText = otherPeersCount > 1
? peers[0].Id + " and " + otherPeersCount + " other peers"
: peers[0].Id + " and " + otherPeersCount + " other peer";
_logger.Logger.Log(_loggerType, logLevel ?? Level.Info, string.Format(format, messageText, messageId, messageSize, peerIdText), null);
}
internal static LogLevel FromLog4Net( Level level )
{
if ( level == Level.Error )
{
return LogLevel.Error;
}
else if ( level == Level.Warn )
{
return LogLevel.Warning;
}
else if ( level == Level.Notice )
{
return LogLevel.Notice;
}
else if ( level == Level.Info )
{
return LogLevel.Info;
}
else if ( level == Level.Debug )
{
return LogLevel.Debug;
}
else
{
throw new NotSupportedException( "LogLevel not supported: " + level );
}
}
/// <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;
}
public void LogMsg(Level level, string message)
{
//Debug.WriteLine( String.Format( "{0} {1}", level.ToString(), message ) );
if (level == Level.Info)
{
_log.Info(message);
}
else if (level == Level.Debug)
{
_log.Debug(message);
}
else if (level == Level.Error)
{
_log.Error(message);
}
else if (level == Level.Warn)
{
_log.Warn(message);
}
else
{
_log.Info(message);
}
}
private log4net.Core.LoggingEvent CreateLogEntry(log4net.Core.Level level, string message, Exception ex, List <KeyValuePair <string, object> > customInfos)
{
customInfos.Add(new KeyValuePair <string, object>("session", _sessionId));
if (ex != null)
{
var e1 = SerializeException(ex, customInfos);
StringBuilder sb = new StringBuilder(5 * 1024);
e1.Serialize(sb);
customInfos.Add(new KeyValuePair <string, object>("Exception", GetBase64Text(sb)));
}
string m = !string.IsNullOrEmpty(message)
? message
: ex != null && ex.Message != null
? ex.Message
: string.Empty;
LoggingEvent result = Generate(level, m);
foreach (var item in customInfos)
{
if (!string.IsNullOrEmpty(item.Key))
{
result.Properties[item.Key] = item.Value;
}
}
return(result);
}
/// <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;
}
public LogControl()
{
InitializeComponent();
this.SuspendLayout();
var levels = new Level[] { Level.Debug, Level.Info, Level.Warn, Level.Error, Level.Fatal };
chkLevels = new List<CheckBox>(levels.Length);
foreach (var level in levels)
{
var chkLevel = new CheckBox();
chkLevel.Checked = level != Level.Debug;
chkLevel.Text = level.ToString();
chkLevel.Tag = level;
chkLevel.CheckedChanged += new EventHandler(chkLevel_CheckedChanged);
pnlFilter.Controls.Add(chkLevel);
chkLevels.Add(chkLevel);
}
btnClean = new Button();
btnClean.Margin = chkLevels.First().Margin;
btnClean.Text = "clean";
btnClean.Click += new EventHandler(btnClean_Click);
pnlFilter.Controls.Add(btnClean);
lblCount = new Label();
lblCount.Margin = chkLevels.First().Margin;
lblCount.Text = "0";
pnlFilter.Controls.Add(lblCount);
this.ResumeLayout(true);
}
public void Trace(log4net.Core.Level logLevel, bool bLogTime, string category, string sFormatTrace, params object[] args)
{
string msg = string.Format(sFormatTrace, args);
if (bLogTime)
{
category = DateTime.Now.ToString("hh:mm:ss") + " " + category;
}
if (logLevel == log4net.Core.Level.Debug)
{
m_Log.DebugFormat(msg, category);
}
else if (logLevel == log4net.Core.Level.Info)
{
m_Log.InfoFormat(msg, category);
}
else if (logLevel == log4net.Core.Level.Warn)
{
m_Log.WarnFormat(msg, category);
}
else if (logLevel == log4net.Core.Level.Error)
{
m_Log.ErrorFormat(msg, category);
}
else if (logLevel == log4net.Core.Level.Fatal)
{
m_Log.FatalFormat(msg, category);
}
}
public virtual long Map(Level log4NetLevel)
{
if (log4NetLevel == null) return (long)LocalSyslogAppender.SyslogSeverity.Debug;
var mappedValue = (long)LocalSyslogAppender.SyslogSeverity.Debug;
levelMappings.TryGetValue(log4NetLevel.Name, out mappedValue);
return mappedValue;
}
public static void WriteMessage(string message, Level level)
{
var stackTrace = new StackTrace(true);
var frame = stackTrace.GetFrame(1);
if (level == Level.Debug && Logger.IsDebugEnabled)
{
Logger.Debug(LoggerMessage.CreateMessage(message, frame));
}
if (level == Level.Error && Logger.IsErrorEnabled)
{
Logger.Error(LoggerMessage.CreateMessage(message, frame));
}
if (level == Level.Fatal && Logger.IsFatalEnabled)
{
Logger.Fatal(LoggerMessage.CreateMessage(message, frame));
}
if (level == Level.Warn && Logger.IsWarnEnabled)
{
Logger.Warn(LoggerMessage.CreateMessage(message, frame));
}
if (level == Level.Info && Logger.IsInfoEnabled)
{
Logger.Info(LoggerMessage.CreateMessage(message, frame));
}
}
/// <summary>
/// Configures the log4net environment
/// </summary>
private void Setup(Level logLevel)
{
Directory.CreateDirectory(_logFolder);
var hierarchy = (Hierarchy)LogManager.GetRepository();
// Log to a file
var roller = new RollingFileAppender();
roller.AppendToFile = false;
roller.File = _logFile;
roller.Layout = new PatternLayout("%date %type.%method [%-5level] - %message%newline");
roller.MaxSizeRollBackups = 5;
roller.RollingStyle = RollingFileAppender.RollingMode.Size;
roller.StaticLogFileName = true;
roller.ActivateOptions();
hierarchy.Root.AddAppender(roller);
// Log to the visual studio console
var appender = new TraceAppender();
appender.ActivateOptions();
appender.Layout = new PatternLayout("%method (%line) %date [%-5level] - %message%newline");
hierarchy.Root.AddAppender(appender);
hierarchy.Root.Level = logLevel;
hierarchy.Configured = true;
}
static int GetIndexForLevel(Level level)
{
if (level == Level.Info) return 2;
if (level == Level.Warn) return 3;
if (level == Level.Error || level == Level.Fatal) return 4;
return 1;
}
public static Infrastructure.Logging.Level ToLoggingLevel(Level level)
{
var loggingLevel = Infrastructure.Logging.Level.Debug;
if (level == log4net.Core.Level.All)
{
loggingLevel = Infrastructure.Logging.Level.All;
}
else if (level == log4net.Core.Level.Debug)
{
loggingLevel = Infrastructure.Logging.Level.Debug;
}
else if (level == log4net.Core.Level.Info)
{
loggingLevel = Infrastructure.Logging.Level.Info;
}
else if (level == log4net.Core.Level.Warn)
{
loggingLevel = Infrastructure.Logging.Level.Warn;
}
else if (level == log4net.Core.Level.Error)
{
loggingLevel = Infrastructure.Logging.Level.Error;
}
else if (level == log4net.Core.Level.Fatal)
{
loggingLevel = Infrastructure.Logging.Level.Fatal;
}
return(loggingLevel);
}
private static void Log(string message, Level logLevel, string exceptionMessage, params object[] parameters)
{
if (WriteAsync)
{
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += LogEvent;
worker.RunWorkerAsync(new LogMessageSpec
{
ExceptionMessage = exceptionMessage,
LogLevel = logLevel,
Message = message,
Parameters = parameters,
Stack = new StackTrace(),
LogTime = DateTime.Now
});
}
else
{
PerformLog(new LogMessageSpec
{
ExceptionMessage = exceptionMessage,
LogLevel = logLevel,
Message = message,
Parameters = parameters,
Stack = new StackTrace(),
LogTime = DateTime.Now
});
}
}
private void PerformLog(Type type, Level level, Func<string> messageDelegate, Exception ex)
{
ThreadContext.Properties["subscriber"] = _subscriber.Email;
ThreadContext.Properties["subscriberId"] = _subscriber.Id;
_log.Logger.Log(type, level, messageDelegate.Invoke(), ex);
}
private static void ConfigureColoredConsoleAppender(Level threshold)
{
var appender = new ColoredConsoleAppender
{
Threshold = threshold
};
appender.AddMapping(
new ColoredConsoleAppender.LevelColors
{
Level = Level.Debug,
ForeColor = ColoredConsoleAppender.Colors.White
});
appender.AddMapping(
new ColoredConsoleAppender.LevelColors
{
Level = Level.Info,
ForeColor = ColoredConsoleAppender.Colors.Green
});
appender.AddMapping(
new ColoredConsoleAppender.LevelColors
{
Level = Level.Warn,
ForeColor = ColoredConsoleAppender.Colors.Yellow | ColoredConsoleAppender.Colors.HighIntensity
});
appender.AddMapping(
new ColoredConsoleAppender.LevelColors
{
Level = Level.Error,
ForeColor = ColoredConsoleAppender.Colors.Red | ColoredConsoleAppender.Colors.HighIntensity
});
ConfigureAppender(appender);
}
//ALL 6
//DEBUG 1
//INFO 2
//WARN 3
//ERROR 4
//FATAL 5
//OFF 0
// > level的日志会显示出来
public static void SetLevel(int level)
{
log4net.Core.Level logLevel = log4net.Core.Level.All;
if (level == 0)
{
logLevel = log4net.Core.Level.Off;
}
else if (level == 1)
{
logLevel = log4net.Core.Level.Debug;
}
else if (level == 2)
{
logLevel = log4net.Core.Level.Info;
}
else if (level == 3)
{
logLevel = log4net.Core.Level.Warn;
}
else if (level == 4)
{
logLevel = log4net.Core.Level.Error;
}
else if (level == 5)
{
logLevel = log4net.Core.Level.Fatal;
}
else if (level == 6)
{
logLevel = log4net.Core.Level.All;
}
((log4net.Repository.Hierarchy.Hierarchy)LogManager.GetRepository(guidStr)).Root.Level = logLevel;
}
public LoggerConfiguration(string appDataFolder, Level logLevel)
{
_logFolder = appDataFolder + "\\Logs";
_logFile = _logFolder + "\\events.log";
Setup(logLevel);
}
public virtual void Log(log4net.Core.Level level, object message, Exception exception)
{
if (this.IsEnabledFor(level))
{
this.ForcedLog(declaringType, level, message, exception);
}
}
public TextWriterToLog4Net(string loggerName, Level defaultLevel)
: base()
{
this.LoggerName = loggerName;
this.DefaultLevel = defaultLevel;
this.TrimHeaders = true;
}
private LoggingEvent Generate(log4net.Core.Level level, string m)
{
StackFrame stackFrame = null;
System.Reflection.MethodBase method = null;
var stackFrames = new StackTrace().GetFrames();
for (int indexFrame = 0; indexFrame < stackFrames.Length; ++indexFrame)
{
stackFrame = stackFrames[indexFrame];
method = stackFrame.GetMethod();
if (method.DeclaringType != typeof(Log4NetTraceListener) && method.Name != "TraceInternals")
{
break;
}
}
var result = new log4net.Core.LoggingEvent(method.ReflectedType, _repository, new LoggingEventData()
{
Level = level,
Message = m,
LoggerName = base.Name,
LocationInfo = new LocationInfo(GetMethodName(method),
method.ToString(),
stackFrame.GetFileName(),
stackFrame.GetFileLineNumber().ToString())
}, FixFlags.All);
return(result);
}
public static void SetThresholdForAppender(string appenderName, Level threshold)
{
var appender = (AppenderSkeleton) GetAppender(appenderName);
appender.Threshold = threshold;
appender.ActivateOptions();
return;
}
private void SetUpLog(Level level)
{
_memoryAppender = new MemoryAppender();
Logger root = ((Hierarchy) LogManager.GetRepository()).Root;
root.Level = level;
root.AddAppender(_memoryAppender);
root.Repository.Configured = true;
}
public MethodLogger(string text, string methodName, ILog logger, Level logLevel)
{
_text = text;
_methodName = methodName;
_logger = logger;
_logLevel = logLevel;
_logger.Logger.Log(typeof (MethodLogger), _logLevel, $"Entered method {_methodName}: {_text}", null);
_stopWatch = Stopwatch.StartNew();
}
public TableStorageAppender(Level minLevel)
{
m_minLevel = minLevel;
var connectionString = ConfigurationManager.AppSettings["AzureConnectionString"];
var account = CloudStorageAccount.Parse(connectionString);
var tableClient = account.CreateCloudTableClient();
m_table = tableClient.GetTableReference(m_tableName);
m_table.CreateIfNotExists();
}
/// <summary>
/// Creates a <see cref="CheckBox"/> for a <see cref="Level"/>.
/// </summary>
/// <param name="level">The level.</param>
/// <param name="index">The display index.</param>
/// <returns>The created <see cref="CheckBox"/>.</returns>
CheckBox CreateLogLevelCheckBox(Level level, int index)
{
var ret = new CheckBox(_cSettingsPanel, new Vector2(_cSettingsPanel.Size.X - 100, 5))
{ Font = _consoleFont, Text = level.Name, Tag = level, ForeColor = level.GetColor(), Value = true };
ret.Position += new Vector2(0, ret.Size.Y * index);
ret.ValueChanged += LevelCheckBox_ValueChanged;
return ret;
}
private void ReloadLevels(ILoggerRepository repository)
{
LevelMap levelMap = repository.LevelMap;
m_levelDebug = levelMap.LookupWithDefault(Level.Debug);
m_levelInfo = levelMap.LookupWithDefault(Level.Info);
m_levelWarn = levelMap.LookupWithDefault(Level.Warn);
m_levelError = levelMap.LookupWithDefault(Level.Error);
m_levelFatal = levelMap.LookupWithDefault(Level.Fatal);
}
public LogSpy(string loggerName)
{
logger = (Logger)LogManager.GetLogger(loggerName).Logger;
if (logger == null)
throw new NullReferenceException();
prevLogLevel = logger.Level;
logger.Level = Level.Debug;
appender = new MemoryAppender();
logger.AddAppender(appender);
}
public ApiClient(string apiBaseUrl, string apiToken, string version = "2", Level logLevel = null, string logPath = ".")
{
ApiBaseUrl = apiBaseUrl;
ApiToken = apiToken;
Version = version;
LogLevel = logLevel ?? LOG_INFO;
LogPath = logPath;
Setup();
}
private int GetSyslogSeverity(log4net.Core.Level level)
{
if (level == log4net.Core.Level.Alert)
{
return((int)LocalSyslogAppender.SyslogSeverity.Alert);
}
if (level == log4net.Core.Level.Critical || level == log4net.Core.Level.Fatal)
{
return((int)LocalSyslogAppender.SyslogSeverity.Critical);
}
if (level == log4net.Core.Level.Debug)
{
return((int)LocalSyslogAppender.SyslogSeverity.Debug);
}
if (level == log4net.Core.Level.Emergency)
{
return((int)LocalSyslogAppender.SyslogSeverity.Emergency);
}
if (level == log4net.Core.Level.Error)
{
return((int)LocalSyslogAppender.SyslogSeverity.Error);
}
if (level == log4net.Core.Level.Fine ||
level == log4net.Core.Level.Finer ||
level == log4net.Core.Level.Finest ||
level == log4net.Core.Level.Info ||
level == log4net.Core.Level.Off)
{
return((int)LocalSyslogAppender.SyslogSeverity.Informational);
}
if (level == log4net.Core.Level.Notice ||
level == log4net.Core.Level.Verbose ||
level == log4net.Core.Level.Trace)
{
return((int)LocalSyslogAppender.SyslogSeverity.Notice);
}
if (level == log4net.Core.Level.Severe)
{
return((int)LocalSyslogAppender.SyslogSeverity.Emergency);
}
if (level == log4net.Core.Level.Warn)
{
return((int)LocalSyslogAppender.SyslogSeverity.Warning);
}
return((int)LocalSyslogAppender.SyslogSeverity.Debug);
}
public void Response_should_default_to_DEBUG_with_unsupported_log_level(Level level)
{
var id = Guid.Parse("cca0662a-b6fb-4b26-b6dd-97ba1e7d32c2");
using (var processor = SlaProcessorBuilder.For(_provider).WithLoggingConfiguration(new LoggingConfiguration(Level.Off, level)).Build())
{
processor.ProcessOutgoingMessage(new Request { Id = id });
processor.ProcessIncomingMessage(new Response { Id = id });
AssertLogEntry(Level.Debug, "SLA=Wonga.SLAMonitor.Tests.Asynchronous.SlaProcessorIntegrationTests\\+Request Response=Wonga.SLAMonitor.Tests.Asynchronous.SlaProcessorIntegrationTests\\+Response ResponseTime=[0-9]+ milliseconds CorrelationId=cca0662a-b6fb-4b26-b6dd-97ba1e7d32c2");
}
}
/// <summary>
/// Log a message at either of these levels
/// </summary>
/// <param name="log"></param>
/// <param name="message"></param>
/// <param name="level">The level to log the message at</param>
public static void ErrorOrFail(this ILog log, String message, log4net.Core.Level level)
{
if (level == Program.MyFailLevel)
{
log.Fail(message);
}
else
{
log.Error(message);
}
}
/// <summary>
/// Returns a configured AdoNetAppender.
/// </summary>
/// <param name="connectionString">SqlConnectionString for the logging database.</param>
/// <param name="tableName">Table to save logs to.</param>
/// <param name="level">The level to log at.</param>
/// <returns>A configured AdoNetAppender.</returns>
public static AdoNetAppender GetSqlLogAppender(string connectionString, string tableName, Level level)
{
var appender = new AdoNetAppender
{
BufferSize = 1,
ConnectionType = typeof(SqlConnection).AssemblyQualifiedName,
ConnectionString = connectionString,
CommandText = "INSERT INTO " + tableName + " (Date, Level, Logger, Message, Exception) VALUES (@date, @level, @logger, @message, @exception)",
Threshold = level
};
appender.AddParameter(new AdoNetAppenderParameter
{
ParameterName = "@date",
DbType = DbType.DateTime,
Layout = new RawTimeStampLayout()
});
appender.AddParameter(new AdoNetAppenderParameter
{
ParameterName = "@level",
DbType = DbType.String,
Size = -1,
Layout = new Layout2RawLayoutAdapter(new PatternLayout("%level"))
});
appender.AddParameter(new AdoNetAppenderParameter
{
ParameterName = "@logger",
DbType = DbType.String,
Size = -1,
Layout = new Layout2RawLayoutAdapter(new PatternLayout("%logger"))
});
appender.AddParameter(new AdoNetAppenderParameter
{
ParameterName = "@message",
DbType = DbType.String,
Size = -1,
Layout = new Layout2RawLayoutAdapter(new PatternLayout("%message"))
});
appender.AddParameter(new AdoNetAppenderParameter
{
ParameterName = "@exception",
DbType = DbType.String,
Size = -1,
Layout = new Layout2RawLayoutAdapter(new PatternLayout("%exception"))
});
appender.ActivateOptions();
return appender;
}
private AutomaticStopwatch(ILog logger, string name, Level logLevel)
{
_name = name;
_logLevel = logLevel;
_logger = logger;
if (_name != string.Empty)
_logger.Logger.Log (typeof (AutomaticStopwatch), _logLevel, string.Format ("Starting '{0}'", _name), null);
_stopwatch = Stopwatch.StartNew();
}
public void Response_violating_sla_should_have_configurable_log_level(Level level)
{
var id = Guid.Parse("cca0662a-b6fb-4b26-b6dd-97ba1e7d32c2");
using (var processor = SlaProcessorBuilder.For(_provider).WithLoggingConfiguration(new LoggingConfiguration(level, Level.Off)).Build())
{
processor.ProcessOutgoingMessage(new Request { Id = id });
Thread.Sleep(_violatedSla);
processor.ProcessIncomingMessage(new Response { Id = id });
AssertLogEntry(level, "SLA=Wonga.SLAMonitor.Tests.Asynchronous.SlaProcessorIntegrationTests\\+Request Response=Wonga.SLAMonitor.Tests.Asynchronous.SlaProcessorIntegrationTests\\+Response ResponseTime=[0-9]+ milliseconds CorrelationId=cca0662a-b6fb-4b26-b6dd-97ba1e7d32c2");
}
}
/// <summary>
/// Converts a log4net flavor trace level (<see cref="E:log4net.Core.Level"/>)
/// into a Sopra like level (<see cref="Siti.Logging.LogLevel"/>).
/// </summary>
/// <param name="level">The log4net level to convert.</param>
/// <returns>Sopra converted trace level.</returns>
public static LogLevel Log4NetLevelToLogLevel(Level level)
{
if (level == Level.All) return LogLevel.All;
if (level == Level.Verbose) return LogLevel.Verbose;
if (level == Level.Debug) return LogLevel.Debug;
if (level == Level.Info) return LogLevel.Info;
if (level == Level.Warn) return LogLevel.Warning;
if (level == Level.Error) return LogLevel.Error;
if (level == Level.Fatal) return LogLevel.Fatal;
if (level == Level.Off) return LogLevel.Off;
return LogLevel.All;
}
public virtual void Log(Type callerStackBoundaryDeclaringType, log4net.Core.Level level, object message, Exception exception)
{
try
{
if (this.IsEnabledFor(level))
{
this.ForcedLog((callerStackBoundaryDeclaringType == null) ? declaringType : callerStackBoundaryDeclaringType, level, message, exception);
}
}
catch (Exception exception2)
{
LogLog.Error(declaringType, "Exception while logging", exception2);
}
}
protected override void Append(LoggingEvent loggingEvent)
{
if (Log4NetToUnityTo)
{
log4net.Core.Level level = loggingEvent.Level;
if (log4net.Core.Level.Fatal.Equals(level) || log4net.Core.Level.Error.Equals(level))
{
Debug.LogError(RenderLoggingEvent(loggingEvent));
}
else if (log4net.Core.Level.Warn.Equals(level))
{
Debug.LogWarning(RenderLoggingEvent(loggingEvent));
}
}
}
public virtual bool IsEnabledFor(log4net.Core.Level level)
{
try
{
if (level != null)
{
return(!this.m_hierarchy.IsDisabled(level) ? (level >= this.EffectiveLevel) : false);
}
}
catch (Exception exception)
{
LogLog.Error(declaringType, "Exception while logging", exception);
}
return(false);
}
public TraceLogger(string logName, string logPrefix, log4net.Core.Level logLevel)
{
string LOG_PATTERN = "%-5level %date{HH:mm:ss} - %message%newline";
string fileName = string.Format(@"./Logs/{0}.txt", logPrefix);
Hierarchy hierarchy = (Hierarchy)LogManager.GetRepository();
hierarchy.Name = logName;
PatternLayout patternLayout = new PatternLayout();
patternLayout.ConversionPattern = LOG_PATTERN;
patternLayout.ActivateOptions();
ConsoleAppender consoleAppender = new ConsoleAppender();
consoleAppender.Layout = patternLayout;
consoleAppender.ActivateOptions();
RollingFileAppender rollingFileAppender = new RollingFileAppender();
rollingFileAppender.Layout = patternLayout;
rollingFileAppender.AppendToFile = true;
rollingFileAppender.RollingStyle = RollingFileAppender.RollingMode.Date;
rollingFileAppender.DatePattern = "(yyyy-MM-dd)";
rollingFileAppender.PreserveLogFileNameExtension = true;
rollingFileAppender.File = fileName;
rollingFileAppender.StaticLogFileName = false;
rollingFileAppender.ActivateOptions();
// OFF > FATAL > ERROR > WARN > INFO > DEBUG > ALL
hierarchy.Root.AddAppender(consoleAppender);
hierarchy.Root.AddAppender(rollingFileAppender);
hierarchy.Root.Level = logLevel;
hierarchy.Configured = true;
m_Log = LogManager.GetLogger(logName);
}
public void LevelSelected(object e, EventArgs a)
{
MenuItem item = e as MenuItem;
if (item == null)
{
return;
}
foreach (FieldInfo field in (typeof(log4net.Core.Level)).GetFields())
{
if (field.DeclaringType == typeof(log4net.Core.Level) && String.Compare(field.Name, item.Text, true) == 0)
{
levelMenuItem.Checked = false;
levelMenuItem = item;
levelMenuItem.Checked = true;
Threshold = (log4net.Core.Level)field.GetValue(Threshold);
}
}
return;
}
protected virtual void ForcedLog(Type callerStackBoundaryDeclaringType, log4net.Core.Level level, object message, Exception exception)
{
this.CallAppenders(new LoggingEvent(callerStackBoundaryDeclaringType, this.Hierarchy, this.Name, level, message, exception));
}
public void Log(log4net.Core.Level level, string message)
{
}
public void TraceNoTime(log4net.Core.Level logLevel, string sFormatTrace, params object[] args)
{
Trace(logLevel, false, "", sFormatTrace, args);
}
public void SetLevel(Level level)
{
this.mylevel = getLevel(level);
append.Threshold = mylevel;
}
public LoggingEvent(Type a, ILoggerRepository b, string c, Level d, object e, Exception f)
{
}
public static bool WriteLog(object message, Exception ex = null, Level level = Level.Info)
{
if (!LogOn)
{
return(false);
}
log4net.Core.Level lev = log4net.Core.Level.All;
switch (level)
{
case Level.Debug:
lev = log4net.Core.Level.Debug;
break;
case Level.Error:
lev = log4net.Core.Level.Error;
break;
case Level.Fatal:
lev = log4net.Core.Level.Fatal;
break;
case Level.Info:
lev = log4net.Core.Level.Info;
break;
case Level.Warn:
lev = log4net.Core.Level.Warn;
break;
}
lock (logLock)
{
try
{
if (message == null || string.IsNullOrWhiteSpace(message.ToString()))
{
return(false); //不写空日志
}
if (logger == null)
{
PatternLayout patternLayout = new PatternLayout();
patternLayout.ConversionPattern = LOG_PATTERN;
patternLayout.ActivateOptions();
TraceAppender tracer = new TraceAppender();
tracer.Layout = patternLayout;
tracer.ActivateOptions();
RollingFileAppender roller = new RollingFileAppender();
roller.Layout = patternLayout;
roller.AppendToFile = true;
roller.File = "Log/";
roller.StaticLogFileName = false;
roller.DatePattern = "yyyyMMdd.LOG";
roller.RollingStyle = RollingFileAppender.RollingMode.Date;
roller.MaximumFileSize = "10MB";
roller.MaxSizeRollBackups = 10;
roller.ImmediateFlush = true;
roller.Encoding = Encoding.UTF8;
roller.LockingModel = new FileAppender.MinimalLock();
roller.ActivateOptions();
Hierarchy hierarchy = (Hierarchy)LogManager.GetRepository();
hierarchy.Name = "log";
hierarchy.Root.AddAppender(tracer);
hierarchy.Root.AddAppender(roller);
hierarchy.Root.Level = lev;
hierarchy.Configured = true;
logger = LogManager.GetLogger("log");
}
if (ex == null)
{
switch (level)
{
case Level.Debug:
logger.Debug(message);
break;
case Level.Error:
logger.Error(message);
break;
case Level.Fatal:
logger.Fatal(message);
break;
case Level.Info:
logger.Info(message);
break;
case Level.Warn:
logger.Warn(message);
break;
}
}
else
{
switch (level)
{
case Level.Debug:
logger.Debug(message, ex);
break;
case Level.Error:
logger.Error(message, ex);
break;
case Level.Fatal:
logger.Fatal(message, ex);
break;
case Level.Info:
logger.Info(message, ex);
break;
case Level.Warn:
logger.Warn(message, ex);
break;
}
}
return(true);
}
catch (Exception)
{
return(false);
}
}
}
public RootLogger(log4net.Core.Level level) : base("root")
{
this.Level = level;
}
public void Add(Level a)
{
}
public Level LookupWithDefault(Level a)
{
return(Level.All);
}
protected static void UpdateLog4NetLevel(log4net.Core.Level level)
{
log4net.LogManager.GetRepository().Threshold = level;
}
public static void Log(object source, log4net.Core.Level level, Exception exception)
{
var sourceType = source.GetType();
LogManager.GetLogger(source.GetType()).Logger.Log(sourceType, level, null, exception);
}
