public static THostBuilder UseNWrathRollingFileLogging <THostBuilder>(
this THostBuilder hostBuilder,
string folderPath = "Logs",
LogLevel minLevel = LogLevel.Error,
LogLevel consoleMinLevel = LogLevel.Info
)
#if NETCOREAPP3
where THostBuilder : IHostBuilder
#else
where THostBuilder : Microsoft.AspNetCore.Hosting.IWebHostBuilder
#endif
{
ILogger baseLogger = LoggingWizard.Spell.RollingFileLogger(folderPath, minLevel);
var emergencyLogger = default(ILogger);
if (Environment.UserInteractive)
{
var mainLogger = baseLogger;
var console = LoggingWizard.Spell.SysConsoleLogger(consoleMinLevel);
emergencyLogger = LoggingWizard.Spell.LambdaLogger(
r => console.Log(r),
b => { /*ignore emergency batch rewrite, write only error*/ },
minLevel
);
baseLogger = new CompositeLogger(new[] { console, mainLogger });
}
baseLogger = LoggingWizard.Spell.BackgroundLogger(baseLogger, emergencyLogger: emergencyLogger);
return(hostBuilder.UseNWrathLogging(baseLogger));
}
/// <summary>
/// Creates the specified type.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>Logger to use (or <see cref="NullLogger.Instance" /> if none is found)</returns>
/// <exception cref="System.ArgumentNullException">type</exception>
public ILogger GetLogger(Type type)
{
if (type == null)
{
throw new ArgumentNullException("type");
}
ILogger resultLogger = null;
CompositeLogger compositeLogger = null;
foreach (var logger in _loggers)
{
if (!logger.Item1.IsSatisfiedBy(type))
{
continue;
}
if (resultLogger != null)
{
if (compositeLogger == null)
{
compositeLogger = new CompositeLogger(type);
compositeLogger.Add(resultLogger);
}
compositeLogger.Add(logger.Item2);
}
else
{
resultLogger = logger.Item2;
}
}
return(compositeLogger ?? resultLogger ?? NullLogger.Instance);
}
protected override void ExecutePdbAgent(CancellationToken cancellationToken)
{
var connectionFactory = new HelperConnectionFactory(this.Helper);
var sqlService = new SqlServerRepository(connectionFactory);
var logger = new CompositeLogger(new List <ILogger>()
{
new AgentLogger(this),
new DatabaseLogger(sqlService.LogRepository, new LogService(sqlService.ConfigurationRepository, sqlService.LogRepository), this)
});
try
{
//can only debug, once the EDDSPerformance database exists... b/c the config key lives there
sqlService.IfInDebugModeLaunchDebugger();
using (var kernel = this.GetKernel())
{
var managerLogic = kernel.Get <MetricSystemManagerAgentLogic>();
logger.WithClassName().LogVerbose($"Starting Manager Logic");
managerLogic.Execute(cancellationToken).GetAwaiter().GetResult();
logger.WithClassName().LogVerbose($"Finish Manager Logic, Start kernel dispose");
}
logger.WithClassName().LogVerbose($"Finish kernel Dispose");
}
catch (Exception ex)
{
logger.WithClassName().LogError($"Metric Manager Failed. Details: {ex.ToString()}");
}
}
public static Summary Run(Benchmark[] benchmarks, IConfig config, Func <Job, IToolchain> toolchainProvider)
{
var resolver = DefaultResolver;
config = BenchmarkConverter.GetFullConfig(benchmarks.FirstOrDefault()?.Target.Type, config);
var title = GetTitle(benchmarks);
var rootArtifactsFolderPath = GetRootArtifactsFolderPath();
using (var logStreamWriter = Portability.StreamWriter.FromPath(Path.Combine(rootArtifactsFolderPath, title + ".log")))
{
var logger = new CompositeLogger(config.GetCompositeLogger(), new StreamLogger(logStreamWriter));
benchmarks = GetSupportedBenchmarks(benchmarks, logger, toolchainProvider, resolver);
var artifactsToCleanup = new List <string>();
try
{
return(Run(benchmarks, logger, title, config, rootArtifactsFolderPath, toolchainProvider, resolver, artifactsToCleanup));
}
finally
{
logger.WriteLineHeader("// * Artifacts cleanup *");
Cleanup(artifactsToCleanup);
}
}
}
static CDRLogger()
{
// Gebruik eigen formatter
BitFactory.Logging.Logger.DefaultFormatterClass = typeof(LogEntryCDRFormatter);
// We gebruiken de application naam als filename voor het log bestand.
filename = String.Format(".\\{0}.log", System.Reflection.Assembly.GetExecutingAssembly().GetName().Name);
if (File.Exists(filename))
{
// We voegen info toe om te vertellen dat dit een nieuwe restart is van de applicatie
using (StreamWriter w = File.AppendText(filename))
{
w.WriteLine();
w.WriteLine(String.Format("Application started at {0:yyyy-MM-dd HH:mm:ss.fff}", DateTime.Now));
w.WriteLine();
} //using
} //if file exists
Logger = new CompositeLogger();
// voeg altijd memory logger toe
memoryLogger = new MemoryLogger(1000); // capacity van 1000 regels maximaal daarna worden de oude overschreven
Logger.AddLogger("MemoryLogger", memoryLogger);
fileLogger = new FileLogger(filename);
Logger.AddLogger("FileLogger", fileLogger);
}
public static THostBuilder UseNWrathSqlLogging <THostBuilder>(
this THostBuilder hostBuilder,
Action <SqlLogSchemaConfig> dbSchemaApply,
ILogger emergencyLogger,
LogLevel minLevel = LogLevel.Error,
LogLevel consoleMinLevel = LogLevel.Info
)
#if NETCOREAPP3
where THostBuilder : IHostBuilder
#else
where THostBuilder : Microsoft.AspNetCore.Hosting.IWebHostBuilder
#endif
{
ILogger baseLogger = LoggingWizard.Spell.SqlLogger(minLevel, dbSchemaApply);
if (Environment.UserInteractive &&
emergencyLogger is ConsoleLogger == false &&
emergencyLogger.CastAs <BackgroundLogger>()?.EmergencyLogger is ConsoleLogger == false
)
{
var mainLogger = baseLogger;
var console = LoggingWizard.Spell.SysConsoleLogger(consoleMinLevel);
baseLogger = new CompositeLogger(new[] { console, mainLogger });
}
baseLogger = LoggingWizard.Spell.BackgroundLogger(baseLogger, emergencyLogger: emergencyLogger);
return(hostBuilder.UseNWrathLogging(baseLogger));
}
static void Main(string[] args)
{
System.Console.WriteLine("Application started - Esc to quit");
var sessionFactory = NHibernateFactory.AssembleSessionFactory(DATABASE_FILE);
ILog consoleLogger = new ConsoleLogger {VerbosityLevel = 2};
ILog databaseLogger = new Logger(new LogEntryDatabaseRepository(sessionFactory)) {VerbosityLevel = 1};
ILog log = new CompositeLogger(consoleLogger, databaseLogger);
var iocContainer = new IocContainerForScheduler();
iocContainer.BindToConstant(sessionFactory);
var taskDirectory = new DirectoryInfo(Assembly.GetExecutingAssembly().Location).Parent.FullName;
var taskScheduler = new Scheduler(iocContainer, taskDirectory, new FileUtilities(), new TimerWithTimestamp(0, 10000), new TimerWithTimestamp(0, 2000), log);
taskScheduler.Start();
try
{
while (System.Console.ReadKey().Key != ConsoleKey.Escape) { }
}
catch (Exception e)
{
log.WriteEntry(new LogEntry(e.Source, e.Message, DateTime.Now));
}
}
protected override void ExecutePdbAgent(CancellationToken cancellationToken)
{
var connectionFactory = new HelperConnectionFactory(this.Helper);
var sqlService = new SqlServerRepository(connectionFactory);
var logger = new CompositeLogger(new List <ILogger>()
{
new AgentLogger(this),
new DatabaseLogger(sqlService.LogRepository, new LogService(sqlService.ConfigurationRepository, sqlService.LogRepository), this)
});
try
{
//can only debug, once the EDDSPerformance database exists... b/c the config key lives there
sqlService.IfInDebugModeLaunchDebugger();
var eventSytemState = sqlService.EventRepository.ReadEventSystemStateAsync().GetAwaiter().GetResult();
var serversPendingQosDeployment = sqlService.PerformanceServerRepository.ReadServerPendingQosDeploymentAsync().GetAwaiter().GetResult();
//If the event system is running normal and there are no servers pending qos deployment
if (eventSytemState == EventSystemState.Normal && !serversPendingQosDeployment.Any())
{
var qosManager = new QoSTaskManager(logger, sqlService, this);
qosManager.Run();
}
}
catch (Exception ex)
{
logger.WithClassName().LogError($"QoS Manager Failed. Details: {ex.ToString()}");
}
}
public void ReturnsFilesFromAllUnderlyingLoggers()
{
var logger1 = new FakeLogger();
logger1.FakeFilesToBackup = new List <string> {
"a.txt", "b.txt"
};
var logger2 = new FakeLogger();
logger2.FakeFilesToBackup = new List <string> {
"c.txt"
};
var loggers = new List <FakeLogger> {
logger1, logger2
};
var sut = new CompositeLogger(loggers);
var list = sut.FilesToBackup;
Assert.Equal(3, list.Count);
Assert.Contains("a.txt", list);
Assert.Contains("b.txt", list);
Assert.Contains("c.txt", list);
}
public static Logger MakeLogger(LoggerOption option)
{
#if UNITY_3_0 || UNITY_3_0_0 || UNITY_3_1 || UNITY_3_2 || UNITY_3_3 || UNITY_3_4 || UNITY_3_5 || UNITY_4_0 || UNITY_4_1 || UNITY_4_2
CompositeLogger logger = new CompositeLogger();
if (option.isPrintEnabled)
{
logger.Add(new UnityConsoleLogger());
}
if (option.isWriteEnabled)
{
logger.Add(new UnityFileLogger(option));
}
return(logger);
#else
CompositeLogger logger = new CompositeLogger();
if (option.isPrintEnabled)
{
logger.Add(new DefaultConsoleLogger());
}
if (option.isWriteEnabled)
{
logger.Add(new DefaultFileLogger());
}
return(logger);
#endif
}
public static Summary Run(BenchmarkRunInfo benchmarkRunInfo, Func <Job, IToolchain> toolchainProvider)
{
var resolver = DefaultResolver;
var benchmarks = benchmarkRunInfo.Benchmarks;
var config = benchmarkRunInfo.Config;
var title = GetTitle(benchmarks);
var rootArtifactsFolderPath = (config?.ArtifactsPath ?? DefaultConfig.Instance.ArtifactsPath).CreateIfNotExists();
using (var logStreamWriter = Portability.StreamWriter.FromPath(Path.Combine(rootArtifactsFolderPath, title + ".log")))
{
var logger = new CompositeLogger(config.GetCompositeLogger(), new StreamLogger(logStreamWriter));
benchmarks = GetSupportedBenchmarks(benchmarks, logger, toolchainProvider, resolver);
var artifactsToCleanup = new List <string>();
try
{
var runInfo = new BenchmarkRunInfo(benchmarks, benchmarkRunInfo.Type, config);
return(Run(runInfo, logger, title, rootArtifactsFolderPath, toolchainProvider, resolver, artifactsToCleanup));
}
finally
{
logger.WriteLineHeader("// * Artifacts cleanup *");
Cleanup(artifactsToCleanup);
}
}
}
protected TransportBase(string protocol, IPersistence persistence, CompositeLogger logger, ISenderProtocol sendingProtocol, BusSettings settings)
{
_sender = new SendingAgent(sendingProtocol);
Protocol = protocol;
Persistence = persistence;
Logger = logger;
_settings = settings[Protocol];
}
public StubIdeScope(ITestOutputHelper testOutputHelper)
{
MonitoringService = new Mock <IMonitoringService>().Object;
CompositeLogger.Add(new DeveroomXUnitLogger(testOutputHelper));
CompositeLogger.Add(StubLogger);
Actions = new StubIdeActions(this);
VsxStubObjects.Initialize();
}
private static void Main(string[] args)
{
// Automatically attached to Log Manager, and also sets it as the default logger to be used
// from LogManager.Log
var l = LogManager.CreateLogger <ColoredConsoleLogger>();
// Default level is Trace, on Debug builds, and Warn+Trace on Release.
LogManager.Logger.Level = LogLevel.Trace;
// Calling the default logger:
LogManager.Log("Hello");
LogManager.LogAsync("Log the same async.");
LogManager.Log(LogLevel.Critical, "This is critical!");
// Alternate ways:
// Exactly the same as above. This is how the above is implemented internally.
LogManager.Logger.Critical("LM: Critical");
LogManager.Logger.Error("LM: oops");
LogManager.Logger.Warn("LM: warning, warning!!");
LogManager.Logger.Info("LM: Hi!");
LogManager.Logger.Debug("LM: Some debug data.");
LogManager.Logger.Trace("LM: Yello");
l.Critical("DIRECT: This should work as well.");
var newLogger = new ConsoleLogger();
newLogger.Level = LogLevel.Trace;
newLogger.IsEnabled = true;
newLogger.Info("DIRECT: SayHi!");
LogManager.AttachLogger(newLogger, "new");
var oldConsoleLogger = LogManager.GetLogger("new");
oldConsoleLogger.Trace("INDIRECT: TRACE Info");
LogManager.DisableAll();
oldConsoleLogger.Info("INDIRECT: won't be printed..");
LogManager.EnableAll();
var cl = new CompositeLogger();
cl.Level = LogLevel.Trace;
cl.AttachTarget(oldConsoleLogger);
cl.Critical("COMPOSITE: hi from composite!");
cl.Info("COMPOSITE: Info");
oldConsoleLogger.Info("Bye bye!");
}
public EnvelopeSender(CompositeLogger logger, IMessageRouter router, IChannelGraph channels, UriAliasLookup aliases, BusSettings settings)
{
_router = router;
_channels = channels;
_aliases = aliases;
_settings = settings;
Logger = logger;
}
public MessageRouter(SerializationGraph serializers, IChannelGraph channels, ISubscriptionsRepository subscriptions, HandlerGraph handlers, CompositeLogger logger, UriAliasLookup lookup)
{
_serializers = serializers;
_channels = channels;
_subscriptions = subscriptions;
_handlers = handlers;
_logger = logger;
_lookup = lookup;
}
private void ApplyLogger()
{
ILoggerSettingsSection section = this.GetLoggerSettings();
ICompositeLogger helper = new CompositeLogger(new CompositeLoggerSettings(section));
helper.AddLogger(new ConsoleLogger(new ConsoleLoggerSettings(section)));
helper.AddLogger(new PersistentLogger(new PersistentLoggerSettings(section)));
this.logger = helper;
}
private static void InitializeLogger()
{
LoggerRow.Height = new GridLength(GameConstants.LoggerRowDefinition);
Logger.Height = GameConstants.LoggerHeight;
CompositeLogger = new CompositeLogger(new List <ILogger>
{
new ConsoleLogger()
});
}
public HandlerPipeline(IEnvelopeSender sender, BusMessageSerializationGraph serializers, HandlerGraph graph, IReplyWatcher replies, CompositeLogger logger, IEnumerable <IMissingHandler> missingHandlers)
{
_sender = sender;
_serializer = serializers;
_graph = graph;
_replies = replies;
_missingHandlers = missingHandlers.ToArray();
Logger = logger;
}
private static void Main(string[] args)
{
// Automatically attached to Log Manager, and also sets it as the default logger to be used
// from LogManager.Log
var l = LogManager.CreateLogger<ColoredConsoleLogger>();
// Default level is Trace, on Debug builds, and Warn+Trace on Release.
LogManager.Logger.Level = LogLevel.Trace;
// Calling the default logger:
LogManager.Log("Hello");
LogManager.LogAsync("Log the same async.");
LogManager.Log(LogLevel.Critical, "This is critical!");
// Alternate ways:
// Exactly the same as above. This is how the above is implemented internally.
LogManager.Logger.Critical("LM: Critical");
LogManager.Logger.Error("LM: oops");
LogManager.Logger.Warn("LM: warning, warning!!");
LogManager.Logger.Info("LM: Hi!");
LogManager.Logger.Debug("LM: Some debug data.");
LogManager.Logger.Trace("LM: Yello");
l.Critical("DIRECT: This should work as well.");
var newLogger = new ConsoleLogger();
newLogger.Level = LogLevel.Trace;
newLogger.IsEnabled = true;
newLogger.Info("DIRECT: SayHi!");
LogManager.AttachLogger(newLogger, "new");
var oldConsoleLogger = LogManager.GetLogger("new");
oldConsoleLogger.Trace("INDIRECT: TRACE Info");
LogManager.DisableAll();
oldConsoleLogger.Info("INDIRECT: won't be printed..");
LogManager.EnableAll();
var cl = new CompositeLogger();
cl.Level = LogLevel.Trace;
cl.AttachTarget(oldConsoleLogger);
cl.Critical("COMPOSITE: hi from composite!");
cl.Info("COMPOSITE: Info");
oldConsoleLogger.Info("Bye bye!");
}
private TestCaseContext CreateContext(TestCase testCase, string correlationId, IDictionary <string, string> options)
{
var writer = new StreamWriter(testCase.GetWriteStream("execution.log"));
var testCaseLogger = new CompositeLogger(
new CompositeLogger.LoggerInfo(_logger, false),
new CompositeLogger.LoggerInfo(new TextWriterLogger(LogLevel.Debug, writer), true)
);
return(new TestCaseContext(options, testCase, correlationId, testCaseLogger, new XDocumentDescriptionWriter(testCaseLogger), new ItemsHolder()));
}
static void Main(string[] args)
{
IEventLogger logger = new CompositeLogger(new ConsoleLogger());
GeneticAlgorithmSimple ga = new GeneticAlgorithmSimple(logger, 0.25, 0.01, 10, 1000);
ga.Run();
ga.WriteResult("GAResult.txt");
Console.ReadKey();
}
public MainWindowViewModel(IEventAggregator eventAggregator)
{
eventAggregator.Subscribe(this);
_logger = new CompositeLogger();
_logger.Add(this);
_logger.Add(new TextLogger());
_archiver = new FileArchiver(eventAggregator);
_watcher = new FileSystemWatcher();
_watcher.Created += Archive;
}
public ServiceBusActivator(BusSettings settings, IHandlerPipeline pipeline, IDelayedJobProcessor delayedJobs, BusMessageSerializationGraph serialization, IEnumerable <ITransport> transports, UriAliasLookup lookups, IWorkerQueue workerQueue, CompositeLogger logger, IPersistence persistence)
{
_settings = settings;
_pipeline = pipeline;
_delayedJobs = delayedJobs;
_serialization = serialization;
_transports = transports.ToArray();
_lookups = lookups;
_workerQueue = workerQueue;
_logger = logger;
_persistence = persistence;
}
public HandlerPipeline(IEnvelopeSender sender, SerializationGraph serializers, HandlerGraph graph, IReplyWatcher replies, IDelayedJobProcessor delayedJobs, CompositeLogger logger, IChannelGraph channels, IEnumerable <IMissingHandler> missingHandlers)
{
_sender = sender;
_serializer = serializers;
_graph = graph;
_replies = replies;
_delayedJobs = delayedJobs;
_channels = channels;
_missingHandlers = missingHandlers.ToArray();
Logger = logger;
}
public static Summary[] Run(BenchmarkRunInfo[] benchmarkRunInfos, IConfig commonSettingsConfig, bool summaryPerType)
{
var resolver = DefaultResolver;
var artifactsToCleanup = new List <string>();
var title = GetTitle(benchmarkRunInfos);
var rootArtifactsFolderPath = (commonSettingsConfig?.ArtifactsPath ?? DefaultConfig.Instance.ArtifactsPath).CreateIfNotExists();
using (var logStreamWriter = Portability.StreamWriter.FromPath(Path.Combine(rootArtifactsFolderPath, title + ".log")))
{
var logger = new CompositeLogger(commonSettingsConfig.GetCompositeLogger(), new StreamLogger(logStreamWriter));
var supportedBenchmarks = GetSupportedBenchmarks(benchmarkRunInfos, logger, resolver);
var validationErrors = Validate(supportedBenchmarks, logger);
if (validationErrors.Any(validationError => validationError.IsCritical))
{
return new [] { Summary.CreateFailed(
supportedBenchmarks.SelectMany(b => b.Benchmarks).ToArray(),
title, HostEnvironmentInfo.GetCurrent(), commonSettingsConfig, GetResultsFolderPath(rootArtifactsFolderPath), validationErrors) }
}
;
var buildPartitions = BenchmarkPartitioner.CreateForBuild(supportedBenchmarks, resolver);
logger.WriteLineHeader("// ***** BenchmarkRunner: Start *****");
var globalChronometer = Chronometer.Start();
var buildResults = BuildInParallel(logger, rootArtifactsFolderPath, buildPartitions, ref globalChronometer);
try
{
var results = new List <Summary>();
var benchmarkToBuildResult = buildResults
.SelectMany(buildResult => buildResult.Key.Benchmarks.Select(buildInfo => (buildInfo.Benchmark, buildInfo.Id, buildResult.Value)))
.ToDictionary(info => info.Benchmark, info => (info.Id, info.Value));
foreach (var benchmarkRunInfo in supportedBenchmarks) // we run them in the old order now using the new build artifacts
{
results.Add(Run(benchmarkRunInfo, benchmarkToBuildResult, resolver, logger, artifactsToCleanup, rootArtifactsFolderPath, ref globalChronometer));
}
return(results.ToArray());
}
finally
{
logger.WriteLineHeader("// * Artifacts cleanup *");
Cleanup(new HashSet <string>(artifactsToCleanup.Distinct()));
}
}
}
public static void Main()
{
var fileLogger = new FileLogger("c:\\path");
var httpLogger = new HttpLogger(new Uri("www.idnes.cz/logs"));
var outputLogger = new OutputLogger();
var multiLogger = new CompositeLogger(fileLogger, httpLogger, outputLogger)
{
MessageBuffer = 50
};
multiLogger.Log("LOG FOR MULTIPLE LOGGERS");
}
public void Setup()
{
mockLogger1 = new Mock<ILog>();
mockLogger2 = new Mock<ILog>();
savedLog1 = null;
savedLog2 = null;
logger = null;
mockLogger1.Setup(l => l.WriteEntry(It.IsAny<LogEntry>())).Callback(
(LogEntry logEntry) => savedLog1 = logEntry );
mockLogger2.Setup(l => l.WriteEntry(It.IsAny<LogEntry>())).Callback(
(LogEntry logEntry) => savedLog2 = logEntry);
}
private static LoggerBase CreateLogger(string channel, LogLevel level)
{
if (_uiContext == null)
{
throw new NullReferenceException("OpenGLLoggerManager must be first configured with proper UI SynchronizationContext object!");
}
var composite = new CompositeLogger(channel, level);
composite.Add(new TizenLogger(channel, level));
composite.Add(new OpenGlLogger(channel, level, _uiContext));
return(composite);
}
/// <summary>
/// Initializes a new instance of the <see cref="CompositeLoggerTest"/> class.
/// </summary>
public CompositeLoggerTest()
{
Log = new CompositeLogger();
var refs = References.FromTuples(
DefaultLoggerFactory.ConsoleLoggerDescriptor, new ConsoleLogger(),
DefaultLoggerFactory.DiagnosticsLoggerDescriptor, new DiagnosticsLogger(),
DefaultLoggerFactory.CompositeLoggerDescriptor, Log
);
Log.SetReferences(refs);
Fixture = new LoggerFixture(Log);
}
static int Main(string[] args)
{
var logger = new CompositeLogger();
var fileLog = new FileLogger("GZipTest.log");
logger.AddChild(fileLog);
logger.AddChild(new ConsoleLogger());
try
{
var argsParser = new ArgsParser(logger);
var param = argsParser.ParsParams(args);
if (param == null)
{
return(1);
}
_sourceFileNameProvider = new FileNameProviderStub(param.SourceFileName);
_targetFileNameProvider = new FileNameProviderStub(param.TargetFileName);
var systemInfoProvider = new SystemInfoProvider();
var appl = new Appl(logger, systemInfoProvider);
switch (param.ApplMode)
{
case ApplMode.Compress:
var compressStrategy = new SmartCompressStrategy(systemInfoProvider);
appl.ExecuteCompress(compressStrategy, _sourceFileNameProvider, _targetFileNameProvider);
break;
case ApplMode.Decompress:
var decompressStrategy = new SmartDecompressStrategy(systemInfoProvider);
appl.ExecuteDecompress(decompressStrategy, _sourceFileNameProvider, _targetFileNameProvider);
break;
}
return(0);
}
catch (Exception ex)
{
logger.Add("Произошла ошибка. Выполнение программы будет завершено\r\n" +
ex.Message + "\r\n" + ex.StackTrace);
AddInnerExceptionToLog(ex, logger);
return(1);
}
finally
{
logger.Close();
}
}
public void ExecutesAllUnderlyingLoggers()
{
var logger1 = new FakeLogger();
var logger2 = new FakeLogger();
var loggers = new List <FakeLogger> {
logger1, logger2
};
var sut = new CompositeLogger(loggers);
sut.ExecuteOnExit(true);
Assert.True(logger1.ExecutedOnExit && logger2.ExecutedOnExit);
}
public WorkerQueue(CompositeLogger logger, IHandlerPipeline pipeline, BusSettings settings, CancellationToken cancellationToken)
{
_logger = logger;
_pipeline = pipeline;
_settings = settings;
_cancellationToken = cancellationToken;
foreach (var worker in _settings.Workers.AllWorkers)
{
AddQueue(worker.Name, worker.Parallelization);
}
DelayedJobs = InMemoryDelayedJobProcessor.ForQueue(this);
}
public void assure_will_register_loggers_via_constructor()
{
Scenario.StartNew(this, scenario =>
{
scenario.Given("Two loggers register via the constructor", () =>
{
logger = new CompositeLogger(new List<ILog>{ mockLogger1.Object, mockLogger2.Object});
});
scenario.When(a_log_message_is_written);
scenario.Then(check_that_all_loggers_saved_the_message);
});
}
