public void WriteToSubLoggerWithLevelSwitchIsSupported()
        {
            var json = @"{
            ""Serilog"": {            
                ""Using"": [""TestDummies""],
                ""LevelSwitches"": {""$switch1"" : ""Warning"" },          
                ""MinimumLevel"" : {
                        ""ControlledBy"" : ""$switch1""
                    },
                ""WriteTo"": [{
                    ""Name"": ""Logger"",
                    ""Args"": {
                        ""configureLogger"" : {
                            ""WriteTo"": [{
                                ""Name"": ""DummyRollingFile"",
                                ""Args"": {""pathFormat"" : ""C:\\""}
                            }]}
                    }
                }]        
            }
            }";

            var log = ConfigFromJson(json)
                      .CreateLogger();

            DummyRollingFileSink.Reset();

            log.Write(Some.InformationEvent());
            log.Write(Some.WarningEvent());

            Assert.Equal(1, DummyRollingFileSink.Emitted.Count);
        }
        public void WriteToSinkIsAppliedWithCustomSinkAndLevelSwitch()
        {
            var json = $@"{{
                ""Serilog"": {{
                    ""Using"": [""TestDummies""],
                    ""LevelSwitches"": {{""$switch1"": ""Warning"" }},
                    ""WriteTo"": [
                    {{
                        ""Name"": ""Sink"",
                        ""Args"": {{
                            ""sink"": ""{typeof(DummyRollingFileSink).AssemblyQualifiedName}"",
                            ""levelSwitch"": ""$switch1""
                        }}
                    }}]
                }}
            }}";

            var log = ConfigFromJson(json)
                      .CreateLogger();

            DummyRollingFileSink.Reset();
            log.Write(Some.InformationEvent());
            log.Write(Some.WarningEvent());

            Assert.Single(DummyRollingFileSink.Emitted);
        }
예제 #3
0
        public void WritingToUndeclaredSinkWritesToSelfLog()
        {
            Messages = new();
            SelfLog.Enable(m =>
            {
                Messages = Messages ?? new();
                Messages.Add(m);
            });

            var settings = new Dictionary <string, string>
            {
                ["write-to:DummyRollingFile.pathFormat"] = "C:\\"
            };

            var log = new LoggerConfiguration()
                      .ReadFrom.KeyValuePairs(settings)
                      .CreateLogger();

            DummyRollingFileSink.Reset();
            DummyRollingFileAuditSink.Reset();

            log.Write(Some.InformationEvent());

            Assert.Single(Messages);
            Assert.Contains(Messages, m => m.EndsWith("Setting \"DummyRollingFile\" could not be matched to an implementation in any of the loaded assemblies. " +
                                                      "To use settings from additional assemblies, specify them with the \"serilog:using\" key."));
        }
예제 #4
0
 static void ClearDummySinkStaticState()
 {
     DummyConsoleSink.Reset();
     DummyAuditSink.Reset();
     DummySink.Reset();
     DummySinkWithComplexParams.Reset();
     DummyRollingFileAuditSink.Reset();
     DummyRollingFileSink.Reset();
     DummySinkWithParams.Reset();
     DummyWithLevelSwitchSink.Reset();
 }
        public void AuditToSinkIsAppliedWithCustomSink()
        {
            var log = new LoggerConfiguration()
                      .ReadFrom.KeyValuePairs(new Dictionary <string, string>
            {
                ["using:TestDummies"]  = typeof(DummyLoggerConfigurationExtensions).GetTypeInfo().Assembly.FullName,
                ["audit-to:Sink.sink"] = typeof(DummyRollingFileSink).AssemblyQualifiedName
            })
                      .CreateLogger();

            DummyRollingFileSink.Reset();
            log.Write(Some.InformationEvent());

            Assert.Single(DummyRollingFileSink.Emitted);
        }
        public void WriteToSinkIsAppliedWithCustomSinkAndLevelSwitch()
        {
            var log = new LoggerConfiguration()
                      .ReadFrom.KeyValuePairs(new Dictionary <string, string>
            {
                ["using:TestDummies"]         = typeof(DummyLoggerConfigurationExtensions).GetTypeInfo().Assembly.FullName,
                ["level-switch:$switch1"]     = "Warning",
                ["write-to:Sink.sink"]        = typeof(DummyRollingFileSink).AssemblyQualifiedName,
                ["write-to:Sink.levelSwitch"] = "$switch1"
            })
                      .CreateLogger();

            DummyRollingFileSink.Reset();
            log.Write(Some.InformationEvent());
            log.Write(Some.WarningEvent());

            Assert.Single(DummyRollingFileSink.Emitted);
        }
        public void AuditSinksAreConfigured()
        {
            var settings = new Dictionary <string, string>
            {
                ["using:TestDummies"] = typeof(DummyLoggerConfigurationExtensions).GetTypeInfo().Assembly.FullName,
                ["audit-to:DummyRollingFile.pathFormat"] = "C:\\"
            };

            var log = new LoggerConfiguration()
                      .ReadFrom.KeyValuePairs(settings)
                      .CreateLogger();

            DummyRollingFileSink.Reset();
            DummyRollingFileAuditSink.Reset();

            log.Write(Some.InformationEvent());

            Assert.Empty(DummyRollingFileSink.Emitted);
            Assert.Single(DummyRollingFileAuditSink.Emitted);
        }
        public void CaseInsensitiveArgumentNameMatching()
        {
            var json = @"{
                ""Serilog"": {            
                    ""Using"": [""TestDummies""],
                    ""WriteTo"": [{
                        ""Name"": ""DummyRollingFile"",
                        ""Args"": {""PATHFORMAT"" : ""C:\\""}
                    }]        
                }
            }";

            var log = ConfigFromJson(json)
                      .CreateLogger();

            DummyRollingFileSink.Reset();

            log.Write(Some.InformationEvent());

            Assert.Equal(1, DummyRollingFileSink.Emitted.Count);
        }
        public void SinkWithIntArrayArgument()
        {
            var json = @"{
                ""Serilog"": {            
                    ""Using"": [""TestDummies""],
                    ""WriteTo"": [{
                        ""Name"": ""DummyRollingFile"",
                        ""Args"": {""pathFormat"" : ""C:\\"",
                                   ""intArrayBinding"" : [ 1,2,3,4,5 ] }
                    }]        
                }
            }";

            var log = ConfigFromJson(json)
                      .CreateLogger();

            DummyRollingFileSink.Reset();

            log.Write(Some.InformationEvent());

            Assert.Equal(1, DummyRollingFileSink.Emitted.Count);
        }
        public void SinkWithConfigurationBindingArgument()
        {
            var json = @"{
                ""Serilog"": {            
                    ""Using"": [""TestDummies""],
                    ""WriteTo"": [{
                        ""Name"": ""DummyRollingFile"",
                        ""Args"": {""pathFormat"" : ""C:\\"",
                                   ""objectBinding"" : [ { ""foo"" : ""bar"" }, { ""abc"" : ""xyz"" } ] }
                    }]        
                }
            }";

            var log = ConfigFromJson(json)
                      .CreateLogger();

            DummyRollingFileSink.Reset();

            log.Write(Some.InformationEvent());

            Assert.Equal(1, DummyRollingFileSink.Emitted.Count);
        }
        public void AuditSinksAreConfigured()
        {
            var json = @"{
                ""Serilog"": {            
                    ""Using"": [""TestDummies""],
                    ""AuditTo"": [{
                        ""Name"": ""DummyRollingFile"",
                        ""Args"": {""pathFormat"" : ""C:\\""}
                    }]        
                }
            }";

            var log = ConfigFromJson(json)
                      .CreateLogger();

            DummyRollingFileSink.Reset();
            DummyRollingFileAuditSink.Reset();

            log.Write(Some.InformationEvent());

            Assert.Equal(0, DummyRollingFileSink.Emitted.Count);
            Assert.Equal(1, DummyRollingFileAuditSink.Emitted.Count);
        }