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