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