Add compile errors to the functionerror collection (#8518)

* add compile errors to the functionerror collection, which is used in admin/functions/{name}/status endpoint

* add unit test for functionerrors collection in dotnetinvocation worker

* remove host.json from pr

* change functionErrorCollection into hashset

Co-authored-by: Vincent Chiang <vchiang@microsoft.com>

Author: chiangvincent

src/WebJobs.Script/Description/DotNet/DotNetFunctionInvoker.cs

@@ -197,6 +197,7 @@ internal async Task<MethodInfo> GetFunctionTargetAsync(bool isInvocation = false
                 // on the invocation path we want to log detailed logs and all compilation diagnostics
                 var properties = isInvocation ? null : PrimaryHostLogProperties;
                 FunctionLogger.Log(LogLevel.Error, 0, properties, exc, (state, ex) => "Function compilation error");
+                Utility.AddFunctionError(Host.FunctionErrors, _functionMetadata.Name, exc.ToString());
                 TraceCompilationDiagnostics(exc.Diagnostics, LogTargets.User, isInvocation);
                 throw;
             }

src/WebJobs.Script/Utility.cs

@@ -541,10 +541,10 @@ internal static void AddFunctionError(IDictionary<string, ICollection<string>> f
         {
             functionName = isFunctionShortName ? functionName : Utility.GetFunctionShortName(functionName);
 
-            ICollection<string> functionErrorCollection = new Collection<string>();
+            ICollection<string> functionErrorCollection = new HashSet<string>();
             if (!string.IsNullOrEmpty(functionName) && !functionErrors.TryGetValue(functionName, out functionErrorCollection))
             {
-                functionErrors[functionName] = functionErrorCollection = new Collection<string>();
+                functionErrors[functionName] = functionErrorCollection = new HashSet<string>();
             }
             functionErrorCollection.Add(error);
         }

test/WebJobs.Script.Tests/Description/DotNet/DotNetFunctionInvokerTests.cs

@@ -409,6 +409,61 @@ public async Task RestorePackagesAsync_WithUpdatedReferences_TriggersShutdown(bo
             }
         }
 
+        [Fact]
+        public async Task GetFunctionTargetAsync_CompilationError_ReportsResultsToScriptHostFunctionErrors()
+        {
+            // Create the compilation exception we expect to throw
+            var descriptor = new DiagnosticDescriptor(DotNetConstants.MissingFunctionEntryPointCompilationCode,
+                "Test compilation exception", "Test compilation error", "AzureFunctions", DiagnosticSeverity.Error, true);
+            var exception = new CompilationErrorException("Test compilation exception", ImmutableArray.Create(Diagnostic.Create(descriptor, Location.None)));
+
+            // Create the invoker dependencies and setup the appropriate method to throw the exception
+            RunDependencies dependencies = CreateDependencies();
+            dependencies.Compilation.Setup(c => c.GetEntryPointSignature(It.IsAny<IFunctionEntryPointResolver>(), It.IsAny<Assembly>()))
+                .Throws(exception);
+            dependencies.Compilation.Setup(c => c.EmitAsync(It.IsAny<CancellationToken>()))
+                .ReturnsAsync(DotNetCompilationResult.FromPath(typeof(DotNetFunctionInvokerTests).Assembly.Location));
+
+            string functionName = Guid.NewGuid().ToString();
+            string rootFunctionsFolder = Path.Combine(Path.GetTempPath(), functionName);
+            Directory.CreateDirectory(rootFunctionsFolder);
+
+            // Create a dummy file to represent our function
+            string filePath = Path.Combine(rootFunctionsFolder, Guid.NewGuid().ToString() + ".csx");
+            File.WriteAllText(filePath, string.Empty);
+
+            var metadata = new FunctionMetadata
+            {
+                ScriptFile = filePath,
+                FunctionDirectory = Path.GetDirectoryName(filePath),
+                Name = functionName,
+                Language = DotNetScriptTypes.CSharp
+            };
+
+            metadata.Bindings.Add(new BindingMetadata() { Name = "Test", Type = "ManualTrigger" });
+
+            var invoker = new DotNetFunctionInvoker(dependencies.Host, metadata, new Collection<FunctionBinding>(), new Collection<FunctionBinding>(),
+                dependencies.EntrypointResolver.Object, dependencies.CompilationServiceFactory.Object, dependencies.LoggerFactory, dependencies.MetricsLogger,
+                new Collection<IScriptBindingProvider>());
+
+            // Send file change notification to trigger a reload
+            var fileEventArgs = new FileSystemEventArgs(WatcherChangeTypes.Changed, Path.GetTempPath(), Path.Combine(Path.GetFileName(rootFunctionsFolder), Path.GetFileName(filePath)));
+            dependencies.Host.EventManager.Publish(new FileEvent(EventSources.ScriptFiles, fileEventArgs));
+
+            await Assert.ThrowsAsync<CompilationErrorException>(async () =>
+            {
+                await invoker.GetFunctionTargetAsync();
+            });
+
+            dependencies.Host.FunctionErrors.TryGetValue(functionName, out ICollection<string> functionErrors);
+            Console.WriteLine(functionErrors);
+            Assert.True(functionErrors.Any());
+            foreach (string error in functionErrors)
+            {
+                Assert.StartsWith("Microsoft.CodeAnalysis.Scripting.CompilationErrorException: Test compilation exception", error);
+            }
+        }
+
         // TODO: DI (FACAVAL) Use test helpers to create host and inject services
         private RunDependencies CreateDependencies(Action<IServiceCollection> configureServices = null)
         {