Replace import = syntax to avoid Node 24 strip-only mode failure

Worker.nuspec

@@ -2,7 +2,7 @@
 <package xmlns="http://schemas.microsoft.com/packaging/2012/06/nuspec.xsd">
   <metadata>
     <id>Microsoft.Azure.Functions.NodeJsWorker</id>
-    <version>3.10.1</version>
+    <version>3.11.0</version>
     <authors>Microsoft</authors>
     <owners>Microsoft</owners>
     <requireLicenseAcceptance>false</requireLicenseAcceptance>

azure-pipelines/templates/test.yml

@@ -13,6 +13,8 @@ jobs:
                   NODE_VERSION: '20.x'
               Node22:
                   NODE_VERSION: '22.x'
+              Node24:
+                  NODE_VERSION: '24.x'
 
       steps:
           - task: NodeTool@0

package.json

@@ -1,7 +1,7 @@
 {
     "name": "azure-functions-nodejs-worker",
     "author": "Microsoft Corporation",
-    "version": "3.10.1",
+    "version": "3.11.0",
     "description": "Microsoft Azure Functions NodeJS Worker",
     "license": "(MIT OR Apache-2.0)",
     "dependencies": {

src/constants.ts

@@ -1,4 +1,4 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License.
 
-export const version = '3.10.1';
+export const version = '3.11.0';

src/coreApi/setProgrammingModel.ts

@@ -4,16 +4,14 @@
 import { ProgrammingModel } from '@azure/functions-core';
 import { AzureFunctionsRpcMessages as rpc } from '../../azure-functions-language-worker-protobuf/src/rpc';
 import { worker } from '../WorkerContext';
-import LogCategory = rpc.RpcLog.RpcLogCategory;
-import LogLevel = rpc.RpcLog.Level;
 
 export function setProgrammingModel(programmingModel: ProgrammingModel): void {
     // Log when setting the programming model, except for the initial default one (partially because the grpc channels aren't fully setup at that time)
     if (worker.app.programmingModel) {
         worker.log({
             message: `Setting Node.js programming model to "${programmingModel.name}" version "${programmingModel.version}"`,
-            level: LogLevel.Information,
-            logCategory: LogCategory.System,
+            level: rpc.RpcLog.Level.Information,
+            logCategory: rpc.RpcLog.RpcLogCategory.System,
         });
     } else {
         worker.defaultProgrammingModel = programmingModel;

src/eventHandlers/FunctionEnvironmentReloadHandler.ts

@@ -7,8 +7,6 @@ import { worker } from '../WorkerContext';
 import { EventHandler } from './EventHandler';
 import { getWorkerCapabilities } from './getWorkerCapabilities';
 import { getWorkerMetadata } from './getWorkerMetadata';
-import LogCategory = rpc.RpcLog.RpcLogCategory;
-import LogLevel = rpc.RpcLog.Level;
 import CapabilitiesUpdateStrategy = rpc.FunctionEnvironmentReloadResponse.CapabilitiesUpdateStrategy;
 import * as path from 'path';
 
@@ -31,8 +29,8 @@ export class FunctionEnvironmentReloadHandler extends EventHandler<
         if (!msg.functionAppDirectory) {
             worker.log({
                 message: `FunctionEnvironmentReload functionAppDirectory is not defined`,
-                level: LogLevel.Debug,
-                logCategory: LogCategory.System,
+                level: rpc.RpcLog.Level.Debug,
+                logCategory: rpc.RpcLog.RpcLogCategory.System,
             });
         }
 
@@ -43,8 +41,8 @@ export class FunctionEnvironmentReloadHandler extends EventHandler<
         ) {
             worker.log({
                 message: `FunctionEnvironmentReload functionAppDirectory has not changed`,
-                level: LogLevel.Debug,
-                logCategory: LogCategory.System,
+                level: rpc.RpcLog.Level.Debug,
+                logCategory: rpc.RpcLog.RpcLogCategory.System,
             });
         }
 
@@ -56,8 +54,8 @@ export class FunctionEnvironmentReloadHandler extends EventHandler<
         const numVariables = (msg.environmentVariables && Object.keys(msg.environmentVariables).length) || 0;
         worker.log({
             message: `Reloading environment variables. Found ${numVariables} variables to reload.`,
-            level: LogLevel.Information,
-            logCategory: LogCategory.System,
+            level: rpc.RpcLog.Level.Information,
+            logCategory: rpc.RpcLog.RpcLogCategory.System,
         });
 
         // reset existing env vars
@@ -69,8 +67,8 @@ export class FunctionEnvironmentReloadHandler extends EventHandler<
         if (msg.functionAppDirectory) {
             worker.log({
                 message: `Changing current working directory to ${msg.functionAppDirectory}`,
-                level: LogLevel.Information,
-                logCategory: LogCategory.System,
+                level: rpc.RpcLog.Level.Information,
+                logCategory: rpc.RpcLog.RpcLogCategory.System,
             });
             process.chdir(msg.functionAppDirectory);
             await startApp(msg.functionAppDirectory);

src/eventHandlers/FunctionLoadHandler.ts

@@ -7,8 +7,6 @@ import { loadLegacyFunction } from '../LegacyFunctionLoader';
 import { isDefined, nonNullProp } from '../utils/nonNull';
 import { worker } from '../WorkerContext';
 import { EventHandler } from './EventHandler';
-import LogCategory = rpc.RpcLog.RpcLogCategory;
-import LogLevel = rpc.RpcLog.Level;
 
 /**
  * Worker responds after loading required metadata to load function with the load result
@@ -27,8 +25,8 @@ export class FunctionLoadHandler extends EventHandler<'functionLoadRequest', 'fu
 
         worker.log({
             message: `Worker ${worker.id} received FunctionLoadRequest`,
-            level: LogLevel.Debug,
-            logCategory: LogCategory.System,
+            level: rpc.RpcLog.Level.Debug,
+            logCategory: rpc.RpcLog.RpcLogCategory.System,
         });
 
         if (isDefined(worker.app.blockingAppStartError)) {

src/eventHandlers/FunctionsMetadataHandler.ts

@@ -5,8 +5,6 @@ import { AzureFunctionsRpcMessages as rpc } from '../../azure-functions-language
 import { isDefined } from '../utils/nonNull';
 import { worker } from '../WorkerContext';
 import { EventHandler } from './EventHandler';
-import LogCategory = rpc.RpcLog.RpcLogCategory;
-import LogLevel = rpc.RpcLog.Level;
 
 export class FunctionsMetadataHandler extends EventHandler<'functionsMetadataRequest', 'functionMetadataResponse'> {
     readonly responseName = 'functionMetadataResponse';
@@ -24,8 +22,8 @@ export class FunctionsMetadataHandler extends EventHandler<'functionsMetadataReq
 
         worker.log({
             message: `Worker ${worker.id} received FunctionsMetadataRequest`,
-            level: LogLevel.Debug,
-            logCategory: LogCategory.System,
+            level: rpc.RpcLog.Level.Debug,
+            logCategory: rpc.RpcLog.RpcLogCategory.System,
         });
 
         if (worker.app.isUsingWorkerIndexing) {

src/eventHandlers/WorkerInitHandler.ts

@@ -11,8 +11,6 @@ import { worker } from '../WorkerContext';
 import { EventHandler } from './EventHandler';
 import { getWorkerCapabilities } from './getWorkerCapabilities';
 import { getWorkerMetadata } from './getWorkerMetadata';
-import LogCategory = rpc.RpcLog.RpcLogCategory;
-import LogLevel = rpc.RpcLog.Level;
 
 /**
  * Host sends capabilities/init data to worker and requests the worker to initialize itself
@@ -30,8 +28,8 @@ export class WorkerInitHandler extends EventHandler<'workerInitRequest', 'worker
         if (!msg.functionAppDirectory) {
             worker.log({
                 message: `WorkerInit functionAppDirectory is not defined`,
-                level: LogLevel.Debug,
-                logCategory: LogCategory.System,
+                level: rpc.RpcLog.Level.Debug,
+                logCategory: rpc.RpcLog.RpcLogCategory.System,
             });
         }
         worker.app.functionAppDirectory = msg.functionAppDirectory;
@@ -40,8 +38,8 @@ export class WorkerInitHandler extends EventHandler<'workerInitRequest', 'worker
 
         worker.log({
             message: `Worker ${worker.id} received WorkerInitRequest`,
-            level: LogLevel.Debug,
-            logCategory: LogCategory.System,
+            level: rpc.RpcLog.Level.Debug,
+            logCategory: rpc.RpcLog.RpcLogCategory.System,
         });
 
         logColdStartWarning();
@@ -75,8 +73,8 @@ export function logColdStartWarning(delayInMs?: number): void {
                     worker.log({
                         message:
                             'package.json is not found at the root of the Function App in Azure Files - cold start for NodeJs can be affected.',
-                        level: LogLevel.Debug,
-                        logCategory: LogCategory.System,
+                        level: rpc.RpcLog.Level.Debug,
+                        logCategory: rpc.RpcLog.RpcLogCategory.System,
                     });
                 }
             });

src/eventHandlers/terminateWorker.ts

@@ -6,14 +6,12 @@ import { AzureFunctionsRpcMessages as rpc } from '../../azure-functions-language
 import { ReadOnlyError } from '../errors';
 import { executeHooks } from '../hooks/executeHooks';
 import { worker } from '../WorkerContext';
-import LogCategory = rpc.RpcLog.RpcLogCategory;
-import LogLevel = rpc.RpcLog.Level;
 
 export async function terminateWorker(_msg: rpc.IWorkerTerminate) {
     worker.log({
         message: 'Received workerTerminate message; gracefully shutting down worker',
-        level: LogLevel.Debug,
-        logCategory: LogCategory.System,
+        level: rpc.RpcLog.Level.Debug,
+        logCategory: rpc.RpcLog.RpcLogCategory.System,
     });
 
     const appTerminateContext: AppTerminateContext = {

src/hooks/executeHooks.ts

@@ -5,8 +5,6 @@ import { HookContext } from '@azure/functions-core';
 import { AzureFunctionsRpcMessages as rpc } from '../../azure-functions-language-worker-protobuf/src/rpc';
 import { worker } from '../WorkerContext';
 import { getHooks } from './getHooks';
-import LogLevel = rpc.RpcLog.Level;
-import LogCategory = rpc.RpcLog.RpcLogCategory;
 
 export async function executeHooks(
     hookName: string,
@@ -18,8 +16,8 @@ export async function executeHooks(
     if (callbacks.length > 0) {
         worker.log({
             message: `Executing ${callbacks.length} "${hookName}" hooks`,
-            level: LogLevel.Debug,
-            logCategory: LogCategory.System,
+            level: rpc.RpcLog.Level.Debug,
+            logCategory: rpc.RpcLog.RpcLogCategory.System,
             invocationId,
             category: msgCategory,
         });
@@ -28,8 +26,8 @@ export async function executeHooks(
         }
         worker.log({
             message: `Executed "${hookName}" hooks`,
-            level: LogLevel.Debug,
-            logCategory: LogCategory.System,
+            level: rpc.RpcLog.Level.Debug,
+            logCategory: rpc.RpcLog.RpcLogCategory.System,
             invocationId,
             category: msgCategory,
         });

src/loadScriptFile.ts

@@ -8,8 +8,6 @@ import { AzureFunctionsRpcMessages as rpc } from '../azure-functions-language-wo
 import { AzFuncSystemError } from './errors';
 import { PackageJson } from './parsers/parsePackageJson';
 import { worker } from './WorkerContext';
-import LogCategory = rpc.RpcLog.RpcLogCategory;
-import LogLevel = rpc.RpcLog.Level;
 
 let hasLoggedAttempt = 0;
 let hasLoggedWarning = false;
@@ -23,8 +21,8 @@ export async function loadScriptFile(filePath: string, packageJson: PackageJson)
             if (currentAttempt > 1 && currentAttempt > hasLoggedAttempt) {
                 worker.log({
                     message: `Retrying file load. Attempt ${currentAttempt}/${retries + 1}`,
-                    level: LogLevel.Debug,
-                    logCategory: LogCategory.System,
+                    level: rpc.RpcLog.Level.Debug,
+                    logCategory: rpc.RpcLog.RpcLogCategory.System,
                 });
                 hasLoggedAttempt = currentAttempt;
             }
@@ -40,8 +38,8 @@ export async function loadScriptFile(filePath: string, packageJson: PackageJson)
                 } else if (error.retriesLeft > 0 && !hasLoggedWarning) {
                     worker.log({
                         message: `Warning: Failed to load file with error "${error.message}"`,
-                        level: LogLevel.Warning,
-                        logCategory: LogCategory.System,
+                        level: rpc.RpcLog.Level.Warning,
+                        logCategory: rpc.RpcLog.RpcLogCategory.System,
                     });
                     hasLoggedWarning = true;
                 }
@@ -82,13 +80,13 @@ function warnIfLongLoadTime(filePath: string, start: number): void {
     ) {
         worker.log({
             message: `Loading "${path.basename(filePath)}" took ${timeElapsed}ms`,
-            level: LogLevel.Warning,
-            logCategory: LogCategory.System,
+            level: rpc.RpcLog.Level.Warning,
+            logCategory: rpc.RpcLog.RpcLogCategory.System,
         });
         worker.log({
             message: `Set "${rfpName}" to "1" to significantly improve load times. Learn more here: https://aka.ms/AAjon54`,
-            level: LogLevel.Warning,
-            logCategory: LogCategory.System,
+            level: rpc.RpcLog.Level.Warning,
+            logCategory: rpc.RpcLog.RpcLogCategory.System,
         });
     }
 }

src/setupEventStream.ts

@@ -13,8 +13,6 @@ import { WorkerInitHandler } from './eventHandlers/WorkerInitHandler';
 import { systemError } from './utils/Logger';
 import { nonNullProp } from './utils/nonNull';
 import { worker } from './WorkerContext';
-import LogCategory = rpc.RpcLog.RpcLogCategory;
-import LogLevel = rpc.RpcLog.Level;
 
 /**
  * Configures handlers for incoming gRPC messages on the client
@@ -101,8 +99,8 @@ async function handleMessage(inMsg: rpc.StreamingMessage): Promise<void> {
         if (error.isAzureFunctionsSystemError && !error.loggedOverRpc) {
             worker.log({
                 message: error.message,
-                level: LogLevel.Error,
-                logCategory: LogCategory.System,
+                level: rpc.RpcLog.Level.Error,
+                logCategory: rpc.RpcLog.RpcLogCategory.System,
             });
         }
 

src/startApp.ts

@@ -12,8 +12,6 @@ import { isEnvironmentVariableSet, isNode20Plus } from './utils/util';
 import { worker } from './WorkerContext';
 import globby = require('globby');
 import path = require('path');
-import LogLevel = rpc.RpcLog.Level;
-import LogCategory = rpc.RpcLog.RpcLogCategory;
 
 /**
  * Starting an app can happen in two places, depending on if the worker was specialized or not
@@ -51,8 +49,8 @@ async function updatePackageJson(functionAppDirectory: string): Promise<void> {
         const error = ensureErrorType(err);
         worker.log({
             message: `Worker failed to load package.json: ${error.message}`,
-            level: LogLevel.Warning,
-            logCategory: LogCategory.System,
+            level: rpc.RpcLog.Level.Warning,
+            logCategory: rpc.RpcLog.RpcLogCategory.System,
         });
         worker.app.packageJson = {};
     }
@@ -81,8 +79,8 @@ async function loadEntryPointFile(functionAppDirectory: string): Promise<void> {
                 currentFile = file;
                 worker.log({
                     message: `Loading entry point file "${file}"`,
-                    level: LogLevel.Debug,
-                    logCategory: LogCategory.System,
+                    level: rpc.RpcLog.Level.Debug,
+                    logCategory: rpc.RpcLog.RpcLogCategory.System,
                 });
                 try {
                     const entryPointFilePath = path.join(functionAppDirectory, file);
@@ -93,8 +91,8 @@ async function loadEntryPointFile(functionAppDirectory: string): Promise<void> {
                 }
                 worker.log({
                     message: `Loaded entry point file "${file}"`,
-                    level: LogLevel.Debug,
-                    logCategory: LogCategory.System,
+                    level: rpc.RpcLog.Level.Debug,
+                    logCategory: rpc.RpcLog.RpcLogCategory.System,
                 });
             }
         } catch (err) {
@@ -119,8 +117,8 @@ async function loadEntryPointFile(functionAppDirectory: string): Promise<void> {
             // Always log as rpc system log, which goes to our internal telemetry
             worker.log({
                 message: newMessage,
-                level: LogLevel.Error,
-                logCategory: LogCategory.System,
+                level: rpc.RpcLog.Level.Error,
+                logCategory: rpc.RpcLog.RpcLogCategory.System,
             });
             error.loggedOverRpc = true;
         }

src/utils/blockedMonitor.ts

@@ -2,8 +2,6 @@
 // Licensed under the MIT License.
 
 import { AzureFunctionsRpcMessages as rpc } from './../../azure-functions-language-worker-protobuf/src/rpc';
-import LogCategory = rpc.RpcLog.RpcLogCategory;
-import LogLevel = rpc.RpcLog.Level;
 import blockedAt = require('blocked-at');
 
 export function startBlockedMonitor(
@@ -14,8 +12,8 @@ export function startBlockedMonitor(
     function logBlockedWarning(message: string) {
         worker.log({
             message,
-            level: LogLevel.Warning,
-            logCategory: LogCategory.System,
+            level: rpc.RpcLog.Level.Warning,
+            logCategory: rpc.RpcLog.RpcLogCategory.System,
         });
     }