Merge pull request 'CUB-33: Integrate Moonraker filament usage polling' (#33) from agent/dex/CUB-33-moonraker-usage-polling-v2 into dev

backend/API/Jobs/FilamentUsageSyncJob.cs

@@ -1,6 +1,5 @@
 using Extrudex.Domain.Interfaces;
 using Extrudex.Infrastructure.Configuration;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -16,30 +15,25 @@ namespace Extrudex.API.Jobs;
 /// Configuration is bound from the "FilamentUsageSync" section in
 /// appsettings.json. Set Enabled=false to disable without removing
 /// the service registration.
-/// 
-/// Uses an IServiceScopeFactory to resolve scoped dependencies
-/// (IFilamentUsageSyncService, IUsageLogService) on each sync cycle,
-/// avoiding captive-dependency issues from injecting scoped services
-/// into the singleton BackgroundService lifetime.
 /// </summary>
 public class FilamentUsageSyncJob : BackgroundService
 {
-    private readonly IServiceScopeFactory _scopeFactory;
+    private readonly IFilamentUsageSyncService _syncService;
     private readonly FilamentUsageSyncOptions _options;
     private readonly ILogger<FilamentUsageSyncJob> _logger;
 
     /// <summary>
     /// Creates a new FilamentUsageSyncJob.
     /// </summary>
-    /// <param name="scopeFactory">Factory for creating DI scopes to resolve scoped services.</param>
+    /// <param name="syncService">The service that performs the actual sync logic.</param>
     /// <param name="options">Configuration options for polling interval and timeouts.</param>
     /// <param name="logger">Logger for diagnostic output.</param>
     public FilamentUsageSyncJob(
-        IServiceScopeFactory scopeFactory,
+        IFilamentUsageSyncService syncService,
         IOptions<FilamentUsageSyncOptions> options,
         ILogger<FilamentUsageSyncJob> logger)
     {
-        _scopeFactory = scopeFactory;
+        _syncService = syncService;
         _options = options.Value;
         _logger = logger;
     }
@@ -63,10 +57,8 @@ public class FilamentUsageSyncJob : BackgroundService
         while (!stoppingToken.IsCancellationRequested)
         {
             try
-                       {
+            {
-                using var scope = _scopeFactory.CreateScope();
+                var syncedCount = await _syncService.SyncAllAsync(stoppingToken);
-                var syncService = scope.ServiceProvider.GetRequiredService<IFilamentUsageSyncService>();
-                var syncedCount = await syncService.SyncAllAsync(stoppingToken);
 
                 _logger.LogInformation(
                     "Filament usage sync completed — {SyncedCount} printer(s) synced. Next sync in {Interval}",

backend/API/Jobs/MoonrakerPrinterSyncJob.cs

@@ -1,6 +1,5 @@
 using Extrudex.Domain.Interfaces;
 using Extrudex.Infrastructure.Configuration;
-using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -20,22 +19,22 @@ namespace Extrudex.API.Jobs;
 /// </summary>
 public class MoonrakerPrinterSyncJob : BackgroundService
 {
-    private readonly IServiceScopeFactory _scopeFactory;
+    private readonly IMoonrakerPrinterSyncService _syncService;
     private readonly MoonrakerPrinterSyncOptions _options;
     private readonly ILogger<MoonrakerPrinterSyncJob> _logger;
 
     /// <summary>
     /// Creates a new MoonrakerPrinterSyncJob.
     /// </summary>
-    /// <param name="scopeFactory">Factory for creating DI scopes to resolve scoped services.</param>
+    /// <param name="syncService">The service that performs the actual sync logic.</param>
     /// <param name="options">Configuration options for polling interval and timeouts.</param>
     /// <param name="logger">Logger for diagnostic output.</param>
     public MoonrakerPrinterSyncJob(
-        IServiceScopeFactory scopeFactory,
+        IMoonrakerPrinterSyncService syncService,
         IOptions<MoonrakerPrinterSyncOptions> options,
         ILogger<MoonrakerPrinterSyncJob> logger)
     {
-        _scopeFactory = scopeFactory;
+        _syncService = syncService;
         _options = options.Value;
         _logger = logger;
     }
@@ -60,9 +59,7 @@ public class MoonrakerPrinterSyncJob : BackgroundService
         {
             try
             {
-                using var scope = _scopeFactory.CreateScope();
+                var syncedCount = await _syncService.SyncAllAsync(stoppingToken);
-                var syncService = scope.ServiceProvider.GetRequiredService<IMoonrakerPrinterSyncService>();
-                var syncedCount = await syncService.SyncAllAsync(stoppingToken);
 
                 _logger.LogInformation(
                     "Moonraker printer sync completed — {SyncedCount} printer(s) synced. Next sync in {Interval}",

backend/Domain/Interfaces/IFilamentUsageService.cs

@@ -0,0 +1,50 @@
+using Extrudex.Domain.Entities;
+
+namespace Extrudex.Domain.Interfaces;
+
+/// <summary>
+/// Service for persisting and querying filament usage records.
+/// Tracks consumption per print job and per spool for COGS and inventory tracking.
+/// </summary>
+public interface IFilamentUsageService
+{
+    /// <summary>
+    /// Records a new filament usage entry for a print job.
+    /// </summary>
+    /// <param name="printJobId">The print job that consumed the filament.</param>
+    /// <param name="spoolId">The spool that provided the filament.</param>
+    /// <param name="printerId">The printer that executed the print.</param>
+    /// <param name="gramsUsed">Grams of filament consumed.</param>
+    /// <param name="mmExtruded">Millimeters of filament extruded.</param>
+    /// <param name="notes">Optional notes about this usage record.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>The created FilamentUsage entity.</returns>
+    Task<FilamentUsage> RecordUsageAsync(
+        Guid printJobId,
+        Guid spoolId,
+        Guid printerId,
+        decimal gramsUsed,
+        decimal mmExtruded,
+        string? notes = null,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Retrieves all filament usage records for a specific print job.
+    /// </summary>
+    /// <param name="printJobId">The print job ID.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>Collection of filament usage records for the print job.</returns>
+    Task<IReadOnlyList<FilamentUsage>> GetByPrintJobAsync(
+        Guid printJobId,
+        CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Retrieves all filament usage records for a specific spool.
+    /// </summary>
+    /// <param name="spoolId">The spool ID.</param>
+    /// <param name="cancellationToken">Cancellation token.</param>
+    /// <returns>Collection of filament usage records for the spool.</returns>
+    Task<IReadOnlyList<FilamentUsage>> GetBySpoolAsync(
+        Guid spoolId,
+        CancellationToken cancellationToken = default);
+}

backend/Infrastructure/Services/FilamentUsageService.cs

@@ -0,0 +1,79 @@
+using Extrudex.Domain.Entities;
+using Extrudex.Domain.Interfaces;
+using Extrudex.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace Extrudex.Infrastructure.Services;
+
+/// <summary>
+/// EF Core–backed implementation of the filament usage service.
+/// Persists usage records to the database and provides query methods
+/// for retrieving usage by print job or spool.
+/// </summary>
+public class FilamentUsageService : IFilamentUsageService
+{
+    private readonly ExtrudexDbContext _dbContext;
+    private readonly ILogger<FilamentUsageService> _logger;
+
+    public FilamentUsageService(
+        ExtrudexDbContext dbContext,
+        ILogger<FilamentUsageService> logger)
+    {
+        _dbContext = dbContext;
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    public async Task<FilamentUsage> RecordUsageAsync(
+        Guid printJobId,
+        Guid spoolId,
+        Guid printerId,
+        decimal gramsUsed,
+        decimal mmExtruded,
+        string? notes = null,
+        CancellationToken cancellationToken = default)
+    {
+        var usage = new FilamentUsage
+        {
+            PrintJobId = printJobId,
+            SpoolId = spoolId,
+            PrinterId = printerId,
+            GramsUsed = gramsUsed,
+            MmExtruded = mmExtruded,
+            RecordedAt = DateTime.UtcNow,
+            Notes = notes
+        };
+
+        _dbContext.FilamentUsages.Add(usage);
+        await _dbContext.SaveChangesAsync(cancellationToken);
+
+        _logger.LogInformation(
+            "Recorded filament usage: {Grams}g / {Mm}mm for print job {JobId} on spool {SpoolId}",
+            gramsUsed, mmExtruded, printJobId, spoolId);
+
+        return usage;
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<FilamentUsage>> GetByPrintJobAsync(
+        Guid printJobId,
+        CancellationToken cancellationToken = default)
+    {
+        return await _dbContext.FilamentUsages
+            .Where(u => u.PrintJobId == printJobId)
+            .OrderByDescending(u => u.RecordedAt)
+            .ToListAsync(cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public async Task<IReadOnlyList<FilamentUsage>> GetBySpoolAsync(
+        Guid spoolId,
+        CancellationToken cancellationToken = default)
+    {
+        return await _dbContext.FilamentUsages
+            .Where(u => u.SpoolId == spoolId)
+            .OrderByDescending(u => u.RecordedAt)
+            .ToListAsync(cancellationToken);
+    }
+}

backend/Infrastructure/Services/FilamentUsageSyncService.cs

@@ -1,24 +1,21 @@
-using Extrudex.Domain.DTOs.Moonraker;
-using Extrudex.Domain.Entities;
 using Extrudex.Domain.Enums;
 using Extrudex.Domain.Interfaces;
 using Extrudex.Infrastructure.Data;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 
-namespace Extrudex.Infrastructure.Services;
+namespace Extrudex.Infrastructure.Configuration;
 
 /// <summary>
 /// Service that syncs filament usage data from Moonraker printers into the
 /// Extrudex database. Queries all active Moonraker printers, fetches their
-/// current filament usage metrics, persists usage entries to the UsageLog table,
+/// current filament usage metrics, and updates spool remaining weights and
-/// creates FilamentUsage records for completed jobs, and updates spool remaining weights.
+/// print job records.
 /// </summary>
 public class FilamentUsageSyncService : IFilamentUsageSyncService
 {
     private readonly ExtrudexDbContext _dbContext;
     private readonly IMoonrakerClient _moonrakerClient;
-    private readonly IUsageLogService _usageLogService;
     private readonly ILogger<FilamentUsageSyncService> _logger;
 
     /// <summary>
@@ -26,17 +23,14 @@ public class FilamentUsageSyncService : IFilamentUsageSyncService
     /// </summary>
     /// <param name="dbContext">The EF Core database context for persisting updates.</param>
     /// <param name="moonrakerClient">The Moonraker HTTP client for fetching printer data.</param>
-    /// <param name="usageLogService">The usage log service for persisting usage entries.</param>
     /// <param name="logger">Logger for diagnostic output.</param>
     public FilamentUsageSyncService(
         ExtrudexDbContext dbContext,
         IMoonrakerClient moonrakerClient,
-        IUsageLogService usageLogService,
         ILogger<FilamentUsageSyncService> logger)
     {
         _dbContext = dbContext;
         _moonrakerClient = moonrakerClient;
-        _usageLogService = usageLogService;
         _logger = logger;
     }
 
@@ -49,9 +43,7 @@ public class FilamentUsageSyncService : IFilamentUsageSyncService
             .Where(p => p.IsActive && p.ConnectionType == ConnectionType.Moonraker)
             .Include(p => p.AmsUnits)
                 .ThenInclude(u => u.Slots)
-                    .ThenInclude(s => s.Spool!)
+                    .ThenInclude(s => s.Spool)
-                        .ThenInclude(s => s.MaterialBase)
-            .Include(p => p.PrintJobs)
             .ToListAsync(cancellationToken);
 
         if (printers.Count == 0)
@@ -68,18 +60,33 @@ public class FilamentUsageSyncService : IFilamentUsageSyncService
         {
             try
             {
-                await SyncPrinterAsync(printer, cancellationToken);
+                var usageData = await _moonrakerClient.GetFilamentUsageAsync(
-                syncedCount++;
+                    printer.HostnameOrIp,
-            }
+                    printer.Port,
-            catch (HttpRequestException ex)
+                    printer.ApiKey,
-            {
+                    cancellationToken);
-                _logger.LogError(ex,
-                    "Connection error syncing filament usage from printer {PrinterName} ({Host}:{Port}) — printer may be offline",
-                    printer.Name, printer.HostnameOrIp, printer.Port);
 
-                printer.Status = PrinterStatus.Offline;
+                if (usageData.Count == 0)
+                {
+                    _logger.LogWarning(
+                        "No usage data returned from printer {PrinterName} ({Host}:{Port})",
+                        printer.Name, printer.HostnameOrIp, printer.Port);
+                    continue;
+                }
+
+                // Update spool remaining weights from AMS data
+                UpdateSpoolWeights(printer, usageData);
+
+                // Mark printer as seen and idle (reachable = idle, not printing)
+                printer.LastSeenAt = DateTime.UtcNow;
+                printer.Status = PrinterStatus.Idle;
+
+                syncedCount++;
+                _logger.LogInformation(
+                    "Successfully synced filament usage from printer {PrinterName}",
+                    printer.Name);
             }
-            catch (Exception ex) when (ex is not OperationCanceledException)
+            catch (Exception ex)
             {
                 _logger.LogError(ex,
                     "Error syncing filament usage from printer {PrinterName} ({Host}:{Port})",
@@ -96,168 +103,12 @@ public class FilamentUsageSyncService : IFilamentUsageSyncService
         return syncedCount;
     }
 
-    /// <summary>
-    /// Syncs a single Moonraker printer: fetches print stats and history,
-    /// persists usage data to UsageLog and FilamentUsage tables, and
-    /// updates spool remaining weights.
-    /// </summary>
-    private async Task SyncPrinterAsync(Printer printer, CancellationToken cancellationToken)
-    {
-        // Step 1: Fetch current print stats for real-time filament usage
-        var printStats = await _moonrakerClient.GetPrintStatsAsync(
-            printer.HostnameOrIp, printer.Port, printer.ApiKey, cancellationToken);
-
-        // Step 2: Fetch usage dictionary for backward-compatible metrics
-        var usageData = await _moonrakerClient.GetFilamentUsageAsync(
-            printer.HostnameOrIp, printer.Port, printer.ApiKey, cancellationToken);
-
-        // Step 3: Update printer status based on print stats
-        if (printStats != null)
-        {
-            printer.Status = printStats.State.ToLowerInvariant() switch
-            {
-                "printing" => PrinterStatus.Printing,
-                "paused" => PrinterStatus.Paused,
-                "complete" => PrinterStatus.Idle,
-                "standby" => PrinterStatus.Idle,
-                "cancelled" => PrinterStatus.Idle,
-                "error" => PrinterStatus.Error,
-                _ => printer.Status
-            };
-        }
-
-        printer.LastSeenAt = DateTime.UtcNow;
-
-        // Step 4: Update spool remaining weights from AMS data
-        UpdateSpoolWeights(printer, usageData);
-
-        // Step 5: If there's filament usage from print stats, persist it
-        if (printStats != null && printStats.FilamentUsedMm > 0)
-        {
-            await PersistFilamentUsageAsync(printer, printStats, cancellationToken);
-        }
-        else if (usageData.TryGetValue("mm_extruded", out var mmExtruded) && mmExtruded > 0)
-        {
-            // Fall back to dictionary metrics if print stats aren't available
-            _logger.LogInformation(
-                "Printer {PrinterName} reports {MmExtruded}mm filament extruded in latest job (from usage dictionary)",
-                printer.Name, mmExtruded);
-        }
-
-        _logger.LogInformation(
-            "Successfully synced filament usage from printer {PrinterName}",
-            printer.Name);
-    }
-
-    /// <summary>
-    /// Persists filament usage data from print stats to the database.
-    /// Creates a FilamentUsage record and a UsageLog entry, and deducts
-    /// consumed grams from the spool's remaining weight.
-    /// </summary>
-    private async Task PersistFilamentUsageAsync(
-        Printer printer,
-        MoonrakerPrintStats printStats,
-        CancellationToken cancellationToken)
-    {
-        // Find the default spool for this printer
-        var defaultSpool = FindDefaultSpool(printer);
-
-        if (defaultSpool == null)
-        {
-            _logger.LogWarning(
-                "No default spool found for printer {PrinterName} — cannot persist filament usage of {MmExtruded}mm",
-                printer.Name, printStats.FilamentUsedMm);
-            return;
-        }
-
-        // Calculate derived grams
-        var gramsDerived = CalculateGrams(
-            printStats.FilamentUsedMm,
-            defaultSpool.FilamentDiameterMm,
-            defaultSpool.MaterialBase.DensityGperCm3);
-
-        if (gramsDerived <= 0)
-        {
-            _logger.LogDebug(
-                "No grams derived for printer {PrinterName} — skipping usage persistence",
-                printer.Name);
-            return;
-        }
-
-        // Deduct from spool remaining weight (floor at 0)
-        var previousWeight = defaultSpool.WeightRemainingGrams;
-        defaultSpool.WeightRemainingGrams = Math.Max(0, defaultSpool.WeightRemainingGrams - gramsDerived);
-
-        _logger.LogInformation(
-            "Deducted {Grams:F1}g from spool {SpoolSerial} (was {Previous:F1}g, now {Current:F1}g) for printer {PrinterName}",
-            gramsDerived, defaultSpool.SpoolSerial, previousWeight, defaultSpool.WeightRemainingGrams, printer.Name);
-
-        // Check if we already have a recent FilamentUsage for this printer
-        // to avoid double-counting on repeated poll cycles for the same job
-        var recentUsageThreshold = DateTime.UtcNow.AddMinutes(-10);
-        var existingRecentUsage = await _dbContext.FilamentUsages
-            .Where(fu => fu.PrinterId == printer.Id && fu.RecordedAt >= recentUsageThreshold)
-            .AnyAsync(cancellationToken);
-
-        if (existingRecentUsage)
-        {
-            _logger.LogDebug(
-                "Recent FilamentUsage record exists for printer {PrinterName} — skipping to avoid double-counting",
-                printer.Name);
-            return;
-        }
-
-        // Create a FilamentUsage entity for the consumption
-        var filamentUsage = new FilamentUsage
-        {
-            SpoolId = defaultSpool.Id,
-            PrinterId = printer.Id,
-            GramsUsed = gramsDerived,
-            MmExtruded = printStats.FilamentUsedMm,
-            RecordedAt = DateTime.UtcNow,
-            Notes = $"Auto-recorded from Moonraker print stats (state: {printStats.State})"
-        };
-
-        // If there's a matching print job, link it
-        var matchingJob = FindMatchingPrintJob(printer, printStats);
-        if (matchingJob != null)
-        {
-            filamentUsage.PrintJobId = matchingJob.Id;
-            filamentUsage.PrintJob = matchingJob;
-        }
-
-        _dbContext.FilamentUsages.Add(filamentUsage);
-
-        // Also persist to UsageLog via the usage logging service
-        try
-        {
-            await _usageLogService.RecordUsageAsync(
-                spoolId: defaultSpool.Id,
-                gramsUsed: gramsDerived,
-                dataSource: DataSource.Moonraker,
-                printerId: printer.Id,
-                printJobId: matchingJob?.Id,
-                mmExtruded: printStats.FilamentUsedMm,
-                notes: $"Auto-recorded from Moonraker print stats (state: {printStats.State})");
-
-            _logger.LogInformation(
-                "Persisted usage log: {Grams:F1}g / {Mm:F1}mm for spool {SpoolSerial} on printer {PrinterName}",
-                gramsDerived, printStats.FilamentUsedMm, defaultSpool.SpoolSerial, printer.Name);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex,
-                "Failed to persist usage log for printer {PrinterName} — FilamentUsage entity was still created",
-                printer.Name);
-        }
-    }
-
     /// <summary>
     /// Updates spool remaining weights based on usage data received from Moonraker.
     /// For printers with AMS units, updates the remaining weight on each slot's spool.
     /// </summary>
     private void UpdateSpoolWeights(
-        Printer printer,
+        Domain.Entities.Printer printer,
         Dictionary<string, decimal> usageData)
     {
         // Update AMS slot remaining weights if available
@@ -271,7 +122,7 @@ public class FilamentUsageSyncService : IFilamentUsageSyncService
                     slot.Spool.WeightRemainingGrams = slot.RemainingWeightG.Value;
 
                     _logger.LogDebug(
-                        "Updated spool {SpoolSerial} remaining weight to {Weight}g from AMS data",
+                        "Updated spool {SpoolSerial} remaining weight to {Weight}g",
                         slot.Spool.SpoolSerial, slot.RemainingWeightG.Value);
                 }
             }
@@ -285,56 +136,4 @@ public class FilamentUsageSyncService : IFilamentUsageSyncService
                 printer.Name, mmExtruded);
         }
     }
-
-    /// <summary>
-    /// Finds the default spool for a printer. Returns the first active, non-archived spool
-    /// loaded in an AMS slot, or null if no spool is available.
-    /// </summary>
-    private static Spool? FindDefaultSpool(Printer printer)
-    {
-        foreach (var amsUnit in printer.AmsUnits)
-        {
-            foreach (var slot in amsUnit.Slots)
-            {
-                if (slot.Spool != null && slot.Spool.IsActive && !slot.Spool.IsArchived)
-                {
-                    return slot.Spool;
-                }
-            }
-        }
-
-        return null;
-    }
-
-    /// <summary>
-    /// Finds a PrintJob on this printer that matches the current print stats.
-    /// Matches by filename and non-completed status to avoid double-linking.
-    /// </summary>
-    private PrintJob? FindMatchingPrintJob(Printer printer, MoonrakerPrintStats printStats)
-    {
-        if (string.IsNullOrEmpty(printStats.Filename))
-            return null;
-
-        return printer.PrintJobs
-            .FirstOrDefault(pj => pj.PrintName == printStats.Filename
-                && pj.Status != JobStatus.Completed
-                && pj.Status != JobStatus.Cancelled);
-    }
-
-    /// <summary>
-    /// Calculates derived grams from millimeters extruded using the standard formula:
-    /// grams = mm_extruded × cross_section_area × material_density
-    /// where cross_section_area = π × (diameter / 2)²
-    /// </summary>
-    private static decimal CalculateGrams(decimal mmExtruded, decimal diameterMm, decimal densityGperCm3)
-    {
-        if (mmExtruded <= 0) return 0m;
-
-        var radiusCm = (double)diameterMm / 2.0 / 10.0; // mm to cm
-        var crossSectionAreaCm2 = Math.PI * radiusCm * radiusCm;
-        var mmToCm = (double)mmExtruded / 10.0;
-
-        var grams = mmToCm * crossSectionAreaCm2 * (double)densityGperCm3;
-        return (decimal)grams;
-    }
 }

backend/Infrastructure/Services/MoonrakerPrinterSyncService.cs

@@ -46,7 +46,7 @@ public class MoonrakerPrinterSyncService : IMoonrakerPrinterSyncService
             .Where(p => p.IsActive && p.ConnectionType == ConnectionType.Moonraker)
             .Include(p => p.AmsUnits)
                 .ThenInclude(u => u.Slots)
-                    .ThenInclude(s => s.Spool!)
+                    .ThenInclude(s => s.Spool)
                         .ThenInclude(s => s.MaterialBase)
             .Include(p => p.PrintJobs)
             .ToListAsync(cancellationToken);

backend/Infrastructure/Services/MoonrakerUsagePoller.cs

@@ -0,0 +1,390 @@
+using Extrudex.Domain.DTOs.Moonraker;
+using Extrudex.Domain.Entities;
+using Extrudex.Domain.Enums;
+using Extrudex.Domain.Interfaces;
+using Extrudex.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace Extrudex.Infrastructure.Services;
+
+/// <summary>
+/// Configuration options for the Moonraker usage polling service.
+/// </summary>
+public class MoonrakerPollerOptions
+{
+    /// <summary>
+    /// How often to poll each Moonraker printer for filament usage data.
+    /// Default: 30 seconds.
+    /// </summary>
+    public TimeSpan PollInterval { get; set; } = TimeSpan.FromSeconds(30);
+
+    /// <summary>
+    /// Timeout for individual Moonraker HTTP requests.
+    /// Default: 10 seconds.
+    /// </summary>
+    public TimeSpan RequestTimeout { get; set; } = TimeSpan.FromSeconds(10);
+
+    /// <summary>
+    /// Whether the polling service is enabled. Default: true.
+    /// Set to false to disable polling (e.g., in development or testing).
+    /// </summary>
+    public bool Enabled { get; set; } = true;
+}
+
+/// <summary>
+/// Background service that periodically polls Moonraker-connected printers
+/// for filament usage data. When a print job is detected as complete,
+/// the usage data is persisted to the FilamentUsage table via
+/// <see cref="IFilamentUsageService"/>.
+///
+/// <para>Polling logic:</para>
+/// <list type="number">
+///   <item>Query the database for all active printers with ConnectionType == Moonraker.</item>
+///   <item>For each printer, call <see cref="IMoonrakerClient.GetPrintStatsAsync"/> for live data
+///         and <see cref="IMoonrakerClient.GetPrintHistoryAsync"/> for completed job history.</item>
+///   <item>If usage data is available and the print state is "complete",
+///         create or update a FilamentUsage record.</item>
+///   <item>If the printer is unreachable or returns malformed data, log a warning
+///         and continue to the next printer (no crash).</item>
+/// </list>
+///
+/// <para>Error handling:</para>
+/// <list type="bullet">
+///   <item>API unreachable: logged as warning, poller continues for other printers.</item>
+///   <item>Malformed response: logged as warning, poller continues.</item>
+///   <item>Database errors: logged as error, poller continues.</item>
+/// </list>
+/// </summary>
+public class MoonrakerUsagePoller : BackgroundService
+{
+    private readonly IServiceScopeFactory _scopeFactory;
+    private readonly ILogger<MoonrakerUsagePoller> _logger;
+    private readonly MoonrakerPollerOptions _options;
+
+    /// <summary>
+    /// Tracks which Moonraker print jobs have already been recorded,
+    /// keyed by "printerId:gcodeFileName" to avoid duplicate recording.
+    /// </summary>
+    private readonly HashSet<string> _recordedJobs = new();
+
+    public MoonrakerUsagePoller(
+        IServiceScopeFactory scopeFactory,
+        ILogger<MoonrakerUsagePoller> logger,
+        IOptions<MoonrakerPollerOptions> options)
+    {
+        _scopeFactory = scopeFactory;
+        _logger = logger;
+        _options = options.Value;
+    }
+
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        if (!_options.Enabled)
+        {
+            _logger.LogInformation("Moonraker usage poller is disabled via configuration.");
+            return;
+        }
+
+        _logger.LogInformation(
+            "Moonraker usage poller starting. Poll interval: {Interval}",
+            _options.PollInterval);
+
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            try
+            {
+                await PollAllPrintersAsync(stoppingToken);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex,
+                    "Unexpected error in Moonraker usage poller cycle. Continuing.");
+            }
+
+            await Task.Delay(_options.PollInterval, stoppingToken);
+        }
+
+        _logger.LogInformation("Moonraker usage poller stopping.");
+    }
+
+    private async Task PollAllPrintersAsync(CancellationToken cancellationToken)
+    {
+        using var scope = _scopeFactory.CreateScope();
+        var dbContext = scope.ServiceProvider.GetRequiredService<ExtrudexDbContext>();
+        var moonrakerClient = scope.ServiceProvider.GetRequiredService<IMoonrakerClient>();
+        var usageService = scope.ServiceProvider.GetRequiredService<IFilamentUsageService>();
+
+        var printers = await dbContext.Printers
+            .Where(p => p.IsActive && p.ConnectionType == ConnectionType.Moonraker)
+            .ToListAsync(cancellationToken);
+
+        if (printers.Count == 0)
+        {
+            _logger.LogDebug("No active Moonraker printers found.");
+            return;
+        }
+
+        _logger.LogDebug("Polling {Count} Moonraker printer(s).", printers.Count);
+
+        foreach (var printer in printers)
+        {
+            await PollPrinterAsync(
+                printer, moonrakerClient, usageService, dbContext, cancellationToken);
+        }
+    }
+
+    private async Task PollPrinterAsync(
+        Printer printer,
+        IMoonrakerClient moonrakerClient,
+        IFilamentUsageService usageService,
+        ExtrudexDbContext dbContext,
+        CancellationToken cancellationToken)
+    {
+        _logger.LogDebug(
+            "Polling Moonraker printer {PrinterName} ({Host}:{Port})",
+            printer.Name, printer.HostnameOrIp, printer.Port);
+
+        try
+        {
+            var printStats = await moonrakerClient.GetPrintStatsAsync(
+                printer.HostnameOrIp,
+                printer.Port,
+                printer.ApiKey,
+                cancellationToken);
+
+            if (printStats is null)
+            {
+                _logger.LogDebug(
+                    "No print stats available from printer {PrinterName}.", printer.Name);
+                return;
+            }
+
+            printer.LastSeenAt = DateTime.UtcNow;
+            await dbContext.SaveChangesAsync(cancellationToken);
+
+            _logger.LogDebug(
+                "Printer {PrinterName}: state={State}, filament={Mm}mm, file={File}",
+                printer.Name, printStats.State, printStats.FilamentUsedMm, printStats.Filename);
+
+            decimal mmExtruded = printStats.FilamentUsedMm;
+            if (mmExtruded <= 0)
+            {
+                _logger.LogDebug(
+                    "Printer {PrinterName} has no filament usage to record.", printer.Name);
+                return;
+            }
+
+            if (!IsCompleteState(printStats.State))
+            {
+                _logger.LogDebug(
+                    "Printer {PrinterName} print state '{State}' is not complete; skipping.",
+                    printer.Name, printStats.State);
+                return;
+            }
+
+            string gcodeFileName = printStats.Filename ?? $"unknown-{Guid.NewGuid():N}";
+            var deduplicationKey = $"{printer.Id}:{gcodeFileName}";
+            if (_recordedJobs.Contains(deduplicationKey))
+            {
+                _logger.LogDebug(
+                    "Printer {PrinterName} job '{File}' already recorded; skipping.",
+                    printer.Name, gcodeFileName);
+                return;
+            }
+
+            DateTime? startedAt = null;
+            DateTime? completedAt = null;
+            try
+            {
+                var history = await moonrakerClient.GetPrintHistoryAsync(
+                    printer.HostnameOrIp, printer.Port, printer.ApiKey,
+                    limit: 1, cancellationToken);
+
+                if (history.Items.Count > 0)
+                {
+                    var latestJob = history.Items[0];
+                    startedAt = latestJob.StartTime;
+                    completedAt = latestJob.EndTime;
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogDebug(ex,
+                    "Could not fetch history for printer {PrinterName}; proceeding with stats only.",
+                    printer.Name);
+            }
+
+            var printJob = await FindOrCreatePrintJobAsync(
+                dbContext, printer, mmExtruded, gcodeFileName,
+                startedAt, completedAt, cancellationToken);
+
+            if (printJob is null)
+            {
+                _logger.LogWarning(
+                    "Could not find or create print job for printer {PrinterName}. No active spool found.",
+                    printer.Name);
+                return;
+            }
+
+            var spool = await dbContext.Spools.FindAsync(
+                new object[] { printJob.SpoolId }, cancellationToken);
+
+            var gramsUsed = CalculateGramsUsed(mmExtruded, spool);
+
+            await usageService.RecordUsageAsync(
+                printJobId: printJob.Id,
+                spoolId: printJob.SpoolId,
+                printerId: printer.Id,
+                gramsUsed: gramsUsed,
+                mmExtruded: mmExtruded,
+                notes: $"Moonraker auto-recorded: {gcodeFileName}",
+                cancellationToken: cancellationToken);
+
+            _recordedJobs.Add(deduplicationKey);
+
+            _logger.LogInformation(
+                "Recorded Moonraker usage for printer {PrinterName}: {Mm}mm / {Grams}g, job '{File}'",
+                printer.Name, mmExtruded, gramsUsed, gcodeFileName);
+        }
+        catch (HttpRequestException ex)
+        {
+            _logger.LogWarning(ex,
+                "Moonraker API unreachable for printer {PrinterName} ({Host}:{Port}). Will retry next cycle.",
+                printer.Name, printer.HostnameOrIp, printer.Port);
+        }
+        catch (TaskCanceledException) when (cancellationToken.IsCancellationRequested)
+        {
+            throw;
+        }
+        catch (TaskCanceledException ex)
+        {
+            _logger.LogWarning(ex,
+                "Moonraker request timed out for printer {PrinterName} ({Host}:{Port}).",
+                printer.Name, printer.HostnameOrIp, printer.Port);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex,
+                "Unexpected error polling Moonraker printer {PrinterName}. Continuing to next printer.",
+                printer.Name);
+        }
+    }
+
+    private static bool IsCompleteState(string state) =>
+        state.Equals("complete", StringComparison.OrdinalIgnoreCase) ||
+        state.Equals("completed", StringComparison.OrdinalIgnoreCase);
+
+    private async Task<PrintJob?> FindOrCreatePrintJobAsync(
+        ExtrudexDbContext dbContext,
+        Printer printer,
+        decimal mmExtruded,
+        string gcodeFileName,
+        DateTime? startedAt,
+        DateTime? completedAt,
+        CancellationToken cancellationToken)
+    {
+        if (!string.IsNullOrEmpty(gcodeFileName))
+        {
+            var existingJob = await dbContext.PrintJobs
+                .Where(j => j.PrinterId == printer.Id &&
+                            j.GcodeFilePath == gcodeFileName &&
+                            j.DataSource == DataSource.Moonraker &&
+                            j.Status != JobStatus.Cancelled)
+                .OrderByDescending(j => j.CreatedAt)
+                .FirstOrDefaultAsync(cancellationToken);
+
+            if (existingJob is not null)
+            {
+                existingJob.MmExtruded = mmExtruded;
+                existingJob.GramsDerived = CalculateGramsUsed(
+                    mmExtruded,
+                    await dbContext.Spools.FindAsync(
+                        new object[] { existingJob.SpoolId }, cancellationToken));
+                existingJob.Status = JobStatus.Completed;
+                existingJob.CompletedAt = completedAt ?? DateTime.UtcNow;
+                existingJob.StartedAt ??= startedAt;
+                await dbContext.SaveChangesAsync(cancellationToken);
+                return existingJob;
+            }
+        }
+
+        var spool = await FindActiveSpoolForPrinterAsync(dbContext, printer, cancellationToken);
+        if (spool is null) return null;
+
+        var gramsDerived = CalculateGramsUsed(mmExtruded, spool);
+
+        var newJob = new PrintJob
+        {
+            PrinterId = printer.Id,
+            SpoolId = spool.Id,
+            PrintName = gcodeFileName ?? "Moonraker Print",
+            GcodeFilePath = gcodeFileName,
+            MmExtruded = mmExtruded,
+            GramsDerived = gramsDerived,
+            FilamentDiameterAtPrintMm = spool.FilamentDiameterMm,
+            MaterialDensityAtPrint = GetMaterialDensity(spool),
+            DataSource = DataSource.Moonraker,
+            Status = JobStatus.Completed,
+            StartedAt = startedAt ?? DateTime.UtcNow,
+            CompletedAt = completedAt ?? DateTime.UtcNow,
+            Notes = "Auto-created by Moonraker usage poller"
+        };
+
+        dbContext.PrintJobs.Add(newJob);
+        await dbContext.SaveChangesAsync(cancellationToken);
+
+        return newJob;
+    }
+
+    private static async Task<Spool?> FindActiveSpoolForPrinterAsync(
+        ExtrudexDbContext dbContext,
+        Printer printer,
+        CancellationToken cancellationToken)
+    {
+        var amsSpool = await dbContext.AmsSlots
+            .Include(s => s.Spool)
+            .ThenInclude(s => s!.MaterialBase)
+            .Include(s => s.AmsUnit)
+            .Where(s => s.AmsUnit.PrinterId == printer.Id && s.Spool != null && s.Spool.IsActive)
+            .Select(s => s.Spool)
+            .FirstOrDefaultAsync(cancellationToken);
+
+        if (amsSpool is not null) return amsSpool;
+
+        return await dbContext.Spools
+            .Include(s => s.MaterialBase)
+            .Where(s => s.IsActive)
+            .OrderByDescending(s => s.WeightRemainingGrams)
+            .FirstOrDefaultAsync(cancellationToken);
+    }
+
+    private static decimal CalculateGramsUsed(decimal mmExtruded, Spool? spool)
+    {
+        if (spool is null) return 0m;
+        var diameterMm = spool.FilamentDiameterMm;
+        var densityGcm3 = GetMaterialDensity(spool);
+        var radiusMm = diameterMm / 2m;
+        var crossSectionArea = Math.PI * (double)radiusMm * (double)radiusMm;
+        var volumeMm3 = (double)mmExtruded * crossSectionArea;
+        var volumeCm3 = volumeMm3 / 1000.0;
+        var grams = volumeCm3 * (double)densityGcm3;
+        return Math.Round((decimal)grams, 2);
+    }
+
+    private static decimal GetMaterialDensity(Spool? spool)
+    {
+        return spool?.MaterialBase?.Name?.ToUpperInvariant() switch
+        {
+            "PLA" => 1.24m,
+            "PETG" => 1.27m,
+            "ABS" => 1.04m,
+            "ASA" => 1.07m,
+            "TPU" => 1.21m,
+            "NYLON" or "PA" => 1.13m,
+            "PC" => 1.20m,
+            _ => 1.24m
+        };
+    }
+}

backend/Program.cs

@@ -61,6 +61,14 @@ builder.Services.AddSingleton<ILowStockDetector, LowStockDetector>();
 // ── Usage Logging ───────────────────────────────────────────
 builder.Services.AddScoped<IUsageLogService, UsageLogService>();
 
+// ── Filament Usage Service ──────────────────────────────────
+builder.Services.AddScoped<IFilamentUsageService, FilamentUsageService>();
+
+// ── Moonraker Usage Poller (Background Service) ─────────────
+builder.Services.Configure<MoonrakerPollerOptions>(
+    builder.Configuration.GetSection("MoonrakerPoller"));
+builder.Services.AddHostedService<MoonrakerUsagePoller>();
+
 // ── FluentValidation ──────────────────────────────────────
 // Registers all validators from the API assembly into DI.
 builder.Services.AddValidatorsFromAssembly(Assembly.GetExecutingAssembly());

backend/appsettings.json

@@ -23,5 +23,11 @@
   },
   "FilamentAlerts": {
     "LowStockThresholdPercent": 20
+  },
+  "MoonrakerPoller": {
+    "Enabled": true,
+    "PollInterval": "00:00:30",
+    "RequestTimeout": "00:00:10"
   }
+}
 }