lambda.js

/*
 * Copyright Elasticsearch B.V. and other contributors where applicable.
 * Licensed under the BSD 2-Clause License; you may not use this file except in
 * compliance with the BSD 2-Clause License.
 */

'use strict';

const constants = require('./constants');
const shimmer = require('./instrumentation/shimmer');
const fs = require('fs');
const path = require('path');
const querystring = require('querystring');

const { MAX_MESSAGES_PROCESSED_FOR_TRACE_CONTEXT } = require('./constants');

// https://github.com/elastic/apm/blob/main/specs/agents/tracing-instrumentation-aws-lambda.md#deriving-cold-starts
let isFirstRun = true;
let gFaasId; // Set on first invocation.

// The trigger types for which we support special handling.
// https://docs.aws.amazon.com/lambda/latest/dg/lambda-services.html
const TRIGGER_GENERIC = 1;
const TRIGGER_API_GATEWAY = 2; // This includes Lambda URLs which use the same event format.
const TRIGGER_SNS = 3;
const TRIGGER_SQS = 4;
const TRIGGER_S3_SINGLE_EVENT = 5;
const TRIGGER_ELB = 6; // Elastic Load Balancer, aka Application Load Balancer

function triggerTypeFromEvent(event) {
  if (event.requestContext) {
    if (event.requestContext.elb) {
      return TRIGGER_ELB;
    } else if (event.requestContext.requestId) {
      return TRIGGER_API_GATEWAY;
    }
  }
  if (event.Records && event.Records.length >= 1) {
    const eventSource =
      event.Records[0].eventSource || // S3 and SQS
      event.Records[0].EventSource; // SNS
    if (eventSource === 'aws:sns') {
      return TRIGGER_SNS;
    } else if (eventSource === 'aws:sqs') {
      return TRIGGER_SQS;
    } else if (eventSource === 'aws:s3' && event.Records.length === 1) {
      return TRIGGER_S3_SINGLE_EVENT;
    }
  }
  return TRIGGER_GENERIC;
}

// Gather APM metadata for this Lambda executor per
// https://github.com/elastic/apm/blob/main/specs/agents/tracing-instrumentation-aws-lambda.md#overwriting-metadata
function getMetadata(agent, cloudAccountId) {
  return {
    service: {
      framework: {
        // Passing this service.framework.name to Client#setExtraMetadata()
        // ensures that it "wins" over a framework name from
        // `agent.setFramework()`, because in the client `_extraMetadata`
        // wins over `_conf.frameworkName`.
        name: 'AWS Lambda',
      },
      runtime: {
        name: process.env.AWS_EXECUTION_ENV,
      },
      node: {
        configured_name: process.env.AWS_LAMBDA_LOG_STREAM_NAME,
      },
    },
    cloud: {
      provider: 'aws',
      region: process.env.AWS_REGION,
      service: {
        name: 'lambda',
      },
      account: {
        id: cloudAccountId,
      },
    },
  };
}

function getFaasData(context, faasId, isColdStart, faasTriggerType, requestId) {
  const faasData = {
    id: faasId,
    name: context.functionName,
    version: context.functionVersion,
    coldstart: isColdStart,
    execution: context.awsRequestId,
    trigger: {
      type: faasTriggerType,
    },
  };
  if (requestId) {
    faasData.trigger.request_id = requestId;
  }
  return faasData;
}

function setGenericData(trans, event, context, faasId, isColdStart) {
  trans.type = 'request';
  trans.setDefaultName(context.functionName);

  trans.setFaas(getFaasData(context, faasId, isColdStart, 'other'));

  const cloudContext = {
    origin: {
      provider: 'aws',
    },
  };
  trans.setCloudContext(cloudContext);
}

// Set transaction data for an API Gateway triggered invocation.
//
// Handle API Gateway payload format vers 1.0 (a.k.a "REST") and 2.0 ("HTTP").
// https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
function setApiGatewayData(agent, trans, event, context, faasId, isColdStart) {
  const requestContext = event.requestContext;

  let name;
  let pseudoReq;
  if (requestContext.http) {
    // 2.0
    if (agent._conf.usePathAsTransactionName) {
      name = `${requestContext.http.method} ${requestContext.http.path}`;
    } else {
      // Get a routeKeyPath from the routeKey:
      //    GET /some/path  ->  /some/path
      //    ANY /some/path  ->  /some/path
      //    $default        ->  /$default
      let routeKeyPath = requestContext.routeKey;
      const spaceIdx = routeKeyPath.indexOf(' ');
      if (spaceIdx === -1) {
        routeKeyPath = '/' + routeKeyPath;
      } else {
        routeKeyPath = routeKeyPath.slice(spaceIdx + 1);
      }
      name = `${requestContext.http.method} /${requestContext.stage}${routeKeyPath}`;
    }
    pseudoReq = {
      httpVersion: requestContext.http.protocol
        ? requestContext.http.protocol.split('/')[1] // 'HTTP/1.1' -> '1.1'
        : undefined,
      method: requestContext.http.method,
      url:
        event.rawPath +
        (event.rawQueryString ? '?' + event.rawQueryString : ''),
      headers: event.normedHeaders || {},
      socket: { remoteAddress: requestContext.http.sourceIp },
      body: event.body,
    };
  } else {
    // payload version format 1.0
    if (agent._conf.usePathAsTransactionName) {
      name = `${requestContext.httpMethod} ${requestContext.path}`;
    } else {
      name = `${requestContext.httpMethod} /${requestContext.stage}${requestContext.resourcePath}`;
    }
    pseudoReq = {
      httpVersion: requestContext.protocol
        ? requestContext.protocol.split('/')[1] // 'HTTP/1.1' -> '1.1'
        : undefined,
      method: requestContext.httpMethod,
      url:
        requestContext.path +
        (event.queryStringParameters
          ? '?' + querystring.encode(event.queryStringParameters)
          : ''),
      headers: event.normedHeaders || {},
      socket: {
        remoteAddress:
          requestContext.identity && requestContext.identity.sourceIp,
      },
      // Limitation: Note that `getContextFromRequest` does *not* use this body,
      // because API Gateway payload format 1.0 does not include the
      // Content-Length header from the original request.
      body: event.body,
    };
  }
  trans.type = 'request';
  trans.setDefaultName(name);
  trans.req = pseudoReq; // Used by parsers.getContextFromRequest() for adding context to transaction and errors.

  trans.setFaas(
    getFaasData(context, faasId, isColdStart, 'http', requestContext.requestId),
  );

  const serviceContext = {
    origin: {
      name: requestContext.domainName,
      id: requestContext.apiId,
      version: event.version || '1.0',
    },
  };
  trans.setServiceContext(serviceContext);

  const originSvcName =
    // `<url-id>.lambda-url.<region>.on.aws` indicates this is a Lambda URL.
    requestContext.domainName &&
    requestContext.domainPrefix &&
    requestContext.domainName.startsWith(
      requestContext.domainPrefix + '.lambda-url.',
    )
      ? 'lambda url'
      : 'api gateway';
  const cloudContext = {
    origin: {
      provider: 'aws',
      service: {
        name: originSvcName,
      },
      account: {
        id: requestContext.accountId,
      },
    },
  };
  trans.setCloudContext(cloudContext);
}

function setTransDataFromApiGatewayResult(err, result, trans, event) {
  if (err) {
    trans.result = 'HTTP 5xx';
    trans._setOutcomeFromHttpStatusCode(500);
  } else if (result && result.statusCode) {
    trans.result = 'HTTP ' + result.statusCode.toString()[0] + 'xx';
    trans._setOutcomeFromHttpStatusCode(result.statusCode);
  } else {
    trans.result = constants.RESULT_SUCCESS;
    trans._setOutcomeFromHttpStatusCode(200);
  }

  // This doc defines the format of API Gateway-triggered responses, from which
  // we can infer `transaction.context.response` values.
  // https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html#http-api-develop-integrations-lambda.response
  // https://docs.aws.amazon.com/lambda/latest/dg/urls-invocation.html#urls-payloads
  if (err) {
    trans.res = {
      statusCode: 500,
    };
  } else if (event.requestContext.http) {
    // payload format version 2.0
    if (result && result.statusCode) {
      trans.res = {
        statusCode: result.statusCode,
        headers: result.headers,
      };
    } else {
      trans.res = {
        statusCode: 200,
        headers: { 'content-type': 'application/json' },
      };
    }
  } else {
    // payload format version 1.0
    if (result && result.statusCode) {
      trans.res = {
        statusCode: result.statusCode,
        headers: result.headers,
      };
    }
  }
}

// https://docs.aws.amazon.com/lambda/latest/dg/services-alb.html
function setElbData(agent, trans, event, context, faasId, isColdStart) {
  trans.type = 'request';
  let name;
  if (agent._conf.usePathAsTransactionName) {
    name = `${event.httpMethod} ${event.path}`;
  } else {
    name = `${event.httpMethod} unknown route`;
  }
  trans.setDefaultName(name);
  trans.req = {
    // Used by parsers.getContextFromRequest() for adding context to transaction and errors.
    method: event.httpMethod,
    url:
      event.path +
      (event.queryStringParameters &&
      Object.keys(event.queryStringParameters) > 0
        ? '?' + querystring.encode(event.queryStringParameters)
        : ''),
    headers: event.normedHeaders || {},
    body: event.body,
    bodyIsBase64Encoded: event.isBase64Encoded,
  };

  trans.setFaas(getFaasData(context, faasId, isColdStart, 'http'));

  const targetGroupArn = event.requestContext.elb.targetGroupArn;
  const arnParts = targetGroupArn.split(':');
  trans.setServiceContext({
    origin: {
      name: arnParts[5].split('/')[1],
      id: targetGroupArn,
    },
  });

  trans.setCloudContext({
    origin: {
      provider: 'aws',
      region: arnParts[3],
      service: {
        name: 'elb',
      },
      account: {
        id: arnParts[4],
      },
    },
  });
}

function setTransDataFromElbResult(err, result, trans) {
  // ELB defaults to 502 Bad Gateway if there is an error or `result.statusCode`
  // is missing or not an integer.
  const validStatusCode =
    result &&
    result.statusCode &&
    typeof result.statusCode === 'number' &&
    Number.isInteger(result.statusCode)
      ? result.statusCode
      : null;

  if (err) {
    trans.result = 'HTTP 5xx';
  } else if (validStatusCode) {
    trans.result = 'HTTP ' + validStatusCode.toString()[0] + 'xx';
  } else {
    trans.result = 'HTTP 5xx';
  }

  // Set an appropriate pseudo `trans.res`, used by `parsers.getContextFromResponse()`.
  if (err) {
    trans.res = {
      statusCode: 502,
    };
  } else {
    trans.res = {
      statusCode: validStatusCode || 502,
      headers: result.headers,
    };
  }

  trans._setOutcomeFromHttpStatusCode(validStatusCode || 502);
}

function setSqsData(agent, trans, event, context, faasId, isColdStart) {
  const record = event && event.Records && event.Records[0];
  const eventSourceARN = record.eventSourceARN ? record.eventSourceARN : '';

  trans.setFaas(getFaasData(context, faasId, isColdStart, 'pubsub'));

  const arnParts = eventSourceARN.split(':');
  const queueName = arnParts[5];
  const accountId = arnParts[4];

  trans.setDefaultName(`RECEIVE ${queueName}`);
  trans.type = 'messaging';

  const serviceContext = {
    origin: {
      name: queueName,
      id: eventSourceARN,
    },
  };
  trans.setServiceContext(serviceContext);

  const cloudContext = {
    origin: {
      provider: 'aws',
      region: record.awsRegion,
      service: {
        name: 'sqs',
      },
      account: {
        id: accountId,
      },
    },
  };
  trans.setCloudContext(cloudContext);

  const links = spanLinksFromSqsRecords(event.Records);
  trans._addLinks(links);
}

function setSnsData(agent, trans, event, context, faasId, isColdStart) {
  const record = event && event.Records && event.Records[0];
  const sns = record && record.Sns;

  trans.setFaas(getFaasData(context, faasId, isColdStart, 'pubsub'));

  const topicArn = (sns && sns.TopicArn) || '';
  const arnParts = topicArn.split(':');
  const topicName = arnParts[5];
  const accountId = arnParts[4];
  const region = arnParts[3];

  trans.setDefaultName(`RECEIVE ${topicName}`);
  trans.type = 'messaging';

  const serviceContext = {
    origin: {
      name: topicName,
      id: topicArn,
    },
  };
  trans.setServiceContext(serviceContext);

  const cloudContext = {
    origin: {
      provider: 'aws',
      region,
      service: {
        name: 'sns',
      },
      account: {
        id: accountId,
      },
    },
  };
  trans.setCloudContext(cloudContext);

  const links = spanLinksFromSnsRecords(event.Records);
  trans._addLinks(links);
}

function setS3SingleData(trans, event, context, faasId, isColdStart) {
  const record = event.Records[0];

  trans.setFaas(
    getFaasData(
      context,
      faasId,
      isColdStart,
      'datasource',
      record.responseElements && record.responseElements['x-amz-request-id'],
    ),
  );

  trans.setDefaultName(
    `${record && record.eventName} ${
      record && record.s3 && record.s3.bucket && record.s3.bucket.name
    }`,
  );
  trans.type = 'request';

  const serviceContext = {
    origin: {
      name: record && record.s3 && record.s3.bucket && record.s3.bucket.name,
      id: record && record.s3 && record.s3.bucket && record.s3.bucket.arn,
      version: record.eventVersion,
    },
  };
  trans.setServiceContext(serviceContext);

  const cloudContext = {
    origin: {
      provider: 'aws',
      service: {
        name: 's3',
      },
      region: record.awsRegion,
    },
  };
  trans.setCloudContext(cloudContext);
}

function elasticApmAwsLambda(agent) {
  const log = agent.logger;
  const ins = agent._instrumentation;

  /**
   * Register this transaction with the Lambda extension, if possible.  This
   * function is `await`able so that the transaction is registered before
   * executing the user's Lambda handler.
   *
   * Perf note: Using a Lambda sized to have 1 vCPU (1769MB memory), some
   * rudimentary perf tests showed an average of 0.8ms for this call to the ext.
   */
  function registerTransaction(trans, awsRequestId) {
    if (!agent._apmClient) {
      return;
    }
    if (!agent._apmClient.lambdaShouldRegisterTransactions()) {
      return;
    }

    // Reproduce the filtering logic from `Instrumentation.prototype.addEndedTransaction`.
    if (agent._conf.contextPropagationOnly) {
      return;
    }
    if (
      !trans.sampled &&
      !agent._apmClient.supportsKeepingUnsampledTransaction()
    ) {
      return;
    }

    var payload = trans.toJSON();
    // If this partial transaction is used, the Lambda Extension will fill in:
    // - `transaction.result` will be set to one of:
    //    - The "status" field from the Logs API platform `runtimeDone` message.
    //      https://docs.aws.amazon.com/lambda/latest/dg/runtimes-logs-api.html#runtimes-logs-api-ref-done
    //      Values: "success", "failure"
    //    - The "shutdownReason" field from the `Shutdown` event from the Extensions API.
    //      https://docs.aws.amazon.com/lambda/latest/dg/runtimes-extensions-api.html#runtimes-lifecycle-shutdown
    //      Values: "spindown", "timeout", "failure"   (I think these are the values.)
    // - `transaction.outcome` will be set to "failure" if the status above is
    //   not "success". Therefore we want a default outcome value.
    // - `transaction.duration` will be estimated
    delete payload.result;
    delete payload.duration;

    payload = agent._transactionFilters.process(payload);
    if (!payload) {
      log.trace(
        { traceId: trans.traceId, transactionId: trans.id },
        'transaction ignored by filter',
      );
      return;
    }

    return agent._apmClient.lambdaRegisterTransaction(payload, awsRequestId);
  }

  function endAndFlushTransaction(
    err,
    result,
    trans,
    event,
    context,
    triggerType,
    cb,
  ) {
    log.trace(
      { awsRequestId: context && context.awsRequestId },
      'lambda: fn end',
    );

    switch (triggerType) {
      case TRIGGER_API_GATEWAY:
        setTransDataFromApiGatewayResult(err, result, trans, event);
        break;
      case TRIGGER_ELB:
        setTransDataFromElbResult(err, result, trans);
        break;
      default:
        if (err) {
          trans.result = constants.RESULT_FAILURE;
          trans.setOutcome(constants.OUTCOME_FAILURE);
        } else {
          trans.result = constants.RESULT_SUCCESS;
          trans.setOutcome(constants.OUTCOME_SUCCESS);
        }
        break;
    }

    if (err) {
      // Capture the error before trans.end() so it associates with the
      // current trans.  `skipOutcome` to avoid setting outcome on a possible
      // currentSpan, because this error applies to the transaction, not any
      // sub-span.
      agent.captureError(err, { skipOutcome: true });
    }

    trans.end();

    agent._flush({ lambdaEnd: true, inflightTimeout: 100 }, (flushErr) => {
      if (flushErr) {
        log.error(
          { err: flushErr, awsRequestId: context && context.awsRequestId },
          'lambda: flush error',
        );
      }
      log.trace(
        { awsRequestId: context && context.awsRequestId },
        'lambda: wrapper end',
      );
      cb();
    });
  }

  function wrapContext(runContext, trans, event, context, triggerType) {
    shimmer.wrap(context, 'succeed', (origSucceed) => {
      return ins.bindFunctionToRunContext(
        runContext,
        function wrappedSucceed(result) {
          endAndFlushTransaction(
            null,
            result,
            trans,
            event,
            context,
            triggerType,
            function () {
              origSucceed(result);
            },
          );
        },
      );
    });

    shimmer.wrap(context, 'fail', (origFail) => {
      return ins.bindFunctionToRunContext(
        runContext,
        function wrappedFail(err) {
          endAndFlushTransaction(
            err,
            null,
            trans,
            event,
            context,
            triggerType,
            function () {
              origFail(err);
            },
          );
        },
      );
    });

    shimmer.wrap(context, 'done', (origDone) => {
      return wrapLambdaCallback(
        runContext,
        trans,
        event,
        context,
        triggerType,
        origDone,
      );
    });
  }

  function wrapLambdaCallback(
    runContext,
    trans,
    event,
    context,
    triggerType,
    callback,
  ) {
    return ins.bindFunctionToRunContext(
      runContext,
      function wrappedLambdaCallback(err, result) {
        endAndFlushTransaction(
          err,
          result,
          trans,
          event,
          context,
          triggerType,
          () => {
            callback(err, result);
          },
        );
      },
    );
  }

  return function wrapLambdaHandler(type, fn) {
    if (typeof type === 'function') {
      fn = type;
      type = 'request';
    }
    if (!agent._conf.active) {
      // Manual usage of `apm.lambda(...)` should be a no-op when not active.
      return fn;
    }

    return async function wrappedLambdaHandler(event, context, callback) {
      if (!(event && context && typeof callback === 'function')) {
        // Skip instrumentation if arguments are unexpected.
        // https://docs.aws.amazon.com/lambda/latest/dg/nodejs-handler.html
        return fn.call(this, ...arguments);
      }
      log.trace({ awsRequestId: context.awsRequestId }, 'lambda: fn start');

      const isColdStart = isFirstRun;
      if (isFirstRun) {
        isFirstRun = false;

        // E.g. 'arn:aws:lambda:us-west-2:123456789012:function:my-function:someAlias'
        const arnParts = context.invokedFunctionArn.split(':');
        gFaasId = arnParts.slice(0, 7).join(':');
        const cloudAccountId = arnParts[4];

        if (agent._apmClient) {
          log.trace(
            { awsRequestId: context.awsRequestId },
            'lambda: setExtraMetadata',
          );
          agent._apmClient.setExtraMetadata(getMetadata(agent, cloudAccountId));
        }
      }

      if (agent._apmClient) {
        agent._apmClient.lambdaStart();
      }

      const triggerType = triggerTypeFromEvent(event);

      // Look for trace-context info in headers or messageAttributes.
      let traceparent;
      let tracestate;
      if (
        triggerType === TRIGGER_GENERIC &&
        event.traceparent &&
        event.tracestate
      ) {
        traceparent = event.traceparent;
        tracestate = event.tracestate;
      }
      if (
        (triggerType === TRIGGER_API_GATEWAY || triggerType === TRIGGER_ELB) &&
        event.headers
      ) {
        // https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
        // says "Header names are lowercased." However, that isn't the case for
        // payload format version 1.0. We need lowercased headers for processing.
        if (!event.requestContext.http) {
          // 1.0
          event.normedHeaders = lowerCaseObjectKeys(event.headers);
        } else {
          event.normedHeaders = event.headers;
        }
        traceparent =
          event.normedHeaders.traceparent ||
          event.normedHeaders['elastic-apm-traceparent'];
        tracestate = event.normedHeaders.tracestate;
      }

      // Start the transaction and set some possibly trigger-specific data.
      const trans = agent.startTransaction(context.functionName, type, {
        childOf: traceparent,
        tracestate,
      });
      switch (triggerType) {
        case TRIGGER_API_GATEWAY:
          setApiGatewayData(agent, trans, event, context, gFaasId, isColdStart);
          break;
        case TRIGGER_ELB:
          setElbData(agent, trans, event, context, gFaasId, isColdStart);
          break;
        case TRIGGER_SQS:
          setSqsData(agent, trans, event, context, gFaasId, isColdStart);
          break;
        case TRIGGER_SNS:
          setSnsData(agent, trans, event, context, gFaasId, isColdStart);
          break;
        case TRIGGER_S3_SINGLE_EVENT:
          setS3SingleData(trans, event, context, gFaasId, isColdStart);
          break;
        case TRIGGER_GENERIC:
          setGenericData(trans, event, context, gFaasId, isColdStart);
          break;
        default:
          log.warn(
            `not setting transaction data for triggerType=${triggerType}`,
          );
      }

      // Wrap context and callback to finish and send transaction.
      // Note: Wrapping context needs to happen *before any `await` calls* in
      // this function, otherwise the Lambda Node.js Runtime will call the
      // *unwrapped* `context.{succeed,fail,done}()` methods.
      const transRunContext = ins.currRunContext();
      wrapContext(transRunContext, trans, event, context, triggerType);
      const wrappedCallback = wrapLambdaCallback(
        transRunContext,
        trans,
        event,
        context,
        triggerType,
        callback,
      );

      await registerTransaction(trans, context.awsRequestId);

      try {
        const retval = ins.withRunContext(
          transRunContext,
          fn,
          this,
          event,
          context,
          wrappedCallback,
        );
        if (retval instanceof Promise) {
          return retval;
        } else {
          // In this case, our wrapping of the user's handler has changed it
          // from a sync function to an async function. We need to ensure the
          // Lambda Runtime does not end the invocation based on this returned
          // promise -- the invocation should end when the `callback` is called
          // -- so we return a promise that never resolves.
          return new Promise((resolve, reject) => {
            /* never resolves */
          });
        }
      } catch (handlerErr) {
        wrappedCallback(handlerErr);
        // Return a promise that never resolves, so that the Lambda Runtime's
        // doesn't attempt its "success" handling.
        return new Promise((resolve, reject) => {
          /* never resolves */
        });
      }
    };
  };
}

function isLambdaExecutionEnvironment() {
  return !!process.env.AWS_LAMBDA_FUNCTION_NAME;
}

function isHandlerNameInModules(handlerModule, modules) {
  for (let instrumentedModules of modules) {
    // array.flat didn't come around until Node 11
    if (!Array.isArray(instrumentedModules)) {
      instrumentedModules = [instrumentedModules];
    }
    for (const instrumentedModule of instrumentedModules) {
      if (handlerModule === instrumentedModule) {
        return true;
      }
    }
  }
  return false;
}

// Returns the full file path to the user's handler handler module
//
// The Lambda Runtime allows a user's handler module to have either a .js or
// .cjs extension.  The getFilePath looks for a .js file first, and if not found
// presumes a csj file exists. If neither file exists this means the user either
// as a misconfigured handler (they'd never reach this code) or is using a
// .mjs file extension (which indicates an ECMAScript/import module, which the
// agent does not support.
//
// @param string taskRoot
// @param string handlerModule
// @return string
function getFilePath(taskRoot, handlerModule) {
  let filePath = path.resolve(taskRoot, `${handlerModule}.js`);
  if (!fs.existsSync(filePath)) {
    filePath = path.resolve(taskRoot, `${handlerModule}.cjs`);
  }
  return filePath;
}

function getLambdaHandlerInfo(env, modules, logger) {
  if (
    !isLambdaExecutionEnvironment() ||
    !env._HANDLER ||
    !env.LAMBDA_TASK_ROOT
  ) {
    return;
  }

  // extract module name and "path" from handler using the same regex as the runtime
  // from https://github.com/aws/aws-lambda-nodejs-runtime-interface-client/blob/c31c41ffe5f2f03ae9e8589b96f3b005e2bb8a4a/src/utils/UserFunction.ts#L21
  const functionExpression = /^([^.]*)\.(.*)$/;
  const match = env._HANDLER.match(functionExpression);
  if (!match || match.length !== 3) {
    return;
  }
  const handlerModule = match[1].split('/').pop();
  const handlerFunctionPath = match[2];

  // if there's a name conflict with an already instrumented module, skip the
  // instrumentation of the lambda handle and log a message.
  if (isHandlerNameInModules(handlerModule, modules)) {
    logger.warn(
      'Unable to instrument Lambda handler "%s" due to name conflict with "%s", please choose a different Lambda handler name',
      env._HANDLER,
      handlerModule,
    );
    return;
  }

  const handlerFilePath = getFilePath(env.LAMBDA_TASK_ROOT, match[1]);

  return {
    filePath: handlerFilePath,
    module: handlerModule,
    field: handlerFunctionPath,
  };
}

function lowerCaseObjectKeys(obj) {
  const lowerCased = {};
  for (const key of Object.keys(obj)) {
    lowerCased[key.toLowerCase()] = obj[key];
  }
  return lowerCased;
}

// Extract span links from up to 1000 messages in this batch.
// https://github.com/elastic/apm/blob/main/specs/agents/tracing-instrumentation-messaging.md#receiving-trace-context
//
// A span link is created from a `traceparent` message attribute in a message.
// `msg.messageAttributes` is of the form:
//    { <attribute-name>: { DataType: <attr-type>, StringValue: <attr-value>, ... } }
// For example:
//    { traceparent: { DataType: 'String', StringValue: 'test-traceparent' } }
function spanLinksFromSqsRecords(records) {
  const links = [];
  const limit = Math.min(
    records.length,
    MAX_MESSAGES_PROCESSED_FOR_TRACE_CONTEXT,
  );
  for (let i = 0; i < limit; i++) {
    const attrs = records[i].messageAttributes;
    if (!attrs) {
      continue;
    }

    let traceparent;
    const attrNames = Object.keys(attrs);
    for (let j = 0; j < attrNames.length; j++) {
      const attrVal = attrs[attrNames[j]];
      if (attrVal.dataType !== 'String') {
        continue;
      }
      const attrNameLc = attrNames[j].toLowerCase();
      if (attrNameLc === 'traceparent') {
        traceparent = attrVal.stringValue;
        break;
      }
    }
    if (traceparent) {
      links.push({ context: traceparent });
    }
  }
  return links;
}

// Extract span links from up to 1000 messages in this batch.
// https://github.com/elastic/apm/blob/main/specs/agents/tracing-instrumentation-messaging.md#receiving-trace-context
//
// A span link is created from a `traceparent` message attribute in a message.
// `record.Sns.MessageAttributes` is of the form:
//    { <attribute-name>: { Type: <attr-type>, Value: <attr-value> } }
// For example:
//    { traceparent: { Type: 'String', Value: 'test-traceparent' } }
function spanLinksFromSnsRecords(records) {
  const links = [];
  const limit = Math.min(
    records.length,
    MAX_MESSAGES_PROCESSED_FOR_TRACE_CONTEXT,
  );
  for (let i = 0; i < limit; i++) {
    const attrs = records[i].Sns && records[i].Sns.MessageAttributes;
    if (!attrs) {
      continue;
    }

    let traceparent;
    const attrNames = Object.keys(attrs);
    for (let j = 0; j < attrNames.length; j++) {
      const attrVal = attrs[attrNames[j]];
      if (attrVal.Type !== 'String') {
        continue;
      }
      const attrNameLc = attrNames[j].toLowerCase();
      if (attrNameLc === 'traceparent') {
        traceparent = attrVal.Value;
        break;
      }
    }
    if (traceparent) {
      links.push({ context: traceparent });
    }
  }
  return links;
}

module.exports = {
  isLambdaExecutionEnvironment,
  elasticApmAwsLambda,
  getLambdaHandlerInfo,
};