private void SendMessage(object message, LogTypes type)
{
if (message == null)
{
return;
}
if (DumpType == DumpType.Interval)
{
MessageQueue.Add(message.ToString());
}
else if (DumpType == DumpType.NoBuffer)
{
DumpQueue();
}
Console.ForegroundColor = type switch
{
LogTypes.Debug => ConsoleColor.White,
LogTypes.Info => ConsoleColor.Green,
LogTypes.Warn => ConsoleColor.DarkYellow,
LogTypes.Error => ConsoleColor.Red,
LogTypes.Fatal => ConsoleColor.DarkRed,
_ => ConsoleColor.White,
};
Console.WriteLine(message);
Console.ForegroundColor = ConsoleColor.White;
OnMessageLogged(message as string);
}
public static void Write(string text, LogTypes logType = LogTypes.Everything, bool isBold = false, string color = "")
{
if (logs == null)
{
InitializeLogs();
}
string logString = text;
if (isBold)
{
logString = "<b>" + logString + "</b>";
}
if (color != "")
{
logString = "<color=" + color + ">" + logString + "</color>";
}
LogEntry logEntry = new LogEntry(logString + "\n", logType);
logs.Add(logEntry);
if (currentLogTypeToShow == logType || currentLogTypeToShow == LogTypes.Everything)
{
ShowLogEntry(logEntry);
}
}
/// <summary>
/// record log
/// </summary>
/// <param name="content">custom log content</param>
/// <param name="methodInfo">log info from invoker's method info</param>
/// <param name="exception">exception object</param>
/// <param name="type">log type</param>
/// <param name="savePath">log saved path(default:the log files are saved into current application executable's path</param>
public void Write(string content, string methodInfo, Exception exception, LogTypes type, string savePath)
{
if (!string.IsNullOrEmpty(content) || exception != null)
{
//if there are no custom log content or exception object,the log will be not record!
string timeString = DateTime.Now.ToString();
StringBuilder append = new StringBuilder();
append.AppendFormat("time:{0}\r\n", timeString);
if (!string.IsNullOrEmpty(content))
{
append.AppendFormat("content:{0}\r\n", content);
}
if (!string.IsNullOrEmpty(methodInfo))
{
append.AppendFormat("method info:{0}\r\n", methodInfo);
}
if (exception != null)
{
append.AppendFormat("exception:{0}\r\n", exception.Message);
append.AppendFormat("heap:{0}\r\n", exception.StackTrace);
}
append.Append("****************************");
WriteLog(append.ToString(), type, savePath);
}
}
private string GetLogTypeFilePath()
{
if (!this._logFilesGenerated)
{
EmitTemplates();
foreach (LogTypes logType in Enum.GetValues(typeof(LogTypes)))
{
if (logType != LogTypes.XmlOutput && logType != LogTypes.TestLog)
{
WriteLogFile(GetTemplateFileName(logType), GetLogFilePath(logType));
}
}
this._logFilesGenerated = true;
}
if (this._logType == LogTypes.TestLog)
{
string testLogFileName = GetXmlTestFilePath(this._lastTestId);
if (File.Exists(testLogFileName))
{
return(testLogFileName);
}
this._logType = LogTypes.OverallResults;
}
return(GetLogFilePath(this._logType));
}
public LogArgs(LogTypes logType, string section, string method, string msg)
{
LogType = logType;
Section = section;
Method = method;
Message = msg;
}
private void AppendLog(LogTypes logType, string section, string method, string text)
{
lock (_lock)
{
string fullName = "";
string prefix = $"{DateTime.Now:dd.MM.yyyy HH:mm:ss} {logType.ToString().PadRight(5)} [{section}]";
string logStr = $"{prefix} [{method}] {text}\r\n";
try
{
string path = string.IsNullOrWhiteSpace(LogfilePath) ? Helper.GetExePath() : LogfilePath;
fullName = Path.Combine(path, Constants.DEBUG_LOG);
File.AppendAllText(fullName, logStr);
}
catch
{
// try to log in program directory
/*
* string newName = Path.Combine(Helper.GetExePath(), Constants.DEBUG_LOG);
* File.AppendAllText(newName, $"{prefix} [AppendLog] Error writing logfile to {fullName}\r\n");
* File.AppendAllText(newName, logStr);
*/
}
}
}
public static void Initialize(string file)
{
config = new Config(file, true);
if (config != null)
{
LogLevel = config.Read("Log.Level", LogTypes.Success | LogTypes.Info);
LogDirectory = config.Read("Log.Directory", "Logs/Manager");
LogConsoleFile = config.Read("Log.Console.File", "");
LogDatabaseFile = config.Read("Log.Database.File", "");
LogPacketFile = config.Read("Log.Packet.File", "");
LogFile fl = null;
if (LogConsoleFile != "")
{
if (!Directory.Exists(LogDirectory))
Directory.CreateDirectory(LogDirectory);
fl = new LogFile(LogDirectory, LogConsoleFile);
}
Log.Initialize(LogLevel, fl);
initialized = true;
}
if (initialized)
ReadConfig();
}
public static void SaveLog(LogTypes type, string method, string message, string stack = null)
{
Logs log = new Logs()
{
Method = method,
Message = message,
Stack = stack,
Type = (int)type,
Created = DateTime.Now
};
switch (type)
{
case LogTypes.Info:
LogInfo(log);
break;
case LogTypes.Warning:
LogWarning(log);
break;
case LogTypes.Error:
LogError(log);
break;
case LogTypes.Critical:
LogCritical(log);
break;
case LogTypes.Fatal:
LogFatal(log);
break;
}
}
public static Color ToBackgroundColor(
this LogTypes t)
=> new[]
{
/*
* (Color)cc.ConvertFrom("#FFFFFFFF"), // UNKNOWN
* (Color)cc.ConvertFrom("#FFFF9999"), // Combat Start
* (Color)cc.ConvertFrom("#FFFF9999"), // Combat End
* (Color)cc.ConvertFrom("#FFCEE6F4"), // Starts Using
* (Color)cc.ConvertFrom("#FFEEFBDD"), // Action
* (Color)cc.ConvertFrom("#FFEFF6FB"), // Effect
* (Color)cc.ConvertFrom("#FFFFDA97"), // Marker
* (Color)cc.ConvertFrom("#FFFFFFFF"), // Added
* (Color)cc.ConvertFrom("#FFFFFFFF"), // HP Rate
* (Color)cc.ConvertFrom("#FFD8D8D8"), // Dialog
*/
(Color)cc.ConvertFrom("#FFFFFFFF"), // UNKNOWN
(Color)cc.ConvertFrom("#FFDC143C"), // Combat Start
(Color)cc.ConvertFrom("#FFDC143C"), // Combat End
(Color)cc.ConvertFrom("#FF4169E1"), // Starts Using
(Color)cc.ConvertFrom("#FF98fb98"), // Action
(Color)cc.ConvertFrom("#FFF0E68C"), // Effect
(Color)cc.ConvertFrom("#FFFFA500"), // Marker
(Color)cc.ConvertFrom("#00000000"), // Added
(Color)cc.ConvertFrom("#00000000"), // HP Rate
(Color)cc.ConvertFrom("#FFD8D8D8"), // Dialog
}[(int)t];
private Line GetFreeLine(LogTypes logType)
{
Line line;
if (lineCount >= MaxLines)
{
line = first;
first = first.Next;
line.Next = null;
}
else // lineCount < MaxLines
{
line = new Line();
++lineCount;
}
if (first == null)
{
first = line;
last = line;
}
if (line != first)
{
last.Next = line;
}
last = line;
line.LogType = logType;
line.Buffer.Length = 0;
AppendColorTag(line);
return(line);
}
public void Publisher()
{
try
{
var logNames = Enum.GetValues(typeof(LogTypes));
var factory = new ConnectionFactory();
factory.HostName = "localhost";
using (var connection = factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: "system-logs", durable: true, type: ExchangeType.Direct);
var propertis = channel.CreateBasicProperties();
propertis.Persistent = true;
for (int i = 0; i < 11; i++)
{
Random random = new Random();
LogTypes logType = (LogTypes)logNames.GetValue(random.Next(logNames.Length));
var body = Encoding.UTF8.GetBytes($"log={logType.ToString()}");
channel.BasicPublish("system-logs", routingKey: logType.ToString(), propertis, body: body);
}
Console.WriteLine("Mesaj Direct Exchange'e gönderilmiştir");
Console.ReadLine();
}
}
}
catch (Exception exception)
{
throw new Exception(exception.Message);
}
}
void CheckLogs(KeyCode keyCode, LogTypes logTypes, string format = "")
{
if (Input.GetKeyUp(keyCode))
{
UpdateLogs(logTypes, format);
}
}
/// <summary>
/// Format message for the trace
/// </summary>
private static string GetFormatedMessage(LogTypes logType, string message, bool isGlobalTrace)
{
string LogType = string.Empty;
switch (logType)
{
case LogTypes.Generic: LogType = " "; break;
case LogTypes.SQL: LogType = "S"; break;
case LogTypes.Stack: LogType = "#"; break;
case LogTypes.Exception: LogType = "X"; break;
case LogTypes.Error: LogType = "E"; break;
default: LogType = " "; break;
}
//fileID part
string fileID = string.Empty;
//need to add when current trace is global and FileID isn't empty
if (isGlobalTrace && !string.IsNullOrEmpty(FileID))
{
fileID = string.Format("{0,-4} |", FileID);
}
return(string.Format("{0}{1,-10}|{2}{3}{4,-2}|{5}", fileID, DateTime.Now.ToString("HH:mm:ss"), "", "", LogType, message));
}
/// <summary>
/// Formats a given message to the log stream
/// </summary>
/// <param name="message"></param>
/// <param name="type"></param>
/// <param name="context"></param>
private static void Write(string message, LogTypes type, object context)
{
if ((allowed & type) == LogTypes.None)
{
return;
}
if (!Streaming)
{
return;
}
DateTime now = DateTime.Now;
string line = now.ToString(DATE_FORMAT) + " - {" + type + "}||";
line += "\t" + message;
if (context != null)
{
line += "\n{Context}" + context.ToString();
}
if (ConsoleStream)
{
Console.WriteLine(line);
}
writer.WriteLine(line);
writer.Flush();
LogOccured?.Invoke(new LogEventArgs()
{
Log = message, LogContext = context, LogType = type
});
}
/// <summary>
/// Sets the stream so that logging takes place
/// <para></para>
/// If a stream is already occuring, that stream gets closed, and replaced.
/// <para></para>
/// By default, all log types are enabled
/// </summary>
/// <param name="ToSet">The stream you would like the information to be logged to</param>
/// <param name="AllowedLoggingTypes">The allowed log types</param>
public static void SetStream(Stream ToSet, bool outputToConsole = false, LogTypes AllowedLoggingTypes = (LogTypes)31)
{
EndStream();
allowed = AllowedLoggingTypes;
writer = new StreamWriter(ToSet);
ConsoleStream = outputToConsole;
}
private void SetLogger(LogTypes type, string text)
{
if ((LogTypes & type) == type)
{
_logQueue.Add(type == LogTypes.None ? Tuple.Create(type, string.Empty, text) : Tuple.Create(type, DateTime.Now.ToString("T"), text));
}
}
public static void Log(LogTypes type, string msg)
{
if (type != LogTypes.Default)
{
Console.Write("[ ");
switch (type)
{
case LogTypes.Listening: Console.ForegroundColor = ConsoleColor.Yellow; break;
case LogTypes.Kill: Console.ForegroundColor = ConsoleColor.Yellow; break;
case LogTypes.Request: Console.ForegroundColor = ConsoleColor.Yellow; break;
case LogTypes.Response: Console.ForegroundColor = ConsoleColor.Yellow; break;
case LogTypes.Error: Console.ForegroundColor = ConsoleColor.Red; break;
case LogTypes.Output: Console.ForegroundColor = ConsoleColor.Green; break;
default: Console.ForegroundColor = ConsoleColor.Magenta; break;
}
Console.Write(type);
Console.ForegroundColor = ConsoleColor.White;
Console.Write(" ] ");
}
Console.WriteLine(msg);
}
private static StreamWriter GetStreamWriter(LogTypes logType)
{
LogFilePoolItem item;
DateTime now = TimeUtil.NowDateTime();
lock (mutex)
{
if (!LogType2FileDict.TryGetValue(logType, out item))
{
item = new LogFilePoolItem();
LogType2FileDict.Add(logType, item);
}
if (now.Hour != item.OpenTimeOnHours || now.DayOfYear != item.OpenTimeOnDayOfYear || item._StreamWriter == null)
{
if (null != item._StreamWriter)
{
item._StreamWriter.Close();
item._StreamWriter = null;
}
item._StreamWriter = File.AppendText(LogPath + logType.ToString() + "_" + now.ToString("yyyyMMdd") + ".log");
item.OpenTimeOnHours = now.Hour;
item.OpenTimeOnDayOfYear = now.DayOfYear;
item._StreamWriter.AutoFlush = true;
}
return(item._StreamWriter);
}
}
private static NLog.LogLevel ConvertLogLevel(LogTypes logType)
{
switch (logType)
{
case LogTypes.Debug:
return(NLog.LogLevel.Debug);
case LogTypes.Error:
return(NLog.LogLevel.Error);
case LogTypes.Fatal:
return(NLog.LogLevel.Fatal);
case LogTypes.Info:
return(NLog.LogLevel.Info);
case LogTypes.Trace:
return(NLog.LogLevel.Trace);
case LogTypes.Warn:
return(NLog.LogLevel.Warn);
default:
return(NLog.LogLevel.Off);
}
}
public static void Write(string logger, LogTypes logType, string message)
{
log4net.ILog log = mainLog;
if (!string.IsNullOrEmpty(logger))
{
log = log4net.LogManager.GetLogger(logger);
}
switch (logType)
{
case LogTypes.Error:
log.Error(message);
break;
case LogTypes.Warning:
log.Warn(message);
break;
case LogTypes.Info:
log.Info(message);
break;
case LogTypes.Debug:
log.Debug(message);
break;
default:
log.Error(message);
break;
}
}
/// <summary>
/// Adds the specified log item to the log.
/// </summary>
/// <param name="type">The log type.</param>
/// <param name="user">The user adding the item.</param>
/// <param name="nodeId">The affected node id.</param>
/// <param name="comment">Comment.</param>
public static void Add(LogTypes type, User user, int nodeId, string comment)
{
if (Instance.ExternalLogger != null)
{
Instance.ExternalLogger.Add(type, user, nodeId, comment);
if (!UmbracoSettings.ExternalLoggerLogAuditTrail)
{
AddLocally(type, user, nodeId, comment);
}
}
else
{
if (!UmbracoSettings.EnableLogging) return;
if (UmbracoSettings.DisabledLogTypes != null &&
UmbracoSettings.DisabledLogTypes.SelectSingleNode(String.Format("//logTypeAlias [. = '{0}']", type.ToString().ToLower())) == null)
{
if (comment != null && comment.Length > 3999)
comment = comment.Substring(0, 3955) + "...";
if (UmbracoSettings.EnableAsyncLogging)
{
ThreadPool.QueueUserWorkItem(
delegate { AddSynced(type, user == null ? 0 : user.Id, nodeId, comment); });
return;
}
AddSynced(type, user == null ? 0 : user.Id, nodeId, comment);
}
}
}
public static void Log(string s, string objectName, LogTypes severity = LogTypes.Debug)
{
if (!_LogEnabled)
{
return;
}
if (severity < _LogThreshold)
{
return;
}
try
{
lock (_classLock)
{
if (_Output == null)
{
_Output = new System.IO.StreamWriter(_LogFile, true, System.Text.UnicodeEncoding.Default);
}
_Output.WriteLine(System.DateTime.Now.ToShortDateString() + " " + System.DateTime.Now.ToString("hh:mm:ss.fff tt") +
"[" + severity.ToString() + "]" + " [" + objectName + "] - " + s, new object[0]);
if (_Output != null)
{
_Output.Close();
_Output = null;
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message, new object[0]);
}
}
public void Log(LogTypes logTypes, Instruction instruction, MethodDefinition methodDefinition, object arg)
{
var next = instruction;
while (next != null)
{
var result = methodDefinition.DebugInformation.GetSequencePoint(next);
if (result != null)
{
this.Log(logTypes, result, arg);
return;
}
next = next.Next;
}
var previous = instruction;
while (previous != null)
{
var result = methodDefinition.DebugInformation.GetSequencePoint(previous);
if (result != null)
{
this.Log(logTypes, result, arg);
return;
}
previous = previous.Previous;
}
this.Log(logTypes, methodDefinition, arg);
}
public void Message(LogTypes logType, string text)
{
lock (_syncObject)
{
SetLogger(logType, text);
}
}
private void LogMessage(LogTypes messageType, String str)
{
String message = "";
// Message header
switch (messageType)
{
case LogTypes.Error:
message = "[Err] ";
break;
case LogTypes.Warning:
message = "[Wrn] ";
break;
case LogTypes.Info:
message = "[Msg] ";
break;
}
message += str;
LogMessageBox.BeginUpdate();
LogMessageBox.Items.Add(message);
LogMessageBox.EndUpdate();
}
public void Log(LogTypes logTypes, SequencePoint sequencePoint, object arg)
{
switch (logTypes)
{
case LogTypes.Error:
if (sequencePoint == null)
{
this.logError(arg as string ?? arg?.ToString() ?? "");
}
else
{
this.logErrorPoint(arg as string ?? arg?.ToString() ?? "", sequencePoint);
}
break;
case LogTypes.Warning:
if (sequencePoint == null)
{
this.logWarning(arg as string ?? arg?.ToString() ?? "");
}
else
{
this.logWarningPoint(arg as string ?? arg?.ToString() ?? "", sequencePoint);
}
break;
case LogTypes.Info:
this.logInfo(arg as string ?? arg?.ToString() ?? "");
break;
}
}
/// <summary>
/// Adds the specified log item to the log.
/// </summary>
/// <param name="type">The log type.</param>
/// <param name="user">The user adding the item.</param>
/// <param name="nodeId">The affected node id.</param>
/// <param name="comment">Comment.</param>
public static void Add(LogTypes type, User user, int nodeId, string comment)
{
if (Instance.ExternalLogger != null)
{
Instance.ExternalLogger.Add(type, user, nodeId, comment);
if (UmbracoConfig.For.UmbracoSettings().Logging.ExternalLoggerEnableAuditTrail == false)
{
AddLocally(type, user, nodeId, comment);
}
}
else
{
if (UmbracoConfig.For.UmbracoSettings().Logging.EnableLogging == false) return;
if (UmbracoConfig.For.UmbracoSettings().Logging.DisabledLogTypes.Any(x => x.LogTypeAlias.InvariantEquals(type.ToString())) == false)
{
if (comment != null && comment.Length > 3999)
comment = comment.Substring(0, 3955) + "...";
if (UmbracoConfig.For.UmbracoSettings().Logging.EnableAsyncLogging)
{
ThreadPool.QueueUserWorkItem(
delegate { AddSynced(type, user == null ? 0 : user.Id, nodeId, comment); });
return;
}
AddSynced(type, user == null ? 0 : user.Id, nodeId, comment);
}
}
}
protected override void LogRecord(string message, LogTypes logTypes)
{
string logRecord = base.GetLogRecord(message, logTypes);
_logFileWriter.WriteLine(logRecord);
_logFileWriter.Flush();
}
public static IRecordsReader GetLogReader(LogTypes Type, DateTime SinceDate)
{
return(SqlHelper.ExecuteReader(
"select userId, NodeId, DateStamp, logHeader, logComment from umbracoLog where logHeader = @logHeader and DateStamp >= @dateStamp order by dateStamp desc",
SqlHelper.CreateParameter("@logHeader", Type.ToString()),
SqlHelper.CreateParameter("@dateStamp", SinceDate)));
}
/// <summary>
/// Adds a log item to the log immidiately instead of Queuing it as a work item.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="userId">The user id.</param>
/// <param name="nodeId">The node id.</param>
/// <param name="comment">The comment.</param>
public static void AddSynced(LogTypes type, int userId, int nodeId, string comment)
{
var logTypeIsAuditType = type.GetType().GetField(type.ToString()).GetCustomAttributes(typeof(AuditTrailLogItem), true).Length != 0;
if (logTypeIsAuditType)
{
try
{
SqlHelper.ExecuteNonQuery(
"insert into umbracoLog (userId, nodeId, logHeader, logComment) values (@userId, @nodeId, @logHeader, @comment)",
SqlHelper.CreateParameter("@userId", userId),
SqlHelper.CreateParameter("@nodeId", nodeId),
SqlHelper.CreateParameter("@logHeader", type.ToString()),
SqlHelper.CreateParameter("@comment", comment));
}
catch (Exception e)
{
LogHelper.Error <Log>("An error occurred adding an audit trail log to the umbracoLog table", e);
}
//Because 'Custom' log types are also Audit trail (for some wacky reason) but we also want these logged normally so we have to check for this:
if (type != LogTypes.Custom)
{
return;
}
}
//if we've made it this far it means that the log type is not an audit trail log or is a custom log.
LogHelper.Info <Log>(
"Redirected log call (please use Umbraco.Core.Logging.LogHelper instead of umbraco.BusinessLogic.Log) | Type: {0} | User: {1} | NodeId: {2} | Comment: {3}",
() => type.ToString(), () => userId, () => nodeId.ToString(CultureInfo.InvariantCulture), () => comment);
}
public static IServiceCollection DeactivateLogTypes(
this IServiceCollection services,
LogTypes logTypes)
{
s_DefaultLogTypes &= ~logTypes;
return(services);
}
public static void Initialize(string file)
{
config = new Config(file, true);
if (config != null)
{
LogLevel = config.Read("Log.Level", LogTypes.Success | LogTypes.Info);
LogDirectory = config.Read("Log.Directory", "Logs/Bnet");
LogConsoleFile = config.Read("Log.Console.File", "");
LogDatabaseFile = config.Read("Log.Database.File", "");
LogPacketFile = config.Read("Log.Packet.File", "");
LogFile fl = null;
if (LogConsoleFile != "")
{
if (!Directory.Exists(LogDirectory))
{
Directory.CreateDirectory(LogDirectory);
}
fl = new LogFile(LogDirectory, LogConsoleFile);
}
Log.Initialize(LogLevel, fl);
initialized = true;
}
if (initialized)
{
ReadConfig();
}
}
public static void TopicExchangeSendQueue(string msg)
{
var logNames = Enum.GetValues(typeof(LogTypes));
string routeKey = string.Empty;
ConnectionFactory factory = new ConnectionFactory();
factory.HostName = "localhost";
using (var connection = factory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: "system-logs", durable: true, type: ExchangeType.Topic);
for (int i = 0; i < 11; i++)
{
Random random = new Random();
LogTypes logType1 = (LogTypes)logNames.GetValue(random.Next(logNames.Length));
LogTypes logType2 = (LogTypes)logNames.GetValue(random.Next(logNames.Length));
LogTypes logType3 = (LogTypes)logNames.GetValue(random.Next(logNames.Length));
routeKey = $"{logType1}.{logType2}.{logType3}";
string message = String.Concat("log=Test", i.ToString());
var body = Encoding.UTF8.GetBytes(message);
channel.BasicPublish("system-logs", routingKey: routeKey, body: body);
Console.WriteLine($"Mesaj=>{message} <=> Routing Key=>{routeKey}");
}
}
}
public static void Start(LogTypes logTypes, LogFile logFile = null)
{
logger = logger ?? new Logger {
LogTypes = logTypes
};
logger?.Start(logFile);
}
public static void WriteLog(LogTypes type, string msg, params object[] pObjects)
{
FileWriter.Write(Constants.LogWriting, string.Format(msg + "\n", pObjects));
string tab = "";
for (int i = 1; i > (type.ToString().Length / 8); i--)
{
tab += "\t";
}
if (type == LogTypes.Debug)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.Write(" Debug" + tab + "| ");
}
else if (type == LogTypes.Info)
{
Console.ForegroundColor = ConsoleColor.Gray;
Console.Write(" Info" + tab + "| ");
}
else if (type == LogTypes.LList)
{
Console.ForegroundColor = ConsoleColor.DarkMagenta;
Console.Write(" Lobby" + tab + "| ");
}
else if (type == LogTypes.CDisp)
{
Console.ForegroundColor = ConsoleColor.DarkGray;
Console.Write(" CDisp" + tab + "| ");
}
else if (type == LogTypes.HEmi)
{
Console.ForegroundColor = ConsoleColor.Magenta;
Console.Write(" Hell" + tab + "| ");
}
else if (type == LogTypes.Warning)
{
Console.ForegroundColor = ConsoleColor.DarkYellow;
Console.Write(" Warning" + tab + "| ");
}
else if (type == LogTypes.Error)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Write(" Error" + tab + "| ");
}
else if (type == LogTypes.Connect)
{
Console.ForegroundColor = ConsoleColor.DarkGreen;
Console.Write(" Connect" + tab + "| ");
}
else if (type == LogTypes.Disconnect)
{
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.Write(" Disconnect" + tab + "| ");
}
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(msg, pObjects);
if (mCommandEnabled)
Console.Write("> {0}", mCommandBuffer);
}
public LogItem(string message, LogTypes type, LogDataFormat format)
{
date = DateTime.Now;
SortMessage = message;
LongMessage = date + " : " + message;
MessageType = type;
MessageColor = SetColorByType(type);
}
public virtual void Write(string message, LogTypes logType)
{
Write(new LogLine()
{
Message = message,
LogType = logType
});
}
/// <summary>
/// Fьgt dem Datenbankkontext einen Logeintrag hinzu.
/// </summary>
/// <param name="logText">Text fьr den Logeintrag.</param>
/// <param name="type">Typ des Logeintrages.</param>
/// <param name="tableName">Tabellenname des betroffenen Datensatzes.</param>
public void WriteLogItem(string logText, LogTypes type, string tableName)
{
if (string.IsNullOrEmpty(tableName))
{
throw new Exception("Der Tabellenname darf nicht leer sein.");
}
this.Systemlog.InsertOnSubmit(this.GetLogItem(logText, type, null, tableName, null, null));
}
protected override void WriteToLog(LogTypes logType, string message)
{
SetListenerStyle(logType);
this.listener.EditStream.Wputs(message + Environment.NewLine);
this.listener.EditStream.Flush();
ResetListenerStyle();
}
public LogEntry(LogEntry.LogTypes logType, DateTime timeStamp, string message, StackTrace stacktrace, object[] oparams, Exception exception, Thread thread)
{
_logType = logType;
_timeStamp = timeStamp;
_message = message;
_stacktrace = stacktrace;
_params = oparams;
_exception = exception;
_thread = thread;
}
public void AddLog(string msg, LogTypes type, string ip)
{
var log = new Log
{
Date = DateTime.UtcNow,
LogMessage = msg,
UserId = UserSession.CurrentUserId,
LogType = type,
IPAddress = ip
};
_db.Logs.Add(log);
_db.SaveChanges();
}
//NOTE: idea have a vector of tables which get called and their address can be swapped depending
//on circumstances, for example: say we have the following function addTab, there is only one time
//we want to check if currentOpenTabIndex is equivalent to the space character. After the first
//time checking we would rather not have to encure the cost of checking every time afterwards.
//so if we make another function named say addTabAfterInitalChecks, which was exactly the same
//as addTab but with out the three lines for the if statement check in it and then we took
//and switched the function address that is called when calling addTab to now be calling
//addTabAfterInitialChecks, in the if statement then the program from now on will only be
//adding new chars without the extra check.
public bool addTab(LogTypes logtype, char tabIndexChar, string tabName, ConsoleColor tabColor )
{
if (!tabs.ContainsKey(logtype))
{
if (tabs.Count == 0)
{
currentOpenTabIndex = logtype;
//here would be where you would make the call to switch the function address
//to the new fucntion without this if statement in it.
}
tabs.Add(logtype, new Utilities.Triplet<char, string, ConsoleColor>(tabIndexChar, tabName, tabColor));
return true;
}
LogManager.getInstance.log(LogTypes.ErrorLog, "Log Type : " + logtype + " already exists\n");
return false;
}
public void Log(string content, LogTypes logType = LogTypes.Log)
{
var now = DateTime.Now;
if (this.SimpleMode) {
this.Print(content,now,logType);
return;
}
var output = "====================================================\r\n";
output += "@Log:" + Enum.GetName(typeof(LogTypes), logType) + "\r\n";
output += "@At:" + now.ToString("yyyy-MM-dd hh:mm:ss") + "." + now.Millisecond.ToString() + "\r\n";
output += content + "\r\n\r\n";
lock (this.Locker) {
this.Print(output,now,logType);
}
}
private void SetListenerStyle(LogTypes logType)
{
switch (logType)
{
case LogTypes.Debug:
this.listener.SetStyle(DebugStyle);
break;
case LogTypes.Error:
this.listener.SetStyle(ErrorStyle);
break;
case LogTypes.Warning:
this.listener.SetStyle(ErrorStyle);
break;
default:
this.listener.SetStyle(InfoStyle);
break;
}
}
// DATE: GREEN
/// <summary>
/// Adds to log.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="type">The type.</param>
public void addToLog(string message, LogTypes type)
{
lock (this)
{
Console.ResetColor();
string dateString = "[ " + DateTime.Now.ToShortDateString() + " " + DateTime.Now.ToLongTimeString() +
" ] ";
switch (type)
{
case LogTypes.IAL:
Console.ForegroundColor = ConsoleColor.Green;
Console.Write(dateString);
Console.ForegroundColor = ConsoleColor.Yellow;
this._ialLogger.WriteLine(dateString + message);
Console.WriteLine("I " + message);
break;
case LogTypes.Command:
Console.ForegroundColor = ConsoleColor.Green;
Console.Write(dateString);
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("C " + message);
break;
case LogTypes.General:
Console.ForegroundColor = ConsoleColor.Green;
Console.Write(dateString);
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("G " + message);
break;
case LogTypes.Error:
Console.ForegroundColor = ConsoleColor.Green;
Console.Write(dateString);
Console.ForegroundColor = ConsoleColor.Red;
this._errorLogger.WriteLine(dateString + message);
Console.WriteLine("E " + message);
break;
default:
break;
}
Console.ResetColor();
}
}
private SolidColorBrush SetColorByType(LogTypes type)
{
switch (type)
{
case LogTypes.Error:
return Brushes.Red;
case LogTypes.Info:
return Brushes.Black;
case LogTypes.Incoming:
return Brushes.Green;
case LogTypes.Outgoing:
return Brushes.Blue;
case LogTypes.Fail:
return Brushes.Purple;
case LogTypes.Settings:
return Brushes.Gray;
default:
return Brushes.Black;
}
}
public LogItem(DetectorMessage message, string text, LogTypes type, LogDataFormat Format)
{
date = DateTime.Now;
Message = message;
SortMessage = text;
MessageType = type;
MessageColor = SetColorByType(type);
LongMessage = date + " : " + text + " ";
switch(Format)
{
case LogDataFormat.ASCII:
LongMessage += message.DataASCII;
break;
case LogDataFormat.HEX:
LongMessage += message.DataHEX;
break;
case LogDataFormat.Decimal:
LongMessage += message.DataInt;
break;
}
}
internal static IRecordsReader GetLogReader(User user, LogTypes type, DateTime sinceDate, int numberOfResults)
{
if (SqlHelper is umbraco.DataLayer.SqlHelpers.MySql.MySqlHelper)
{
return SqlHelper.ExecuteReader(
"select userId, NodeId, DateStamp, logHeader, logComment from umbracoLog where UserId = @user and logHeader = @logHeader and DateStamp >= @dateStamp order by dateStamp desc limit " + numberOfResults,
SqlHelper.CreateParameter("@logHeader", type.ToString()),
SqlHelper.CreateParameter("@user", user.Id),
SqlHelper.CreateParameter("@dateStamp", sinceDate));
}
else
{
return SqlHelper.ExecuteReader(
"select top " + numberOfResults + " userId, NodeId, DateStamp, logHeader, logComment from umbracoLog where UserId = @user and logHeader = @logHeader and DateStamp >= @dateStamp order by dateStamp desc",
SqlHelper.CreateParameter("@logHeader", type.ToString()),
SqlHelper.CreateParameter("@user", user.Id),
SqlHelper.CreateParameter("@dateStamp", sinceDate));
}
}
internal static IRecordsReader GetLogReader(User user, LogTypes type, DateTime sinceDate, int numberOfResults)
{
var query = "select {0} userId, NodeId, DateStamp, logHeader, logComment from umbracoLog where UserId = @user and logHeader = @logHeader and DateStamp >= @dateStamp order by dateStamp desc {1}";
query = ApplicationContext.Current.DatabaseContext.DatabaseProvider == DatabaseProviders.MySql
? string.Format(query, string.Empty, "limit 0," + numberOfResults)
: string.Format(query, "top " + numberOfResults, string.Empty);
return SqlHelper.ExecuteReader(query,
SqlHelper.CreateParameter("@logHeader", type.ToString()),
SqlHelper.CreateParameter("@user", user.Id),
SqlHelper.CreateParameter("@dateStamp", sinceDate));
}
public static void Loggitt(string title,string msg, LogTypes type)
{
//if (!(System.IO.Directory.Exists(@"C:\Temp\TrimMail\")))
//{
// System.IO.Directory.CreateDirectory(@"C:\Temp\TrimMail\");
//}
string strLogPrefix = null;
switch (type)
{
case LogTypes.log:
strLogPrefix = "errlog_";
break;
case LogTypes.err:
strLogPrefix = "log_";
break;
case LogTypes.dir:
strLogPrefix = "IncorrectDirlog__";
break;
}
//if (Error)
//{
// strLogPrefix = "errlog_";
//}
//else
//{
// strLogPrefix = "log_";
//}
FileStream fs = new FileStream(strWorkingLocation+ "\\" + strLogPrefix + DateTime.Today.ToShortDateString().Replace("/", "") + ".txt", FileMode.OpenOrCreate, FileAccess.ReadWrite);
StreamWriter s = new StreamWriter(fs);
s.Close();
fs.Close();
FileStream fs1 = new FileStream(strWorkingLocation + "\\" + strLogPrefix + DateTime.Today.ToShortDateString().Replace("/", "") + ".txt", FileMode.Append, FileAccess.Write);
StreamWriter s1 = new StreamWriter(fs1);
s1.Write("Title: " + title + Environment.NewLine);
s1.Write("Message: " + msg + Environment.NewLine);
//s1.Write("StackTrace: " + stkTrace + Environment.NewLine);
s1.Write("Date/Time: " + DateTime.Now.ToString() + Environment.NewLine);
s1.Write
("============================================" + Environment.NewLine);
s1.Close();
fs1.Close();
}
protected override void Print(string content, DateTime now, LogTypes logType)
{
var file = this.GetFilename(now, logType);
this.Storage.AppendText(file,content);
}
protected virtual string GetFilename(DateTime now, LogTypes logType) {
var path = now.Year.ToString("0000") + now.Month.ToString("00") + "/" + now.Day.ToString("00");
path += "/" + Enum.GetName(typeof(LogTypes), logType) + "." + now.Hour.ToString("00") + ".log";
return path;
}
/// <summary>
/// 通知文字列を表示
/// </summary>
/// <param name="text"></param>
/// <param name="forceScroll"></param>
/// <param name="type"></param>
private void WriteNotice(string text, bool forceScroll, LogTypes type)
{
if (!this.IsLogFollowing.Value)
{
return;
}
if (type == LogTypes.Notice)
{
Application.Current.Dispatcher.Invoke
(() => { if (!this.IsDisposed) { this.NoticeText.Value = text; } });
if (!this.IsNoticeEnabled.Value)
{
return;
}
}
text = text.Replace("\r\n", "\n").Replace("\r", "\n");
this.ActionQueueSubject.OnNext(new RequestContainer()
{
Text = text + "\n",
Brush = new TextBrush(type.GetColor(), 0, text.Length),
Scroll = forceScroll,
NewLine = true,
});
//this.ActionQueueSubject.OnNext(() =>
//{
// if (this.AppendableTextController.LastText?.Length > 0)
// {
// text = "\n" + text;
// }
//
// this.WriteMain(text + "\n", new TextBrush(type.GetColor(), 0, text.Length));
//
// if (forceScroll)
// {
// this.ScrollToBottom();
// }
//});
}
public static IRecordsReader GetLogReader(User user, LogTypes Type, DateTime SinceDate)
{
return SqlHelper.ExecuteReader(
"select userId, NodeId, DateStamp, logHeader, logComment from umbracoLog where UserId = @user and logHeader = @logHeader and DateStamp >= @dateStamp order by dateStamp desc",
SqlHelper.CreateParameter("@logHeader", Type.ToString()),
SqlHelper.CreateParameter("@user", user.Id),
SqlHelper.CreateParameter("@dateStamp", SinceDate));
}
public List<LogItem> GetLogItems(User user, LogTypes type, DateTime sinceDate)
{
if (ExternalLogger != null)
return ExternalLogger.GetLogItems(user, type, sinceDate);
return LogItem.ConvertIRecordsReader(SqlHelper.ExecuteReader(
"select userId, NodeId, DateStamp, logHeader, logComment from umbracoLog where UserId = @user and logHeader = @logHeader and DateStamp >= @dateStamp order by dateStamp desc",
SqlHelper.CreateParameter("@logHeader", type),
SqlHelper.CreateParameter("@user", user.Id),
SqlHelper.CreateParameter("@dateStamp", sinceDate)));
}
/// <summary>
/// Adds a log item to the log immidiately instead of Queuing it as a work item.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="userId">The user id.</param>
/// <param name="nodeId">The node id.</param>
/// <param name="comment">The comment.</param>
public static void AddSynced(LogTypes type, int userId, int nodeId, string comment)
{
var logTypeIsAuditType = type.GetType().GetField(type.ToString()).GetCustomAttributes(typeof(AuditTrailLogItem), true).Length != 0;
if (logTypeIsAuditType)
{
try
{
SqlHelper.ExecuteNonQuery(
"insert into umbracoLog (userId, nodeId, logHeader, logComment) values (@userId, @nodeId, @logHeader, @comment)",
SqlHelper.CreateParameter("@userId", userId),
SqlHelper.CreateParameter("@nodeId", nodeId),
SqlHelper.CreateParameter("@logHeader", type.ToString()),
SqlHelper.CreateParameter("@comment", comment));
}
catch (Exception e)
{
LogHelper.Error<Log>("An error occurred adding an audit trail log to the umbracoLog table", e);
}
//Because 'Custom' log types are also Audit trail (for some wacky reason) but we also want these logged normally so we have to check for this:
if (type != LogTypes.Custom)
{
return;
}
}
//if we've made it this far it means that the log type is not an audit trail log or is a custom log.
LogHelper.Info<Log>(
"Redirected log call (please use Umbraco.Core.Logging.LogHelper instead of umbraco.BusinessLogic.Log) | Type: {0} | User: {1} | NodeId: {2} | Comment: {3}",
() => type.ToString(), () => userId, () => nodeId.ToString(CultureInfo.InvariantCulture), () => comment);
}
/// <summary>
/// Adds the specified log item to the log without any user information attached.
/// </summary>
/// <param name="type">The log type.</param>
/// <param name="nodeId">The affected node id.</param>
/// <param name="comment">Comment.</param>
public static void Add(LogTypes type, int nodeId, string comment)
{
Add(type, null, nodeId, comment);
}
/// <summary>
/// Adds the specified log item to the Umbraco log no matter if an external logger has been defined.
/// </summary>
/// <param name="type">The log type.</param>
/// <param name="user">The user adding the item.</param>
/// <param name="nodeId">The affected node id.</param>
/// <param name="comment">Comment.</param>
public static void AddLocally(LogTypes type, User user, int nodeId, string comment)
{
if (comment.Length > 3999)
comment = comment.Substring(0, 3955) + "...";
if (UmbracoSettings.EnableAsyncLogging)
{
ThreadPool.QueueUserWorkItem(
delegate { AddSynced(type, user == null ? 0 : user.Id, nodeId, comment); });
return;
}
AddSynced(type, user == null ? 0 : user.Id, nodeId, comment);
}
public LogItem(int userId, int nodeId, DateTime timestamp, LogTypes logType, string comment)
{
UserId = userId;
NodeId = nodeId;
Timestamp = timestamp;
LogType = logType;
Comment = comment;
}
public static void Write(LogTypes logType, string message)
{
Write(null, logType, message);
}
