EF Core Context is causing memory leak

Question

My software using EF Core in combination with a SQLite database within an ASP.NET Core Web API using dependency injection, has a memory leak.

I have a background job using Quartz which gets called every 9 seconds.

My context looks like this:

public class TeslaSolarChargerContext : DbContext, ITeslaSolarChargerContext
{
    public DbSet<ChargePrice> ChargePrices { get; set; } = null!;
    public DbSet<HandledCharge> HandledCharges { get; set; } = null!;
    public DbSet<PowerDistribution> PowerDistributions { get; set; } = null!;

    public string DbPath { get; }

    public void RejectChanges()
    {
        foreach (var entry in ChangeTracker.Entries())
        {
            switch (entry.State)
            {
                case EntityState.Modified:
                case EntityState.Deleted:
                    entry.State = EntityState.Modified; //Revert changes made to deleted entity.
                    entry.State = EntityState.Unchanged;
                    break;

                case EntityState.Added:
                    entry.State = EntityState.Detached;
                    break;
            }
        }
    }

    public TeslaSolarChargerContext()
    {
    }

    public TeslaSolarChargerContext(DbContextOptions<TeslaSolarChargerContext> options)
        : base(options)
    {
    }
}

With the interface

public interface ITeslaSolarChargerContext
{
    DbSet<ChargePrice> ChargePrices { get; set; }
    DbSet<HandledCharge> HandledCharges { get; set; }
    DbSet<PowerDistribution> PowerDistributions { get; set; }
    ChangeTracker ChangeTracker { get; }
    Task<int> SaveChangesAsync(CancellationToken cancellationToken = new CancellationToken());
    DatabaseFacade Database { get; }
    void RejectChanges();
}

In my Program.cs I add the context and Quartz job to the dependency injection like that:

builder.Services.AddDbContext<ITeslaSolarChargerContext, TeslaSolarChargerContext>((provider, options) =>
    {
        options.UseSqlite(provider.GetRequiredService<IDbConnectionStringHelper>().GetTeslaSolarChargerDbPath());
        options.EnableSensitiveDataLogging();
        options.EnableDetailedErrors();
    }, ServiceLifetime.Transient, ServiceLifetime.Transient)
    .AddTransient<IChargingCostService, ChargingCostService>();
builder.Services
    .AddSingleton<JobManager>()
    .AddTransient<PowerDistributionAddJob>()
    .AddTransient<IJobFactory, JobFactory>()
    .AddTransient<ISchedulerFactory, StdSchedulerFactory>();

I am using my own JobManager because job intervalls can be configured in various ways so I inject a wrapper into my JobManager and it is Singleton as I need to stop my jobs at any time as the job intervall can be updated during runtime, so I need to stop and start the jobs:

public class JobManager
{
    private readonly ILogger<JobManager> _logger;
    private readonly IJobFactory _jobFactory;
    private readonly ISchedulerFactory _schedulerFactory;
    private readonly IConfigurationWrapper _configurationWrapper;

    private IScheduler _scheduler;

    
    public JobManager(ILogger<JobManager> logger, IJobFactory jobFactory, ISchedulerFactory schedulerFactory, IConfigurationWrapper configurationWrapper)
    {
        _logger = logger;
        _jobFactory = jobFactory;
        _schedulerFactory = schedulerFactory;
        _configurationWrapper = configurationWrapper;
    }

    public async Task StartJobs()
    {
        _logger.LogTrace("{Method}()", nameof(StartJobs));
        _scheduler = _schedulerFactory.GetScheduler().GetAwaiter().GetResult();
        _scheduler.JobFactory = _jobFactory;

        var powerDistributionAddJob = JobBuilder.Create<PowerDistributionAddJob>().Build();

        var powerDistributionAddTrigger = TriggerBuilder.Create()
            .WithSchedule(SimpleScheduleBuilder.RepeatSecondlyForever((int)_configurationWrapper.JobIntervall().TotalSeconds)).Build();


        var triggersAndJobs = new Dictionary<IJobDetail, IReadOnlyCollection<ITrigger>>
        {
            {powerDistributionAddJob, new HashSet<ITrigger> {powerDistributionAddTrigger}},
        };

        await _scheduler.ScheduleJobs(triggersAndJobs, false).ConfigureAwait(false);

        await _scheduler.Start().ConfigureAwait(false);
    }

    public async Task StopJobs()
    {
        await _scheduler.Shutdown(true).ConfigureAwait(false);
    }
}

The job looks like this:

[DisallowConcurrentExecution]
public class PowerDistributionAddJob : IJob
{
    private readonly ILogger<ChargeTimeUpdateJob> _logger;
    private readonly IChargingCostService _service;

    public PowerDistributionAddJob(ILogger<ChargeTimeUpdateJob> logger, IChargingCostService service)
    {
        _logger = logger;
        _service = service;
    }
    public async Task Execute(IJobExecutionContext context)
    {
        _logger.LogTrace("{method}({context})", nameof(Execute), context);
        await _service.AddPowerDistributionForAllChargingCars().ConfigureAwait(false);
    }
}

The context is injected to the service like that:

public ChargingCostService(ILogger<ChargingCostService> logger,
        ITeslaSolarChargerContext teslaSolarChargerContext)
{
    _logger = logger;
    _teslaSolarChargerContext = teslaSolarChargerContext;
}

I use the context within a service and just call this method:

var chargePrice = await _teslaSolarChargerContext.ChargePrices
                                                 .FirstOrDefaultAsync().ConfigureAwait(false);

Calling this results in the app blowing using 1GB RAM after a week.

After analyzing a memory dump I found that after about 8 hours I have over two thousand instances of TeslaSolarChargerContext.

Answer 1

Did you run any memory profiler to confirm where the leak is?:

I created a small minimal reproduction:

using Microsoft.EntityFrameworkCore;
using Quartz;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddDbContext<MyContext>(ServiceLifetime.Transient, ServiceLifetime.Transient); // works even without changing the lifetime
builder.Services.AddQuartz((IServiceCollectionQuartzConfigurator quartzOptions) =>
{
    quartzOptions.UseMicrosoftDependencyInjectionJobFactory();
    quartzOptions.ScheduleJob<MyJob>(job => job.WithSimpleSchedule(x => x.WithIntervalInSeconds(3).RepeatForever()));
}).AddQuartzServer();

EnsureDb(builder.Services); // to make HasData work
var app = builder.Build();
app.Run();

void EnsureDb(IServiceCollection builderServices)
{
    using var scope = builderServices.BuildServiceProvider().CreateScope();
    var context = scope.ServiceProvider.GetRequiredService<MyContext>();
    context.Database.EnsureCreated();
}

class MyContext : DbContext
{
    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        base.OnConfiguring(optionsBuilder);
        optionsBuilder.UseInMemoryDatabase("products");
    }

    public DbSet<Product> Products
    {
        get;
        set;
    }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        modelBuilder.Entity<Product>()
            .HasData(new Product(1, "Test"));

        base.OnModelCreating(modelBuilder);
    }

    public override void Dispose()
    {
        base.Dispose(); // put a breakpoint here
    }
}
record Product(int Id, string Name);

class MyJob : IJob, IDisposable
{
    private readonly MyContext _ctx;
    private readonly ILogger<MyJob> _logger;

    public MyJob(MyContext ctx, ILogger<MyJob> logger)
    {
        _ctx = ctx;
        _logger = logger;
        
        _logger.LogInformation("Creating job");
    }
    
    public async Task Execute(IJobExecutionContext context)
    {
        _logger.LogInformation("Product {Product}", await _ctx.Products.FirstOrDefaultAsync());
    }

    public void Dispose()
    {
        _ctx.Dispose(); // totally not needed, but you can try this approach
    }
}

First of all, it works at all, which means that Quartz is creating scope for each job creation - DbContext is created each time job is run and is properly disposed. dotMemory confirms this. quartzOptions.UseMicrosoftDependencyInjectionJobFactory(); is key to that: https://www.quartz-scheduler.net/documentation/quartz-3.x/packages/microsoft-di-integration.html#installation

I noticed that you register your context as transient, probably because you found that you cannot inject scoped dependencies into transient services. Put a breakpoint in the DbContext.Dispose method and see if it gets hit. If not, you messed up something with registration or holding onto the instanc - that's your leak.

The container SHOULD dispose your transient dependencies, but then I don't really know how you register Quartz - maybe you misconfigured somewhere there. Take a look at my repro and check what is different.

EDIT:

If you are sure that it's the DbContext that's causing problems, you can always switch to injecting DbContextFactory (docs):

// writen out of memory 

// in your startup
services.AddDbContextFactory<ApplicationDbContext>(
    options => 
    // your config
);


class YourService
{
    private readonly IDbContextFactory<ApplicationDbContext> _contextFactory;

    public YourService(IDbContextFactory<ApplicationDbContext> contextFactory)
    {
        _contextFactory = contextFactory;
    }

    public async Task Execute()
    {
        ChargePrice price;

        using (var ctx = _contextFactory.CreateDbContext())
        {
            price = await ctx.ChargePrices.FirstAsync();
        } // this will dispose the DbContext

        // continue
    }
}