public DLogger(DLoggerConfig config)
{
_lock = new Object();
_config = config;
_isDefault = true;
_name = config.DefaultLoggerName;
_allowedMessgeTypes = config.DefaultMessageTypes;
String outputPath = DLoggerConfig.ParsePath(config.PathOutput);
if (!outputPath.EndsWith("/"))
{
outputPath += "/";
}
_fullPath = String.Format(@"{0}{1}.log", outputPath, _name);
LogStartupMessages();
//Log(LoggerMessageType.Naked,
// new String('-', 50) + Environment.NewLine);
//Log(LoggerMessageType.Information | LoggerMessageType.Success,
// "Logger initialised for '{0}', with allowed message types of '{1}'. Output file is located at '{2}'.",
// _name,
// _allowedMessgeTypes,
// _fullPath);
}
public Boolean Log(LoggerMessageType type,
String format,
params System.Object[] args)
{
if (!CheckMessageType(type))
{
return(false);
}
LogWritingEventArgs writingArgs = new LogWritingEventArgs(FullPath,
type,
String.Format(format, args));
Writing?.Invoke(this, writingArgs);
FileInfo outputFile = new FileInfo(FullPath);
if (!outputFile.Directory.Exists)
{
outputFile.Directory.Create();
}
LogMessageTemplate messageTemplate = new LogMessageTemplate(_config.MessageTemplateText,
writingArgs);
lock (_lock)
{
File.AppendAllText(FullPath, messageTemplate.ToString());
}
Console.WriteLine(messageTemplate.ToString());
return(true);
}
private Boolean CheckMessageType(LoggerMessageType type)
{
lock (_lock)
{
if (_allowedMessageTypesList == null)
{
String[] allowedMessageTypes = AllowedMessageTypes.ToString().Split(',');
_allowedMessageTypesList = new List <String>();
foreach (String curAllowedType in allowedMessageTypes)
{
_allowedMessageTypesList.Add(curAllowedType.Trim().ToLower());
}
}
}
String[] messageTypes = type.ToString().Split(',');
foreach (String curType in messageTypes)
{
if (!_allowedMessageTypesList.Contains(curType.Trim().ToLower()))
{
return(false);
}
}
return(true);
}
public LogWritingEventArgs(String fullPath,
LoggerMessageType messageType,
String plainMessage)
{
_fullPath = fullPath;
_messageType = messageType;
_plainMessage = plainMessage;
}
/// <summary> New message from logger. </summary>
///
/// <remarks> AM Kozhevnikov, 30.01.2018. </remarks>
///
/// <param name="messageType"> The type of the message. </param>
/// <param name="text"> The text. </param>
///
/// <returns> A LoggerMessage. </returns>
public static LoggerMessage New(LoggerMessageType messageType, string text, string category)
{
return(new LoggerMessage()
{
MessageType = messageType,
Text = text,
Category = category
});
}
private void Parse(String json)
{
_configJObject = JObject.Parse(json);
_pathOutput = _configJObject["Paths"]["Output"].Value <String>();
_defaultLoggerName = _configJObject["Default"]["Name"].Value <String>();
_defaultEnabled = _configJObject["Default"]["Enabled"].Value <bool>();
String defaultMessageTypes = _configJObject["Default"]["AllowedMessageTypes"].Value <String>();
_defaultMessageTypes = (LoggerMessageType)Enum.Parse(typeof(LoggerMessageType), defaultMessageTypes, true);
_messageTemplateIsUTC = Boolean.Parse(_configJObject["MessageTemplate"]["IsUTC"].Value <String>());
_messageTemplateText = _configJObject["MessageTemplate"]["Text"].Value <String>();
}
public void WriteLine(LoggerMessageType messageType, string message, params object[] arguments)
{
System.Console.ForegroundColor = ForegroundColors[messageType];
if (arguments.Length == 0)
{
System.Console.WriteLine(message);
}
else
{
System.Console.WriteLine(message, arguments);
}
System.Console.ForegroundColor = ForegroundColors[LoggerMessageType.Default];
}
public Boolean Log(LoggerMessageType type,
String format,
params System.Object[] args)
{
//This is a special flag which prevents sensitive logging information
//for being output when a debugger is not attached.
if (type.HasFlag(LoggerMessageType.Sensitive) && !System.Diagnostics.Debugger.IsAttached)
{
return(false);
}
else
{
type = type & ~LoggerMessageType.Sensitive;
}
//We need all message types to be in the allowed message
//types before we can continue
String[] allowedMessageTypes = AllowedMessageTypes.ToString().Split(',');
List <String> allowedMessageTypesList = new List <String>();
foreach (String curAllowedType in allowedMessageTypes)
{
allowedMessageTypesList.Add(curAllowedType.Trim().ToLower());
}
String[] messageTypes = type.ToString().Split(',');
foreach (String curType in messageTypes)
{
if (!allowedMessageTypesList.Contains(curType.Trim().ToLower()))
{
return(false);
}
}
LogWritingEventArgs writingArgs = new LogWritingEventArgs(FullPath,
type,
String.Format(format, args));
Writing?.Invoke(this, writingArgs);
System.Diagnostics.Debug.WriteLine(String.Format(format, args));
return(true);
}
/// <summary>
/// This function appends the given text to the logger form based on the specified
/// message type.
/// </summary>
/// <param name="value">Text to be appended to the form.</param>
/// <param name="type">The logger message type.</param>
public void Log(string value, LoggerMessageType type)
{
Style style;
switch (type)
{
case LoggerMessageType.Warning:
style = warningStyle;
break;
case LoggerMessageType.Error:
style = errorStyle;
break;
default:
style = infoStyle;
break;
}
console.AppendText(DateTime.Now + ": " + value + "\n", style);
}
public static bool SendMessage(LoggerMessageType loggerType, string message, string category = "None")
{
return(SendMessage(LoggerMessage.New(loggerType, message, category)));
}
public void Write(LoggerMessageType messageType, string message, params object[] arguments)
{
System.Console.ForegroundColor = ForegroundColors[messageType];
System.Console.Write(message, arguments);
System.Console.ForegroundColor = ForegroundColors[LoggerMessageType.Default];
}
/// <summary> Send this message. Отправка сообщения через логгер с произвольным типом, текстом и категорией </summary>
///
/// <remarks> AM Kozhevnikov, 07.02.2018. </remarks>
///
/// <param name="messageType"> Type of the message. </param>
/// <param name="text"> The text. </param>
/// <param name="category"> The category. </param>
private static void Send(LoggerMessageType messageType, string text, string category)
{
Send(LoggerMessage.New(messageType, text, category));
}
public void WriteMessage(LoggerMessageType messageType, Exception exception)
{
mLogWriter.WriteLine("[{0}] [{1:dd.MM.yyyy HH:mm:ss}.{2}] {3}", messageType.ToString().ToUpper(), DateTime.Now, DateTime.Now.Millisecond, exception);
mLogWriter.Flush();
}
public void WriteMessage(LoggerMessageType messageType, Exception exception)
{
mLogWriter.WriteLine("[{0}] [{1:dd.MM.yyyy HH:mm:ss}.{2}] {3}", messageType.ToString().ToUpper(), DateTime.Now, DateTime.Now.Millisecond, exception);
mLogWriter.Flush();
}
