Logging dans l'hébergement AspNetCore / Redirection de la sortie de la console

Question

J'ai récemment ajouté un projet AspNetCore à notre logiciel qui n'est rien de plus qu'un petit site MVC. Pour héberger ce projet, j'utilise les fonctionnalités suivantes Microsoft.AspNetCore.Hosting y Topshelf pour exécuter l'hébergement dans un service Windows.

Le problème est que je ne peux obtenir aucune information de débogage du processus d'hébergement une fois qu'il est exécuté dans le service Windows. Habituellement, toutes les informations sont écrites dans la console et comme j'utilise mon propre traçage/journalisme dans notre logiciel, je voudrais continuer à l'utiliser si possible ou au moins dire au processus d'hébergement de simplement transmettre toutes les informations à un appel de méthode de notre traçage pour ne rien manquer et mettre en œuvre l'un des loggers courants comme NLog à l'avenir.

Voici le code pour l'hébergement

public class Program
{
    public static void Main(string[] args)
    {
        // Name of the executable
        var nameOfExe = Process.GetCurrentProcess().MainModule.FileName;

        // Path of the current executable
        var pathToContentRoot = Path.GetDirectoryName(nameOfExe);

        // Path of the www root for the static files
        var pathToWebRoot = pathToContentRoot + @"\wwwroot";

        IWebHost host = WebHost.CreateDefaultBuilder()
        .UseKestrel()
        .UseContentRoot(pathToContentRoot)
        .UseIISIntegration()
        .UseWebRoot(pathToWebRoot)
        .UseStartup<Startup>()
        .UseApplicationInsights()
        .Build();

        host.RunAsCustomService();
    }
}

public static class WebHostServiceExtensions
{
    public static void RunAsCustomService(this IWebHost host)
    {
        var webHostService = new Service(host);
        ServiceBase.Run(webHostService);
    }
}

public class Startup
{
    public Startup(IHostingEnvironment env)
    {
        if(env.IsDevelopment())
        {
            env.ContentRootPath = env.ContentRootPath.Replace("Bin", @"Main");
            env.ContentRootFileProvider = new PhysicalFileProvider(env.ContentRootPath);
            env.WebRootPath = env.WebRootPath.Replace("Bin", @"Main");
            env.WebRootFileProvider = new PhysicalFileProvider(env.WebRootPath);
        }

        var builder = new ConfigurationBuilder()
            .SetBasePath(env.ContentRootPath)
            .AddJsonFile("appsettings.json", optional: false, reloadOnChange: true)
            .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
            .AddEnvironmentVariables();
        Configuration = builder.Build();
    }

    public IConfigurationRoot Configuration { get; }

    // This method gets called by the runtime. Use this method to add services to the container.
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddSession(options => {
            options.IdleTimeout = TimeSpan.FromMinutes(500); });
        // Add framework services.
        services
            .AddLocalization(options => options.ResourcesPath = "Resources")

            .AddMvc().ConfigureApplicationPartManager(manager =>
            {
                var oldMetadataReferenceFeatureProvider = manager.FeatureProviders.First(f => f is MetadataReferenceFeatureProvider);
                manager.FeatureProviders.Remove(oldMetadataReferenceFeatureProvider);
                manager.FeatureProviders.Add(new ReferencesMetadataReferenceFeatureProvider());
            })
            .AddViewLocalization(LanguageViewLocationExpanderFormat.Suffix)
            .AddDataAnnotationsLocalization();

        services.AddSingleton<FFDModel>();
        services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();

        services.Configure<WebSettings>(Configuration.GetSection("ValidationFilters"));
    }

    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
    public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
    {
        app.UseSession();

        loggerFactory.AddConsole(Configuration.GetSection("Logging"));
        loggerFactory.AddDebug();

        if (env.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
            app.UseBrowserLink();
        }
        else
        {
            app.UseExceptionHandler("/Home/Error");
        }

        app.UseStaticFiles();

        IList<CultureInfo> supportedCultures = new List<CultureInfo>
        {
             new CultureInfo("en-US"),
             new CultureInfo("de-DE"),
            };
        app.UseRequestLocalization(new RequestLocalizationOptions
        {
            DefaultRequestCulture = new RequestCulture("en-US"),
            SupportedCultures = supportedCultures,
            SupportedUICultures = supportedCultures
        });

        app.UseMvc(routes =>
        {
            routes.MapRoute(
                name: "default",
                template: "{controller=FFD}/{action=Index}/{id?}");
        });
    }
}

Answer 1

J'utiliserais Serilog https://serilog.net pour la journalisation dans toute application .NET.

Serilog peut être configuré pour rediriger la sortie vers plusieurs cibles, par exemple la console, le fichier de roulement. Si vous avez une destination/exigence de journalisation personnalisée, vous pouvez rediriger la sortie en écrivant un script personnalisé Sink .

Il est facile à intégrer dans une application ASP.Net Core à l'aide de la fonction IWebHostBuilder extension https://github.com/serilog/serilog-aspnetcore

Sources

• Exemple de Serilog ASP.Net Core https://github.com/serilog/serilog-aspnetcore/tree/dev/samples/SimpleWebSample
• Éviers fournis https://github.com/serilog/serilog/wiki/Provided-Sinks
• Développement d'un évier https://github.com/serilog/serilog/wiki/Developing-a-sink