add warning log for end of support extension bundles versions (#11075)

* compare loaded bundle version with latest major bundle version

* update message

* use resx

* update message

* update bitness for x86

* update the message

* move to scriptstartup

* add test cases

* remove new line

* handle null check

* move the logic to extension bundle manager

* change to warning

* move to function app validation service

* revert some changes

* make validator extensible

* fix the test case

* Update resource

* update the message as per PM review

* change the date format

* update tests

* code review comments + remove diagnostic event

* remove extra space in tests

* change to warning logs

* peformant logging and updated date

* update the date to Aug 4, 2026

* remove resx files

* register validators always

* review comment

* review comments

* use LogCategoryHostGeneral

* add null check

Author: manvkaur

release_notes.md

@@ -1,8 +1,9 @@
-### Release notes
-
-<!-- Please add your release notes in the following format:
-- My change description (#PR)
--->
-- Adding activity sources for Durable and WebJobs (Kafka and RabbitMQ) (#11137)
-- Add JitTrace Files for v4.1041
-- Fix startup deadlock on transient exceptions (#11142)
+### Release notes
+
+<!-- Please add your release notes in the following format:
+- My change description (#PR)
+-->
+- Adding activity sources for Durable and WebJobs (Kafka and RabbitMQ) (#11137)
+- Add JitTrace Files for v4.1041
+- Fix startup deadlock on transient exceptions (#11142)
+- Add warning log for end of support bundle version, any bundle version < 4 (#11075)

src/WebJobs.Script.SiteExtension/New-PrivateSiteExtension.ps1

@@ -42,7 +42,7 @@ param (
 $normalizeBitness = @{
     'x64' = '64bit'
     '64bit' = '64bit'
-    'x86' = '64bit'
+    'x86' = '32bit'
     '32bit' = '32bit'
 }
 

src/WebJobs.Script/Diagnostics/Extensions/LoggerExtension.cs

@@ -206,6 +206,16 @@ internal static class LoggerExtension
         private static readonly Action<ILogger, string, Exception> _publishingMetrics =
             LoggerMessage.Define<string>(LogLevel.Debug, new EventId(338, nameof(PublishingMetrics)), "{metrics}");
 
+        private static readonly Action<ILogger, string, int, int, Exception> _outdatedExtensionBundleFuture =
+           LoggerMessage.Define<string, int, int>(LogLevel.Warning,
+           new EventId(342, nameof(OutdatedExtensionBundle)),
+           "Your current bundle version {currentVersion} will reach end of support on Aug 4, 2026. Upgrade to [{suggestedMinVersion}.*, {suggestedMaxVersion}.0.0). For more information, see https://aka.ms/functions-outdated-bundles");
+
+        private static readonly Action<ILogger, string, int, int, Exception> _outdatedExtensionBundlePast =
+           LoggerMessage.Define<string, int, int>(LogLevel.Warning,
+           new EventId(342, nameof(OutdatedExtensionBundle)),
+           "Your current bundle version {currentVersion} has reached end of support on Aug 4, 2026. Upgrade to [{suggestedMinVersion}.*, {suggestedMaxVersion}.0.0). For more information, see https://aka.ms/functions-outdated-bundles");
+
         public static void PublishingMetrics(this ILogger logger, string metrics)
         {
             _publishingMetrics(logger, metrics, null);
@@ -407,5 +417,20 @@ public static void IncorrectAzureFunctionsFolderPath(this ILogger logger, string
         {
             _incorrectAzureFunctionsFolderPath(logger, path, EnvironmentSettingNames.FunctionWorkerRuntime, null);
         }
+
+        public static void OutdatedExtensionBundle(this ILogger logger, string currentVersion, int suggestedMinVersion, int suggestedMaxVersion)
+        {
+            var currentTime = DateTime.UtcNow;
+            var deprecationDate = new DateTime(2026, 8, 5, 0, 0, 0, DateTimeKind.Utc);
+
+            if (currentTime >= deprecationDate)
+            {
+                _outdatedExtensionBundlePast(logger, currentVersion, suggestedMinVersion, suggestedMaxVersion, null);
+            }
+            else
+            {
+                _outdatedExtensionBundleFuture(logger, currentVersion, suggestedMinVersion, suggestedMaxVersion, null);
+            }
+        }
     }
 }

src/WebJobs.Script/ExtensionBundle/ExtensionBundleManager.cs

@@ -10,8 +10,10 @@
 using System.Threading.Tasks;
 using Microsoft.Azure.WebJobs.Script.Config;
 using Microsoft.Azure.WebJobs.Script.Configuration;
+using Microsoft.Azure.WebJobs.Script.Diagnostics;
 using Microsoft.Azure.WebJobs.Script.Diagnostics.Extensions;
 using Microsoft.Azure.WebJobs.Script.Models;
+using Microsoft.Azure.WebJobs.Script.Properties;
 using Microsoft.Extensions.Logging;
 using Newtonsoft.Json;
 using NuGet.Versioning;
@@ -375,5 +377,33 @@ public async Task<string> GetExtensionBundleBinPathAsync()
             // if no bin directory is present something is wrong
             return FileUtility.DirectoryExists(binPath) ? binPath : null;
         }
+
+        public string GetOutdatedBundleVersion()
+        {
+            // If the extension bundle version is not set or if the extension bundle is not the default one,
+            // return empty string
+            if (string.IsNullOrEmpty(_extensionBundleVersion) ||
+                !string.Equals(_options?.Id, ScriptConstants.DefaultExtensionBundleId, StringComparison.OrdinalIgnoreCase))
+            {
+                return null;
+            }
+
+            // Extract the major version number from the version string
+            int dotIndex = _extensionBundleVersion.IndexOf('.');
+            if (dotIndex <= 0 || !int.TryParse(_extensionBundleVersion.AsSpan(0, dotIndex), out var majorVersion) || majorVersion == 0)
+            {
+                return null;
+            }
+
+            int latestMajorVersion = ScriptConstants.ExtensionBundleV4MajorVersion;
+
+            // Return the version if it's outdated
+            if (majorVersion < latestMajorVersion)
+            {
+                return _extensionBundleVersion;
+            }
+
+            return null;
+        }
     }
 }

src/WebJobs.Script/ExtensionBundle/IExtensionBundleManager.cs

@@ -20,5 +20,7 @@ public interface IExtensionBundleManager
         bool IsLegacyExtensionBundle();
 
         Task<ExtensionBundleDetails> GetExtensionBundleDetails();
+
+        string GetOutdatedBundleVersion();
     }
 }

src/WebJobs.Script/Host/ExtensionBundleManagerValidator.cs

@@ -0,0 +1,34 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using Microsoft.Azure.WebJobs.Script.Diagnostics.Extensions;
+using Microsoft.Azure.WebJobs.Script.ExtensionBundle;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Azure.WebJobs.Script.Host
+{
+    internal sealed class ExtensionBundleManagerValidator : IFunctionAppValidator
+    {
+        private readonly IExtensionBundleManager _extensionBundleManager;
+
+        public ExtensionBundleManagerValidator(IExtensionBundleManager extensionBundleManager)
+        {
+            _extensionBundleManager = extensionBundleManager;
+        }
+
+        public void Validate(ScriptJobHostOptions options, IEnvironment environment, ILogger logger)
+        {
+            if (!logger.IsEnabled(LogLevel.Warning))
+            {
+                return;
+            }
+
+            string outdatedBundleVersion = _extensionBundleManager.GetOutdatedBundleVersion();
+            if (!string.IsNullOrEmpty(outdatedBundleVersion))
+            {
+                int latestMajorVersion = ScriptConstants.ExtensionBundleV4MajorVersion;
+                logger.OutdatedExtensionBundle(outdatedBundleVersion, latestMajorVersion, latestMajorVersion + 1);
+            }
+        }
+    }
+}

src/WebJobs.Script/Host/FunctionAppValidationService.cs

@@ -3,11 +3,8 @@
 
 using System;
 using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
-using Microsoft.Azure.WebJobs.Script.Diagnostics.Extensions;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
@@ -20,17 +17,20 @@ namespace Microsoft.Azure.WebJobs.Script.Host
     internal sealed class FunctionAppValidationService : BackgroundService
     {
         private readonly IEnvironment _environment;
-        private readonly ILogger<FunctionAppValidationService> _logger;
+        private readonly ILogger _logger;
         private readonly IOptions<ScriptJobHostOptions> _scriptOptions;
+        private readonly IEnumerable<IFunctionAppValidator> _validators;
 
         public FunctionAppValidationService(
-            ILogger<FunctionAppValidationService> logger,
+            ILoggerFactory loggerFactory,
             IOptions<ScriptJobHostOptions> scriptOptions,
-            IEnvironment environment)
+            IEnvironment environment,
+            IEnumerable<IFunctionAppValidator> validators)
         {
             _scriptOptions = scriptOptions ?? throw new ArgumentNullException(nameof(scriptOptions));
-            _logger = logger ?? throw new ArgumentNullException(nameof(logger));
+            _logger = loggerFactory?.CreateLogger(ScriptConstants.LogCategoryHostGeneral) ?? throw new ArgumentNullException(nameof(loggerFactory));
             _environment = environment ?? throw new ArgumentNullException(nameof(environment));
+            _validators = validators ?? throw new ArgumentNullException(nameof(validators));
         }
 
         protected override async Task ExecuteAsync(CancellationToken cancellationToken)
@@ -40,39 +40,21 @@ protected override async Task ExecuteAsync(CancellationToken cancellationToken)
                 // Adding a delay to ensure that this validation does not impact the cold start performance
                 Utility.ExecuteAfterColdStartDelay(_environment, Validate, cancellationToken);
             }
-
             await Task.CompletedTask;
         }
 
         private void Validate()
         {
-            try
+            foreach (var validator in _validators)
             {
-                string azureFunctionsDirPath = Path.Combine(_scriptOptions.Value.RootScriptPath, ScriptConstants.AzureFunctionsSystemDirectoryName);
-
-                if (_scriptOptions.Value.RootScriptPath is not null &&
-                    !_scriptOptions.Value.IsDefaultHostConfig &&
-                    Utility.IsDotnetIsolatedApp(environment: _environment) &&
-                    !Directory.Exists(azureFunctionsDirPath))
+                try
                 {
-                    // Search for the .azurefunctions directory within nested directories to verify scenarios where it isn't located at the root. This situation occurs when a function app has been improperly zipped.
-                    IEnumerable<string> azureFunctionsDirectories = Directory.GetDirectories(_scriptOptions.Value.RootScriptPath, ScriptConstants.AzureFunctionsSystemDirectoryName, SearchOption.AllDirectories)
-                        .Where(dir => !dir.Equals(azureFunctionsDirPath, StringComparison.OrdinalIgnoreCase));
-
-                    if (azureFunctionsDirectories.Any())
-                    {
-                        string azureFunctionsDirectoriesPath = string.Join(", ", azureFunctionsDirectories).Replace(_scriptOptions.Value.RootScriptPath, string.Empty);
-                        _logger.IncorrectAzureFunctionsFolderPath(azureFunctionsDirectoriesPath);
-                    }
-                    else
-                    {
-                        _logger.MissingAzureFunctionsFolder();
-                    }
+                    validator.Validate(_scriptOptions.Value, _environment, _logger);
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogTrace(ex, "Validator {ValidatorType} failed", validator.GetType().Name);
                 }
-            }
-            catch (Exception ex)
-            {
-                _logger.LogTrace("Unable to validate deployed function app payload", ex);
             }
         }
     }

src/WebJobs.Script/Host/IFunctionAppValidator.cs

@@ -0,0 +1,21 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Azure.WebJobs.Script.Host
+{
+    /// <summary>
+    /// Defines a validator interface for Function App validation.
+    /// </summary>
+    internal interface IFunctionAppValidator
+    {
+        /// <summary>
+        /// Validates aspects of the function app and reports any issues through the provided logger.
+        /// </summary>
+        /// <param name="options">The script host options containing function app configuration.</param>
+        /// <param name="environment">The environment in which the function app is running.</param>
+        /// <param name="logger">The logger to report validation issues.</param>
+        void Validate(ScriptJobHostOptions options, IEnvironment environment, ILogger logger);
+    }
+}

src/WebJobs.Script/Host/MissingAzureFunctionsFolderValidator.cs

@@ -0,0 +1,39 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT License. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Microsoft.Azure.WebJobs.Script.Diagnostics.Extensions;
+using Microsoft.Extensions.Logging;
+
+namespace Microsoft.Azure.WebJobs.Script.Host
+{
+    internal sealed class MissingAzureFunctionsFolderValidator : IFunctionAppValidator
+    {
+        public void Validate(ScriptJobHostOptions options, IEnvironment environment, ILogger logger)
+        {
+            string azureFunctionsDirPath = Path.Combine(options.RootScriptPath, ScriptConstants.AzureFunctionsSystemDirectoryName);
+
+            if (options.RootScriptPath is not null &&
+                !options.IsDefaultHostConfig &&
+                Utility.IsDotnetIsolatedApp(environment: environment) &&
+                !Directory.Exists(azureFunctionsDirPath))
+            {
+                IEnumerable<string> azureFunctionsDirectories = Directory.GetDirectories(options.RootScriptPath, ScriptConstants.AzureFunctionsSystemDirectoryName, SearchOption.AllDirectories)
+                    .Where(dir => !dir.Equals(azureFunctionsDirPath, StringComparison.OrdinalIgnoreCase));
+
+                if (azureFunctionsDirectories.Any())
+                {
+                    string azureFunctionsDirectoriesPath = string.Join(", ", azureFunctionsDirectories).Replace(options.RootScriptPath, string.Empty);
+                    logger.IncorrectAzureFunctionsFolderPath(azureFunctionsDirectoriesPath);
+                }
+                else
+                {
+                    logger.MissingAzureFunctionsFolder();
+                }
+            }
+        }
+    }
+}

src/WebJobs.Script/ScriptHostBuilderExtensions.cs

@@ -172,6 +172,11 @@ public static IHostBuilder AddScriptHostCore(this IHostBuilder builder, ScriptAp
             {
                 if (!SystemEnvironment.Instance.IsPlaceholderModeEnabled())
                 {
+                    // Register all validators here
+                    services.AddSingleton<IFunctionAppValidator, ExtensionBundleManagerValidator>();
+                    services.AddSingleton<IFunctionAppValidator, MissingAzureFunctionsFolderValidator>();
+
+                    // Add more validators as needed
                     services.AddHostedService<FunctionAppValidationService>();
                 }