Adding warning for callback handlers

Author: Fabiana Severin

src/UserFunction.js

@@ -311,10 +311,16 @@ module.exports.isHandlerFunction = function (value) {
   return typeof value === 'function';
 };
 
+function _isAsync(handlerFunc) {
+  return handlerFunc.constructor.name === 'AsyncFunction';
+}
+
 module.exports.getHandlerMetadata = function (handlerFunc) {
   return {
     streaming: _isHandlerStreaming(handlerFunc),
     highWaterMark: _highWaterMark(handlerFunc),
+    isAsync: _isAsync(handlerFunc),
+    argsNum: handlerFunc.length,
   };
 };
 

src/WarningForCallbackHandlers.js

@@ -0,0 +1,24 @@
+/*
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: Apache-2.0
+*/
+
+'use strict';
+
+const shouldWarnOnCallbackFunctionUse = (metadata) => {
+  return (
+    process.env.AWS_LAMBDA_NODEJS_DISABLE_CALLBACK_WARNING === undefined &&
+    metadata !== undefined &&
+    metadata.argsNum == 3 &&
+    metadata.isAsync == false &&
+    metadata.streaming == false
+  );
+};
+
+module.exports.checkForDeprecatedCallback = function (metadata) {
+  if (shouldWarnOnCallbackFunctionUse(metadata)) {
+    console.warn(
+      `AWS Lambda plans to remove support for callback-based function handlers starting with Node.js 24. You will need to update this function to use an async handler to use Node.js 24 or later. For more information and to provide feedback on this change, see https://github.com/aws/aws-lambda-nodejs-runtime-interface-client/issues/137. To disable this warning, set the AWS_LAMBDA_NODEJS_DISABLE_CALLBACK_WARNING environment variable.`,
+    );
+  }
+};

src/index.mjs

@@ -11,6 +11,7 @@ const UserFunction = require('./UserFunction.js');
 const Errors = require('./Errors.js');
 const BeforeExitListener = require('./BeforeExitListener.js');
 const LogPatch = require('./LogPatch');
+const { checkForDeprecatedCallback } = require('./WarningForCallbackHandlers');
 
 export async function run(appRootOrHandler, handler = '') {
   LogPatch.patchConsole();
@@ -44,6 +45,7 @@ export async function run(appRootOrHandler, handler = '') {
     : await UserFunction.load(appRootOrHandler, handler);
 
   const metadata = UserFunction.getHandlerMetadata(handlerFunc);
+  checkForDeprecatedCallback(metadata);
   new Runtime(
     client,
     handlerFunc,

test/unit/WarningForCallbackHandlersTest.js

@@ -0,0 +1,68 @@
+/*
+Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+SPDX-License-Identifier: Apache-2.0
+*/
+
+'use strict';
+
+require('should');
+
+let { captureStream, consoleSnapshot } = require('./LoggingGlobals');
+
+let {
+  checkForDeprecatedCallback,
+} = require('../../src/WarningForCallbackHandlers.js');
+
+let LogPatch = require('lambda-runtime/LogPatch');
+const UserFunction = require('lambda-runtime/UserFunction.js');
+
+const path = require('path');
+const TEST_ROOT = path.join(__dirname, '../');
+const HANDLERS_ROOT = path.join(TEST_ROOT, 'handlers');
+
+describe('Formatted Error Logging', () => {
+  let restoreConsole = consoleSnapshot();
+  let capturedStdout = captureStream(process.stdout);
+
+  beforeEach(
+    'delete env var',
+    () => delete process.env.AWS_LAMBDA_NODEJS_DISABLE_CALLBACK_WARNING,
+  );
+  beforeEach('capture stdout', () => capturedStdout.hook());
+  beforeEach('apply console patch', () => LogPatch.patchConsole());
+  afterEach('remove console patch', () => restoreConsole());
+  afterEach('unhook stdout', () => capturedStdout.unhook());
+
+  const expectedString =
+    'AWS Lambda plans to remove support for callback-based function handlers';
+
+  const tests = [
+    { args: [false, 'isAsyncCallback.handler'], expected: true },
+    { args: [true, 'isAsyncCallback.handler'], expected: false },
+    { args: [false, 'isAsync.handlerAsync'], expected: false },
+    { args: [true, 'isAsync.handlerAsync'], expected: false },
+    { args: [false, 'defaultHandler.default'], expected: false },
+    { args: [true, 'defaultHandler.default'], expected: false },
+  ];
+
+  tests.forEach(({ args, expected }) => {
+    const shouldDeclareEnv = args[0];
+    const handler = args[1];
+    it(`When AWS_LAMBDA_NODEJS_DISABLE_CALLBACK_WARNING=${shouldDeclareEnv} expecting ${
+      expected ? 'no ' : ''
+    }warning logs for handler ${handler}`, async () => {
+      if (shouldDeclareEnv) {
+        process.env.AWS_LAMBDA_NODEJS_DISABLE_CALLBACK_WARNING = 1;
+      }
+      const handlerFunc = await UserFunction.load(HANDLERS_ROOT, handler);
+      const metadata = UserFunction.getHandlerMetadata(handlerFunc);
+
+      checkForDeprecatedCallback(metadata);
+      if (expected) {
+        capturedStdout.captured().should.containEql(expectedString);
+      } else {
+        capturedStdout.captured().should.not.containEql(expectedString);
+      }
+    });
+  });
+});