public void Log(string msg, Enums.LogLevel level)
{
if (level <= this.level)
{
db.LogMsg(msg);
}
}
private NLog.LogLevel GetLogLevel(Enums.LogLevel logLevel)
{
switch (logLevel)
{
case Enums.LogLevel.Trace:
return(NLog.LogLevel.Trace);
case Enums.LogLevel.Debug:
return(NLog.LogLevel.Debug);
case Enums.LogLevel.Info:
return(NLog.LogLevel.Info);
case Enums.LogLevel.Warn:
return(NLog.LogLevel.Warn);
case Enums.LogLevel.Error:
return(NLog.LogLevel.Error);
case Enums.LogLevel.Fatal:
return(NLog.LogLevel.Fatal);
default:
return(NLog.LogLevel.Off);
}
}
public static LogLevel AsNLog(this Enums.LogLevel logLevel)
{
switch (logLevel)
{
case Enums.LogLevel.Trace:
return(LogLevel.Trace);
case Enums.LogLevel.Debug:
return(LogLevel.Debug);
case Enums.LogLevel.Info:
return(LogLevel.Info);
case Enums.LogLevel.Warn:
return(LogLevel.Warn);
case Enums.LogLevel.Error:
return(LogLevel.Error);
case Enums.LogLevel.Fatal:
return(LogLevel.Fatal);
default:
return(LogLevel.Trace);
}
}
public static void Write(Enums.LogLevel logLevel, Exception exception)
{
var logMessage = Format(exception);
switch (logLevel)
{
case Enums.LogLevel.Debug:
logger.Debug(logMessage);
break;
case Enums.LogLevel.Error:
logger.Error(logMessage);
break;
case Enums.LogLevel.Fatal:
logger.Fatal(logMessage);
break;
case Enums.LogLevel.Info:
logger.Info(logMessage);
break;
case Enums.LogLevel.Warn:
logger.Warn(logMessage);
break;
}
}
public static void Write(Enums.LogLevel logLevel, string logMessage)
{
switch (logLevel)
{
case Enums.LogLevel.Debug:
logger.Debug(logMessage);
break;
case Enums.LogLevel.Error:
logger.Error(logMessage);
break;
case Enums.LogLevel.Fatal:
logger.Fatal(logMessage);
break;
case Enums.LogLevel.Info:
logger.Info(logMessage);
break;
case Enums.LogLevel.Warn:
logger.Warn(logMessage);
break;
}
}
public Log(string message, Enums.Component component, Enums.LogLevel logLevel, DateTime dateTime)
{
Message = message;
Component = component;
LogLevel = logLevel;
DateTime = dateTime;
}
public static void Initialize()
{
// Set loglevel
Level = (Enums.LogLevel)Enum.Parse (typeof (Enums.LogLevel), Services.Config.Get<string> (Enums.ConfigKey.core_loglevel), true);
// Initalize all Addins
foreach (SorentoLib.Addins.ILogger logger in AddinManager.GetExtensionObjects (typeof(SorentoLib.Addins.ILogger)))
{
logger.Initialize ();
}
// LOG: LogInfo.RuntimeServiceInitialized
Services.Logging.LogInfo (string.Format (Strings.LogInfo.RuntimeServiceInitialized, "Logging"));
}
/// <summary>
/// 错误日志（异步）
/// </summary>
/// <param name="ex">错误信息</param>
/// <param name="logLevel">日志等级</param>
/// <param name="errorMessage">错误信息</param>
/// <returns></returns>
public async Task WriteErrorLogAsync(Exception ex, Enums.LogLevel logLevel, string errorMessage)
{
LogError error = new LogError();
error.LogLevel = logLevel;
error.MsgType = ex.GetType().Name;
error.Message = errorMessage + "--系统提示：" + ex.InnerException != null ? ex.InnerException.Message : ex.Message;
error.StackTrace = ex.StackTrace.Length > 300 ? ex.StackTrace.Substring(0, 300) : ex.StackTrace;
error.Source = ex.Source;
error.Time = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
error.Assembly = ex.TargetSite.Module.Assembly.FullName;
error.Method = ex.TargetSite.Name;
await Db.Insertable(error).ExecuteCommandAsync();
}
private void WriteLog(Enums.LogLevel logLevel, string message, int logMessageType, Exception ex = null, string userName = null,
string clientIPAddress = null, string methodName = null, string sourceFile = null, int lineNumber = 0, decimal?executionTimeInMilliseconds = default(decimal?),
int?httpResponseStatusCode = default(int?), string url = null)
{
try
{
string abbrSourceName = string.Empty;
int last = sourceFile.LastIndexOf("\\");
if (last > 0)
{
abbrSourceName = sourceFile.Substring(last, sourceFile.Length - last);
}
if (logLevel <= Enums.LogLevel.Error && ex != null)
{
var dict = new Dictionary <string, string>
{
{ "ex_message", ex.Message },
{ "ex_stacktrace", ex.StackTrace },
{ "method", $"{abbrSourceName}: {methodName}: {lineNumber}" }
};
Analytics.TrackEvent($"{logLevel}: {message}", dict);
}
else
{
Analytics.TrackEvent($"{logLevel}: {message}");
}
if (ex != null)
{
System.Diagnostics.Debug.WriteLine("******************************************************************");
System.Diagnostics.Debug.WriteLine($"ex.Message: {ex.Message}");
System.Diagnostics.Debug.WriteLine($"ex.StackTrace: {ex.StackTrace}");
System.Diagnostics.Debug.WriteLine($"ex.InnerException.Message: {ex.InnerException?.Message}");
System.Diagnostics.Debug.WriteLine($"ex.InnerException.StackTrace: {ex.InnerException?.StackTrace}");
System.Diagnostics.Debug.WriteLine("******************************************************************");
}
else
{
System.Diagnostics.Debug.WriteLine($"{DateTime.Now} {logLevel}: {message}");
}
}
catch (Exception e)
{
Crashes.TrackError(ex);
System.Diagnostics.Debug.WriteLine($"FAILURE TO LOG! Serious application exception which is also blocking analytics functionality! Error: {e.Message} StackTrace: {e.StackTrace}");
}
}
internal void AddError(ref TemplateOutput templateOutput, Exception ex, Enums.LogLevel logLevel)
{
while (ex != null)
{
TemplateError te = new TemplateError()
{
ErrorLevel = logLevel,
Message = ex.Message,
StackTrace = ex.StackTrace,
TemplateIdentity = ProcessModel.TemplateIdentity.Copy()
};
templateOutput.Errors.Add(te);
ex = ex.InnerException;
}
}
public static void LogCalculateEngineConnections(string IP, string message, Enums.LogLevel logLevel)
{
try
{
if (!File.Exists(path4))
{
using (FileStream fs = File.Create(path4))
{
fs.Close();
}
}
using (StreamWriter writter = File.AppendText(path4))
{
writter.Write(DateTime.Now + " " + IP + " " + logLevel.ToString() + " " + message + "\r\n");
writter.Close();
}
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
}
public static void LogSimulatorValues(string IP, string message, Enums.LogLevel logLevel, int value)
{
try
{
if (!File.Exists(path3))
{
using (FileStream fs = File.Create(path3))
{
fs.Close();
}
}
using (StreamWriter writter = File.AppendText(path3))
{
writter.Write(DateTime.Now + " " + IP + " " + logLevel.ToString() + " " + message + value + " bytes." + "\r\n");
writter.Close();
}
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
}
public static void Log(string message, Enums.Component component, Enums.LogLevel logLevel)
{
try
{
if (!File.Exists(path))
{
using (FileStream fs = File.Create(path))
{
fs.Close();
}
}
using (StreamWriter writter = File.AppendText(path))
{
writter.Write(DateTime.Now + " << " + component.ToString() + " >> [" + logLevel.ToString() + "] -> " + message + "\r\n");
writter.Close();
}
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="message"><see cref="Message"/></param>
/// <param name="level"><see cref="Level"/></param>
/// <param name="additionalDatas"><see cref="AdditionalDatas"/></param>
/// <exception cref="ArgumentNullException"><paramref name="message"/> is <c>Null</c>.</exception>
/// <exception cref="ArgumentException"><paramref name="additionalDatas"/> contains some <c>Null</c> or duplicated informations.</exception>
internal LogData(string message, Enums.LogLevel level, params KeyValuePair <string, string>[] additionalDatas)
{
Message = message ?? throw new ArgumentNullException(nameof(message));
Date = DateTime.Now;
Level = level;
var datas = new Dictionary <string, string>();
if (additionalDatas != null)
{
foreach (KeyValuePair <string, string> kvp in additionalDatas)
{
if (string.IsNullOrWhiteSpace(kvp.Key) || kvp.Value == null ||
datas.ContainsKey(kvp.Key.Trim()))
{
throw new ArgumentException(nameof(additionalDatas));
}
datas.Add(kvp.Key.Trim(), kvp.Value);
}
}
AdditionalDatas = datas;
}
private void WriteFormattedLog(Enums.LogLevel _Level, string _Text)
{
string pretext;
switch (_Level)
{
case Enums.LogLevel.TRACE:
pretext = System.DateTime.Now.ToString(datetimeFormat) + " [TRACE] ";
break;
case Enums.LogLevel.INFO:
pretext = System.DateTime.Now.ToString(datetimeFormat) + " [INFO] ";
break;
case Enums.LogLevel.DEBUG:
pretext = System.DateTime.Now.ToString(datetimeFormat) + " [DEBUG] ";
break;
case Enums.LogLevel.WARNING:
pretext = System.DateTime.Now.ToString(datetimeFormat) + " [WARNING] ";
break;
case Enums.LogLevel.ERROR:
pretext = System.DateTime.Now.ToString(datetimeFormat) + " [ERROR] ";
break;
case Enums.LogLevel.FATAL:
pretext = System.DateTime.Now.ToString(datetimeFormat) + " [FATAL] ";
break;
default:
pretext = "";
break;
}
WriteLine(pretext + _Text);
}
public IMassUploaderBuilder EnableLogs(Enums.LogLevel logLevel)
{
enableLogs = true;
return(this);
}
public static void LogGeneratorValues(string message, Enums.GeneratorType generatorType, Enums.LogLevel logLevel, float value)
{
try
{
if (!File.Exists(path2))
{
using (FileStream fs = File.Create(path2))
{
fs.Close();
}
}
using (StreamWriter writter = File.AppendText(path2))
{
writter.Write(DateTime.Now + " " + generatorType.ToString() + " " + logLevel.ToString() + " Value: " + value + "\r\n");
writter.Close();
}
}
catch (Exception e)
{
Console.WriteLine(e.StackTrace);
}
}
public static void Initialize()
{
// // Set loglevel
// Level = (Enums.LogLevel)Enum.Parse (typeof (Enums.LogLevel), Services.Config.Get<string> ("core", "loglevel"), true);
Level = Enums.LogLevel.FatalError | Enums.LogLevel.Error | Enums.LogLevel.Warning | Enums.LogLevel.Info | Enums.LogLevel.Debug;
}
public MassUploader(Classes.NetworkAccount uptoboxAccount, Classes.NetworkAccount megaAccount, Classes.NetworkAccount dropboxAccount, Classes.NetworkAccount unFichierAccount,Classes.NetworkAccount turbotBitAccount, bool enableLogs, Enums.LogLevel logLevel)
{
if (enableLogs) logger = new Logger(logLevel);
if (uptoboxAccount != null)
{
uptboxSession = new Classes.NetworkSession(uptoboxAccount);
uptboxSession.NetworkStatus = Enums.NetworkStatus.Enabled;
if (logger != null) logger.WriteLog("Build", $"Uptobox is enabled, {uptoboxAccount.Id}:{uptoboxAccount.Password}");
}
if (megaAccount != null)
{
megaSession = new Classes.NetworkSession(megaAccount);
megaSession.NetworkStatus = Enums.NetworkStatus.Enabled;
if (logger != null) logger.WriteLog("Build", $"MEGA is enabled, {megaAccount.Id}:{megaAccount.Password}");
}
if (dropboxAccount != null)
{
dropboxSession = new Classes.NetworkSession(dropboxAccount);
dropboxSession.NetworkStatus = Enums.NetworkStatus.Enabled;
if (logger != null) logger.WriteLog("Build", $"Dropbox is enabled, {dropboxAccount.Id}:{dropboxAccount.Password}");
}
if (unFichierAccount != null)
{
unFichierSession = new Classes.NetworkSession(unFichierAccount);
unFichierSession.NetworkStatus = Enums.NetworkStatus.Enabled;
if (logger != null) logger.WriteLog("Build", $"1Fichier is enabled, {unFichierAccount.Id}:{unFichierAccount.Password}");
}
if (turbotBitAccount != null)
{
turbotBitSession = new NetworkSession(turbotBitAccount);
turbotBitSession.NetworkStatus = Enums.NetworkStatus.Enabled;
if (logger != null) logger.WriteLog("Build", $"TurbotBit is enabled, {turbotBitAccount.Id}:{turbotBitAccount.Password}");
}
upload = new Processor.Upload(uptboxSession, megaSession, dropboxSession, unFichierSession,turbotBitSession, logger);
}
public LogData(long EventID, Enums.LogLevel LogLevel, string Message)
{
this.EventID = EventID;
this.LogLevel = LogLevel;
this.Message = Message;
}
public Logger(IBucketListData_Old db, Enums.LogLevel level)
{
this.db = db;
this.level = level;
}
internal static void ServiceConfigChanged()
{
Level = (Enums.LogLevel)Enum.Parse (typeof (Enums.LogLevel), Services.Config.Get<string> (Enums.ConfigKey.core_loglevel), true);
}
protected void AddTemplateVariablesManagerErrorsToRetVal(ref TemplateOutput retVal, Enums.LogLevel logLevel)
{
foreach (var errorItem in TemplateVariablesManager.Errors)
{
retVal.Errors.Add(new TemplateError()
{
ErrorLevel = logLevel,
Message = errorItem,
TemplateIdentity = ProcessModel.TemplateIdentity.Copy()
});
}
}
internal Logger(Enums.LogLevel logLever)
{
Logs = new ObservableCollection <string>();
this.logLevel = logLever;
}
