public bool DebugLog(object message, dynamic request = null, string errorCode = "", string identity = "", [CallerFilePath] string fileName = "", [CallerMemberName] string methodName = "", ComponentStatus componentStatus = ComponentStatus.None, LogSeverity logSeverity = LogSeverity.Debug)
{
if (!_logging || !_debugLogging)
{
return(false);
}
try
{
DebugLoggerModel debugLoggerModel = new DebugLoggerModel
{
Date = DateTime.UtcNow,
Severity = logSeverity.ToString(),
Logger = _serviceType.ToString(),
File = fileName.ToFileName(),
Method = methodName,
Identity = !string.IsNullOrEmpty(identity) ? identity : Convert.ToString(CommonMethods.GetValueFromDynamic(request, "UserID")),
Message = Convert.ToString(message),
StackTrace = null,
Exception = null,
ApplicationCode = _applicationCode ?? string.Empty,
ErrorCode = errorCode,
MessageData = request != null?JsonConvert.SerializeObject(request, Formatting.None) : string.Empty,
ComponentStatus = componentStatus != ComponentStatus.None ? componentStatus.ToString() : string.Empty
};
return(_eventBus.Publish(debugLoggerModel));
}
catch (Exception ex)
{
return(false);
}
}
public static void Log(string message, LogSeverity severity = LogSeverity.Verbose)
{
if (severity <= Logger.LoggingLevel)
{
Console.WriteLine($"{severity.ToString("g")}:{message}");
}
}
/// <summary>
/// Sends a message to the log.
/// </summary>
/// <remarks>
/// This should almost never be called directly, but rather through one of the helper functions.
/// </remarks>
/// <param name="log_severity">Severity of the log message.</param>
/// <param name="log_message">Text to write into the log.</param>
public static void log(LogSeverity log_severity, string log_message)
{
if (running == false)
{
String formattedMessage = String.Format("!!! {0}|{1}|({2}): {3}",
DateTime.Now.ToString("MM-dd HH:mm:ss.ffff"),
log_severity.ToString(),
Thread.CurrentThread.ManagedThreadId,
log_message);
if (consoleOutput)
{
Console.WriteLine(formattedMessage);
}
return;
}
LogStatement statement = new LogStatement
{
threadId = Thread.CurrentThread.ManagedThreadId,
severity = log_severity,
message = log_message,
time = DateTime.Now.ToString("MM-dd HH:mm:ss.ffff")
};
lock (statements)
{
statements.Add(statement);
}
}
/// <summary>
/// Logs the specified severity.
/// </summary>
/// <param name="severity">The severity.</param>
/// <param name="message">The message.</param>
public void Log(LogSeverity severity, string message)
{
RequiresNotNull(message);
var con = factory.OpenConnection();
con.ContinueWith(pt =>
{
var connection = pt.Result;
try
{
var cmd = connection.CreateCommand();
cmd.CommandText = "INSERT INTO Log (Id, Timestamp, Severity, Message) VALUES (NEWID(), @time, @sev, @msg)";
var timestampParameter = cmd.CreateParameter();
timestampParameter.ParameterName = "@time";
timestampParameter.Value = DateTime.Now;
cmd.Parameters.Add(timestampParameter);
var severityParameter = cmd.CreateParameter();
severityParameter.ParameterName = "@sev";
severityParameter.Value = severity.ToString();
cmd.Parameters.Add(severityParameter);
var messageParameter = cmd.CreateParameter();
messageParameter.ParameterName = "@msg";
messageParameter.Value = message;
cmd.Parameters.Add(messageParameter);
cmd.ExecuteNonQuery();
}
finally
{
connection.Dispose();
}
});
}
public void Log(LogSeverity severity, string source, Exception exception)
{
Console.WriteLine(string.Format("Log : {0} - {1} - {2}", severity.ToString(), source, exception.ToString()));
if (severity == LogSeverity.Error || severity == LogSeverity.Critical)
{
Errors.Add(new KeyValuePair<string, Exception>(source, exception));
}
}
/// <summary>
/// Log a message
/// </summary>
/// <param name="severity">The severity</param>
/// <param name="source">The source</param>
/// <param name="message">The message</param>
public void Log(LogSeverity severity, string source, string message)
{
if ((int)severity < (int)MinLogSeverity)
{
return;
}
Console.WriteLine(severity.ToString() + " " + source + " " + message);
}
public void Log(LogSeverity severity, string message, params object[] args)
{
LogEventInfo logEvent = new LogEventInfo(LogLevel.FromString(severity.ToString()), "User", string.Format(message, args));
logEvent.Properties["AgentID"] = AgentId;
logEvent.Properties["Occured"] = Security.LastTickEvent;
_loggerUser.Log(logEvent);
}
private void Log(string message, LogSeverity severity = LogSeverity.Info)
{
if (severity < _minLogSeverity)
{
return;
}
Console.WriteLine("Song Loader [" + severity.ToString().ToUpper() + "]: " + message);
}
public void Log(string message, LogSeverity severity, Exception exception)
{
Console.WriteLine($"[bond] {severity.ToString().ToUpper()}: {message}");
if (exception != null)
{
Console.WriteLine(exception);
}
}
public void Log(string message, LogSeverity severity, Exception exception)
{
Console.WriteLine($"[bond] {severity.ToString().ToUpper()}: {message}");
if (exception != null)
{
Console.WriteLine(exception);
}
}
/// <excludedoc />
protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
{
message = String.Format("[{0}] {1}", severity.ToString().ToLowerInvariant(), message);
if (exceptionData != null)
writer.WriteException(exceptionData, message);
else
writer.WriteLine(message);
}
private static void WriteToLog(LogSeverity messageLevel, string logMessage)
{
if (messageLevel <= currentLogLevel)
{
string log = DateTime.Now + " " + messageLevel.ToString() + ":" + logMessage;
Console.WriteLine(log);
File.AppendAllText("zerog.log", log + Environment.NewLine);
}
}
private static void LogRecord(LogSeverity level, string message)
{
if (level < LogSeverity.LogWarning)
{
BuglyAgent.DebugLog(level.ToString(), message, new object[0]);
}
BuglyAgent.ConfigCrashReporterPackage();
try
{
BuglyAgent.GameAgent.CallStatic("printLog", new object[]
{
string.Format("<{0}> - {1}", level.ToString(), message)
});
}
catch
{
}
}
private static void LogRecord(LogSeverity level, string message)
{
if (level < LogSeverity.LogWarning)
{
BuglyAgent.DebugLog(level.ToString(), message, new object[0]);
return;
}
try
{
BuglyAgent.UnityAgent.Call("printLog", new object[]
{
string.Format("<{0}> - {1}", level.ToString(), message)
});
}
catch
{
}
}
/// <summary>Returns a string that represents the current object.</summary>
/// <returns>A string that represents the current object.</returns>
public override string ToString()
{
string output = $"[{DateTime.Now}] {TAG.ToUpper()} - '{LogSeverity.ToString()}: {Message}'";
foreach (KeyValuePair <string, string> additionalField in AdditionalFields)
{
output += $" - '{additionalField.Key}' : '{additionalField.Value}'";
}
return(output);
}
private static LogSeverity GetLogSeveritySetting(LogSeverity defaultValue)
{
if (!Enum.TryParse(Settings.LogSeverity, out LogSeverity result))
{
Settings.LogSeverity = defaultValue.ToString();
result = defaultValue;
}
return(result);
}
public static void LogIssue(string message, string issueLocation, DateTime issueTime, LogSeverity severity)
{
//TODO: update this to use a config file path
string path = "~/logs/issue_log" + DateTime.Now.ToString("dd-MM-yyyy") + ".log";
using (StreamWriter sw = new StreamWriter(path, true))
{
sw.WriteLine(issueTime.ToString("hh:mm:ss") + " [" + severity.ToString() + "] @" + issueLocation + " : " + message);
}
}
public static Task Log(string msg, bool succeeded)
{
LogSeverity severity = succeeded ? LogSeverity.Info : LogSeverity.Error;
HandleLogSeverity(severity);
Console.WriteLine(BuildLogMessage(severity.ToString(), "Commands", msg));
Console.ForegroundColor = defColor;
return(Task.CompletedTask);
}
private static void LogRecord(LogSeverity level, string message)
{
if (level < LogSeverity.LogWarning)
{
DebugLog(level.ToString(), message);
}
ConfigCrashReporterType();
_BuglyLogMessage(LogSeverityToInt(level), null, message);
}
public static void Log(string msg, LogSeverity severity = LogSeverity.Information)
{
if (ConfigurationHelper.GetLogQueueName() != null)
{
if (ConfigurationHelper.GetCurrentSeverityLevel().ToLower() == LogSeverity.Information.ToString().ToLower() ||
(severity.ToString().ToLower() == ConfigurationHelper.GetCurrentSeverityLevel().ToLower()))
{
CloudQueueMessage m = new CloudQueueMessage(msg);
queue.AddMessage(m);
}
}
}
public static string ToShortString(this LogSeverity severity)
{
return(severity switch
{
LogSeverity.Verbose => "VRB",
LogSeverity.Debug => "DBG",
LogSeverity.Information => "INF",
LogSeverity.Warning => "WRN",
LogSeverity.Error => "ERR",
LogSeverity.Fatal => "FTL",
_ => severity.ToString(),
});
public static LogSeverity GetLogSeverity(this Settings settings, LogSeverity defaultValue)
{
if (Enum.TryParse(settings.LogSeverity, out LogSeverity result))
{
return(result);
}
settings.LogSeverity = defaultValue.ToString();
result = defaultValue;
return(result);
}
public static void Log(string msg,LogSeverity severity=LogSeverity.Information)
{
if (ConfigurationHelper.GetLogQueueName() != null)
{
if (ConfigurationHelper.GetCurrentSeverityLevel().ToLower() == LogSeverity.Information.ToString().ToLower()
|| (severity.ToString().ToLower() == ConfigurationHelper.GetCurrentSeverityLevel().ToLower()))
{
CloudQueueMessage m = new CloudQueueMessage(msg);
queue.AddMessage(m);
}
}
}
private static void LogToConsole(LogSeverity level, string message)
{
if (!_debugMode && LogSeverity.Log != level)
{
if (level < LogSeverity.LogInfo)
{
return;
}
}
UnityEngine.Debug.LogWarning(string.Format("[BuglyAgent] <{0}> - {1}", level.ToString(), message));
}
/// <summary>
/// Initializes a new instance of the <see cref="NlogManager" /> class.
/// </summary>
/// <param name="logDirectory">The log directory.</param>
/// <param name="logFileNamePrefix">The log file name prefix.</param>
public NlogManager(string logDirectory, string logFileNamePrefix, LogSeverity initialSeverity) : this(logDirectory, logFileNamePrefix)
{
_severity = initialSeverity;
DebugFileWriter(
logDirectory, String.Format(
"NlogManager constructor called, logDirectory is [{0}], logFileNamePrefix is [{1}], _severity is [{2}].",
logDirectory,
logFileNamePrefix,
_severity.ToString()
));
}
public void Log(string message, LogSeverity severity)
{
string fmat = $"{severity.ToString().ToUpper()}\t{message}";
if (_stdoutPred.Any(x => x(message, severity)))
{
_stdout.WriteLine(fmat);
}
if (_stderrPred.Any(x => x(message, severity)))
{
_stderr.WriteLine(fmat);
}
}
/// <excludedoc />
protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
{
message = String.Format("[{0}] {1}", severity.ToString().ToLowerInvariant(), message);
if (exceptionData != null)
{
writer.WriteException(exceptionData, message);
}
else
{
writer.WriteLine(message);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="NlogManager" /> class.
/// </summary>
/// <param name="logDirectory">The log directory.</param>
/// <param name="logFileNamePrefix">The log file name prefix.</param>
public NlogManager(string logDirectory, string logFileNamePrefix)
{
DebugFileWriter(
logDirectory, String.Format(
"NlogManager constructor called, logDirectory is [{0}], logFileNamePrefix is [{1}], _severity is [{2}].",
logDirectory,
logFileNamePrefix,
_severity.ToString()
));
LogDirectory = logDirectory;
LogFilePrefix = logFileNamePrefix;
LogManager.Configuration = new LoggingConfiguration();
}
private static void LogToConsole(LogSeverity level, string message)
{
if (!_debugMode && LogSeverity.Log != level)
{
if (level < LogSeverity.LogInfo)
{
return;
}
}
try {
UnityAgent.Call("printLog", string.Format("[BuglyAgent] <{0}> - {1}", level.ToString(), message));
} catch {
}
}
public void Handle(LogSeverity severity, Exception exception, String format, params object[] args)
{
if (severity < LogSeverity.Information)
{
return;
}
var message = string.Format(format, args);
Console.WriteLine($"[bond] {severity.ToString().ToUpper()}: {message}");
if (exception != null)
{
Console.WriteLine(exception);
}
}
// Internal log function called by the log thread
private static void log_internal(LogSeverity severity, string message, int threadId, string time)
{
try
{
if (severity >= currentSeverity)
{
String formattedMessage = String.Format("{0}|{1}|({2}): {3}",
time,
severity.ToString(),
threadId,
message);
if (consoleOutput)
{
if (severity == LogSeverity.error)
{
Console.ForegroundColor = ConsoleColor.Red;
}
Console.WriteLine(formattedMessage);
if (severity == LogSeverity.error)
{
Console.ResetColor();
}
}
Debug.WriteLine(formattedMessage);
lock (logfilename)
{
Logging.roll();
byte[] logMessage = Encoding.UTF8.GetBytes(formattedMessage + Environment.NewLine);
logFileStream.Write(logMessage, 0, logMessage.Length);
logFileStream.Flush();
currentLogSize += logMessage.Length;
}
}
}
catch (Exception e)
{
if (consoleOutput)
{
Console.WriteLine("Logging exception: {0}", e.Message);
}
}
}
private static void LogToConsole(LogSeverity level, string message)
{
if (!_debugMode && LogSeverity.Log != level)
{
if (level < LogSeverity.LogWarning)
{
return;
}
}
if (_debugMode)
{
Console.WriteLine("[BuglyAgent] <{0}> - {1}", level.ToString(), message);
}
_BuglyLogMessage(LogSeverityToInt(level), null, message);
}
public LogEntry(
string username,
LogSeverity severity,
string message,
string stackTrace,
string machineName,
string applicationName,
DateTime dateTime)
{
Username = username;
Severity = severity.ToString();
Message = message;
StackTrace = stackTrace;
MachineName = machineName;
ApplicationName = applicationName;
DateTime = dateTime;
}
private static string Message(string source, string message, LogSeverity severity)
{
var lines = new List <string[]>
{
new[]
{
string.Format("{0:dd/MM/yyyy HH:mm:ss}", DateTime.UtcNow),
"[" + source + "]",
"[" + severity.ToString()[0] + "]",
message ?? ""
}
};
var prettied = lines.PrettyLines(2);
Console.ForegroundColor = severity.SeverityToColor();
return(prettied);
}
internal static bool GetIsLoggingEnabled(Log log, LogSeverity severity)
{
switch (severity)
{
case LogSeverity.VERBOSE: return(log.IsVerboseEnabled);
case LogSeverity.DEBUG: return(log.IsDebugEnabled);
case LogSeverity.INFO: return(log.IsInfoEnabled);
case LogSeverity.WARNING: return(log.IsWarnEnabled);
case LogSeverity.FATAL: return(log.IsFatalEnabled);
case LogSeverity.ERROR: return(log.IsErrorEnabled);
default:
throw new InvalidOperationException("Unsupported log severity: " + severity.ToString());
}
}
private static Action <string> GetLogMessageMethod(Log log, LogSeverity logSeverity)
{
switch (logSeverity)
{
case LogSeverity.VERBOSE: return(log.Verbose);
case LogSeverity.DEBUG: return(log.Debug);
case LogSeverity.INFO: return(log.Info);
case LogSeverity.WARNING: return(log.Warn);
case LogSeverity.FATAL: return(log.Fatal);
case LogSeverity.ERROR: return(log.Error);
default:
throw new InvalidOperationException("Unsupported log severity: " + logSeverity.ToString());
}
}
/// <summary>
/// Writes to the log.
/// </summary>
/// <param name="level">Severity of the log.</param>
/// <param name="text">Actual (formattable) text.</param>
/// <param name="args">string.Format arguments.</param>
public void Write(LogSeverity level, string text, params string[] args)
{
if (args.Length > 0) {
text = string.Format(text, args);
}
string[] split = text.Split('\n');
if (split.Length > 1) {
foreach (string part in split) {
Write(level, part);
}
return;
}
string line = string.Format(Format, new string[3] {
DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
level.ToString().PadLeft(8),
text
});
LogFile.WriteLine(line);
LogEntry logEntry = new LogEntry {
Text = text,
Instance = InstanceName,
Level = level,
Line = line
};
(new Thread(() => {
foreach (Action<LogEntry> action in LogWrite) {
action.Invoke(logEntry);
}
})).Start();
}
/// <summary>
/// Formats the log message.
/// </summary>
/// <param name="message">The message.</param>
/// <param name="severity">The severity.</param>
/// <param name="messageToken">The message token.</param>
/// <param name="source">The source.</param>
/// <returns>System.String.</returns>
private static string FormatLogMessage(string message, LogSeverity severity, string messageToken = "", string source = "")
{
return string.Format(CultureInfo.InvariantCulture, "{0} | {1} | {2} | {3} | {4}{5}", DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture), severity.ToString().ToUpper(CultureInfo.InvariantCulture), message, source, messageToken, Environment.NewLine);
}
public string Format(LogSeverity severity, string message)
{
return string.Format("{0} [{1}]: {2}", DateTime.Now,
severity.ToString(), message);
}
private void OnLog(LogSeverity arg1, string arg2)
{
if (arg1 == LogSeverity.Error || arg1 == LogSeverity.Fatal)
{
WriteLine("{0}: {1}", arg1.ToString().ToUpper(), arg2);
}
else
{
WriteLine("{0}: {1}", arg1.ToString().ToUpper(), arg2);
}
}
private static string GetSeverityText(LogSeverity severity)
{
if (severity == LogSeverity.Default || severity == LogSeverity.Debug)
return "";
if (severity == LogSeverity.Notice)
return "***";
return severity.ToString().ToUpper();
}
private static void LogToConsole(LogSeverity level, string message)
{
if (!BuglyAgent._debugMode && level != LogSeverity.Log && level < LogSeverity.LogInfo)
{
return;
}
try
{
BuglyAgent.UnityAgent.Call("printLog", new object[]
{
string.Format("[BuglyAgent] <{0}> - {1}", level.ToString(), message)
});
}
catch
{
}
}
private static void _HandleException(LogSeverity logLevel, string name, string message, string stackTrace, bool uncaught)
{
if (!BuglyAgent.IsInitialized)
{
BuglyAgent.PrintLog(LogSeverity.Log, "It has not been initialized.", new object[0]);
return;
}
if (logLevel == LogSeverity.Log)
{
return;
}
if (uncaught && logLevel < BuglyAgent._autoReportLogLevel)
{
BuglyAgent.PrintLog(LogSeverity.Log, "Not report exception for level {0}", new object[]
{
logLevel.ToString()
});
return;
}
string text = null;
string text2 = null;
if (!string.IsNullOrEmpty(message))
{
try
{
if (logLevel == LogSeverity.LogException && message.Contains("Exception"))
{
Match match = new Regex("^(?<errorType>\\S+):\\s*(?<errorMessage>.*)").Match(message);
if (match.Success)
{
text = match.Groups["errorType"].Value;
text2 = match.Groups["errorMessage"].Value.Trim();
}
}
}
catch
{
}
if (string.IsNullOrEmpty(text2))
{
text2 = message;
}
}
if (string.IsNullOrEmpty(name))
{
if (string.IsNullOrEmpty(text))
{
text = string.Format("Unity{0}", logLevel.ToString());
}
}
else
{
text = name;
}
BuglyAgent._reportException(uncaught, text, text2, stackTrace);
}
private static string GetCaption(LogSeverity severity)
{
return severity.ToString().ToUpperInvariant();
}
/// <summary>
/// Gets the log level.
/// </summary>
/// <param name="severity">The severity.</param>
/// <returns>NLog.LogLevel.</returns>
private NLog.LogLevel GetLogLevel(LogSeverity severity)
{
switch (severity)
{
case LogSeverity.Debug:
return NLog.LogLevel.Debug;
case LogSeverity.Error:
return NLog.LogLevel.Error;
case LogSeverity.Warn:
return NLog.LogLevel.Warn;
case LogSeverity.Fatal:
return NLog.LogLevel.Fatal;
case LogSeverity.Info:
return NLog.LogLevel.Info;
default:
throw new ArgumentException("Unknown LogSeverity: " + severity.ToString());
}
}
/// <summary>Retrieves a CSS class for the given severity level.</summary>
/// <param name="severity">The severity of the log message.</param>
public static string SeverityClass(LogSeverity severity)
{
return string.Format("{0}_{1}", RootClass, severity.ToString());
}
private static void LogToConsole(LogSeverity level, string message){
if (!_debugMode && LogSeverity.Log != level) {
if (level < LogSeverity.LogInfo) {
return;
}
}
try {
UnityAgent.Call ("printLog", string.Format ("[BuglyAgent] <{0}> - {1}", level.ToString (), message));
} catch {
}
}
private static void _HandleException (LogSeverity logLevel, string name, string message, string stackTrace, bool uncaught)
{
if (!IsInitialized) {
PrintLog (LogSeverity.Log, "It has not been initialized.");
return;
}
if (logLevel == LogSeverity.Log) {
return;
}
if ((uncaught && logLevel < _autoReportLogLevel)) {
PrintLog (LogSeverity.Log, "Not report exception for level {0}", logLevel.ToString ());
return;
}
string type = null;
string reason = null;
if (!string.IsNullOrEmpty (message)) {
try {
if ((LogSeverity.LogException == logLevel) && message.Contains ("Exception")) {
Match match = new Regex (@"^(?<errorType>\S+):\s*(?<errorMessage>.*)").Match (message);
if (match.Success) {
type = match.Groups ["errorType"].Value;
reason = match.Groups ["errorMessage"].Value.Trim ();
}
}
} catch {
}
if (string.IsNullOrEmpty (reason)) {
reason = message;
}
}
if (string.IsNullOrEmpty (name)) {
if (string.IsNullOrEmpty (type)) {
type = string.Format ("Unity{0}", logLevel.ToString ());
}
} else {
type = name;
}
_reportException (uncaught, type, reason, stackTrace);
}
private static void LogToConsole(LogSeverity level, string message){
if (!_debugMode && LogSeverity.Log != level) {
if (level < LogSeverity.LogInfo) {
return;
}
}
UnityEngine.Debug.LogWarning (string.Format("[BuglyAgent] <{0}> - {1}", level.ToString(), message));
}