10432: Performance Measurement - TO TEST

cypress/deployed-and-local/integration/documentQC/complete-docket-qc.cy.ts

@@ -183,9 +183,14 @@ describe('Document QC Complete', () => {
       });
 
       cy.visit('/document-qc/my/inbox');
-      cy.get(
-        `[data-testid="message-queue-docket-number-${unservedDocketNumber}"]`,
-      ).should('be.visible');
+
+      retry(() => {
+        cy.reload(true);
+        cy.get('[data-testid="my-work-queue-inbox"]').should('be.visible');
+        return assertExists(
+          `[data-testid="message-queue-docket-number-${unservedDocketNumber}"]`,
+        );
+      });
     });
   });
 });

esbuildHelper.mjs

@@ -66,6 +66,7 @@ export default async function ({
     entryNames: '[name].[hash]',
     entryPoints: [`web-client/src/${entryPoint}`],
     format: 'esm',
+    keepNames: true,
     loader: {
       '.html': 'text',
       '.pdf': 'file',

scripts/dynamo/setup-sequence-performance-minimum-time.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+# creates the entry for minimum time for sequence performance logging in the dynamo deploy table
+
+# Usage
+#   ENV=dev ./setup-sequence-performance-minimum-time.sh
+
+./check-env-variables.sh \
+  "ENV" \
+  "AWS_SECRET_ACCESS_KEY" \
+  "AWS_ACCESS_KEY_ID"
+
+ITEM=$(cat <<-END
+{
+    "pk": {
+        "S": "sequence-performance-minimum-time"
+    },
+    "sk":{
+        "S": "sequence-performance-minimum-time"
+    },
+    "current": {
+        "N": "5"
+    }
+}
+END
+)
+
+aws dynamodb put-item \
+    --region us-east-1 \
+    --table-name "efcms-deploy-${ENV}" \
+    --item "${ITEM}"

scripts/env/environments/00-common

@@ -46,6 +46,7 @@ IRS_CLIENT_ID=$(aws cognito-idp list-user-pool-clients \
   echo "DAWSON_ENV='${ENV}'"
   echo "DYNAMODB_TABLE_NAME='${SOURCE_TABLE}'"
   echo "ELASTICSEARCH_ENDPOINT='${ELASTICSEARCH_ENDPOINT}'"
+  echo "ELASTICSEARCH_INFO_ENDPOINT='${ELASTICSEARCH_INFO_ENDPOINT}'"
   echo "EMAIL_CHANGE_VERIFICATION_TEMPLATE='email_change_verification_${ENV}'"
   echo "EMAIL_DOCUMENT_SERVED_TEMPLATE='document_served_${ENV}'"
   echo "EMAIL_SERVED_PETITION_TEMPLATE='petition_served_${ENV}'"

shared/src/business/entities/EntityConstants.ts

@@ -89,6 +89,9 @@ export const ALLOWLIST_FEATURE_FLAGS = {
   ENTITY_LOCKING_FEATURE_FLAG: {
     key: 'entity-locking-feature-flag',
   },
+  SEQUENCE_PERFORMANCE_MINIMUM_TIME: {
+    key: 'sequence-performance-minimum-time',
+  },
   UPDATED_PETITION_FLOW: {
     key: 'updated-petition-flow',
   },

shared/src/proxies/system/logUserPerformanceDataProxy.ts

@@ -0,0 +1,16 @@
+import { post } from '@shared/proxies/requests';
+
+export const logUserPerformanceDataInteractor = (
+  applicationContext,
+  performanceData: {
+    sequenceName: string;
+    duration: number;
+    actionPerformanceArray: { actionName: string; duration: number }[];
+  },
+) => {
+  return post({
+    applicationContext,
+    body: { performanceData },
+    endpoint: '/log/performance-data',
+  });
+};

web-api/src/app.ts

@@ -127,6 +127,7 @@ import { getUsersPendingEmailLambda } from './lambdas/users/getUsersPendingEmail
 import { getWorkItemLambda } from './lambdas/workitems/getWorkItemLambda';
 import { ipLimiter } from './middleware/ipLimiter';
 import { lambdaWrapper } from './lambdaWrapper';
+import { logUserPerformanceDataLambda } from '@web-api/lambdas/system/logUserPerformanceDataLambda';
 import { logger } from './logger';
 import { loginLambda } from '@web-api/lambdas/auth/loginLambda';
 import { opinionAdvancedSearchLambda } from './lambdas/documents/opinionAdvancedSearchLambda';
@@ -1072,6 +1073,16 @@ app.delete(
   app.put('/work-items', lambdaWrapper(assignWorkItemsLambda));
 }
 
+/**
+ * logging
+ */
+{
+  app.post(
+    '/log/performance-data',
+    lambdaWrapper(logUserPerformanceDataLambda),
+  );
+}
+
 /**
  * system
  */

web-api/src/applicationContext.ts

@@ -18,6 +18,7 @@ import {
 import { Case } from '../../shared/src/business/entities/cases/Case';
 import { CaseDeadline } from '../../shared/src/business/entities/CaseDeadline';
 import { Client } from '@opensearch-project/opensearch';
+import { CloudWatchClient } from '@aws-sdk/client-cloudwatch';
 import { CognitoIdentityProvider } from '@aws-sdk/client-cognito-identity-provider';
 import { Correspondence } from '../../shared/src/business/entities/Correspondence';
 import { DocketEntry } from '../../shared/src/business/entities/DocketEntry';
@@ -79,6 +80,7 @@ import sass from 'sass';
 
 let sqsCache: SQSClient;
 let searchClientCache: Client;
+let cloudWatchClientCache: CloudWatchClient;
 
 const entitiesByName = {
   Case,
@@ -125,6 +127,21 @@ export const createApplicationContext = (
         return await getChromiumBrowserAWS();
       }
     },
+    getCloudWatchClient: () => {
+      if (cloudWatchClientCache) return cloudWatchClientCache;
+
+      if (environment.stage === 'local') {
+        cloudWatchClientCache = {
+          send: (...args) => console.log('** SYSTEM PERFORMANCE LOGS', ...args),
+        } as CloudWatchClient;
+      } else {
+        cloudWatchClientCache = new CloudWatchClient({
+          region: environment.region,
+        });
+      }
+
+      return cloudWatchClientCache;
+    },
     getCognito: (): CognitoIdentityProvider => {
       if (environment.stage === 'local') {
         return getLocalCognito();

web-api/src/business/useCases/system/logUserPerformanceDataInteractor.test.ts

@@ -0,0 +1,65 @@
+import { ROLES } from '@shared/business/entities/EntityConstants';
+import { UnknownAuthUser } from '@shared/business/entities/authUser/AuthUser';
+import { applicationContext } from '@shared/business/test/createTestApplicationContext';
+import { logUserPerformanceDataInteractor } from '@web-api/business/useCases/system/logUserPerformanceDataInteractor';
+
+describe('logUserPerformanceDataInteractor', () => {
+  const TEST_EMAIL = 'TEST_EMAIL@EXAMPLE.COM';
+
+  const PERFORMANCE_DATA: {
+    actionPerformanceArray: { actionName: string; duration: number }[];
+    duration: number;
+    email: string;
+    sequenceName: string;
+  } = {
+    actionPerformanceArray: [
+      { actionName: 'TEST_ACTION_NAME_1', duration: 25 },
+      { actionName: 'TEST_ACTION_NAME_2', duration: 25 },
+      { actionName: 'TEST_ACTION_NAME_3', duration: 25 },
+      { actionName: 'TEST_ACTION_NAME_4', duration: 25 },
+    ],
+    duration: 100,
+    email: TEST_EMAIL,
+    sequenceName: 'TEST_SEQUENCE_NAME',
+  };
+
+  const TEST_USER: UnknownAuthUser = {
+    email: TEST_EMAIL,
+    name: 'TEST_NAME',
+    role: ROLES.docketClerk,
+    userId: 'SOME_TEST_USER_ID',
+  };
+
+  beforeEach(() => {
+    applicationContext
+      .getPersistenceGateway()
+      .saveSystemPerformanceData.mockImplementation(() => {});
+  });
+
+  it('should not allow unauthorized call to log data', async () => {
+    await expect(
+      logUserPerformanceDataInteractor(
+        applicationContext,
+        PERFORMANCE_DATA,
+        undefined,
+      ),
+    ).rejects.toThrow('Unauthorized to log performance data');
+  });
+
+  it('should call persistence method with correct data', async () => {
+    await logUserPerformanceDataInteractor(
+      applicationContext,
+      PERFORMANCE_DATA,
+      TEST_USER,
+    );
+
+    const saveSystemPerformanceDataCalls =
+      applicationContext.getPersistenceGateway().saveSystemPerformanceData.mock
+        .calls;
+
+    expect(saveSystemPerformanceDataCalls.length).toEqual(1);
+    expect(saveSystemPerformanceDataCalls[0][0].performanceData).toEqual(
+      PERFORMANCE_DATA,
+    );
+  });
+});

web-api/src/business/useCases/system/logUserPerformanceDataInteractor.ts

@@ -0,0 +1,29 @@
+import { ServerApplicationContext } from '@web-api/applicationContext';
+import { UnauthorizedError } from '@web-api/errors/errors';
+import {
+  UnknownAuthUser,
+  isAuthUser,
+} from '@shared/business/entities/authUser/AuthUser';
+
+export const logUserPerformanceDataInteractor = async (
+  applicationContext: ServerApplicationContext,
+  performanceData: {
+    sequenceName: string;
+    duration: number;
+    actionPerformanceArray: { actionName: string; duration: number }[];
+  },
+  authorizedUser: UnknownAuthUser,
+): Promise<void> => {
+  if (!isAuthUser(authorizedUser)) {
+    throw new UnauthorizedError('Unauthorized to log performance data');
+  }
+
+  const { email } = authorizedUser;
+  await applicationContext.getPersistenceGateway().saveSystemPerformanceData({
+    applicationContext,
+    performanceData: {
+      ...performanceData,
+      email,
+    },
+  });
+};

web-api/src/getPersistenceGateway.ts

@@ -149,6 +149,7 @@ import {
 } from './persistence/dynamo/cases/removePractitionerOnCase';
 import { saveDispatchNotification } from './persistence/dynamo/notifications/saveDispatchNotification';
 import { saveDocumentFromLambda } from './persistence/s3/saveDocumentFromLambda';
+import { saveSystemPerformanceData } from '@web-api/persistence/elasticsearch/system/saveSystemPerformanceData';
 import { saveUserConnection } from './persistence/dynamo/notifications/saveUserConnection';
 import { saveWorkItem } from './persistence/dynamo/workitems/saveWorkItem';
 import { saveWorkItemForDocketClerkFilingExternalDocument } from './persistence/dynamo/workitems/saveWorkItemForDocketClerkFilingExternalDocument';
@@ -388,6 +389,7 @@ const gatewayMethods = {
   removeIrsPractitionerOnCase,
   removeLock,
   removePrivatePractitionerOnCase,
+  saveSystemPerformanceData,
   setChangeOfAddressCaseAsDone,
   setStoredApplicationHealth,
   uploadDocument,

web-api/src/getUseCases.ts

@@ -140,6 +140,7 @@ import { getUsersInSectionInteractor } from './business/useCases/user/getUsersIn
 import { getUsersPendingEmailInteractor } from './business/useCases/user/getUsersPendingEmailInteractor';
 import { getWorkItemInteractor } from './business/useCases/workItems/getWorkItemInteractor';
 import { handleBounceNotificationInteractor } from './business/useCases/email/handleBounceNotificationInteractor';
+import { logUserPerformanceDataInteractor } from '@web-api/business/useCases/system/logUserPerformanceDataInteractor';
 import { loginInteractor } from '@web-api/business/useCases/auth/loginInteractor';
 import { onConnectInteractor } from './business/useCases/notifications/onConnectInteractor';
 import { onDisconnectInteractor } from './business/useCases/notifications/onDisconnectInteractor';
@@ -354,6 +355,7 @@ const useCases = {
   getUsersPendingEmailInteractor,
   getWorkItemInteractor,
   handleBounceNotificationInteractor,
+  logUserPerformanceDataInteractor,
   loginInteractor,
   onConnectInteractor,
   onDisconnectInteractor,

web-api/src/lambdas/system/logUserPerformanceDataLambda.ts

@@ -0,0 +1,18 @@
+import { UnknownAuthUser } from '@shared/business/entities/authUser/AuthUser';
+import { genericHandler } from '@web-api/genericHandler';
+
+export const logUserPerformanceDataLambda = (
+  event,
+  authorizedUser: UnknownAuthUser,
+) =>
+  genericHandler(event, async ({ applicationContext }) => {
+    const { performanceData } = JSON.parse(event.body);
+
+    return await applicationContext
+      .getUseCases()
+      .logUserPerformanceDataInteractor(
+        applicationContext,
+        performanceData,
+        authorizedUser,
+      );
+  });

web-api/src/persistence/elasticsearch/system/saveSystemPerformanceData.ts

@@ -0,0 +1,52 @@
+import {
+  MetricDatum,
+  PutMetricDataCommand,
+  PutMetricDataCommandInput,
+  StandardUnit,
+} from '@aws-sdk/client-cloudwatch';
+import { ServerApplicationContext } from '@web-api/applicationContext';
+
+export const saveSystemPerformanceData = async ({
+  applicationContext,
+  performanceData,
+}: {
+  applicationContext: ServerApplicationContext;
+  performanceData: {
+    sequenceName: string;
+    duration: number;
+    actionPerformanceArray: { actionName: string; duration: number }[];
+    email: string;
+  };
+}) => {
+  const { stage } = applicationContext.getEnvironment();
+
+  const cloudwatchClient = applicationContext.getCloudWatchClient();
+  const metricData: MetricDatum[] = [
+    {
+      Dimensions: [
+        { Name: 'SequenceName', Value: performanceData.sequenceName },
+      ],
+      MetricName: 'SequenceDuration',
+      Unit: 'Seconds',
+      Value: performanceData.duration,
+    },
+    ...performanceData.actionPerformanceArray.map(action => ({
+      Dimensions: [
+        { Name: 'SequenceName', Value: performanceData.sequenceName },
+        { Name: 'ActionName', Value: action.actionName },
+      ],
+      MetricName: 'ActionPerformance',
+      Unit: 'Seconds' as StandardUnit,
+      Value: action.duration,
+    })),
+  ];
+
+  const params: PutMetricDataCommandInput = {
+    MetricData: metricData,
+    Namespace: `System-Performance-Log-${stage}`,
+  };
+
+  const command = new PutMetricDataCommand(params);
+
+  await cloudwatchClient.send(command);
+};

web-api/storage/fixtures/seed/efcms-local.json

@@ -40527,6 +40527,11 @@
     "current": "2023-05-01",
     "pk": "document-visibility-policy-change-date"
   },
+  {
+    "sk": "sequence-performance-minimum-time",
+    "current": "5",
+    "pk": "sequence-performance-minimum-time"
+  },
   {
     "sk": "e-consent-fields-enabled-feature-flag",
     "current": true,

web-api/terraform/modules/lambda-role/lambda-role.tf

@@ -51,6 +51,15 @@ resource "aws_iam_role_policy" "lambda_policy" {
             ],
             "Effect": "Allow"
         },
+        {
+            "Action": [
+                "cloudwatch:PutMetricData"
+            ],
+            "Resource": [
+                "*"
+            ],
+            "Effect": "Allow"
+        },
         {
             "Action": [
                 "lambda:InvokeFunction"
@@ -160,7 +169,8 @@ resource "aws_iam_role_policy" "lambda_policy" {
                 "es:ESHttpPut"
             ],
             "Resource": [
-                "arn:aws:es:us-east-1:${data.aws_caller_identity.current.account_id}:domain/efcms-search-${var.environment}-*"
+                "arn:aws:es:us-east-1:${data.aws_caller_identity.current.account_id}:domain/efcms-search-${var.environment}-*",
+                "arn:aws:es:us-east-1:${data.aws_caller_identity.current.account_id}:domain/info"
             ],
             "Effect": "Allow"
         },