public void Log_InIgnoredScopePrefix_LogsWithoutScope()
        {
            loggerProvider = new VostokLoggerProvider(
                log,
                new VostokLoggerProviderSettings
            {
                IgnoredScopePrefixes = new HashSet <string> {
                    "system"
                }
            });

            var logger = loggerProvider.CreateLogger(null);

            using (var scope1 = logger.BeginScope(new HashSet <int>()))
                using (var scope2 = logger.BeginScope(new HashSet <string>()))
                {
                    scope1.Should().BeOfType <EmptyDisposable>();
                    scope2.Should().BeOfType <EmptyDisposable>();

                    logger.LogInformation("message");
                }

            var expectedLogEvent = new VostokLogEvent(LogLevel.Info, DateTimeOffset.UtcNow, "message");

            log.Events.Single()
            .Should()
            .BeEquivalentTo(
                expectedLogEvent,
                o => o.Excluding(x => x.Timestamp));
        }
        public void Log_InIgnoredScope_LogsWithoutScope()
        {
            loggerProvider = new VostokLoggerProvider(
                log,
                new VostokLoggerProviderSettings
            {
                IgnoredScopes = new HashSet <string>
                {
                    typeof(HashSet <int>).FullName
                }
            });

            var logger = loggerProvider.CreateLogger(null);

            using (var scope1 = logger.BeginScope(new HashSet <int>()))
                using (var scope2 = logger.BeginScope(new HashSet <string>()))
                {
                    scope1.Should().BeOfType <EmptyDisposable>();
                    scope2.Should().NotBeOfType <EmptyDisposable>();

                    logger.LogInformation("message");
                }

            var expectedLogEvent = new VostokLogEvent(LogLevel.Info, DateTimeOffset.UtcNow, "message")
                                   .WithProperty("operationContext", new OperationContextValue(new[] { "System.Collections.Generic.HashSet`1[System.String]" }));

            log.Events.Single()
            .Should()
            .BeEquivalentTo(
                expectedLogEvent,
                o => o.Excluding(x => x.Timestamp));
        }
        public void IsEnabledFor_ReturnsValidResult(LogLevel minLevel, MsLogLevel level, bool expectedEnabled)
        {
            loggerProvider = new VostokLoggerProvider(log.WithMinimumLevel(minLevel));

            var logger = loggerProvider.CreateLogger(null);

            logger.IsEnabled(level).Should().Be(expectedEnabled);
        }
Esempio n. 4
0
        public SqlDbContext CreateDbContext(string[] args)
        {
            var container            = new Container(new ContainerConfiguration(AssembliesLoader.Load(), nameof(TestSqlDatabaseContextFactory), ContainerMode.UseShortLog));
            var vostokLoggerProvider = new VostokLoggerProvider(new ConsoleLog());

            container.Configurator.ForAbstraction <ILoggerFactory>().UseInstances(new LoggerFactory(new[] { vostokLoggerProvider }));
            var sqlDbContextSettings = new TestSqlDbContextSettings(WithTestSqlStorage.DbName, WithTestSqlStorage.TestSqlEntitiesRegistry, WithTestSqlStorage.MigrationsAssembly);

            container.Configurator.ForAbstraction <ISqlDbContextSettings>().UseInstances(sqlDbContextSettings);
            return(container.Get <SqlDbContext>());
        }
        public void IsEnabledFor_ReturnsValidResult(MsLogLevel minLevel, LogLevel level, bool expectedEnabled)
        {
            var provider            = new VostokLoggerProvider(oracleLog);
            var loggerFilterOptions = new LoggerFilterOptions {
                MinLevel = minLevel
            };
            var loggerFactory = new LoggerFactory(new[] { provider }, loggerFilterOptions);

            var microsoftLogger1 = loggerFactory.CreateLogger <MicrosoftLog_BasedOnPureLogger_Tests>();

            var microsoftLog1 = new MicrosoftLog(microsoftLogger1);

            microsoftLog1.IsEnabledFor(level).Should().Be(expectedEnabled);
        }
        public void Log_WithEventIdWithNAMEOnly_LogsValidEvent()
        {
            loggerProvider = new VostokLoggerProvider(log, new VostokLoggerProviderSettings {
                AddEventIdProperties = true
            });

            loggerProvider.CreateLogger(null).LogCritical(new EventId(0, "eventId"), "message");

            var expectedLogEvent = new VostokLogEvent(LogLevel.Fatal, DateTimeOffset.Now, "message")
                                   .WithProperty("EventId.Name", "eventId");

            log.Events.Single()
            .Should()
            .BeEquivalentTo(
                expectedLogEvent,
                o => o.Excluding(x => x.Timestamp));
        }
 public void TestSetup()
 {
     log            = new MemoryLog();
     loggerProvider = new VostokLoggerProvider(log);
 }