private void LogToLoggerClient (LogLevel level, string tag, string message, Exception exc) { if (level >= LogLevel.Warning) { ErrorSeverity severity; switch (level) { case LogLevel.Warning: severity = ErrorSeverity.Warning; break; case LogLevel.Error: severity = ErrorSeverity.Error; break; default: severity = ErrorSeverity.Info; break; } var md = new Metadata (); md.AddToTab ("Logger", "Tag", tag); md.AddToTab ("Logger", "Message", message); AddExtraMetadata (md); var loggerClient = ServiceContainer.Resolve<ILoggerClient> (); if (loggerClient != null) { loggerClient.Notify (exc, severity, md); } } }
private static void LogLine(LogLevel level, string msg) { if ((Level & level) == level) { LogStream.WriteLine(msg); } }
internal LogStatement(LogLevel level, string text, object[] args, Type type) { Level = level; Args = args; Type = type; Text = text; }
protected virtual void WriteConsole (LogLevel level, string tag, string message, Exception exc) { Console.WriteLine ("[{1}] {0}: {2}", level, tag, message); if (exc != null) { Console.WriteLine (exc.ToString ()); } }
public override void Log(LogLevel level, string msg, params object[] args) { lock (_lock) { var previous = Console.ForegroundColor; switch (level) { case LogLevel.Debug: Console.ForegroundColor = ConsoleColor.Blue; break; case LogLevel.Info: Console.ForegroundColor = ConsoleColor.White; break; case LogLevel.Warning: Console.ForegroundColor = ConsoleColor.Yellow; break; case LogLevel.Error: Console.ForegroundColor = ConsoleColor.Red; break; case LogLevel.Fatal: Console.ForegroundColor = ConsoleColor.Magenta; break; default: break; } Console.WriteLine(NameFormatToPositionalFormat(msg), args); Console.ForegroundColor = previous; } }
/// <summary> /// Configures NLog for to log to the specified target so that all messages /// above and including the specified level are output. /// </summary> /// <param name="target">The target to log all messages to.</param> /// <param name="minLevel">The minimal logging level.</param> public static void ConfigureForTargetLogging(Target target, LogLevel minLevel) { LoggingConfiguration config = new LoggingConfiguration(); LoggingRule rule = new LoggingRule("*", minLevel, target); config.LoggingRules.Add(rule); LogManager.Configuration = config; }
internal static Level ToLog4Net( LogLevel level ) { if ( level == LogLevel.Error ) { return Level.Error; } else if ( level == LogLevel.Warning ) { return Level.Warn; } else if ( level == LogLevel.Notice ) { return Level.Notice; } else if ( level == LogLevel.Info ) { return Level.Info; } else if ( level == LogLevel.Debug ) { return Level.Debug; } else { throw new NotSupportedException( "LogLevel not supported: " + level ); } }
public LogLine(LogLevel level, string text, Type type) { Time = DateTime.Now; Level = level; Text = text; Type = type; }
/// <summary> /// ��¼��־�ķ���,�÷���Ĭ�ϰ���־��Ϣ��¼���ı��ļ��� /// </summary> /// <param name="logMsg">��־�ı���Ϣ</param> /// <param name="logLevel">��־�ȼ�</param> public void Write(string logMsg, LogLevel logLevel) { MetaLog metaLog = new TxtMetaLog(logMsg); metaLog.Level = logLevel; this.Write(metaLog); }
public static void SetLogLevel(LogLevel logLevel, bool enableLogging=true) { #if UNITY_ANALYTICS_SUPPORTED_PLATFORM Logger.EnableLogging = enableLogging; Logger.SetLogLevel((int)logLevel); #endif }
public static void Write (LogLevel level, string msg, params object[] args) { lock (loggers) { foreach (var l in loggers) l.Write (level, msg, args); } }
/// <summary> /// Configures Rebus to log its stuff to with different colors depending on the log level, possibly ignore logged lines under the specified <see cref="LogLevel"/> /// </summary> public void ColoredConsole(LogLevel minLevel = LogLevel.Debug) { UseLoggerFactory(new ConsoleLoggerFactory(true) { MinLevel = minLevel }); }
/// <summary> /// Logs an entry to the source /// </summary> /// <param name="logLevel">Used level.</param> /// <param name="msg">Message.</param> /// <param name="exception">The exception (or null).</param> public override void Write(LogLevel logLevel, string msg, Exception exception) { if (logLevel < _minLevel) return; _innerLogger.Write(logLevel, msg, exception); }
/// <summary> /// Log a message to the logger. /// </summary> /// <param name="level">Log level.</param> /// <param name="msg">Log message (format string).</param> /// <param name="args">Log message arguments.</param> public override void Log(LogLevel level, string msg, params object[] args) { var ordinalFormattedMessage = NameFormatToPositionalFormat(msg); switch (level) { case LogLevel.Debug: this.logger.DebugFormat(ordinalFormattedMessage, args); break; case LogLevel.Info: this.logger.InfoFormat(ordinalFormattedMessage, args); break; case LogLevel.Warning: this.logger.WarnFormat(ordinalFormattedMessage, args); break; case LogLevel.Error: this.logger.ErrorFormat(ordinalFormattedMessage, args); break; case LogLevel.Fatal: this.logger.FatalFormat(ordinalFormattedMessage, args); break; default: this.logger.InfoFormat(ordinalFormattedMessage, args); break; } }
public bool IsLoggingEnabled(LogLevel logLevel) { log4net.ILog logger; if (_loggerName != null && _loggerName.Trim() != string.Empty) logger = LogManager.GetLogger(_loggerName); else { Type type = new StackFrame(_frameToSkip, false).GetMethod().DeclaringType; logger = LogManager.GetLogger(type); } switch (logLevel) { case LogLevel.Debug: return logger.IsDebugEnabled; case LogLevel.Info: return logger.IsInfoEnabled; case LogLevel.Warn: return logger.IsWarnEnabled; case LogLevel.Error: return logger.IsErrorEnabled; case LogLevel.Fatal: return logger.IsFatalEnabled; case LogLevel.Off: return false; default: throw new Exception(string.Format("Unrecognized log level '{0}'.", logLevel.ToString())); } }
private static void Log(LogLevel logLevel, string msg) { if (logLevel < LogLevel) return; StackFrame frame = new StackFrame(2, true); var method = frame.GetMethod(); var lineNumber = frame.GetFileLineNumber(); var color = Console.ForegroundColor; switch (logLevel) { case LogLevel.None: break; case LogLevel.Debug: Console.ForegroundColor = ConsoleColor.DarkGray; break; case LogLevel.Info: Console.ForegroundColor = ConsoleColor.Gray; break; case LogLevel.Warning: Console.ForegroundColor = ConsoleColor.Yellow; break; case LogLevel.Error: Console.ForegroundColor = ConsoleColor.Red; break; } Console.WriteLine("{0}.{1}:{2} - {3}", method.DeclaringType.FullName, method.Name, lineNumber, msg); Console.ForegroundColor = color; }
public static void Log(LogLevel level, object sender, string message, params object[] args) { string typeName = (sender == null ? "(null)" : sender.GetType ().FullName); LogEventInfo info = new LogEventInfo (_levelMap[level], typeName, string.Format (message, args)); info.Context.Add ("sender", sender); _logger.Log (info); }
public static void ColoredConsoleWrite(ConsoleColor color, string text, LogLevel level = LogLevel.Info) { ConsoleColor originalColor = System.Console.ForegroundColor; System.Console.ForegroundColor = color; System.Console.WriteLine($"[{DateTime.Now.ToString("HH:mm:ss")}] "+ text); System.Console.ForegroundColor = originalColor; }
/// <summary> Logs specified log level and above to custom target (requires knowledge of NLog target usage) </summary> public LoggerConfiguration AddTarget(LogLevel minLogLevel, Target target) { var loggingRule = new LoggingRule("*", minLogLevel.NLogLevel, target); LogManager.Configuration.LoggingRules.Add(loggingRule); LogManager.ReconfigExistingLoggers(); return this; }
protected void Log(string log, LogLevel level) { if (LogEvent != null) { LogEvent(this, new LogEventArgs(log, level)); } }
/// <summary> /// Initializes a new instance of the <see cref="T:System.EventArgs"/> class. /// </summary> public CaptureEngineLogEventArgs(string message, LogLevel level, DateTime date, object data = null) { this.Message = message; this.Level = level; this.Date = date; this.Data = data; }
public void WriteLog(string message, LogLevel level) { // Check if the specified log level is enabled if (!IsEnabled(level)) { return; } // Don't bother with empty messages if (string.IsNullOrEmpty(message)) { return; } lock (_lock) { if (!File.Exists(_logFile) || !_logFileStream.CanWrite) { // File has been delete so dispose the stream and create a new one _logFileStream.Dispose(); _logFileStream = new FileStream(_logFile, FileMode.Append, FileAccess.Write, FileShare.ReadWrite); } using (StreamWriter sw = new StreamWriter(_logFileStream)) { // Write to the file sw.WriteLine(message); // Flush the contents to disk sw.Flush(); } } }
public SimpleLogItem(LogLevel level, string message, string info) { this.time = DateTime.Now; this.level = level; this.message = message; this.info = info; }
/// <summary> /// Used only by filtering extension methods (level is filtered and not None) or by static FakeLineSender (level is None). /// </summary> internal ActivityMonitorLineSender( IActivityMonitor monitor, LogLevel level, string fileName, int lineNumber ) : base( level, fileName, lineNumber ) { Debug.Assert( FakeLineSender == null || ((level & LogLevel.IsFiltered) != 0 && MaskedLevel != LogLevel.None), "The level is already filtered and not None or we are initializing the static FakeLineSender." ); _monitor = monitor; }
public ManagementConsoleLogTracer(string logLevel) { switch (logLevel) { case "Fine": _logLevel = LogLevel.Fine; break; case "Info": _logLevel = LogLevel.Info; break; case "Fatal": _logLevel = LogLevel.Fatal; break; case "Warning": _logLevel = LogLevel.Warning; break; case "Debug": _logLevel = LogLevel.Debug; break; case "Error": _logLevel = LogLevel.Error; break; default: throw new ArgumentException( "Unhandled log level: " + logLevel); } }
// ReSharper disable ExplicitCallerInfoArgument public static void Log( this ILogger logger, LogLevel logLevel, Exception exception, string message = null, [CallerMemberName] string callerMemberName = null, [CallerFilePath] string callerFilePath = null, [CallerLineNumber] int callerLineNumber = 0) { if (exception == null) { throw new ArgumentNullException("exception"); } if (logLevel != LogLevel.Audit && !logger.IsEnabled(logLevel)) { return; } var logEntry = DefaultLogEntryFactory.Current.CreateLogEntry(); logEntry.Level = logLevel; logEntry.SetException(exception); logEntry.Message = message ?? exception.Message; logger.LogAsync(logEntry, callerMemberName, callerFilePath, callerLineNumber); }
public static void Log(LogLevel level, string message, Exception exception = null) { var builder = new StringBuilder(); builder.Append(DateTime.Now); builder.Append(" [").Append(level.ToString().ToUpper()).Append("] "); builder.Append(message); //vamos imprimir para tela sem o stack track. switch (level) { case LogLevel.Debug: Console.ForegroundColor = ConsoleColor.DarkBlue; break; case LogLevel.Warn: Console.ForegroundColor = ConsoleColor.Yellow; break; case LogLevel.Error: Console.ForegroundColor = ConsoleColor.Red; break; } Console.WriteLine(builder.ToString()); Console.ResetColor(); if (exception != null) { builder.Append('\n'); builder.Append("Caused by: ").Append(exception.Message).Append('\n'); builder.Append("Stack trace:\n"); builder.Append(exception.StackTrace); } Write(builder.ToString()); }
public FileLog(string filePath, LogLevel minLevel = LogLevel.Info) { AttemptToCreateDirectory(filePath); _logFileStream = new FileStream(filePath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite); _minLevel = minLevel; _logFile = filePath; }
/// <summary> /// 初始化应用程序异常 /// </summary> /// <param name="message">错误消息</param> /// <param name="code">错误码</param> /// <param name="level">日志级别</param> /// <param name="exception">异常</param> public Warning( string message, string code, LogLevel level, Exception exception ) : base( message ?? "", exception ) { Code = code; Level = level; _message = GetMessage(); }
public void Write(Verbosity verbosity, LogLevel level, string format, params object[] args) { if (verbosity > Verbosity) { return; } lock (_lock) { try { var palette = _palettes[level]; var tokens = FormatParser.Parse(format); foreach (var token in tokens) { SetPalette(token, palette); _console.Write("{0}", token.Render(args)); } } finally { _console.ResetColor(); _console.WriteLine(); } } }
public Logger(LogLevel logLevel = LogLevel.Info) { _logLevel = logLevel; }
bool ILogger.IsEnabled(LogLevel logLevel) { return(true); }
protected void Log(object message, LogLevel level = LogLevel.Info) { Utility.Log($"{nameof(Plugin)}:{Name}", level, message); }
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { Log(DateTimeOffset.Now, logLevel, eventId, state, exception, formatter); }
public bool IsEnabled(LogLevel logLevel) { return(_provider.IsEnabled); }
/// <inheritdoc/> public bool IsEnabled(LogLevel logLevel) { return(true); }
public void SetLogLevel(LogLevel newLogLevel) { this.Debug($"Setting log level to {newLogLevel.ToString()} from {_logLevel.ToString()}"); _logLevel = newLogLevel; }
public HttpNotFoundResult(string statusDescription, LogLevel logLevel = LogLevel.Warning) : base( HttpStatusCode.NotFound, statusDescription, logLevel) { }
/// <summary> /// Provides the method to write logs like defined in the ICakeLog interface but does not log anything. /// </summary> /// <param name="verbosity">The ignored verbosity of the log message.</param> /// <param name="level">The ignored level of the log message</param> /// <param name="format">The ignored format string for the log message</param> /// <param name="args">The ignored string format arguments for the log message</param> /// <remarks> /// Can be used as logger to prevent the Cake tool from logging at all. /// This way, the caller does not have to check for nulls. /// </remarks> public void Write(Verbosity verbosity, LogLevel level, string format, params object[] args) { // log nothing }
public HttpNotFoundResult(LogLevel logLevel = LogLevel.Warning) : this(null, logLevel) { }
/** <inheritdoc /> */ public void Log(LogLevel level, string message, object[] args, IFormatProvider formatProvider, string category, string nativeErrorInfo, Exception ex) { throw new NotImplementedException(); }
/// <summary> /// Run the app /// </summary> /// <param name="keyvaultName">Keyvault Name</param> /// <param name="authType">Authentication Type</param> /// <param name="dryRun">Dry Run flag</param> /// <returns></returns> public static async Task <int> RunApp(string keyvaultName, AuthenticationType authType, LogLevel logLevel, bool dryRun) { // validate keyvaultName and convert to URL if (!KeyVaultHelper.BuildKeyVaultConnectionString(keyvaultName, out string kvUrl)) { return(-1); } try { // setup ctl c handler ctCancel = SetupCtlCHandler(); HeliumLogLevel = logLevel; // build the host host = await BuildHost(kvUrl, authType).ConfigureAwait(false); if (host == null) { return(-1); } // don't start the web server if (dryRun) { return(DoDryRun(kvUrl, authType)); } // log startup messages LogStartup(); // start the webserver var w = host.RunAsync(); // this doesn't return except on ctl-c await w.ConfigureAwait(false); // use this line instead if you want to re-read the Cosmos connection info on a timer //await RunKeyRotationCheck(ctCancel, Constants.KeyVaultChangeCheckSeconds).ConfigureAwait(false); // if not cancelled, app exit -1 return(ctCancel.IsCancellationRequested ? 0 : -1); } catch (Exception ex) { // end app on error if (logger != null) { logger.LogError($"Exception: {ex}"); } else { Console.WriteLine($"Error in Main()\n{ex}"); } return(-1); } }
private void Log(string message, LogLevel level = LogLevel.Info) { Plugin.Log(nameof(ConsensusService), level, message); }
/** <inheritdoc /> */ public bool IsEnabled(LogLevel level) { throw new NotImplementedException(); }
//Interface /// <summary>Initializes a new instance of the Argix08.ArgixEventLogTraceListener class that listens for Argix08.TraceMessages and logs them to a System.Diagnostics.EventLog.</summary> /// <param name="logLevelFloor">The minimum log level (floor) that Argix08.TraceMessage must meet to be logged.</param> /// <param name="eventLogName"></param> public ArgixEventLogTraceListener(LogLevel logLevelFloor, string eventLogName) : this(logLevelFloor, eventLogName, global::Argix.Properties.Settings.Default.EventLogMachineName) { }
public bool IsEnabled(LogLevel logLevel) { //return logLevel == LogLevel.Trace; return(true); }
bool ILogger.IsEnabled(LogLevel logLevel) => true;
public LogItem(LogLevel level, string msg) { this.mLogLevel = level; this.mMsg = msg; this.mLogTime = DateTime.Now.ToLocalTime(); }
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { _loggingOutputBuilder.AppendLine(formatter(state, exception)); }
public bool IsEnabled(LogLevel logLevel) { return(logLevel == _config.LogLevel); }
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { System.Diagnostics.Trace.WriteLine(formatter(state, exception)); }
public virtual void WriteMessage(LogLevel logLevel, string logName, int eventId, string message, Exception exception) { var logBuilder = _logBuilder; _logBuilder = null; if (logBuilder == null) { logBuilder = new StringBuilder(); } var logLevelString = string.Empty; // Example: // INFO: ConsoleApp.Program[10] // Request received logLevelString = GetLogLevelString(logLevel); // category and event id logBuilder.Append(_loglevelPadding); logBuilder.Append(logName); logBuilder.Append("["); logBuilder.Append(eventId); logBuilder.AppendLine("]"); // scope information GetScopeInformation(logBuilder); if (!string.IsNullOrEmpty(message)) { // message logBuilder.Append(_messagePadding); var len = logBuilder.Length; logBuilder.AppendLine(message); logBuilder.Replace(Environment.NewLine, _newLineWithMessagePadding, len, message.Length); } // Example: // System.InvalidOperationException // at Namespace.Class.Function() in File:line X if (exception != null) { // exception message logBuilder.AppendLine(exception.ToString()); } var hasLevel = !string.IsNullOrEmpty(logLevelString); // Queue log message string machineName = Environment.MachineName; var entityMessage = new EntityMessages() { Id = Guid.NewGuid().ToString("N"), MachineName = machineName, OtherFlag = _prix, DateTime = DateTime.Now, LogLevel = (hasLevel ? logLevelString : null), Message = logBuilder.ToString() }; AddCollMess(entityMessage); logBuilder.Clear(); if (logBuilder.Capacity > 1024) { logBuilder.Capacity = 1024; } _logBuilder = logBuilder; }
public bool IsEnabled(LogLevel logLevel) => false;
public static void Log(this string message, LogLevel level) { //TODO: decide on logging code //Console.WriteLine(string.Format("{0:d/M/yyyy HH:mm:ss}: {1}", DateTime.Now, message)); }
private static bool doLog(LogLevel level) { return(level >= Level); }
public void Log <TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func <TState, Exception, string> formatter) { }
public bool IsEnabled(LogLevel logLevel) => logLevel != LogLevel.None;
private static string getLogMessage(LogLevel level, string message, params object[] @params) { return(string.Format("[{0}] [{1}] {2}", CATEGORY, level, formatMessage(message, @params))); }
public virtual bool IsEnabled(LogLevel logLevel) { return _enabledByName; }
/// <summary> /// These two method are used to retain the ${callsite} for all the Nlog method /// </summary> /// <param name="level">LogLevel.</param> /// <param name="format">Passed message.</param> /// <param name="ex">Exception.</param> private void Write(LogLevel level, string format, params object[] args) { LogEventInfo le = new LogEventInfo(level, _logger.Name, null, format, args); _logger.Log(typeof(NlogWrapper), le); }