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)); } } }
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)); }