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