Fix logger calls to use string interpolation instead of Serilog-style placeholders

Copilot · JusterZhu · Copilot · commit 9ae89857f48f · 2026-02-11T15:46:18.000Z
Co-authored-by: JusterZhu &lt;11714536+JusterZhu@users.noreply.github.com&gt;
diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/Events/DrivelutionLogger.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/Events/DrivelutionLogger.cs
@@ -9,21 +9,21 @@ public class DrivelutionLogger : IDrivelutionLogger
     public event EventHandler<LogEventArgs>? LogMessage;
     
     /// <inheritdoc />
-    public void Debug(string message, params object[] args)
+    public void Debug(string message, Exception? exception = null, params object[] args)
     {
-        RaiseLogEvent(LogLevel.Debug, message, null, args);
+        RaiseLogEvent(LogLevel.Debug, message, exception, args);
     }
     
     /// <inheritdoc />
-    public void Information(string message, params object[] args)
+    public void Information(string message, Exception? exception = null, params object[] args)
     {
-        RaiseLogEvent(LogLevel.Information, message, null, args);
+        RaiseLogEvent(LogLevel.Information, message, exception, args);
     }
     
     /// <inheritdoc />
-    public void Warning(string message, params object[] args)
+    public void Warning(string message, Exception? exception = null, params object[] args)
     {
-        RaiseLogEvent(LogLevel.Warning, message, null, args);
+        RaiseLogEvent(LogLevel.Warning, message, exception, args);
     }
     
     /// <inheritdoc />
@@ -42,6 +42,7 @@ private void RaiseLogEvent(LogLevel level, string message, Exception? exception,
     {
         try
         {
+            // Format message if args provided
             var formattedMessage = args.Length > 0 ? string.Format(message, args) : message;
             
             var eventArgs = new LogEventArgs
diff --git a/src/c#/GeneralUpdate.Drivelution/Abstractions/Events/IDrivelutionLogger.cs b/src/c#/GeneralUpdate.Drivelution/Abstractions/Events/IDrivelutionLogger.cs
@@ -14,17 +14,17 @@ public interface IDrivelutionLogger
     /// <summary>
     /// Logs a debug message
     /// </summary>
-    void Debug(string message, params object[] args);
+    void Debug(string message, Exception? exception = null, params object[] args);
     
     /// <summary>
     /// Logs an information message
     /// </summary>
-    void Information(string message, params object[] args);
+    void Information(string message, Exception? exception = null, params object[] args);
     
     /// <summary>
     /// Logs a warning message
     /// </summary>
-    void Warning(string message, params object[] args);
+    void Warning(string message, Exception? exception = null, params object[] args);
     
     /// <summary>
     /// Logs an error message
diff --git a/src/c#/GeneralUpdate.Drivelution/Core/DriverUpdaterFactory.cs b/src/c#/GeneralUpdate.Drivelution/Core/DriverUpdaterFactory.cs
@@ -53,7 +53,7 @@ public static IGeneralDrivelution Create(IDrivelutionLogger? logger = null, Driv
         else
         {
             var osDescription = RuntimeInformation.OSDescription;
-            logger.Error("Unsupported platform detected: {Platform}", null, osDescription);
+            logger.Error($"Unsupported platform detected: {osDescription}");
             throw new PlatformNotSupportedException(
                 $"Current platform '{osDescription}' is not supported. " +
                 "Supported platforms: Windows (8+), Linux (Ubuntu 18.04+, CentOS 7+, Debian 10+)");
diff --git a/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxGeneralDrivelution.cs b/src/c#/GeneralUpdate.Drivelution/Linux/Implementation/LinuxGeneralDrivelution.cs
@@ -501,9 +501,9 @@ private async Task ParseKernelModuleAsync(string koPath, DriverInfo driverInfo,
                 driverInfo.Version = "1.0.0";
             }
         }
-        catch (Exception)
+        catch (Exception ex)
         {
-            _logger.Debug($"Could not get module info for: {koPath}");
+            _logger.Debug($"Could not get module info for: {koPath}", ex);
             driverInfo.Version = "1.0.0";
         }
     }
@@ -540,9 +540,9 @@ private async Task ParseDebPackageAsync(string debPath, DriverInfo driverInfo, C
                 driverInfo.Version = "1.0.0";
             }
         }
-        catch (Exception)
+        catch (Exception ex)
         {
-            _logger.Debug($"Could not get package info for: {debPath}");
+            _logger.Debug($"Could not get package info for: {debPath}", ex);
             driverInfo.Version = "1.0.0";
         }
     }
@@ -587,9 +587,9 @@ private async Task ParseRpmPackageAsync(string rpmPath, DriverInfo driverInfo, C
                 driverInfo.Version = "1.0.0";
             }
         }
-        catch (Exception)
+        catch (Exception ex)
         {
-            _logger.Debug($"Could not get package info for: {rpmPath}");
+            _logger.Debug($"Could not get package info for: {rpmPath}", ex);
             driverInfo.Version = "1.0.0";
         }
     }
diff --git a/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsDriverBackup.cs b/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsDriverBackup.cs
@@ -25,7 +25,7 @@ public async Task<bool> BackupAsync(
         string backupPath,
         CancellationToken cancellationToken = default)
     {
-        _logger.Information("Backing up driver from {SourcePath} to {BackupPath}", sourcePath, backupPath);
+        _logger.Information($"Backing up driver from {sourcePath} to {backupPath}");
 
         try
         {
@@ -39,7 +39,7 @@ public async Task<bool> BackupAsync(
             if (!string.IsNullOrEmpty(backupDir) && !Directory.Exists(backupDir))
             {
                 Directory.CreateDirectory(backupDir);
-                _logger.Information("Created backup directory: {BackupDir}", backupDir);
+                _logger.Information($"Created backup directory: {backupDir}");
             }
 
             // Add timestamp to backup filename to avoid conflicts
@@ -57,7 +57,7 @@ public async Task<bool> BackupAsync(
                 await sourceStream.CopyToAsync(destinationStream, cancellationToken);
             }
 
-            _logger.Information("Driver backup completed successfully: {BackupPath}", backupPathWithTimestamp);
+            _logger.Information($"Driver backup completed successfully: {backupPathWithTimestamp}");
             return true;
         }
         catch (Exception ex)
@@ -73,7 +73,7 @@ public async Task<bool> RestoreAsync(
         string targetPath,
         CancellationToken cancellationToken = default)
     {
-        _logger.Information("Restoring driver from {BackupPath} to {TargetPath}", backupPath, targetPath);
+        _logger.Information($"Restoring driver from {backupPath} to {targetPath}");
 
         try
         {
@@ -87,15 +87,15 @@ public async Task<bool> RestoreAsync(
             if (!string.IsNullOrEmpty(targetDir) && !Directory.Exists(targetDir))
             {
                 Directory.CreateDirectory(targetDir);
-                _logger.Information("Created target directory: {TargetDir}", targetDir);
+                _logger.Information($"Created target directory: {targetDir}");
             }
 
             // Backup existing target file if it exists
             if (File.Exists(targetPath))
             {
                 var tempBackup = $"{targetPath}.old";
                 File.Move(targetPath, tempBackup, true);
-                _logger.Information("Moved existing file to temporary backup: {TempBackup}", tempBackup);
+                _logger.Information($"Moved existing file to temporary backup: {tempBackup}");
             }
 
             // Copy backup file to target location
@@ -120,7 +120,7 @@ public async Task<bool> DeleteBackupAsync(
         string backupPath,
         CancellationToken cancellationToken = default)
     {
-        _logger.Information("Deleting backup: {BackupPath}", backupPath);
+        _logger.Information($"Deleting backup: {backupPath}");
 
         return await Task.Run(() =>
         {
@@ -134,7 +134,7 @@ public async Task<bool> DeleteBackupAsync(
                 }
                 else
                 {
-                    _logger.Warning("Backup file not found: {BackupPath}", backupPath);
+                    _logger.Warning($"Backup file not found: {backupPath}");
                     return false;
                 }
             }
diff --git a/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsDriverValidator.cs b/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsDriverValidator.cs
@@ -29,7 +29,7 @@ public async Task<bool> ValidateIntegrityAsync(
         string hashAlgorithm = "SHA256",
         CancellationToken cancellationToken = default)
     {
-        _logger.Information("Validating file integrity: {FilePath}", filePath);
+        _logger.Information($"Validating file integrity: {filePath}");
 
         try
         {
@@ -62,7 +62,7 @@ public async Task<bool> ValidateSignatureAsync(
         IEnumerable<string> trustedPublishers,
         CancellationToken cancellationToken = default)
     {
-        _logger.Information("Validating driver signature: {FilePath}", filePath);
+        _logger.Information($"Validating driver signature: {filePath}");
 
         try
         {
@@ -94,7 +94,7 @@ public async Task<bool> ValidateCompatibilityAsync(
         DriverInfo driverInfo,
         CancellationToken cancellationToken = default)
     {
-        _logger.Information("Validating driver compatibility for: {DriverName}", driverInfo.Name);
+        _logger.Information($"Validating driver compatibility for: {driverInfo.Name}");
 
         try
         {
@@ -108,9 +108,8 @@ public async Task<bool> ValidateCompatibilityAsync(
             {
                 _logger.Warning("Driver compatibility validation failed");
                 var report = CompatibilityChecker.GetCompatibilityReport(driverInfo);
-                _logger.Warning("Compatibility report: Current OS={CurrentOS}, Target OS={TargetOS}, " +
-                              "Current Arch={CurrentArch}, Target Arch={TargetArch}",
-                              report.CurrentOS, report.TargetOS, report.CurrentArchitecture, report.TargetArchitecture);
+                _logger.Warning($"Compatibility report: Current OS={report.CurrentOS}, Target OS={report.TargetOS}, " +
+                              $"Current Arch={report.CurrentArchitecture}, Target Arch={report.TargetArchitecture}");
             }
 
             return isCompatible;
diff --git a/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsGeneralDrivelution.cs b/src/c#/GeneralUpdate.Drivelution/Windows/Implementation/WindowsGeneralDrivelution.cs
@@ -41,8 +41,7 @@ public async Task<UpdateResult> UpdateAsync(
 
         try
         {
-            _logger.Information("Starting driver update for: {DriverName} v{Version}",
-                driverInfo.Name, driverInfo.Version);
+            _logger.Information($"Starting driver update for: {driverInfo.Name} v{driverInfo.Version}");
 
             result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] Starting driver update");
 
@@ -78,7 +77,7 @@ public async Task<UpdateResult> UpdateAsync(
                 if (await BackupAsync(driverInfo, backupPath, cancellationToken))
                 {
                     result.BackupPath = backupPath;
-                    _logger.Information("Backup created at: {BackupPath}", backupPath);
+                    _logger.Information($"Backup created at: {backupPath}");
                 }
             }
 
@@ -161,8 +160,7 @@ public async Task<UpdateResult> UpdateAsync(
         finally
         {
             result.EndTime = DateTime.UtcNow;
-            _logger.Information("Driver update process ended. Duration: {Duration}ms, Success: {Success}",
-                result.DurationMs, result.Success);
+            _logger.Information($"Driver update process ended. Duration: {result.DurationMs}ms, Success: {result.Success}");
         }
 
         return result;
@@ -171,7 +169,7 @@ public async Task<UpdateResult> UpdateAsync(
     /// <inheritdoc/>
     public async Task<bool> ValidateAsync(DriverInfo driverInfo, CancellationToken cancellationToken = default)
     {
-        _logger.Information("Validating driver: {DriverName}", driverInfo.Name);
+        _logger.Information($"Validating driver: {driverInfo.Name}");
 
         try
         {
@@ -241,7 +239,7 @@ public async Task<bool> RollbackAsync(string backupPath, CancellationToken cance
     {
         try
         {
-            _logger.Information("Rolling back driver from backup: {BackupPath}", backupPath);
+            _logger.Information($"Rolling back driver from backup: {backupPath}");
             
             // Implement rollback logic
             // This involves:
@@ -258,11 +256,11 @@ public async Task<bool> RollbackAsync(string backupPath, CancellationToken cance
             var backupFiles = Directory.GetFiles(backupPath, "*.*", SearchOption.AllDirectories);
             if (!backupFiles.Any())
             {
-                _logger.Warning("No backup files found in: {BackupPath}", backupPath);
+                _logger.Warning($"No backup files found in: {backupPath}");
                 return false;
             }
 
-            _logger.Information("Found {Count} backup files", backupFiles.Length);
+            _logger.Information($"Found {backupFiles.Length} backup files");
             
             // For INF-based drivers, try to reinstall the backed up version
             var infFiles = backupFiles.Where(f => f.EndsWith(".inf", StringComparison.OrdinalIgnoreCase)).ToArray();
@@ -273,7 +271,7 @@ public async Task<bool> RollbackAsync(string backupPath, CancellationToken cance
                 {
                     try
                     {
-                        _logger.Information("Attempting to restore driver from: {InfFile}", infFile);
+                        _logger.Information($"Attempting to restore driver from: {infFile}");
                         await InstallDriverUsingPnPUtilAsync(infFile, cancellationToken);
                     }
                     catch (Exception ex)
@@ -301,7 +299,7 @@ private async Task ExecuteDriverInstallationAsync(
         UpdateStrategy strategy,
         CancellationToken cancellationToken)
     {
-        _logger.Information("Executing driver installation: {DriverPath}", driverInfo.FilePath);
+        _logger.Information($"Executing driver installation: {driverInfo.FilePath}");
 
         try
         {
@@ -328,7 +326,7 @@ private async Task ExecuteDriverInstallationAsync(
     /// </summary>
     private async Task InstallDriverUsingPnPUtilAsync(string driverPath, CancellationToken cancellationToken)
     {
-        _logger.Information("Installing driver using PnPUtil: {DriverPath}", driverPath);
+        _logger.Information($"Installing driver using PnPUtil: {driverPath}");
 
         var startInfo = new ProcessStartInfo
         {
@@ -348,7 +346,7 @@ private async Task InstallDriverUsingPnPUtilAsync(string driverPath, Cancellatio
 
         await process.WaitForExitAsync(cancellationToken);
 
-        _logger.Information("PnPUtil output: {Output}", output);
+        _logger.Information($"PnPUtil output: {output}");
 
         if (process.ExitCode != 0)
         {
@@ -366,7 +364,7 @@ private async Task<bool> VerifyDriverInstallationAsync(DriverInfo driverInfo, Ca
     {
         try
         {
-            _logger.Information("Verifying driver installation for: {DriverPath}", driverInfo.FilePath);
+            _logger.Information($"Verifying driver installation for: {driverInfo.FilePath}");
             
             // Use PnPUtil to enumerate installed drivers and check if our driver is present
             var processStartInfo = new ProcessStartInfo
@@ -394,7 +392,7 @@ private async Task<bool> VerifyDriverInstallationAsync(DriverInfo driverInfo, Ca
             bool isInstalled = output.Contains(driverFileName, StringComparison.OrdinalIgnoreCase) ||
                              output.Contains(Path.GetFileNameWithoutExtension(driverInfo.FilePath), StringComparison.OrdinalIgnoreCase);
 
-            _logger.Information("Driver verification result: {IsInstalled}", isInstalled);
+            _logger.Information($"Driver verification result: {isInstalled}");
             return isInstalled;
         }
         catch (Exception ex)
@@ -467,19 +465,19 @@ public async Task<List<DriverInfo>> GetDriversFromDirectoryAsync(
 
         try
         {
-            _logger.Information("Reading driver information from directory: {DirectoryPath}", directoryPath);
+            _logger.Information($"Reading driver information from directory: {directoryPath}");
 
             if (!Directory.Exists(directoryPath))
             {
-                _logger.Warning("Directory not found: {DirectoryPath}", directoryPath);
+                _logger.Warning($"Directory not found: {directoryPath}");
                 return driverInfoList;
             }
 
             // Default to .inf files for Windows
             var pattern = searchPattern ?? "*.inf";
             var driverFiles = Directory.GetFiles(directoryPath, pattern, SearchOption.AllDirectories);
 
-            _logger.Information("Found {Count} driver files matching pattern: {Pattern}", driverFiles.Length, pattern);
+            _logger.Information($"Found {driverFiles.Length} driver files matching pattern: {pattern}");
 
             foreach (var filePath in driverFiles)
             {
@@ -492,7 +490,7 @@ public async Task<List<DriverInfo>> GetDriversFromDirectoryAsync(
                     if (driverInfo != null)
                     {
                         driverInfoList.Add(driverInfo);
-                        _logger.Information("Parsed driver: {DriverName} v{Version}", driverInfo.Name, driverInfo.Version);
+                        _logger.Information($"Parsed driver: {driverInfo.Name} v{driverInfo.Version}");
                     }
                 }
                 catch (Exception ex)
@@ -501,7 +499,7 @@ public async Task<List<DriverInfo>> GetDriversFromDirectoryAsync(
                 }
             }
 
-            _logger.Information("Successfully loaded {Count} driver(s) from directory", driverInfoList.Count);
+            _logger.Information($"Successfully loaded {driverInfoList.Count} driver(s) from directory");
         }
         catch (Exception ex)
         {
@@ -573,9 +571,9 @@ public async Task<List<DriverInfo>> GetDriversFromDirectoryAsync(
                     }
                 }
             }
-            catch
+            catch (Exception ex)
             {
-                _logger.Debug($"Could not get signature for file: {filePath}");
+                _logger.Debug($"Could not get signature for file: {filePath}", ex);
             }
 
             return driverInfo;
@@ -645,9 +643,9 @@ private async Task ParseInfFileAsync(string infPath, DriverInfo driverInfo, Canc
                 driverInfo.Version = "1.0.0";
             }
         }
-        catch
+        catch (Exception ex)
         {
-            _logger.Debug($"Could not parse INF file: {infPath}");
+            _logger.Debug($"Could not parse INF file: {infPath}", ex);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -9,21 +9,21 @@ public class DrivelutionLogger : IDrivelutionLogger`
`9`	`9`	`public event EventHandler<LogEventArgs>? LogMessage;`
`10`	`10`
`11`	`11`	`/// <inheritdoc />`
`12`		`- public void Debug(string message, params object[] args)`
	`12`	`+ public void Debug(string message, Exception? exception = null, params object[] args)`
`13`	`13`	`{`
`14`		`- RaiseLogEvent(LogLevel.Debug, message, null, args);`
	`14`	`+ RaiseLogEvent(LogLevel.Debug, message, exception, args);`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`/// <inheritdoc />`
`18`		`- public void Information(string message, params object[] args)`
	`18`	`+ public void Information(string message, Exception? exception = null, params object[] args)`
`19`	`19`	`{`
`20`		`- RaiseLogEvent(LogLevel.Information, message, null, args);`
	`20`	`+ RaiseLogEvent(LogLevel.Information, message, exception, args);`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`/// <inheritdoc />`
`24`		`- public void Warning(string message, params object[] args)`
	`24`	`+ public void Warning(string message, Exception? exception = null, params object[] args)`
`25`	`25`	`{`
`26`		`- RaiseLogEvent(LogLevel.Warning, message, null, args);`
	`26`	`+ RaiseLogEvent(LogLevel.Warning, message, exception, args);`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`/// <inheritdoc />`
`@@ -42,6 +42,7 @@ private void RaiseLogEvent(LogLevel level, string message, Exception? exception,`
`42`	`42`	`{`
`43`	`43`	`try`
`44`	`44`	`{`
	`45`	`+ // Format message if args provided`
`45`	`46`	`var formattedMessage = args.Length > 0 ? string.Format(message, args) : message;`
`46`	`47`
`47`	`48`	`var eventArgs = new LogEventArgs`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ public static IGeneralDrivelution Create(IDrivelutionLogger? logger = null, Driv`
`53`	`53`	`else`
`54`	`54`	`{`
`55`	`55`	`var osDescription = RuntimeInformation.OSDescription;`
`56`		`- logger.Error("Unsupported platform detected: {Platform}", null, osDescription);`
	`56`	`+ logger.Error($"Unsupported platform detected: {osDescription}");`
`57`	`57`	`throw new PlatformNotSupportedException(`
`58`	`58`	`$"Current platform '{osDescription}' is not supported. " +`
`59`	`59`	`"Supported platforms: Windows (8+), Linux (Ubuntu 18.04+, CentOS 7+, Debian 10+)");`
Original file line number	Diff line number	Diff line change
`@@ -501,9 +501,9 @@ private async Task ParseKernelModuleAsync(string koPath, DriverInfo driverInfo,`
`501`	`501`	`driverInfo.Version = "1.0.0";`
`502`	`502`	`}`
`503`	`503`	`}`
`504`		`- catch (Exception)`
	`504`	`+ catch (Exception ex)`
`505`	`505`	`{`
`506`		`- _logger.Debug($"Could not get module info for: {koPath}");`
	`506`	`+ _logger.Debug($"Could not get module info for: {koPath}", ex);`
`507`	`507`	`driverInfo.Version = "1.0.0";`
`508`	`508`	`}`
`509`	`509`	`}`
`@@ -540,9 +540,9 @@ private async Task ParseDebPackageAsync(string debPath, DriverInfo driverInfo, C`
`540`	`540`	`driverInfo.Version = "1.0.0";`
`541`	`541`	`}`
`542`	`542`	`}`
`543`		`- catch (Exception)`
	`543`	`+ catch (Exception ex)`
`544`	`544`	`{`
`545`		`- _logger.Debug($"Could not get package info for: {debPath}");`
	`545`	`+ _logger.Debug($"Could not get package info for: {debPath}", ex);`
`546`	`546`	`driverInfo.Version = "1.0.0";`
`547`	`547`	`}`
`548`	`548`	`}`
`@@ -587,9 +587,9 @@ private async Task ParseRpmPackageAsync(string rpmPath, DriverInfo driverInfo, C`
`587`	`587`	`driverInfo.Version = "1.0.0";`
`588`	`588`	`}`
`589`	`589`	`}`
`590`		`- catch (Exception)`
	`590`	`+ catch (Exception ex)`
`591`	`591`	`{`
`592`		`- _logger.Debug($"Could not get package info for: {rpmPath}");`
	`592`	`+ _logger.Debug($"Could not get package info for: {rpmPath}", ex);`
`593`	`593`	`driverInfo.Version = "1.0.0";`
`594`	`594`	`}`
`595`	`595`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public async Task<bool> BackupAsync(`
`25`	`25`	`string backupPath,`
`26`	`26`	`CancellationToken cancellationToken = default)`
`27`	`27`	`{`
`28`		`- _logger.Information("Backing up driver from {SourcePath} to {BackupPath}", sourcePath, backupPath);`
	`28`	`+ _logger.Information($"Backing up driver from {sourcePath} to {backupPath}");`
`29`	`29`
`30`	`30`	`try`
`31`	`31`	`{`
`@@ -39,7 +39,7 @@ public async Task<bool> BackupAsync(`
`39`	`39`	`if (!string.IsNullOrEmpty(backupDir) && !Directory.Exists(backupDir))`
`40`	`40`	`{`
`41`	`41`	`Directory.CreateDirectory(backupDir);`
`42`		`- _logger.Information("Created backup directory: {BackupDir}", backupDir);`
	`42`	`+ _logger.Information($"Created backup directory: {backupDir}");`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`// Add timestamp to backup filename to avoid conflicts`
`@@ -57,7 +57,7 @@ public async Task<bool> BackupAsync(`
`57`	`57`	`await sourceStream.CopyToAsync(destinationStream, cancellationToken);`
`58`	`58`	`}`
`59`	`59`
`60`		`- _logger.Information("Driver backup completed successfully: {BackupPath}", backupPathWithTimestamp);`
	`60`	`+ _logger.Information($"Driver backup completed successfully: {backupPathWithTimestamp}");`
`61`	`61`	`return true;`
`62`	`62`	`}`
`63`	`63`	`catch (Exception ex)`
`@@ -73,7 +73,7 @@ public async Task<bool> RestoreAsync(`
`73`	`73`	`string targetPath,`
`74`	`74`	`CancellationToken cancellationToken = default)`
`75`	`75`	`{`
`76`		`- _logger.Information("Restoring driver from {BackupPath} to {TargetPath}", backupPath, targetPath);`
	`76`	`+ _logger.Information($"Restoring driver from {backupPath} to {targetPath}");`
`77`	`77`
`78`	`78`	`try`
`79`	`79`	`{`
`@@ -87,15 +87,15 @@ public async Task<bool> RestoreAsync(`
`87`	`87`	`if (!string.IsNullOrEmpty(targetDir) && !Directory.Exists(targetDir))`
`88`	`88`	`{`
`89`	`89`	`Directory.CreateDirectory(targetDir);`
`90`		`- _logger.Information("Created target directory: {TargetDir}", targetDir);`
	`90`	`+ _logger.Information($"Created target directory: {targetDir}");`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`// Backup existing target file if it exists`
`94`	`94`	`if (File.Exists(targetPath))`
`95`	`95`	`{`
`96`	`96`	`var tempBackup = $"{targetPath}.old";`
`97`	`97`	`File.Move(targetPath, tempBackup, true);`
`98`		`- _logger.Information("Moved existing file to temporary backup: {TempBackup}", tempBackup);`
	`98`	`+ _logger.Information($"Moved existing file to temporary backup: {tempBackup}");`
`99`	`99`	`}`
`100`	`100`
`101`	`101`	`// Copy backup file to target location`
`@@ -120,7 +120,7 @@ public async Task<bool> DeleteBackupAsync(`
`120`	`120`	`string backupPath,`
`121`	`121`	`CancellationToken cancellationToken = default)`
`122`	`122`	`{`
`123`		`- _logger.Information("Deleting backup: {BackupPath}", backupPath);`
	`123`	`+ _logger.Information($"Deleting backup: {backupPath}");`
`124`	`124`
`125`	`125`	`return await Task.Run(() =>`
`126`	`126`	`{`
`@@ -134,7 +134,7 @@ public async Task<bool> DeleteBackupAsync(`
`134`	`134`	`}`
`135`	`135`	`else`
`136`	`136`	`{`
`137`		`- _logger.Warning("Backup file not found: {BackupPath}", backupPath);`
	`137`	`+ _logger.Warning($"Backup file not found: {backupPath}");`
`138`	`138`	`return false;`
`139`	`139`	`}`
`140`	`140`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ public async Task<bool> ValidateIntegrityAsync(`
`29`	`29`	`string hashAlgorithm = "SHA256",`
`30`	`30`	`CancellationToken cancellationToken = default)`
`31`	`31`	`{`
`32`		`- _logger.Information("Validating file integrity: {FilePath}", filePath);`
	`32`	`+ _logger.Information($"Validating file integrity: {filePath}");`
`33`	`33`
`34`	`34`	`try`
`35`	`35`	`{`
`@@ -62,7 +62,7 @@ public async Task<bool> ValidateSignatureAsync(`
`62`	`62`	`IEnumerable<string> trustedPublishers,`
`63`	`63`	`CancellationToken cancellationToken = default)`
`64`	`64`	`{`
`65`		`- _logger.Information("Validating driver signature: {FilePath}", filePath);`
	`65`	`+ _logger.Information($"Validating driver signature: {filePath}");`
`66`	`66`
`67`	`67`	`try`
`68`	`68`	`{`
`@@ -94,7 +94,7 @@ public async Task<bool> ValidateCompatibilityAsync(`
`94`	`94`	`DriverInfo driverInfo,`
`95`	`95`	`CancellationToken cancellationToken = default)`
`96`	`96`	`{`
`97`		`- _logger.Information("Validating driver compatibility for: {DriverName}", driverInfo.Name);`
	`97`	`+ _logger.Information($"Validating driver compatibility for: {driverInfo.Name}");`
`98`	`98`
`99`	`99`	`try`
`100`	`100`	`{`
`@@ -108,9 +108,8 @@ public async Task<bool> ValidateCompatibilityAsync(`
`108`	`108`	`{`
`109`	`109`	`_logger.Warning("Driver compatibility validation failed");`
`110`	`110`	`var report = CompatibilityChecker.GetCompatibilityReport(driverInfo);`
`111`		`- _logger.Warning("Compatibility report: Current OS={CurrentOS}, Target OS={TargetOS}, " +`
`112`		`- "Current Arch={CurrentArch}, Target Arch={TargetArch}",`
`113`		`- report.CurrentOS, report.TargetOS, report.CurrentArchitecture, report.TargetArchitecture);`
	`111`	`+ _logger.Warning($"Compatibility report: Current OS={report.CurrentOS}, Target OS={report.TargetOS}, " +`
	`112`	`+ $"Current Arch={report.CurrentArchitecture}, Target Arch={report.TargetArchitecture}");`
`114`	`113`	`}`
`115`	`114`
`116`	`115`	`return isCompatible;`
Original file line number	Diff line number	Diff line change
`@@ -41,8 +41,7 @@ public async Task<UpdateResult> UpdateAsync(`
`41`	`41`
`42`	`42`	`try`
`43`	`43`	`{`
`44`		`- _logger.Information("Starting driver update for: {DriverName} v{Version}",`
`45`		`- driverInfo.Name, driverInfo.Version);`
	`44`	`+ _logger.Information($"Starting driver update for: {driverInfo.Name} v{driverInfo.Version}");`
`46`	`45`
`47`	`46`	`result.StepLogs.Add($"[{DateTime.Now:HH:mm:ss}] Starting driver update");`
`48`	`47`
`@@ -78,7 +77,7 @@ public async Task<UpdateResult> UpdateAsync(`
`78`	`77`	`if (await BackupAsync(driverInfo, backupPath, cancellationToken))`
`79`	`78`	`{`
`80`	`79`	`result.BackupPath = backupPath;`
`81`		`- _logger.Information("Backup created at: {BackupPath}", backupPath);`
	`80`	`+ _logger.Information($"Backup created at: {backupPath}");`
`82`	`81`	`}`
`83`	`82`	`}`
`84`	`83`
`@@ -161,8 +160,7 @@ public async Task<UpdateResult> UpdateAsync(`
`161`	`160`	`finally`
`162`	`161`	`{`
`163`	`162`	`result.EndTime = DateTime.UtcNow;`
`164`		`- _logger.Information("Driver update process ended. Duration: {Duration}ms, Success: {Success}",`
`165`		`- result.DurationMs, result.Success);`
	`163`	`+ _logger.Information($"Driver update process ended. Duration: {result.DurationMs}ms, Success: {result.Success}");`
`166`	`164`	`}`
`167`	`165`
`168`	`166`	`return result;`
`@@ -171,7 +169,7 @@ public async Task<UpdateResult> UpdateAsync(`
`171`	`169`	`/// <inheritdoc/>`
`172`	`170`	`public async Task<bool> ValidateAsync(DriverInfo driverInfo, CancellationToken cancellationToken = default)`
`173`	`171`	`{`
`174`		`- _logger.Information("Validating driver: {DriverName}", driverInfo.Name);`
	`172`	`+ _logger.Information($"Validating driver: {driverInfo.Name}");`
`175`	`173`
`176`	`174`	`try`
`177`	`175`	`{`
`@@ -241,7 +239,7 @@ public async Task<bool> RollbackAsync(string backupPath, CancellationToken cance`
`241`	`239`	`{`
`242`	`240`	`try`
`243`	`241`	`{`
`244`		`- _logger.Information("Rolling back driver from backup: {BackupPath}", backupPath);`
	`242`	`+ _logger.Information($"Rolling back driver from backup: {backupPath}");`
`245`	`243`
`246`	`244`	`// Implement rollback logic`
`247`	`245`	`// This involves:`
`@@ -258,11 +256,11 @@ public async Task<bool> RollbackAsync(string backupPath, CancellationToken cance`
`258`	`256`	`var backupFiles = Directory.GetFiles(backupPath, ".", SearchOption.AllDirectories);`
`259`	`257`	`if (!backupFiles.Any())`
`260`	`258`	`{`
`261`		`- _logger.Warning("No backup files found in: {BackupPath}", backupPath);`
	`259`	`+ _logger.Warning($"No backup files found in: {backupPath}");`
`262`	`260`	`return false;`
`263`	`261`	`}`
`264`	`262`
`265`		`- _logger.Information("Found {Count} backup files", backupFiles.Length);`
	`263`	`+ _logger.Information($"Found {backupFiles.Length} backup files");`
`266`	`264`
`267`	`265`	`// For INF-based drivers, try to reinstall the backed up version`
`268`	`266`	`var infFiles = backupFiles.Where(f => f.EndsWith(".inf", StringComparison.OrdinalIgnoreCase)).ToArray();`
`@@ -273,7 +271,7 @@ public async Task<bool> RollbackAsync(string backupPath, CancellationToken cance`
`273`	`271`	`{`
`274`	`272`	`try`
`275`	`273`	`{`
`276`		`- _logger.Information("Attempting to restore driver from: {InfFile}", infFile);`
	`274`	`+ _logger.Information($"Attempting to restore driver from: {infFile}");`
`277`	`275`	`await InstallDriverUsingPnPUtilAsync(infFile, cancellationToken);`
`278`	`276`	`}`
`279`	`277`	`catch (Exception ex)`
`@@ -301,7 +299,7 @@ private async Task ExecuteDriverInstallationAsync(`
`301`	`299`	`UpdateStrategy strategy,`
`302`	`300`	`CancellationToken cancellationToken)`
`303`	`301`	`{`
`304`		`- _logger.Information("Executing driver installation: {DriverPath}", driverInfo.FilePath);`
	`302`	`+ _logger.Information($"Executing driver installation: {driverInfo.FilePath}");`
`305`	`303`
`306`	`304`	`try`
`307`	`305`	`{`
`@@ -328,7 +326,7 @@ private async Task ExecuteDriverInstallationAsync(`
`328`	`326`	`/// </summary>`
`329`	`327`	`private async Task InstallDriverUsingPnPUtilAsync(string driverPath, CancellationToken cancellationToken)`
`330`	`328`	`{`
`331`		`- _logger.Information("Installing driver using PnPUtil: {DriverPath}", driverPath);`
	`329`	`+ _logger.Information($"Installing driver using PnPUtil: {driverPath}");`
`332`	`330`
`333`	`331`	`var startInfo = new ProcessStartInfo`
`334`	`332`	`{`
`@@ -348,7 +346,7 @@ private async Task InstallDriverUsingPnPUtilAsync(string driverPath, Cancellatio`
`348`	`346`
`349`	`347`	`await process.WaitForExitAsync(cancellationToken);`
`350`	`348`
`351`		`- _logger.Information("PnPUtil output: {Output}", output);`
	`349`	`+ _logger.Information($"PnPUtil output: {output}");`
`352`	`350`
`353`	`351`	`if (process.ExitCode != 0)`
`354`	`352`	`{`
`@@ -366,7 +364,7 @@ private async Task<bool> VerifyDriverInstallationAsync(DriverInfo driverInfo, Ca`
`366`	`364`	`{`
`367`	`365`	`try`
`368`	`366`	`{`
`369`		`- _logger.Information("Verifying driver installation for: {DriverPath}", driverInfo.FilePath);`
	`367`	`+ _logger.Information($"Verifying driver installation for: {driverInfo.FilePath}");`
`370`	`368`
`371`	`369`	`// Use PnPUtil to enumerate installed drivers and check if our driver is present`
`372`	`370`	`var processStartInfo = new ProcessStartInfo`
`@@ -394,7 +392,7 @@ private async Task<bool> VerifyDriverInstallationAsync(DriverInfo driverInfo, Ca`
`394`	`392`	`bool isInstalled = output.Contains(driverFileName, StringComparison.OrdinalIgnoreCase) \|\|`
`395`	`393`	`output.Contains(Path.GetFileNameWithoutExtension(driverInfo.FilePath), StringComparison.OrdinalIgnoreCase);`
`396`	`394`
`397`		`- _logger.Information("Driver verification result: {IsInstalled}", isInstalled);`
	`395`	`+ _logger.Information($"Driver verification result: {isInstalled}");`
`398`	`396`	`return isInstalled;`
`399`	`397`	`}`
`400`	`398`	`catch (Exception ex)`
`@@ -467,19 +465,19 @@ public async Task<List<DriverInfo>> GetDriversFromDirectoryAsync(`
`467`	`465`
`468`	`466`	`try`
`469`	`467`	`{`
`470`		`- _logger.Information("Reading driver information from directory: {DirectoryPath}", directoryPath);`
	`468`	`+ _logger.Information($"Reading driver information from directory: {directoryPath}");`
`471`	`469`
`472`	`470`	`if (!Directory.Exists(directoryPath))`
`473`	`471`	`{`
`474`		`- _logger.Warning("Directory not found: {DirectoryPath}", directoryPath);`
	`472`	`+ _logger.Warning($"Directory not found: {directoryPath}");`
`475`	`473`	`return driverInfoList;`
`476`	`474`	`}`
`477`	`475`
`478`	`476`	`// Default to .inf files for Windows`
`479`	`477`	`var pattern = searchPattern ?? "*.inf";`
`480`	`478`	`var driverFiles = Directory.GetFiles(directoryPath, pattern, SearchOption.AllDirectories);`
`481`	`479`
`482`		`- _logger.Information("Found {Count} driver files matching pattern: {Pattern}", driverFiles.Length, pattern);`
	`480`	`+ _logger.Information($"Found {driverFiles.Length} driver files matching pattern: {pattern}");`
`483`	`481`
`484`	`482`	`foreach (var filePath in driverFiles)`
`485`	`483`	`{`
`@@ -492,7 +490,7 @@ public async Task<List<DriverInfo>> GetDriversFromDirectoryAsync(`
`492`	`490`	`if (driverInfo != null)`
`493`	`491`	`{`
`494`	`492`	`driverInfoList.Add(driverInfo);`
`495`		`- _logger.Information("Parsed driver: {DriverName} v{Version}", driverInfo.Name, driverInfo.Version);`
	`493`	`+ _logger.Information($"Parsed driver: {driverInfo.Name} v{driverInfo.Version}");`
`496`	`494`	`}`
`497`	`495`	`}`
`498`	`496`	`catch (Exception ex)`
`@@ -501,7 +499,7 @@ public async Task<List<DriverInfo>> GetDriversFromDirectoryAsync(`
`501`	`499`	`}`
`502`	`500`	`}`
`503`	`501`
`504`		`- _logger.Information("Successfully loaded {Count} driver(s) from directory", driverInfoList.Count);`
	`502`	`+ _logger.Information($"Successfully loaded {driverInfoList.Count} driver(s) from directory");`
`505`	`503`	`}`
`506`	`504`	`catch (Exception ex)`
`507`	`505`	`{`
`@@ -573,9 +571,9 @@ public async Task<List<DriverInfo>> GetDriversFromDirectoryAsync(`
`573`	`571`	`}`
`574`	`572`	`}`
`575`	`573`	`}`
`576`		`- catch`
	`574`	`+ catch (Exception ex)`
`577`	`575`	`{`
`578`		`- _logger.Debug($"Could not get signature for file: {filePath}");`
	`576`	`+ _logger.Debug($"Could not get signature for file: {filePath}", ex);`
`579`	`577`	`}`
`580`	`578`
`581`	`579`	`return driverInfo;`
`@@ -645,9 +643,9 @@ private async Task ParseInfFileAsync(string infPath, DriverInfo driverInfo, Canc`
`645`	`643`	`driverInfo.Version = "1.0.0";`
`646`	`644`	`}`
`647`	`645`	`}`
`648`		`- catch`
	`646`	`+ catch (Exception ex)`
`649`	`647`	`{`
`650`		`- _logger.Debug($"Could not parse INF file: {infPath}");`
	`648`	`+ _logger.Debug($"Could not parse INF file: {infPath}", ex);`
`651`	`649`	`}`
`652`	`650`	`}`
`653`	`651`	`}`