I cannot get basic LogTrace(...)

output in my application. It reproduces here:

• Create a new ASP.NET Core app using Visual Studio 2017.
• (Optional) comment out .UseApplicationInsights()
  
  for clearer playback

• Replace the code with the ValuesController.cs
  
  following:

  using System.Collections.Generic;
  using Microsoft.AspNetCore.Mvc;
  using Microsoft.Extensions.Logging;
  
  namespace WebApplication1.Controllers
  {
      [Route("api/[controller]")]
      public class ValuesController : Controller
      {
          private readonly ILogger<ValuesController> logger;
  
          public ValuesController(ILogger<ValuesController> logger)
          {
              this.logger = logger;
          }
  
          [HttpGet]
          public IEnumerable<string> Get()
          {
              logger.LogError("ERROR!");
              logger.LogWarning("WARN!");
              logger.LogInformation("INFO!");
              logger.LogTrace("TRACE!");
              return new string[] { "value1", "value2" };
          }
      }
  }
  
        
  
          
          
          
        
  
      

• Change appsettings.Development.json
  
  to this:

  {
    "Logging": {
      "IncludeScopes": false,
      "LogLevel": {
        "Default": "Trace",
        "System": "Information",
        "Microsoft": "Information"
      }
    }
  }
  
        
  
          
          
          
        
  
      

• Run and view the Debug output

This leads to:

• Actual output:

  

• The expected output is "TRACE!" message also

I also tried changing the values ​​in the file appsettings.json

, but that didn't make any difference either.

Oddly enough, changing the value in any file to "Error"

does nothing either.

Bottom line / question

What do I need to do to get my inputs to ILogger<ValuesController>

respect the logging parameters including Trace

level?

Footnote

Here are some of the relevant code that would be auto-generated with the above reproduction:

Startup.cs

public class Startup
{
    public Startup(IHostingEnvironment env)
    {
        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)
    {
        // Add framework services.
        services.AddMvc();
    }

    // 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)
    {
        loggerFactory.AddConsole(Configuration.GetSection("Logging"));
        loggerFactory.AddDebug();

        app.UseMvc();
    }
}

      

        
        
        
      

    

Program.cs

public class Program
{
    public static void Main(string[] args)
    {
        var host = new WebHostBuilder()
            .UseKestrel()
            .UseContentRoot(Directory.GetCurrentDirectory())
            .UseIISIntegration()
            .UseStartup<Startup>()
            .UseApplicationInsights()
            .Build();

        host.Run();
    }
}

      

        
        
        
      

    

appsettings.json

default:

{
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Warning"
    }
  }
}