/// <summary>
/// Write the message to the current thread's log.
/// </summary>
/// <param name="e"></param>
public void Write(Log.MessageType type, string message, string details = null)
{
lock (this)
{
if (type == Log.MessageType.EXIT)
{
if (exiting_thread != null)
{
return;
}
exiting_thread = new Thread(() =>
{
if (Exitig != null)
{
Exitig.Invoke(message);
}
write(type, message, details);
Environment.Exit(0);
});
exiting_thread.Start();
}
else
{
write(type, message, details);
}
}
}
/// <summary>
/// Record the Message acception exception
/// </summary>
/// <param name="mexcMessage"></param>
/// <param name="Severity"></param>
public override void RecordMessage(Exception mexcMessage, Log.MessageType Severity)
{
this._FileLocation = "C:\\RK\\Labs\\TW\\Assignment\\ConferenceManager\\ConferenceManager\\LogFile.txt";
this._StackTrace = mexcMessage.StackTrace;
this._StackTrace = mexcMessage.Message + this._StackTrace;
this.RecordMessage(mexcMessage.Message, Severity);
}
public override void RecordMessage(string Message,
Log.MessageType Severity)
{
FileStream fileStream = null;
StreamWriter writer = null;
StringBuilder message = new StringBuilder();
try {
fileStream = new FileStream(this._FileLocation +
this._FileName, FileMode.OpenOrCreate,
FileAccess.Write);
writer = new StreamWriter(fileStream);
writer.BaseStream.Seek(0, SeekOrigin.End);
message.Append(System.DateTime.Now.ToString())
.Append(",").Append(Message);
writer.WriteLine(message.ToString());
writer.Flush();
}
finally
{
if (writer != null)
{
writer.Close();
}
}
}
/*-----------------------------------------------------------------------------------------
*
* Console
*
* -----------------------------------------------------------------------------------------*/
#if false
System.Drawing.Color GetMessageColor(Log.MessageType type)
{
//return System.Drawing.Color.Black;
if (type == Log.MessageType.Debug)
{
return(System.Drawing.Color.Gray);
}
if (type == Log.MessageType.Message)
{
return(System.Drawing.Color.Black);
}
if (type == Log.MessageType.Information)
{
return(System.Drawing.Color.Blue);
}
if (type == Log.MessageType.Warning)
{
return(System.Drawing.Color.DarkOrange);
}
if (type == Log.MessageType.Error)
{
return(System.Drawing.Color.Red);
}
return(System.Drawing.Color.Black);
}
void MessageCallbackOld(Log.MessageType type, string msg)
{
if (!messageTextBox.IsDisposed)
{
AppendText(msg, GetMessageColor(type), GetMessageBackColor(type));
}
}
System.Drawing.Color GetMessageBackColor(Log.MessageType type)
{
//return System.Drawing.Color.White;
if (type == Log.MessageType.Debug)
{
return(System.Drawing.Color.White); /*.White; */
}
if (type == Log.MessageType.Message)
{
return(System.Drawing.Color.White); /*.White; */
}
if (type == Log.MessageType.Information)
{
return(System.Drawing.Color.White); /*.White; */
}
if (type == Log.MessageType.Warning)
{
return(System.Drawing.Color.White); /*.Yellow; */
}
if (type == Log.MessageType.Error)
{
return(System.Drawing.Color.White); /*.Red; */
}
return(System.Drawing.Color.Black);
}
/// <summary>
/// Record the Message acception exception
/// </summary>
/// <param name="mexcMessage"></param>
/// <param name="Severity"></param>
public override void RecordMessage(Exception mexcMessage, Log.MessageType Severity)
{
this._FileLocation = "LogFile.txt";
this._StackTrace = mexcMessage.StackTrace;
this._StackTrace = mexcMessage.Message + this._StackTrace;
this.RecordMessage(mexcMessage.Message, Severity);
}
/// <summary>
/// General writting log method.
/// </summary>
public void Write(Log.MessageType messageType, string message, string details = null)
{
lock (this)
{
write(messageType, message, details);
if (messageType == Log.MessageType.EXIT)
{
if (exiting)
{
return;
}
exiting = true;
//if (exitingThread != null)
// return;
//exitingThread = ThreadRoutines.Start(() =>
//{
try
{
Exitig?.Invoke(message);
}
catch (Exception e)
{
write(Log.MessageType.ERROR, GetExceptionMessage(e));
}
finally
{
Environment.Exit(0);
}
//});
}
}
}
/// Log a message.
public override void RecordMessage(string Message, Log.MessageType Severity)
{
FileStream fileStream = null;
StreamWriter writer = null;
StringBuilder message = new StringBuilder();
try
{
fileStream = new FileStream(this._FileName, FileMode.OpenOrCreate, FileAccess.Write);
writer = new StreamWriter(fileStream);
// Set the file pointer to the end of the file
writer.BaseStream.Seek(0, SeekOrigin.End);
// Create the message
message.Append(Severity.ToString() + ": " + System.DateTime.Now.ToString()).Append(" - ").Append(Message);
// Force the write to the underlying file
writer.WriteLine(message.ToString());
writer.Flush();
}
finally
{
if (writer != null)
{
writer.Close();
}
}
}
void write(Log.MessageType messageType, string message, string details = null)
{
lock (this)
{
Writing?.Invoke(Name, messageType, message, details);
switch (Level)
{
case Level.NONE:
return;
case Level.ERROR:
if (messageType < MessageType.ERROR)
{
return;
}
break;
case Level.WARNING:
if (messageType < MessageType.WARNING)
{
return;
}
break;
case Level.INFORM:
if (messageType < MessageType.INFORM)
{
return;
}
break;
case Level.ALL:
break;
default:
throw new Exception("Unknown option: " + Level);
}
if (MaxFileSize > 0)
{
FileInfo fi = new FileInfo(File);
if (fi.Exists && fi.Length > MaxFileSize)
{
fileCounter++;
SetFile();
}
}
if (logWriter == null)
{
Directory.CreateDirectory(PathRoutines.GetFileDir(File));
logWriter = new StreamWriter(File, true);
}
message = (messageType == MessageType.LOG ? "" : messageType.ToString() + ": ") + message + (string.IsNullOrWhiteSpace(details) ? "" : "\r\n\r\n" + details);
logWriter.WriteLine(DateTime.Now.ToString(Log.TimePattern) + message);
logWriter.Flush();
}
}
/// <summary>
/// Writes message into component log using caller file name and line number for the FROM field
/// </summary>
protected internal Guid WriteLogFromHere(Log.MessageType type,
string text,
Exception error = null,
Guid?related = null,
string pars = null,
[System.Runtime.CompilerServices.CallerFilePath] string file = null,
[System.Runtime.CompilerServices.CallerLineNumber] int src = 0)
=> WriteLog(type, null, text, error, related, pars, file, src);
void write2Messages(Log.MessageType type, string message, string details)
{
lock (this)
{
if (type == Log.MessageType.LOG)
{
return;
}
this["INSERT INTO Messages (Type,Source,Value,Time,Details) VALUES(@Type,@Source,@Value,GETDATE(),@Details)"].Execute("@Type", (int)type, "@Source", entry_assembly_name, "@Value", message, "@Details", details);
}
}
/// <summary>
/// Base writting log method.
/// </summary>
public void Write(Log.MessageType messageType, string message, string details = null)
{
lock (this)
{
write(messageType, message, details);
if (messageType == Log.MessageType.EXIT)
{
Environment.Exit(0);
}
}
}
/// <summary>
/// Outputs log message to application log
/// </summary>
public void Log(Log.MessageType type, string message)
{
Log(new Log.Message
{
Text = message ?? string.Empty,
Type = type,
From = this.RecordName,
Topic = CoreConsts.RECORD_TOPIC,
Parameters = this.TableName
}
);
}
void MessageCallback(Log.MessageType type, string msg)
{
if (!messageTextBox.IsDisposed)
{
if (uiThread == Thread.CurrentThread)
{
AppendText(msg, GetMessageColor(type), GetMessageBackColor(type));
}
else
{
MethodInvoker action = delegate { AppendText(msg, GetMessageColor(type), GetMessageBackColor(type)); };
messageTextBox.BeginInvoke(action);
messageTextBox.Invalidate();
}
}
}
public void LogMsg(String Msg, String tipoMsg, String severityMsg)
{
Log.MessageType type = Log.MessageType.Informacion;
switch (severityMsg.ToUpper())
{
case "I":
type = Log.MessageType.Informacion;
break;
case "F":
type = Log.MessageType.Falla;
break;
case "W":
type = Log.MessageType.Warning;
break;
case "E":
type = Log.MessageType.Error;
break;
case "D":
type = Log.MessageType.Debug;
break;
}
//Sin Debug no muestra mensajes tipo Debug
if (!Llacolen_SBOService.Properties.Settings.Default.Debug)
{
return;
}
// tipoMsg -> E: evento, F: File, A:All
if (tipoMsg == "E" || tipoMsg == "A")
{
//
// Messages al EventLog de windows deshabilitados
//
// this.LogType = Logger.LogTypes.Event;
// this.RecordMessage(Msg, type);
}
if (tipoMsg == "F" || tipoMsg == "A")
{
this.LogType = Logger.LogTypes.File;
this.RecordMessage(Msg, type);
}
}
/// <summary>
/// RecordMessage acception string
/// </summary>
/// <param name="mstrMessage"></param>
/// <param name="Severity"></param>
public override void RecordMessage(string mstrMessage, Log.MessageType Severity)
{
FileStream fileStream = null;
StreamWriter writer = null;
this._FileLocation = "LogFile.txt";
StringBuilder message = new StringBuilder();
try
{
fileStream = new FileStream(this._FileLocation, FileMode.OpenOrCreate, FileAccess.Write);
writer = new StreamWriter(fileStream);
// Set the file pointer to the end of the file
writer.BaseStream.Seek(0, SeekOrigin.End);
// Create the message
message.Append(Environment.NewLine);
message.Append(Environment.NewLine);
message.Append("*******************Error Details***********************");
message.Append(Environment.NewLine);
message.Append("Details : " + mstrMessage);
message.Append(Environment.NewLine);
message.Append("Severity : " + Severity);
message.Append(Environment.NewLine);
message.Append("Assembly Version : " + System.Reflection.Assembly.GetAssembly(this.GetType()).GetName().Version.ToString());
message.Append(Environment.NewLine);
message.Append("TimeStamp : " + DateTime.Now.ToString());
message.Append(Environment.NewLine);
message.Append("StackTrace : " + _StackTrace);
message.Append(Environment.NewLine);
message.Append("********************************************************");
// Force the write to the underlying file
writer.WriteLine(message.ToString());
writer.Flush();
}
finally
{
if (writer != null)
{
writer.Close();
}
}
}
/// Log a message.
public override void RecordMessage(string Message, Log.MessageType Severity)
{
StringBuilder message = new StringBuilder();
System.Diagnostics.EventLog eventLog = new System.Diagnostics.EventLog();
// Create the source if it does not already exist
if (!System.Diagnostics.EventLog.SourceExists(this._EventLogSource))
{
System.Diagnostics.EventLog.CreateEventSource(this._EventLogSource, this._EventLogName);
}
eventLog.Source = this._EventLogSource;
eventLog.MachineName = this._MachineName;
// Determine what the EventLogEventType should be
// based on the LogSeverity passed in
EventLogEntryType type = EventLogEntryType.Information;
switch (Severity.ToString().ToUpper())
{
case "INFORMACION":
type = EventLogEntryType.Information;
break;
case "FALLA":
type = EventLogEntryType.FailureAudit;
break;
case "WARNING":
type = EventLogEntryType.Warning;
break;
case "ERROR":
type = EventLogEntryType.Error;
break;
case "DEBUG":
type = EventLogEntryType.Error;
break;
}
message.Append(Severity.ToString()).Append(" - ").Append(Message);
eventLog.WriteEntry(message.ToString(), type);
}
/// <summary>
/// Writes a log message for this component; returns the new log msg GDID for correlation, or GDID.Empty if no message was logged.
/// The file/src are only used if `from` is null/blank
/// </summary>
protected internal virtual Guid WriteLog(Log.MessageType type,
string from,
string text,
Exception error = null,
Guid?related = null,
string pars = null,
[System.Runtime.CompilerServices.CallerFilePath] string file = null,
[System.Runtime.CompilerServices.CallerLineNumber] int src = 0)
{
if (type < ComponentEffectiveLogLevel)
{
return(Guid.Empty);
}
if (from.IsNullOrWhiteSpace())
{
from = "{0}:{1}".Args(file.IsNotNullOrWhiteSpace() ? System.IO.Path.GetFileName(file) : "?", src);
}
var msg = new Log.Message
{
App = App.AppId,
Topic = ComponentLogTopic,
From = ComponentLogFromPrefix + from,
Type = type,
Text = text,
Exception = error,
Parameters = pars,
Source = src
};
msg.InitDefaultFields(App);
if (related.HasValue)
{
msg.RelatedTo = related.Value;
}
App.Log.Write(msg);
return(msg.Guid);
}
/// <summary>
/// Write the message to the current thread's log.
/// </summary>
/// <param name="e"></param>
public void Write(Log.MessageType messageType, string message, string details = null)
{
lock (this)
{
if (messageType == Log.MessageType.EXIT)
{
if (exiting_thread != null)
{
return;
}
write(messageType, message, details);
exiting_thread = startThread(() =>
{
try
{
if (Exitig != null)
{
Exitig.Invoke(message);
}
}
catch (Exception e)
{
string m;
string d;
GetExceptionMessage(e, out m, out d);
write(Log.MessageType.ERROR, m, d);
}
finally
{
Environment.Exit(0);
}
});
}
else
{
write(messageType, message, details);
}
}
}
void ThreadLog_Writing(Log.MessageType type, string message, string details)
{
write2Messages(type, message, details);
}
/// <summary>
///
/// </summary>
/// <param name="mstrMessage"></param>
/// <param name="Severity"></param>
/// <param name="LogTo"></param>
public static void RecordMessage(string mstrMessage, Log.MessageType Severity, LogTypes LogTo)
{
LogType = LogTo;
ObjLogger.RecordMessage(mstrMessage, Severity);
}
public void LogMsg(String Msg, String tipoMsg, String severityMsg)
{
Log.MessageType type = Log.MessageType.Informacion;
switch (severityMsg.ToUpper())
{
case "I":
type = Log.MessageType.Informacion;
break;
case "F":
type = Log.MessageType.Falla;
break;
case "W":
type = Log.MessageType.Warning;
break;
case "E":
type = Log.MessageType.Error;
break;
case "D":
type = Log.MessageType.Debug;
break;
}
// Menasjes informativos siempre
if (tipoMsg == "A" || type == Log.MessageType.Informacion)
{
this.LogType = Logger.LogTypes.File;
this.RecordMessage(Msg, type);
if (FTextBoxMsg != null)
{
FTextBoxMsg.AppendText(Msg + Environment.NewLine);
Application.DoEvents();
}
return;
}
//Sin Debug no muestra mensajes tipo Debug
else if ((!SBO_VID_Currency.Properties.Settings.Default.Debug) && (type == Log.MessageType.Debug))
{
return;
}
// tipoMsg -> E: evento, F: File, A:All
else if (tipoMsg == "E" || tipoMsg == "A")
{
//
// Messages al EventLog de windows deshabilitados
//
// this.LogType = Logger.LogTypes.Event;
// this.RecordMessage(Msg, type);
}
else if (tipoMsg == "F" || tipoMsg == "A")
{
this.LogType = Logger.LogTypes.File;
this.RecordMessage(Msg, type);
if (FTextBoxMsg != null)
{
FTextBoxMsg.AppendText(Msg + Environment.NewLine);
Application.DoEvents();
}
}
}
void write(Log.MessageType messageType, string message, string details)
{
switch (Level)
{
case Level.NONE:
return;
case Level.ERROR:
if (messageType < MessageType.ERROR)
{
return;
}
break;
case Level.WARNING:
if (messageType < MessageType.WARNING)
{
return;
}
break;
case Level.INFORM:
if (messageType < MessageType.INFORM)
{
return;
}
break;
case Level.ALL:
break;
default:
throw new Exception("Unknown option: " + Level);
}
lock (this)
{
Writing?.Invoke(Name, messageType, message, details);
if (Log.writeLog)
{
if (log_writer == null)
{
log_writer = new StreamWriter(Path, true);
}
details = string.IsNullOrWhiteSpace(details) ? "" : "\r\n\r\n" + details;
message = (messageType == MessageType.LOG ? "" : messageType.ToString()) + ": " + message + details;
//switch (type)
//{
// case Log.MessageType.INFORM:
// message = "INFORM: " + message;
// break;
// case Log.MessageType.WARNING:
// message = "WARNING: " + message;
// break;
// case Log.MessageType.ERROR:
// message = "ERROR: " + message + details;
// _ErrorCount++;
// break;
// case Log.MessageType.EXIT:
// message = "EXIT: " + message + details;
// _ErrorCount++;
// break;
// case Log.MessageType.TRACE:
// message = "TRACE: " + message;
// break;
// case Log.MessageType.LOG:
// break;
// default:
// throw new Exception("No case for " + type.ToString());
//}
if (MaxFileSize > 0)
{
FileInfo fi = new FileInfo(Path);
if (fi.Length > MaxFileSize)
{
log_writer.Close();
int counter = 0;
file_name = Regex.Replace(file_name, @"(\d+_)(\d+)(\.[^\.]+)$",
(Match m) =>
{
counter = int.Parse(m.Groups[2].Value) + 1;
return(m.Groups[1].Value + counter + m.Groups[3].Value);
}
);
if (counter < 1)
{
file_name = Regex.Replace(file_name, @"\.[^\.]+$", @"_1$0");
}
log_writer = new StreamWriter(Path, true);
}
}
//if (!string.IsNullOrWhiteSpace(details))
// message += "\r\n\r\n" + details;
log_writer.WriteLine(DateTime.Now.ToString("[dd-MM-yy HH:mm:ss] ") + message);
log_writer.Flush();
}
}
}
/// <summary>
/// Encloses an action in try catch and logs the error if it leaked from action. This method never leaks.
/// Returns true if there was no error on action success, or false if error leaked from action and was logged by component.
/// The actual logging depends on the component log level
/// </summary>
public static TResult DontLeak <TResult>(this IApplicationComponent cmp, Func <TResult> func, string errorText = null, [CallerMemberName] string errorFrom = null, Log.MessageType errorLogType = Log.MessageType.Error)
{
var ac = (cmp.NonNull(nameof(cmp)) as ApplicationComponent).NonNull("Internal error: not a AC");
func.NonNull(nameof(func));
try
{
return(func());
}
catch (Exception error)
{
if (errorText.IsNullOrWhiteSpace())
{
errorText = "Error leaked: ";
}
errorText += error.ToMessageWithType();
ac.WriteLog(errorLogType, errorFrom, errorText, error);
}
return(default(TResult));
}
/// <summary>
/// Encloses an action in try catch and logs the error if it leaked from action. This method never leaks.
/// Returns true if there was no error on action success, or false if error leaked from action and was logged by component.
/// The actual logging depends on the component log level
/// </summary>
public static bool DontLeak(this IApplicationComponent cmp, Action action, string errorText = null, [CallerMemberName] string errorFrom = null, Log.MessageType errorLogType = Log.MessageType.Error)
{
var ac = (cmp.NonNull(nameof(cmp)) as ApplicationComponent).NonNull("Internal error: not a AC");
action.NonNull(nameof(action));
try
{
action();
return(true);
}
catch (Exception error)
{
if (errorText.IsNullOrWhiteSpace())
{
errorText = "Error leaked: ";
}
errorText += error.ToMessageWithType();
ac.WriteLog(errorLogType, errorFrom, errorText, error);
}
return(false);
}
public LogMessage(string m, Log.MessageType t)
{
message = m;
type = t;
}
public override void RecordMessage(Exception Message, Log.MessageType Severity)
{
this.RecordMessage(Message.Message, Severity);
}
void write(Log.MessageType type, string message, string details)
{
lock (this)
{
if (Writing != null)
{
Writing.Invoke(type, message, details);
}
if (Properties.Log.Default.WriteLog)
{
if (log_writer == null)
{
log_writer = new StreamWriter(Path, true);
}
switch (type)
{
case Log.MessageType.INFORM: message = "INFORM: " + message; break;
case Log.MessageType.WARNING: message = "WARNING: " + message; break;
case Log.MessageType.ERROR:
message = "ERROR: " + message;
_ErrorCount++;
break;
case Log.MessageType.EXIT:
message = "EXIT: " + message;
_ErrorCount++;
break;
case Log.MessageType.TRACE: message = "TRACE: " + message; break;
case Log.MessageType.LOG: break;
default: throw new Exception("No case for " + type.ToString());
}
if (MaxFileSize > 0)
{
FileInfo fi = new FileInfo(Path);
if (fi.Length > MaxFileSize)
{
log_writer.Close();
int counter = 0;
path = Regex.Replace(path, @"(\d+_)(\d+)(\.[^\.]+)$",
(Match m) => {
counter = int.Parse(m.Groups[2].Value) + 1;
return(m.Groups[1].Value + counter + m.Groups[3].Value);
},
RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.Singleline
);
if (counter < 1)
{
path = Regex.Replace(path, @"\.[^\.]+$", @"_1$0", RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.Singleline);
}
log_writer = new StreamWriter(Path, true);
}
}
log_writer.WriteLine(DateTime.Now.ToString("[dd-MM-yy HH:mm:ss] ") + message);
log_writer.Flush();
}
}
}
/// Log an exception.
public void RecordMessage(Exception Message, Log.MessageType Severity)
{
this._Logger.RecordMessage(Message, Severity);
}
/// Log a message.
public void RecordMessage(string Message, Log.MessageType Severity)
{
this._Logger.RecordMessage(Message, Severity);
}
