public static void WriteLog(LOGTYPE logType, string message)
{
string file = string.Empty;
switch (logType)
{
default:
case LOGTYPE.INFO:
case LOGTYPE.SUCCESS:
file = PathInfo.CombinePath(PathInfo.CurrentLog, DateTime.Now.ToString("yyyyMMddHH")) + "-access.log";
break;
case LOGTYPE.ERROR:
file = PathInfo.CombinePath(PathInfo.CurrentLog, DateTime.Now.ToString("yyyyMMddHH")) + "-error.log";
break;
}
if (!string.IsNullOrEmpty(file))
{
using (StreamWriter writer = new StreamWriter(file, true))
{
writer.WriteLine(string.Format("{0} {1}", DateTime.Now.ToString("u"), message));
}
}
}
/// <summary>
/// @func:将日志根据类型记录入日志池
/// @author:wolan
/// @brief:内部根据enmLogType进行日志内容区分
/// </summary>
/// <param name="logType"></param>
/// <param name="logContent"></param>
public static void Write(LOGTYPE logType, params string[] content)
{
try
{
if ((LogEngine._logType & (int)logType) > 0)
{
StringBuilder logInfo = new StringBuilder(LOG_EACH_MAXLEN + 50);
logInfo.Append(DateTime.Now.ToString("dd HH:mm:ss "));
switch (logType)
{
case LOGTYPE.ERROR:
logInfo.Append("● ");
break;
case LOGTYPE.DEBUG:
logInfo.Append("○ ");
break;
}
foreach (string each in content)
{
logInfo.Append(each);
}
LogEngine._s_logPool.Enqueue(logInfo.ToString());
logInfo.Remove(0, logInfo.Length);
}
}
catch { }
}
public static void LogError(LOGTYPE type, string message, Exception innerException, string projectId)
{
try
{
switch (type)
{
case LOGTYPE.ERROR:
Log.Error(innerException, $"ProjectId:{projectId}, Message:{message}");
break;
case LOGTYPE.INFORMATION:
Log.Information(innerException, $"ProjectId:{projectId}, Message:{message}");
break;
case LOGTYPE.USERINFO:
Log.Information($"[UserInfo] ProjectId:{projectId}, Message:(\"{message}\")");
break;
case LOGTYPE.WARNING:
Log.Warning(innerException, $"ProjectId:{projectId}, Message:{message}");
break;
case LOGTYPE.DEBUG:
Log.Debug(innerException, $"ProjectId:{projectId}, Message:{message}");
break;
default:
break;
}
}
catch (Exception ex)
{
}
}
public static BaseResultInfo FileToNewDB(string fileName, LOGTYPE logType, bool isUnified)
{
SiteLogger.ILogger logger = SiteLogger.LoggingFactory.GetLogger;
List <string> file = LogReader.LogFileReader.ReadFile(fileName);
if (isUnified)
{
file = LogReader.LogFileReader.UnifiedLogLines(file);
}
List <LogItem> items = LogReader.LogFileReader.LinesToLogs(file.ToArray(), logType);
LogItemRepository repository = new LogItemRepository();
BaseResultInfo res = repository.GetLastLogItem(logType.ToString(), null);
LogItem last = res.GetResult <LogItem>();
int itemsSentToDB = items.Count;
LogItem lastFound = last == null? null: items.FirstOrDefault(l => l.InsertDate == last.InsertDate);
if (lastFound == null)
{
res = repository.InsertLogItem(items);
}
else
{
List <LogItem> itemsToSend = items.FindAll(l => l.Index > lastFound.Index);
itemsSentToDB = itemsToSend.Count;
res = repository.InsertLogItem(itemsToSend);
}
logger.Debug(string.Format("FILE NAME = {0} , TOTAL ITEMS = {1} , ITEM TRY INSERT = {2}, TOTAL SUCCESS = {3}, TOTAL FAILD = {4}", fileName, items.Count, itemsSentToDB, res.ReturnValue, itemsSentToDB - res.ReturnValue));
return(res);
}
/// <summary>
/// LOG를 기록하기 위한 함수
/// </summary>
/// <param name="_LOGTYPE">LOGTYPE[ENUM]</param>
/// <param name="_DATA">LOG VALUE</param>
/// <param name="_ONLY_UI">Log Display 처리 유무</param>
/// <param name="_FILE_WRITE">File Write 유무</param>
static public void SetLOG(LOGTYPE _LOGTYPE, string _DATA, bool _ONLY_UI = true, bool _FILE_WRITE = true)
{
clsLOGMsg clsLOGMsg = new clsLOGMsg
{
LogType = _LOGTYPE.ToString(),
EventTime = "[" + String.Format("{0:HH:mm:ss.fff}" + "]\t", DateTime.Now).Trim(),
LOGDATA = _DATA.Trim()
};
try
{
if (_FILE_WRITE)
{
//File Write Queue 에 적재
lock (Queue_LOG.SyncRoot)
{
Queue_LOG.Enqueue(clsLOGMsg); //LOG File Save 용
}
}
if (_ONLY_UI)
{
if (OnLOG_VIEW != null)
{
OnLOG_VIEW(_LOGTYPE, _DATA);
}
}
clsLOGMsg = null;
}
catch
{
}
}
/// <summary>
/// 自定义添加日志
/// </summary>
/// <param name="logtype">日志类型：</param>
/// <param name="logid">日志ID</param>
/// <param name="logobject">日志对象</param>
/// <param name="logsubject">日志主题</param>
/// <param name="logcontent">日志内容</param>
/// <param name="key01">保留字段1</param>
/// <param name="key02">保留字段2</param>
/// <param name="key03">保留字段3</param>
/// <param name="key04">保留字段4</param>
/// <param name="key05">保留字段5</param>
public static void LogAdd(LOGTYPE logtype, String logid, String logobject, String logsubject,
String logcontent, String key01 = "",
String key02 = "", String key03 = "",
String key04 = "", String key05 = "")
{
LOG.LogAdd(logtype, logid, logobject, logsubject, logcontent, key01, key02, key03, key04, key05);
}
public static BaseResultInfo GetLastItem(LOGTYPE logType, string server)
{
LogItemRepository repository = new LogItemRepository();
BaseResultInfo res = repository.GetLastLogItem(logType.ToString(), server);
return(res);
}
public void WriteBytesLog(string head, byte[] bts, int offset, int count, LOGTYPE logTYPE = LOGTYPE.DEBUG)
{
if (Config.ShowNetLog)
{
Log.WriteLog4(head + ByteHelper.BytesToHexString(bts, offset, count, Config.HexAddSpace), LOGTYPE.DEBUG);
}
}
public void WriteLog(string log, LOGTYPE logTYPE = LOGTYPE.DEBUG)
{
if (Config.ShowNetLog)
{
Log.WriteLog4(log, logTYPE);
}
}
public static void Print(object stdout, LOGTYPE stdtype = LOGTYPE.INFO, string LineTerminator = "")
{
if (LineTerminator == "")
{
LineTerminator = System.Environment.NewLine;
}
string Prepend = "";
switch (stdtype)
{
case LOGTYPE.INFO:
Prepend = "[INFO] ";
//log.AppendLine("[INFO]" + stdout.ToString());
break;
case LOGTYPE.WARNING:
Prepend = "[WARNING] ";
//log.AppendLine("[WARNING]" + stdout.ToString());
break;
case LOGTYPE.ERROR:
Prepend = "[ERROR] ";
//log.AppendLine("[ERROR]" + stdout.ToString());
break;
}
DebugWindow.AppendLog(Prepend + stdout.ToString() + LineTerminator);
}
public void LogManagerLogging(LOGTYPE type, String text)
{
Channel.Instance.logProxy.LogMessage(type, text);
mainWindowViewModel.Logging.Add(new ClientLog()
{
Type = type.ToString(), Text = text
});
}
public void Log(LOGTYPE Type, string sData)
{
if (Type > m_Level)
return;
// Do some stuff that always applies
sData = GetDateTime() + sData;
System.Diagnostics.Debug.WriteLine(m_sFileName + ": " + sData);
LogToFile(Type, sData);
}
public void Write(LOGTYPE type, string value)
{
string log = string.Format("[{0:12}] ({1}) {2}",
DateTime.Now.ToString("hh:mm:ss.fff"), type.ToString(), value);
sw.WriteLine(log);
if (Properties.Settings.Default.logFormEnabled)
{
logList[0].AppendText(string.Format("{0}" + Environment.NewLine, log));
logList[(int)type].AppendText(string.Format("{0}" + Environment.NewLine, log));
}
}
public void Log(LOGTYPE Type, string sData)
{
if (Type > m_Level)
{
return;
}
// Do some stuff that always applies
sData = GetDateTime() + sData;
System.Diagnostics.Debug.WriteLine(m_sFileName + ": " + sData);
LogToFile(Type, sData);
}
public static BaseResultInfo FileToDB(string fileName, LOGTYPE logType, bool isUnified)
{
List <string> file = LogReader.LogFileReader.ReadFile(fileName);
if (isUnified)
{
file = LogReader.LogFileReader.UnifiedLogLines(file);
}
List <LogItem> items = LogReader.LogFileReader.LinesToLogs(file.ToArray(), logType);
LogItemRepository repository = new LogItemRepository();
BaseResultInfo res = repository.InsertLogItem(items);
return(res);
}
public void LogWrite(LOGTYPE type, string str)
{
string FilePath = Environment.CurrentDirectory + @"\Log\Log_" + type.ToString() + "_" + DateTime.Today.ToString("yyyyMMdd") + ".log";
string DirPath = Environment.CurrentDirectory + @"\Log";
string temp;
if (mSaveLogfile != true)
{
temp = string.Format("[{0}] {1}", DateTime.Now, str);
Console.WriteLine(temp);
return;
}
else
{
temp = string.Format("[{0}] {1}", DateTime.Now, str);
}
DirectoryInfo di = new DirectoryInfo(DirPath);
FileInfo fi = new FileInfo(FilePath);
try
{
if (!di.Exists)
{
Directory.CreateDirectory(DirPath);
}
if (!fi.Exists)
{
using (StreamWriter sw = new StreamWriter(FilePath))
{
temp = string.Format("[{0}] {1}", DateTime.Now, str);
sw.WriteLine(temp);
sw.Close();
}
}
else
{
using (StreamWriter sw = File.AppendText(FilePath))
{
temp = string.Format("[{0}] {1}", DateTime.Now, str);
sw.WriteLine(temp);
sw.Close();
}
}
}
catch (Exception e)
{
}
}
public static List <LogItem> LinesToLogs(string[] lines, LOGTYPE logType)
{
List <LogItem> items = new List <LogItem>();
for (int i = 0; i < lines.Length; i++)
{
var item = lines[i];
LogItem logItem = ExtractLogItem(item, i, logType);
if (logItem != null)
{
items.Add(logItem);
}
}
return(items);
}
// File version
private void LogToFile(LOGTYPE Type, string sData)
{
switch (Type)
{
case LOGTYPE.INFO:
m_ILog.Info(sData);
break;
case LOGTYPE.DEBUG:
m_ILog.Debug(sData);
break;
case LOGTYPE.ERROR:
m_ILog.Error(sData);
break;
}
}
public static LogItem ExtractLogItem(string line, int index, LOGTYPE logType)
{
string[] lineSplited = line.Split('¡');
LogItem i = new LogItem();
switch (logType)
{
case LOGTYPE.Info:
break;
case LOGTYPE.Debug:
break;
case LOGTYPE.Warn:
return(ExtractLogItemWarn(lineSplited, index));
case LOGTYPE.Trace:
return(ExtractLogItemTrace(lineSplited, index));
case LOGTYPE.Error:
return(ExtractLogItemError(lineSplited, index));
case LOGTYPE.Fatal:
return(ExtractLogItemFatal(lineSplited, index));
case LOGTYPE.JSError:
return(ExtractLogItemJSTrace(lineSplited, index));
case LOGTYPE.DBTrace:
return(ExtractLogItemDBTrace(lineSplited, index));
case LOGTYPE.Test:
break;
case LOGTYPE.Report:
break;
case LOGTYPE.Cache:
break;
default:
break;
}
return(i);
}
/// <summary>
/// UI 출력용 LOG Event 처리 함수
/// </summary>
/// <param name="TYPE">LOG Type</param>
/// <param name="DATA">DATA</param>
private void LOG_EVENT(LOGTYPE TYPE, string DATA)
{
string LogMessage = string.Empty;
string Log_Event = string.Empty;
try
{
//Log_Event = ("TYPE:" + TYPE.ToString() + ", DATA:" + DATA);
LogMessage = "[" + String.Format("{0:HH:mm:ss.fff}" + "] ", DateTime.Now) + DATA.ToString();
_queLog.Enqueue(LogMessage);
}
catch (Exception ex)
{
clsLOG.SetLOG(LOGTYPE.SYSTEMERROR, ex.ToString());
}
}
/// <summary>
/// 添加日志
/// </summary>
/// <param name="logtype">日志类型</param>
/// <param name="logid">日志ID</param>
/// <param name="logobject">日志对象</param>
/// <param name="logsubject">日志主题</param>
/// <param name="logcontent">日志内容</param>
/// <param name="key01">保留字段1</param>
/// <param name="key02">保留字段2</param>
/// <param name="key03">保留字段3</param>
/// <param name="key04">保留字段4</param>
/// <param name="key05">保留字段5</param>
public void LogAdd(LOGTYPE logtype, String logid, String logobject, String logsubject,
String logcontent, String key01 = "",
String key02 = "", String key03 = "",
String key04 = "", String key05 = "")
{
LogData data = new LogData();
data.LogType = logtype;
data.LogID = logid;
data.LogObject = logobject;
data.LogSubject = logsubject;
data.LogContent = logcontent;
data.LogTime = System.DateTime.Now;
data.LogKey01 = key01;
data.LogKey02 = key02;
data.LogKey03 = key03;
data.LogKey04 = key04;
data.LogKey05 = key05;
_logList_temp.Add(data);
}
public static bool IsUnified(LOGTYPE logType)
{
switch (logType)
{
case LOGTYPE.Trace:
case LOGTYPE.DBTrace:
case LOGTYPE.Error:
case LOGTYPE.Fatal:
return(true);
case LOGTYPE.Info:
case LOGTYPE.Debug:
case LOGTYPE.Warn:
case LOGTYPE.JSError:
case LOGTYPE.Test:
case LOGTYPE.Report:
case LOGTYPE.Cache:
return(false);
default:
return(true);
}
}
public bool LogMessage(LOGTYPE logType, String message)
{
try
{
switch (logType)
{
case LOGTYPE.DEBUG:
log.Debug("CLIENT side - " + message);
break;
case LOGTYPE.INFO:
log.Info("CLIENT side - " + message);
break;
case LOGTYPE.WARN:
log.Warn("CLIENT side - " + message);
break;
case LOGTYPE.ERROR:
log.Error("CLIENT side - " + message);
break;
case LOGTYPE.FATAL:
log.Fatal("CLIENT side - " + message);
break;
default:
break;
}
return(true);
}
catch
{
return(false);
}
}
public static void WriteLog(LOGTYPE logType, string message)
{
string file = string.Empty;
switch (logType)
{
default:
case LOGTYPE.INFO:
case LOGTYPE.SUCCESS:
file = PathInfo.CombinePath(PathInfo.CurrentLog, DateTime.Now.ToString("yyyyMMddHH")) + "-access.log";
break;
case LOGTYPE.ERROR:
file = PathInfo.CombinePath(PathInfo.CurrentLog, DateTime.Now.ToString("yyyyMMddHH")) + "-error.log";
break;
}
if (!string.IsNullOrEmpty(file))
{
using (StreamWriter writer = new StreamWriter(file, true))
{
writer.WriteLine(string.Format("{0} {1}", DateTime.Now.ToString("u"), message));
}
}
}
public static void WriteLog(LOGTYPE type, Object message)
{
Console.WriteLine(message);
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="type">ログの種類</param>
/// <param name="message">ログとして残す文字列</param>
public Log(LOGTYPE type, string message)
{
this.type = type;
this.message = message;
}
// Event Log version
private void LogToStore(LOGTYPE Type, string sData)
{
lock (m_LogRS)
{
SequenceNumber Last = SequenceNumber.Invalid;
Last = m_LogRS.Append(CreateData(sData), SequenceNumber.Invalid, SequenceNumber.Invalid, RecordAppendOptions.ForceFlush);
}
}
// File version
private void LogToFile(LOGTYPE Type, string sData)
{
byte[] bBuf = ASCIIEncoding.Default.GetBytes(sData);
lock (m_LogFS)
{
m_LogFS.Write(bBuf, 0, bBuf.Length);
m_LogFS.Write(m_bNewnline, 0, m_bNewnline.Length);
m_LogFS.Flush();
}
}
public void SetLogging(LOGTYPE Level)
{
m_Level = Level;
}
// File version
private void LogToFile(LOGTYPE Type, string sData)
{
switch (Type)
{
case LOGTYPE.INFO:
m_ILog.Info(sData);
break;
case LOGTYPE.DEBUG:
m_ILog.Debug(sData);
break;
case LOGTYPE.ERROR:
m_ILog.Error(sData);
break;
}
}
public void SetLogging(LOGTYPE Level)
{
m_Level = Level;
}
public static void Write(LOGTYPE logType, StringBuilder content)
{
Write(logType, content.ToString());
content.Remove(0, content.Length);
}
/// <summary>
/// [T]Message の形式でログを逆順で吐き出します
/// フィルターを掛けて表示
/// </summary>
/// <param name="filter">指定したレベル未満のログを非表示にします</param>
/// <param name="Exclude">Trueを指定した場合、filter以外のログを非表示にします。</param>
public string ToStringReverse(LOGTYPE filter, bool Exclude = false)
{
LogDat.Reverse();
string ret = "";
foreach(var it in LogDat) {
if(Exclude) {
if(it.GetLogType() != filter) {
continue;
}
} else {
if(it.GetLogType() < filter) {
continue;
}
}
ret += it.ToString();
}
LogDat.Reverse();
return ret;
}
