| private GetLogger ( LoggerCacheKey cacheKey ) : Logger | ||
| cacheKey | LoggerCacheKey | |
| return | Logger | |
static void Main(string[] args)
{
var config = new NLog.Config.LoggingConfiguration();
using (var fluentdTarget = new NLog.Targets.Fluentd())
{
fluentdTarget.Layout = new NLog.Layouts.SimpleLayout("${longdate}|${level}|${callsite}|${logger}|${message}");
config.AddTarget("fluentd", fluentdTarget);
config.LoggingRules.Add(new NLog.Config.LoggingRule("demo", LogLevel.Debug, fluentdTarget));
var loggerFactory = new LogFactory(config);
var logger = loggerFactory.GetLogger("demo");
logger.Info("Hello World!");
}
}
static void Main(string[] args)
{
LayoutRendererFactory.AddLayoutRenderer("AppSetting", typeof(AppSettingLayoutReader));
LogFactory logFactory = new LogFactory(new XmlLoggingConfiguration("c:\\NLog.config"));
//TargetCollection targetCollection = LogManager.Configuration.GetConfiguredNamedTargets();
//int cant = targetCollection.Count;
//Target target = targetCollection[0];
//if (target is FileTarget)
//{
// string nombreArchivo = (target as FileTarget).FileName;
// Console.WriteLine(nombreArchivo);
//}
Logger logger1 = logFactory.GetLogger("Logger1");
Logger logger2 = logFactory.GetLogger("Logger2");
for (int i = 0; i < 1000; i++)
{
logger1.Debug("Archivo de salida 1: " + i.ToString("000"));
logger2.Debug("Archivo de salida 2: " + i.ToString("000"));
}
Console.WriteLine("Press any key to contine");
Console.ReadLine();
}
private void LoadLogConfig()
{
NLog.Config.XmlLoggingConfiguration config = new XmlLoggingConfiguration(FileHelper.GetPhysicalPath("config\\nlog.config"), false);
var factory = new NLog.LogFactory(config);
_DefaultLogger = factory.GetLogger("DefaultLog");
}
public NLogLogger(Type type, ILoggingConfigurationResolve loggingConfigurationResolve)
{
if (type == null)
throw new ArgumentNullException("type");
var assembly = type.Assembly;
var loggingConfiguration = loggingConfigurationResolve.GetLoggingConfiguration(assembly);
using (var logFactory = new LogFactory(loggingConfiguration as LoggingConfiguration))
{
_logger = logFactory.GetLogger(type.FullName);
}
}
public ProdutosController()
{
var factory = new LogFactory();
_logger = factory.GetLogger("Default");
_logger.Debug("Criando Controller");
// var produtoRepository = new ProdutoADORepository();
var produtoRepository = new ProdutoEFRepository();
var departamentoRepository = new DepartamentoEFRepository();
_catalogoService = new CatalogoService(produtoRepository, departamentoRepository);
}
public void IndexLogsEvents()
{
// Initialise the configuration
var config = new LoggingConfiguration();
var target = new MemoryTarget
{
Layout = "${Logger}|${Level}|${Message}"
};
config.AddTarget("unitTesting", target);
var rule = new LoggingRule("*", LogLevel.Debug, target);
config.LoggingRules.Add(rule);
// Generate the logger
var factory = new LogFactory
{
Configuration = config
};
var logger = factory.GetLogger(typeof(DynamicController).FullName);
try
{
DynamicController.OverrideLogger(logger);
var controller = new DynamicController();
// Resolve an action that doesn't exist - we are only interested that logging is actually workig
controller.Index("blankServerName", "blankProjectName", "blankBuildName", "nowherenonsenseaction");
var expectedMessages = new[]
{
MakeMessage("Dynamically resolving request", LogLevel.Debug),
MakeMessage("Generating request context", LogLevel.Debug),
MakeMessage("Action is a build level report", LogLevel.Debug),
MakeMessage("Retrieving action handler for nowherenonsenseaction", LogLevel.Debug),
MakeMessage("Unable to find action handler for nowherenonsenseaction", LogLevel.Info),
MakeMessage("Generating error message", LogLevel.Debug)
};
Assert.That(target.Logs.ToArray(), Is.EqualTo(expectedMessages));
}
finally
{
DynamicController.ResetLogger();
}
}
public static void Main(string[] args)
{
// NLog: setup the logger first to catch all errors
var loggerFactory = new NLog.LogFactory();
var logger = loggerFactory.GetLogger("Main");
try
{
logger.Debug("init main");
BuildWebHost(args).Run();
}
catch (Exception e)
{
//NLog: catch setup errors
logger.Error(e, "Stopped program because of exception");
throw;
}
//var logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
//XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
}
public void TypedGetLoggerTest()
{
LogFactory lf = new LogFactory();
MyLogger l1 = (MyLogger)lf.GetLogger("AAA", typeof(MyLogger));
MyLogger l2 = (MyLogger)lf.GetLogger("AAA", typeof(MyLogger));
Logger l3 = lf.GetLogger("AAA", typeof(Logger));
Logger l4 = lf.GetLogger("AAA", typeof(Logger));
Logger l5 = lf.GetLogger("AAA");
Logger l6 = lf.GetLogger("AAA");
Assert.AreSame(l1, l2);
Assert.AreSame(l3, l4);
Assert.AreSame(l5, l6);
Assert.AreSame(l3, l5);
Assert.AreNotSame(l1, l3);
Assert.AreEqual("AAA", l1.Name);
Assert.AreEqual("AAA", l3.Name);
}
public static Logger GetCurrentClassLogger()
{
return(factory.GetLogger(GetClassFullName()));
}
/// <summary>
/// Process the log event
/// <param name="logLevel">The log level.</param>
/// <param name="loggerName">The name of the logger.</param>
/// <param name="message">The log message.</param>
/// <param name="arguments">The log parameters.</param>
/// <param name="eventId">The event id.</param>
/// <param name="eventType">The event type.</param>
/// <param name="relatedActiviyId">The related activity id.</param>
/// </summary>
protected virtual void ProcessLogEventInfo(LogLevel logLevel, string loggerName, [Localizable(false)] string message, object[] arguments, int?eventId, TraceEventType?eventType, Guid?relatedActiviyId)
{
loggerName = (loggerName ?? Name) ?? string.Empty;
StackTrace stackTrace = null;
int userFrameIndex = -1;
if (AutoLoggerName)
{
stackTrace = new StackTrace();
MethodBase userMethod = null;
for (int i = 0; i < stackTrace.FrameCount; ++i)
{
var frame = stackTrace.GetFrame(i);
var method = frame.GetMethod();
if (method.DeclaringType == GetType())
{
// skip all methods of this type
continue;
}
if (method.DeclaringType != null && method.DeclaringType.Assembly == systemAssembly)
{
// skip all methods from System.dll
continue;
}
userFrameIndex = i;
userMethod = method;
break;
}
if (userFrameIndex >= 0)
{
if (userMethod != null && userMethod.DeclaringType != null)
{
loggerName = userMethod.DeclaringType.FullName;
}
}
}
ILogger logger;
if (LogFactory != null)
{
logger = LogFactory.GetLogger(loggerName);
}
else
{
logger = LogManager.GetLogger(loggerName);
}
logLevel = _forceLogLevel ?? logLevel;
if (!logger.IsEnabled(logLevel))
{
return; // We are done
}
var ev = new LogEventInfo();
ev.LoggerName = loggerName;
ev.Level = logLevel;
if (eventType.HasValue)
{
ev.Properties.Add("EventType", eventType.Value);
}
if (relatedActiviyId.HasValue)
{
ev.Properties.Add("RelatedActivityID", relatedActiviyId.Value);
}
ev.Message = message;
ev.Parameters = arguments;
ev.Level = _forceLogLevel ?? logLevel;
if (eventId.HasValue)
{
ev.Properties.Add("EventID", eventId.Value);
}
if (stackTrace != null && userFrameIndex >= 0)
{
ev.SetStackTrace(stackTrace, userFrameIndex);
}
logger.Log(ev);
}
public NLogLogger(Type typeToLog)
{
this.log = Factory.GetLogger(typeToLog.FullName);
}
public static Logger GetCurrentClassLogger()
{
StackFrame frame = new StackFrame(1, false);
return(_globalFactory.GetLogger(frame.GetMethod().DeclaringType.FullName));
}
/// <summary>
/// Process the log event
/// <param name="logLevel">The log level.</param>
/// <param name="loggerName">The name of the logger.</param>
/// <param name="message">The log message.</param>
/// <param name="arguments">The log parameters.</param>
/// <param name="eventId">The event id.</param>
/// <param name="eventType">The event type.</param>
/// <param name="relatedActiviyId">The related activity id.</param>
/// </summary>
protected virtual void ProcessLogEventInfo(LogLevel logLevel, string loggerName, [Localizable(false)] string message, object[] arguments, int?eventId, TraceEventType?eventType, Guid?relatedActiviyId)
{
loggerName = (loggerName ?? Name) ?? string.Empty;
StackTrace stackTrace = null;
int userFrameIndex = -1;
if (AutoLoggerName)
{
stackTrace = new StackTrace();
for (int i = 0; i < stackTrace.FrameCount; ++i)
{
var frame = stackTrace.GetFrame(i);
loggerName = Internal.StackTraceUsageUtils.LookupClassNameFromStackFrame(frame);
if (!string.IsNullOrEmpty(loggerName))
{
userFrameIndex = i;
break;
}
}
}
ILogger logger;
if (LogFactory != null)
{
logger = LogFactory.GetLogger(loggerName);
}
else
{
logger = LogManager.GetLogger(loggerName);
}
logLevel = _forceLogLevel ?? logLevel;
if (!logger.IsEnabled(logLevel))
{
return; // We are done
}
var ev = new LogEventInfo();
ev.LoggerName = loggerName;
ev.Level = logLevel;
if (eventType.HasValue)
{
ev.Properties.Add("EventType", eventType.Value);
}
if (relatedActiviyId.HasValue)
{
ev.Properties.Add("RelatedActivityID", relatedActiviyId.Value);
}
ev.Message = message;
ev.Parameters = arguments;
ev.Level = _forceLogLevel ?? logLevel;
if (eventId.HasValue)
{
ev.Properties.Add("EventID", eventId.Value);
}
if (stackTrace != null && userFrameIndex >= 0)
{
ev.SetStackTrace(stackTrace, userFrameIndex);
}
logger.Log(ev);
}
/// <summary>
/// Gets the logger by name.
/// </summary>
/// <param name="name">The name.</param>
/// <returns></returns>
/// <exception cref="System.NotImplementedException"></exception>
public override ILog GetLogger(string name)
{
return(new NLogLogger(m_DefaultLogFactory.GetLogger(name)));
}
public void GenericGetLoggerTest()
{
LogFactory<MyLogger> lf = new LogFactory<MyLogger>();
MyLogger l1 = lf.GetLogger("AAA");
MyLogger l2 = lf.GetLogger("AAA");
MyLogger l3 = lf.GetLogger("BBB");
Assert.AreSame(l1, l2);
Assert.AreNotSame(l1, l3);
Assert.AreEqual("AAA", l1.Name);
Assert.AreEqual("BBB", l3.Name);
}
public WebServer(NLog.LogFactory factory)
{
LogFactory = factory;
_logger = factory?.GetLogger <NLog.Logger>("webserver") ?? LogManager.LogFactory.CreateNullLogger();
}
