private static int ToLogMessageSeverity(MvxLogLevel logLevel)
{
switch (logLevel)
{
case MvxLogLevel.Trace:
return(TraceEventTypeValues.Verbose);
case MvxLogLevel.Debug:
return(TraceEventTypeValues.Verbose);
case MvxLogLevel.Info:
return(TraceEventTypeValues.Information);
case MvxLogLevel.Warn:
return(TraceEventTypeValues.Warning);
case MvxLogLevel.Error:
return(TraceEventTypeValues.Error);
case MvxLogLevel.Fatal:
return(TraceEventTypeValues.Critical);
default:
throw new ArgumentOutOfRangeException("logLevel");
}
}
public bool Log(MvxLogLevel logLevel, Func <string> messageFunc, Exception exception, params object[] formatParameters)
{
var translatedLevel = TranslateLevel(logLevel);
if (messageFunc == null)
{
return(IsEnabled(_logger, translatedLevel));
}
if (!IsEnabled(_logger, translatedLevel))
{
return(false);
}
if (exception != null)
{
LogException(translatedLevel, messageFunc, exception, formatParameters);
}
else
{
LogMessage(translatedLevel, messageFunc, formatParameters);
}
return(true);
}
private object TranslateLevel(MvxLogLevel logLevel)
{
switch (logLevel)
{
case MvxLogLevel.Trace:
return(_levelTrace);
case MvxLogLevel.Debug:
return(_levelDebug);
case MvxLogLevel.Info:
return(_levelInfo);
case MvxLogLevel.Warn:
return(_levelWarn);
case MvxLogLevel.Error:
return(_levelError);
case MvxLogLevel.Fatal:
return(_levelFatal);
default:
throw new ArgumentOutOfRangeException("logLevel", logLevel, null);
}
}
public bool Log(MvxLogLevel logLevel, Func <string> messageFunc, Exception exception = null,
params object[] formatParameters)
{
Debug.WriteLine(logLevel + ":" + messageFunc());
return(true);
}
public bool LogException(MvxLogLevel logLevel, Func <string> messageFunc, Exception exception)
{
var severity = MapSeverity(logLevel);
var message = messageFunc() + Environment.NewLine + exception;
_writeLog(_loggerName, message, severity);
return(true);
}
private static void Trace(MvxLogLevel level, string message, params object[] args)
{
if (level < TraceBindingLevel)
{
return;
}
Instance?.Log(level, () => message, null, args);
}
private static void Trace(MvxLogLevel level, string message, params object[] args)
{
if (level < TraceBindingLevel)
{
return;
}
Instance.Log(level, () => string.Format(message, args));
}
public bool Log(MvxLogLevel logLevel, Func <string> messageFunc, Exception exception = null, params object[] formatParameters)
{
var properties = new Dictionary <string, string> {
{ "messageFunc", messageFunc() }
};
Debug.WriteLine(logLevel + ":" + messageFunc());
Crashes.TrackError(exception, properties);
return(true);
}
public void Trace(MvxLogLevel level, string tag, string message, params object[] args)
{
try
{
Debug.WriteLine(tag + ":" + level + ":" + message, args);
}
catch (FormatException)
{
Trace(MvxLogLevel.Error, tag, "Exception during trace of {0} {1}", level, message);
}
}
private bool LogException(MvxLogLevel logLevel, Func <string> messageFunc, Exception exception)
{
switch (logLevel)
{
case MvxLogLevel.Debug:
if (_logger.IsDebugEnabled)
{
_logger.DebugException(messageFunc(), exception);
return(true);
}
break;
case MvxLogLevel.Info:
if (_logger.IsInfoEnabled)
{
_logger.InfoException(messageFunc(), exception);
return(true);
}
break;
case MvxLogLevel.Warn:
if (_logger.IsWarnEnabled)
{
_logger.WarnException(messageFunc(), exception);
return(true);
}
break;
case MvxLogLevel.Error:
if (_logger.IsErrorEnabled)
{
_logger.ErrorException(messageFunc(), exception);
return(true);
}
break;
case MvxLogLevel.Fatal:
if (_logger.IsFatalEnabled)
{
_logger.FatalException(messageFunc(), exception);
return(true);
}
break;
default:
if (_logger.IsTraceEnabled)
{
_logger.TraceException(messageFunc(), exception);
return(true);
}
break;
}
return(false);
}
protected override void Write(MvxLogLevel logLevel, string message, Exception e = null)
{
try
{
var formatted = TestLogProvider.MessageFormatter(_name, logLevel, message, e);
_testOuputHelper.WriteLine(formatted);
}
catch (InvalidOperationException)
{
// not ready to log yet, usually happens before test actually started
// however, MvvmCross is already setting up things in fixture and logging
}
}
public bool Log(MvxLogLevel logLevel, Func <string> messageFunc, Exception exception,
params object[] formatParameters)
{
if (messageFunc == null)
{
return(true);
}
messageFunc = LogMessageFormatter.SimulateStructuredLogging(messageFunc, formatParameters);
Write(logLevel, messageFunc(), exception);
return(true);
}
public bool Log(MvxLogLevel logLevel, Func <string> messageFunc, Exception exception, params object[] formatParameters)
{
if (messageFunc == null)
{
//nothing to log..
return(true);
}
messageFunc = LogMessageFormatter.SimulateStructuredLogging(messageFunc, formatParameters);
_logWriteDelegate(ToLogMessageSeverity(logLevel), LogSystem, _skipLevel, exception, true, 0, null,
_category, null, messageFunc.Invoke());
return(true);
}
public bool Log(MvxLogLevel logLevel, Func <string> messageFunc, Exception exception, params object[] formatParameters)
{
var severity = MapSeverity(logLevel);
if (messageFunc == null)
{
return(_shouldLog(_loggerName, severity));
}
messageFunc = LogMessageFormatter.SimulateStructuredLogging(messageFunc, formatParameters);
if (exception != null)
{
return(LogException(logLevel, messageFunc, exception));
}
_writeLog(_loggerName, messageFunc(), severity);
return(true);
}
private static int MapSeverity(MvxLogLevel logLevel)
{
switch (logLevel)
{
case MvxLogLevel.Fatal:
return(TraceEventTypeValues.Critical);
case MvxLogLevel.Error:
return(TraceEventTypeValues.Error);
case MvxLogLevel.Warn:
return(TraceEventTypeValues.Warning);
case MvxLogLevel.Info:
return(TraceEventTypeValues.Information);
default:
return(TraceEventTypeValues.Verbose);
}
}
protected void Write(MvxLogLevel logLevel, string message, Exception e = null)
{
var formattedMessage = MessageFormatter(_name, logLevel, message, e);
if (Colors.TryGetValue(logLevel, out var color))
{
var originalColor = System.Console.ForegroundColor;
try
{
System.Console.ForegroundColor = color;
System.Console.WriteLine(formattedMessage);
}
finally
{
System.Console.ForegroundColor = originalColor;
}
}
else
{
System.Console.WriteLine(formattedMessage);
}
}
public bool Log(MvxLogLevel logLevel, Func <string> messageFunc, Exception exception, params object[] formatParameters)
{
if (messageFunc == null)
{
return(IsLogLevelEnable(logLevel));
}
if (!IsLogLevelEnable(logLevel))
{
return(false);
}
string message = messageFunc();
IEnumerable <string> patternMatches;
string formattedMessage =
LogMessageFormatter.FormatStructuredMessage(message,
formatParameters,
out patternMatches);
// determine correct caller - this might change due to jit optimizations with method inlining
if (s_callerStackBoundaryType == null)
{
lock (CallerStackBoundaryTypeSync)
s_callerStackBoundaryType = typeof(MvxLog);
}
var translatedLevel = TranslateLevel(logLevel);
object loggingEvent = _createLoggingEvent(_logger, s_callerStackBoundaryType, translatedLevel, formattedMessage, exception);
PopulateProperties(loggingEvent, patternMatches, formatParameters);
_logDelegate(_logger, loggingEvent);
return(true);
}
private bool IsLogLevelEnable(MvxLogLevel logLevel)
{
switch (logLevel)
{
case MvxLogLevel.Debug:
return(_logger.IsDebugEnabled);
case MvxLogLevel.Info:
return(_logger.IsInfoEnabled);
case MvxLogLevel.Warn:
return(_logger.IsWarnEnabled);
case MvxLogLevel.Error:
return(_logger.IsErrorEnabled);
case MvxLogLevel.Fatal:
return(_logger.IsFatalEnabled);
default:
return(_logger.IsTraceEnabled);
}
}
protected void Write(MvxLogLevel logLevel, string message, Exception e = null)
{
var formattedMessage = MessageFormatter(_name, logLevel, message, e);
int color;
if (Colors.TryGetValue(logLevel, out color))
{
var originalColor = _getForeground();
try
{
_setForeground(color);
_write(formattedMessage);
}
finally
{
_setForeground(originalColor);
}
}
else
{
_write(formattedMessage);
}
}
private static object TranslateLevel(MvxLogLevel logLevel)
{
switch (logLevel)
{
case MvxLogLevel.Fatal:
return(FatalLevel);
case MvxLogLevel.Error:
return(ErrorLevel);
case MvxLogLevel.Warn:
return(WarningLevel);
case MvxLogLevel.Info:
return(InformationLevel);
case MvxLogLevel.Trace:
return(VerboseLevel);
default:
return(DebugLevel);
}
}
public bool Log(MvxLogLevel logLevel, Func <string> messageFunc, Exception exception = null, params object[] formatParameters)
{
if (messageFunc == null)
{
return(_logger(logLevel, null));
}
Func <string> wrappedMessageFunc = () =>
{
try
{
return(messageFunc());
}
catch (Exception ex)
{
Log(MvxLogLevel.Error, () => FailedToGenerateLogMessage, ex);
}
return(null);
};
return(_logger(logLevel, wrappedMessageFunc, exception, formatParameters));
}
private static string MessageFormatter(string loggerName, MvxLogLevel level, object message, Exception e)
{
var stringBuilder = new StringBuilder();
stringBuilder.Append(DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss", CultureInfo.InvariantCulture));
stringBuilder.Append(" ");
// Append a readable representation of the log level
stringBuilder.Append(("[" + level.ToString().ToUpper() + "]").PadRight(8));
stringBuilder.Append("(" + loggerName + ") ");
// Append the message
stringBuilder.Append(message);
// Append stack trace if there is an exception
if (e != null)
{
stringBuilder.Append(Environment.NewLine).Append(e.GetType());
stringBuilder.Append(Environment.NewLine).Append(e.Message);
stringBuilder.Append(Environment.NewLine).Append(e.StackTrace);
}
return(stringBuilder.ToString());
}
public bool Log(MvxLogLevel logLevel, Func <string> messageFunc, Exception exception, params object[] formatParameters)
{
if (messageFunc == null)
{
return(IsLogLevelEnable(logLevel));
}
messageFunc = LogMessageFormatter.SimulateStructuredLogging(messageFunc, formatParameters);
if (_logEventInfoFact != null)
{
if (IsLogLevelEnable(logLevel))
{
var nlogLevel = TranslateLevel(logLevel);
_logger.Log(_logEventInfoFact(_logger.Name, nlogLevel, messageFunc(), exception));
return(true);
}
return(false);
}
if (exception != null)
{
return(LogException(logLevel, messageFunc, exception));
}
switch (logLevel)
{
case MvxLogLevel.Debug:
if (_logger.IsDebugEnabled)
{
_logger.Debug(messageFunc());
return(true);
}
break;
case MvxLogLevel.Info:
if (_logger.IsInfoEnabled)
{
_logger.Info(messageFunc());
return(true);
}
break;
case MvxLogLevel.Warn:
if (_logger.IsWarnEnabled)
{
_logger.Warn(messageFunc());
return(true);
}
break;
case MvxLogLevel.Error:
if (_logger.IsErrorEnabled)
{
_logger.Error(messageFunc());
return(true);
}
break;
case MvxLogLevel.Fatal:
if (_logger.IsFatalEnabled)
{
_logger.Fatal(messageFunc());
return(true);
}
break;
default:
if (_logger.IsTraceEnabled)
{
_logger.Trace(messageFunc());
return(true);
}
break;
}
return(false);
}
public bool IsLogLevelEnabled(MvxLogLevel logLevel)
{
return(true);
}
public bool Log(MvxLogLevel logLevel, Func <string> messageFunc, Exception exception = null, params object[] formatParameters)
{
return(true);
}
private static void LogFormat(this IMvxLog logger, MvxLogLevel logLevel, string message, params object[] args)
{
logger.Log(logLevel, message.AsFunc(), null, args);
}
protected void Write(MvxLogLevel logLevel, string message, Exception e = null)
{
var formattedMessage = MessageFormatter(_name, logLevel, message, e);
//Console.WriteLine(formattedMessage);
}
public bool IsLogLevelEnabled(MvxLogLevel logLevel) => _logger(logLevel, null);
public bool IsLogLevelEnabled(MvxLogLevel logLevel) => true;
private bool IsLogLevelEnable(MvxLogLevel logLevel)
{
var level = TranslateLevel(logLevel);
return(_isEnabledForDelegate(_logger, level));
}
