private static void ProcessLog(ELogType type, string message, bool rcon = true) { AsyncLoggerQueue.Current.Enqueue(new LogEntry() { Severity = type, Message = message, RCON = rcon }); }
public static void End(ELogType log_type, string time_check_name) { int elapsed_time = Environment.TickCount - check_start_time; object[] arg = { time_check_name, elapsed_time, ID }; CDebugLog.LogFormat(log_type, "{0} elapsed_time = {1}ms [ID:{2}]", arg); }
/// <summary> /// 把所有的文件开关 /// </summary> /// <param name="eLogType"></param> /// <param name="bSwitch"></param> public void ChangeAllFileSwitch(ELogType eLogType, bool bSwitch) { if (this.mConfig == null) return; this.mConfig.ChangeAllFileSwitch(eLogType, bSwitch); }
internal LoggerEntry(string msg, ELogType level, uint line, string file) { Message = msg; Level = level; Line = line; File = file; }
static string GetLogTypeStr(ELogType Type) { switch (Type) { case ELogType.AStar: return("[AStar]"); case ELogType.Battle: return("[Battle]"); case ELogType.Character: return("[Character]"); case ELogType.GameMode: return("[GameMode]"); case ELogType.MapGenerator: return("[MapGenerator]"); case ELogType.MapObject: return("[MapObject]"); case ELogType.Animation: return("[Animation]"); } ; return("[Default]"); }
public void AddLogEntry(Exception aException, ELogType aELogType, string aSystemName) { var _SErrorTime = DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToLongTimeString(); if (!fLogPath.EndsWith("\\")) { fLogPath = fLogPath + "\\"; } using (var _StreamWriter = new StreamWriter(fLogPath + aSystemName + ".txt", true)) { string _LogFormat = "System Error: " + aException.Message; var ToEvalException = aException; while (ToEvalException.GetInnerExceptionMessage() != null) { if (!ToEvalException.Message.Contains("See the inner exception for details")) { _LogFormat += "\n" + ToEvalException.GetInnerExceptionMessage(); ToEvalException = ToEvalException.InnerException; } } _LogFormat += "\nDate: " + _SErrorTime; _StreamWriter.WriteLine( "--------------------------------------------------------------------------------"); _StreamWriter.WriteLine(_LogFormat); _StreamWriter.WriteLine( "--------------------------------------------------------------------------------"); } }
public static void Log(int siteId, int channelId, int contentID, string logType, string administratorName, int departmentId) { var logInfo = new LogInfo(0, siteId, channelId, contentID, departmentId, administratorName, logType, Utils.GetIpAddress(), DateTime.Now, string.Empty); var departmentName = DepartmentManager.GetDepartmentName(departmentId); ELogType eLogType = ELogTypeUtils.GetEnumType(logType); if (eLogType == ELogType.Accept) { logInfo.Summary = $"{departmentName}({administratorName})受理办件"; } else if (eLogType == ELogType.Deny) { logInfo.Summary = $"{departmentName}({administratorName})拒绝受理办件"; } else if (eLogType == ELogType.Reply) { logInfo.Summary = $"{departmentName}({administratorName})回复办件"; } else if (eLogType == ELogType.Comment) { logInfo.Summary = $"{departmentName}({administratorName})批示办件"; } else if (eLogType == ELogType.Redo) { logInfo.Summary = $"{departmentName}({administratorName})要求返工"; } else if (eLogType == ELogType.Check) { logInfo.Summary = $"{departmentName}({administratorName})审核通过"; } LogDao.Insert(logInfo); }
private static void ProcessInternalLog(ELogType type, string message, ConsoleColor color = ConsoleColor.White) { // OPENMOD PATCH: Use SeriLog switch (type) { case ELogType.Info: StandardLogger?.LogInformation(message); break; case ELogType.Error: StandardLogger?.LogError(message); break; case ELogType.Exception: StandardLogger?.LogError(message); break; case ELogType.Warning: StandardLogger?.LogWarning(message); break; case ELogType.Undefined: StandardLogger?.LogInformation(message); break; default: throw new ArgumentOutOfRangeException(nameof(type), type, null); } // END OPENMOD PATCH: Use SeriLog ProcessLog(type, message); }
/// <summary> /// 是否打开了开关 /// </summary> /// <param name="eLogType"></param> /// <returns></returns> public bool IsConsoleSwitch(ELogType eLogType) { if (!this.mConsoleSwitch.ContainsKey(eLogType)) return true; return this.mConsoleSwitch[eLogType]; }
/// <summary> /// 修改开关 /// </summary> /// <param name="eLogType"></param> /// <param name="bSwitch"></param> public void ChangeFileSwitch(ELogType eLogType, bool bSwitch) { if (!this.mFileSwitch.ContainsKey(eLogType)) return; this.mFileSwitch[eLogType] = bSwitch; }
public override void ActionPrintLog(ELogType type, object message) { if (!IsDebug) { return; } switch (type) { case ELogType.Info: UnityEngine.Debug.Log(message); break; case ELogType.Warning: UnityEngine.Debug.LogWarning(message); break; case ELogType.Error: UnityEngine.Debug.LogError(message); break; case ELogType.Exception: UnityEngine.Debug.LogException((Exception)message); break; } }
/// <summary> /// Запись ошибки в лог-файл /// </summary> /// <param name="exception">Ошибка</param> /// <param name="message">Текст сообщения</param> /// <param name="type">Тип сообщения</param> public static void WriteException(Exception exception, ELogType type, string message = null) { //если логгер выключен, то выходим if (!_loggerEnabled) { return; } //если логгер включен, то пишем в лог-файл switch (type) { case ELogType.Error: CurrentLogger.Error(exception, message); break; case ELogType.Warn: CurrentLogger.Warn(exception, message); break; case ELogType.Info: CurrentLogger.Info(exception, message); break; case ELogType.Debug: CurrentLogger.Debug(exception, message); break; case ELogType.Fatal: CurrentLogger.Fatal(exception, message); break; default: throw new ArgumentOutOfRangeException(nameof(type), type, null); } }
private void CLog_DidLog(String txt, ELogType logType) { Color logColor; switch (logType) { case ELogType.CRITICAL_ERROR: logColor = Color.Red; break; case ELogType.GAME_EVENT: logColor = Color.Cyan; break; case ELogType.NETWORK: logColor = Color.Azure; break; default: logColor = Color.GreenYellow; break; } rtbMainLog.SelectionColor = Color.Yellow; rtbMainLog.AppendText(String.Format("[{0:D02}:{1:D02}:{2:D02}] ", DateTime.Now.Hour, DateTime.Now.Minute, DateTime.Now.Second)); rtbMainLog.SelectionColor = logColor; rtbMainLog.AppendText(txt + "\n"); }
private static void ExportLog(ELogType LogType, string Message) { switch (LogType) { case ELogType.Fatal: LogManager.GetLogger(LogType.ToString()).Fatal(Message); break; case ELogType.Error: LogManager.GetLogger(LogType.ToString()).Error(Message); break; case ELogType.Warn: LogManager.GetLogger(LogType.ToString()).Warn(Message); break; case ELogType.Debug: LogManager.GetLogger(LogType.ToString()).Debug(Message); break; case ELogType.Info: LogManager.GetLogger(LogType.ToString()).Info(Message); break; default: LogManager.GetLogger(typeof(Logging)).Debug(Message); break; } }
public LogObject(string message, ELogType logType, Dictionary <string, string> parameters = null, string souce = null) : this() { Message = message; Parameters = parameters; LogType = logType; Source = souce; }
public static void Log(ELogType logType, string message) { if (_callback != null) { _callback.Invoke(logType, message); } }
public LogProcessor(string name, string group) { string path = Path.Combine(Path.Combine("log", fFolderMonth), group); Directory.CreateDirectory(path); fLocation = Path.Combine(path, name); //Allow us to set both kLogLeveXXX and xxx as log levels... //This is mostly so configuration files will look nicer :) string loglev = Configuration.GetString("log_level", "kLogWarning"); if (Enum.IsDefined(typeof(ELogType), loglev)) fMinLevel = (ELogType)Enum.Parse(typeof(ELogType), loglev); else if (loglev.ToLower() == "error") fMinLevel = ELogType.kLogError; else if (loglev.ToLower() == "warn") fMinLevel = ELogType.kLogWarning; else if (loglev.ToLower() == "info") fMinLevel = ELogType.kLogInfo; else if (loglev.ToLower() == "debug") fMinLevel = ELogType.kLogDebug; else if (loglev.ToLower() == "verbose") fMinLevel = ELogType.kLogVerbose; else { fMinLevel = ELogType.kLogWarning; Error(String.Format("MUd.conf has invalid log_level \"{0}\"", loglev)); } }
/// <summary> /// 输出日志 /// </summary> public static void Log(ELogType logType, string log) { if (_callback != null) { _callback.Invoke(logType, log); } }
public void CLog(ELogType logType, string message, ConsoleColor color = ConsoleColor.White, bool newLine = true) { string text = PrefixMsg(message); Log(logType, text, null); T4GCLog(logType, text, color, newLine); }
public void Log(ELogType type, object log) { if (IsLogTypeAllowed(type)) { LogHandler.Log(type, log.ToString()); } }
/// <summary> /// 是否写文件日志 /// </summary> /// <param name="strSystemMark"></param> /// <returns></returns> protected bool IsWriteFile(string strSystemMark, ELogType eLogType) { if (null == this.mConfig) return true; return this.mConfig.IsWriteFile(strSystemMark, eLogType); }
public static void AddLog(ELogType type, string function, string message, DateTime time) { if (EventNewLog != null) { EventNewLog(message, time); } }
public void Log(ELogType t, string format, params object[] args) { string strData = string.Format(format, args); string strAppend = string.Format("[{0}] {1}", t.ToString(), strData + Environment.NewLine); int oldLen = LogRichTextBox.Text.Length; LogRichTextBox.AppendText(strAppend); LogRichTextBox.Select(oldLen, strAppend.Length); switch (t) { case ELogType.INFO: case ELogType.DEBUG: LogRichTextBox.SelectionColor = Color.Black; break; case ELogType.ERROR: case ELogType.FATAL: LogRichTextBox.SelectionColor = Color.Red; break; case ELogType.WARN: LogRichTextBox.SelectionColor = Color.Blue; break; default: break; } LogRichTextBox.Select(LogRichTextBox.Text.Length, 0); LogRichTextBox.SelectionColor = Color.Black; }
public LogEntry(string message, string targetFile, ELogType severity = ELogType.INFO) { Severity = severity; Message = message; TargetFile = targetFile; Timestamp = DateTime.Now; }
/// <summary> /// 记录日志 /// </summary> /// <param name="logType">日志类型</param> /// <param name="priority">日志级别</param> /// <param name="ex">异常</param> /// <param name="message">错误消息</param> public static void SaveLog(ELogType logType, ELogPriority priority, string nameSpace, string message, string desc) { switch (priority) { case ELogPriority.Trace: logger.Trace(const_Error, logType.ToString(), nameSpace, message, desc); break; case ELogPriority.Debug: logger.Debug(const_Error, logType.ToString(), nameSpace, message, desc); break; case ELogPriority.Inf: logger.Info(const_Error, logType.ToString(), nameSpace, message, desc); break; case ELogPriority.Warn: logger.Warn(const_Error, logType.ToString(), nameSpace, message, desc); break; case ELogPriority.Error: logger.Error(const_Error, logType.ToString(), nameSpace, message, desc); break; case ELogPriority.Fatal: logger.Fatal(const_Error, logType.ToString(), nameSpace, message, desc); break; } }
private string LogTypeName(ELogType type) { switch (type) { case ELogType.Critical: return("Critical"); case ELogType.Error: return("Error"); case ELogType.Warning: return("Warning"); case ELogType.Info: return("Info"); case ELogType.Verbose: return("Verbose"); case ELogType.Debug: return("Debug"); default: return(string.Format("<value={0}>", (int)type)); } }
static public void DisableLog(ELogType eType) { TLog[(int)eType] = EmptyLog; TLogFormat[(int)eType] = EmptyLogFormat; TLogWarning[(int)eType] = EmptyLog; TLogError[(int)eType] = EmptyLog; }
public static void NowProcess() { //获取当前进程 string path = LogPrepare.GetLogPath(); System.Text.StringBuilder sb = new System.Text.StringBuilder(); Process cur = Process.GetCurrentProcess(); string pn = cur.ProcessName;//当前运行进程 w3wp/iisexpress sb.AppendLine("ProcessName=" + pn); string site = cur.Site != null? cur.Site.Name:string.Empty; sb.AppendLine("Site=" + site); string maiche = cur.MachineName; sb.AppendLine("MachineName{.=local}=" + maiche); string window = cur.MainWindowTitle; sb.AppendLine("MainWindowTitle=" + window); string poolName = Environment.GetEnvironmentVariable("APP_POOL_ID", EnvironmentVariableTarget.Process);//应用程序池名称 HrApp/Clr4IntegratedAppPool sb.AppendLine("APP_POOL_ID=" + poolName); // string json = Newtonsoft.Json.JsonConvert.SerializeObject(cur); ELogType lt = ELogType.BackgroundProcess; LoggerWriter.CreateLogFile(sb.ToString(), path, lt, LogPrepare.GetLogName(lt), true); }
static void EveryDayDo() { string path = LogPrepare.GetLogPath(); try { StringBuilder text = new StringBuilder(); text.AppendFormat("Background process【{0}】,index={1} ,time ={2}", GetStartWebOfProcess(), BackRunNumber, DateTime.Now.ToString(Common.Data.CommonFormat.DateTimeFormat)); ELogType el = ELogType.BackgroundProcess; LoggerWriter.CreateLogFile(text.ToString(), path, el, LogPrepare.GetLogName(el), true); DoSomeInitEventFacadeFactory dosome = new DoSomeInitEventFacadeFactory(); dosome.ActiveEmailSmtp(); //读取xml配置 string xmlFile = InitAppSetting.DefaultLogPath + "/XmlConfig/AppConfig.xml"; //执行成功时间写入到xml中 UiCfgNode.NodeKeyValue = typeof(AppEmailAccount).Name; AppEmailAccount appEmail = xmlFile.GetNodeSpecialeAttribute <AppEmailAccount>(UiCfgNode, nodeCfgFormat); appEmail.EmailLastActiveTime = DateTime.Now.ToString(Common.Data.CommonFormat.DateTimeFormat); appEmail.EmailAccount = InitAppSetting.AppSettingItemsInDB[EAppSetting.SystemEmailSendBy.ToString()]; xmlFile.UpdateXmlNode(appEmail, UiCfgNode, nodeCfgFormat); LoggerWriter.CreateLogFile(Newtonsoft.Json.JsonConvert.SerializeObject(appEmail), path, el, LogPrepare.GetLogName(el), false); } catch (Exception ex) { ELogType el = ELogType.BackgroundProcess; LoggerWriter.CreateLogFile("【Error】" + ex.Message.ToString(), path, el, LogPrepare.GetLogName(el), true); } }
protected void Application_Start() { AreaRegistration.RegisterAllAreas(); WebApiConfig.Register(GlobalConfiguration.Configuration); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); GlobalNotifyHandle handle = new GlobalNotifyHandle(); string format = Common.Data.CommonFormat.DateTimeMilFormat; string time = DateTime.Now.ToString(format); string path = LogPrepare.GetLogPath(); ELogType heart = ELogType.DebugData; string file = LogPrepare.GetLogName(heart); LoggerWriter.CreateLogFile(string.Format("begin init Data {0}", time), path, heart, file, true); Domain.GlobalModel.AppRunData.InitAppData(); time = DateTime.Now.ToString(format); LoggerWriter.CreateLogFile(string.Format("end init Data {0}", time), path, heart, file, true); Domain.GlobalModel.AppRunData.AppName = this.GetType().Name; time = DateTime.Now.ToString(format); LoggerWriter.CreateLogFile(string.Format("begin init ioc {0}", time), path, heart, file, true); IocMvcFactoryHelper.GetIocDict(true); time = DateTime.Now.ToString(format); LoggerWriter.CreateLogFile(string.Format("end init ioc {0}", time), path, heart, file, true); InitAppSetting.AppSettingItemsInDB = RefreshAppSetting.QueryAllAppSetting(IocMvcFactoryHelper.GetInterface <IAppSettingService>()); RefreshAppSetting.RefreshFileVersion(); AppProcess.GlobalXmlManage(); AppProcess.CallTodo(); }
public static void Log(ELogType logType, string format, params object[] args) { if (_callback != null) { string message = string.Format(format, args); _callback.Invoke(logType, message); } }
public CLogComponent(ELogType type) { logType = type; if (_logObject != null) { _logManager = _logObject.GetComponent <CLogManager>(); } }
/// <summary> /// Exception /// </summary> /// <param name="exp">Exception</param> /// <param name="LogType">log type</param> public static void SaveLog(Exception exp, ELogType LogType) { string strErrMsg = exp.Message + "\r\n"; strErrMsg = strErrMsg + "Source:" + exp.Source.ToString() + "\r\n"; strErrMsg = strErrMsg + "StackTrace:" + exp.StackTrace; ExportLog(LogType, strErrMsg); }
public void Log(Type type, ELogType logType, ELogLevel levelType, object data, Exception exception) { string className = type.FullName; string level = GetLevel(levelType); Save(Newtonsoft.Json.JsonConvert.SerializeObject(new { Type = GetLogType(logType), Level = level, Class = className, Method = new { exception.TargetSite.Name, exception.TargetSite.DeclaringType }, exception.StackTrace, exception.Message, Time = GetCurrentDateTime(), Data = data }), levelType); }
public void Log(Type type, ELogType logType, ELogLevel levelType, object data, string method) { string className = type.FullName; string level = GetLevel(levelType); Save(Newtonsoft.Json.JsonConvert.SerializeObject(new { Type = GetLogType(logType), Level = level, Class = className, Method = method, Time = GetCurrentDateTime(), Data = data }), levelType); }
public static void LogFormat(ELogType Type, string format, params object[] args) { if (bEnableLog[(int)Type] == true) { string TypeStr = GetLogTypeStr(Type); format = TypeStr + " " + format; Debug.LogFormat(format, args); } }
protected static string TypeLog(string sIn, ELogType eType) { #if UNITY_EDITOR int iType = (int)eType; string sOut = string.Format("<color=#{0}>{1}</color><b>{2}</b>", colors[iType], prefixstring[iType], sIn); return sOut; #else return sIn; #endif }
public static void Create(string pMessage, ELogType pType, ELogCategory pCategory) { if (UnityEngine.Debug.isDebugBuild && !string.IsNullOrEmpty(pMessage)) { var creator = new LogCreator(); var entry = creator.Create(pMessage, pType, pCategory); ShowLog(entry); ServiceManager.Instance.GetService<LogService>().AddLogEntry(entry); } }
internal LogEntry Create(string pMessage, ELogType pType, ELogCategory pCategory) { mEntry = new LogEntry() { LogType = pType, Message = pMessage, Time = DateTime.Now, Category = pCategory }; HandleStackTrace(); return mEntry; }
public void DumpToLog(string dump, ELogType level) { if (level <= fMinLevel) DumpToLog(dump); }
public LogEventArgs(ELogType type, string message) { EventTime = DateTime.Now; Type = type; Message = message; }
private static void ProcessInternalLog(ELogType type, string message, bool doWriteToConsole = true) { if (doWriteToConsole) { if (type == ELogType.Error || type == ELogType.Exception) { // Debug.LogError(message); writeToConsole(message, ConsoleColor.Red); } else if (type == ELogType.Warning) { // Debug.LogWarning(message); writeToConsole(message, ConsoleColor.Yellow); } else { //Debug.Log(message); writeToConsole(message, ConsoleColor.White); } ProcessLog(type, message); } }
private static void ProcessLog(ELogType type, string message,bool rcon = true) { AsyncLoggerQueue.Current.Enqueue(new LogEntry() { Severity = type, Message = message, RCON = rcon }); }
// 输出日志 public static void WriteLog(ELogType type, string msg) { using (StreamWriter souts = new StreamWriter(LogFile, true, Encoding.Unicode)) { try { switch (type) { case ELogType.Info: { souts.WriteLine(string.Format("[Info]: {0}", msg)); } break; case ELogType.Warning: { souts.WriteLine(string.Format("[Warning]: {0}", msg)); } break; case ELogType.Error: { souts.WriteLine(string.Format("[Info]: {0}", msg)); } break; } } catch (Exception) { } } }
public static void Create(string pMessage, ELogType pType) { Create(pMessage, pType, ELogCategory.NONE); }
/// <summary> /// 构造函数 /// </summary> /// <param name="logType"></param> /// <param name="strContent"></param> public LogContent(ELogType logType, string strSystemMark, string strContent) { LogType = logType; Content = strContent; SystemMark = strSystemMark; }
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"); } }
public String format(ELogType type, String message) { String data = default_format; data = data.Replace("{message}", message); data = data.Replace("{level}", type.ToString()); data = data.Replace("{time}", String.Format("{0:HH:mm:ss:fff}",DateTime.Now)); return data; }
public void log(ELogType type, String message) { foreach (ILogger logger in loggers) { logger.log(type, message); } }
public override void log(ELogType type, string message) { if (type < writeLevel) return; if (onLog != null) onLog(type, message); }
public override void log(ELogType type, string message) { if (type < writeLevel) return; Console.WriteLine(base.formatter.format(type, message)); }
internal ErrorSeverityAttribute(ELogType pLogType) { LogType = pLogType; }
public abstract void log(ELogType type, String message);
private string LogTypeName(ELogType type) { switch (type) { case ELogType.Critical: return "Critical"; case ELogType.Error: return "Error"; case ELogType.Warning: return "Warning"; case ELogType.Info: return "Info"; case ELogType.Verbose: return "Verbose"; case ELogType.Debug: return "Debug"; default: return string.Format("<value={0}>", (int) type); } }
public void DumpToLog(string dump, string msg, ELogType level) { if (level <= fMinLevel) { WriteLine(msg, level); DumpToLog(dump); } }
/// <summary> /// 修改控制台日志开关 /// </summary> /// <param name="strSystemMark"></param> /// <param name="eLogType"></param> /// <param name="bSwitch"></param> public void ChangeConsoleSwitch(string strSystemMark, ELogType eLogType, bool bSwitch) { if (this.mConfig == null) return; this.mConfig.ChangeConsoleSwitch(strSystemMark, eLogType, bSwitch); }
public void Log(ELogType type, string format, params object[] args) { Log(type, (format == null) ? null : string.Format(format, args)); }
public void WriteLine(string line, ELogType level) { if (level <= fMinLevel) { string levelstr = "[UNK] "; switch (level) { case ELogType.kLogDebug: levelstr = "[DBG] "; break; case ELogType.kLogError: levelstr = "[ERR] "; break; case ELogType.kLogInfo: levelstr = "[INF] "; break; case ELogType.kLogVerbose: levelstr = "[VBS] "; break; case ELogType.kLogWarning: levelstr = "[WRN] "; break; } IWriteLine(levelstr + line); } }
public void DumpToLog(byte[] dump, string msg, ELogType level) { if (level <= fMinLevel) { WriteLine(msg, level); DumpToLog(BitConverter.ToString(dump).Replace('-', ' ')); } }
public void Log(ELogType type, string message) { WriteEvent(new LogEventArgs(type, message)); }