Feature/CCM 14508 Metrics not showing for batches

lambdas/api-handler/src/handlers/get-letters.ts

@@ -14,7 +14,6 @@ import { mapToGetLettersResponse } from "../mappers/letter-mapper";
 import type { Deps } from "../config/deps";
 import { MetricStatus, emitForSingleSupplier } from "../utils/metrics";
 
-// List letters Handlers
 // The endpoint should only return pending letters for now
 const status = "PENDING";
 

lambdas/api-handler/src/handlers/letter-status-update.ts

@@ -1,10 +1,13 @@
-import { SQSEvent, SQSHandler } from "aws-lambda";
+import { SQSEvent, SQSHandler, SQSRecord } from "aws-lambda";
+import { Unit } from "aws-embedded-metrics";
+import pino from "pino";
 import {
   UpdateLetterCommand,
   UpdateLetterCommandSchema,
 } from "../contracts/letters";
 import { Deps } from "../config/deps";
 import { mapToUpdateLetter } from "../mappers/letter-mapper";
+import { MetricEntry, buildEMFObject } from "../utils/metrics";
 
 export default function createLetterStatusUpdateHandler(
   deps: Deps,
@@ -31,9 +34,20 @@ export default function createLetterStatusUpdateHandler(
           correlationId: message.messageAttributes.CorrelationId.stringValue,
           messageBody: message.body,
         });
+        emitAndFlushMetricLog(message, deps.logger);
       }
     });
 
     await Promise.all(tasks);
   };
 }
+
+function emitAndFlushMetricLog(message: SQSRecord, logger: pino.Logger) {
+  const metric: MetricEntry = {
+    key: "statusUpdateFailed",
+    value: 1,
+    unit: Unit.Count,
+  };
+  const emf = buildEMFObject("letter-status-update", {}, metric);
+  logger.info(emf);
+}

lambdas/api-handler/src/handlers/post-letters.ts

@@ -1,5 +1,6 @@
 import { APIGatewayProxyHandler } from "aws-lambda";
-import { MetricsLogger, Unit, metricScope } from "aws-embedded-metrics";
+import { Unit } from "aws-embedded-metrics";
+import pino from "pino";
 import type { Deps } from "../config/deps";
 import { ApiErrorDetail } from "../contracts/errors";
 import {
@@ -13,7 +14,7 @@
 import { enqueueLetterUpdateRequests } from "../services/letter-operations";
 import { extractCommonIds } from "../utils/common-ids";
 import { assertNotEmpty, requireEnvVar } from "../utils/validation";
-import { MetricStatus } from "../utils/metrics";
+import { MetricEntry, MetricStatus, buildEMFObject } from "../utils/metrics";
 
 function duplicateIdsExist(postLettersRequest: PostLettersRequest) {
   const ids = postLettersRequest.data.map((item) => item.id);
@@ -23,17 +24,24 @@
 /**
  * emits metrics of successful letter updates, including the supplier and grouped by status
  */
-function emitMetics(
-  metrics: MetricsLogger,
+function emitSuccessMetrics(
   supplierId: string,
   statusesMapping: Map<string, number>,
+  logger: pino.Logger,
 ) {
   for (const [status, count] of statusesMapping) {
-    metrics.putDimensions({
+    const dimensions: Record<string, string> = {
       supplier: supplierId,
       eventType: status,
-    });
-    metrics.putMetric(MetricStatus.Success, count, Unit.Count);
+    };
+    const metric: MetricEntry = {
+      key: "Letters posted",
+      value: count,
+      unit: Unit.Count,
+    };
+    const emf = buildEMFObject("postLetters", dimensions, metric);
+    logger.info(emf);
+    logger.info(`process.env: ${JSON.stringify(process.env)}`);
   }
 }
 
@@ -48,92 +56,97 @@
 export default function createPostLettersHandler(
   deps: Deps,
 ): APIGatewayProxyHandler {
-  return metricScope((metrics: MetricsLogger) => {
-    return async (event) => {
-      const commonIds = extractCommonIds(
-        event.headers,
-        event.requestContext,
-        deps,
-      );
+  return async (event) => {
+    const commonIds = extractCommonIds(
+      event.headers,
+      event.requestContext,
+      deps,
+    );
 
-      if (!commonIds.ok) {
-        return processError(
-          commonIds.error,
-          commonIds.correlationId,
-          deps.logger,
-        );
-      }
+    if (!commonIds.ok) {
+      return processError(
+        commonIds.error,
+        commonIds.correlationId,
+        deps.logger,
+      );
+    }
 
-      const maxUpdateItems = requireEnvVar(deps.env, "MAX_LIMIT");
-      requireEnvVar(deps.env, "QUEUE_URL");
+    const maxUpdateItems = requireEnvVar(deps.env, "MAX_LIMIT");
+    requireEnvVar(deps.env, "QUEUE_URL");
 
-      const { supplierId } = commonIds.value;
-      metrics.setNamespace(
-        process.env.AWS_LAMBDA_FUNCTION_NAME || "postLetters",
+    const { supplierId } = commonIds.value;
+    try {
+      const body = assertNotEmpty(
+        event.body,
+        new ValidationError(ApiErrorDetail.InvalidRequestMissingBody),
       );
+
+      let postLettersRequest: PostLettersRequest;
+
       try {
-        const body = assertNotEmpty(
-          event.body,
-          new ValidationError(ApiErrorDetail.InvalidRequestMissingBody),
-        );
+        postLettersRequest = PostLettersRequestSchema.parse(JSON.parse(body));
+      } catch (error) {
+        const typedError =
+          error instanceof Error
+            ? new ValidationError(ApiErrorDetail.InvalidRequestBody, {
+                cause: error,
+              })
+            : error;
+        throw typedError;
+      }
 
-        let postLettersRequest: PostLettersRequest;
-
-        try {
-          postLettersRequest = PostLettersRequestSchema.parse(JSON.parse(body));
-        } catch (error) {
-          const typedError =
-            error instanceof Error
-              ? new ValidationError(ApiErrorDetail.InvalidRequestBody, {
-                  cause: error,
-                })
-              : error;
-          throw typedError;
-        }
-
-        deps.logger.info({
-          description: "Received post letters request",
-          supplierId: commonIds.value.supplierId,
-          letterIds: postLettersRequest.data.map((letter) => letter.id),
-          correlationId: commonIds.value.correlationId,
-        });
-
-        if (postLettersRequest.data.length > maxUpdateItems) {
-          throw new ValidationError(
-            ApiErrorDetail.InvalidRequestLettersToUpdate,
-            { args: [maxUpdateItems] },
-          );
-        }
-
-        if (duplicateIdsExist(postLettersRequest)) {
-          throw new ValidationError(
-            ApiErrorDetail.InvalidRequestDuplicateLetterId,
-          );
-        }
-
-        const updateLetterCommands: UpdateLetterCommand[] = mapToUpdateCommands(
-          postLettersRequest,
-          supplierId,
-        );
-        const statusesMapping = populateStatusesMap(updateLetterCommands);
-        await enqueueLetterUpdateRequests(
-          updateLetterCommands,
-          commonIds.value.correlationId,
-          deps,
+      deps.logger.info({
+        description: "Received post letters request",
+        supplierId: commonIds.value.supplierId,
+        letterIds: postLettersRequest.data.map((letter) => letter.id),
+        correlationId: commonIds.value.correlationId,
+      });
+
+      if (postLettersRequest.data.length > maxUpdateItems) {
+        throw new ValidationError(
+          ApiErrorDetail.InvalidRequestLettersToUpdate,
+          { args: [maxUpdateItems] },
         );
+      }
 
-        emitMetics(metrics, supplierId, statusesMapping);
-        return {
-          statusCode: 202,
-          body: "",
-        };
-      } catch (error) {
-        metrics.putDimensions({
-          supplier: supplierId,
-        });
-        metrics.putMetric(MetricStatus.Failure, 1, Unit.Count);
-        return processError(error, commonIds.value.correlationId, deps.logger);
+      if (duplicateIdsExist(postLettersRequest)) {
+        throw new ValidationError(
+          ApiErrorDetail.InvalidRequestDuplicateLetterId,
+        );
       }
-    };
-  });
+
+      const updateLetterCommands: UpdateLetterCommand[] = mapToUpdateCommands(
+        postLettersRequest,
+        supplierId,
+      );
+      const statusesMapping = populateStatusesMap(updateLetterCommands);
+      await enqueueLetterUpdateRequests(
+        updateLetterCommands,
+        commonIds.value.correlationId,
+        deps,
+      );
+
+      emitSuccessMetrics(supplierId, statusesMapping, deps.logger);
+      return {
+        statusCode: 202,
+        body: "",
+      };
+    } catch (error) {
+      // error metrics
+      emitErrorMetrics(supplierId, deps.logger);
+
+      return processError(error, commonIds.value.correlationId, deps.logger);
+    }
+  };
+}
+
+function emitErrorMetrics(supplierId: string, logger: pino.Logger) {
+  const dimensions: Record<string, string> = { supplier: supplierId };
+  const metric: MetricEntry = {
+    key: MetricStatus.Failure,
+    value: 1,
+    unit: Unit.Count,
+  };
+  const emf = buildEMFObject("postLetters", dimensions, metric);
+  logger.info(emf);
 }

lambdas/api-handler/src/utils/metrics.ts

@@ -20,3 +20,34 @@ export enum MetricStatus {
   Success = "success",
   Failure = "failure",
 }
+
+export interface MetricEntry {
+  key: string;
+  value: number;
+  unit: Unit;
+}
+
+// build EMF object
+export function buildEMFObject(
+  functionName: string,
+  dimensions: Record<string, string>,
+  metric: MetricEntry,
+) {
+  const namespace = process.env.AWS_LAMBDA_FUNCTION_NAME || functionName;
+  return {
+    LogGroup: namespace,
+    ServiceName: namespace,
+    ...dimensions,
+    _aws: {
+      Timestamp: Date.now(),
+      CloudWatchMetrics: [
+        {
+          Namespace: namespace,
+          Dimensions: [[...Object.keys(dimensions), "ServiceName", "LogGroup"]],
+          Metrics: [{ Name: metric.key, Unit: metric.value }],
+        },
+      ],
+    },
+    [metric.key]: metric.value,
+  };
+}