public static void WriteLog(ELogLevel logLevel, String log)
{
if (logLevel.Equals(ELogLevel.DEBUG))
{
logger.Debug(log);
}
else if (logLevel.Equals(ELogLevel.ERROR))
{
logger.Error(log);
}
else if (logLevel.Equals(ELogLevel.FATAL))
{
logger.Fatal(log);
}
else if (logLevel.Equals(ELogLevel.INFO))
{
logger.Info(log);
}
else if (logLevel.Equals(ELogLevel.WARN))
{
logger.Warn(log);
}
}
public static void LogEvent(string system, string message, ELogLevel level)
{
message = message.Replace("\r", "\r\n");
lock (_writeLock)
{
//[TIME] [SYSTEM] MESSAGE
Console.ForegroundColor = ConsoleColor.Gray;
Console.Write("[{0}] [", DateTime.Now.ToString());
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write(system);
Console.ForegroundColor = ConsoleColor.Gray;
Console.Write("] ");
switch (level)
{
case ELogLevel.DEBUG:
Console.ForegroundColor = ConsoleColor.DarkGreen;
break;
case ELogLevel.INFO:
Console.ForegroundColor = ConsoleColor.Green;
break;
case ELogLevel.WARNING:
Console.ForegroundColor = ConsoleColor.DarkRed;
break;
case ELogLevel.ERROR:
Console.ForegroundColor = ConsoleColor.Red;
break;
}
Console.WriteLine(message);
}
}
public static void WriteLog(ELogLevel logLevel, String log)
{
switch(logLevel)
{
case ELogLevel.INFO:
if(logger.IsInfoEnabled) logger.Info(log);
break;
case ELogLevel.WARN:
if(logger.IsWarnEnabled) logger.Warn(log);
break;
case ELogLevel.ERROR:
if(logger.IsErrorEnabled) logger.Error(log);
break;
case ELogLevel.FATAL:
if(logger.IsFatalEnabled) logger.Fatal(log);
break;
case ELogLevel.DEBUG:
if(logger.IsDebugEnabled) logger.Debug(log);
break;
}
}
public void Log(ELogLevel level, string value, string tags = null, string memberName = null, string filePath = null, int lineNumber = 0)
{
if (_enabledLevel <= level)
{
_buffer.Add(LogEntry.Create(level, tags, value, memberName, filePath, lineNumber));
}
}
public void Log(ELogLevel level, string value, string tags=null, string memberName = null, string filePath = null, int lineNumber = 0)
{
if (_enabledLevel <= level)
{
string message = LogEntry.Create(level, tags, value, memberName, filePath, lineNumber).ToString();
Console.WriteLine(message);
}
}
public void Log(ELogLevel level, string value, string tags=null, string memberName = null, string filePath = null, int lineNumber = 0)
{
if (_enabledLevel <= level)
{
LogEntry message = LogEntry.Create(level, tags, value, memberName, filePath, lineNumber);
InsertLog(message.Date, message.Level, message.Data, message.Tags);
}
}
public void log(object caller, string message, ELogLevel level)
{
DateTime now = DateTime.Now;
string line = level.ToString() + ": (" + now.ToLongTimeString() + " " + now.ToLongDateString() + ") [" + caller.ToString() + "] ~" + message;
Llog.Add(line);
loggedLevel.Add(level);
writeLogToFile();
//displayLine();
}
private void BuildInsertQuery(ref IStatementBuilder pStatement, DateTime startDate, ELogLevel maxLevel, string title, string data)
{
pStatement.Append($"insert into {targetTable}({targetDateColumn},{targetLevelColumn},{targetTitleColumn},{targetDataColumn})");
pStatement.Append($"values(@{targetDateColumn},@{targetLevelColumn},@{targetTitleColumn},@{targetDataColumn})");
pStatement.AddParameter(targetDateColumn, startDate, DbType.DateTime);
pStatement.AddParameter(targetDateColumn, maxLevel, DbType.String);
pStatement.AddParameter(targetDateColumn, title, DbType.String);
pStatement.AddParameter(targetDateColumn, data, DbType.String);
}
private void BuildInsertQuery(ref IStatementBuilder pStatement, DateTime date, ELogLevel level, string data,string tag,string memberName = null, string filePath = null, int lineNumber = 0)
{
pStatement.Append($"insert into {targetTable}({targetDateColumn},{targetLevelColumn},{targetDataColumn},{targetTagColumn},{targetMemberNameColumn},{targetFilePathColumn},{targetLineNumberColumn})");
pStatement.Append($"values(@{targetDateColumn},@{targetLevelColumn},@{targetDataColumn},@{targetTagColumn},@{targetMemberNameColumn},@{targetFilePathColumn},@{targetLineNumberColumn})");
pStatement.AddParameter(targetDateColumn, date, DbType.DateTime);
pStatement.AddParameter(targetLevelColumn, level, DbType.String);
pStatement.AddParameter(targetDataColumn, data, DbType.String);
pStatement.AddParameter(targetTagColumn, tag, DbType.String);
pStatement.AddParameter(targetMemberNameColumn, memberName, DbType.String);
pStatement.AddParameter(targetFilePathColumn, filePath, DbType.String);
pStatement.AddParameter(targetLineNumberColumn, lineNumber, DbType.Int32);
}
private void InsertLog(DateTime date, ELogLevel level, string data,string tag, string memberName = null, string filePath = null, int lineNumber = 0)
{
IDataContext c = _dataContext;
IStatementBuilder statement = null;
try
{
BuildInsertQuery(ref statement, date, level, data, tag,memberName,filePath,lineNumber);
statement = _statementBuilderFactory.Build(QueryType.Insert);
c.Execute(statement);
}
catch (Exception e)
{
throw new Exception(
$"[DAL] Query:\"{statement?.ToString() ?? ""}\" Error:\"{e.Message}\" StatckTrace:\"{e.StackTrace}\"");
}
}
public void log(ELogLevel eLogLevel, string sMessage, string sModule)
{
//check if LogLevel is high enough to be logged
if (eLogLevel < m_LogLevel) {
return;
}
switch (m_sLogType) {
case "memory":
m_LogList.Add (createLogEntry (eLogLevel, sMessage, sModule));
break;
case "console":
Console.WriteLine (createLogEntry (eLogLevel, sMessage, sModule));
break;
default:
m_LogList.Add (createLogEntry (eLogLevel, sMessage, sModule));
break;
}
}
/// <summary>
/// This method writes log according to log level.
/// In each message it adds caller name (method name) as a prefix
/// </summary>
/// <param name="message"></param>
/// <param name="eLevel"></param>
public void WriteLog(string sMessage, ELogLevel eLevel)
{
WriteLogToFile( sMessage, eLevel, null);
}
/// <summary>Log an exception with message 'msg'</summary> public static void Write(ELogLevel level, Exception ex, string msg, string file = null, int?line = null) => m_log.Write(level, ex, msg, file, line);
/// <summary>
/// 添加日志到缓存
/// </summary>
/// <param name="type">日志类型</param>
/// <param name="ex">异常信息</param>
/// <param name="info">附加信息</param>
/// <returns>返回日志Code</returns>
public static string AddLog(ELogLevel type, Exception ex, string info)
{
return(AddLogToBuffer(ELogLevel.Warn, info, ex.Message, ex.StackTrace));
}
public void WriteLog(string message, ELogLevel eLevel, Exception oEx)
{
WriteLogToFile(message, eLevel, oEx);
}
public CustomLogLevelAttribute(ELogLevel eLogLevel)
{
p_eLogLevel = eLogLevel;
p_iLogLevelGroup_HashCode = -1;
}
/// <summary>
/// 添加日志
/// </summary>
/// <param name="type">日志类型</param>
/// <param name="info">日志信息</param>
/// <returns>返回日志Code</returns>
public static string AddLog(ELogLevel type, string info)
{
return(AddLogToBuffer(type, info));
}
public static LogEntry Create(ELogLevel level, string tags, string data, string memberName, string filePath, int lineNumber)
{
return new LogEntry { Date = DateTime.Now, Data = data, Level = level, Tags = tags, MemberName = memberName, FilePath = filePath, LineNumber = lineNumber };
}
// 记录日志(虚函数继承,继承自ILoggingService)
public virtual void DoLog(String kMsg, ELogLevel eLevel)
{
DoLog(kMsg, eLevel, false);
}
public void Log(ELogType logType, ELogLevel logLevel, string method, object data) => this.Log("--", new Guid(), logType, logLevel, method, data);
public void Log(ELogType logType, ELogLevel logLevel, Exception exception, object data) => this.Log("--", new Guid(), logType, logLevel, exception, data);
//CLogger(object className)
//{
// logger = LoggerManager.GetLogger(Assembly.GetCallingAssembly(), "CLogger");
// XmlConfigurator.Configure();
//}
#endregion
#region Methods
public static void WriteLog(ELogLevel logLevel, String log)
{
WriteLog(logLevel, log, null);
}
public CustomLogLevelAttribute(ELogLevel eLogLevel, System.Type eEnumValue)
{
p_eLogLevel = eLogLevel;
p_iLogLevelGroup_HashCode = eEnumValue.GetHashCode();
}
public CustomLogLevelAttribute(ELogLevel eLogLevel, int iLogLevelGroupHashCode)
{
p_eLogLevel = eLogLevel;
p_iLogLevelGroup_HashCode = iLogLevelGroupHashCode;
}
/// <summary>
/// 记录日志
/// </summary>
/// <param name="identifier"></param>
/// <param name="message"></param>
/// <param name="logLevel"></param>
/// <returns></returns>
public static bool WriteLog(string identifier, string message, ELogLevel logLevel = ELogLevel.Info)
{
LogInfo logInfo = new LogInfo(message, logLevel);
return(WriteLog(identifier, logInfo));
}
private static bool IsMatchLevel(ELogLevel level)
{
return((logLevel & level) > 0);
}
protected LogAppenderBase(AppenderConfiguration configuration)
{
_enabledLevel = configuration.EnabledLevel;
}
public Logger(ELogLevel level, BaseLoggerHandler handler)
{
this._LogLevel = level;
this._DefaultHandler = handler;
}
public LogEvent(String kMsg, DateTime kTime, ELogLevel eLevel)
{
this.mMessage = kMsg;
this.mTime = kTime;
this.mLevel = eLevel;
}
static Log()
{
mode = ELogLevel.Debug;
listener = new DelimitedListTraceListener(filepath);
Trace.Listeners.Add(listener);
}
private string createLogEntry(ELogLevel eLogLevel, string sMessage, string sModule)
{
return eLogLevel.ToString () + " | " + sModule + " | " + sMessage;
}
private static string FormatLog(string slog, ELogLevel elog)
{
return("[" + elog + "] " + "[" + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToLongTimeString() + "] " + slog);
}
/// <summary>
/// 添加日志
/// </summary>
/// <param name="type">日志类型</param>
/// <param name="info">日志信息</param>
/// <returns>返回日志Code</returns>
public static string AddLog(ELogLevel type, params string[] info)
{
return(AddLogToBuffer(type, info));
}
public static void Log(string slog, ELogLevel elog = ELogLevel.Info)
{
Instance.log(slog, elog);
}
/// <summary>
/// 添加日志到缓存
/// </summary>
/// <param name="type">日志类型</param>
/// <param name="message">日志内容</param>
/// <returns>返回日志Code</returns>
private static string AddLogToBuffer(ELogLevel type, params string[] message)
{
if (message == null || message.Length == 0)
{
return(string.Empty);
}
try
{
long tick = DateTime.Now.Ticks;
Random ran = new Random((int)(tick & 0xffffffffL) | (int)(tick >> 32));
int code = new Random().Next(100000, 999999);
string codeStr = string.Format("{0}{1}", TAG_LOG_HEADER, code);
StringBuilder sb = new StringBuilder();
sb.Append(codeStr);
sb.Append(TAG_SPLIT);
List <string> parmsStr = new List <string>();
parmsStr.AddRange(message);
//记录堆栈信息
parmsStr.AddRange(GetMethodName());
for (int i = 0; i < parmsStr.Count; i++)
{
if (i == parmsStr.Count - 1)
{
sb.Append(parmsStr[i]);
}
else
{
sb.AppendFormat("{0}", parmsStr[i]);
}
}
sb.Append(TAG_SPLIT);
sb.Append(TAG_SPLIT);
string log = sb.ToString();
string key = ((int)type).ToString();
ConcurrentStack <string> oldInfo = null;
if (Logs.TryGetValue(key, out oldInfo))
{
oldInfo.Push(log);
}
else
{
oldInfo = new ConcurrentStack <string>();
oldInfo.Push(log);
Logs.TryAdd(key, oldInfo);
}
return(codeStr);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + "----" + ex.StackTrace);
return(string.Empty);
}
}
public string BuildLogEntry(string tag, ELogLevel logLevel, string message)
=> $"{logLevel.ToString().ToUpper()}:{tag}->{message}";
/// <summary>
/// This method writes log according to log level.
/// In each message it adds caller name (method name) as a prefix
/// </summary>
/// <param name="sRequestID"></param>
/// <param name="message"></param>
/// <param name="eLevel"></param>
protected void WriteLogToFile(string message, ELogLevel eLevel,Exception oEx)
{
StackFrame sf = null;
sf = new StackFrame(2);
MethodBase mb = sf.GetMethod();
string assemblyName = mb.DeclaringType.Assembly.GetName().Name;
string classFunctionNames = mb.DeclaringType.Name + "." + mb.Name + "()";
message = assemblyName + "." + classFunctionNames + ":: " + message;
switch (Enum.GetName(typeof(ELogLevel), eLevel))
{
case "Debug":
if (m_oFPLogger.IsEnabledFor(log4net.Core.Level.Debug))
{
m_oFPLogger.Log(log4net.Core.Level.Debug, message, oEx);
}
break;
case "Info":
if (m_oFPLogger.IsEnabledFor(log4net.Core.Level.Info))
{
m_oFPLogger.Log(log4net.Core.Level.Info, message, oEx);
}
break;
case "Warn":
if (m_oFPLogger.IsEnabledFor(log4net.Core.Level.Warn))
{
m_oFPLogger.Log(log4net.Core.Level.Warn, message, oEx);
}
break;
case "Error":
if (m_oFPLogger.IsEnabledFor(log4net.Core.Level.Error))
{
m_oFPLogger.Log(log4net.Core.Level.Error, message, oEx);
}
break;
case "Fatal":
if (m_oFPLogger.IsEnabledFor(log4net.Core.Level.Fatal))
{
m_oFPLogger.Log(log4net.Core.Level.Fatal, message, oEx);
}
break;
default:
break;
}
}
public void Log(ELogLevel level, string message)
{
Log(level, message, Header, null);
}
public static void WriteLine(ELogLevel pLogLevel, string pFormat, params object[] pArgs)
{
OnOutput(DateTime.Now.ToString() + " <" + pLogLevel.ToString() + "> " + string.Format(pFormat, pArgs));
}
public void Log(ELogLevel level, string message, string header, params (string Key, string Value)[] additionalValues)
private void Log(ELogLevel level, string text)
{
if (level == ELogLevel.None)
{
level = ELogLevel.Error;
}
#if UNITY
Action <string> log = Debug.Log;
#else
Action <string> log = Console.WriteLine;
#endif
#if !UNITY
Output(MakeEntry(level, text));
var error = level == ELogLevel.Error;
var showFrames = ShowStack || error;
// HACK!
showFrames = error;
if (ShowSource || error)
{
OutputLine("");
var lead = "\t\t";
var st = new StackTrace(true);
var foundTop = false;
foreach (var fr in st.GetFrames())
{
if (!foundTop)
{
var name = fr.GetMethod().Name;
if (((IList)_logNames).Contains(name))
{
foundTop = true;
continue;
}
}
if (!foundTop)
{
continue;
}
//if (!fr.HasSource())
// break;
if (string.IsNullOrEmpty(fr.GetFileName()))
{
break;
}
OutputLine(
$"{lead}{fr.GetFileName()}({fr.GetFileLineNumber()},{fr.GetFileColumnNumber()}): from: {fr.GetMethod().Name}");
if (!showFrames)
{
break;
}
lead += "\t";
}
}
else
{
OutputLine("");
}
#else // TODO: use bitmasks as intended
switch (level)
{
case ELogLevel.Info:
log = Debug.Log;
break;
case ELogLevel.Warn:
log = Debug.LogWarning;
break;
case ELogLevel.Error:
log = Debug.LogError;
break;
case ELogLevel.Verbose:
log = Debug.Log;
break;
}
log(MakeEntry(level, text));
#endif
}
public static void SetLevel(ELogLevel logLevel)
{
Log.logLevel = logLevel;
}
public void Log(ELogLevel pLogLevel, string pFormat, params object[] pArgs)
{
Logger.WriteLine(pLogLevel, "[Client:" + Host + "] " + pFormat, pArgs);
}
/// <summary>
/// Initialize the logging framework.
/// </summary>
/// <param name="logFolder">The folder where to write the log files.</param>
/// <param name="fileNameMainLog">The name of the main log.</param>
/// <param name="fileNameSongInfoLog">The name of the log for song problems.</param>
/// <param name="fileNameCrashMarker">The name of the file which is used as crash marker.</param>
/// <param name="currentVersion">The current version tag as it is displayed in the main menu.</param>
/// <param name="showReporterFunc">Delegate to the function which should be called if the reporter have to been shown.</param>
/// <param name="logLevel">The log level for log messages.</param>
public static void Init(string logFolder, string fileNameMainLog, string fileNameSongInfoLog, string fileNameCrashMarker, string currentVersion, ShowReporterDelegate showReporterFunc, ELogLevel logLevel)
{
_LogFolder = logFolder;
_ShowReporterFunc = showReporterFunc;
_CurrentVersion = currentVersion;
_CrashMarkerFilePath = Path.Combine(_LogFolder, fileNameCrashMarker);
// Creates the log directory if it does not exist
if (!Directory.Exists(_LogFolder))
{
Directory.CreateDirectory(_LogFolder);
}
var mainLogFilePath = Path.Combine(_LogFolder, fileNameMainLog);
var songLogFilePath = Path.Combine(_LogFolder, fileNameSongInfoLog);
// Check if crash marker file
if (File.Exists(_CrashMarkerFilePath))
{
// There was a crash in the last run -> check version tag of the crashed application instance
string versionTag;
using (StreamReader reader = new StreamReader(_CrashMarkerFilePath, Encoding.UTF8))
{
versionTag = (reader.ReadLine() ?? "").Trim();
}
// Delete the old marker
File.Delete(_CrashMarkerFilePath);
#if !DEBUG
if (_CurrentVersion == versionTag && File.Exists(mainLogFilePath))
{
string logContent = File.ReadAllText(mainLogFilePath, Encoding.UTF8);
_ShowReporterFunc(crash: true,
showContinue: true,
vocaluxeVersionTag: versionTag,
log: logContent,
lastError: "Vocaluxe crashed while the last execution.");
}
#endif
}
// Write new marker
File.WriteAllText(_CrashMarkerFilePath, _CurrentVersion, Encoding.UTF8);
CLogFileRoller.RollLogs(mainLogFilePath, 2);
CLogFileRoller.RollLogs(songLogFilePath, 2);
_MainLog = new LoggerConfiguration()
.MinimumLevel.Is(logLevel.ToSerilogLogLevel())
.Enrich.WithThreadId()
.Enrich.FromLogContext()
.Enrich.WithTimeStampFromStart()
.WriteTo.TextWriter(_MainLogStringWriter,
outputTemplate: _MainLogTemplate)
// Json can be activated by adding "new CompactJsonFormatter()" as first argument
.WriteTo.File(mainLogFilePath,
flushToDiskInterval: TimeSpan.FromSeconds(30),
outputTemplate: _MainLogTemplate)
#if DEBUG
.WriteTo.Console(outputTemplate: _MainLogTemplate)
#endif
.CreateLogger();
_SongLog = new LoggerConfiguration()
.MinimumLevel.Is(logLevel.ToSerilogLogLevel())
.WriteTo.File(songLogFilePath,
flushToDiskInterval: TimeSpan.FromSeconds(60),
outputTemplate: _SongLogTemplate)
#if DEBUG
.WriteTo.Console(outputTemplate: "[SongInfo] " + _SongLogTemplate)
#endif
.CreateLogger();
// Adding first line to log with information about this run
Information("Starting to log",
Params(new { Version = _CurrentVersion },
new { StartDate = DateTime.Now },
new { Id = Guid.NewGuid() }));
}
public static void WriteLine(ELogLevel pLogLevel, string pFormat, params object[] pArgs)
{
string buffer = DateTime.Now.ToString() + " (" + pLogLevel.ToString() + ") " + string.Format(pFormat, pArgs);
lock (sLock) Console.WriteLine(buffer);
}
public static void SetLv(int lv)
{
logLevel = (ELogLevel)lv;
}
// 记录日志(虚函数继承,继承自ILoggingService)
public virtual void DoLog(String kMsg, ELogLevel eLevel, bool bImmediate)
{
LogEvent kLogEvent = new LogEvent(kMsg, DateTime.Now, eLevel);
if (bImmediate)
{
DoLogEvent(kLogEvent);
}
else
{
// 加入队列
Thread.BeginCriticalRegion();
mLogQueue.Enqueue(kLogEvent);
Thread.EndCriticalRegion();
}
}
public void Log(ELogLevel level, string value, string tags = null, string memberName = null, string filePath = null, int lineNumber = 0)
{
Parallel.ForEach(_appenders, item => item.Log(level, value, tags, memberName, filePath, lineNumber));
}
public static void updateLog(string txt, ELogLevel level, ELogType whom)
{
if (level == ELogLevel.Debug && (whom != ELogType.SpeechRecog && whom != ELogType.Net)) return;
if (Form1.server.txtLog.InvokeRequired)
{
Form1.updateLog_Callback d = new updateLog_Callback(updateLog);
Form1.server.Invoke(d, new object[] { txt, level, whom });
}
else
{
System.Diagnostics.Trace.WriteLine(DateTime.Now.ToString("yyMMdd HH:mm:ss: [") +
level.ToString() + "] " +
txt);
Form1.server.txtLog.AppendText(DateTime.Now.ToString("yyMMdd HH:mm:ss: [") +
level.ToString()+"] " +
txt + "\n");
}
}
private ConsoleColor Convert(ELogLevel level)
=> level switch
{
/// <summary>
/// Create a new LogFunction with
/// </summary>
/// <param name="_sink"></param>
/// <param name="_level"></param>
public LogFunction(ILogSink _sink = null, ELogLevel _level = ELogLevel.Debug)
{
Sink = _sink;
Level = _level;
}
private void InsertLog(DateTime startDate, ELogLevel maxLevel, string title, string data)
{
IDataContext c = _dataContext;
IStatementBuilder statement = null;
try
{
BuildInsertQuery(ref statement, startDate, maxLevel, title, data);
statement = _statementBuilder;
c.Execute(statement);
}
catch (Exception e)
{
throw new Exception(
$"[DAL] Query:\"{statement?.ToString() ?? ""}\" Error:\"{e.Message}\" StatckTrace:\"{e.StackTrace}\"");
}
}
public static void Set_Log_Level( ELogLevel log_level )
{
Interlocked.Exchange( ref m_LogLevel, (long) log_level );
}
public static void WriteLog(ProjectSource projectSource, ELogLevel logLevel, String log, Exception exception)
{
WriteLogToDB(projectSource.ToString(), logLevel.ToString(), log, exception);
}
public LogInfo(string message, ELogLevel logLevel)
{
Message = message;
LogLevel = logLevel;
}
/// <summary>
/// 输出日志
/// </summary>
public static void Log(ELogLevel logType, string log)
{
MotionLog.Log(logType, log);
}
public static void Log( ELoggingChannel channel, ELogLevel log_level, string log_text )
{
if ( log_level > Get_Log_Level() || log_level <= ELogLevel.None )
{
return;
}
if ( Frame == null )
{
Frame = new COutboundLogFrame();
}
Frame.Add_Request( new CLogMessageRequest( channel, log_text ) );
}
public static void WriteLog(ProjectSource projectSource, ELogLevel logLevel, String log)
{
WriteLog(projectSource, logLevel, log, null);
}
