dependabot-nuget 0.288.0 → 0.289.0

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/SdkProjectDiscovery.cs

@@ -36,6 +36,14 @@ internal static class SdkProjectDiscovery
         "NETStandard.Library"
     };
 
+    // these are additional files that are relevant to the project and need to be reported
+    private static readonly HashSet<string> AdditionalFileNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+        "packages.config",
+        "app.config",
+        "web.config",
+    };
+
     public static async Task<ImmutableArray<ProjectDiscoveryResult>> DiscoverAsync(string repoRootPath, string workspacePath, string startingProjectPath, ExperimentsManager experimentsManager, ILogger logger)
     {
         if (experimentsManager.UseDirectDiscovery)
@@ -73,6 +81,9 @@ internal static class SdkProjectDiscovery
         Dictionary<string, HashSet<string>> referencedProjects = new(PathComparer.Instance);
         //         projectPath, referencedProjects
 
+        Dictionary<string, HashSet<string>> additionalFiles = new(PathComparer.Instance);
+        //         projectPath, additionalFiles
+
         var tfms = await MSBuildHelper.GetTargetFrameworkValuesFromProject(repoRootPath, startingProjectPath, logger);
         foreach (var tfm in tfms)
         {
@@ -106,7 +117,7 @@ internal static class SdkProjectDiscovery
                 if (exitCode != 0)
                 {
                     // log error, but still try to resolve what we can
-                    logger.Log($"  Error determining dependencies from `{startingProjectPath}`:\nSTDOUT:\n{stdOut}\nSTDERR:\n{stdErr}");
+                    logger.Warn($"  Error determining dependencies from `{startingProjectPath}`:\nSTDOUT:\n{stdOut}\nSTDERR:\n{stdErr}");
                 }
 
                 var buildRoot = BinaryLog.ReadBuild(binLogPath);
@@ -154,17 +165,39 @@ internal static class SdkProjectDiscovery
                         case NamedNode namedNode when namedNode is AddItem or RemoveItem:
                             ProcessResolvedPackageReference(namedNode, packagesPerProject, topLevelPackagesPerProject);
 
-                            // maintain list of project references
-                            if (namedNode is AddItem addItem && addItem.Name == "ProjectReference")
+                            if (namedNode is AddItem addItem)
                             {
-                                var projectEvaluation = GetNearestProjectEvaluation(addItem);
-                                if (projectEvaluation is not null)
+                                // maintain list of project references
+                                if (addItem.Name.Equals("ProjectReference", StringComparison.OrdinalIgnoreCase))
+                                {
+                                    var projectEvaluation = GetNearestProjectEvaluation(addItem);
+                                    if (projectEvaluation is not null)
+                                    {
+                                        foreach (var referencedProject in addItem.Children.OfType<Item>())
+                                        {
+                                            var referencedProjectPaths = referencedProjects.GetOrAdd(projectEvaluation.ProjectFile, () => new(PathComparer.Instance));
+                                            var referencedProjectPath = new FileInfo(Path.Combine(Path.GetDirectoryName(projectEvaluation.ProjectFile)!, referencedProject.Name)).FullName;
+                                            referencedProjectPaths.Add(referencedProjectPath);
+                                        }
+                                    }
+                                }
+
+                                // maintain list of additional files
+                                if (addItem.Name.Equals("None", StringComparison.OrdinalIgnoreCase) ||
+                                    addItem.Name.Equals("Content", StringComparison.OrdinalIgnoreCase))
                                 {
-                                    foreach (var referencedProject in addItem.Children.OfType<Item>())
+                                    var projectEvaluation = GetNearestProjectEvaluation(addItem);
+                                    if (projectEvaluation is not null)
                                     {
-                                        var referencedProjectPaths = referencedProjects.GetOrAdd(projectEvaluation.ProjectFile, () => new(PathComparer.Instance));
-                                        var referencedProjectPath = new FileInfo(Path.Combine(Path.GetDirectoryName(projectEvaluation.ProjectFile)!, referencedProject.Name)).FullName;
-                                        referencedProjectPaths.Add(referencedProjectPath);
+                                        foreach (var additionalItem in addItem.Children.OfType<Item>())
+                                        {
+                                            if (AdditionalFileNames.Contains(additionalItem.Name))
+                                            {
+                                                var additionalFilesForProject = additionalFiles.GetOrAdd(projectEvaluation.ProjectFile, () => new(PathComparer.Instance));
+                                                var additionalFilePath = new FileInfo(Path.Combine(Path.GetDirectoryName(projectEvaluation.ProjectFile)!, additionalItem.Name)).FullName;
+                                                additionalFilesForProject.Add(additionalFilePath);
+                                            }
+                                        }
                                     }
                                 }
                             }
@@ -220,11 +253,18 @@ internal static class SdkProjectDiscovery
                 .Select(pkvp => new Property(pkvp.Key, pkvp.Value, Path.GetRelativePath(repoRootPath, projectPath).NormalizePathToUnix()))
                 .OrderBy(p => p.Name)
                 .ToImmutableArray();
-            var referenced = referencedProjects.GetOrAdd(projectPath, () => new(StringComparer.OrdinalIgnoreCase))
+            var referenced = referencedProjects.GetOrAdd(projectPath, () => new(PathComparer.Instance))
                 .Select(p => Path.GetRelativePath(projectFullDirectory, p).NormalizePathToUnix())
                 .OrderBy(p => p)
                 .ToImmutableArray();
-            var imported = importedFiles.GetOrAdd(projectPath, () => new(StringComparer.OrdinalIgnoreCase))
+            var imported = importedFiles.GetOrAdd(projectPath, () => new(PathComparer.Instance))
+                .Select(p => Path.GetRelativePath(projectFullDirectory, p))
+                .Select(p => p.NormalizePathToUnix())
+                .OrderBy(p => p)
+                .ToImmutableArray();
+            var additionalFromLocation = ProjectHelper.GetAdditionalFilesFromProjectLocation(projectPath, ProjectHelper.PathFormat.Full);
+            var additional = additionalFiles.GetOrAdd(projectPath, () => new(PathComparer.Instance))
+                .Concat(additionalFromLocation)
                 .Select(p => Path.GetRelativePath(projectFullDirectory, p))
                 .Select(p => p.NormalizePathToUnix())
                 .OrderBy(p => p)
@@ -238,6 +278,7 @@ internal static class SdkProjectDiscovery
                 Properties = properties,
                 ReferencedProjectPaths = referenced,
                 ImportedFiles = imported,
+                AdditionalFiles = additional,
             };
         }).ToImmutableArray();
         return projectDiscoveryResults;
@@ -448,6 +489,7 @@ internal static class SdkProjectDiscovery
                         Path.Join(Path.GetDirectoryName(buildFile.Path), "obj"),
                     };
                     var projectDirectory = Path.GetDirectoryName(buildFile.Path)!;
+                    var additionalFiles = ProjectHelper.GetAllAdditionalFilesFromProject(buildFile.Path, ProjectHelper.PathFormat.Relative);
                     results.Add(new()
                     {
                         FilePath = Path.GetRelativePath(workspacePath, buildFile.Path).NormalizePathToUnix(),
@@ -463,6 +505,7 @@ internal static class SdkProjectDiscovery
                             .Where(b => !intermediateDirectories.Any(i => PathHelper.IsFileUnderDirectory(new DirectoryInfo(i), new FileInfo(b.Path))))
                             .Select(b => Path.GetRelativePath(projectDirectory, b.Path).NormalizePathToUnix())
                             .ToImmutableArray(),
+                        AdditionalFiles = additionalFiles,
                     });
                 }
             }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Discover/WorkspaceDiscoveryResult.cs

@@ -7,7 +7,6 @@ public sealed record WorkspaceDiscoveryResult : NativeResult
     public required string Path { get; init; }
     public bool IsSuccess { get; init; } = true;
     public ImmutableArray<ProjectDiscoveryResult> Projects { get; init; }
-    public ImmutableArray<string> ImportedFiles { get; init; } = [];
     public GlobalJsonDiscoveryResult? GlobalJson { get; init; }
     public DotNetToolsJsonDiscoveryResult? DotNetToolsJson { get; init; }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/ExperimentsManager.cs

@@ -37,8 +37,7 @@ public record ExperimentsManager
         }
         catch (JsonException ex)
         {
-            // the following message has been specifically designed to match the format of `Dependabot.logger.info(...)` from Ruby
-            logger.Log($"{DateTime.UtcNow:yyyy/MM/dd HH:mm:ss} INFO Error deserializing job file: {ex.ToString()}: {jobFileContent}");
+            logger.Info($"Error deserializing job file: {ex.ToString()}: {jobFileContent}");
             return new ExperimentsManager();
         }
     }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Files/JsonBuildFile.cs

@@ -39,7 +39,7 @@ internal abstract class JsonBuildFile : BuildFile<string>
             {
                 // We can't police that people have legal JSON files.
                 // If they don't, we just return null.
-                logger.Log($"Failed to parse JSON file: {RelativePath}, got {ex}");
+                logger.Warn($"Failed to parse JSON file: {RelativePath}, got {ex}");
                 FailedToParse = true;
                 return null;
             }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/FrameworkChecker/CompatabilityChecker.cs

@@ -15,11 +15,11 @@ public class CompatibilityChecker
         var incompatibleFrameworks = projectFrameworks.Where(f => !compatibleFrameworks.Contains(f)).ToArray();
         if (incompatibleFrameworks.Length > 0)
         {
-            logger.Log($"The package is not compatible. Incompatible project frameworks: {string.Join(", ", incompatibleFrameworks.Select(f => f.GetShortFolderName()))}");
+            logger.Warn($"The package is not compatible. Incompatible project frameworks: {string.Join(", ", incompatibleFrameworks.Select(f => f.GetShortFolderName()))}");
             return false;
         }
 
-        logger.Log("The package is compatible.");
+        logger.Info("The package is compatible.");
         return true;
 
         static NuGetFramework ParseFramework(string tfm)

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Run/RunWorker.cs

@@ -113,8 +113,8 @@ public class RunWorker
     {
         var discoveryResult = await _discoveryWorker.RunAsync(repoContentsPath.FullName, repoDirectory);
 
-        _logger.Log("Discovery JSON content:");
-        _logger.Log(JsonSerializer.Serialize(discoveryResult, DiscoveryWorker.SerializerOptions));
+        _logger.Info("Discovery JSON content:");
+        _logger.Info(JsonSerializer.Serialize(discoveryResult, DiscoveryWorker.SerializerOptions));
 
         // report dependencies
         var discoveredUpdatedDependencies = GetUpdatedDependencyListFromDiscovery(discoveryResult, repoContentsPath.FullName);
@@ -134,35 +134,28 @@ public class RunWorker
             });
 
             // track original contents for later handling
-            async Task TrackOriginalContentsAsync(string directory, string fileName, string? replacementFileName = null)
+            async Task TrackOriginalContentsAsync(string directory, string fileName)
             {
-                var repoFullPath = Path.Join(directory, fileName);
-                if (replacementFileName is not null)
-                {
-                    repoFullPath = Path.Join(Path.GetDirectoryName(repoFullPath)!, replacementFileName);
-                }
-
-                repoFullPath = repoFullPath.FullyNormalizedRootedPath();
+                var repoFullPath = Path.Join(directory, fileName).FullyNormalizedRootedPath();
                 var localFullPath = Path.Join(repoContentsPath.FullName, repoFullPath);
-
-                if (!File.Exists(localFullPath))
-                {
-                    return;
-                }
-
                 var content = await File.ReadAllTextAsync(localFullPath);
                 originalDependencyFileContents[repoFullPath] = content;
             }
 
             foreach (var project in discoveryResult.Projects)
             {
+                var projectDirectory = Path.GetDirectoryName(project.FilePath);
                 await TrackOriginalContentsAsync(discoveryResult.Path, project.FilePath);
-                await TrackOriginalContentsAsync(discoveryResult.Path, project.FilePath, replacementFileName: "packages.config");
+                foreach (var extraFile in project.ImportedFiles.Concat(project.AdditionalFiles))
+                {
+                    var extraFilePath = Path.Join(projectDirectory, extraFile);
+                    await TrackOriginalContentsAsync(discoveryResult.Path, extraFilePath);
+                }
                 // TODO: include global.json, etc.
             }
 
             // do update
-            _logger.Log($"Running update in directory {repoDirectory}");
+            _logger.Info($"Running update in directory {repoDirectory}");
             foreach (var project in discoveryResult.Projects)
             {
                 foreach (var dependency in project.Dependencies.Where(d => !d.IsTransitive))
@@ -192,13 +185,7 @@ public class RunWorker
                     // TODO: log analysisResult
                     if (analysisResult.CanUpdate)
                     {
-                        var dependencyLocation = Path.Join(discoveryResult.Path, project.FilePath);
-                        if (dependency.Type == DependencyType.PackagesConfig)
-                        {
-                            dependencyLocation = Path.Join(Path.GetDirectoryName(dependencyLocation)!, "packages.config");
-                        }
-
-                        dependencyLocation = dependencyLocation.FullyNormalizedRootedPath();
+                        var dependencyLocation = Path.Join(discoveryResult.Path, project.FilePath).FullyNormalizedRootedPath();
 
                         // TODO: this is inefficient, but not likely causing a bottleneck
                         var previousDependency = discoveredUpdatedDependencies.Dependencies
@@ -241,48 +228,46 @@ public class RunWorker
             }
 
             // create PR - we need to manually check file contents; we can't easily use `git status` in tests
-            var updatedDependencyFiles = new List<DependencyFile>();
-            async Task AddUpdatedFileIfDifferentAsync(string directory, string fileName, string? replacementFileName = null)
+            var updatedDependencyFiles = new Dictionary<string, DependencyFile>();
+            async Task AddUpdatedFileIfDifferentAsync(string directory, string fileName)
             {
-                var repoFullPath = Path.Join(directory, fileName);
-                if (replacementFileName is not null)
-                {
-                    repoFullPath = Path.Join(Path.GetDirectoryName(repoFullPath)!, replacementFileName);
-                }
-
-                repoFullPath = repoFullPath.FullyNormalizedRootedPath();
-                var localFullPath = Path.Join(repoContentsPath.FullName, repoFullPath);
-
-                if (!File.Exists(localFullPath))
-                {
-                    return;
-                }
-
+                var repoFullPath = Path.Join(directory, fileName).FullyNormalizedRootedPath();
+                var localFullPath = Path.GetFullPath(Path.Join(repoContentsPath.FullName, repoFullPath));
                 var originalContent = originalDependencyFileContents[repoFullPath];
                 var updatedContent = await File.ReadAllTextAsync(localFullPath);
                 if (updatedContent != originalContent)
                 {
-                    updatedDependencyFiles.Add(new DependencyFile()
+                    updatedDependencyFiles[localFullPath] = new DependencyFile()
                     {
                         Name = Path.GetFileName(repoFullPath),
                         Directory = Path.GetDirectoryName(repoFullPath)!.NormalizePathToUnix(),
                         Content = updatedContent,
-                    });
+                    };
                 }
             }
 
             foreach (var project in discoveryResult.Projects)
             {
                 await AddUpdatedFileIfDifferentAsync(discoveryResult.Path, project.FilePath);
-                await AddUpdatedFileIfDifferentAsync(discoveryResult.Path, project.FilePath, replacementFileName: "packages.config");
+                var projectDirectory = Path.GetDirectoryName(project.FilePath);
+                foreach (var extraFile in project.ImportedFiles.Concat(project.AdditionalFiles))
+                {
+                    var extraFilePath = Path.Join(projectDirectory, extraFile);
+                    await AddUpdatedFileIfDifferentAsync(discoveryResult.Path, extraFilePath);
+                }
+                // TODO: handle global.json, etc.
             }
 
             if (updatedDependencyFiles.Count > 0)
             {
+                var updatedDependencyFileList = updatedDependencyFiles
+                    .OrderBy(kvp => kvp.Key)
+                    .Select(kvp => kvp.Value)
+                    .ToArray();
                 var createPullRequest = new CreatePullRequest()
                 {
                     Dependencies = actualUpdatedDependencies.ToArray(),
-                    UpdatedDependencyFiles = updatedDependencyFiles.ToArray(),
+                    UpdatedDependencyFiles = updatedDependencyFileList,
                     BaseCommitSha = baseCommitSha,
                     CommitMessage = "TODO: message",
                     PrTitle = "TODO: title",
@@ -303,7 +288,7 @@ public class RunWorker
 
         var result = new RunResult()
         {
-            Base64DependencyFiles = originalDependencyFileContents.Select(kvp =>
+            Base64DependencyFiles = originalDependencyFileContents.OrderBy(kvp => kvp.Key).Select(kvp =>
             {
                 var fullPath = kvp.Key.FullyNormalizedRootedPath();
                 return new DependencyFile()
@@ -339,14 +324,20 @@ public class RunWorker
         foreach (var project in discoveryResult.Projects)
         {
             var projectDirectory = Path.GetDirectoryName(project.FilePath);
-            var pathToPackagesConfig = Path.Join(pathToContents, discoveryResult.Path, projectDirectory, "packages.config");
-
-            if (File.Exists(pathToPackagesConfig))
+            foreach (var extraFile in project.ImportedFiles.Concat(project.AdditionalFiles))
             {
-                auxiliaryFiles.Add(GetFullRepoPath(Path.Join(projectDirectory, "packages.config")));
+                var extraFileFullPath = Path.Join(projectDirectory, extraFile);
+                var extraFileRepoPath = GetFullRepoPath(extraFileFullPath);
+                auxiliaryFiles.Add(extraFileRepoPath);
             }
         }
 
+        var dependencyFiles = discoveryResult.Projects
+            .Select(p => GetFullRepoPath(p.FilePath))
+            .Concat(auxiliaryFiles)
+            .Distinct()
+            .OrderBy(p => p)
+            .ToArray();
         var updatedDependencyList = new UpdatedDependencyList()
         {
             Dependencies = discoveryResult.Projects.SelectMany(p =>
@@ -357,9 +348,7 @@ public class RunWorker
                         Name = d.Name,
                         Requirements = d.IsTransitive ? [] : [new ReportedRequirement()
                         {
-                            File = d.Type == DependencyType.PackagesConfig
-                                ? Path.Join(Path.GetDirectoryName(GetFullRepoPath(p.FilePath))!, "packages.config").FullyNormalizedRootedPath()
-                                : GetFullRepoPath(p.FilePath),
+                            File = GetFullRepoPath(p.FilePath),
                             Requirement = d.Version!,
                             Groups = ["dependencies"],
                         }],
@@ -367,7 +356,7 @@ public class RunWorker
                     }
                 );
             }).ToArray(),
-            DependencyFiles = discoveryResult.Projects.Select(p => GetFullRepoPath(p.FilePath)).Concat(auxiliaryFiles).ToArray(),
+            DependencyFiles = dependencyFiles,
         };
         return updatedDependencyList;
     }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/BindingRedirectManager.cs

@@ -8,6 +8,8 @@ using Microsoft.Language.Xml;
 
 using NuGet.ProjectManagement;
 
+using NuGetUpdater.Core.Utilities;
+
 using Runtime_AssemblyBinding = CoreV2::NuGet.Runtime.AssemblyBinding;
 
 namespace NuGetUpdater.Core;
@@ -32,7 +34,7 @@ internal static class BindingRedirectManager
     /// <param name="updatedPackageVersion">The version of the package that was updated</param>
     public static async ValueTask UpdateBindingRedirectsAsync(ProjectBuildFile projectBuildFile, string updatedPackageName, string updatedPackageVersion)
     {
-        var configFile = await TryGetRuntimeConfigurationFile(projectBuildFile);
+        var configFile = await TryGetRuntimeConfigurationFile(projectBuildFile.Path);
         if (configFile is null)
         {
             // no runtime config file so no need to add binding redirects
@@ -124,56 +126,24 @@ internal static class BindingRedirectManager
         }
     }
 
-    private static async ValueTask<ConfigurationFile?> TryGetRuntimeConfigurationFile(ProjectBuildFile projectBuildFile)
+    private static async ValueTask<ConfigurationFile?> TryGetRuntimeConfigurationFile(string fullProjectPath)
     {
-        var directoryPath = Path.GetDirectoryName(projectBuildFile.Path);
-        if (directoryPath is null)
-        {
-            return null;
-        }
-
-        var configFile = projectBuildFile.ItemNodes
-            .Where(IsConfigFile)
-            .FirstOrDefault();
+        var additionalFiles = ProjectHelper.GetAdditionalFilesFromProjectContent(fullProjectPath, ProjectHelper.PathFormat.Full);
+        var configFilePath = additionalFiles
+            .FirstOrDefault(p =>
+            {
+                var fileName = Path.GetFileName(p);
+                return fileName.Equals(ProjectHelper.AppConfigFileName, StringComparison.OrdinalIgnoreCase)
+                    || fileName.Equals(ProjectHelper.WebConfigFileName, StringComparison.OrdinalIgnoreCase);
+            });
 
-        if (configFile is null)
+        if (configFilePath is null)
         {
             return null;
         }
 
-        var configFilePath = Path.GetFullPath(Path.Combine(directoryPath, GetValue(configFile)));
         var configFileContents = await File.ReadAllTextAsync(configFilePath);
         return new ConfigurationFile(configFilePath, configFileContents, false);
-
-        static string GetValue(IXmlElementSyntax element)
-        {
-            var content = element.GetAttributeValue("Include");
-            if (!string.IsNullOrEmpty(content))
-            {
-                return content;
-            }
-
-            content = element.GetContentValue();
-            if (!string.IsNullOrEmpty(content))
-            {
-                return content;
-            }
-
-            return string.Empty;
-        }
-
-        static bool IsConfigFile(IXmlElementSyntax element)
-        {
-            var content = GetValue(element);
-            if (content is null)
-            {
-                return false;
-            }
-
-            var path = Path.GetFileName(content);
-            return (element.Name == "None" && string.Equals(path, "app.config", StringComparison.OrdinalIgnoreCase))
-                   || (element.Name == "Content" && string.Equals(path, "web.config", StringComparison.OrdinalIgnoreCase));
-        }
     }
 
     private static string AddBindingRedirects(ConfigurationFile configFile, IEnumerable<(Runtime_AssemblyBinding Binding, string AssemblyPath)> bindingRedirectsAndAssemblyPaths, string assemblyPathPrefix)

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/DotNetToolsJsonUpdater.cs

@@ -12,18 +12,18 @@ internal static class DotNetToolsJsonUpdater
     {
         if (!MSBuildHelper.TryGetDotNetToolsJsonPath(repoRootPath, workspacePath, out var dotnetToolsJsonPath))
         {
-            logger.Log("  No dotnet-tools.json file found.");
+            logger.Info("  No dotnet-tools.json file found.");
             return;
         }
 
         var dotnetToolsJsonFile = DotNetToolsJsonBuildFile.Open(repoRootPath, dotnetToolsJsonPath, logger);
 
-        logger.Log($"  Updating [{dotnetToolsJsonFile.RelativePath}] file.");
+        logger.Info($"  Updating [{dotnetToolsJsonFile.RelativePath}] file.");
 
         var containsDependency = dotnetToolsJsonFile.GetDependencies().Any(d => d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase));
         if (!containsDependency)
         {
-            logger.Log($"    Dependency [{dependencyName}] not found.");
+            logger.Info($"    Dependency [{dependencyName}] not found.");
             return;
         }
 
@@ -39,7 +39,7 @@ internal static class DotNetToolsJsonUpdater
 
             if (await dotnetToolsJsonFile.SaveAsync())
             {
-                logger.Log($"    Saved [{dotnetToolsJsonFile.RelativePath}].");
+                logger.Info($"    Saved [{dotnetToolsJsonFile.RelativePath}].");
             }
         }
     }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/GlobalJsonUpdater.cs

@@ -12,25 +12,25 @@ internal static class GlobalJsonUpdater
     {
         if (!MSBuildHelper.TryGetGlobalJsonPath(repoRootPath, workspacePath, out var globalJsonPath))
         {
-            logger.Log("  No global.json file found.");
+            logger.Info("  No global.json file found.");
             return;
         }
 
         var globalJsonFile = GlobalJsonBuildFile.Open(repoRootPath, globalJsonPath, logger);
 
-        logger.Log($"  Updating [{globalJsonFile.RelativePath}] file.");
+        logger.Info($"  Updating [{globalJsonFile.RelativePath}] file.");
 
         var containsDependency = globalJsonFile.GetDependencies().Any(d => d.Name.Equals(dependencyName, StringComparison.OrdinalIgnoreCase));
         if (!containsDependency)
         {
-            logger.Log($"    Dependency [{dependencyName}] not found.");
+            logger.Info($"    Dependency [{dependencyName}] not found.");
             return;
         }
 
         if (globalJsonFile.MSBuildSdks?.TryGetPropertyValue(dependencyName, out var version) != true
             || version?.GetValue<string>() is not string versionString)
         {
-            logger.Log("    Unable to determine dependency version.");
+            logger.Info("    Unable to determine dependency version.");
             return;
         }
 
@@ -43,7 +43,7 @@ internal static class GlobalJsonUpdater
 
         if (await globalJsonFile.SaveAsync())
         {
-            logger.Log($"    Saved [{globalJsonFile.RelativePath}].");
+            logger.Info($"    Saved [{globalJsonFile.RelativePath}].");
         }
     }
 }

data/helpers/lib/NuGetUpdater/NuGetUpdater.Core/Updater/LockFileUpdater.cs

@@ -7,21 +7,13 @@ internal static class LockFileUpdater
         string projectPath,
         ILogger logger)
     {
-        var projectDirectory = Path.GetDirectoryName(projectPath);
-        var lockPath = Path.Combine(projectDirectory, "packages.lock.json");
-        logger.Log($"    Updating lock file");
-        if (!File.Exists(lockPath))
-        {
-            logger.Log($"      File [{Path.GetRelativePath(repoRootPath, lockPath)}] does not exist.");
-            return;
-        }
-
+        var projectDirectory = Path.GetDirectoryName(projectPath)!;
         await MSBuildHelper.SidelineGlobalJsonAsync(projectDirectory, repoRootPath, async () =>
         {
             var (exitCode, stdout, stderr) = await ProcessEx.RunAsync("dotnet", ["restore", "--force-evaluate", projectPath], workingDirectory: projectDirectory);
             if (exitCode != 0)
             {
-                logger.Log($"      Lock file update failed.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");
+                logger.Error($"      Lock file update failed.\nSTDOUT:\n{stdout}\nSTDERR:\n{stderr}");
             }
             return (exitCode, stdout, stderr);
         }, logger, retainMSBuildSdks: true);