protected override void Load(ContainerBuilder builder)
{
var loggerConfig = new LoggerConfiguration();
loggerConfig.SystemInstrumentationKey = SystemKey;
loggerConfig.BusinessInstrumentationKey = BusinessKey;
loggerConfig.Level = LogLevel;
LoggerFilterOptions filterOptions = new LoggerFilterOptions();
filterOptions.AddFilter("", loggerConfig.LogLevel);
var config = TelemetryConfiguration.CreateDefault();
config.InstrumentationKey = loggerConfig.BusinessInstrumentationKey;
IOptions <TelemetryConfiguration> telemeryOptions = Options.Create(config);
IOptions <ApplicationInsightsLoggerOptions> configureApplicationInsightsLoggerOptions = Options.Create(
new ApplicationInsightsLoggerOptions());
ILoggerFactory loggerFactory =
new LoggerFactory(
new[]
{
new ApplicationInsightsLoggerProvider(telemeryOptions,
configureApplicationInsightsLoggerOptions)
}, filterOptions);
ILogger logger = loggerFactory.CreateLogger("Global_Logger");
builder.RegisterInstance(loggerConfig);
builder.RegisterInstance <ILogger>(logger);
builder.RegisterInstance(loggerFactory)
.As <ILoggerFactory>();
}
internal static LoggerFilterOptions CreateFilterOptions(LoggerFilterOptions registeredOptions)
{
// We want our own copy of the rules, excluding the 'allow-all' rule that we added for this provider.
LoggerFilterOptions customFilterOptions = new LoggerFilterOptions
{
MinLevel = registeredOptions.MinLevel
};
ApplicationInsightsLoggerFilterRule allowAllRule = registeredOptions.Rules.OfType <ApplicationInsightsLoggerFilterRule>().Single();
// Copy all existing rules
foreach (LoggerFilterRule rule in registeredOptions.Rules)
{
if (rule != allowAllRule)
{
customFilterOptions.Rules.Add(rule);
}
}
// Copy 'hidden' rules
foreach (LoggerFilterRule rule in allowAllRule.ChildRules)
{
customFilterOptions.Rules.Add(rule);
}
return(customFilterOptions);
}
public void Processor_MissingCategory_FiltersAsDefault(LogLevel telemetryLevel, bool isEnabled)
{
var filter = new LoggerFilterOptions
{
MinLevel = LogLevel.Information
};
var processor = new FilteringTelemetryProcessor(filter, _nextTelemetryProcessorMock.Object);
var telemetry = new TestTelemetry();
telemetry.Properties[LogConstants.LogLevelKey] = telemetryLevel.ToString();
// no category specified
processor.Process(telemetry);
if (isEnabled)
{
_nextTelemetryProcessorMock.Verify(m => m.Process(telemetry), Times.Once);
}
else
{
_nextTelemetryProcessorMock.Verify(m => m.Process(It.IsAny <ITelemetry>()), Times.Never);
}
}
public void Logging_DefaultsToInformation()
{
IHost host = new HostBuilder()
.ConfigureDefaultTestWebScriptHost()
.Build();
LoggerFilterOptions filterOptions = host.Services.GetService <IOptions <LoggerFilterOptions> >().Value;
Assert.Equal(LogLevel.None, filterOptions.MinLevel);
var rules = filterOptions.Rules.ToArray();
Assert.Equal(3, rules.Length);
var rule = rules[0];
Assert.Null(rule.ProviderName);
Assert.Null(rule.CategoryName);
Assert.Null(rule.LogLevel);
Assert.NotNull(rule.Filter); // The broad "allowed category" filter.
rule = rules[1];
Assert.Equal(typeof(SystemLoggerProvider).FullName, rule.ProviderName);
Assert.Null(rule.CategoryName);
Assert.Equal(LogLevel.None, rule.LogLevel);
Assert.Null(rule.Filter);
rule = rules[2];
Assert.Equal(typeof(SystemLoggerProvider).FullName, rule.ProviderName);
Assert.Null(rule.CategoryName);
Assert.Null(rule.LogLevel);
Assert.NotNull(rule.Filter); // The system-specific "allowed category" filter
}
public void Processor_UsesFilter(LogLevel defaultLevel, LogLevel categoryLevel, LogLevel telemetryLevel, bool isEnabled)
{
var filter = new LoggerFilterOptions
{
MinLevel = defaultLevel
};
filter.AddFilter(LogCategories.Results, categoryLevel);
var processor = new FilteringTelemetryProcessor(filter, _nextTelemetryProcessorMock.Object);
var telemetry = new TestTelemetry();
telemetry.Properties[LogConstants.CategoryNameKey] = LogCategories.Results;
telemetry.Properties[LogConstants.LogLevelKey] = telemetryLevel.ToString();
processor.Process(telemetry);
if (isEnabled)
{
_nextTelemetryProcessorMock.Verify(m => m.Process(telemetry), Times.Once);
}
else
{
_nextTelemetryProcessorMock.Verify(m => m.Process(It.IsAny <ITelemetry>()), Times.Never);
}
}
private static LoggerFilterOptions CreateFilters()
{
var filters = new LoggerFilterOptions();
filters.AddFilter(nameof(MySqlRemindersTableTests), LogLevel.Trace);
return(filters);
}
private static LoggerFilterOptions CreateFilters()
{
var filters = new LoggerFilterOptions();
filters.AddFilter(typeof(PostgreSqlMembershipTableTests).Name, LogLevel.Trace);
return(filters);
}
public ColoredConsoleLogger(string category, LoggingFilterHelper loggingFilterHelper, LoggerFilterOptions loggerFilterOptions)
{
_category = category;
_loggerFilterOptions = loggerFilterOptions ?? throw new ArgumentNullException(nameof(loggerFilterOptions));
_loggingFilterHelper = loggingFilterHelper ?? throw new ArgumentNullException(nameof(loggingFilterHelper));
_verboseErrors = StaticSettings.IsDebug;
}
internal LoggerFilterRule SelectRule(string categoryName, LoggerFilterOptions loggerFilterOptions)
{
RuleSelector.Select(loggerFilterOptions, ProviderType, categoryName,
out LogLevel? minLevel, out Func <string, string, LogLevel, bool> filter);
return(new LoggerFilterRule(ProviderType.FullName, categoryName, minLevel, filter));
}
public async Task Factory_LogsFrameworkOptions()
{
IOptionsLoggingSource source = new OptionsLoggingSource();
IOptionsFactory <LoggerFilterOptions> factory = new WebJobsOptionsFactory <LoggerFilterOptions>(
Enumerable.Empty <IConfigureOptions <LoggerFilterOptions> >(),
Enumerable.Empty <IPostConfigureOptions <LoggerFilterOptions> >(),
source,
new LoggerFilterOptionsFormatter());
LoggerFilterOptions options = factory.Create(null);
source.LogStream.Complete();
IList <string> logs = new List <string>();
ISourceBlock <string> logStream = source.LogStream;
while (await logStream.OutputAvailableAsync(CancellationToken.None))
{
logs.Add(await logStream.ReceiveAsync());
}
string log = logs.Single();
string expected =
"LoggerFilterOptions" + Environment.NewLine +
"{" + Environment.NewLine +
" \"MinLevel\": \"Trace\"," + Environment.NewLine +
" \"Rules\": []" + Environment.NewLine +
"}";
Assert.Equal(expected, log);
}
private static LoggerFilterOptions CreateFilters()
{
var filters = new LoggerFilterOptions();
filters.AddFilter("RedisMembershipTable", LogLevel.Trace);
return(filters);
}
public ScheduleLogger(ScheduleLoggerProvider loggerProvider, string categoryName, LoggerFilterOptions filterOptions)
{
_loggerProvider = loggerProvider;
_categoryName = categoryName;
_filterOptions = filterOptions;
_logScope = new ScheduleLogScope();
}
/// <summary>
/// Create the default logger factory, which would configure logger factory with a <see cref="FileLoggerProvider"/> that writes logs to <paramref name="filePath"/> and console.
/// by default;
/// </summary>
/// <param name="filePath">the logger file path</param>
/// <param name="filters">log filters you want to configure your logging with</param>
/// <returns></returns>
public static ILoggerFactory CreateDefaultLoggerFactory(string filePath, LoggerFilterOptions filters)
{
var factory = new LoggerFactory(new List <ILoggerProvider>(), filters);
factory.AddProvider(new FileLoggerProvider(filePath));
return(factory);
}
public void Logging_Filters()
{
// Ensure that the logging path is configured for filter configuration binding in .NET Core.
// All of the filtering details are handled by the built-in logging infrastructure, so here we
// simply want to make sure that we're populating the LoggerFilterOptions from our config.
IHost host = new HostBuilder()
.ConfigureAppConfiguration(c =>
{
c.AddInMemoryCollection(new Dictionary <string, string>
{
{ ConfigurationPath.Combine(_loggingPath, "LogLevel", "Default"), "Error" },
{ ConfigurationPath.Combine(_loggingPath, "LogLevel", "Some.Custom.Category"), "Trace" },
{ ConfigurationPath.Combine(_loggingPath, "Console", "LogLevel", "Default"), "Trace" }
});
})
.ConfigureDefaultTestWebScriptHost()
.Build();
LoggerFilterOptions filterOptions = host.Services.GetService <IOptions <LoggerFilterOptions> >().Value;
Assert.Equal(3, filterOptions.Rules.Count);
Assert.Equal(LogLevel.Trace, filterOptions.Rules[0].LogLevel);
Assert.Equal("Console", filterOptions.Rules[0].ProviderName);
Assert.Equal(LogLevel.Trace, filterOptions.Rules[1].LogLevel);
Assert.Null(filterOptions.Rules[1].ProviderName);
Assert.Equal("Some.Custom.Category", filterOptions.Rules[1].CategoryName);
Assert.Equal(LogLevel.Error, filterOptions.Rules[2].LogLevel);
Assert.Null(filterOptions.Rules[2].ProviderName);
}
private static LoggerFilterOptions CreateFilters()
{
var filters = new LoggerFilterOptions();
filters.AddFilter("AzureTableDataManager", LogLevel.Trace);
filters.AddFilter("OrleansSiloInstanceManager", LogLevel.Trace);
filters.AddFilter("Storage", LogLevel.Trace);
return filters;
}
private static LoggerFilterOptions CreateFilters()
{
var filters = new LoggerFilterOptions();
filters.AddFilter("ConsulBasedMembershipTable", Microsoft.Extensions.Logging.LogLevel.Trace);
filters.AddFilter("Storage", Microsoft.Extensions.Logging.LogLevel.Trace);
return(filters);
}
private static LoggerFilterOptions CreateFilters()
{
var filters = new LoggerFilterOptions();
//filters.AddFilter(typeof(OrleansSiloInstanceManager).FullName, LogLevel.Trace);
//filters.AddFilter("Orleans.Storage", LogLevel.Trace);
return(filters);
}
public void Logging_Filters()
{
// Ensure that the logging path is configured for filter configuration binding in .NET Core.
// All of the filtering details are handled by the built-in logging infrastructure, so here we
// simply want to make sure that we're populating the LoggerFilterOptions from our config.
var hostBuilder = new HostBuilder()
.ConfigureAppConfiguration(c =>
{
c.AddInMemoryCollection(new Dictionary <string, string>
{
{ ConfigurationPath.Combine(_loggingPath, "LogLevel", "Default"), "Error" },
{ ConfigurationPath.Combine(_loggingPath, "LogLevel", "Some.Custom.Category"), "Trace" },
{ ConfigurationPath.Combine(_loggingPath, "Console", "LogLevel", "Default"), "Trace" }
});
})
.ConfigureDefaultTestWebScriptHost();
using (IHost host = hostBuilder.Build())
{
LoggerFilterOptions filterOptions = host.Services.GetService <IOptions <LoggerFilterOptions> >().Value;
Assert.Equal(6, filterOptions.Rules.Count);
var rules = filterOptions.Rules.ToArray();
var rule = rules[0];
Assert.Null(rule.ProviderName);
Assert.Null(rule.CategoryName);
Assert.Null(rule.LogLevel);
Assert.NotNull(rule.Filter); // The broad "allowed category" filter.
rule = rules[1];
Assert.Equal(LogLevel.Trace, rule.LogLevel);
Assert.Equal("Console", rule.ProviderName);
rule = rules[2];
Assert.Equal(LogLevel.Trace, rule.LogLevel);
Assert.Null(rule.ProviderName);
Assert.Equal("Some.Custom.Category", rule.CategoryName);
rule = rules[3];
Assert.Equal(LogLevel.Error, rule.LogLevel);
Assert.Null(rule.ProviderName);
rule = rules[4];
Assert.Equal(typeof(SystemLoggerProvider).FullName, rule.ProviderName);
Assert.Null(rule.CategoryName);
Assert.Equal(LogLevel.None, rule.LogLevel);
Assert.Null(rule.Filter);
rule = rules[5];
Assert.Equal(typeof(SystemLoggerProvider).FullName, rule.ProviderName);
Assert.Null(rule.CategoryName);
Assert.Null(rule.LogLevel);
Assert.NotNull(rule.Filter); // The system-specific "allowed category" filter
}
}
public IServiceProvider ConfigureServices(IServiceCollection services)
{
// 注册数据库上下文
if (!string.IsNullOrWhiteSpace(_configurationRoot.GetConnectionString(IEManageSystemConsts.ConnectionStringName)))
{
services.AddAbpDbContext <IEManageSystemDbContext>(options =>
{
DbContextOptionsConfigurer.Configure(
options.DbContextOptions,
_configurationRoot.GetConnectionString(IEManageSystemConsts.ConnectionStringName),
_configurationRoot.GetSection("ConnectionType").Value);
if (_env.IsDevelopment())
{
LoggerFilterOptions loggerFilterOptions = new LoggerFilterOptions();
loggerFilterOptions.AddFilter((level) => level >= LogLevel.Information);
// 日志过滤器
options.DbContextOptions.UseLoggerFactory(new LoggerFactory(new[] { new DebugLoggerProvider() }, loggerFilterOptions));
}
});
}
services.AddControllersWithViews(options =>
{
// .net core 自动将移除 Async 后缀，如方法 LoginAsync 的路由为 /Controller/Login
// 设为发 false 则不会移除
options.SuppressAsyncSuffixInActionNames = false;
options.Conventions.Insert(0, new IEApiConvention());
}).AddNewtonsoftJson(options => {
options.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore;
});
// 添加单页
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/build";
});
// 添加IEJwtBearer认证
services.AddIEJwtBearer(
WebConfiguration.Issuer,
WebConfiguration.Audience,
WebConfiguration.SymmetricKey);
// 添加IE授权
services.AddIEAuthorization();
// Configure Abp and Dependency Injection
return(services.AddAbp <IEManageSystemWebModule>(options =>
{
// Configure Log4Net logging
options.IocManager.IocContainer.AddFacility <LoggingFacility>(
f => f.UseAbpLog4Net().WithConfig("log4net.config")
);
}));
}
private static LoggerFilterOptions CreateFilters()
{
var filters = new LoggerFilterOptions();
filters.AddFilter(typeof(Orleans.Clustering.AzureStorage.AzureTableDataManager <>).FullName, LogLevel.Trace);
filters.AddFilter(typeof(OrleansSiloInstanceManager).FullName, LogLevel.Trace);
filters.AddFilter("Orleans.Storage", LogLevel.Trace);
return(filters);
}
private static LoggerFilterOptions CreateFilters()
{
var filters = new LoggerFilterOptions();
filters.AddFilter("DynamoDBDataManager", LogLevel.Trace);
filters.AddFilter("OrleansSiloInstanceManager", LogLevel.Trace);
filters.AddFilter("Storage", LogLevel.Trace);
return(filters);
}
private static LoggerFactory CreateLoggerFactory()
{
var loggerFilterOptions = new LoggerFilterOptions();
loggerFilterOptions.MinLevel = LogLevel.Information;
var loggerFactory = new LoggerFactory(new[] { new DebugLoggerProvider(), }, loggerFilterOptions);
loggerFactory.AddProvider(new MyLogProvider());
return(loggerFactory);
}
internal static ILoggerFactory InitSchedulerLogging()
{
var filters = new LoggerFilterOptions();
filters.AddFilter("Scheduler", LogLevel.Trace);
filters.AddFilter("Scheduler.WorkerPoolThread", LogLevel.Trace);
var loggerFactory = TestingUtils.CreateDefaultLoggerFactory(TestingUtils.CreateTraceFileName("Silo", DateTime.Now.ToString("yyyyMMdd_hhmmss")), filters);
return(loggerFactory);
}
public static LoggerFilterOptions CreateLoggerFilterOptions()
{
// TODO: Whitelist should be configurable
// Whitelist our log categories to remove large amounts of ASP.NET logs.
var filterOptions = new LoggerFilterOptions();
filterOptions.AddFilter((category, level) => category.StartsWith($"{ScriptConstants.LogCategoryHost}.") || category.StartsWith($"{ScriptConstants.LogCategoryFunction}.") || category.StartsWith($"{ScriptConstants.LogCategoryWorker}."));
return(filterOptions);
}
// Helper to pull out the calculated rule
private static LoggerFilterRule SelectAppInsightsRule(LoggerFilterOptions options, string category)
{
var providerType = typeof(ApplicationInsightsLoggerProvider);
var ruleSelector = new LoggerRuleSelector();
ruleSelector.Select(options, providerType, category, out LogLevel? minLevel, out Func <string, string, LogLevel, bool> filter);
return(new LoggerFilterRule(providerType.FullName, category, minLevel, filter));
}
public EndToEndTestBase()
{
var filterOptions = new LoggerFilterOptions
{
MinLevel = LogLevel.Trace
};
_loggerFactory = new LoggerFactory(new[] { new TestLoggerProvider() }, filterOptions);
//_loggerFactory.AddProvider();
_logger = _loggerFactory.CreateLogger("EndToEndTests");
}
public void Processor_No_ISupportProperties_DoesNotFilter()
{
var filter = new LoggerFilterOptions();
var processor = new FilteringTelemetryProcessor(filter, _nextTelemetryProcessorMock.Object);
var telemetry = new Mock <ITelemetry>(MockBehavior.Strict);
processor.Process(telemetry.Object);
_nextTelemetryProcessorMock.Verify(m => m.Process(telemetry.Object), Times.Once);
}
/// <summary>
/// Create the default logger factory, which would create <see cref="Microsoft.Extensions.Logging.ILogger"/>> that writes logs to <paramref name="filePath"/> and console.
/// This is to restore legacy default behavior of LogManager, which configure LogManager with a FileTelemetryConsumer and ConsoleTelemetryConsumer
/// by default;
/// </summary>
/// <param name="filePath">the logger file path</param>
/// <param name="filters">log filters you want to configure your logging with</param>
/// <returns></returns>
public static ILoggerFactory CreateDefaultLoggerFactory(string filePath, LoggerFilterOptions filters)
{
var factory = new LoggerFactory(new List <ILoggerProvider>(), filters);
factory.AddProvider(new FileLoggerProvider(filePath));
if (ConsoleText.IsConsoleAvailable)
{
factory.AddConsole();
}
return(factory);
}
public void Logging_DefaultsToInformation()
{
IHost host = new HostBuilder()
.ConfigureDefaultTestWebScriptHost()
.Build();
LoggerFilterOptions filterOptions = host.Services.GetService <IOptions <LoggerFilterOptions> >().Value;
Assert.Equal(LogLevel.Information, filterOptions.MinLevel);
Assert.Empty(filterOptions.Rules);
}
protected void RegisterLogging()
{
var loggerOptions = new LoggerFilterOptions {
MinLevel = LogLevel.Debug
};
var loggerFactory = new LoggerFactory(GetLogProviders(), loggerOptions);
Log.SetLoggerFactory(loggerFactory);
_container.RegisterInstance <ILoggerFactory>(loggerFactory);
_container.Register(typeof(ILogger <>), typeof(GenericLogger <>), Lifestyle.Singleton);
}
