Suppress SQL Queries logging in Entity Framework core

Found that if Logging section is modified in following manner i am not see EF logs message related to SQL queries:

  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Information",
      "Microsoft.Hosting.Lifetime": "Information",
      "Microsoft.EntityFrameworkCore.Database.Command": "Warning"
    }
  }

If you're using built-in logger, you can add filter to you ILoggingBuilder in Program.cs.

So, it can look like:

WebHost.CreateDefaultBuilder(args)
    // ...
    .ConfigureLogging((context, logging) => {
        var env = context.HostingEnvironment;
        var config = context.Configuration.GetSection("Logging");
        // ...
        logging.AddConfiguration(config);
        logging.AddConsole();
        // ...
        logging.AddFilter("Microsoft.EntityFrameworkCore.Database.Command", LogLevel.Warning);
    })
    // ...
    .UseStartup<Startup>()
    .Build();

If you are using the default Logger, in the appsettings.json (or appesttings.Development.json for dev startup) file:

"Logging": {
    "LogLevel": {
      "Default": "Debug",
      "System": "Information",
      "Microsoft": "Warning"        <----
    }
},

Set it to Warning instead of Information.

The answers doesn't work for me then i found this one:

On your Programs.cs, creating builder, add that line:

builder.Logging.AddFilter("Microsoft.EntityFrameworkCore.Database.Command", LogLevel.Warning);

You want to change your Serilog configuration to set the minimum level for the Microsoft.EntityFrameworkCore.Storage.IRelationalCommandBuilderFactory context to Warning or higher.

You can find the context you need to change by setting the output template to something like [{Timestamp:HH:mm:ss} {SourceContext} [{Level}] {Message}{NewLine}{Exception}. Once you know the context you can set the template back to how it was before.

I had this issue in one of my projects and noticed that there's a bit more to look at in addition to earlier answers to this question.

You can do things like this:

    "Logging": {
        "IncludeScopes": true,
        "LogLevel": {
            "Default": "Debug",
            "System": "Information",
            "Microsoft": "Information",
            "Microsoft.EntityFrameworkCore": "Warning" <-- Note that this applies to EF Core, including everything in it.
        }
    }

What's also important is the order where things are added to the ILoggingBuilder.

    // This still will log EF messages to the console.
    serviceCollection.AddLogging(builder =>
        builder
            .AddConsole()
            .AddConfiguration(config.GetSection("Logging")));

    // This will apply the configuration to the console logger.
    serviceCollection.AddLogging(builder =>
        builder
            .AddConfiguration(config.GetSection("Logging"))
            .AddConsole());

Another way this can be configured differently is to add the following when registering the DbContext, so the CommandExecuted event is logged with a different LogLevel.

AddDbContext<DataStoreContext>(options =>
            options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")))
            options.ConfigureWarnings(b => b.Log((RelationalEventId.CommandExecuted, LogLevel.Trace)));

First find your source context where sql queries are being generated from. To do that, set outputTemplate as described here.

Then add it in LoggerConfiguration

.MinimumLevel.Override(<your_source_context>, LogEventLevel.Warning)

1.First I have installed these two Nuget packages.

2.Configurations goes like this

var logger = new LoggerConfiguration()
            .MinimumLevel.Information()
            .MinimumLevel.Override("Microsoft", LogEventLevel.Information)
            .MinimumLevel.Override("Microsoft.AspNetCore", LogEventLevel.Warning)
            .MinimumLevel.Override("Microsoft.EntityFrameworkCore.Database.Command", LogEventLevel.Warning)    
            .WriteTo.File(builder.Environment.WebRootPath + "/Logs/SUPCOMS-LOG-.log", rollingInterval: RollingInterval.Day)
            .CreateLogger();
        
builder.Logging.ClearProviders();
builder.Logging.AddSerilog(logger);

3.Log writing looks like this

public class MyClass: IMyInterface
{
    private readonly SupcomsDBContext _dBContext;
    private readonly ILogger<MyClass> _logger;

    public MyClass(SupcomsDBContext dBContext, ILogger<MyClass> logger)
    {
        this._dBContext = dBContext;
        this._logger = logger;
    }

    public bool MyMethod()
    { 
      _logger.LogError("I have an error");
      _logger.LogInformation("This is an information"  );
    }
}

4.Log file looks like this

this is a solution:

 <!--Skip non-critical Microsoft logs and so log only own logs-->
    <logger name="Microsoft.*" maxlevel="Fatal" final="true" /> 
    <!-- BlackHole without writeTo -->
    <logger name="*" minlevel="Trace" writeTo="mydatabase" />