private static ILogger CreateLogger(IContext context)
{
var declaringType = context.Request.Target.Member.DeclaringType;
var fullName = declaringType == null ? "" : declaringType.FullName;
return(new LoggerAdapter(LogManager.GetLogger(fullName)));
}
private NLogger GetLogger(string loggerName, NLogLevel consoleLogLevel, NLogLevel fileLogLevel)
{
try
{
InternalLock.EnterUpgradeableReadLock();
if (ConfiguredLoggers.Any(ln => ln == loggerName))
{
return(NLogManager.GetLogger(loggerName));
}
try
{
InternalLock.EnterWriteLock();
var logger = InitializeOfflineLogger(loggerName, consoleLogLevel, fileLogLevel);
ConfiguredLoggers.Add(loggerName);
return(logger);
}
finally
{
if (InternalLock.IsWriteLockHeld)
{
InternalLock.ExitWriteLock();
}
}
}
finally
{
if (InternalLock.IsUpgradeableReadLockHeld)
{
InternalLock.ExitUpgradeableReadLock();
}
}
}
/// <summary>
/// The entry point
/// </summary>
static void Main(string[] args)
{
// Initialize logging
InitializeLogging();
// Create the private Hologic tags and add them
// to the default dictionary
CreateHologicPrivateDictionary();
// Register DICOM implementations
RegisterDicomImplementations();
// Parse input arguments and...
Parser.Default.ParseArguments <Options>(args)
.WithParsed <Options>(o =>
{
try
{
// ... do the actual decoding
DecodeScoToBto(o.Input, o.Output);
}
catch (Exception ex)
{
LogManager.GetCurrentClassLogger().Error(ex);
}
});
}
public static void DumpLoggerInfo(NLog.LogManager logManager)
{
//foreach ( var item in logManager.Configuration.Rules )
//{
//}
}
public NLogLogger(string logName)
: base(logName)
{
if (logName == Constants.LoggerNames.DefaultLogger || string.IsNullOrEmpty(logName))
{
_logger = NLogLogManager.GetCurrentClassLogger();
return;
}
_logger = NLogLogManager.GetLogger(logName);
}
public TcpXmppConnection(IXmppListener listener, TcpClient client)
{
this._listener = listener;
this._client = client;
this._stream = this._client.GetStream();
var id = Guid.NewGuid().ToString("D");
this.Session = new TcpXmppSession(id);
this._log = LogManager.GetLogger($"{GetType().Name}/{id}");
}
static void Main()
{
SimpleConfigurator.ConfigureForConsoleLogging();
LogManager.GetLogger("app").Info("works");
NLogAppender.Initialize();
LogWithLog4Net();
Console.ReadLine();
}
public void LogsAreIgnoredBasedOnLogLevel()
{
Logger logger = Logger.GetLogger("LoggerTests", this.testConfig);
string logMessage = "This is a log message";
logger.Debug(logMessage);
NLogManager.Shutdown();
string pathToLogFile = Path.Combine(this.testConfig.LogFilePath, this.testConfig.LogFileName);
Assert.IsFalse(File.Exists(pathToLogFile), "Log file should not be created.");
}
public void LogsAreEmittedBasedOnLogLevel()
{
Logger logger = Logger.GetLogger("LoggerTests", this.testConfig);
string logMessage = "This is a log message";
logger.Info(logMessage);
NLogManager.Shutdown();
string pathToLogFile = Path.Combine(this.testConfig.LogFilePath, this.testConfig.LogFileName);
Assert.IsTrue(File.Exists(pathToLogFile), "Log file was not created");
Assert.IsTrue(File.ReadAllText(pathToLogFile).Trim().EndsWith(logMessage), "The log doesn't contain the log message.");
}
public ILogger GetLogger(string name)
{
if (!loggerCache.ContainsKey(name))
{
lock (loggerCacheLock)
{
if (!loggerCache.ContainsKey(name))
{
var logger = new NLogLogger(LogManager.GetLogger(name));
loggerCache[name] = logger;
}
}
}
return(loggerCache[name]);
}
public Task FlushAsync(TimeSpan timeout)
{
var tcs = new TaskCompletionSource <object>();
NLogManager.Flush(
e =>
{
if (e != null)
{
tcs.TrySetException(e);
}
else
{
tcs.TrySetResult(null);
}
},
timeout);
return(tcs.Task);
}
static void Main()
{
var log = LogManager.GetCurrentClassLogger();
log.Info("ABC Pos startuje");
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
DevExpress.Skins.SkinManager.EnableFormSkins();
DevExpress.UserSkins.BonusSkins.Register();
UserLookAndFeel.Default.SetSkinStyle("Metropolis");
Application.Run(new Shell());
Application.ThreadException += (s, e) =>
{
log.ErrorException("Neobrađena greška", e.Exception);
Shell.ShowError(e.Exception.Message);
};
}
public void Log(LogLevel logLevel, string message, Exception exception = null)
{
var logger = LogManager.GetLogger(GetCallerType());
NLog.LogLevel level;
switch (logLevel)
{
case LogLevel.Trace:
level = NLog.LogLevel.Trace;
break;
case LogLevel.Debug:
level = NLog.LogLevel.Debug;
break;
case LogLevel.Warn:
level = NLog.LogLevel.Warn;
break;
case LogLevel.Error:
level = NLog.LogLevel.Error;
break;
case LogLevel.Fatal:
level = NLog.LogLevel.Fatal;
break;
default:
level = NLog.LogLevel.Info;
break;
}
if (exception != null)
{
logger.Log(level, exception, message);
}
else
{
logger.Log(level, message);
}
}
public void RoutesToCommonLogging()
{
LoggingConfiguration cfg = new LoggingConfiguration();
CommonLoggingTarget target = new CommonLoggingTarget("${level:uppercase=true}|${logger}|${message}");
cfg.LoggingRules.Add(new LoggingRule("*", LogLevel.Trace, target));
NLogLogManager.Configuration = cfg;
// configure for capturing
CapturingLoggerFactoryAdapter adapter = new CapturingLoggerFactoryAdapter();
LogManager.Adapter = adapter;
string msg = "testmessage";
Exception ex = new Exception("testexception");
adapter.ClearLastEvent();
NLogLogManager.GetLogger("myLogger").DebugException(msg, ex);
Assert.AreEqual("myLogger", adapter.LastEvent.Source.Name);
Assert.AreEqual(string.Format("DEBUG|myLogger|{0}", msg), adapter.LastEvent.RenderedMessage);
Assert.AreSame(ex, adapter.LastEvent.Exception);
}
public void Flush()
{
NLogManager.Flush();
}
private void InitializeOnlineLogger(string appName, string appVersion, string connStr)
{
var loggerName = $"SigniaReactor_{appName}_{appVersion}";
var target = new DatabaseTarget
{
ConnectionString = connStr,
Name = loggerName,
CommandText = "insert into [LogTable]([time_stamp], [level], [machinename], [processid], [processname], [message], [exception_info])"
+ " values(@time_stamp, @level, @machinename, @processid, @processname, @message, @exception_info);"
};
target.Parameters.Add(
new DatabaseParameterInfo
{
Name = "@time_stamp",
Layout = "${date}"
});
target.Parameters.Add(
new DatabaseParameterInfo
{
Name = "@level",
Layout = "${level}"
});
target.Parameters.Add(
new DatabaseParameterInfo
{
Name = "@machinename",
Layout = "${machinename}"
});
target.Parameters.Add(
new DatabaseParameterInfo
{
Name = "@processid",
Layout = "${processid}"
});
target.Parameters.Add(
new DatabaseParameterInfo
{
Name = "@processname",
Layout = "${processname}"
});
target.Parameters.Add(
new DatabaseParameterInfo
{
Name = "@message",
Layout = "${message}"
});
//moze stacktrace tylko w opisie wyjatku...
//target.Parameters.Add(
// new DatabaseParameterInfo
// {
// Name = "@stacktrace",
// Layout = "${stacktrace}"
// });
target.Parameters.Add(
new DatabaseParameterInfo
{
Name = "@exception_info",
Layout = "${exception:format=Message, Type, StackTrace:separator=\r\n}"
});
#if DEBUG
LogLevels severity = LogLevels.Trace;
#else
LogLevels severity = LogLevels.Info;
#endif
var debugRule = new LoggingRule(loggerName, NLogLevel.FromOrdinal((int)severity), target);
var config = NLogManager.Configuration ?? new LoggingConfiguration();
config.AddTarget("debugDB", target);
config.LoggingRules.Add(debugRule);
NLogManager.Configuration = config;
_logger = NLogManager.GetLogger(loggerName);
_logger.Trace("Online (Database) Logger initialized");
_defaultLogger = this;
}
private NLogger InitializeOfflineLogger(string loggerName, NLogLevel consoleLogLevel, NLogLevel fileLogLevel)
{
var config = NLogManager.Configuration ?? new LoggingConfiguration();
var newRegistrationMsg = new StringBuilder();
#if DEBUG
var target = config.FindTargetByName("debugConsoleTarget");
if (target == null)
{
var wrapper = new ConsoleTarget
{
Name = "debugConsoleTarget",
Layout =
"${longdate} | ${logger} | ${level} ${message} ${exception:format=Message, Type, StackTrace:separator=\r\n}"
};
target = new AsyncTargetWrapper(wrapper, 5000, AsyncTargetWrapperOverflowAction.Discard);
// LogLayout.DEFAULT_LAYOUT;
config.AddTarget("debugConsoleTarget", target);
newRegistrationMsg.AppendLine($"New file target {target.Name} created");
}
var isRuleRegistered =
config.LoggingRules.Any(lr => lr.LoggerNamePattern == loggerName && lr.Targets.Any(t => t == target));
if (!isRuleRegistered)
{
var debugRule = new LoggingRule(loggerName, consoleLogLevel, target);
config.LoggingRules.Add(debugRule);
newRegistrationMsg.AppendLine($"New logging rule with params: {loggerName}|{consoleLogLevel}|{target.Name} added to configuration");
}
target = config.FindTargetByName("debugFileTarget");
if (target == null)
{
var wrapper = new FileTarget
{
Name = "debugFileTarget",
FileName = $"{loggerName}_{DateTime.Now:yyyy-MM-dd}.txt",
Layout =
"${longdate} | ${logger} | ${level} ${message} ${exception:format=Message, Type, StackTrace:separator=\r\n}"
};
target = new AsyncTargetWrapper(wrapper, 5000, AsyncTargetWrapperOverflowAction.Discard);
// LogLayout.DEFAULT_LAYOUT;
config.AddTarget("debugFileTarget", target);
newRegistrationMsg.AppendLine($"New file target {target.Name} created");
}
isRuleRegistered =
config.LoggingRules.Any(lr => lr.LoggerNamePattern == loggerName && lr.Targets.Any(t => t == target));
if (!isRuleRegistered)
{
var debugRule = new LoggingRule(loggerName, fileLogLevel, target);
config.LoggingRules.Add(debugRule);
newRegistrationMsg.AppendLine($"New logging rule with params: {loggerName}|{fileLogLevel}|{target.Name} added to configuration");
}
#endif
NLogManager.Configuration = config;
var logger = NLogManager.GetLogger(loggerName);
if (newRegistrationMsg.Length > 0)
{
logger.Info($"New logger registrations: {newRegistrationMsg}");
}
return(logger);
}
public ILog GetLogger(string name)
{
var logger = NlogLogManager.GetLogger(name);
return(new Logger(logger));
}
public ILog GetLogger(Type type)
{
var logger = NlogLogManager.GetLogger(type.FullName);
return(new Logger(logger));
}
public void MethodContainingNLogNode()
{
var log = NLogLogManager.GetCurrentClassLogger();
log.Debug("Test");
}
public ILogger Create(string name)
{
return(new Logger(NLogManager.GetLogger(name)));
}
public ILogger GetLogger(string name)
{
return(new LoggerAdaptor(NLogLogManager.GetLogger(name)));
}
public NLogger(Type type)
{
logger = LogManager.GetLogger(type.Name);
}
public void Flush(TimeSpan timeout)
{
NLogManager.Flush(timeout);
}
/// <summary>
/// 创建指定名称的缓存实例
/// </summary>
/// <param name="name">指定名称</param>
/// <returns></returns>
protected override ILog CreateLogger(string name)
{
var log = LogManager.GetLogger(name);
return(new NLogLogger(log));
}
private Logger(string className)
{
this.nLogger = NLogManager.GetLogger(className);
}
