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); }