index.js

const { trace } = require("@opentelemetry/api");
const pino = require("pino");
const GeocodingService = require("./geocoding");

const pinoOptions = {
  // Set the global log level to the lowest level
  // We adjust the level per transport
  level: "trace",
  hooks: {},
  serializers: {
    // Handle error properties as Error and serialize them correctly
    err: pino.stdSerializers.err,
    error: pino.stdSerializers.err,
    validationErrors: pino.stdSerializers.err,
  },
  // Automatic trace context injection
  mixin() {
    const span = trace.getActiveSpan();
    if (!span) return {};
    const spanContext = span.spanContext();
    return {
      trace_id: spanContext.traceId,
      span_id: spanContext.spanId,
      trace_flags: spanContext.traceFlags,
    };
  },
};

const otlpTransport = pino.transport({
  target: "pino-opentelemetry-transport",
  options: {
    loggerName: "pino-js-logger",
    serviceVersion: "1.0.0",
  },
});

const streams = [
  {
    level: "debug",
    stream: otlpTransport,
  },
];

const logger = pino(pinoOptions, pino.multistream(streams));

const geocodingService = new GeocodingService(logger);

exports.handler = async (event, context) => {
  try {
    logger.info("Lambda function invoked", {
      requestId: context.awsRequestId,
      functionName: context.functionName,
      functionVersion: context.functionVersion,
    });

    logger.info("Processing event", { event });

    // Extract zip code from event
    const zipCode =
      event.zipCode ||
      event.body?.zipCode ||
      event.queryStringParameters?.zipCode;

    if (!zipCode) {
      const error = new Error("Missing required parameter: zipCode");
      logger.error("Missing zipCode parameter", { event });

      return {
        statusCode: 400,
        body: JSON.stringify({
          error: "Missing required parameter: zipCode",
          usage:
            "Include zipCode in event body, query parameters, or root level",
          timestamp: new Date().toISOString(),
          requestId: context.awsRequestId,
        }),
      };
    }

    // Get coordinates for the zip code
    const coordinates =
      await geocodingService.getCoordinatesFromZipCode(zipCode);

    const response = {
      statusCode: 200,
      body: JSON.stringify({
        zipCode,
        coordinates,
        timestamp: new Date().toISOString(),
        requestId: context.awsRequestId,
      }),
    };

    logger.info("Lambda function completed successfully", {
      zipCode,
      coordinates,
      requestId: context.awsRequestId,
    });

    return response;
  } catch (error) {
    logger.error("Lambda function failed", {
      error: error.message,
      stack: error.stack,
      requestId: context.awsRequestId,
    });

    return {
      statusCode: 500,
      body: JSON.stringify({
        error: "Internal server error",
        message: error.message,
        timestamp: new Date().toISOString(),
        requestId: context.awsRequestId,
      }),
    };
  } finally {
    logger.flush();
    otlpTransport.flushSync();
  }
};