chore : updated function to extract nested handlers with test cases (#325)

aavinash-nr · web-flow · commit e552257f140b · 2025-07-03T15:01:50.000+05:30
updated function to extract nested handlers
diff --git a/nodejs/index.js b/nodejs/index.js
@@ -14,6 +14,13 @@ const newrelic = require('newrelic')
 const fs = require('node:fs')
 const path = require('node:path')
 
+function getNestedHandler(object, nestedProperty) {
+  return nestedProperty.split('.').reduce((nested, key) => {
+    return nested && nested[key]
+  }, object)
+}
+
+
 function getHandlerPath() {
   let handler
   const { NEW_RELIC_LAMBDA_HANDLER } = process.env
@@ -32,9 +39,12 @@ function getHandlerPath() {
     )
   }
 
-  const handlerToWrap = parts[parts.length - 1]
-  const moduleToImport = handler.slice(0, handler.lastIndexOf('.'))
-  return { moduleToImport, handlerToWrap }
+  const lastSlashIndex = handler.lastIndexOf('/') + 1
+  const firstDotAfterSlash = handler.indexOf('.', lastSlashIndex)
+  const moduleToImport = handler.slice(0, firstDotAfterSlash)
+  const handlerToWrap = handler.slice(firstDotAfterSlash + 1)
+
+  return {moduleToImport, handlerToWrap}
 }
 
 function handleRequireImportError(e, moduleToImport) {
@@ -117,14 +127,17 @@ if (process.env.NEW_RELIC_USE_ESM === 'true') {
 }
 
 async function getHandler() {
-  const userHandler = (await getModuleWithImport(LAMBDA_TASK_ROOT, moduleToImport))[handlerToWrap]
+  const userModule = await getModuleWithImport(LAMBDA_TASK_ROOT, moduleToImport)
+  const userHandler = getNestedHandler(userModule, handlerToWrap)
+
   validateHandlerDefinition(userHandler, handlerToWrap, moduleToImport)
 
   return userHandler
 }
 
 function getHandlerSync() {
-  const userHandler = getModuleWithRequire(LAMBDA_TASK_ROOT, moduleToImport)[handlerToWrap]
+  const userModule = getModuleWithRequire(LAMBDA_TASK_ROOT, moduleToImport)
+  const userHandler = getNestedHandler(userModule, handlerToWrap)
   validateHandlerDefinition(userHandler, handlerToWrap, moduleToImport)
 
   return userHandler
diff --git a/nodejs/test/integration/cjs/handler.js b/nodejs/test/integration/cjs/handler.js
@@ -186,3 +186,40 @@ module.exports.TestPayloadSchemaValidation = (event, context, callback) => {
     statusCode: 200,
   })
 }
+
+module.exports.nested = {
+  contextDoneHandler: function contextDoneHandler(event, context) {
+    context.done(null, {
+      body: JSON.stringify('foo'),
+      statusCode: 200,
+    })
+  },
+
+  contextSucceedHandler: function contextSucceedHandler(event, context) {
+    context.succeed({
+      body: JSON.stringify('foo'),
+      statusCode: 200,
+    })
+  },
+
+  callbackHandler: function callbackHandler(event, context, callback) {
+    callback(null, {
+      body: JSON.stringify('foo'),
+      statusCode: 200,
+    })
+  },
+
+  promiseHandler: function promiseHandler() {
+    return Promise.resolve({
+      body: JSON.stringify('foo'),
+      statusCode: 200,
+    })
+  },
+
+  asyncFunctionHandler: async function asyncFunctionHandler() {
+    return {
+      body: JSON.stringify('foo'),
+      statusCode: 200,
+    }
+  },
+}
diff --git a/nodejs/test/integration/cjs/index.tap.js b/nodejs/test/integration/cjs/index.tap.js
@@ -134,6 +134,36 @@ tap.test('CJS Handler Integration Tests', (t) => {
       path: '/dev/callback-inside-promise-handler',
       status: 200,
     },
+    {
+      description: 'when nested handler uses context.done',
+      expected: 'foo',
+      path: '/dev/nested/context-done-handler',
+      status: 200,
+    },
+    {
+      description: 'when nested handler uses context.succeed',
+      expected: 'foo',
+      path: '/dev/nested/context-succeed-handler',
+      status: 200,
+    },
+    {
+      description: 'when nested handler uses a callback',
+      expected: 'foo',
+      path: '/dev/nested/callback-handler',
+      status: 200,
+    },
+    {
+      description: 'when nested handler returns a promise',
+      expected: 'foo',
+      path: '/dev/nested/promise-handler',
+      status: 200,
+    },
+    {
+      description: 'when nested handler uses an async function',
+      expected: 'foo',
+      path: '/dev/nested/async-function-handler',
+      status: 200,
+    },
   ].forEach(({ description, expected, path, status }) => {
     t.test(description, async(t) => {
       const url = new URL(path, BASE_URL)
diff --git a/nodejs/test/integration/esm/handler.js b/nodejs/test/integration/esm/handler.js
@@ -125,6 +125,7 @@ export function callbackWithContextDoneHandler(event, context, callback) {
   })
 }
 
+
 export function callbackWithPromiseHandler(event, context, callback) {
   callback(null, {
     body: stringify('Hello Callback!'),
@@ -168,3 +169,39 @@ export const BadAnswerInPromiseHandler = async() => {
 export const BadAnswerInCallbackHandler = (event, context, callback) => {
   callback(null, {})
 }
+export const nested = {
+  contextDoneHandler: function contextDoneHandler(event, context) {
+    context.done(null, {
+      body: JSON.stringify('foo'),
+      statusCode: 200,
+    })
+  },
+
+  contextSucceedHandler: function contextSucceedHandler(event, context) {
+    context.succeed({
+      body: JSON.stringify('foo'),
+      statusCode: 200,
+    })
+  },
+
+  callbackHandler: function callbackHandler(event, context, callback) {
+    callback(null, {
+      body: JSON.stringify('foo'),
+      statusCode: 200,
+    })
+  },
+
+  promiseHandler: function promiseHandler() {
+    return Promise.resolve({
+      body: JSON.stringify('foo'),
+      statusCode: 200,
+    })
+  },
+
+  asyncFunctionHandler: async function asyncFunctionHandler() {
+    return {
+      body: JSON.stringify('foo'),
+      statusCode: 200,
+    }
+  },
+}
diff --git a/nodejs/test/integration/esm/index.tap.js b/nodejs/test/integration/esm/index.tap.js
@@ -135,6 +135,36 @@ tap.test('ESM Handler Integration Tests', (t) => {
       path: '/dev/callback-inside-promise-handler',
       status: 200,
     },
+    {
+      description: 'when nested handler uses context.done',
+      expected: 'foo',
+      path: '/dev/nested/context-done-handler',
+      status: 200,
+    },
+    {
+      description: 'when nested handler uses context.succeed',
+      expected: 'foo',
+      path: '/dev/nested/context-succeed-handler',
+      status: 200,
+    },
+    {
+      description: 'when nested handler uses a callback',
+      expected: 'foo',
+      path: '/dev/nested/callback-handler',
+      status: 200,
+    },
+    {
+      description: 'when nested handler returns a promise',
+      expected: 'foo',
+      path: '/dev/nested/promise-handler',
+      status: 200,
+    },
+    {
+      description: 'when nested handler uses an async function',
+      expected: 'foo',
+      path: '/dev/nested/async-function-handler',
+      status: 200,
+    },
   ].forEach(({ description, expected, path, status }) => {
     t.test(description, async(t) => {
       const url = new URL(path, BASE_URL)
diff --git a/nodejs/test/integration/serverless.yml b/nodejs/test/integration/serverless.yml
@@ -221,3 +221,58 @@ functions:
       NEW_RELIC_LAMBDA_HANDLER: ./${env:MODULE_TYPE}/handler.BadAnswerInCallbackHandler
       NEW_RELIC_LAMBDA_EXTENSION_ENABLED: false
       LAMBDA_TASK_ROOT: ./
+  nestedContextDoneHandler:
+    events:
+      - http:
+          method: get
+          path: nested/context-done-handler
+    handler: ${env:HANDLER}
+    environment:
+      NEW_RELIC_USE_ESM: ${env:NEW_RELIC_USE_ESM}
+      NEW_RELIC_LAMBDA_HANDLER: ./${env:MODULE_TYPE}/handler.nested.contextDoneHandler
+      NEW_RELIC_LAMBDA_EXTENSION_ENABLED: false
+      LAMBDA_TASK_ROOT: ./
+  nestedContextSucceedHandler:
+    events:
+      - http:
+          method: get
+          path: nested/context-succeed-handler
+    handler: ${env:HANDLER}
+    environment:
+      NEW_RELIC_USE_ESM: ${env:NEW_RELIC_USE_ESM}
+      NEW_RELIC_LAMBDA_HANDLER: ./${env:MODULE_TYPE}/handler.nested.contextSucceedHandler
+      NEW_RELIC_LAMBDA_EXTENSION_ENABLED: false
+      LAMBDA_TASK_ROOT: ./
+  nestedCallbackHandler:
+    events:
+      - http:
+          method: get
+          path: nested/callback-handler
+    handler: ${env:HANDLER}
+    environment:
+      NEW_RELIC_USE_ESM: ${env:NEW_RELIC_USE_ESM}
+      NEW_RELIC_LAMBDA_HANDLER: ./${env:MODULE_TYPE}/handler.nested.callbackHandler
+      NEW_RELIC_LAMBDA_EXTENSION_ENABLED: false
+      LAMBDA_TASK_ROOT: ./
+  nestedPromiseHandler:
+    events:
+      - http:
+          method: get
+          path: nested/promise-handler
+    handler: ${env:HANDLER}
+    environment:
+      NEW_RELIC_USE_ESM: ${env:NEW_RELIC_USE_ESM}
+      NEW_RELIC_LAMBDA_HANDLER: ./${env:MODULE_TYPE}/handler.nested.promiseHandler
+      NEW_RELIC_LAMBDA_EXTENSION_ENABLED: false
+      LAMBDA_TASK_ROOT: ./
+  nestedAsyncFunctionHandler:
+    events:
+      - http:
+          method: get
+          path: nested/async-function-handler
+    handler: ${env:HANDLER}
+    environment:
+      NEW_RELIC_USE_ESM: ${env:NEW_RELIC_USE_ESM}
+      NEW_RELIC_LAMBDA_HANDLER: ./${env:MODULE_TYPE}/handler.nested.asyncFunctionHandler
+      NEW_RELIC_LAMBDA_EXTENSION_ENABLED: false
+      LAMBDA_TASK_ROOT: ./
diff --git a/nodejs/test/unit/cjsErrorStates.tap.js b/nodejs/test/unit/cjsErrorStates.tap.js
@@ -35,6 +35,26 @@ const handlerAndPath = [
     handlerFile: 'badImport',
     method: 'handler'
   },
+  {
+    handlerFile: 'nestedHandler',
+    handlerMethod: 'nested.contextDoneHandler'
+  },
+  {
+    handlerFile: 'nestedHandler',
+    handlerMethod: 'nested.contextSucceedHandler'
+  },
+  {
+    handlerFile: 'nestedHandler',
+    handlerMethod: 'nested.callbackHandler'
+  },
+  {
+    handlerFile: 'nestedHandler',
+    handlerMethod: 'nested.promiseHandler'
+  },
+  {
+    handlerFile: 'nestedHandler',
+    handlerMethod: 'nested.asyncFunctionHandler'
+  }
 ]
 
 tap.test('CJS Edge Cases', (t) => {
diff --git a/nodejs/test/unit/cjsHandler.tap.js b/nodejs/test/unit/cjsHandler.tap.js
@@ -22,6 +22,7 @@ tap.test('Layer Handler - CJS Function', (t) => {
     })
     t.context.helper = helper
     t.context.handler = handler
+    t.context.newrelic = newrelic
   })
 
   t.afterEach((t) => {
@@ -46,4 +47,25 @@ tap.test('Layer Handler - CJS Function', (t) => {
     t.same(res, { statusCode: 200, body: 'response body this is a test' }, 'response should be correct')
     await promise
   })
+
+  t.test('should wrap nested asyncFunctionHandler in transaction', async(t) => {
+    process.env.NEW_RELIC_LAMBDA_HANDLER = 'test/unit/fixtures/cjs/handler.nested.asyncFunctionHandler'
+
+    const { handler } = proxyquire('../../index', {
+      'newrelic': t.context.newrelic
+    })
+    t.context.handler = handler
+
+    const promise = new Promise((resolve) => {
+      t.context.helper.agent.on('transactionFinished', (transaction) => {
+        t.equal(transaction.name, 'OtherTransaction/Function/testFn', 'transaction should be properly named')
+        resolve()
+      })
+    })
+
+    t.equal(typeof handler, 'function', 'handler should be a function')
+    const res = await handler({ key: 'this is a test'}, { functionName: 'testFn'})
+    t.same(res, { statusCode: 200, body: JSON.stringify('foo') }, 'response should be correct')
+    await promise
+  })
 })
diff --git a/nodejs/test/unit/esmErrorStates.tap.js b/nodejs/test/unit/esmErrorStates.tap.js
@@ -30,6 +30,26 @@ const testCases = [
     handlerFile: 'errors',
     handlerMethod: 'notAfunction'
   },
+  {
+    handlerFile: 'nestedHandler',
+    handlerMethod: 'nested.contextDoneHandler'
+  },
+  {
+    handlerFile: 'nestedHandler',
+    handlerMethod: 'nested.contextSucceedHandler'
+  },
+  {
+    handlerFile: 'nestedHandler',
+    handlerMethod: 'nested.callbackHandler'
+  },
+  {
+    handlerFile: 'nestedHandler',
+    handlerMethod: 'nested.promiseHandler'
+  },
+  {
+    handlerFile: 'nestedHandler',
+    handlerMethod: 'nested.asyncFunctionHandler'
+  }
 ]
 
 tap.test('Early-throwing ESM Edge Cases', (t) => {
diff --git a/nodejs/test/unit/esmHandler.tap.js b/nodejs/test/unit/esmHandler.tap.js
@@ -16,10 +16,11 @@ tap.test('Layer Handler - ESM Function', (t) => {
 
     const newrelic = helper.getAgentApi()
     await td.replaceEsm('newrelic', {}, newrelic)
-    const { handler } =  await import('../../esm.mjs')
+    const { handler } = await import('../../esm.mjs')
     t.context.helper = helper
     t.context.handler = handler
     t.context.originalEnv = originalEnv
+    t.context.newrelic = newrelic
   })
 
   t.afterEach((t) => {
@@ -44,4 +45,25 @@ tap.test('Layer Handler - ESM Function', (t) => {
     t.same(res, { statusCode: 200, body: 'response body this is a test' }, 'response should be correct')
     await promise
   })
+
+  t.test('should wrap nested asyncFunctionHandler in transaction', async(t) => {
+    process.env.NEW_RELIC_LAMBDA_HANDLER = 'test/unit/fixtures/esm/handler.nested.asyncFunctionHandler'
+
+    const newrelic = t.context.newrelic
+    await td.replaceEsm('newrelic', {}, newrelic)
+    const { handler } = await import('../../esm.mjs')
+    t.context.handler = handler
+
+    const promise = new Promise((resolve) => {
+      t.context.helper.agent.on('transactionFinished', (transaction) => {
+        t.equal(transaction.name, 'OtherTransaction/Function/testFn', 'transaction should be properly named')
+        resolve()
+      })
+    })
+
+    t.equal(typeof handler, 'function', 'handler should be a function')
+    const res = await handler({ key: 'this is a test'}, { functionName: 'testFn'})
+    t.same(res, { statusCode: 200, body: JSON.stringify('foo') }, 'response should be correct')
+    await promise
+  })
 })
diff --git a/nodejs/test/unit/fixtures/cjs/badRequire.js b/nodejs/test/unit/fixtures/cjs/badRequire.js
diff --git a/nodejs/test/unit/fixtures/cjs/handler.js b/nodejs/test/unit/fixtures/cjs/handler.js
diff --git a/nodejs/test/unit/fixtures/esm/badImport.mjs b/nodejs/test/unit/fixtures/esm/badImport.mjs
diff --git a/nodejs/test/unit/fixtures/esm/handler.mjs b/nodejs/test/unit/fixtures/esm/handler.mjs
diff --git a/nodejs/test/unit/legacyEsmErrorStates.tap.js b/nodejs/test/unit/legacyEsmErrorStates.tap.js
