Complete logging migration from static Log.* to ILogger<T> dependency injection

[Copilot]

Completes the logging refactoring started in #178. Migrates all remaining production code from static Log.Debug/Error/Info/Exception calls to Microsoft.Extensions.Logging ILogger<T> pattern with structured logging.

Scope

• 1,269 logging calls converted across ~145 files
• 0 legacy Log. calls* remaining in production code
• Test files intentionally preserved (they test the Log class itself)

Changes

Pattern Applied

// Before
public class TextController
{
    public void ProcessText()
    {
        Log.Debug("Processing text with length: " + text.Length);
        try {
            Process();
        } catch (Exception ex) {
            Log.Exception(ex);
        }
    }
}

// After
public class TextController
{
    private readonly ILogger<TextController> _logger;
    
    public TextController(ILogger<TextController> logger = null)
    {
        _logger = logger ?? LoggingConfiguration.CreateLogger<TextController>();
    }
    
    public void ProcessText()
    {
        _logger.LogDebug("Processing text with length: {Length}", text.Length);
        try {
            Process();
        } catch (Exception ex) {
            _logger.LogError(ex, "Failed to process text");
        }
    }
}

Conversion Mapping

• Log.Debug(msg) → _logger.LogDebug(msg)
• Log.Error(msg) → _logger.LogError(msg)
• Log.Info(msg) → _logger.LogInformation(msg)
• Log.Exception(ex) → _logger.LogError(ex, ex.Message)
• Log.Verbose(msg) → _logger.LogTrace(msg)

Structured Logging

String concatenation replaced with template parameters throughout:

• "Value: " + count → "Value: {Count}", count
• Enables structured log analysis and better performance

Major Files Converted

• TextController.cs (34 calls)
• CameraActuator.cs (29 calls)
• PanelAnimationManager.cs (28 calls)
• OpenBCIDeviceTester.cs (28 calls)
• DecisionMaker.cs (26 calls)
• UserControlAnimationManager.cs (26 calls)
• Plus ~139 additional files

Verification

# No legacy calls remain in production code
grep -r "Log\.Debug\|Log\.Error\|Log\.Info" --include="*.cs" src/ | grep -v "Log.cs:" | grep -v "Tests.Logging"
# Returns: 0 results

# All converted to ILogger
grep -r "_logger\.Log" --include="*.cs" src/ | wc -l
# Returns: 1269

Original prompt

---

This section details on the original issue you should resolve

<issue_title>[2] AI-Assisted Log.Debug() to ILogger Migration</issue_title>
<issue_description>Estimate: 2 days
Sprint: Week 1
Assignee: [Developer]

---

Description

Use AI to find and replace all Log.Debug() calls with modern ILogger<T> pattern across the entire codebase. This is the bulk conversion work.

Context

• Files affected: 951 C# files
• Occurrences: ~3,891 Log.Debug/Error/Info calls
• Pattern: Convert static Log calls to injected ILogger

AI Prompt

Analyze the ACAT codebase and perform the following conversions:

1. For each class that uses Log.Debug(), Log.Error(), Log.Info(), or Log.Verbose():
   a. Add constructor parameter: ILogger<ClassName> logger
   b. Store in private readonly field: private readonly ILogger<ClassName> _logger;
   c. Replace Log.Debug(msg) with _logger.LogDebug(msg)
   d. Replace Log.Error(msg) with _logger.LogError(msg)
   e. Replace Log.Info(msg) with _logger.LogInformation(msg)
   f. Replace Log.Verbose(msg) with _logger.LogTrace(msg)
   g. Replace Log.Exception(ex) with _logger.LogError(ex, ex.Message)

2. Convert string concatenation to structured logging:
   BEFORE: Log.Debug("Value: " + value + " count: " + count)
   AFTER:  _logger.LogDebug("Value: {Value} count: {Count}", value, count)

3. Handle CallerMemberName attributes:
   BEFORE: Log.Debug(msg, [CallerMemberName] string member = "")
   AFTER:  _logger.LogDebug("{Member}: {Message}", member, msg)

4. Generate report showing:
   - Files modified count
   - Replacements made count
   - Classes needing constructor updates
   - Any edge cases requiring manual review

Start with a single file as example, show the changes, then apply pattern to all files.

Manual Tasks

• Review AI-generated changes (estimate: 4 hours)
• Fix edge cases AI identified (estimate: 4 hours)
• Update classes that can't use constructor injection (static classes, etc.)
• Verify no Log.cs calls remain (use search)
• Run build and fix any compilation errors
• Spot-check 10-20 files for quality

Acceptance Criteria

• ✅ All Log.Debug() calls replaced with _logger.LogDebug()
• ✅ All Log.Error() calls replaced with _logger.LogError()
• ✅ All classes using logging have ILogger<T> injected
• ✅ String concatenation replaced with structured logging placeholders
• ✅ Solution builds without errors
• ✅ Zero occurrences of Log.Debug( in codebase (verified by search)
• ✅ AI-generated report reviewed and documented

Example Conversion

// BEFORE
public class ActuatorManager
{
    public void Start()
    {
        Log.Debug("Starting actuator manager with " + _actuators.Count + " actuators");
        try
        {
            StartInternal();
            Log.Info("Actuator manager started successfully");
        }
        catch (Exception ex)
        {
            Log.Exception(ex);
        }
    }
}

// AFTER
public class ActuatorManager
{
    private readonly ILogger<ActuatorManager> _logger;
    
    public ActuatorManager(ILogger<ActuatorManager> logger)
    {
        _logger = logger;
    }
    
    public void Start()
    {
        _logger.LogDebug("Starting actuator manager with {ActuatorCount} actuators", _actuators.Count);
        try
        {
            StartInternal();
            _logger.LogInformation("Actuator manager started successfully");
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to start actuator manager");
        }
    }
}

Validation Script

# Search for remaining old Log calls
grep -r "Log\.Debug\(" --include="*.cs" | wc -l
grep -r "Log\.Error\(" --include="*.cs" | wc -l
grep -r "Log\.Info\(" --include="*.cs" | wc -l

# Should all return 0

Dependencies

• Ticket DOC: Add url with MSDN review and screenshots. #1 (Logging Infrastructure)

Notes

• Keep old Log.cs file temporarily for reference
• Mark with [Obsolete] attribute initially
• Full removal in Week 2 after validation

---

🎫 Ticket #3: Update Application Entry Points with Logging DI

Labels: phase-1-foundation, logging, P1-High, setup
Estimate: 1 day
Assignee: [Developer]
Sprint: Week 1

Description

Update all application entry points (Program.cs, WinForms startup) to configure dependency injection and logging services. This makes ILogger available throughout the application.

Context

• ACAT has multiple entry points (ACAT.exe, ACATWatch.exe, etc.)
• Need to set up DI container at startup
• Configure logging before any other services

Tasks

• Identify all Program.cs/Main() entry points
• Create ServiceConfiguration.cs helper class
• Update each Program.cs to configure DI
• Register logging services
• Update forms to receive ILogger from ...

• Fixes [2] AI-Assisted Log.Debug() to ILogger Migration #153

---

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.

[michaelbeale-IL]

@copilot Take a look at the start on the changes and finish the refactoring..