/// <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 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);
}
}
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 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]);
}
}
/// <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 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)));
}
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);
}
}
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);
}
internal static IRecordsReader GetLogReader(User user, LogTypes type, DateTime sinceDate, int numberOfResults)
{
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)));
}
public void LogWithCategory(LogTypes i_type, string i_message, string i_category)
{
string prefix = "(" + i_type.ToString() + ")";
i_message = string.IsNullOrEmpty(i_category) ? prefix + i_message : prefix + i_category + ": " + i_message;
UnityEngine.Debug.Log(i_message);
}
public static IRecordsReader GetLogReader(User user, LogTypes Type, DateTime SinceDate)
{
using (var sqlHelper = Application.SqlHelper)
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)));
}
private static void WriteToFile(LogTypes type, string log)
{
log = string.Format("{0}: {1}! {2}\n", DateTime.Now, type.ToString(), log);
using (FileStream stream = new FileStream(logFileName, FileMode.Append, FileAccess.Write))
{
byte[] bytes = Encoding.Default.GetBytes(log);
stream.Write(bytes, 0, bytes.Length);
stream.Flush();
}
}
public static void WriteLog(LogTypes logType, string logMsg)
{
if (logType >= LogManager.LogTypeToWrite)
{
lock (LogManager.mutex)
{
LogManager.WriteLog(logType.ToString(), logMsg);
}
}
}
public async Task LogAction(LogTypes logType, string message)
{
_context.Logging.Add(new Logging()
{
LoggingDate = DateTime.Now,
LoggingMessage = message,
LoggingType = logType.ToString()
});
await _context.SaveChangesAsync();
}
private void WriteLog(LogTypes LogType, string FullPathSrc, string FullPathSrcNew, string FullPathDest, Exception ex)
{
string FullPath = Path.Combine(this._LogFolder, LogType.ToString() + DateTime.Now.ToString("yyyyMMdd") + ".log");
string Log = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")
+ "\t" + FullPathSrc
+ (!string.IsNullOrEmpty(FullPathSrcNew) ? "(" + FullPathSrcNew + ")" : "")
+ "\t" + FullPathDest
+ "\t" + ((ex != null) ? CInfo.GetExceptionText(ex) : "");
_Logging.WriteLog(FullPath, Log);
}
public static void Log(LogTypes type, string log)
{
//prepare file name.
var file = type.ToString() + ".log";
//if dir not there, make it.
Directory.CreateDirectory("Logs");
//Append
ThreadPool.QueueUserWorkItem(WriteToFile, new [] { "Logs/" + file, $"[{DateTime.Now:R}] " + log });
}
public void RecordLog(LogTypes logTypes, params string[] messages)
{
_builder.Clear();
_builder.AppendLine();
_builder.AppendLine(logTypes.ToString());
_builder.AppendLine(DateTime.Now.ToString());
for (int i = 0; i < messages.Length; i++)
{
_builder.AppendLine(messages[i]);
}
File.AppendAllText(_fileProvider.ProvideFile(), _builder.ToString());
}
/// <summary>
/// 写入一行日志
/// </summary>
/// <param name="LogMessage">日志消息</param>
/// <param name="LogType">日志类型</param>
public static void WriteLog(string LogMessage, LogTypes LogType = LogTypes.INFO)
{
string Message = string.Format(
@"\{0}/ <{1}> {2}",
DateTime.Now.ToString("yyyy/MM/dd-hh:mm:ss.fff"),
LogType.ToString().PadRight(5),
LogMessage
);
LogListener?.WriteLine(Message);
System.Diagnostics.Debug.Print(Message);
}
/// <summary>
/// 写日志
/// </summary>
/// <param name="logType">日志类型</param>
/// <param name="logMsg">日志信息</param>
public static void WriteLog(LogTypes logType, string logMsg)
{
if ((int)logType < (int)LogTypeToWrite) //不必记录
{
return;
}
lock (mutex)
{
WriteLog(logType.ToString(), logMsg);
}
}
private void AppendLog(LogTypes logType, string section, string method, string text)
{
try
{
//string fullName = Path.Combine(Global.DATA_PATH, Global.LOG_NAME);
string fullName = "TapecartFlasher.log";
File.AppendAllText(fullName, $"{DateTime.Now:dd.MM.yyyy HH:mm:ss} {logType.ToString().PadRight(5)} [{section}] [{method}] {text}\r\n");
}
catch (Exception)
{
}
}
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 DirectExchangeSendQueue(string msg)
{
var logNames = Enum.GetValues(typeof(LogTypes));
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.Direct);
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(), body: body);
}
}
}
public void Write(String message, LogTypes type)
{
var category = type.ToString();
var fileName = String.Format("{0}-{1}.log", DateTime.Now.ToString("dd-MM-yyyy"), category);
var path = HttpContext.Current.Server.MapPath("~/Logs");
var FileName = Path.Combine(path, fileName);
lock (Locker)
{
File.AppendAllText(FileName,
String.Format("{0} | {1}\r\n", DateTime.Now.ToString("[HH:mm:ss]"), message));
}
}
/// <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)
{
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)
{
Debug.WriteLine(e.ToString(), "Error");
Trace.WriteLine(e.ToString());
}
}
/// <summary>
/// Write a line of formatted log message into a log file
/// </summary>
/// <param name="text">Formatted log message</param>
/// <param name="append">True to append, False to overwrite the file</param>
/// <exception cref="System.IO.IOException"></exception>
private void WriteLogtoFile(string text, LogTypes logType, bool append = true)
{
var currentTime = logType.ToString() + Environment.NewLine + DateTime.Now.ToString(_dateTimeFormat) + Environment.NewLine;
try
{
using (StreamWriter stream = new StreamWriter(_fileName, append, Encoding.UTF8))
{
if (text != "")
{
stream.WriteLine(text);
}
}
}
catch
{
throw;
}
}
public static void WriteLog(LogTypes logType, string logMsg, Exception ex = null, bool bConsole = true)
{
if (logType >= LogManager.LogTypeToWrite)
{
lock (LogManager.mutex)
{
LogManager.WriteLog(logType.ToString(), logMsg);
}
if (logType >= LogTypes.Fatal && bConsole && LogManager.LogTypeToWrite <= LogTypes.Warning)
{
ConsoleColor color = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Red;
SysConOut.WriteLine(logMsg);
Console.ForegroundColor = color;
}
if (null != ex)
{
LogManager.WriteException(logMsg + ex.ToString());
}
}
}
public static void Log(LogTypes LogType, string Message)
{
try
{
string currentTime = GetLogTime(System.DateTime.Now);
string LogString = null;
if (LogType == LogTypes.Entry)
{
LogString = "]" + Message;
}
else
{
LogString = LogType.ToString(NumberFormatInfo.InvariantInfo) + " (" + currentTime + "): " + Message;
}
Debug("Logger: " + LogString);
string Log = "";
if (File.Exists(Path.Combine(GameController.GamePath + "log.dat")))
{
Log = File.ReadAllText(Path.Combine(GameController.GamePath + "log.dat"));
}
if (string.IsNullOrEmpty(Log))
{
Log = LogString;
}
else
{
Log += Environment.NewLine + LogString;
}
File.WriteAllText(Path.Combine(GameController.GamePath + "log.dat"), Log);
}
catch (Exception ex)
{
}
}
public static string BuildLogMessage(
StreamRequestContext context,
LogTypes logType,
string message,
object applicationData = null)
{
context = context ?? new StreamRequestContext
{
AppName = $"{AssemblyName}-UnknownEnvironment",
Version = string.Empty,
SystemInformation = null
};
return(JsonConvert.SerializeObject(new LogEvent()
{
LogType = logType.ToString(),
Message = message,
ApplicationName = context.AppName,
ApplicationVersion = context.Version,
ApplicationData = applicationData,
SystemInformation = context.SystemInformation
}));
}
private static void Log(LogTypes types, string message)
{
Console.ForegroundColor = ConsoleColor.White;
Console.Write($"[{DateTime.Now}] - ");
switch (types)
{
case LogTypes.Error:
Console.ForegroundColor = ConsoleColor.Red;
break;
case LogTypes.Copied:
Console.ForegroundColor = ConsoleColor.Green;
break;
case LogTypes.Changes:
Console.ForegroundColor = ConsoleColor.Yellow;
break;
default:
break;
}
Console.Write($"[{types.ToString()}] - {message} \n");
}
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.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.ToString()),
SqlHelper.CreateParameter("@user", user.Id),
SqlHelper.CreateParameter("@dateStamp", sinceDate))));
}
/// <summary>
/// Log the server message.
/// </summary>
/// <param name="Message">Message to log.</param>
/// <param name="LogType">Log Type.</param>
public void Log(string Message, LogTypes LogType)
{
if (IsActive)
{
ThreadPool.QueueWorkItem(() =>
{
if (CanLog(LogType))
{
string MessageToLog = $"{DateTime.Now.ToString()} [{LogType.ToString()}] {Message}";
Core.Instance.LogMessage(MessageToLog);
Writer.WriteLine(MessageToLog);
Writer.Flush();
}
});
}
}
/// <summary>
/// Writes a line to the console and the log from a string
/// </summary>
/// <param name="text"></param>
/// <param name="type"></param>
public static void WriteLine(string text, LogTypes type = LogTypes.INFO)
{
if (LicenseManager.UsageMode == LicenseUsageMode.Designtime)
{
return;
}
//Get the stack trace
StackTrace stackTrace = new StackTrace(true);
string thisFileName = stackTrace.GetFrame(0).GetFileName();
StackFrame stackFrame = null;
int frame = 1;
//Get the first stack frame that isn't from this file
while (stackFrame == null || stackFrame.GetFileName() == thisFileName)
{
stackFrame = stackTrace.GetFrame(frame++);
}
//Get data from the function that called this
int lineNum = stackFrame.GetFileLineNumber();
string fileName = Path.GetFileName(stackFrame.GetFileName());
string methodName = stackFrame.GetMethod().Name;
//Get the date and time
DateTime now = DateTime.Now;
string date = now.ToString("yyyy-MM-dd");
string time = now.ToString("HH:mm:ss");
//Get the type of log this is
string typeText = type.ToString();
//Create the output with formatting
string output = "";
output += time + " | ";
output += typeText + " | ";
output += fileName + ":" + methodName + "():" + lineNum + " | ";
output += text + Environment.NewLine;
if (MainForm.Debug)
{
System.Console.Write(output);
}
//Append the text to the console
MainForm.ConsoleMessage(output, LogTypeToColor(type));
//If we're not in debug mode
if (!MainForm.Debug)
{
//If a log file for today doesn't exist
if (!File.Exists("Logs/" + date + ".log"))
{
//Make one and write the output to it
StreamWriter sw = File.CreateText("Logs/" + date + ".log");
sw.Write(output);
sw.Close();
}
else
{
try {
notWritten += output;
if (!locker.IsWriterLockHeld)
{
locker.AcquireWriterLock(-1);
if (locker.IsWriterLockHeld)
{
File.AppendAllText("Logs/" + date + ".log", output);
notWritten = "";
}
}
} catch {
notWritten += output;
} finally {
locker.ReleaseWriterLock();
}
}
//If the log is an error
if (type == LogTypes.ERROR)
{
string caption = "Error!";
string message = text + Environment.NewLine + "The program may not function as intended." + Environment.NewLine + "Do you wish to exit?";
//Show a message box asking the user if they want to exit the program
DialogResult result = MessageBox.Show(message, caption, MessageBoxButtons.YesNo);
//If they don't click no, exit the program
if (result != DialogResult.No)
{
WriteLine("User has exited after error.");
Environment.Exit(1);
}
}
//If the log is a fatal
if (type == LogTypes.FATAL)
{
string error = text.Substring(0, text.IndexOf("\n"));
string caption = "Fatal Error!";
string message = error + Environment.NewLine + "Check the Logs folder for more info, please report this." + Environment.NewLine + "The program will now exit.";
//Show a message box telling the user that the program is closing
MessageBox.Show(message, caption, MessageBoxButtons.OK);
Environment.Exit(2);
}
}
}
/// <summary>
/// Log the server message.
/// </summary>
/// <param name="Message">Message to log.</param>
/// <param name="LogType">Log Type.</param>
/// <param name="TcpClient">TcpClient.</param>
public void Log(string Message, LogTypes LogType, TcpClient TcpClient)
{
if (IsActive)
{
ThreadPool.QueueWorkItem(() =>
{
if (CanLog(LogType))
{
string MessageToLog = $"{DateTime.Now.ToString() + (TcpClient == null ? "" : " " + ((IPEndPoint)TcpClient.Client.RemoteEndPoint).Address.ToString())} [{LogType.ToString()}] {Message}";
Core.Instance.LogMessage(MessageToLog);
Writer.WriteLine(MessageToLog);
Writer.Flush();
}
});
}
}
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));
}
}
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));
}
/// <summary>
/// Log a message.
/// </summary>
/// <param name="type">The type of the log (DEBUG, INFO, WARNING, ERROR).</param>
/// <param name="message">The message to be logged.</param>
/// <param name="logtoconsole">Force the message be logged to the console</param>
/// <param name="logtofile">Force the message be logged to file</param>
private static void Log(string message, LogTypes type = LogTypes.INFO, bool logtoconsole = false, bool logtofile = false)
{
if (type <= LogTypes.NONE) // Goat boy is a bad boy.
return;
if ((ConsoleLogLevel >= type) || logtoconsole)
Console.WriteLine(String.Format("[{0} {1}] {2}", DateTime.Now.ToString("HH:mm:ss"), type.ToString(), message));
if ((FileLogLevel >= type) || logtofile)
File.AppendAllText(_logfile, String.Format("[{0} {1}] {2}\r\n", DateTime.Now.ToString("dd MMM yyyy-HH:mm:ss:fff"), type.ToString(), message));
}
/// <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);
}
}
}
//public static void LogCheat(HackTypes type, MapleClient c, string msg = "")
//{
// Cheaters.Add(type, c);
// //TODO:
// //Log msg and such to file.
//}
public static void WriteLog(LogTypes type, string msg, params object[] 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("\tDebug" + tab + "| ");
}
else if (type == LogTypes.Info)
{
Console.ForegroundColor = ConsoleColor.Gray;
Console.Write("\tInfo" + tab + "| ");
}
else if (type == LogTypes.Warning)
{
Console.ForegroundColor = ConsoleColor.DarkYellow;
Console.Write("\tWarning" + tab + "| ");
}
else if (type == LogTypes.Error)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Write("\tError" + tab + "| ");
}
else if (type == LogTypes.Connect)
{
Console.ForegroundColor = ConsoleColor.DarkGreen;
Console.Write("\tConnect" + tab + "| ");
}
else if (type == LogTypes.Disconnect)
{
Console.ForegroundColor = ConsoleColor.DarkRed;
Console.Write("\tDisconnect" + tab + "| ");
}
else if (type == LogTypes.NX)
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.Write("\tNX" + tab + "| ");
}
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine(msg, pObjects);
if (mCommandEnabled)
Console.Write("> {0}", mCommandBuffer);
}
/// <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);
}
}
}
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));
}
/// <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)
{
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)
{
Debug.WriteLine(e.ToString(), "Error");
Trace.WriteLine(e.ToString());
}
}
/// <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);
}
