public static SerilogLogger CreateWithDefaultConfiguration( Umbraco.Cms.Core.Hosting.IHostingEnvironment hostingEnvironment, ILoggingConfiguration loggingConfiguration, IConfiguration configuration) { return(CreateWithDefaultConfiguration(hostingEnvironment, loggingConfiguration, configuration, out _)); }
/* * HOW TO REPLACE THE MEDIA UNDERLYING FILESYSTEM * ---------------------------------------------- * * Create an implementation of IFileSystem and register it as the underlying filesystem for * MediaFileSystem with the following extension on composition. * * builder.SetMediaFileSystem(factory => FactoryMethodToReturnYourImplementation()) * * WHAT IS SHADOWING * ----------------- * * Shadowing is the technology used for Deploy to implement some sort of * transaction-management on top of filesystems. The plumbing explained above, * compared to creating your own physical filesystem, ensures that your filesystem * would participate into such transactions. * */ internal static IUmbracoBuilder AddFileSystems(this IUmbracoBuilder builder) { // register FileSystems, which manages all filesystems builder.Services.AddSingleton <FileSystems>(); // register the scheme for media paths builder.Services.AddUnique <IMediaPathScheme, UniqueMediaPathScheme>(); builder.Services.AddUnique <IViewHelper, ViewHelper>(); builder.Services.AddUnique <IDefaultViewContentProvider, DefaultViewContentProvider>(); builder.SetMediaFileSystem(factory => { IIOHelper ioHelper = factory.GetRequiredService <IIOHelper>(); IHostingEnvironment hostingEnvironment = factory.GetRequiredService <IHostingEnvironment>(); ILogger <PhysicalFileSystem> logger = factory.GetRequiredService <ILogger <PhysicalFileSystem> >(); GlobalSettings globalSettings = factory.GetRequiredService <IOptions <GlobalSettings> >().Value; var rootPath = Path.IsPathRooted(globalSettings.UmbracoMediaPhysicalRootPath) ? globalSettings.UmbracoMediaPhysicalRootPath : hostingEnvironment.MapPathWebRoot(globalSettings.UmbracoMediaPhysicalRootPath); var rootUrl = hostingEnvironment.ToAbsolute(globalSettings.UmbracoMediaPath); return(new PhysicalFileSystem(ioHelper, hostingEnvironment, logger, rootPath, rootUrl)); }); return(builder); }
public MacroRenderer( IProfilingLogger profilingLogger, ILogger <MacroRenderer> logger, IUmbracoContextAccessor umbracoContextAccessor, IOptionsMonitor <ContentSettings> contentSettings, ILocalizedTextService textService, AppCaches appCaches, IMacroService macroService, IHostingEnvironment hostingEnvironment, ICookieManager cookieManager, ISessionManager sessionManager, IRequestAccessor requestAccessor, PartialViewMacroEngine partialViewMacroEngine, IHttpContextAccessor httpContextAccessor) : this( profilingLogger, logger, umbracoContextAccessor, contentSettings, textService, appCaches, macroService, cookieManager, sessionManager, requestAccessor, partialViewMacroEngine, httpContextAccessor, StaticServiceProvider.Instance.GetRequiredService <IWebHostEnvironment>()) { }
public static LoggerConfiguration MinimalConfiguration( this LoggerConfiguration logConfig, Umbraco.Cms.Core.Hosting.IHostingEnvironment hostingEnvironment, ILoggingConfiguration loggingConfiguration, IConfiguration configuration) { return(MinimalConfiguration(logConfig, hostingEnvironment, loggingConfiguration, configuration, out _)); }
public static TypeLoader AddTypeLoader( this IServiceCollection services, Assembly entryAssembly, IHostingEnvironment hostingEnvironment, ILoggerFactory loggerFactory, AppCaches appCaches, IConfiguration configuration, IProfiler profiler) => services.AddTypeLoader(entryAssembly, loggerFactory, configuration);
public IconService( IOptionsMonitor <GlobalSettings> globalSettings, IHostingEnvironment hostingEnvironment, AppCaches appCaches) : this(globalSettings, hostingEnvironment, appCaches, StaticServiceProvider.Instance.GetRequiredService <IWebHostEnvironment>()) { }
public void Is_Client_Side_Request(string url, bool assert) { IHostingEnvironment hostingEnvironment = CreateHostingEnvironment(); var umbracoRequestPaths = new UmbracoRequestPaths(Options.Create(_globalSettings), hostingEnvironment); var uri = new Uri("http://test.com" + url); var result = umbracoRequestPaths.IsClientSideRequest(uri.AbsolutePath); Assert.AreEqual(assert, result); }
public void Is_Client_Side_Request_InvalidPath_ReturnFalse() { IHostingEnvironment hostingEnvironment = CreateHostingEnvironment(); var umbracoRequestPaths = new UmbracoRequestPaths(Options.Create(_globalSettings), hostingEnvironment); // This URL is invalid. Default to false when the extension cannot be determined var uri = new Uri("http://test.com/installing-modules+foobar+\"yipee\""); var result = umbracoRequestPaths.IsClientSideRequest(uri.AbsolutePath); Assert.AreEqual(false, result); }
public static SerilogLogger CreateWithDefaultConfiguration( Umbraco.Cms.Core.Hosting.IHostingEnvironment hostingEnvironment, ILoggingConfiguration loggingConfiguration, IConfiguration configuration, out UmbracoFileConfiguration umbracoFileConfig) { var serilogConfig = new LoggerConfiguration() .MinimalConfiguration(hostingEnvironment, loggingConfiguration, configuration, out umbracoFileConfig) .ReadFrom.Configuration(configuration); return(new SerilogLogger(serilogConfig)); }
public IconService( IOptionsMonitor <GlobalSettings> globalSettings, IHostingEnvironment hostingEnvironment, AppCaches appCaches, IWebHostEnvironment webHostEnvironment) { _globalSettings = globalSettings.CurrentValue; _hostingEnvironment = hostingEnvironment; _webHostEnvironment = webHostEnvironment; _cache = appCaches.RuntimeCache; globalSettings.OnChange(x => _globalSettings = x); }
/// <summary> /// Called to create the <see cref="TypeLoader"/> to assign to the <see cref="IUmbracoBuilder"/> /// </summary> /// <param name="services"></param> /// <param name="entryAssembly"></param> /// <param name="hostingEnvironment"></param> /// <param name="loggerFactory"></param> /// <param name="appCaches"></param> /// <param name="configuration"></param> /// <param name="profiler"></param> /// <returns></returns> /// <remarks> /// This should never be called in a web project. It is used internally by Umbraco but could be used in unit tests. /// If called in a web project it will have no affect except to create and return a new TypeLoader but this will not /// be the instance in DI. /// </remarks> public static TypeLoader AddTypeLoader( this IServiceCollection services, Assembly entryAssembly, IHostingEnvironment hostingEnvironment, ILoggerFactory loggerFactory, AppCaches appCaches, IConfiguration configuration, IProfiler profiler) { TypeFinderSettings typeFinderSettings = configuration.GetSection(Cms.Core.Constants.Configuration.ConfigTypeFinder).Get <TypeFinderSettings>() ?? new TypeFinderSettings(); var assemblyProvider = new DefaultUmbracoAssemblyProvider( entryAssembly, loggerFactory, typeFinderSettings.AdditionalEntryAssemblies); RuntimeHashPaths runtimeHashPaths = new RuntimeHashPaths().AddAssemblies(assemblyProvider); var runtimeHash = new RuntimeHash( new ProfilingLogger( loggerFactory.CreateLogger <RuntimeHash>(), profiler), runtimeHashPaths); var typeFinderConfig = new TypeFinderConfig(Options.Create(typeFinderSettings)); var typeFinder = new TypeFinder( loggerFactory.CreateLogger <TypeFinder>(), assemblyProvider, typeFinderConfig ); var typeLoader = new TypeLoader( typeFinder, runtimeHash, appCaches.RuntimeCache, new DirectoryInfo(hostingEnvironment.LocalTempPath), loggerFactory.CreateLogger <TypeLoader>(), profiler ); // This will add it ONCE and not again which is what we want since we don't actually want people to call this method // in the web project. services.TryAddSingleton <ITypeFinder>(typeFinder); services.TryAddSingleton <TypeLoader>(typeLoader); return(typeLoader); }
/// <summary> /// Outputs a .txt format log at /App_Data/Logs/ /// </summary> /// <param name="logConfig">A Serilog LoggerConfiguration</param> /// <param name="loggingConfiguration"></param> /// <param name="minimumLevel">The log level you wish the JSON file to collect - default is Verbose (highest)</param> /// <param name="retainedFileCount">The number of days to keep log files. Default is set to null which means all logs are kept</param> public static LoggerConfiguration OutputDefaultTextFile( this LoggerConfiguration logConfig, Umbraco.Cms.Core.Hosting.IHostingEnvironment hostingEnvironment, LogEventLevel minimumLevel = LogEventLevel.Verbose) { //Main .txt logfile - in similar format to older Log4Net output //Ends with ..txt as Date is inserted before file extension substring logConfig.WriteTo.File(Path.Combine(hostingEnvironment.MapPathContentRoot(Cms.Core.Constants.SystemDirectories.LogFiles), $"UmbracoTraceLog.{Environment.MachineName}..txt"), shared: true, rollingInterval: RollingInterval.Day, restrictedToMinimumLevel: minimumLevel, retainedFileCountLimit: null, //Setting to null means we keep all files - default is 31 days outputTemplate: "{Timestamp:yyyy-MM-dd HH:mm:ss,fff} [P{ProcessId}/D{AppDomainId}/T{ThreadId}] {Log4NetLevel} {SourceContext} - {Message:lj}{NewLine}{Exception}"); return(logConfig); }
/// <summary> /// Outputs a CLEF format JSON log at /App_Data/Logs/ /// </summary> /// <param name="logConfig">A Serilog LoggerConfiguration</param> /// <param name="loggingConfiguration">The logging configuration</param> /// <param name="minimumLevel">The log level you wish the JSON file to collect - default is Verbose (highest)</param> /// <param name="retainedFileCount">The number of days to keep log files. Default is set to null which means all logs are kept</param> public static LoggerConfiguration OutputDefaultJsonFile( this LoggerConfiguration logConfig, Umbraco.Cms.Core.Hosting.IHostingEnvironment hostingEnvironment, ILoggingConfiguration loggingConfiguration, LogEventLevel minimumLevel = LogEventLevel.Verbose, int?retainedFileCount = null) { // .clef format (Compact log event format, that can be imported into local SEQ & will make searching/filtering logs easier) // Ends with ..txt as Date is inserted before file extension substring logConfig.WriteTo.File(new CompactJsonFormatter(), Path.Combine(hostingEnvironment.MapPathContentRoot(Cms.Core.Constants.SystemDirectories.LogFiles), $"UmbracoTraceLog.{Environment.MachineName}..json"), shared: true, rollingInterval: RollingInterval.Day, // Create a new JSON file every day retainedFileCountLimit: retainedFileCount, // Setting to null means we keep all files - default is 31 days restrictedToMinimumLevel: minimumLevel); return(logConfig); }
/// <summary> /// Registers the default required middleware to run Umbraco. /// </summary> public void RegisterDefaultRequiredMiddleware() { UseUmbracoCoreMiddleware(); AppBuilder.UseStatusCodePages(); // Important we handle image manipulations before the static files, otherwise the querystring is just ignored. AppBuilder.UseImageSharp(); // Get media file provider and request path/URL var mediaFileManager = AppBuilder.ApplicationServices.GetRequiredService <MediaFileManager>(); if (mediaFileManager.FileSystem.TryCreateFileProvider(out IFileProvider mediaFileProvider)) { GlobalSettings globalSettings = AppBuilder.ApplicationServices.GetRequiredService <IOptions <GlobalSettings> >().Value; IHostingEnvironment hostingEnvironment = AppBuilder.ApplicationServices.GetService <IHostingEnvironment>(); string mediaRequestPath = hostingEnvironment.ToAbsolute(globalSettings.UmbracoMediaPath); // Configure custom file provider for media IWebHostEnvironment webHostEnvironment = AppBuilder.ApplicationServices.GetService <IWebHostEnvironment>(); webHostEnvironment.WebRootFileProvider = webHostEnvironment.WebRootFileProvider.ConcatComposite(new PrependBasePathFileProvider(mediaRequestPath, mediaFileProvider)); } AppBuilder.UseStaticFiles(); AppBuilder.UseUmbracoPluginsStaticFiles(); // UseRouting adds endpoint routing middleware, this means that middlewares registered after this one // will execute after endpoint routing. The ordering of everything is quite important here, see // https://docs.microsoft.com/en-us/aspnet/core/fundamentals/routing?view=aspnetcore-5.0 // where we need to have UseAuthentication and UseAuthorization proceeding this call but before // endpoints are defined. AppBuilder.UseRouting(); AppBuilder.UseAuthentication(); AppBuilder.UseAuthorization(); // This must come after auth because the culture is based on the auth'd user AppBuilder.UseRequestLocalization(); // Must be called after UseRouting and before UseEndpoints AppBuilder.UseSession(); // DO NOT PUT ANY UseEndpoints declarations here!! Those must all come very last in the pipeline, // endpoints are terminating middleware. All of our endpoints are declared in ext of IUmbracoApplicationBuilder }
public static LoggerConfiguration MinimalConfiguration( this LoggerConfiguration logConfig, Umbraco.Cms.Core.Hosting.IHostingEnvironment hostingEnvironment, ILoggingConfiguration loggingConfiguration, IConfiguration configuration, out UmbracoFileConfiguration umbFileConfiguration) { global::Serilog.Debugging.SelfLog.Enable(msg => System.Diagnostics.Debug.WriteLine(msg)); //Set this environment variable - so that it can be used in external config file //add key="serilog:write-to:RollingFile.pathFormat" value="%BASEDIR%\logs\log.txt" /> Environment.SetEnvironmentVariable("BASEDIR", hostingEnvironment.MapPathContentRoot("/").TrimEnd(Path.DirectorySeparatorChar), EnvironmentVariableTarget.Process); Environment.SetEnvironmentVariable("UMBLOGDIR", loggingConfiguration.LogDirectory, EnvironmentVariableTarget.Process); Environment.SetEnvironmentVariable("MACHINENAME", Environment.MachineName, EnvironmentVariableTarget.Process); logConfig.MinimumLevel.Verbose() //Set to highest level of logging (as any sinks may want to restrict it to Errors only) .Enrich.WithProcessId() .Enrich.WithProcessName() .Enrich.WithThreadId() .Enrich.WithProperty("ApplicationId", hostingEnvironment.ApplicationId) // Updated later by ApplicationIdEnricher .Enrich.WithProperty("MachineName", Environment.MachineName) .Enrich.With <Log4NetLevelMapperEnricher>() .Enrich.FromLogContext(); // allows us to dynamically enrich //This is not optimal, but seems to be the only way if we do not make an Serilog.Sink.UmbracoFile sink all the way. var umbracoFileConfiguration = new UmbracoFileConfiguration(configuration); umbFileConfiguration = umbracoFileConfiguration; logConfig.WriteTo.UmbracoFile( path: umbracoFileConfiguration.GetPath(loggingConfiguration.LogDirectory), fileSizeLimitBytes: umbracoFileConfiguration.FileSizeLimitBytes, restrictedToMinimumLevel: umbracoFileConfiguration.RestrictedToMinimumLevel, rollingInterval: umbracoFileConfiguration.RollingInterval, flushToDiskInterval: umbracoFileConfiguration.FlushToDiskInterval, rollOnFileSizeLimit: umbracoFileConfiguration.RollOnFileSizeLimit, retainedFileCountLimit: umbracoFileConfiguration.RetainedFileCountLimit ); return(logConfig); }
/// <summary> /// Create and configure the logger /// </summary> public static IServiceCollection AddLogger( this IServiceCollection services, IHostingEnvironment hostingEnvironment, ILoggingConfiguration loggingConfiguration, IConfiguration configuration) { // Create a serilog logger var logger = SerilogLogger.CreateWithDefaultConfiguration(hostingEnvironment, loggingConfiguration, configuration, out var umbracoFileConfig); services.AddSingleton(umbracoFileConfig); // This is nessasary to pick up all the loggins to MS ILogger. Log.Logger = logger.SerilogLog; // Wire up all the bits that serilog needs. We need to use our own code since the Serilog ext methods don't cater to our needs since // we don't want to use the global serilog `Log` object and we don't have our own ILogger implementation before the HostBuilder runs which // is the only other option that these ext methods allow. // I have created a PR to make this nicer https://github.com/serilog/serilog-extensions-hosting/pull/19 but we'll need to wait for that. // Also see : https://github.com/serilog/serilog-extensions-hosting/blob/dev/src/Serilog.Extensions.Hosting/SerilogHostBuilderExtensions.cs services.AddLogging(configure => { configure.AddSerilog(logger.SerilogLog, false); }); // This won't (and shouldn't) take ownership of the logger. services.AddSingleton(logger.SerilogLog); // Registered to provide two services... var diagnosticContext = new DiagnosticContext(logger.SerilogLog); // Consumed by e.g. middleware services.AddSingleton(diagnosticContext); // Consumed by user code services.AddSingleton <IDiagnosticContext>(diagnosticContext); services.AddSingleton(loggingConfiguration); return(services); }
public BootFailedMiddleware(IRuntimeState runtimeState, IHostingEnvironment hostingEnvironment, IWebHostEnvironment webHostEnvironment) { _runtimeState = runtimeState; _hostingEnvironment = hostingEnvironment; _webHostEnvironment = webHostEnvironment; }
public BootFailedMiddleware(IRuntimeState runtimeState, IHostingEnvironment hostingEnvironment) : this(runtimeState, hostingEnvironment, StaticServiceProvider.Instance.GetRequiredService <IWebHostEnvironment>()) { _runtimeState = runtimeState; _hostingEnvironment = hostingEnvironment; }