/// <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(string message, LogSeverity severity, Exception exception)
{
LastMessageSeverity = severity;
LastMessage = message;
LastException = exception;
MessagesReceived++;
}
public void Log(LogSeverity severity, string message, params object[] args)
{
if (!Environment.UserInteractive) return;
if ((int)severity < (int)this.minimalSeverity) return;
var color = Console.ForegroundColor;
switch (severity)
{
case LogSeverity.Debug:
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("{0}\t{1}\t{2}", severity, DateTime.Now, string.Format(message, args));
Console.ForegroundColor = color;
break;
case LogSeverity.Info:
case LogSeverity.Warn:
Console.WriteLine("{0}\t{1}\t{2}", severity, DateTime.Now, string.Format(message, args));
break;
case LogSeverity.Error:
case LogSeverity.Critical:
default:
Console.ForegroundColor = ConsoleColor.Red;
Console.Error.WriteLine("{0}\t{1}\t{2}", severity, DateTime.Now, string.Format(message, args));
Console.ForegroundColor = color;
break;
}
}
private void Write(LogSeverity logSeverity, string description)
{
foreach (var logSource in _logSources)
{
logSource.AddItem(logSeverity, description);
}
}
protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
{
if (exceptionData != null)
message += "\n" + exceptionData;
switch (severity)
{
case LogSeverity.Error:
taskLoggingHelper.LogError(message);
break;
case LogSeverity.Warning:
taskLoggingHelper.LogWarning(message);
break;
case LogSeverity.Important:
taskLoggingHelper.LogMessage(MessageImportance.High, message);
break;
case LogSeverity.Info:
taskLoggingHelper.LogMessage(MessageImportance.Normal, message);
break;
case LogSeverity.Debug:
taskLoggingHelper.LogMessage(MessageImportance.Low, message);
break;
}
}
protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
{
if (severity < MinLogSeverity || LogMessage == null)
return;
Color color = Color.Black;
switch (severity)
{
case LogSeverity.Error:
color = Color.Red;
break;
case LogSeverity.Warning:
color = Color.Gold;
break;
case LogSeverity.Important:
color = Color.Black;
break;
case LogSeverity.Info:
color = Color.Gray;
break;
case LogSeverity.Debug:
color = Color.DarkGray;
break;
}
LogMessage(this, new RuntimeLogEventArgs(message, color));
if (exceptionData != null)
LogMessage(this, new RuntimeLogEventArgs(exceptionData.ToString(), color));
}
protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
{
StringBuilder fullMessage = new StringBuilder();
fullMessage.Append(GetCaption(severity));
fullMessage.Append(": ");
fullMessage.Append(message);
if (exceptionData != null)
fullMessage.Append('\n').Append(exceptionData);
switch (severity)
{
case LogSeverity.Debug:
facadeLogger.LogMessage(fullMessage.ToString());
break;
case LogSeverity.Info:
case LogSeverity.Important:
case LogSeverity.Warning:
facadeLogger.LogMessage(fullMessage.ToString());
break;
case LogSeverity.Error:
facadeLogger.LogError(fullMessage.ToString());
break;
}
}
public void Log(string message, LogSeverity logSeverity)
{
Console.ForegroundColor = DetermineColor(logSeverity);
Console.Write(message);
Console.WriteLine();
Console.ResetColor();
}
/// <summary>
/// Initializes a new instance of the <see cref="LogItem"/> struct.
/// </summary>
/// <param name="timestamp">The timestamp.</param>
/// <param name="severity">The severity.</param>
/// <param name="message">The message.</param>
public LogItem(DateTimeOffset? timestamp, LogSeverity severity, string message)
{
RequiresNotNull(message);
this.timestamp = timestamp;
this.severity = severity;
this.message = message;
}
/// <inheritdoc />
public void Log(LogSeverity severity, string message, ExceptionData exceptionData)
{
if (message == null)
throw new ArgumentNullException("message");
LogImpl(severity, message, exceptionData);
}
/// <summary>
/// Writes a message into the log given the logger name, the severity and the message.
/// </summary>
/// <param name="loggerName">Name of the logger.</param>
/// <param name="severity">The severity.</param>
/// <param name="message">The message.</param>
protected override void InnerWriteLog(string loggerName, LogSeverity severity, string message)
{
if (!configured)
{
Configure();
}
switch (severity)
{
case LogSeverity.Debug:
logger.Debug(message);
break;
case LogSeverity.Info:
logger.Info(message);
break;
case LogSeverity.Warning:
logger.Warn(message);
break;
case LogSeverity.Error:
logger.Error(message);
break;
case LogSeverity.Fatal:
logger.Fatal(message);
break;
default:
logger.Debug(message);
break;
}
}
/// <inheritdoc />
protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
{
switch (severity)
{
case LogSeverity.Error:
testListener.WriteLine(message, FacadeCategory.Error);
break;
case LogSeverity.Warning:
testListener.WriteLine(message, FacadeCategory.Warning);
break;
case LogSeverity.Important:
case LogSeverity.Info:
testListener.WriteLine(message, FacadeCategory.Info);
break;
case LogSeverity.Debug:
testListener.WriteLine(message, FacadeCategory.Debug);
break;
}
if (exceptionData != null)
testListener.WriteLine(exceptionData.ToString(), FacadeCategory.Error);
}
/// <summary>
/// Constructor of LogEventArgs.
/// </summary>
/// <param name="severity">Log severity.</param>
/// <param name="message">Log message</param>
/// <param name="exception">Inner exception.</param>
/// <param name="date">Log date.</param>
public LogEventArgs(LogSeverity severity, string message, Exception exception, DateTime date)
{
Severity = severity;
Message = message;
Exception = exception;
Date = date;
}
protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
{
var warning = exceptionData == null
? message
: string.Concat(message, "\n", exceptionData.ToString());
switch (severity)
{
case LogSeverity.Info:
_messageLogger.SendMessage(TestMessageLevel.Informational, warning);
break;
case LogSeverity.Warning:
_messageLogger.SendMessage(TestMessageLevel.Warning, warning);
break;
case LogSeverity.Debug:
_messageLogger.SendMessage(TestMessageLevel.Informational, warning);
break;
case LogSeverity.Important:
_messageLogger.SendMessage(TestMessageLevel.Informational, warning);
break;
case LogSeverity.Error:
_messageLogger.SendMessage(TestMessageLevel.Error, warning);
break;
}
}
/// <summary>
/// Log a message.
/// </summary>
/// <param name="severity">Severity.</param>
/// <param name="message">Message.</param>
/// <param name="args">Format arguments.</param>
public static void Log(LogSeverity severity, string message, params string[] args)
{
if (OnLog != null)
{
OnLog(severity, string.Format(message, args));
}
}
/// <summary>
/// Performs log operation in all registered loggers
/// </summary>
/// <param name="severity"></param>
/// <param name="msg"></param>
/// <param name="exc"></param>
public void DoLog(LogSeverity severity, string msg, Exception exc)
{
switch (severity)
{
case LogSeverity.Info:
foreach (var logger in _cache.Values)
{
ILogProvider provider = GetCasted(logger);
provider.Info(msg);
}
break;
case LogSeverity.Warn:
foreach (var logger in _cache.Values)
{
ILogProvider provider = GetCasted(logger);
provider.Warn(msg, exc);
}
break;
case LogSeverity.Error:
foreach (var logger in _cache.Values)
{
ILogProvider provider = GetCasted(logger);
provider.Error(msg, exc);
}
break;
case LogSeverity.Fatal:
foreach (var logger in _cache.Values)
{
ILogProvider provider = GetCasted(logger);
provider.Fatal(msg, exc);
}
break;
}
}
public LogMessageEventArgs(LogSeverity severity, string source, string msg, Exception exception)
{
Severity = severity;
Source = source;
Message = msg;
Exception = exception;
}
protected override void LogImpl(LogSeverity severity, string message, ExceptionData exceptionData)
{
if (exceptionData != null)
message += "\n" + exceptionData;
switch (severity)
{
case LogSeverity.Error:
task.Log(Level.Error, message);
break;
case LogSeverity.Warning:
task.Log(Level.Warning, message);
break;
case LogSeverity.Important:
task.Log(Level.Info, message);
break;
case LogSeverity.Info:
task.Log(Level.Verbose, message);
break;
case LogSeverity.Debug:
task.Log(Level.Debug, message);
break;
}
}
public StoryLogEntry(LogSeverity severity, string text, TimeSpan elapsed)
{
this.severity = severity;
this.text = text;
this.elapsed = elapsed;
this.dateTime = DateTime.UtcNow;
}
public SpellbookLoggerEventArgs(string message, object source, Exception exception, LogSeverity severity)
{
Message = message;
Source = source;
Exception = exception;
Severity = severity;
}
/// <summary>
/// Log a message
/// </summary>
/// <param name="severity">The severity</param>
/// <param name="source">The source</param>
/// <param name="message"></param>
public void Log(LogSeverity severity, string source, string message)
{
if ((int)severity < (int)MinLogSeverity)
{
return;
}
LogClient.LogAsync((LogLevel)severity, source, message);
}
public static void Log(LogSeverity severity, string msg)
{
lock (LogLock)
{
if (OnLog != null)
OnLog(null, new LogEvent(severity, msg));
}
}
public void Log(LogSeverity severity, string source, string message, Exception exception = null)
{
if (severity <= Level)
{
try { Message(this, new LogMessageEventArgs(severity, source, message, exception)); }
catch { } //We dont want to log on log errors
}
}
public void Log(string message, LogSeverity severity, Exception exception)
{
Console.WriteLine($"[bond] {severity.ToString().ToUpper()}: {message}");
if (exception != null)
{
Console.WriteLine(exception);
}
}
/// <summary>
/// Constructor of LogEventArgs.
/// </summary>
/// <param name="severity">Log severity.</param>
/// <param name="message">Log message</param>
/// <param name="exception">Inner exception.</param>
/// <param name="date">Log date.</param>
public LogEventArgs(LogSeverity severity, string message,
Exception exception, DateTime date)
{
this._severity = severity;
this._message = message;
this._exception = exception;
this._date = date;
}
protected static void Log (LogSeverity severity, string format, params object[] parms)
{
if (severity == LogSeverity.Debug && !Config.Instance.Debug)
return;
Console.Error.Write ("*CaptainHook {0}*: ", severity);
Console.Error.WriteLine (format, parms);
}
public void Log(LogSeverity severity, string message)
{
string fullText = String.Format("Severity: {0}, \t\t Message: {1}", severity, message);
//Console.WriteLine(String.Format("Date: {0:d/M/yyyy HH:mm:ss}", DateTime.Now));
Console.WriteLine(fullText);
// Please make it stop
//Console.WriteLine("============================================================");
}
/// <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);
}
/// <summary>
/// Creates a filtered logger.
/// </summary>
/// <param name="logger">The logger to which filtered log messages are sent.</param>
/// <param name="minSeverity">The lowest severity message type to retain.</param>
/// <exception cref="ArgumentNullException">Thrown if <paramref name="logger"/> is null.</exception>
public FilteredLogger(ILogger logger, LogSeverity minSeverity)
{
if (logger == null)
throw new ArgumentNullException("logger");
this.logger = logger;
this.minSeverity = minSeverity;
}
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));
}
}
internal void Log(LogSeverity severity, string message, Exception exception = null)
=> Logger.Log(this, new LogEventArgs("Client", severity, message, exception));
/// <summary>
/// Constructor with a user-specified level passed
/// </summary>
/// <param name="minimumSeverity">The minimum level to log</param>
public DefaultLogger(LogSeverity minimumSeverity)
{
_severityLevel = minimumSeverity;
}
public void ReloadLogger(LogSeverity severity)
{
throw new NotImplementedException();
}
public Logger(LogManager logManager, LogSeverity minSeverity)
{
this.logManager = logManager;
this.minSeverity = minSeverity;
}
/// <inheritdoc/>
public void Write(LogSeverity severity, string format, params object[] args)
{
string msg = string.Format(format, args);
this.Write(severity, msg);
}
public LeafSQLExceptionBase(string message)
: base(message)
{
Severity = LogSeverity.Exception;
}
public static void Log(LogSeverity severity, string source, string message, Exception ex = null)
{
Log(new LogMessage(severity, source, message, ex));
}
public void Log(string source, LogSeverity severity, string message, Exception exception = null) => Logger.Log(this, new LogEventArgs(source, severity, message, exception));
protected void RaiseLog(LogSeverity severity, string message, Exception exception = null)
{
Log?.Invoke(new LogMessage(severity, GetType().Name, message, exception));
}
public void LogMultiline(string message, LogSeverity severity, StringBuilder additionalContent)
{
}
public void Log(LogSeverity severity, string message, params object[] paramList)
{
_logger.Info(message, paramList);
}
public Entry(LogSeverity severity, string message)
{
Time = DateTime.Now;
Severity = severity;
Message = message;
}
internal Task Log(LogSeverity severity, string msg)
{
return(Logger(new LogMessage(severity, "SimplePermissions", msg)));
}
protected void Log(LogSeverity severity, string message, Exception exception = null) => Logger.Log(this, new LogEventArgs(GetType().Name, severity, message, exception));
public static void Log(LogSeverity severity, Type source, string message, Exception ex = null)
{
Log(severity, source.Name, message, ex);
}
public abstract void CascadeLog(string message, LogSeverity severity);
public LeafSQLExceptionBase()
{
Severity = LogSeverity.Exception;
}
public LogEventArgs(LogSeverity severity, string message)
{
Severity = severity;
Message = message;
Timestamp = DateTime.Now;
}
private static void LogRecord(LogSeverity level, string message)
{
}
public void Log(object message, LogSeverity severity) => Log(message, severity);
public LogEntry(string message, LogSeverity severity = LogSeverity.Info, string module = "N/A")
: this(message, severity, module, null)
{
}
private static void _HandleException(LogSeverity logLevel, string name, string message, string stackTrace, bool uncaught)
{
if (!IsInitialized)
{
DebugLog(null, "It has not been initialized.");
return;
}
if (logLevel == LogSeverity.Log)
{
return;
}
if ((uncaught && logLevel < _autoReportLogLevel))
{
DebugLog(null, "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>.*)", RegexOptions.Singleline).Match(message);
if (match.Success)
{
type = match.Groups ["errorType"].Value.Trim();
reason = match.Groups ["errorMessage"].Value.Trim();
}
}
else if ((LogSeverity.LogError == logLevel) && message.StartsWith("Unhandled Exception:"))
{
Match match = new Regex(@"^Unhandled\s+Exception:\s*(?<exceptionName>\S+):\s*(?<exceptionDetail>.*)", RegexOptions.Singleline).Match(message);
if (match.Success)
{
string exceptionName = match.Groups ["exceptionName"].Value.Trim();
string exceptionDetail = match.Groups ["exceptionDetail"].Value.Trim();
//
int dotLocation = exceptionName.LastIndexOf(".");
if (dotLocation > 0 && dotLocation != exceptionName.Length)
{
type = exceptionName.Substring(dotLocation + 1);
}
else
{
type = exceptionName;
}
int stackLocation = exceptionDetail.IndexOf(" at ");
if (stackLocation > 0)
{
//
reason = exceptionDetail.Substring(0, stackLocation);
// substring after " at "
string callStacks = exceptionDetail.Substring(stackLocation + 3).Replace(" at ", "\n").Replace("in <filename unknown>:0", "").Replace("[0x00000]", "");
//
stackTrace = string.Format("{0}\n{1}", stackTrace, callStacks.Trim());
}
else
{
reason = exceptionDetail;
}
// for LuaScriptException
if (type.Equals("LuaScriptException") && exceptionDetail.Contains(".lua") && exceptionDetail.Contains("stack traceback:"))
{
stackLocation = exceptionDetail.IndexOf("stack traceback:");
if (stackLocation > 0)
{
reason = exceptionDetail.Substring(0, stackLocation);
// substring after "stack traceback:"
string callStacks = exceptionDetail.Substring(stackLocation + 16).Replace(" [", " \n[");
//
stackTrace = string.Format("{0}\n{1}", stackTrace, callStacks.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);
}
/// <summary>
/// Configs the auto report log level. Default is LogSeverity.LogError.
/// <example>
/// LogSeverity { Log, LogDebug, LogInfo, LogWarning, LogAssert, LogError, LogException }
/// </example>
/// </summary>
///
/// <param name="level">Level.</param>
public static void ConfigAutoReportLogLevel(LogSeverity level)
{
_autoReportLogLevel = level;
}
/// <summary>
/// Sets the severity
/// </summary>
/// <param name="minimumLevel">Minimum level</param>
public void SetSeverity(LogSeverity minimumLevel)
{
_severityLevel = minimumLevel;
}
private static LogLevel LogLevelFromSeverity(LogSeverity severity) => (LogLevel)(Math.Abs((int)severity - 5));
public qBittorrentClient(Uri host, string userAgent = "qbit-api-core", RetryMode retry = RetryMode.AlwaysRetry, LogSeverity minimum = LogSeverity.Info)
{
Preconditions.NotNull(host, nameof(host));
LogManager = new LogManager(minimum);
ApiClient = new qBitApiClient(userAgent, retry);
ApiClient.SetBaseUrl(Path.Combine(host.AbsoluteUri, $"api/v{qBitApiConfig.APIVersion}"));
LogManager.Message += async msg => await _logEvent.InvokeAsync(msg).ConfigureAwait(false);
ApiClient.SentRequest += async(method, endpoint, millis) =>
{ await _restLogger.VerboseAsync($"{method} {endpoint}: {millis} ms").ConfigureAwait(false); };
_restLogger = LogManager.CreateLogger("Rest");
_stateLock = new SemaphoreSlim(1, 1);
_isFirstLogin = false;
_cancelToken = new CancellationTokenSource();
}
public void StartLogging()
{
try
{
Enabled = true;
string logsDirectoryPath = FileUtility.GetLogDirectory();
string pathSeparator = AppSettings.GetAppSettingValue(AppSettings.PathSeparatorAppSettingName, "/");
logsDirectoryPath += pathSeparator;
string logsDirectoryName = AppSettings.GetAppSettingValue(AppSettings.LoggingDirectoryNameAppSettingName, "Logs");
//string logEmailRecipientsSeparator = AppSettings.GetAppSettingValue(AppSettings.LogEmailRecipientsSeparatorAppSettingName, ";");
//string logEmailRecipientsString = AppSettings.GetAppSettingValue(AppSettings.LogEmailRecipientsAppSettingName, DefaultLogEmailRecipients);
logsDirectoryPath += logsDirectoryName;
CleanupLogsDirectory(logsDirectoryPath);
string logFileExtension = AppSettings.GetAppSettingValue(AppSettings.LogFileExtensionAppSettingName, "log");
string configuredLogSeverityStringValue = AppSettings.GetAppSettingValue(AppSettings.LogSeverityAppSettingName,
DefaultLogSeverity.ToString());
const bool ignoreCase = false;
_configuredLogSeverity =
(LogSeverity)Enum.Parse(typeof(LogSeverity), configuredLogSeverityStringValue, ignoreCase);
//const string format = "M_dd_yyyy_h_mm_ss_tt";
const string format = "M_dd_yyyy";
string logFileName = DateTime.Now.ToString(format);
logFileName = logFileName.Replace(pathSeparator, "_") + "." + logFileExtension;
LogFileName = logFileName;
string logFullPath = logsDirectoryPath + logFileName;
LogFileFullPath = logFullPath;
_logFileInfo = new FileInfo(logFullPath);
DirectoryInfo directoryInfo = _logFileInfo.Directory;
if (directoryInfo == null)
{
return;
}
if (!directoryInfo.Exists)
{
directoryInfo.Create();
}
if (_logFileInfo.Exists)
{
//_logFileInfo.Delete();
}
_logFileStream = File.Open(_logFileInfo.FullName, FileMode.Append, FileAccess.Write);
_logFileStreamWriter = new StreamWriter(_logFileStream);
LogMessage("Start Logging...", LogSeverity.Info);
}
// ReSharper disable once EmptyGeneralCatchClause
catch (Exception e)
{
System.Diagnostics.Debug.WriteLine(e.ToString());
}
}
public static void LogException(this ILogger logger, Exception ex)
{
LogSeverity severity = (ex as IHasLogSeverity)?.Severity ?? LogSeverity.Error;
logger.Log(severity, ex.Message, ex);
}
public void Log(LogSeverity severity, string message, params object[] paramList)
{
}
/// <summary>
/// Log with formatting
/// </summary>
/// <param name="severity">The severity</param>
/// <param name="source">The source</param>
/// <param name="messageTemplate">The message template</param>
/// <param name="arguments">The lines to log</param>
public void LogFormat(LogSeverity severity, string source, string messageTemplate, params object[] arguments)
{
Log(severity, source, string.Format(messageTemplate, arguments));
}
