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!");
}
}
internal static void Main(string[] args)
{
CompositionInitializer.Preload(typeof(IgorSoft.CloudFS.Interface.Composition.ICloudGateway));
CompositionInitializer.Initialize("Gateways", "IgorSoft.CloudFS.Gateways.*.dll");
var factory = new CloudDriveFactory();
CompositionInitializer.SatisfyImports(factory);
var mountSection = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None).Sections[MountSection.Name] as MountSection;
if (mountSection == null)
throw new ConfigurationErrorsException("Mount configuration missing");
try {
var logger = new LogFactory().GetCurrentClassLogger();
var tokenSource = new CancellationTokenSource();
var tasks = new List<Task>();
foreach (var drive in mountSection.Drives.Cast<DriveElement>()) {
var operations = new CloudOperations(factory.CreateCloudDrive(drive.Schema, drive.UserName, drive.Root, new CloudDriveParameters() { EncryptionKey = drive.EncryptionKey }), logger);
tasks.Add(Task.Run(() => operations.Mount(drive.Root, DokanOptions.RemovableDrive, mountSection.Threads, 800, TimeSpan.FromSeconds(drive.Timeout != 0 ? drive.Timeout : 20)), tokenSource.Token));
}
Console.ReadKey(true);
tokenSource.Cancel();
} finally {
foreach (var drive in mountSection.Drives.Cast<DriveElement>())
Dokan.Unmount(drive.Root[0]);
}
}
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 static ABIExitCode Compile(ABIFileSystemOptions options, LogFactory factory)
{
#region Argument exceptions
if (options == null)
throw new ArgumentNullException("options");
if (factory == null)
throw new ArgumentNullException("factory");
#endregion
_logger = factory.GetCurrentClassLogger();
_logger.Debug(options);
try
{
if (!Validate(options))
return ABIExitCode.ErrorDuringValidation;
var engine = new CompilerEngine(options, factory);
var result = engine.Compile();
Debug.Assert(result != ABIExitCode.ErrorExitCodeUnassigned);
return result;
}
catch (Exception ex) // avoid external unhandled exceptions
{
_logger.Error(ex);
}
return ABIExitCode.ErrorUnhandledException;
}
public static void Main(string[] args)
{
var loggerFactory = new NLOG.LogFactory();
if (_NLogConfiguration != null)
{
loggerFactory = NLOG.Web.NLogBuilder.ConfigureNLog(_NLogConfiguration);
}
else
{
loggerFactory = NLOG.Web.NLogBuilder.ConfigureNLog(_NLogConfigFile);
}
var logger = loggerFactory.GetCurrentClassLogger();
var host = Core.Program.WebHostBuilder(args, typeof(Program).Assembly)
.UseStartup(_startupConfigurationType)
.UseNLog()
.Build();
try
{
host.Run();
}
catch (Exception ex)
{
logger.Fatal(ex, "Stopped program");
throw;
}
finally
{
NLOG.LogManager.Shutdown();
}
}
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();
}
static TeamPilgrimLogManager()
{
var designTime = System.ComponentModel.DesignerProperties.GetIsInDesignMode(new DependencyObject());
Instance = designTime
? new LogFactory()
: new LogFactory(new XmlLoggingConfiguration(GetNLogConfigFilePath()));
}
/// <summary>
/// Initializes the specified configuration files, we only use the first found one
/// </summary>
/// <param name="configFiles">All the potential configuration files, order by priority.</param>
/// <returns></returns>
public override bool Initialize(string[] configFiles)
{
if (!base.Initialize(configFiles))
return false;
m_DefaultConfig = new XmlLoggingConfiguration(ConfigFile) { AutoReload = true };
m_DefaultLogFactory = new NLogRef.LogFactory(m_DefaultConfig);
return true;
}
protected void Application_Error(object sender, EventArgs e)
{
var ex = Server.GetLastError();
Debug.WriteLine("ERROR:");
Debug.WriteLine("Url: " + Request.Url);
Debug.WriteLine("Message: " + ex);
Debug.WriteLine(ex.StackTrace);
Server.ClearError();
var logger = new LogFactory().GetLogger("file");
logger.Error(ex);
}
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);
}
}
internal static void Write(Type loggerType, TargetWithFilterChain targets, LogEventInfo logEvent, LogFactory factory)
{
if (targets == null)
{
return;
}
#if !NET_CF
StackTraceUsage stu = targets.GetStackTraceUsage();
if (stu != StackTraceUsage.None && !logEvent.HasStackTrace)
{
StackTrace stackTrace;
#if !SILVERLIGHT
stackTrace = new StackTrace(StackTraceSkipMethods, stu == StackTraceUsage.WithSource);
#else
stackTrace = new StackTrace();
#endif
int firstUserFrame = FindCallingMethodOnStackTrace(stackTrace, loggerType);
logEvent.SetStackTrace(stackTrace, firstUserFrame);
}
#endif
int originalThreadId = Thread.CurrentThread.ManagedThreadId;
AsyncContinuation exceptionHandler = ex =>
{
if (ex != null)
{
if (factory.ThrowExceptions && Thread.CurrentThread.ManagedThreadId == originalThreadId)
{
throw new NLogRuntimeException("Exception occurred in NLog", ex);
}
}
};
for (var t = targets; t != null; t = t.NextInChain)
{
if (!WriteToTargetWithFilterChain(t, logEvent, exceptionHandler))
{
break;
}
}
// Destroy the objects
logEvent.Dispose();
}
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 NLogDemo() {
_logFactory = new LoggerFactory();
LoggingConfiguration config = new LoggingConfiguration();
ColoredConsoleTarget consoleTarget = new ColoredConsoleTarget();
config.AddTarget("console", consoleTarget);
LoggingRule rule1 = new LoggingRule("*", NLog.LogLevel.Trace, consoleTarget);
config.LoggingRules.Add(rule1);
LogFactory factory = new LogFactory(config);
_logFactory.AddNLog(factory);
}
/// <summary>
/// Initializes the specified configuration files, we only use the first found one
/// </summary>
/// <param name="configFiles">All the potential configuration files, order by priority.</param>
/// <returns></returns>
public override bool Initialize(string[] configFiles)
{
if (!base.Initialize(configFiles))
{
return(false);
}
m_DefaultConfig = new XmlLoggingConfiguration(ConfigFile)
{
AutoReload = true
};
m_DefaultLogFactory = new NLogRef.LogFactory(m_DefaultConfig);
return(true);
}
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 void TypedGetCurrentClassLoggerTest()
{
LogFactory lf = new LogFactory();
MyLogger l1 = (MyLogger)lf.GetCurrentClassLogger(typeof(MyLogger));
MyLogger l2 = (MyLogger)lf.GetCurrentClassLogger(typeof(MyLogger));
Logger l3 = lf.GetCurrentClassLogger(typeof(Logger));
Logger l4 = lf.GetCurrentClassLogger(typeof(Logger));
Logger l5 = lf.GetCurrentClassLogger();
Logger l6 = lf.GetCurrentClassLogger();
Assert.AreSame(l1, l2);
Assert.AreSame(l3, l4);
Assert.AreSame(l5, l6);
Assert.AreSame(l3, l5);
Assert.AreNotSame(l1, l3);
Assert.AreEqual("NLog.UnitTests.GetLoggerTests", l1.Name);
Assert.AreEqual("NLog.UnitTests.GetLoggerTests", l3.Name);
}
static void Main(string[] args)
{
ContainerBuilder builder = new ContainerBuilder();
builder.RegisterType<CommandRunner>().As<ICommandRunner>();
builder.RegisterType<QueryParser>().As<IQueryParser>();
builder.RegisterType<QueryValidator>().As<IQueryValidator>();
builder.RegisterType<DirectoryInfoProcessor>().As<IDirectoryInfoProcessor>();
LogFactory logFactory = new LogFactory();
Logger logger = logFactory.GetCurrentClassLogger();
IContainer diContainer = builder.Build();
using (var scope = diContainer.BeginLifetimeScope())
{
ICommandRunner commandRunner = scope.Resolve<ICommandRunner>();
IQueryValidator queryValidator = scope.Resolve<IQueryValidator>();
IQueryParser queryParser = scope
.Resolve<IQueryParser>(new TypedParameter(typeof(IQueryValidator),
queryValidator));
QueryProcessor queryProcessor = new QueryProcessor(commandRunner,
queryParser);
OperationResult queryRunningResult = queryProcessor.RunQuery(args);
Console.WriteLine(queryRunningResult.Successful);
if (!queryRunningResult.Successful)
{
string logString = String.Format("\"{0}\". {1}",
String.Join(" ", args),
queryRunningResult.Description);
logger.Info(logString);
}
#if DEBUG
Console.ReadLine();
#endif
}
}
private static async Task GenerateThumbnailDuration(long vodId)
{
Logger _logger = new NLog.LogFactory().GetCurrentClassLogger();
try {
await FFmpegDownloader.GetLatestVersion(FFmpegVersion.Official);
} catch (NotImplementedException) {
_logger.Warn("OS not supported. Skipping thumbnail generation.");
return;
}
Stream stream;
using (var context = new MainDataContext()) {
stream = context.Streams.FirstOrDefault(item => item.streamId == vodId);
if (stream != null)
{
stream.duration = FFmpeg.GetMediaInfo(GlobalConfig.GetGlobalConfig("contentRootPath") + stream.location + stream.fileName).Result
.Duration
.Seconds;
}
context.SaveChanges();
}
if (stream != null)
{
Task <IMediaInfo> streamFile =
FFmpeg.GetMediaInfo(Path.Combine(GlobalConfig.GetGlobalConfig("contentRootPath"), stream.location, stream.fileName));
var conversion = await FFmpeg.Conversions.New()
.AddStream(streamFile.Result.Streams.FirstOrDefault())
.AddParameter("-vframes 1 -s 320x180")
.SetOutput(Path.Combine(GlobalConfig.GetGlobalConfig("contentRootPath"), stream.location, "thumbnail.jpg"))
.Start();
}
}
public static void SetChatDownloadToFinished(long streamId, bool isLive)
{
Logger _logger = new NLog.LogFactory().GetCurrentClassLogger();
_logger.Info("Chat finished downloading.");
using (var context = new MainDataContext()) {
Stream stream;
if (isLive)
{
stream = context.Streams.FirstOrDefault(item => item.vodId == streamId);
}
else
{
stream = context.Streams.FirstOrDefault(item => item.streamId == streamId);
}
if (stream != null)
{
stream.chatDownloading = false;
}
context.SaveChanges();
}
}
public NLogLogWriterFactory(LogFactory logFactory)
{
_logFactory = logFactory;
}
public ModuleLoggerFactory(NLog.LogFactory factory)
{
this.factory = factory;
}
/// <summary>
/// Initializes a new instance of the <see cref="LogEnabler" /> class.
/// </summary>
/// <param name="factory">The factory.</param>
public LogEnabler(LogFactory factory)
{
this.factory = factory;
}
public LoggerFactory()
{
this.NLogFactory = new NLog.LogFactory();
}
internal static void Write([NotNull] Type loggerType, TargetWithFilterChain targets, LogEventInfo logEvent, LogFactory factory)
{
if (targets == null)
{
return;
}
StackTraceUsage stu = targets.GetStackTraceUsage();
if (stu != StackTraceUsage.None && !logEvent.HasStackTrace)
{
StackTrace stackTrace;
#if WINDOWS_UWP
stackTrace = null;
#elif NETSTANDARD1_5
stackTrace = (StackTrace)Activator.CreateInstance(typeof(StackTrace), new object[] { stu == StackTraceUsage.WithSource });
#elif !SILVERLIGHT
stackTrace = new StackTrace(StackTraceSkipMethods, stu == StackTraceUsage.WithSource);
#else
stackTrace = new StackTrace();
#endif
if (stackTrace != null)
{
var stackFrames = stackTrace.GetFrames();
int?firstUserFrame = FindCallingMethodOnStackTrace(stackFrames, loggerType);
int?firstLegacyUserFrame = firstUserFrame.HasValue ? SkipToUserStackFrameLegacy(stackFrames, firstUserFrame.Value) : (int?)null;
logEvent.GetCallSiteInformationInternal().SetStackTrace(stackTrace, firstUserFrame ?? 0, firstLegacyUserFrame);
}
}
AsyncContinuation exceptionHandler = (ex) => { };
if (factory.ThrowExceptions)
{
int originalThreadId = AsyncHelpers.GetManagedThreadId();
exceptionHandler = ex =>
{
if (ex != null)
{
if (AsyncHelpers.GetManagedThreadId() == originalThreadId)
{
throw new NLogRuntimeException("Exception occurred in NLog", ex);
}
}
};
}
if (targets.NextInChain == null &&
logEvent.Parameters != null &&
logEvent.Parameters.Length > 0 &&
logEvent.Message?.Length < 128 &&
ReferenceEquals(logEvent.MessageFormatter, LogEventInfo.DefaultMessageFormatter))
{
// Signal MessageLayoutRenderer to skip string allocation of LogEventInfo.FormattedMessage
if (!ReferenceEquals(logEvent.MessageFormatter, LogEventInfo.StringFormatMessageFormatter))
{
logEvent.MessageFormatter = LogEventInfo.DefaultMessageFormatterSingleTarget;
}
}
for (var t = targets; t != null; t = t.NextInChain)
{
if (!WriteToTargetWithFilterChain(t, logEvent, exceptionHandler))
{
break;
}
}
}
public NLogLoggerProvider(LogFactory logFactory)
{
if (logFactory == null) throw new ArgumentNullException(nameof(logFactory));
_logFactory = logFactory;
}
public NLogLoggerProvider(NLog.LogFactory p_logFactory)
{
m_nLogFactory = p_logFactory;
}
public static void SetDownloadToFinished(long streamId, bool isLive)
{
Logger _logger = new NLog.LogFactory().GetCurrentClassLogger();
using (var context = new MainDataContext()) {
Stream dbStream;
dbStream = context.Streams.FirstOrDefault(item => item.streamId == streamId);
string streamFile = GlobalConfig.GetGlobalConfig("contentRootPath") + dbStream.location + dbStream.fileName;
dbStream.size = new FileInfo(streamFile).Length;
dbStream.downloading = false;
NotificationHub.Current.Clients.All.SendAsync($"{streamId}-completed",
dbStream);
if (isLive)
{
_logger.Info("Stopping live chat download...");
if (dbStream.chatDownloadJobId.Contains("."))
{
var splitJobKey = dbStream.chatDownloadJobId.Split(".");
JobHelpers.CancelJob(splitJobKey[1], splitJobKey[0], QuartzSchedulers.PrimaryScheduler());
}
else
{
JobHelpers.CancelJob(dbStream.chatDownloadJobId, null,
QuartzSchedulers.PrimaryScheduler());
}
dbStream.chatDownloading = false;
dbStream.duration = getStreamDuration(streamFile);
GenerateThumbnailDuration(streamId);
}
else
{
_logger.Info("Stopping VOD chat download.");
}
context.SaveChanges();
// make another background job for this
string checkVideoThumbnailsEnabled = GlobalConfig.GetGlobalConfig("generateVideoThumbnails");
if (checkVideoThumbnailsEnabled != null && checkVideoThumbnailsEnabled == "True")
{
_logger.Info("Queueing video thumbnail creation job...");
IJobDetail job = JobBuilder.Create <GenerateVideoThumbnailJob>()
.WithIdentity("GenerateVideoThumbnail" + streamId)
.UsingJobData("streamId", streamId)
.UsingJobData("streamFile", streamFile)
.Build();
var schedulerFactory = new StdSchedulerFactory(QuartzSchedulers.PrimaryScheduler());
IScheduler scheduler = schedulerFactory.GetScheduler().Result;
scheduler.Start();
ISimpleTrigger trigger = (ISimpleTrigger)TriggerBuilder.Create()
.WithIdentity("GenerateVideoThumbnail" + streamId)
.StartNow()
.Build();
scheduler.ScheduleJob(job, trigger);
//BackgroundJob.Enqueue(() => GenerateVideoThumbnail(streamId, streamFile));
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LogEnabler" /> class.
/// </summary>
/// <param name="factory">The factory.</param>
public LogEnabler(LogFactory factory)
{
this.factory = factory;
}
public static void Use(LogFactory factory)
{
HostLogger.UseLogger(new NLogHostLoggerConfigurator(factory));
}
/// <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);
}
public NLogHostLoggerConfigurator(LogFactory factory)
{
_factory = factory;
}
public void Initialize(LogFactory log)
{
_logger = log.GetCurrentClassLogger();
_logger.Debug("Initialize");
}
public ModuleSubLoggerFactory(string loggerName, NLog.LogFactory logFactory)
{
this.loggerName = loggerName;
this.logFactory = logFactory;
}
internal void Initialize(string name, LoggerConfiguration loggerConfiguration, LogFactory factory)
{
this.Name = name;
this.Factory = factory;
this.SetConfiguration(loggerConfiguration);
}
public CompilerEngine(ABIFileSystemOptions options, LogFactory factory)
{
_logger = factory.GetCurrentClassLogger();
_options = options;
}
public WebServer(NLog.LogFactory factory)
{
LogFactory = factory;
_logger = factory?.GetLogger <NLog.Logger>("webserver") ?? LogManager.LogFactory.CreateNullLogger();
}
public NLogLogger(LogFactory factory)
{
_logFactory = factory.GetLogger;
_logs = new ConcurrentDictionary<string, NLogLog>();
}
public void Initialize()
{
_fixture = new Fixture();
_logFactory= new LogFactory();
}
internal static void Write([NotNull] Type loggerType, [NotNull] TargetWithFilterChain targetsForLevel, LogEventInfo logEvent, LogFactory factory)
{
#if !NETSTANDARD1_0 || NETSTANDARD1_5
StackTraceUsage stu = targetsForLevel.GetStackTraceUsage();
if (stu != StackTraceUsage.None && !logEvent.HasStackTrace)
{
#if NETSTANDARD1_5
var stackTrace = (StackTrace)Activator.CreateInstance(typeof(StackTrace), new object[] { stu == StackTraceUsage.WithSource });
#elif !SILVERLIGHT
var stackTrace = new StackTrace(StackTraceSkipMethods, stu == StackTraceUsage.WithSource);
#else
var stackTrace = new StackTrace();
#endif
var stackFrames = stackTrace.GetFrames();
int?firstUserFrame = FindCallingMethodOnStackTrace(stackFrames, loggerType);
int?firstLegacyUserFrame = firstUserFrame.HasValue ? SkipToUserStackFrameLegacy(stackFrames, firstUserFrame.Value) : (int?)null;
logEvent.GetCallSiteInformationInternal().SetStackTrace(stackTrace, firstUserFrame ?? 0, firstLegacyUserFrame);
}
#endif
AsyncContinuation exceptionHandler = (ex) => { };
if (factory.ThrowExceptions)
{
int originalThreadId = AsyncHelpers.GetManagedThreadId();
exceptionHandler = ex =>
{
if (ex != null && AsyncHelpers.GetManagedThreadId() == originalThreadId)
{
throw new NLogRuntimeException("Exception occurred in NLog", ex);
}
};
}
if (targetsForLevel.NextInChain == null && logEvent.CanLogEventDeferMessageFormat())
{
// Change MessageFormatter so it writes directly to StringBuilder without string-allocation
logEvent.MessageFormatter = LogMessageTemplateFormatter.DefaultAutoSingleTarget.MessageFormatter;
}
IList <Filter> prevFilterChain = null;
FilterResult prevFilterResult = FilterResult.Neutral;
for (var t = targetsForLevel; t != null; t = t.NextInChain)
{
FilterResult result = ReferenceEquals(prevFilterChain, t.FilterChain) ?
prevFilterResult : GetFilterResult(t.FilterChain, logEvent, t.DefaultResult);
if (!WriteToTargetWithFilterChain(t.Target, result, logEvent, exceptionHandler))
{
break;
}
prevFilterResult = result; // Cache the result, and reuse it for the next target, if it comes from the same logging-rule
prevFilterChain = t.FilterChain;
}
}
internal static void Write(Type loggerType, TargetWithFilterChain targets, LogEventInfo logEvent, LogFactory factory)
{
if (targets == null)
{
return;
}
StackTraceUsage stu = targets.GetStackTraceUsage();
if (stu != StackTraceUsage.None && !logEvent.HasStackTrace)
{
StackTrace stackTrace;
#if !SILVERLIGHT
stackTrace = new StackTrace(StackTraceSkipMethods, stu == StackTraceUsage.WithSource);
#else
stackTrace = new StackTrace();
#endif
int firstUserFrame = FindCallingMethodOnStackTrace(stackTrace, loggerType);
logEvent.SetStackTrace(stackTrace, firstUserFrame);
}
int originalThreadId = Thread.CurrentThread.ManagedThreadId;
AsyncContinuation exceptionHandler = ex =>
{
if (ex != null)
{
if (factory.ThrowExceptions && Thread.CurrentThread.ManagedThreadId == originalThreadId)
{
throw new NLogRuntimeException("Exception occurred in NLog", ex);
}
}
};
for (var t = targets; t != null; t = t.NextInChain)
{
if (!WriteToTargetWithFilterChain(t, logEvent, exceptionHandler))
{
break;
}
}
}
internal static void Write([NotNull] Type loggerType, [NotNull] TargetWithFilterChain targetsForLevel, LogEventInfo logEvent, LogFactory logFactory)
{
logEvent.SetMessageFormatter(logFactory.ActiveMessageFormatter, targetsForLevel.NextInChain == null ? logFactory.SingleTargetMessageFormatter : null);
#if CaptureCallSiteInfo
StackTraceUsage stu = targetsForLevel.GetStackTraceUsage();
if (stu != StackTraceUsage.None)
{
bool attemptCallSiteOptimization = targetsForLevel.TryCallSiteClassNameOptimization(stu, logEvent);
if (attemptCallSiteOptimization && targetsForLevel.TryLookupCallSiteClassName(logEvent, out string callSiteClassName))
{
logEvent.CallSiteInformation.CallerClassName = callSiteClassName;
}
else if (attemptCallSiteOptimization || targetsForLevel.MustCaptureStackTrace(stu, logEvent))
{
CaptureCallSiteInfo(logFactory, loggerType, logEvent, stu);
if (attemptCallSiteOptimization)
{
targetsForLevel.TryRememberCallSiteClassName(logEvent);
}
}
}
#endif
AsyncContinuation exceptionHandler = SingleCallContinuation.Completed;
if (logFactory.ThrowExceptions)
{
int originalThreadId = AsyncHelpers.GetManagedThreadId();
exceptionHandler = ex =>
{
if (ex != null && AsyncHelpers.GetManagedThreadId() == originalThreadId)
{
throw new NLogRuntimeException("Exception occurred in NLog", ex);
}
};
}
IList <Filter> prevFilterChain = null;
FilterResult prevFilterResult = FilterResult.Neutral;
for (var t = targetsForLevel; t != null; t = t.NextInChain)
{
FilterResult result = ReferenceEquals(prevFilterChain, t.FilterChain) ?
prevFilterResult : GetFilterResult(t.FilterChain, logEvent, t.DefaultResult);
if (!WriteToTargetWithFilterChain(t.Target, result, logEvent, exceptionHandler))
{
break;
}
prevFilterResult = result; // Cache the result, and reuse it for the next target, if it comes from the same logging-rule
prevFilterChain = t.FilterChain;
}
}
public Logger CreateLogger(string name)
{
if (_logFactory == null) { _logFactory = CreateLogFactory(); }
return _logFactory.GetLogger(name);
}
public NLogLoggerProvider(LogFactory logFactory) {
_factory = logFactory;
}
/// <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 LogEnabler(LogFactory factory)
{
_factory = factory;
}
internal static void Write([NotNull] Type loggerType, [NotNull] TargetWithFilterChain targetsForLevel, LogEventInfo logEvent, LogFactory factory)
{
#if CaptureCallSiteInfo
StackTraceUsage stu = targetsForLevel.GetStackTraceUsage();
if (stu != StackTraceUsage.None && !logEvent.HasStackTrace)
{
CaptureCallSiteInfo(factory, loggerType, logEvent, stu);
}
#endif
AsyncContinuation exceptionHandler = (ex) => { };
if (factory.ThrowExceptions)
{
int originalThreadId = AsyncHelpers.GetManagedThreadId();
exceptionHandler = ex =>
{
if (ex != null && AsyncHelpers.GetManagedThreadId() == originalThreadId)
{
throw new NLogRuntimeException("Exception occurred in NLog", ex);
}
};
}
if (targetsForLevel.NextInChain == null && logEvent.CanLogEventDeferMessageFormat())
{
// Change MessageFormatter so it writes directly to StringBuilder without string-allocation
logEvent.MessageFormatter = LogMessageTemplateFormatter.DefaultAutoSingleTarget.MessageFormatter;
}
IList <Filter> prevFilterChain = null;
FilterResult prevFilterResult = FilterResult.Neutral;
for (var t = targetsForLevel; t != null; t = t.NextInChain)
{
FilterResult result = ReferenceEquals(prevFilterChain, t.FilterChain) ?
prevFilterResult : GetFilterResult(t.FilterChain, logEvent, t.DefaultResult);
if (!WriteToTargetWithFilterChain(t.Target, result, logEvent, exceptionHandler))
{
break;
}
prevFilterResult = result; // Cache the result, and reuse it for the next target, if it comes from the same logging-rule
prevFilterChain = t.FilterChain;
}
}
internal static void Write(Type loggerType, TargetWithFilterChain targets, LogEventInfo logEvent, LogFactory factory)
{
if (targets == null)
return;
#if !NETCF
bool needTrace = false;
bool needTraceSources = false;
int nst = targets.NeedsStackTrace;
if (nst > 0)
needTrace = true;
if (nst > 1)
needTraceSources = true;
StackTrace stackTrace = null;
if (needTrace && !logEvent.HasStackTrace)
{
int firstUserFrame = 0;
stackTrace = new StackTrace(STACK_TRACE_SKIP_METHODS, needTraceSources);
for (int i = 0; i < stackTrace.FrameCount; ++i)
{
System.Reflection.MethodBase mb = stackTrace.GetFrame(i).GetMethod();
if (mb.DeclaringType == loggerType)
{
firstUserFrame = i + 1;
}
else
{
if (firstUserFrame != 0)
break;
}
}
logEvent.SetStackTrace(stackTrace, firstUserFrame);
}
#endif
for (TargetWithFilterChain awf = targets; awf != null; awf = awf.Next)
{
Target app = awf.Target;
FilterResult result = FilterResult.Neutral;
try
{
FilterCollection filterChain = awf.FilterChain;
for (int i = 0; i < filterChain.Count; ++i)
{
Filter f = filterChain[i];
result = f.Check(logEvent);
if (result != FilterResult.Neutral)
break;
}
if ((result == FilterResult.Ignore) || (result == FilterResult.IgnoreFinal))
{
if (InternalLogger.IsDebugEnabled)
{
InternalLogger.Debug("{0}.{1} Rejecting message because of a filter.", logEvent.LoggerName, logEvent.Level);
}
if (result == FilterResult.IgnoreFinal)
return;
continue;
}
}
catch (Exception ex)
{
InternalLogger.Error("FilterChain exception: {0}", ex);
if (factory.ThrowExceptions)
throw;
else
continue;
}
try
{
app.Write(logEvent);
}
catch (Exception ex)
{
InternalLogger.Error("Target exception: {0}", ex);
if (factory.ThrowExceptions)
throw;
else
continue;
}
if (result == FilterResult.LogFinal)
return;
}
}
/// <summary>
/// Specify that you want to use the NLog logging framework with MassTransit.
/// </summary>
/// <param name="configurator">Optional service bus configurator</param>
/// <param name="factory">Required log-producing factory from NLog</param>
public static void UseNLog(this IBusFactoryConfigurator configurator, LogFactory factory)
{
MassTransit.Logging.Logger.UseLogger(new NLogLogger(factory));
}
