/// <inheritdoc/>
protected override void ConfigureWebHost(IWebHostBuilder builder)
{
// Specify the startup command line options
var commandLineOpts = new StartupOptions
{
NoWebClient = true,
NoAutoRunWebApp = true
};
// Use a temporary directory for the application paths
var webHostPathRoot = Path.Combine(_testPathRoot, "test-host-" + Path.GetFileNameWithoutExtension(Path.GetRandomFileName()));
Directory.CreateDirectory(Path.Combine(webHostPathRoot, "logs"));
Directory.CreateDirectory(Path.Combine(webHostPathRoot, "config"));
Directory.CreateDirectory(Path.Combine(webHostPathRoot, "cache"));
Directory.CreateDirectory(Path.Combine(webHostPathRoot, "jellyfin-web"));
var appPaths = new ServerApplicationPaths(
webHostPathRoot,
Path.Combine(webHostPathRoot, "logs"),
Path.Combine(webHostPathRoot, "config"),
Path.Combine(webHostPathRoot, "cache"),
Path.Combine(webHostPathRoot, "jellyfin-web"));
// Create the logging config file
// TODO: We shouldn't need to do this since we are only logging to console
Program.InitLoggingConfigFile(appPaths).GetAwaiter().GetResult();
// Create a copy of the application configuration to use for startup
var startupConfig = Program.CreateAppConfiguration(commandLineOpts, appPaths);
ILoggerFactory loggerFactory = new SerilogLoggerFactory();
var serviceCollection = new ServiceCollection();
_disposableComponents.Add(loggerFactory);
// Create the app host and initialize it
var appHost = new CoreAppHost(
appPaths,
loggerFactory,
commandLineOpts,
new ManagedFileSystem(loggerFactory.CreateLogger <ManagedFileSystem>(), appPaths),
new NetworkManager(loggerFactory.CreateLogger <NetworkManager>()),
serviceCollection);
_disposableComponents.Add(appHost);
appHost.Init();
// Configure the web host builder
Program.ConfigureWebHostBuilder(builder, appHost, serviceCollection, commandLineOpts, startupConfig, appPaths);
}
private static void ConfigureLogging(HttpConfiguration httpConfig, IConfiguration appConfiguration)
{
var logFolder = HostingEnvironment.MapPath("/Logs");
var apiLoggerFactory = new SerilogLoggerFactory(new LoggerConfiguration()
.Enrich.With <UtcTimeLogEventEnricher>()
.Enrich.WithHttpRequestType()
.Enrich.WithHttpRequestClientHostIP()
.Enrich.WithHttpRequestClientHostName()
.Enrich.WithHttpRequestRawUrl()
.Enrich.WithWebApiControllerName()
.Enrich.WithWebApiActionName()
.WriteTo.Async(a =>
a.File(Path.Combine(logFolder, $"app-errors.log"),
rollingInterval: RollingInterval.Day,
outputTemplate: "{UtcTime}|{HttpRequestType}|{HttpRequestRawUrl}|{WebApiController}|{WebApiAction}|{HttpRequestClientHostIP}|{HttpRequestClientHostName}|{Message:lj}{NewLine}{Exception}",
shared: true))
.CreateLogger(), true);
var logger = apiLoggerFactory.CreateLogger("app-errors");
if (appConfiguration.GetValue("Logging:LogRequests", false))
{
httpConfig.MessageHandlers.Add(new RequestLoggerCSV(logFolder,
logRequests: true,
logResponses: true,
logContent: appConfiguration.GetValue("Logging:LogContent", false)));
}
httpConfig.Services.Replace(typeof(IExceptionLogger),
new DefaultExceptionLogger(GetExceptionLoggerAuditEventRepository(logFolder), logger));
}
private void SetupSerilog()
{
var loggingPath = Path.Combine(WorkingDirectory, "logging.yaml");
if (!File.Exists(loggingPath))
{
// First run, logging.yaml doesn't exist yet. We can not wait for auto-copy as it would be too late.
using var stream = typeof(AsyncHelper).Assembly.GetManifestResourceStream("OpenMod.Core.logging.yaml");
using var reader = new StreamReader(stream ?? throw new MissingManifestResourceException("Couldn't find resource: OpenMod.Core.logging.yaml"));
var fileContent = reader.ReadToEnd();
File.WriteAllText(loggingPath, fileContent);
}
var configuration = new ConfigurationBuilder()
.SetBasePath(WorkingDirectory)
.AddYamlFile("logging.yaml")
.AddEnvironmentVariables()
.Build();
var loggerConfiguration = new LoggerConfiguration()
.ReadFrom.Configuration(configuration);
var serilogLogger = Log.Logger = loggerConfiguration.CreateLogger();
m_LoggerFactory = new SerilogLoggerFactory(serilogLogger);
m_Logger = m_LoggerFactory.CreateLogger <Runtime>();
}
public TypedLoggingComponent(Serilog.ILogger logger)
{
using (var logfactory = new SerilogLoggerFactory(logger))
{
_logger = logfactory.CreateLogger(typeof(T).FullName);
}
}
public SerilogTypedLogger(Serilog.ILogger logger)
{
using (var logfactory = new SerilogLoggerFactory(logger))
{
this.logger = logfactory.CreateLogger(typeof(T).FullName);
}
}
public ILogger CreateLogger(string categoryName)
{
LogEventLevel eventLevel = _serilogOptions.MinimumLevel.Default;
foreach (var overrideOption in _serilogOptions.MinimumLevel.Override)
{
if (categoryName.StartsWith(overrideOption.Key))
{
eventLevel = overrideOption.Value;
}
}
// Chain new loggers to the global loggers with its own switch
// taking into accound any "Overrides"
var levelSwitch = new LoggingLevelSwitch(eventLevel);
_loggerSwitches.GetOrAdd(categoryName, levelSwitch);
var serilogger = new Serilog.LoggerConfiguration()
.MinimumLevel.ControlledBy(levelSwitch)
.WriteTo.Logger(_globalLogger)
.CreateLogger();
var factory = new SerilogLoggerFactory(serilogger, true);
return(_loggers.GetOrAdd(categoryName, factory.CreateLogger(categoryName)));
}
public static async Task Main(string[] args)
{
Log.Logger = SerilogLoggerFactory.CreateLogger();
try
{
Log.Information($"Starting ratesApi. Environment: '{EnvironmentHelpers.GetEnvironmentName()}'");
var host = CreateHostBuilder(args).Build();
using (var scope = host.Services.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService <RatesDataContext>();
await context.Database.MigrateAsync();
}
await host.RunAsync();
}
catch (Exception exc)
{
Log.Fatal(exc, "Error during ratesApi startup.");
throw;
}
finally
{
Log.CloseAndFlush();
}
}
public void LoggerMessage_IsCorrect(string name, Action <Microsoft.Extensions.Logging.ILogger> logAction, string method, string expectedResult)
{
global::Serilog.ILogger newLogger = new LoggerConfiguration()
.MinimumLevel.Verbose()
.WriteTo.InMemory()
.CreateLogger();
Log.Logger = newLogger;
ILoggerFactory loggerFactory = new SerilogLoggerFactory();
Microsoft.Extensions.Logging.ILogger logger = loggerFactory.CreateLogger("test");
logger.Here(logAction);
var result = InMemorySink.Instance.LogEvents.First().RenderMessage();
TestContext.WriteLine($"Method: {method} Template: {InMemorySink.Instance.LogEvents.First().MessageTemplate} Render: {InMemorySink.Instance.LogEvents.First().RenderMessage()}");
var templateFile = Path.Combine(TestContext.CurrentContext.TestDirectory, "templates.txt");
File.AppendAllLines(templateFile, new string[]
{
$"<tr><td>{method}</td><td>{InMemorySink.Instance.LogEvents.First().RenderMessage()}</td></tr>"
});
newLogger = null;
Log.CloseAndFlush();
InMemorySink.Instance.Dispose();
Assert.AreEqual(expectedResult, result);
}
public static IServiceCollection AddCustomizedLogging(this IServiceCollection sc)
{
var sp = sc.BuildServiceProvider();
var httpAccessor = sp.GetRequiredService <IHttpContextAccessor>();
var correlationAccessor = sp.GetRequiredService <ICorrelationContextAccessor>();
var configuration = sp.GetRequiredService <IOptions <EnvironmentConfiguration> >();
var logLevelStr = configuration.Value.LOG_LEVEL;
var logLevel = Enum.TryParse(logLevelStr, out LogEventLevel level) ? level : LogEventLevel.Information;
var formatter = new JsonLogFormatter();
var conf = new LoggerConfiguration()
.Enrich.FromLogContext()
.Enrich.With(new HttpEnricher(httpAccessor, correlationAccessor))
.MinimumLevel.ControlledBy(new LoggingLevelSwitch(logLevel))
.MinimumLevel.Override("CorrelationId", LogEventLevel.Error);
conf.WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level:u3}] {Message:lj}{NewLine}{Exception}");
// Add additional sinks (Azure, logentries, etc) here
var serilog = conf.CreateLogger();
Microsoft.Extensions.Logging.ILoggerFactory msLoggerFactory = new SerilogLoggerFactory(serilog);
msLoggerFactory.AddProvider(new SerilogLoggerProvider(serilog));
sc.AddSingleton <ILogger>(serilog);
sc.AddSingleton(msLoggerFactory).AddSingleton(msLoggerFactory.CreateLogger("PROJECT_NAME"));
return(sc);
}
/// <summary>
/// Create a logger and bind it to <see cref="ILogger"/> interface in a provided service collection.
/// </summary>
/// <param name="services">A service collection to bind logger.</param>
/// <param name="esConnectionString">A connection string to Elastic Search instance.</param>
/// <returns>A modified version of service collection.</returns>
public static IServiceCollection AddStructuredLogging(this IServiceCollection services, string esConnectionString)
{
var loggerFactory = new SerilogLoggerFactory(esConnectionString);
var logger = loggerFactory.CreateLogger();
services.AddSingleton(logger);
return(services);
}
private static ILogger CreateLogger()
{
var logger = new LoggerConfiguration()
.WriteTo.Console()
.CreateLogger();
var loggerFactory = new SerilogLoggerFactory(logger);
return(loggerFactory.CreateLogger <Program>());
}
/// <summary>
/// Create a logger and assign it to global static <see cref="Log.Logger"/> -
/// this logger is used in contexts where DI container is not accessible: e.g. on application startup.
/// </summary>
/// <param name="esConnectionString">A connection string to Elastic Search instance.</param>
/// <returns>An globally registered instance of a logger.</returns>
public static ILogger CreateGlobalLogger(string esConnectionString)
{
if (Log.Logger == null)
{
var loggerFactory = new SerilogLoggerFactory(esConnectionString);
Log.Logger = loggerFactory.CreateLogger();
}
return(Log.Logger);
}
private static ILogger CreateLogger(ILogEventSink sink, Func <LoggerConfiguration, LoggerConfiguration> configureLoggerConfiguration = null)
{
LoggerConfiguration config = new LoggerConfiguration().WriteTo.Sink(sink);
config = configureLoggerConfiguration?.Invoke(config) ?? config;
Logger logger = config.CreateLogger();
var factory = new SerilogLoggerFactory(logger);
return(factory.CreateLogger <ApplicationInsightsTelemetryConverterTests>());
}
/// <summary>
/// Adds a console logger. Can be omitted if internal SIPSorcery debug and warning messages are not required.
/// </summary>
private static Microsoft.Extensions.Logging.ILogger AddConsoleLogger()
{
var serilogLogger = new LoggerConfiguration()
.Enrich.FromLogContext()
.MinimumLevel.Is(Serilog.Events.LogEventLevel.Debug)
.WriteTo.Console()
.CreateLogger();
var factory = new SerilogLoggerFactory(serilogLogger);
SIPSorcery.LogFactory.Set(factory);
return factory.CreateLogger<Program>();
}
public static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.Enrich.With(new SimpleClassEnricher())
.Enrich.FromLogContext()
// en dit met die :
.WriteTo.Console(outputTemplate: "{Timestamp:HH:mm:ss} [{Level:u3}] {MyCustom} {RequestPath} {Message}{Exception} @ {SourceContext:20}{NewLine}") //[{SourceContext}{Properties:j}]
//wasdit
.WriteTo.Logger(lc => lc
// .Filter.ByIncludingOnly(Matching.FromSource("LoggingWeb.Data"))
.WriteTo.File("data-log.txt"))
.CreateLogger();
using (LogContext.PushProperty("MyCustom", "jemoeder"))
{
Log.Information("Whutever");
}
// Task<byte[]> readAsync = ReadAsync(new FileInfo(@"C:\Users\Niels\Downloads\adwcleaner_8.0.5.exe"));
// readAsync.Wait();
SerilogLoggerFactory factory = new SerilogLoggerFactory(Log.Logger);
ILoggerFactory fck = factory;
ILogger <Program> nother = fck.CreateLogger <Program>();
ILogger <Program> logger = factory.CreateLogger <Program>();
logger.LogInformation("Zo kan het dus ook");
try
{
IHostBuilder hostBuilder = Host.CreateDefaultBuilder(args);
hostBuilder.ConfigureWebHostDefaults(webHostBuilder =>
{
webHostBuilder.UseStartup <Startup>()
.UseSerilog();
});
var host = hostBuilder.Build();
host.Run();
}
catch (Exception ex)
{
Log.Fatal(ex, "Host terminated unexpectedly");
}
finally
{
Log.CloseAndFlush();
}
}
/// <summary>
/// Adds a console logger. Can be omitted if internal SIPSorcery debug and warning messages are not required.
/// </summary>
private static void AddConsoleLogger()
{
var logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.MinimumLevel.Is(Serilog.Events.LogEventLevel.Debug)
.WriteTo.Console()
.CreateLogger();
var factory = new SerilogLoggerFactory(logger);
SIPSorcery.LogFactory.Set(factory);
Log = factory.CreateLogger <Program>();
}
public UnitTest1(ITestOutputHelper testOutputHelper)
{
var logConfig = new LoggerConfiguration()
.WriteTo.TestOutput(testOutputHelper, LogEventLevel.Verbose)
.MinimumLevel.Verbose();
Log.Logger = logConfig.CreateLogger();
ILoggerFactory loggerFactory = new SerilogLoggerFactory(Log.Logger);
_logger = loggerFactory.CreateLogger <UnitTest1>();
_testSettingsDataStore = new SharpSettingsMongoDataStore <TestSettings>(Col, _logger);
}
public async Task Setup()
{
await Task.Yield();
var loggerConfig = new LoggerConfiguration()
.MinimumLevel.Verbose()
.WriteTo.LiterateConsole(LogEventLevel.Verbose);
var logger = loggerConfig.CreateLogger();
ILoggerFactory factory = new SerilogLoggerFactory(logger);
_logger = factory.CreateLogger(GetType());
_col = new List <LockBase>();
}
private static void Startup(string[] args)
{
DbStartup.Reporter = Reporter;
Configuration = ConfigurationExtensions.Configuration(args);
Log.Logger = new LoggerConfiguration()
.ReadFrom
.Configuration(Configuration)
.CreateLogger();
var loggerFactory = new SerilogLoggerFactory(Log.Logger);
_dbContext = DbStartup.InitDbAsync(args, loggerFactory).Result;
_mapper = AutoMapperFactory.Create();
var pgnRepository = new PgnRepository(_dbContext, loggerFactory.CreateLogger <PgnRepository>());
_svc = new PgnImportService(pgnRepository, _mapper, loggerFactory.CreateLogger <PgnImportService>());
_svc.Status += ShowStatus;
}
static void Main(string[] args)
{
var seriLogger = new LoggerConfiguration()
.Enrich.FromLogContext()
.MinimumLevel.Is(Serilog.Events.LogEventLevel.Debug)
.WriteTo.Console(theme: AnsiConsoleTheme.Code)
.CreateLogger();
var factory = new SerilogLoggerFactory(seriLogger);
SIPSorcery.LogFactory.Set(factory);
logger = factory.CreateLogger <Program>();
var result = Parser.Default.ParseArguments <Options>(args)
.WithParsed <Options>(opts => RunCommand(opts).Wait());
}
private void Awake()
{
var seriLogger = new LoggerConfiguration()
.MinimumLevel.Is(LevelConvert.ToSerilogLevel(LogLevel.Debug))
.Destructure.With <UnityObjectDestructuringPolicy>()
.Enrich.FromLogContext()
.Enrich.WithProperty(Constant.CATEGORY_NAME, "Project")
.Enrich.WithProperty(Constant.UNITY_OBJECT_PROPERTY, "Unknown")
.WriteTo.Unity3D(outputTemplate: "[{Level:u3}] {SourceContext}: {Message:lj}")
.CreateLogger()
;
var loggerFactory = new SerilogLoggerFactory(seriLogger);
_logger = loggerFactory.CreateLogger(this);
}
public ILogger CreateLogger(string categoryName)
{
var eventLevel = GetLevel(categoryName);
var levelSwitch = new LoggingLevelSwitch(eventLevel);
_loggerSwitches.GetOrAdd(categoryName, levelSwitch);
var serilogger = new Serilog.LoggerConfiguration()
.MinimumLevel.ControlledBy(levelSwitch)
.WriteTo.Logger(_globalLogger)
.CreateLogger();
var factory = new SerilogLoggerFactory(serilogger, true);
return(_loggers.GetOrAdd(categoryName, factory.CreateLogger(categoryName)));
}
public static Microsoft.Extensions.Logging.ILogger UseSerilogToDebugWithSerilogLoggerFactory()
{
ILoggerFactory loggerFactory = new SerilogLoggerFactory().AddSerilog();
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Verbose()
.WriteTo.Debug
(
outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss.fff} [{Level}] {Message}{NewLine}{Exception}"
)
.CreateLogger();
Microsoft.Extensions.Logging.ILogger logger = loggerFactory.CreateLogger(nameof(PurchaseOrder));
return(logger);
}
public async Task Setup()
{
var loggerConfig = new LoggerConfiguration()
.MinimumLevel.Verbose()
.WriteTo.LiterateConsole(LogEventLevel.Verbose);
var logger = loggerConfig.CreateLogger();
ILoggerFactory factory = new SerilogLoggerFactory(logger);
_logger = factory.CreateLogger(GetType());
var client = new MongoClient();
var db = client.GetDatabase("Test");
_col = db.GetCollection <LockBase>($"lockables.{GetType()}");
await _col.DeleteManyAsync(Builders <LockBase> .Filter.Empty);
}
public static void RegisterLogging(IMutableDependencyResolver services, IReadonlyDependencyResolver resolver)
{
services.RegisterLazySingleton(() =>
{
var config = resolver.GetRequiredService <LoggingConfiguration>();
var logFilePath = GetLogFileName(config, resolver);
var logger = new LoggerConfiguration()
.MinimumLevel.Override("Default", config.DefaultLogLevel)
.MinimumLevel.Override("Microsoft", config.MicrosoftLogLevel)
.WriteTo.Console()
.WriteTo.RollingFile(logFilePath, fileSizeLimitBytes: config.LimitBytes)
.CreateLogger();
var factory = new SerilogLoggerFactory(logger);
return(factory.CreateLogger("Default"));
});
}
public static Microsoft.Extensions.Logging.ILogger Configure(string name)
{
var version = Assembly.GetExecutingAssembly().GetName().Version.ToString();
var outputTemplate = $"{{SourceContext}}: [{{Timestamp:{ShortTimeFormatString}}} {{Level:u3}}] [{{ThreadId}}] {{Message:lj}}{{NewLine}}{{Exception}}";
var config = new LoggerConfiguration()
.MinimumLevel.Debug()
.Enrich.FromLogContext()
.Enrich.WithThreadId()
.WriteTo.Console(LogEventLevel.Verbose, outputTemplate)
.WriteTo.Debug(LogEventLevel.Debug, outputTemplate)
;
Log.Logger = config.CreateLogger().ForContext("SourceContext", name);
Log.Logger.Information("{AppName} v{Version}", name, version);
using var loggerFactory = new SerilogLoggerFactory().AddSerilog();
return(loggerFactory.CreateLogger(name));
}
public async Task Setup()
{
var factory = new SerilogLoggerFactory();
var log = factory.CreateLogger <MicroceliumLoggingDelegatingHandlerTests>();
using (var tracingHandler = new MicroceliumLoggingDelegatingHandler(Endpoint.CreateHandler(), log))
using (var httpClient = new HttpClient(tracingHandler)
{
BaseAddress = new Uri("http://localhost")
})
{
httpClient.DefaultRequestHeaders.Add("X-MICROCELIUM-REQUEST", $"{nameof(RequestIsWrittenToTraceListener)}");
using (var response = await httpClient.GetAsync("?ignore=1"))
{
content = await response.Content.ReadAsStringAsync();
}
}
}
public static void AddCertificate(this IIdentityServerBuilder builder, IHostEnvironment environment, IConfiguration configuration, ILogger logger = null)
{
if (logger == null)
{
var factory = new SerilogLoggerFactory(Serilog.Log.Logger);
logger = factory.CreateLogger(typeof(IdentityServerExtentions));
}
if (environment.IsDevelopment())
{
logger.LogInformation("IDS: AddDeveloperSigningCredential");
builder.AddDeveloperSigningCredential(true);
}
else
{
// http://amilspage.com/signing-certificates-idsv4/
AddCertificateFromStore(builder, configuration, logger);
}
}
static async Task Main(string[] args)
{
Log.Logger = SerilogLoggerFactory.CreateLogger();
try
{
Log.Information($"Starting bot. Environment: '{EnvironmentHelpers.GetEnvironmentName()}'");
await CreateHostBuilder(args).Build().RunAsync();
}
catch (Exception exc)
{
Log.Fatal(exc, "Error during bot startup.");
throw;
}
finally
{
Log.CloseAndFlush();
}
}
public QuickStartApp()
{
// 1, Configuration loading
// With Portos eKasa, windows application called "Portos eKasa servis" is shipped.
// With portos ekasa servis, you can change all necessary settings.
// The settings are saved in JSON file.
// The goal is to use exactly same JSON configuration file that is edited by servis application.
// Please make sure that you have installed servis application and configured serial port and other necessary things.
// Lets load configuration from JSON file.
ClientConfiguration configuration = this.LoadClientConfiguration();
// 2, Logging
// Client class accepts ILoggerFactory instance.
// Thanks to this abstract approach, you can use your favorite logging library.
// In this example, we are using Serilong, with following nuget packages:
// - Serilog.Extensions.Logging
// - Serilog.Sinks.Console
Serilog.ILogger serilogLogger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.Console()
.CreateLogger();
// create universal Microsoft.Extensions.Logging.ILoggerFactory instance
ILoggerFactory loggerFactory = new SerilogLoggerFactory(serilogLogger);
// we can test the logger:
loggerFactory.CreateLogger(nameof(QuickStartApp)).LogDebug("Hello from QuickStartApp!");
// 3, Client instantiation
// Now, lets instantiate the entry point to whole solution - instance of Client class.
this.client = new Client(configuration, loggerFactory);
// The instantiation of library is now completed.
// Your application should keep only one instance of client.
}
