public static void Main(string[] args)
{
// You can register this instance (i.e. ISerilogConfiguration) with DI
// and, for example, control the logging level via GUI or Web API
var loggingConfig = new SerilogConfiguration();
var config = new ConfigurationBuilder()
// Adding JsonFile to provide defaults.
// Limitation: Serilog creates "a watcher" for keys that are present when building the logger.
// For example: if there is no configuration for "MinimumLevel:Override:Thinktecture" when CreateLogger() is called
// then you won't be able to change the log level for this category.
.AddJsonFile("appsettings.json", false, true)
// The following line is the only one that's new.
// The path to the logging config is "My:Serilog" in this example
.AddLoggingConfiguration(loggingConfig, "My", "Serilog")
.Build();
var loggerConfiguration = new LoggerConfiguration()
.ReadFrom.Configuration(config, "My:Serilog")
.WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {SourceContext}: {Message:lj}{NewLine}{Exception}");
var logger = loggerConfiguration.CreateLogger().ForContext <Program>();
while (true)
{
GenerateLogs(logger, loggingConfig);
Print("Press ENTER to generate logs again.");
Console.ReadLine();
}
}
public static async Task Main(string[] args)
{
Log.Logger = SerilogConfiguration.Setup();
try
{
Log.Information("Starting Amplifier web host");
var webHost = CreateHostBuilder(args).Build();
/*
* using (var scope = webHost.Services.CreateScope())
* {
* var service = scope.ServiceProvider.GetRequiredService<YourService>();
* }
*/
await webHost.RunAsync();
}
catch (Exception ex)
{
Log.Fatal(ex, "Host terminated unexpectedly");
}
finally
{
Log.CloseAndFlush();
}
}
public static int Main(string[] args)
{
try
{
// setup logger
var versionInfo = Assembly.GetEntryAssembly().GetApplicationVersionInfo();
Log.Logger = SerilogConfiguration.ConfigureDefault(loggerConfig => loggerConfig
.Enrich.WithProperty("AppName", versionInfo.Name)
.Enrich.WithProperty("Semver", versionInfo.SemanticVersion)
#if DEBUG
.WriteTo.SeqWithUrl(
Environment.GetEnvironmentVariable("LOG_SEQ_URL"),
Environment.GetEnvironmentVariable("LOG_SEQ_APIKEY")) // "9mjWXUIYPanPokRLE4B6"
#endif // DEBUG
).CreateLogger();
CreateHostBuilder(args).Build().Run();
return(0);
}
catch (Exception ex)
{
Log.Fatal(ex, "Host terminated unexpectedly");
return(1);
}
finally
{
Log.CloseAndFlush();
}
}
public void ConfigureServices(IServiceCollection services)
{
var serilogSettings = Configuration.GetSection("SerilogSettings").Get <SerilogSettings>();
SerilogConfiguration.Configure(serilogSettings);
var ravenConfig = Configuration.GetSection("RavenDbSettings").Get <RavenDbSettings>();
services.AddSingleton(RavenDbConfiguration.Configure(ravenConfig));
var filesConfig = Configuration.GetSection("FileSettings").Get <FilesSettings>();
services.AddSingleton(filesConfig);
services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
.AddCookie(options => {
options.Events.OnRedirectToLogin = (context) =>
{
context.Response.StatusCode = 401;
return(Task.CompletedTask);
};
});
services.AddMvc();
}
protected static SerilogConfiguration CreateConfig(out ISerilogConfigurationProviderCollection collection)
{
var config = new SerilogConfiguration();
collection = config;
return(config);
}
public static void Run()
{
Log.Logger = new LoggerConfiguration()
.Enrich.With <MachineNameEnricher>()
.Enrich.With(new SensitiveInformationEnricher())
.Destructure.AsSensitive <Email>()
.Destructure.AsSensitive <BankAccount>(stringify: false)
.Destructure.AsSensitiveByTransforming <PhoneNumber>(pn => pn.CountryPrefix + pn.Localnumber)
.WriteTo.Sink(SerilogConfiguration.CreateAzureEventHubBatchingSink())
.CreateLogger();
var logger = Log.Logger.MarkAsReviewedRegardingSensitiveInformation();
var engagement = new
{
Merchant = "Merchant name",
Email = new Email("*****@*****.**"),
PhoneNumber = new PhoneNumber("+46", "0123456789"),
BankAccount = new BankAccount("number", BankAccountType.SwedishBankAccount)
};
logger.ForContext("Engagement", engagement, destructureObjects: true)
.Information("AsSensitiveExample");
Log.CloseAndFlush();
}
public static void SetupSerilog(
this IServiceCollection services,
string domain,
string application,
LoggerSettings settings,
IEnumerable <string> ignoredRoutes)
{
var loggerBuilder = new LoggerBuilder();
Log.Logger = loggerBuilder
.UseSuggestedSetting(domain, application)
.SetupSeq(settings?.SeqOptions)
.SetupSplunk(settings?.SplunkOptions)
.BuildLogger();
if (settings?.DebugEnabled ?? false)
{
loggerBuilder.EnableDebug();
}
var config = new SerilogConfiguration
{
InformationTitle = settings?.TitlePrefix + CommunicationLogger.DefaultInformationTitle,
ErrorTitle = settings?.TitlePrefix + CommunicationLogger.DefaultErrorTitle,
Blacklist = settings?.JsonBlacklist,
RequestKeyProperty = RequestKeyServiceExtension.RequestKeyHeaderName,
AccountIdProperty = AccountIdServiceExtension.AccountIdHeaderName,
TimeElapsedProperty = TimeElapsedServiceExtension.TimeElapsedHeaderName,
IgnoredRoutes = ignoredRoutes
};
services.SetupSerilog(config);
}
public Startup(IConfiguration configuration, IWebHostEnvironment environment)
{
Configuration = configuration;
LoggingLevels = configuration.GetLoggingLevels();
_environment = environment;
Log.Logger = SerilogConfiguration.CreateSerilogLogger("RestApi", LoggingLevels);
}
public void LoggingBuilderCannotBeNull()
{
Action method = () => SerilogConfiguration.Configure(fakeHostingEnvironment, fakeConfiguration, null, A.Dummy <string>());
method.Should()
.Throw <ArgumentNullException>()
.WithMessage(ExceptionsUtility.NullArgument("logging"));
}
public void ApplicationNameCannotBeEmpty(string applicationName)
{
Action method = () => SerilogConfiguration.Configure(fakeHostingEnvironment, fakeConfiguration, fakeLoggingBuilder, applicationName);
method.Should()
.Throw <ArgumentException>()
.WithMessage("applicationName cannot be empty.");
}
public void LoggingBuilderCannotBeNull()
{
Action method = () => SerilogConfiguration.Configure(fakeHostingEnvironment, fakeConfiguration, null, A.Dummy <string>());
method.Should()
.Throw <ArgumentNullException>()
.WithMessage($"Value cannot be null.{Environment.NewLine}Parameter name: logging");
}
public static void AddConfiguration(this IServiceCollection service, IConfiguration configuration)
{
RepositoriesDI.Register(service);
ServicesDI.Register(service);
SwaggerConfiguration.RegisterSwagger(service);
SerilogConfiguration.CreateLogger();
service.AddBindConfiguration(configuration);
}
public static void Run()
{
// Serilog
SerilogConfiguration.CreateLogger();
// Configure Autofac
AutofacWebapiConfig.Initialize(GlobalConfiguration.Configuration);
// Configure AutoMapper
AutoMapperConfiguration.Configure();
}
public static void CreateSerilogLogger()
{
if (IsUseNLog)
{
throw new InvalidOperationException("Duplicated EasyWeb.Core Logger - Now use nlog");
}
SerilogConfiguration.Initialize(GetEnvironment());
IsUseSerilog = true;
}
private static void GetSerilog(this IServiceCollection services)
{
Enum.TryParse <LogEventLevel>(GetEnvironmentVariable("Serilog_MinimumLevel"), out LogEventLevel logEventLevel);
var serilogConfiguration = new SerilogConfiguration
{
ConnectionString = GetEnvironmentVariable("SQLConnectionString"),
MinimumLevel = logEventLevel,
TableName = GetEnvironmentVariable("Serilog_TableName")
};
services.AddSingleton(typeof(IPearUpLogger), new PearupSqlLogger(serilogConfiguration));
}
public static void SetupSerilog(
this IServiceCollection services,
string domain,
string application,
LoggerSettings settings,
List <string> ignoredRoutes)
{
var loggerBuilder = new LoggerBuilder();
if (settings?.NewRelicOptions?.Enabled == true && string.IsNullOrWhiteSpace(settings?.NewRelicOptions?.LicenseKey))
{
settings.NewRelicOptions.LicenseKey = Environment.GetEnvironmentVariable("NEW_RELIC_LICENSE_KEY");
}
Log.Logger = loggerBuilder
.UseSuggestedSetting(domain, application)
.SetupSeq(settings?.SeqOptions)
.SetupSplunk(settings?.SplunkOptions)
.SetupNewRelic(settings?.NewRelicOptions)
.SetupDataDog(settings?.DataDogOptions)
.BuildLogger();
if (settings?.DebugEnabled ?? false)
{
loggerBuilder.EnableDebug();
}
var config = new SerilogConfiguration
{
Version = Api.ApiSettings.BuildVersion,
InformationTitle = settings?.TitlePrefix + CommunicationLogger.DefaultInformationTitle,
ErrorTitle = settings?.TitlePrefix + CommunicationLogger.DefaultErrorTitle,
BlacklistRequest = settings?.GetJsonBlacklistRequest(),
BlacklistResponse = settings?.JsonBlacklistResponse,
HeaderBlacklist = settings?.HeaderBlacklist,
QueryStringBlacklist = settings?.QueryStringBlacklist,
RequestKeyProperty = RequestKeyServiceExtension.RequestKeyHeaderName,
AccountIdProperty = AccountIdServiceExtension.AccountIdHeaderName,
TimeElapsedProperty = TimeElapsedServiceExtension.TimeElapsedHeaderName,
IgnoredRoutes = ignoredRoutes
};
StaticSimpleLogger.UpdateVersion(Api.ApiSettings.BuildVersion);
StaticSimpleLogger.UpdateEnvironment(EnvironmentUtility.GetCurrentEnvironment());
services.SetupSerilog(config);
services.AddScoped <ISimpleLogger, SimpleLogger>();
}
public void ConfigureServices(IServiceCollection services)
{
var serilogSettings = Configuration.GetSection("SerilogSettings").Get <SerilogSettings>();
SerilogConfiguration.Configure(serilogSettings);
var ravenConfig = Configuration.GetSection("RavenDbSettings").Get <RavenDbSettings>();
services.AddSingleton(RavenDbConfiguration.Configure(ravenConfig));
var highScoreSettings = Configuration.GetSection("HighScoreSettings").Get <HighScoreSettings>();
services.AddSingleton(highScoreSettings);
services.AddMvc();
}
public SyslogBackgroundService(ILogger logger, IClock clock, SerilogConfiguration serilogConfiguration)
{
_syslogLogger = new LoggerConfiguration()
.WriteTo.Seq(serilogConfiguration.SeqUrl)
.Enrich.WithProperty("Application", App.Name)
.MinimumLevel.Information()
.CreateLogger();
_logger = logger;
_clock = clock;
_handler = message => _syslogLogger.Information("{HostName} {Facility} {Message} {Severity} {RemoteIP}",
message.Hostname,
message.Facility,
message.Content,
message.Severity,
message.RemoteIP);
}
public static void Main(string[] args)
{
Log.Logger = SerilogConfiguration.LoggerConfig();
try
{
Log.Information(CommonConstants.HostStart);
CreateHostBuilder(args).Build().Run();
}
catch (Exception ex)
{
Log.Fatal(ex, CommonConstants.HostTerminate);
}
finally
{
Log.CloseAndFlush();
}
}
public static IHostBuilder CreateWebHostBuilder(string[] args)
{
return(Host.CreateDefaultBuilder(args)
.ConfigureAppConfiguration((ctx, config) =>
{
var isDevEnv = ctx.HostingEnvironment.IsDevelopment();
if (isDevEnv)
{
config.AddJsonFile("appsettings.dev.json", optional: false, reloadOnChange: true);
}
if (!isDevEnv)
{
var builtConfig = config.Build();
var azureServiceTokenProvider = new AzureServiceTokenProvider();
var keyVaultClient = new KeyVaultClient(
new KeyVaultClient.AuthenticationCallback(
azureServiceTokenProvider.KeyVaultTokenCallback));
config.AddAzureKeyVault(
$"https://{builtConfig["KeyVaultName"]}.vault.azure.net/",
keyVaultClient,
new DefaultKeyVaultSecretManager());
}
})
.UseSerilog((ctx, config) =>
{
if (!ctx.HostingEnvironment.IsDevelopment())
{
var teleConfig = TelemetryConfiguration.CreateDefault();
teleConfig.InstrumentationKey = ctx.Configuration.GetValue <string>("APPINSIGHTS_INSTRUMENTATIONKEY");
config.WriteTo.ApplicationInsights(teleConfig, TelemetryConverter.Events);
}
SerilogConfiguration.CreateDefaultLogger(ctx, config);
})
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup <Startup>();
}));
}
public static void Run()
{
Log.Logger = new LoggerConfiguration()
.Enrich.With <MachineNameEnricher>()
.Enrich.FromLogContext()
.Enrich.WithProperty("SensitiveEnricherProperty", "sensitive enricher property value")
.Enrich.With(new SensitiveInformationEnricher("B1", "B2", "SensitiveEnricherProperty"))
.WriteTo.Sink(SerilogConfiguration.CreateAzureEventHubBatchingSink())
.CreateLogger();
var logger = Log.Logger.MarkAsReviewedRegardingSensitiveInformation();
using (LogContext.PushProperty("B1", "blacklisted"))
logger.ForContext("B2", "blacklisted")
.Information("BlacklistExample");
Log.CloseAndFlush();
}
public static void Main(string[] args)
{
var baseConfig = GetLogConfig();
Log.Logger = SerilogConfiguration.CreateSerilogLogger(baseConfig, AppName);
try
{
Log.Information("Æô¶¯{ApplicationContext}...", AppName);
CreateHostBuilder(args).Build().Run();
}
catch (Exception ex)
{
Log.Fatal(ex, "{ApplicationContext} ³öÏÖ´íÎó:{messsage} !", AppName, ex.Message);
}
finally
{
Log.CloseAndFlush();
}
}
public static void Main(string[] args)
{
var configuration = SerilogConfiguration.GetConfiguration();
Log.Logger = SerilogConfiguration.CreateLogger(configuration);
try
{
Log.Information("Starting web host");
CreateHostBuilder(args).Build().Run();
}
catch (Exception ex)
{
Log.Fatal(ex, "Host terminated unexpectedly");
}
finally
{
Log.CloseAndFlush();
}
}
public static void Main(string[] args)
{
var baseConfig = GetLogConfig();
Log.Logger = SerilogConfiguration.CreateSerilogLogger(baseConfig, AppName);
try
{
Log.Information("准备启动{ApplicationContext}...", AppName);
var host = BuildWebHost(args);
Log.Information("{ApplicationContext} 已启动", AppName);
host.Run();
}
catch (Exception ex)
{
Log.Fatal(ex, "{ApplicationContext} 出现错误:{messsage} !", AppName, ex.Message);
}
finally
{
Log.CloseAndFlush();
}
}
public static void Run()
{
Log.Logger = new LoggerConfiguration()
.Enrich.With <MachineNameEnricher>()
.Enrich.With(new SensitiveInformationEnricher())
.Destructure.HasSensitiveProperties <BankAccount>(b => b.AccountNumber)
.WriteTo.Sink(SerilogConfiguration.CreateAzureEventHubBatchingSink())
.CreateLogger();
var logger = Log.Logger.MarkAsReviewedRegardingSensitiveInformation();
var engagement = new
{
Merchant = "Merchant name",
BankAccount = new BankAccount("number", BankAccountType.SwedishBankAccount)
};
logger.ForContext("Engagement", engagement, destructureObjects: true)
.Information("HasSensitivePropertiesExample");
Log.CloseAndFlush();
}
public static void Run()
{
Log.Logger = new LoggerConfiguration()
.Enrich.With <MachineNameEnricher>()
.Enrich.FromLogContext()
.Enrich.With(new SensitiveInformationEnricher())
.WriteTo.Sink(SerilogConfiguration.CreateAzureEventHubBatchingSink())
.CreateLogger();
var logger = Log.Logger.MarkAsReviewedRegardingSensitiveInformation();
logger.ForContext("RegularProp", "regular value")
.WithSensitiveInformation("SensitiveProp", "sensitive value")
.Information("WithSensitiveInformation");
using (SensitiveLogContext.PushProperty("SensitiveProp", "sensitive value"))
using (LogContext.PushProperty("RegularProp", "regular value"))
logger.Information("SensitiveLogContext");
Log.CloseAndFlush();
}
/// <summary>
/// Run application.
/// </summary>
/// <param name="args">Application arguments.</param>
public static void Main(string[] args)
{
Log.Logger = SerilogConfiguration.LoggerConfig();
try
{
Log.Information(InitializationConstants.WebHostStarting);
var host = CreateHostBuilder(args).Build();
InitialServicesScopeFactory.Build(host);
host.Run();
}
catch (Exception ex)
{
Log.Fatal(ex, InitializationConstants.WebHostTerminated);
}
finally
{
Log.CloseAndFlush();
}
}
static void Main(string[] args)
{
Configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
.Build();
var connectionString = Configuration.GetConnectionString("DefaultConnection");
var logLevel = Configuration.GetValue <string>("Logging:LogLevel") ?? "Information";
var onlySymbolsString = Configuration.GetValue <string>("CrawlOptions:OnlySymbols");
var onlySymbols = new List <string>();
if (!string.IsNullOrWhiteSpace(onlySymbolsString))
{
onlySymbols = onlySymbolsString.Split(',').ToList();
}
var excludeSymbolsString = Configuration.GetValue <string>("CrawlOptions:ExcludeSymbols");
var excludeSymbols = new List <string>();
if (!string.IsNullOrWhiteSpace(excludeSymbolsString))
{
excludeSymbols = excludeSymbolsString.Split(',').ToList();
}
var startSymbol = Configuration.GetValue <string>("CrawlOptions:StartSymbol");
Log.Logger = new LoggerConfiguration()
.MinimumLevel.ControlledBy(SerilogConfiguration.LoggingLevel)
.Enrich.WithMachineName()
.Enrich.WithEnvironmentUserName()
.Enrich.WithProperty("Source", "FinaScope BinanceCrawler 0.1")
.WriteTo.Console()
.WriteTo.PostgreSQL(connectionString, "logs", ColumnConfiguration.GetColumnConfiguration(), needAutoCreateTable: true)
.CreateLogger();
SerilogConfiguration.SetLoggingLevel(logLevel);
Log.Logger.Debug("Running with the following crawl configuration. StartSymbol: {StartSymbol}. OnlySymbols: '{OnlySymbols}'. ExcludeSymbols: '{ExcludeSymbols}'", startSymbol, onlySymbolsString, excludeSymbolsString);
try
{
ServiceProvider = new ServiceCollection()
.AddBinance()
.AddOptions()
.Configure <BinanceApiOptions>(Configuration.GetSection("ApiOptions"))
.AddLogging(builder => builder.AddSerilog(Log.Logger))
.BuildServiceProvider();
var api = ServiceProvider.GetService <IBinanceApi>();
var candlestickRepository = new CandlestickRepository(connectionString);
var binanceDataFacade = new BinanceDataFacade(api, candlestickRepository, onlySymbols, excludeSymbols, startSymbol);
var symbols = binanceDataFacade.InitializeSymbols().Result;
var stopwatch = new Stopwatch();
stopwatch.Start();
var symbolCount = 1;
var totalSymbols = symbols.Count();
foreach (var symbol in symbols)
{
try
{
Log.Logger.ForContext("Action", "CrawlSymbol")
.Information("Begin crawling symbol {Symbol}", symbol.SymbolLabel);
binanceDataFacade.CrawlSymbol(symbol).Wait();
}
catch (Exception e)
{
Log.Logger.ForContext("Action", "CrawlSymbol")
.Error(e, "Error crawling symbol {Symbol}", symbol.SymbolLabel);
}
Log.Logger.ForContext("Action", "CrawlSymbol")
.Information("Finished crawling symbol {Symbol}. Total elapsed time: {ElapsedTimeTotal}. Symbol {SymbolCount} of {TotalSymbols}", symbol.SymbolLabel, stopwatch.Elapsed, symbolCount++, totalSymbols);
}
Log.Logger.ForContext("Action", "CrawlSymbol")
.Information("Finished crawling all symbols. Total elapsed time: {ElapsedTimeTotal}", stopwatch.Elapsed);
}
catch (Exception e)
{
Log.Logger.Fatal(e, "Uncaught exceptions. Program aborting.");
}
if (Environment.UserInteractive)
{
Console.Write("Press any key to quit: ");
Console.ReadKey();
}
}
static void Main(string[] args)
{
SettingsLoaderIni settingsLoader = new SettingsLoaderIni(args);
var settings = settingsLoader.Load();
string correlationId = Guid.NewGuid().ToString();
Log.Logger = SerilogConfiguration.Create("XboxFtpUpload", settings, correlationId).CreateLogger();
Log.Information("Starting XBox FTP Upload");
SerilogProgressNotifier serilogNotifier = new SerilogProgressNotifier(Log.Logger);
TerminalGuiAdapter adapter = new TerminalGuiAdapter();
adapter.Initialize();
TerminalGuiProgressNotifier terminalGuiProgressNotifier = adapter.CreateNotifier();
IProgressNotifier notifier = new ChainedProgressNotifier(new List <IProgressNotifier>()
{
terminalGuiProgressNotifier, serilogNotifier
});
try
{
IXboxGameRepositoryFactory xboxGameRepositoryFactory = null;
if (settings.TestMode)
{
xboxGameRepositoryFactory = UseInMemoryAdapter();
}
else
{
FtpXboxSettings xboxFtpsettings = new FtpXboxSettings()
{
Host = settings.Host,
Password = settings.Password,
User = settings.User,
Port = settings.Port,
GameRootDirectory = settings.GameRootDirectory
};
xboxGameRepositoryFactory = UseFtpAdapter(xboxFtpsettings);
}
UploadArchivesUseCase useCase = new UploadArchivesUseCase(xboxGameRepositoryFactory, notifier, new ZipFileProcessor());
List <string> gamesToUpload = new List <string>();
if (!string.IsNullOrWhiteSpace(settings.GameToUpload))
{
Log.Warning("Found single games for upload specified");
gamesToUpload.Add(settings.GameToUpload);
}
else if (!string.IsNullOrWhiteSpace(settings.GamesToUploadFile))
{
if (!File.Exists(settings.GamesToUploadFile))
{
Log.Warning("File specified in GameToUploadFile does not exist");
adapter.Shutdown();
Environment.Exit(-1);
}
gamesToUpload = File.ReadAllLines(settings.GamesToUploadFile).Select(x => RemoveSurroundingQuotes(x))
.ToList();
}
else if (settings.GamesToUpload == null || settings.GamesToUpload.Count == 0)
{
Log.Warning("Found no games configured to upload");
adapter.Shutdown();
Environment.Exit(0);
}
else
{
gamesToUpload = settings.GamesToUpload;
}
useCase.Execute(gamesToUpload);
}
catch (Exception ex)
{
Log.Error(ex, "Unhandled exception occured");
adapter.Shutdown();
Environment.Exit(-1);
}
Log.Information("Finished XBox FTP Upload");
adapter.Shutdown();
Environment.Exit(0);
}
public static void ConfigureLogging(IConfiguration configuration) => SerilogConfiguration.ConfigureLogging(configuration);
