/// <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. }