public void ShouldRespectDynamicLevelChanges()
        {
            using (var logger = new LoggerConfiguration()
                                .ReadFrom
                                .Configuration(new ConfigurationBuilder().Add(_configSource).Build())
                                .CreateLogger())
            {
                DummyConsoleSink.Emitted.Clear();
                logger.Write(Some.DebugEvent());
                Assert.Empty(DummyConsoleSink.Emitted);

                DummyConsoleSink.Emitted.Clear();
                UpdateConfig(minimumLevel: LogEventLevel.Debug);
                logger.Write(Some.DebugEvent());
                Assert.Empty(DummyConsoleSink.Emitted);

                DummyConsoleSink.Emitted.Clear();
                UpdateConfig(switchLevel: LogEventLevel.Debug);
                logger.Write(Some.DebugEvent());
                logger.ForContext(Constants.SourceContextPropertyName, "Root.Test").Write(Some.DebugEvent());
                Assert.Single(DummyConsoleSink.Emitted);

                DummyConsoleSink.Emitted.Clear();
                UpdateConfig(overrideLevel: LogEventLevel.Debug);
                logger.ForContext(Constants.SourceContextPropertyName, "Root.Test").Write(Some.DebugEvent());
                Assert.Single(DummyConsoleSink.Emitted);
            }
        }
示例#2
0
        public void ReloadableLoggerRespectsMinimumLevelOverrides()
        {
            var emittedEvents = new List <LogEvent>();
            var logger        = new LoggerConfiguration()
                                .MinimumLevel.Override("Test", LogEventLevel.Warning)
                                .WriteTo.Sink(new ListSink(emittedEvents))
                                .CreateBootstrapLogger();

            var limited = logger
                          .ForContext("X", 1)
                          .ForContext(Constants.SourceContextPropertyName, "Test.Stuff");

            var notLimited = logger.ForContext <ReloadableLoggerTests>();

            foreach (var context in new[] { limited, notLimited })
            {
                // Suppressed by both sinks
                context.Debug("First");

                // Suppressed by the limited logger
                context.Information("Second");

                // Emitted by both loggers
                context.Warning("Third");
            }

            Assert.Equal(3, emittedEvents.Count);
            Assert.Equal(2, emittedEvents.Count(le => le.Level == LogEventLevel.Warning));
        }
示例#3
0
        public void Fact2()
        {
            LoggingLevelSwitch category1Switch = new LoggingLevelSwitch();

            bool CategoriesBelowCertainLevel(LogEvent e)
            {
                return(Matching.FromSource("Category1").Invoke(e) && e.Level < category1Switch.MinimumLevel);
            }

            Logger logger = new LoggerConfiguration()
                            .Enrich.FromLogContext()
                            .MinimumLevel.Verbose()
                            .Filter.ByExcluding(CategoriesBelowCertainLevel)
                            //.AuditTo.Sink()
                            .WriteTo.Logger(configuration => configuration
                                            .MinimumLevel.Warning()
                                            .MinimumLevel.Override("Category1", LogEventLevel.Information)
                                            .WriteTo.File("file1.log"))
                            .WriteTo.Console()
                            .CreateLogger();

            Serilog.ILogger category1Logger = logger.ForContext(Constants.SourceContextPropertyName, "Category1");
            Serilog.ILogger category2Logger = logger.ForContext(Constants.SourceContextPropertyName, "Category2");

            category1Logger.Information("visible");
            category2Logger.Information("invisible");

            category1Logger.Information("invisible");
            category2Logger.Information("visible");
        }
示例#4
0
        public void ReloadableLoggersRecordEnrichment()
        {
            var emittedEvents = new List <LogEvent>();

            var logger = new LoggerConfiguration()
                         .WriteTo.Sink(new ListSink(emittedEvents))
                         .CreateBootstrapLogger();

            var outer = logger
                        .ForContext("A", new object());
            var inner = outer.ForContext("B", "test");

            inner.Information("First");

            logger.Reload(lc => lc.WriteTo.Sink(new ListSink(emittedEvents)));

            inner.Information("Second");

            logger.Freeze();

            inner.Information("Third");

            outer.ForContext("B", "test").Information("Fourth");

            logger.ForContext("A", new object())
            .ForContext("B", "test")
            .Information("Fifth");

            Assert.Equal(5, emittedEvents.Count);
            Assert.All(emittedEvents, e => Assert.Equal(2, e.Properties.Count));
        }
示例#5
0
        private static void Main(string[] args)
        {
            using (var log = new LoggerConfiguration()
                             .MinimumLevel.Debug()
                             // 要使用LogContext.PushProperty, Enrich.FromLogcontext()為必要
                             .Enrich.FromLogContext()
                             .Enrich.WithProperty("Application", "Demo")
                             // Package: Serilog.Enrichers.Environment
                             .Enrich.WithMachineName()
                             // Package: Serilog.Sinks.Console
                             .WriteTo.Console()
                             // Package: Serilog.Sinks.File
                             .WriteTo.File("./log/log.txt")
                             .WriteTo.File(new JsonFormatter(), "./log/log.json")
                             // Package: Serilog.Formatting.Compact
                             .WriteTo.File(new CompactJsonFormatter(), "./log/log.clef")
                             .CreateLogger())
            {
                try
                {
                    throw new Exception("exception test");
                }
                catch (Exception ex)
                {
                    log.Error(ex, "Error Happened: {message}", ex.Message);
                }
                log.Debug("Test");
                log.Information("Hello, Serilog!");
                log.Warning("Goodbye, Serilog.");

                // 加入特定property
                var specialLog = log.ForContext("Customer", "Mike");
                specialLog.Warning("A very rich man! balance: {balance} millions", 100);

                // 以某個Class為Property (property name: SourceProperty)
                var contextLog = log.ForContext <SomeContext>();
                contextLog.Warning("context log");

                // 動態加入property
                using (LogContext.PushProperty("OrderNumber", "ABC123"))
                {
                    using (LogContext.PushProperty("TransactionId", "T12345"))
                    {
                        log.Debug("this log has TransactionId");

                        using (LogContext.PushProperty("OrderNumber", "ABC123"))
                        {
                            log.Debug("this log has OrderNumber");
                        }
                    }

                    log.Debug("this log has no TransactionId");
                }

                log.Debug("this log has no OrderNumber");
            }
        }
        public void LowerMinimumLevelOverridesArePropagated()
        {
            var sink = new CollectingSink();

            var logger = new LoggerConfiguration()
                         .MinimumLevel.Error()
                         .MinimumLevel.Override("Microsoft", LogEventLevel.Debug)
                         .WriteTo.Sink(sink)
                         .CreateLogger();

            logger.Write(Some.InformationEvent());
            logger.ForContext(Constants.SourceContextPropertyName, "Microsoft.AspNet.Something").Write(Some.InformationEvent());
            logger.ForContext <LoggerConfigurationTests>().Write(Some.InformationEvent());

            Assert.Single(sink.Events);
        }
        public void SpecifyingMinimumLevelOverridesInWriteToLoggerWritesWarningToSelfLog()
        {
            var outputs = new List <string>();

            using (TemporarySelfLog.SaveTo(outputs))
            {
                var subSink = new CollectingSink();

                var subLogger = new LoggerConfiguration()
                                .MinimumLevel.Verbose()
                                .MinimumLevel.Override("Foo.Bar", Debug)
                                .WriteTo.Sink(subSink)
                                .CreateLogger();

                var logger = new LoggerConfiguration()
                             .MinimumLevel.Verbose()
                             .MinimumLevel.Override("Foo.Bar", Warning)
                             .WriteTo.Logger(subLogger)
                             .CreateLogger();

                var contextLogger = logger.ForContext(Constants.SourceContextPropertyName, "Foo.Bar");
                contextLogger.Write(Some.InformationEvent());
            }

            Assert.EndsWith("Minimum level overrides are not supported on sub-loggers " +
                            "and may be removed completely in a future version.",
                            outputs.FirstOrDefault() ?? "");
        }
        public void TestMinimumLevelOverrides()
        {
            var settings = new Dictionary <string, string>
            {
                ["minimum-level:override:System"] = "Warning",
            };

            LogEvent evt = null;

            var log = new LoggerConfiguration()
                      .ReadFrom.KeyValuePairs(settings)
                      .WriteTo.Sink(new DelegatingSink(e => evt = e))
                      .CreateLogger();

            var systemLogger = log.ForContext <WeakReference>();

            systemLogger.Write(Some.InformationEvent());

            Assert.Null(evt);

            systemLogger.Warning("Bad things");
            Assert.NotNull(evt);

            evt = null;
            log.Write(Some.InformationEvent());
            Assert.NotNull(evt);
        }
        static void JsonFormattingExample()
        {
            using var log = new LoggerConfiguration()
                            .Enrich.WithProperty("Application", "Example")
                            .WriteTo.Console(new ExpressionTemplate(
                                                 "{ {@t, @mt, @l: if @l = 'Information' then undefined() else @l, @x, ..@p} }\n"))
                            .CreateLogger();

            log.Information("Running {Example}", nameof(JsonFormattingExample));

            log.ForContext <Program>()
            .Information("Cart contains {@Items}", new[] { "Tea", "Coffee" });

            log.ForContext <Program>()
            .Warning("Cart is empty");
        }
示例#10
0
        public void TestMinimumLevelOverrides()
        {
            var settings = new Dictionary <string, string>
            {
                ["minimum-level:override:Microsoft"] = "Warning",
            };

            LogEvent evt = null;

            var log = new LoggerConfiguration()
                      .ReadFrom.KeyValuePairs(settings)
                      .WriteTo.Sink(new DelegatingSink(e => evt = e))
                      .CreateLogger();

            var microsoftLogger = log.ForContext <Microsoft.Extensions.Testing.Abstractions.FullPdbReader>();

            microsoftLogger.Write(Some.InformationEvent());

            Assert.Null(evt);

            microsoftLogger.Warning("Bad things");
            Assert.NotNull(evt);

            evt = null;
            log.Write(Some.InformationEvent());
            Assert.NotNull(evt);
        }
示例#11
0
        public void Fact3()
        {
            DummySink sink = new DummySink();
            LoggerSourceContextLevelOverrides switches = new LoggerSourceContextLevelOverrides(LogEventLevel.Warning,
                                                                                               KeyValuePair.Create("A", LogEventLevel.Debug),
                                                                                               KeyValuePair.Create("2", LogEventLevel.Debug),
                                                                                               KeyValuePair.Create("3", LogEventLevel.Debug),
                                                                                               KeyValuePair.Create("4", LogEventLevel.Debug),
                                                                                               KeyValuePair.Create("5", LogEventLevel.Debug),
                                                                                               KeyValuePair.Create("6", LogEventLevel.Debug),
                                                                                               KeyValuePair.Create("7", LogEventLevel.Debug),
                                                                                               KeyValuePair.Create("8", LogEventLevel.Debug),
                                                                                               KeyValuePair.Create("9", LogEventLevel.Debug),
                                                                                               KeyValuePair.Create("10", LogEventLevel.Debug)
                                                                                               );

            Logger logger = new LoggerConfiguration()
                            .Filter().MinimumLevel()
                            .WriteTo.Logger(c => c
                                            .Filter().Overrides(switches)
                                            .WriteTo.Sink(sink))
                            .CreateLogger();

            Logger defaultLogger = new LoggerConfiguration()
                                   .Filter().MinimumLevel()
                                   .WriteTo.Logger(c => c
                                                   .Filter().Overrides(switches)
                                                   .WriteTo.Sink(sink))
                                   .CreateLogger();

            Serilog.ILogger abLogger = logger.ForContext(Constants.SourceContextPropertyName, "A.B");
            Serilog.ILogger bLogger  = logger.ForContext(Constants.SourceContextPropertyName, "B");

            for (int i = 0; i < 100_000; i++)
            {
                bLogger.Information("b");
            }
            Assert.Empty(sink.Events);

            sink.Events.Clear();
            for (int i = 0; i < 100_000; i++)
            {
                abLogger.Debug("ab");
            }
            Assert.Equal(100000, sink.Events.Count);
            sink.Events.Clear();
        }
        public void FilterWithIsAppliedWithCustomFilter()
        {
            LogEvent evt = null;
            var      log = new LoggerConfiguration()
                           .ReadFrom.KeyValuePairs(new Dictionary <string, string>
            {
                ["using:TestDummies"]  = typeof(DummyLoggerConfigurationExtensions).GetTypeInfo().Assembly.FullName,
                ["filter:With.filter"] = typeof(DummyAnonymousUserFilter).AssemblyQualifiedName
            })
                           .WriteTo.Sink(new DelegatingSink(e => evt = e))
                           .CreateLogger();

            log.ForContext("User", "anonymous").Write(Some.InformationEvent());
            Assert.Null(evt);
            log.ForContext("User", "the user").Write(Some.InformationEvent());
            Assert.NotNull(evt);
        }
示例#13
0
        public LogEventConstructionBenchmark()
        {
            _sink = new CapturingSink();
            var underlyingLogger = new LoggerConfiguration().WriteTo.Sink(_sink).CreateLogger();

            _serilogContextualLogger = underlyingLogger.ForContext <LogEventConstructionBenchmark>();
            _melLogger = new SerilogLoggerProvider(underlyingLogger).CreateLogger(GetType().FullName);
        }
示例#14
0
        /// <summary>
        /// Creates a logger using the application configuration
        /// </summary>
        /// <param name="configuration">The configuration to read from</param>
        /// <returns>An logger instance</returns>
        private static ILogger CreateLogger(IConfiguration configuration)
        {
            var logger = new LoggerConfiguration()
                         .ReadFrom.Configuration(configuration)
                         .CreateLogger();

            Log.Logger = logger;
            return(logger.ForContext <Program>());
        }
        static void PipelineComponentExample()
        {
            using var log = new LoggerConfiguration()
                            .Enrich.WithProperty("Application", "Example")
                            .Enrich.WithComputed("FirstItem", "coalesce(Items[0], '<empty>')")
                            .Enrich.WithComputed("SourceContext", "coalesce(Substring(SourceContext, LastIndexOf(SourceContext, '.') + 1), '<no source>')")
                            .Filter.ByIncludingOnly("Items is null or Items[?] like 'C%'")
                            .WriteTo.Console(outputTemplate:
                                             "[{Timestamp:HH:mm:ss} {Level:u3} ({SourceContext})] {Message:lj} (first item is {FirstItem}){NewLine}{Exception}")
                            .CreateLogger();

            log.Information("Running {Example}", nameof(PipelineComponentExample));

            log.ForContext <Program>()
            .Information("Cart contains {@Items}", new[] { "Tea", "Coffee" });

            log.ForContext <Program>()
            .Information("Cart contains {@Items}", new[] { "Apricots" });
        }
示例#16
0
        public void ExceptionsThrownByAuditSinksArePropagatedFromChildLoggers()
        {
            var logger = new LoggerConfiguration()
                         .AuditTo.Sink(new DelegatingSink(e => { throw new Exception("Boom!"); }))
                         .CreateLogger();

            Assert.Throws <AggregateException>(() => logger
                                               .ForContext <LoggerConfigurationTests>()
                                               .Write(Some.InformationEvent()));
        }
示例#17
0
        //TODO: extract common projects in to shared stages and build then cache
        static async Task Main(string[] args)
        {
            await DockerfileGenerator.WriteResources();

            await Parser.Default.ParseArguments <CmdOptions>(args)
            .WithParsedAsync <CmdOptions>(async o =>
            {
                o.OriginalArgs = string.Join(" ", args);
                var logger     = new LoggerConfiguration()
                                 .MinimumLevel.Debug()
                                 .WriteTo.Console(o.Verbose ? LogEventLevel.Verbose : LogEventLevel.Warning)
                                 .CreateLogger();
                try
                {
                    if (!o.Validate(logger.ForContext <CmdOptions>()))
                    {
                        Environment.ExitCode = 101;
                        return;
                    }

                    o.OutputArgs(logger.ForContext <CmdOptions>());

                    DockerfileGenerator generator =
                        new DockerfileGenerator(o.Template, logger.ForContext <DockerfileGenerator>());
                    if (generator.InvalidTemplate)
                    {
                        Environment.ExitCode = 102;
                        return;
                    }

                    using var solutionsData = new SolutionData(o.SlnFile, logger);
                    var testProvider        = new TestProvider(logger.ForContext <TestProvider>(), o.ProjectsToTest,
                                                               o.AutoTestExclude, o.AutoTestDepth);
                    await execute(o, generator, solutionsData, testProvider, logger);
                }
                catch (Exception ex)
                {
                    logger.Fatal(ex, "Exception thrown in Main");
                    throw;
                }
            });
        }
示例#18
0
        public static Logger 添加上下文()
        {
            var logger = new LoggerConfiguration()
                         .Enrich.WithProperty("Version", "1.0.0")
                         .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}")
                         .CreateLogger();
            var subLogger = logger.ForContext("Version", "1.0.1");//修改了Properties中的Version信息

            subLogger.Information("in {Version}");
            return(logger);
        }
        public static void Main(string[] args)
        {
            var configuration = new ConfigurationBuilder()
                                .SetBasePath(Directory.GetCurrentDirectory())
                                .AddJsonFile(path: "appsettings.json", optional: false, reloadOnChange: true)
                                .Build();

            var logger = new LoggerConfiguration()
                         .ReadFrom.Configuration(configuration)
                         .CreateLogger();

            do
            {
                logger.ForContext <Program>().Information("Hello, world!");
                logger.ForContext(Constants.SourceContextPropertyName, "Microsoft").Warning("Hello, world!");
                logger.ForContext(Constants.SourceContextPropertyName, "MyApp.Something.Tricky").Verbose("Hello, world!");

                Console.WriteLine();
            }while (Console.ReadKey().KeyChar != 'q');
        }
示例#20
0
        public void CachingReloadableLoggerRemainsUsableAfterFreezing()
        {
            var logger     = new LoggerConfiguration().CreateBootstrapLogger();
            var contextual = logger.ForContext <ReloadableLoggerTests>();

            contextual.Information("First");
            logger.Reload(c => c);
            logger.Freeze();
            contextual.Information("Second");
            contextual.Information("Third");
            contextual.Information("Fourth"); // No crash :-)
        }
        static void TextFormattingExample()
        {
            using var log = new LoggerConfiguration()
                            .WriteTo.Console(new ExpressionTemplate(
                                                 "[{@t:HH:mm:ss} " +
                                                 "{@l:u3} " +
                                                 "({coalesce(Substring(SourceContext, LastIndexOf(SourceContext, '.') + 1), '<no source>')})] " +
                                                 "{@m} " +
                                                 "(first item is {coalesce(Items[0], '<empty>')})" +
                                                 "\n" +
                                                 "{@x}"))
                            .CreateLogger();

            log.Information("Running {Example}", nameof(TextFormattingExample));

            log.ForContext <Program>()
            .Information("Cart contains {@Items}", new[] { "Tea", "Coffee" });

            log.ForContext <Program>()
            .Information("Cart contains {@Items}", new[] { "Apricots" });
        }
        public void Can_Specify_Category_As_Missing_Property()
        {
            var methodInfo = nameof(Can_Specify_Category_As_Property);

            using (var log = new LoggerConfiguration()
                             .WriteTo.Loupe(categoryPropertyName: "CategoryWeWillNotFind")
                             .CreateLogger())
            {
                log.ForContext("LoupeCategoryProperty", methodInfo + ".Debug")
                .Debug("This is a debug message about {methodInfo} which should be in the default category", methodInfo);

                log.ForContext("LoupeCategoryProperty", methodInfo + ".Verbose")
                .Verbose("This is a verbose message about {methodInfo} which should be in the default category", methodInfo);

                log.ForContext("LoupeCategoryProperty", methodInfo + ".Info")
                .Information("This is an informational message about {methodInfo} which should be in the default category", methodInfo);

                log.ForContext("LoupeCategoryProperty", methodInfo + ".Error")
                .Error("This is an error message about {methodInfo} which should be in the default category", methodInfo);
            }
        }
        public static void Main(string[] args)
        {
            var configuration = new ConfigurationBuilder()
                                .SetBasePath(Directory.GetCurrentDirectory())
                                .AddJsonFile(path: "appsettings.json", optional: false, reloadOnChange: true)
                                .Build();

            var logger = new LoggerConfiguration()
                         .ReadFrom.Configuration(configuration)
                         .CreateLogger();

            logger.Information("Args: {a}", args);

            do
            {
                logger.ForContext <Program>().Information("Hello, world!");
                logger.ForContext <Program>().Error("Hello, world!");
                logger.ForContext(Constants.SourceContextPropertyName, "Microsoft").Warning("Hello, world!");
                logger.ForContext(Constants.SourceContextPropertyName, "Microsoft").Error("Hello, world!");
                logger.ForContext(Constants.SourceContextPropertyName, "MyApp.Something.Tricky").Verbose("Hello, world!");

                logger.Information("Destructure with max object nesting depth:\n{@NestedObject}",
                                   new { FiveDeep = new { Two = new { Three = new { Four = new { Five = "the end" } } } } });

                logger.Information("Destructure with max string length:\n{@LongString}",
                                   new { TwentyChars = "0123456789abcdefghij" });

                logger.Information("Destructure with max collection count:\n{@BigData}",
                                   new { TenItems = new[] { "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten" } });

                logger.Information("Destructure with policy to strip password:\n{@LoginData}",
                                   new LoginData {
                    Username = "******", Password = "******"
                });

                Console.WriteLine("\nPress \"q\" to quit, or any other key to run again.\n");
            }while(!args.Contains("--run-once") && (Console.ReadKey().KeyChar != 'q'));
        }
示例#24
0
        public void EventsCanBeExcludedBySource()
        {
            var written = false;

            var log = new LoggerConfiguration()
                .Filter.ByExcluding(Matching.FromSource<MatchingTests>())
                .WriteTo.Sink(new DelegatingSink(e => written = true))
                .CreateLogger();

            var sourceContext = log.ForContext<MatchingTests>();
            sourceContext.Write(Some.InformationEvent());

            Assert.False(written);
        }
        public void Can_Specify_Category_As_Property()
        {
            var methodInfo = nameof(Can_Specify_Category_As_Property);

            var categoryPropertyName = "LogCategory";

            using (var log = new LoggerConfiguration()
                             .WriteTo.Loupe(categoryPropertyName: categoryPropertyName)
                             .CreateLogger())
            {
                log.ForContext(categoryPropertyName, methodInfo + ".Debug")
                .Debug("This is a debug message about {methodInfo} which should be in category {" + categoryPropertyName + "}", methodInfo);

                log.ForContext(categoryPropertyName, methodInfo + ".Verbose")
                .Verbose("This is a verbose message about {methodInfo} which should be in category {" + categoryPropertyName + "}", methodInfo);

                log.ForContext(categoryPropertyName, methodInfo + ".Info")
                .Information("This is an informational message about {methodInfo} which should be in category {" + categoryPropertyName + "}", methodInfo);

                log.ForContext(categoryPropertyName, methodInfo + ".Error")
                .Error("This is an error message about {methodInfo} which should be in category {" + categoryPropertyName + "}", methodInfo);
            }
        }
示例#26
0
        public void EventsCanBeExcludedBySource()
        {
            var written = false;

            var log = new LoggerConfiguration()
                      .Filter.ByExcluding(Matching.FromSource <MatchingTests>())
                      .WriteTo.Sink(new DelegatingSink(e => written = true))
                      .CreateLogger();

            var sourceContext = log.ForContext <MatchingTests>();

            sourceContext.Write(Some.InformationEvent());

            Assert.False(written);
        }
示例#27
0
        public void ShouldNotEnrichLogEventsWhenMinLevelIsHigherThanProvidedLogLevel(LogEventLevel logMinLevel, LogEventLevel propertLogLevel)
        {
            var propValue = Guid.NewGuid();
            var propKey   = Some.String();
            var sink      = new CollectingSink();
            var logger    = new LoggerConfiguration()
                            .MinimumLevel.Is(logMinLevel)
                            .WriteTo.Sink(sink)
                            .CreateLogger();

            logger.ForContext(propertLogLevel, propKey, propValue)
            .Write(logMinLevel, string.Empty);

            Assert.True(!sink.SingleEvent.Properties.ContainsKey(propKey));
        }
        private static void ConfigureLogger(IConfiguration config)
        {
            var logger = new LoggerConfiguration()
                         .MinimumLevel.Debug()
                         .Enrich.FromLogContext()
                         .ReadFrom.Configuration(config)
                         .WriteTo.Console()
                         .WriteTo.File(
                new RenderedCompactJsonFormatter(),
                "azure-storage-migrator.log",
                rollOnFileSizeLimit: true,
                fileSizeLimitBytes: 10 * 1024 * 1024 /*10 MB*/,
                retainedFileCountLimit: 10)
                         .CreateLogger();

            Log.Logger = logger.ForContext("SourceContext", "AzureStorageMigrator");
        }
示例#29
0
        public void EventsAreWrittenToTheAliyunLog()
        {
            var targetFramework = typeof(ILogServiceClient)
                                  .Assembly
                                  .GetCustomAttribute <TargetFrameworkAttribute>()
                                  .FrameworkName;

            var stats = new
            {
                DateTime.Now,
                RuntimeInformation.OSDescription,
                RuntimeInformation.OSArchitecture,
                RuntimeInformation.ProcessArchitecture,
                TargetFramework = targetFramework
            };

            var client = LogServiceClientBuilders
                         .HttpBuilder
                         .Endpoint("https://cn-qingdao.log.aliyuncs.com", project)
                         .Credential(accessKeyId, accessKey)
                         .Build();

            var log = new LoggerConfiguration()
                      .WriteTo.AliyunLog(client, logStore, logTags: new Dictionary <string, string> {
                { "Env", "UnitTest" },
                { "App", "Serilog.Sinks.AliyunLog" }
            })
                      .MinimumLevel.Verbose()
                      .CreateLogger();


            log.Information("this is info message {@stats}", stats);
            log.ForContext <AliyunLogSinkTest>().Error(new NotImplementedException(), "this is error message with context {@stats}", stats);
            log.Debug("{@stats}", stats);

            if (Debugger.IsAttached)
            {
                SpinWait.SpinUntil(() => false);
            }
            else
            {
                SpinWait.SpinUntil(() => false, 1000 * 60 * 1);
            }
        }
示例#30
0
        private static void Main()
        {
            var logger = new LoggerConfiguration()
                         .MinimumLevel.Debug()
                         .WriteTo.ColoredConsole(
                outputTemplate: "{Timestamp:HH:mm:ss} ({ThreadId}) [{Level}] {Message:l}{NewLine:l}{Exception:l}")
                         .WriteTo.Trace()
                         .Enrich.WithProperty("App", "Test Harness")
                         .Enrich.With(new ThreadIdEnricher(), new MachineNameEnricher())
                         .CreateLogger();

            logger.Information("Just biting {Fruit} number {Count}", "Apple", 12);
            logger.ForContext <Program>().Information("Just biting {Fruit} number {Count:0000}", "Apple", 12);

            using (logger.BeginTimedOperation("Time a thread sleep for 2 seconds."))
            {
                Thread.Sleep(1000);
                using (logger.BeginTimedOperation("And inside we try a Task.Delay for 2 seconds."))
                {
                    Task.Delay(2000).Wait();
                }
                Thread.Sleep(1000);
            }

            using (logger.BeginTimedOperation("Using a passed in identifier", "test-loop"))
            {
                var a = "";
                for (int i = 0; i < 1000; i++)
                {
                    a += "b";
                }
            }

            // Exceed a limit
            using (logger.BeginTimedOperation("This should execute within 1 second.", null, LogEventLevel.Debug, TimeSpan.FromSeconds(1)))
            {
                Thread.Sleep(1100);
            }



            Console.ReadKey(true);
        }
示例#31
0
        public void LoggingLevelSwitchCanBeUsedForMinimumLevelOverrides()
        {
            var settings = new Dictionary <string, string>
            {
                ["minimum-level"] = "Debug",
                ["level-switch:$specificSwitch"]  = "Warning",
                ["minimum-level:override:System"] = "$specificSwitch",
                ["using:TestDummies"]             = typeof(DummyLoggerConfigurationExtensions).GetTypeInfo().Assembly.FullName,
                ["write-to:DummyWithLevelSwitch.controlLevelSwitch"] = "$specificSwitch"
            };

            LogEvent evt = null;

            var log = new LoggerConfiguration()
                      .ReadFrom.KeyValuePairs(settings)
                      .WriteTo.Sink(new DelegatingSink(e => evt = e))
                      .CreateLogger();

            var systemLogger = log.ForContext(Constants.SourceContextPropertyName, "System.Bar");

            log.Write(Some.InformationEvent());
            Assert.False(evt is null, "Minimum level is Debug. It should log Information messages");

            evt = null;
            // ReSharper disable HeuristicUnreachableCode
            systemLogger.Write(Some.InformationEvent());
            Assert.True(evt is null, "LoggingLevelSwitch initial level was Warning for logger System.*. It should not log Information messages for SourceContext System.Bar");

            systemLogger.Write(Some.WarningEvent());
            Assert.False(evt is null, "LoggingLevelSwitch initial level was Warning for logger System.*. It should log Warning messages for SourceContext System.Bar");


            evt = null;
            var controlSwitch = DummyWithLevelSwitchSink.ControlLevelSwitch;

            controlSwitch.MinimumLevel = LogEventLevel.Information;
            systemLogger.Write(Some.InformationEvent());
            Assert.False(evt is null, "LoggingLevelSwitch level was changed to Information for logger System.*. It should now log Information events for SourceContext System.Bar.");
            // ReSharper restore HeuristicUnreachableCode
        }
示例#32
0
        public void ExceptionsThrownByAuditSinksArePropagatedFromChildLoggers()
        {
            var logger = new LoggerConfiguration()
                .AuditTo.Sink(new DelegatingSink(e => { throw new Exception("Boom!"); }))
                .CreateLogger();

            Assert.Throws<AggregateException>(() => logger
                .ForContext<LoggerConfigurationTests>()
                .Write(Some.InformationEvent()));
        }
示例#33
0
        public void LowerMinimumLevelOverridesArePropagated()
        {
            var sink = new CollectingSink();

            var logger = new LoggerConfiguration()
                .MinimumLevel.Error()
                .MinimumLevel.Override("Microsoft", LogEventLevel.Debug)
                .WriteTo.Sink(sink)
                .CreateLogger();

            logger.Write(Some.InformationEvent());
            logger.ForContext(Serilog.Core.Constants.SourceContextPropertyName, "Microsoft.AspNet.Something").Write(Some.InformationEvent());
            logger.ForContext<LoggerConfigurationTests>().Write(Some.InformationEvent());

            Assert.Equal(1, sink.Events.Count);
        }