/// <summary>
/// Write a Log Information into File
/// </summary>
/// <param name="Control">Object fired Log</param>
/// <param name="LogType">Log Level Type</param>
/// <param name="LogText">Log Text with a String.Format options</param>
/// <param name="LogOptionsText">Optional String format addings information</param>
public static void WriteLog(object Control, LogTypeEnum LogType, string LogText, params object[] LogOptionsText)
{
lock (codaLog)
{
codaLog.Add(new LogClass()
{
_Control = Control,
_LogType = LogType,
_LogText = LogText,
_LogOptionsText = LogOptionsText
});
if (codaLog.Count > 1)
{
return;
}
}
lock (lockObj)
{
List <LogClass> coda;
lock (codaLog)
{
coda = codaLog.Select(item => (LogClass)item.Clone()).ToList();
codaLog.Clear();
}
Write(coda);
}
}
public void AddResponseLog(
LogTypeEnum parmLogType,
string parmLogSenderFunc,
int?parmLogUser,
string parmLogMessage,
string parmRequestData,
long parmRequestDate,
string parmResponseData,
long parmResponseDate,
Exception parmException = null
)
{
var entity = new LogEntity
{
LogUser = parmLogUser,
LogType = (int)parmLogType,
RequestData = parmRequestData,
RequestDate = parmRequestDate,
ResponseData = parmResponseData,
ResponseDate = parmResponseDate,
LogDate = GetDate,
LogMessage = parmLogMessage,
LogSender = parmLogSenderFunc,
LogException = (parmException != null) ? parmException.StackTrace : string.Empty
};
InsertLog(entity);
}
private static EventLogEntryType GetEntryType(LogTypeEnum pEnmType)
{
switch (pEnmType)
{
case LogTypeEnum.SUCCESS:
return(EventLogEntryType.Information);
case LogTypeEnum.WARNING:
return(EventLogEntryType.Warning);
case LogTypeEnum.ERROR:
return(EventLogEntryType.Error);
case LogTypeEnum.EXCEPTION:
return(EventLogEntryType.Error);
case LogTypeEnum.TRACKING:
return(EventLogEntryType.Information);
case LogTypeEnum.PROCESS:
return(EventLogEntryType.Information);
case LogTypeEnum.INFO:
return(EventLogEntryType.Information);
default:
return(EventLogEntryType.Information);
}
}
internal static void InternalLog(LogTypeEnum logType, int operationUserId, string errorMessage, string operationData, int ext1 = 0, int ext2 = 0, string ext3 = null, string ext4 = null)
{
try
{
SysLog log = new SysLog {
ServerId = GetAppSettingAsInt(Config_ServerId),
AppId = GetAppSettingAsInt(Config_AppId),
CreateTime = DateTime.Now,
OperationUserId = operationUserId,
Data = operationData,
Info = errorMessage,
LogType = logType,
Ext1 = ext1,
Ext2 = ext2,
Ext3 = ext3,
Ext4 = ext4
};
LogAsync(log);
}
catch (Exception exception)
{
StringBuilder builder = new StringBuilder(0x400);
builder.Append("写日志失败:").Append("logType=").Append(logType).Append(";operationUserId=").Append(operationUserId).Append(";errorMessage=").Append(errorMessage).Append(";operationData=").Append(operationData).Append(";ext1=").Append(ext1).Append(";ext2=").Append(ext2).Append(";ext3=").Append(ext3).Append(";ext4=").Append(ext4);
EventLogHelper.Error2EventLog(builder.ToString(), exception);
}
}
/// <summary>
/// logs a message to the currently active outputlogger
/// </summary>
/// <param name="message">the message to be logged</param>
/// <param name="elementID">the element ID to associate with the message. Can be used by add-ins when they implement EA_OnOutput...</param>
/// <param name="logType">the type of logging to the logfile</param>
public static void log(string message, int elementID = 0, LogTypeEnum logType = LogTypeEnum.none)
{
if (defaultLogger != null)
{
log(defaultLogger.model, defaultLogger.name, message, elementID, logType);
}
}
internal static void Write(LogTypeEnum logType, string className, string methodName, string logContent)
{
if (SqlDiagnosticSourceEnabled)
{
SqlDiagnosticSource.Write(SqlDiagnosticSourceName, new { LogType = logType, ClassName = className, MethodName = methodName, LogContent = logContent });
}
}
private static ConsoleColor GetConsoleColor(LogTypeEnum pEnmType)
{
switch (pEnmType)
{
case LogTypeEnum.SUCCESS:
return(ConsoleColor.Green);
case LogTypeEnum.WARNING:
return(ConsoleColor.DarkYellow);
case LogTypeEnum.ERROR:
return(ConsoleColor.Red);
case LogTypeEnum.EXCEPTION:
return(ConsoleColor.Red);
case LogTypeEnum.TRACKING:
return(ConsoleColor.Gray);
case LogTypeEnum.PROCESS:
return(ConsoleColor.Yellow);
case LogTypeEnum.INFO:
return(ConsoleColor.Gray);
default:
return(ConsoleColor.Gray);
}
}
public void WriteLog(LogTypeEnum logType, string message)
{
switch (logType)
{
case LogTypeEnum.Fatal:
_logTarget.Fatal(message);
break;
case LogTypeEnum.Error:
_logTarget.Error(message);
break;
case LogTypeEnum.Warning:
_logTarget.Warn(message);
break;
case LogTypeEnum.Info:
_logTarget.Info(message);
break;
case LogTypeEnum.Debug:
_logTarget.Debug(message);
break;
}
}
public void WriteLog(LogTypeEnum logType, Func <string> getMessage)
{
switch (logType)
{
case LogTypeEnum.Fatal:
_logTarget.Fatal(getMessage());
break;
case LogTypeEnum.Error:
_logTarget.Error(getMessage());
break;
case LogTypeEnum.Warning:
_logTarget.Warn(getMessage());
break;
case LogTypeEnum.Info:
_logTarget.Info(getMessage());
break;
case LogTypeEnum.Debug:
_logTarget.Debug(getMessage());
break;
}
}
/// <summary>
/// Log custom message
/// </summary>
/// <param name="logType">Error or info</param>
/// <param name="source">Where the message originated</param>
/// <param name="message">The messsage to log</param>
public static void Log(LogTypeEnum logType, string source, string message, bool ignoreRemote = false)
{
try
{
ThreadPool.QueueUserWorkItem(delegate
{
var log = new Log
{
Event = DateTime.Now,
LogTypeId = logType,
Source = source.Ellipse(200 - 5),
Message = message.Ellipse(1500 - 5),
StackTrace = null,
Machine = MachineName.Ellipse(210),
Version = VersionHelper.GetVersionFull()
};
Task.Run(async() => await LogsRepo.Add(log));
if (SendLogToSource && logType != LogTypeEnum.Info && !ignoreRemote)
{
log.Machine += $"@{ExternalIp}";
LogsRepo.RemoteAdd(log);
}
});
}
catch { }
}
/// <summary>
/// Log error from exception with error severity
/// </summary>
/// <param name="e">Exception to log</param>
public static void Log(Exception e, string additionalMessage, LogTypeEnum logType, bool ignoreRemote = false)
{
try
{
ThreadPool.QueueUserWorkItem(delegate
{
var log = new Log
{
Event = DateTime.Now,
LogTypeId = logType,
Source = GetExceptionSource(e).Ellipse(200 - 5),
Message = (additionalMessage + ": " + GetExceptionMessage(e)).Ellipse(1500 - 5),
StackTrace = GetExceptionStackTrace(e).Ellipse(4000 - 5),
Machine = MachineName.Ellipse(210),
Version = VersionHelper.GetVersionFull()
};
Task.Run(async() => await LogsRepo.Add(log));
if (SendLogToSource && !ignoreRemote)
{
log.Machine += $"@{ExternalIp}";
LogsRepo.RemoteAdd(log);
}
});
}
catch { }
}
private static void DefaultLogWriter(LogTypeEnum type, LogContextEnum context, string message, object additionalData)
{
if (_logger == null)
{
throw new InvalidOperationException($"Logging is not initialized. Run '{nameof(Initialize)}' first.");
}
// does not block invoking code
Task.Run(async() =>
{
try
{
var logRecord = new LogRecord()
{
UniqueId = $"{Guid.NewGuid():N}{Guid.NewGuid():N}", // double GUID
KioskVersion = _kioskVersion,
LocalTime = DateTime.Now,
Type = type,
Context = context,
Message = message,
AdditionalDataJson = _logger.SerializeObject(additionalData),
};
await _logger.MoveLogRecordToQueueAsync(logRecord);
}
catch
{
// ignore to avoid infinite recursion
}
});
}
private static void SaveEventLog(LogTypeEnum pEnmType, string pStrMessage)
{
string lStrEventLogName = "";
if (Log.Configuration.EventLog.Active)
{
try
{
System.Diagnostics.EventLog lObjEventLog = new System.Diagnostics.EventLog();
lStrEventLogName = !string.IsNullOrEmpty(Log.Configuration.EventLog.Name)?
Log.Configuration.EventLog.Name :
Process.GetCurrentProcess().ProcessName;
if (!System.Diagnostics.EventLog.SourceExists(lStrEventLogName))
{
System.Diagnostics.EventLog.CreateEventSource(lStrEventLogName, "Application");
}
lObjEventLog.Source = lStrEventLogName;
lObjEventLog.WriteEntry(pStrMessage, GetEntryType(pEnmType), GetEntryId(pEnmType));
lObjEventLog.Close();
}
catch (Exception lObjException)
{
Log.Write(lObjException);
}
}
}
protected virtual string LogFormat(LogTypeEnum type, string message, Exception ex = null)
{
var caller = GetCallerInfo();
string logTemplate = "-------------------------------------------------------------------------------" + Enum.GetName(typeof(LogTypeEnum), type);
string logType = string.Empty;
string contentPrefix = ">>> ";
switch (type)
{
case LogTypeEnum.Debug: logType = "调试信息"; break;
case LogTypeEnum.Error: logType = "错误信息"; break;
case LogTypeEnum.Exception: logType = "异常信息"; break;
case LogTypeEnum.Info: logType = "追踪信息"; break;
}
logTemplate += "记录时间: " + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fffff") + Environment.NewLine;
logTemplate += "记录类型: " + logType + Environment.NewLine;
logTemplate += "记录来源: " + Environment.NewLine;
logTemplate += contentPrefix + "FilePath: " + caller.FileName + " ClassName: " + caller.ClassName + " MethodName:" + caller.MethodName + " Line: " + caller.LineNumber.ToString() + " Column: " + caller.ColumnNumber.ToString() + Environment.NewLine;
logTemplate += "记录内容: " + Environment.NewLine;
logTemplate += contentPrefix + message + Environment.NewLine;
if (ex != null)
{
logTemplate += "记录异常: " + Environment.NewLine;
logTemplate += contentPrefix + ex.ToString() + Environment.NewLine;
}
return(logTemplate);
}
private static int GetEntryId(LogTypeEnum pEnmType)
{
switch (pEnmType)
{
case LogTypeEnum.SUCCESS:
return(Log.Configuration.EventLog.SuccessId);
case LogTypeEnum.WARNING:
return(Log.Configuration.EventLog.WarningId);
case LogTypeEnum.ERROR:
return(Log.Configuration.EventLog.ErrorId);
case LogTypeEnum.EXCEPTION:
return(Log.Configuration.EventLog.ExceptionId);
case LogTypeEnum.TRACKING:
return(Log.Configuration.EventLog.TrackingId);
case LogTypeEnum.PROCESS:
return(Log.Configuration.EventLog.ProcessId);
case LogTypeEnum.INFO:
return(Log.Configuration.EventLog.InfoId);
default:
return(Log.Configuration.EventLog.InfoId);
}
}
/// <summary>
/// Log error from exception with error severity
/// </summary>
/// <param name="e">Exception to log</param>
public static void Log(Exception e, LogTypeEnum logType)
{
if (IsInIgnoreList(GetExceptionMessage(e)))
{
return;
}
try
{
ThreadPool.QueueUserWorkItem(delegate
{
var log = new Log
{
Event = DateTime.Now,
LogTypeId = logType,
Source = GetExceptionSource(e).Ellipse(200 - 5),
Message = GetExceptionMessage(e).Ellipse(1500 - 5),
StackTrace = GetExceptionStackTrace(e).Ellipse(4000 - 5),
Machine = MachineName.Ellipse(210),
Version = VersionHelper.GetVersionFull()
};
Task.Run(async() => await LogsRepo.Add(log));
});
}
catch { }
}
public MsBuildRunner(TaskLoggingHelper log, LogTypeEnum logType, string logFile) : base()
{
Log = log;
LogType = logType;
LogFile = logFile;
OriginalIgnoreList = IgnoreList = new NotSupportedIgnoreList();
}
private static void LogException(Exception e, string sourceMethod, LogTypeEnum type, string logFile, string additionalMessage = null)
{
if (!String.IsNullOrEmpty(logFile))
{
Utility.WriteToLogFile(logFile, string.Format("[{0}][{1}][{2}][{3}][{4}][{5}][{6}]"
, DateTime.Now.ToString()
, type
, sourceMethod
, "nouser"
, System.Environment.MachineName
, e.Message
, additionalMessage));
}
else
{
using (var logClient = new LoggingService.BILoggerServiceClient())
{
logClient.HandleBIExceptionAsync(e.ConvertToBIException(LogActionEnum.LogAndEmail
, type
, sourceMethod + " Error"
, sourceMethod
, "nouser"
, System.Environment.MachineName
, additionalMessage));
}
}
}
public IEnumerable <Log> SelectLogsForType(LogTypeEnum type)
{
if (type == LogTypeEnum.Error)
{
return(GetLogsWithTypes()
.Where(x => x.CheckIfError())
.ToList());
}
if (type == LogTypeEnum.Warning)
{
return(GetLogsWithTypes()
.Where(x => x.CheckIfWarning())
.ToList());
}
if (type == LogTypeEnum.Trace)
{
return(GetLogsWithTypes()
.Where(x => x.CheckIfTrace())
.ToList());
}
return(_databaseContext
.Logs
.ToList());
}
private void Log(string message, LogTypeEnum logTypeEnum)
{
Directory.CreateDirectory(Config.LogDirectory + $@"\{Config.ApplicationName}");
var fileName = Config.FileName.Invoke();
var filePath = $@"{Config.LogDirectory}\{Config.ApplicationName}\{fileName}.html";
var lockObj = GetLockObj(filePath);
lock (lockObj)
{
StreamWriter fileStream = null;
try
{
var isLogFileExists = File.Exists(filePath);
if (isLogFileExists)
{
var fileInfo = new FileInfo(filePath);
if (fileInfo.Length > Config.MaxFileSize * 1024)
{
var archiveDirectory =
Directory.CreateDirectory($@"{Config.LogDirectory}\{Config.ApplicationName}\Archive");
var newName =
$@"{archiveDirectory.FullName}\{fileName}_{DateTime.Now:HH mm ss}.html";
fileInfo.MoveTo(newName);
isLogFileExists = false;
}
}
if (!isLogFileExists)
{
fileStream = File.CreateText(filePath);
InitiateHtmlFile(fileStream, fileName);
}
else
{
fileStream = new StreamWriter(
File.Open(filePath, FileMode.Open, FileAccess.Write, FileShare.Read | FileShare.Delete),
UTF8NoBOM);
fileStream.BaseStream.Seek(Constants.EngTags.Length * -1, SeekOrigin.End);
fileStream.Write(",{");
}
fileStream.Write(GetLogDiv(message, logTypeEnum));
fileStream.Write(Constants.EngTags);
}
catch (Exception ex)
{
#if DEBUG_LOG
throw;
#endif
}
finally
{
fileStream?.Dispose();
}
}
}
public ActionLog(int entityId, int userId, LogTypeEnum type, EntitiesEnum entity)
{
EntityId = entityId;
UserId = userId;
Type = type;
Entity = entity;
Date = DateTime.Now;
}
/// <summary>
/// Inserts a log item
/// </summary>
/// <param name="LogType">Log item type</param>
/// <param name="Severity">The severity</param>
/// <param name="Message">The short message</param>
/// <param name="Exception">The full exception</param>
/// <param name="IPAddress">The IP address</param>
/// <param name="CustomerID">The customer identifier</param>
/// <param name="PageURL">The page URL</param>
/// <returns>Log item</returns>
public static Log InsertLog(LogTypeEnum LogType, int Severity, string Message, string Exception, string IPAddress, int CustomerID, string PageURL)
{
if (IPAddress == null)
{
IPAddress = string.Empty;
}
return(LogDBManager.InsertLog((int)LogType, Severity, Message, Exception, IPAddress, CustomerID, PageURL, DateTime.Now));
}
private static bool CheckWrite(LogTypeEnum LogType)
{
if (config.DisabledLog)
{
return(false);
}
return((int)LogType <= (int)config.LogLevel);
}
/// <summary>
/// Initializes a new instance of the <see cref="EventException"/> class.
/// </summary>
/// <param name="title">
/// Título da exception
/// </param>
/// <param name="details">
/// The details.
/// </param>
/// <param name="storeId">
/// The store Id.
/// </param>
/// <param name="appName">
/// The app Name.
/// </param>
/// <param name="logType">
/// The log Type.
/// </param>
public EventException(string title, string details = null, string storeId = null, string appName = null, LogTypeEnum? logType = null)
: base(title)
{
this.Details = details;
this.StoreId = storeId;
this.AppName = appName;
this.LogType = logType;
}
public static void AddLog(LogTypeEnum logType, string msg, string command)
{
LogInfo info = new LogInfo()
{
logType = logType, msg = msg, commandStr = command
};
logAction?.BeginInvoke(info, null, null);
}
public static void Log(LogTypeEnum type, string msg)
{
if (!Directory.Exists(LOG_DIR))
{
Directory.CreateDirectory(LOG_DIR);
}
File.AppendAllText(Path.Combine(LOG_DIR, LOG_NAME), DateTime.Now.ToString() + " " + type.ToString() + " " + msg + Environment.NewLine);
}
public void ToEnum_Passing_Valid_IntName_Enumeracion_Returns_Enumeracion()
{
var value = 2;
var expected = LogTypeEnum.Created;
var actual = LogTypeEnum.ToEnum(value);
Assert.AreEqual(expected, actual);
}
public static string GetOperatingTypeName(string op)
{
LogTypeEnum logTypeEnum = (LogTypeEnum)Enum.Parse(typeof(LogTypeEnum), op);
string result = "";
switch (logTypeEnum)
{
case LogTypeEnum.Login:
result = "登录";
break;
case LogTypeEnum.IncomeProc:
result = "入款处理";
break;
case LogTypeEnum.PlayerInfo:
result = "玩家信息";
break;
case LogTypeEnum.LimtCop:
result = "限制操作";
break;
case LogTypeEnum.AccountLock:
result = "锁定账号";
break;
case LogTypeEnum.AccountUnlock:
result = "解锁账号";
break;
case LogTypeEnum.AlmsModify:
result = "修改救济金";
break;
case LogTypeEnum.GTimeAwardModify:
result = "修改游戏时长奖励";
break;
case LogTypeEnum.AgentInfoModify:
result = "修改代理资料";
break;
case LogTypeEnum.RechangeAgent:
result = "后台充值代理";
break;
case LogTypeEnum.PromoterProModify:
result = "推广员属性修改";
break;
case LogTypeEnum.PromoterLockOrNo:
result = "冻结/解冻推广员";
break;
}
return(result);
}
public static void WriteLog(LogTypeEnum logType, Func <string> getMessage)
{
//TODO: check log level
string message = getMessage();
WriteLog(logType, message);
//throw new NotImplementedException();
}
public void ToEnum_Passing_Valid_String_Name_Enumeracion_Returns_Enumeracion()
{
var name = "Changed";
var expected = LogTypeEnum.Changed;
var actual = LogTypeEnum.ToEnum(name);
Assert.AreEqual(expected, actual);
}
public void ToEnum_Passing_Invalid_Int_Name_Enumeracion_Returns_Null()
{
var value = new Random().Next();
LogTypeEnum?expected = null;
var actual = LogTypeEnum.ToEnum(value);
Assert.AreEqual(expected, actual);
}
public void ToEnum_Passing_Invalid_String_Name_Enumeracion_Returns_Null()
{
var name = Guid.NewGuid().ToString();
LogTypeEnum?expected = null;
var actual = LogTypeEnum.ToEnum(name);
Assert.AreEqual(expected, actual);
}
protected override async void Log(object logData, LogTypeEnum logType) {
await Task.Run(() => {
EventLog eventLog = new EventLog();
string serializedLogData = Framework.Serializer.JsonSerialize(logData);
eventLog.Source = "Dlp.WhereIsMyChange";
eventLog.WriteEntry(serializedLogData, EventLogEntryType.Information);
});
}
/// <summary>
/// log a message to the EA output window. If requested the message will also be logged to the logfile
/// </summary>
/// <param name="model">the model on which to show the output</param>
/// <param name="outputName">the name of the output window</param>
/// <param name="message">the message to show</param>
/// <param name="elementID">the element ID to associate with the message. Can be used by add-ins when they implement EA_OnOutput...</param>
/// <param name="logType">the type of logging to the logfile</param>
public static void log(Model model,string outputName, string message, int elementID = 0,LogTypeEnum logType = LogTypeEnum.none)
{
var logger = getOutputLogger(model, outputName);
logger.logToOutput(message,elementID);
//log to logfile if needed
switch (logType)
{
case LogTypeEnum.log:
Logger.log(message);
break;
case LogTypeEnum.warning:
Logger.logWarning(message);
break;
case LogTypeEnum.error:
Logger.logError(message);
break;
}
}
protected override void Log(object logData, LogTypeEnum logType) {
string path = Path.GetFullPath(this.ConfigurationUtility.LogPath);
string fullPath = Path.GetFullPath(path + "WhereIsMyChangeLog.txt");
if (Directory.Exists(path) == false) {
Directory.CreateDirectory(path);
}
if (File.Exists(fullPath) == false) {
File.Create(fullPath).Dispose();
}
string serializedObject = Dlp.Framework.Serializer.JsonSerialize(logData);
string content = string.Format("{0} - {1} - {2}{3}", DateTime.UtcNow, logType.ToString(), serializedObject, Environment.NewLine);
File.AppendAllText(fullPath, content);
}
/************************************************************************/
/* SendLog - Payload format */
/* %c - log type */
/* %s - message */
/************************************************************************/
public bool SendLog(LogTypeEnum LogLevel, string Message)
{
byte[] payload = new byte[Message.Length + 2];
int offset = 0;
payload[offset++] = (byte)LogLevel;
for (int i = 0; i < Message.Length; i++)
payload[offset++] = (byte)Message[i];
payload[offset++] = (byte)'\0';
return Send(PacketType.PT_LOG, payload);
}
private void Log(LogTypeEnum logLevel, string logMessage)
{
switch (logLevel)
{
case LogTypeEnum.DEBUG:
_log.Debug(logMessage);
break;
case LogTypeEnum.ERROR:
_log.Error(logMessage);
break;
case LogTypeEnum.FATAL:
_log.Fatal(logMessage);
break;
case LogTypeEnum.INFO:
_log.Info(logMessage);
break;
case LogTypeEnum.WARN:
_log.Warn(logMessage);
break;
default:
throw new NotSupportedException();
}
}
/// <summary>
/// Registra exception que ocorreu no sistema.
/// </summary>
/// <param name="ex">
/// Exception do sistema.
/// </param>
/// <param name="storeId">
/// The store Id.
/// </param>
/// <param name="appName">
/// The app Name.
/// </param>
/// <param name="logType">
/// The log Type.
/// </param>
public void LogException(Exception ex, string storeId = null, string appName = null, LogTypeEnum logType = LogTypeEnum.Error)
{
// Encadeamento
if (!this.IsChild && threadChain != null)
{
foreach (var childLogger in threadChain)
{
childLogger.LogException(ex, storeId, appName, logType);
}
}
if (!this.IsChild && staticChain != null)
{
foreach (var childLogger in staticChain)
{
childLogger.LogException(ex, storeId, appName, logType);
}
}
this.elmah.Log(new Error(ex));
}
/// <summary>
/// Logging function
/// </summary>
/// <param name="type">Log type;LogTypeEnum</param>
/// <param name="log">Log data</param>
protected void Log(LogTypeEnum type, string log)
{
switch (type)
{
case LogTypeEnum.INFO:
Console.WriteLine("Info:" + log);
break;
case LogTypeEnum.WARN:
Console.WriteLine("Warning:" + log);
break;
case LogTypeEnum.ERROR:
Console.WriteLine("Error:" + log);
break;
case LogTypeEnum.IMAP:
Console.WriteLine(log);
break;
}
}
/// <summary>
/// Registra exception que ocorreu no sistema.
/// </summary>
/// <param name="title">
/// Título da problema/exception
/// </param>
/// <param name="storeId">
/// Identificador do cliente
/// </param>
/// <param name="appName">
/// The app Name.
/// </param>
/// <param name="logType">
/// The log Type.
/// </param>
public void LogEvent(string err, string storeId = null, string appName = null, string title = null, LogTypeEnum logType = LogTypeEnum.Error)
{
}
/// <summary>
/// Writes the value of the object's ToString method to the trace listeners in the Listeners collection if a condition is true and defines the type of log.
/// </summary>
/// <param name="condition">
/// Type: System.Boolean
/// The conditional expression to evaluate. If the condition is true, the category name and value are written to the trace listeners in the collection.
/// </param>
/// <param name="value">
/// Type: System.Object
/// An object whose name is sent to the Listeners.
/// </param>
/// <param name="logType">
/// Type: Meek.Diagnostics.LogTypeEnum
/// A log type enum used to organize the output.
/// </param>
public static void WriteLineIf(bool condition, object value, LogTypeEnum logType)
{
Loggers.ForEach(l => l.WriteLineIf(condition, value, logType));
}
private void Log(LogTypeEnum logLevel, string logMessage)
{
string prompt = string.Empty;
switch (logLevel)
{
case LogTypeEnum.DEBUG:
prompt = "Debug: {0}";
break;
case LogTypeEnum.ERROR:
prompt = "Error: {0}";
break;
case LogTypeEnum.FATAL:
prompt = "Fatal: {0}";
break;
case LogTypeEnum.INFO:
prompt = "Info: {0}";
break;
case LogTypeEnum.WARN:
prompt = "Warn: {0}";
break;
default:
throw new NotSupportedException();
}
System.Diagnostics.Debug.Write(String.Format(prompt, logMessage));
}
/// <summary>
/// Writes a message followed by a line terminator to the trace listeners in the Listeners collection and defines the type of log.
/// </summary>
/// <param name="message">
/// Type: System.String
/// A message to write.
/// </param>
/// <param name="logType">
/// Type: Meek.Diagnostics.LogTypeEnum
/// A log type enum used to organize the output.
/// </param>
public static void WriteLine(string message, LogTypeEnum logType)
{
Loggers.ForEach(l => l.WriteLine(message, logType));
}
/// <summary>
/// Logging function
/// </summary>
/// <param name="type">Log type;LogTypeEnum</param>
/// <param name="log">Log data</param>
public virtual void Log(LogTypeEnum type, string log)
{
//if (!IMAPBase.Debug)
// return;
//imapLogActive = true;
//if (InfoLogged != null)
// InfoLogged(type, log);
IMAPLogger.LogType t = IMAPLogger.LogType.General;
switch (type)
{
case LogTypeEnum.ERROR:
{
t = IMAPLogger.LogType.Error;
break;
}
case LogTypeEnum.IMAP:
{
t = IMAPLogger.LogType.General;
break;
}
case LogTypeEnum.INFO:
{
t = IMAPLogger.LogType.Info;
break;
}
case LogTypeEnum.WARN:
{
t = IMAPLogger.LogType.Warning;
break;
}
}
if (_logger != null)
_logger.Log(IMAPLogger.LoggingSource.IMAP, t, log);
//Console.WriteLine(msg);
}
public void Save(object logData, LogTypeEnum logType) {
this.Log(logData, logType);
}
/// <summary>
/// Writes the value of the object's ToString() method to the trace listeners in the Listeners collection and defines the type of log.
/// </summary>
/// <param name="value">
/// Type: System.Object
/// An object whose name is sent to the Listeners.
/// </param>
/// <param name="logType">
/// Type: Meek.Diagnostics.LogTypeEnum
/// A log type enum used to organize the output.
/// </param>
public static void Write(object value, LogTypeEnum logType)
{
Loggers.ForEach(l => l.Write(value, logType));
}
public void Log(LogTypeEnum logLevel, string logMessage, params object[] args)
{
string message = new SystemStringFormat(CultureInfo.InvariantCulture, logMessage, args).ToString();
Log(logLevel, message);
}
/// <summary>
/// Inserts a log item
/// </summary>
/// <param name="logType">Log item type</param>
/// <param name="message">The short message</param>
/// <param name="exception">The exception</param>
/// <returns>A log item</returns>
public static Log InsertLog(LogTypeEnum logType, string message, Exception exception)
{
int customerId = 0;
if (NopContext.Current != null && NopContext.Current.User != null)
customerId = NopContext.Current.User.CustomerId;
string IPAddress = NopContext.Current.UserHostAddress;
string pageUrl = CommonHelper.GetThisPageUrl(true);
return InsertLog(logType, 11, message, exception, IPAddress, customerId, pageUrl);
}
/// <summary>
/// Inserts a log item
/// </summary>
/// <param name="logType">Log item type</param>
/// <param name="severity">The severity</param>
/// <param name="message">The short message</param>
/// <param name="exception">The full exception</param>
/// <param name="IPAddress">The IP address</param>
/// <param name="customerId">The customer identifier</param>
/// <param name="pageUrl">The page URL</param>
/// <returns>Log item</returns>
public static Log InsertLog(LogTypeEnum logType, int severity, string message,
Exception exception, string IPAddress,
int customerId, string pageUrl)
{
//don't log thread abort exception
if ((exception != null) && (exception is ThreadAbortException))
return null;
if (message == null)
message = string.Empty;
if (IPAddress == null)
IPAddress = string.Empty;
string exceptionStr = exception == null ? string.Empty : exception.ToString();
string referrerUrl = string.Empty;
if (HttpContext.Current != null &&
HttpContext.Current.Request != null &&
HttpContext.Current.Request.UrlReferrer != null)
referrerUrl = HttpContext.Current.Request.UrlReferrer.ToString();
if (referrerUrl == null)
referrerUrl = string.Empty;
message = CommonHelper.EnsureMaximumLength(message, 1000);
exceptionStr = CommonHelper.EnsureMaximumLength(exceptionStr, 4000);
IPAddress = CommonHelper.EnsureMaximumLength(IPAddress, 100);
pageUrl = CommonHelper.EnsureMaximumLength(pageUrl, 100);
referrerUrl = CommonHelper.EnsureMaximumLength(referrerUrl, 100);
DateTime createdOn = DateTime.UtcNow;
NopObjectContext context = ObjectContextHelper.CurrentObjectContext;
Log log = context.Log.CreateObject();
log.LogTypeId = (int) logType;
log.Severity = severity;
log.Message = message;
log.Exception = exceptionStr;
log.IPAddress = IPAddress;
log.CustomerId = customerId;
log.PageUrl = pageUrl;
log.ReferrerUrl = referrerUrl;
log.CreatedOn = createdOn;
context.Log.AddObject(log);
context.SaveChanges();
return log;
}
/// <summary>
/// Writes a message to the trace listeners in the Listeners collection if a condition is true and defines the type of log.
/// </summary>
/// <param name="condition">
/// Type: System.Boolean
/// The conditional expression to evaluate. If the condition is true, the category name and value are written to the trace listeners in the collection.
/// </param>
/// <param name="message">
/// Type: System.String
/// A message to write.
/// </param>
/// <param name="logType">
/// Type: Meek.Diagnostics.LogTypeEnum
/// A log type enum used to organize the output.
/// </param>
public static void WriteLineIf(bool condition, string message, LogTypeEnum logType)
{
Loggers.ForEach(l => l.WriteLineIf(condition, message, logType));
}
/// <summary>
/// Registra exception que ocorreu no sistema.
/// </summary>
/// <param name="ex">
/// Exception do sistema.
/// </param>
/// <param name="storeId">
/// The store Id.
/// </param>
/// <param name="appName">
/// The app Name.
/// </param>
public void LogException(Exception ex, string storeId = null, string appName = null, LogTypeEnum logType = LogTypeEnum.Error)
{
// Encadeamento
if (threadChain != null)
{
foreach (var x in threadChain)
{
x.LogException(ex, storeId, appName);
}
}
if (staticChain != null)
{
foreach (var x in staticChain)
{
x.LogException(ex, storeId, appName);
}
}
Trace.WriteLine("--------------------------------------------");
Trace.WriteLine(String.Format("[{0}] Exception: \r\n{1}", DateTime.Now, ex));
}
/// <summary>
/// Inserts a log item
/// </summary>
/// <param name="logType">Log item type</param>
/// <param name="message">The short message</param>
/// <param name="exception">The exception</param>
/// <returns>A log item</returns>
public static Log InsertLog(LogTypeEnum logType, string message, string exception)
{
return InsertLog(logType, message, new Exception(String.IsNullOrEmpty(exception) ? string.Empty : exception));
}
/// <summary>
/// Registra exception que ocorreu no sistema.
/// </summary>
/// <param name="event"> Evento do sistema </param>
/// <param name="detail">Detalhamento do evento</param>
/// <param name="storeId"> Identificador do cliente </param>
/// <param name="appName"> The app Name. </param>
public void LogEvent(string @event, string detail = null, string storeId = null, string appName = null, LogTypeEnum logType = LogTypeEnum.Error)
{
// Encadeamento
if (threadChain != null)
{
foreach (var x in threadChain)
{
x.LogEvent(@event, detail, storeId, appName);
}
}
if (staticChain != null)
{
foreach (var x in staticChain)
{
x.LogEvent(@event, detail, storeId, appName);
}
}
Trace.WriteLine("--------------------------------------------");
Trace.WriteLine(string.Format("[{0}] Event: {1}\r\nDetails: {2}", DateTime.Now, @event, detail));
}
/// <summary>
/// Registra exception que ocorreu no sistema.
/// </summary>
/// <param name="err">
/// Exception do sistema.
/// </param>
/// <param name="storeId">
/// Identificador do cliente
/// </param>
/// <param name="appName">
/// The app Name.
/// </param>
/// <param name="logType">
/// The log Type.
/// </param>
public void LogEvent(string err, string storeId = null, string appName = null, string details = null, LogTypeEnum logType = LogTypeEnum.Error)
{
// Encadeamento
if (!this.IsChild && threadChain != null)
{
foreach (var childLogger in threadChain)
{
childLogger.LogEvent(err, storeId, appName, details, logType);
}
}
if (!this.IsChild && staticChain != null)
{
foreach (var childLogger in staticChain)
{
childLogger.LogEvent(err, storeId, appName, details, logType);
}
}
Error error = null;
if (!string.IsNullOrEmpty(err) && err.StartsWith("<error"))
{
try
{
error = ErrorXml.DecodeString(err);
}
catch (Exception)
{
}
}
if (error == null)
{
error = new Error(new EventException(err, details, storeId, appName));
}
this.elmah.Log(error);
}
public void LogStatus(string message, LogTypeEnum logType = LogTypeEnum.Info, Exception exception = null)
{
OnStatusBroadcast(new LogStatus { Message = message, LogType = logType, Exception = exception });
}
/// <summary>
/// Registra exception que ocorreu no sistema.
/// </summary>
/// <param name="ex">
/// Exception do sistema.
/// </param>
/// <param name="storeId">
/// Identificador do cliente
/// </param>
/// <param name="appName">
/// The app Name.
/// </param>
/// <param name="logType">
/// The log Type.
/// </param>
public void LogException(Exception ex, string storeId = null, string appName = null, LogTypeEnum logType = LogTypeEnum.Error)
{
}
