chore(eng-prod): Improved logging output [CLK-134855] (#19)

Author: Justinon

src/deploy.ts

@@ -4,7 +4,7 @@ import chalk from 'chalk';
 import log from 'loglevel';
 import { create } from './helpers/create-app-version';
 import { deploy } from './helpers/deploy-app-version-to-env';
-import { DBError } from './helpers/Errors';
+import { DBError, DBGroupDeployTriggerError, DBHealthinessCheckError } from './helpers/Errors';
 import { waitForGroupHealthiness } from './helpers/healthiness';
 import { IDeployToGroupProps, IHealthCheckProps } from './helpers/Interfaces';
 
@@ -56,13 +56,56 @@ async function createAppVersionsForGroup(client: ElasticBeanstalkClient, props:
   log.info(chalk.green('All needed application versions exist.'));
 }
 
+async function preDeployHealthcheck(client: ElasticBeanstalkClient, props: IDeployToGroupProps) {
+  try {
+    log.info(chalk.blue('Verifying environments are ready to receive deployment before initiating...'));
+    await waitForGroupHealthiness({
+      client,
+      group: props.group,
+      force: props.force ?? DEFAULT_FORCE,
+      checkVersion: false,
+      ...(props.preDeployHealthCheckProps ?? DEFAULT_HEALTH_CHECK_PROPS),
+    });
+  } catch (e) {
+    if (e instanceof DBHealthinessCheckError) {
+      e.message = `preDeployHealthcheck(): ${e.message}`;
+    }
+    throw e;
+  }
+}
+
+async function postDeployHealthcheck(client: ElasticBeanstalkClient, props: IDeployToGroupProps) {
+  log.info(chalk.blue('Verifying environments successfully receive the deployment...this could take a while.'));
+  try {
+    await waitForGroupHealthiness({
+      client,
+      group: props.group,
+      force: props.force ?? DEFAULT_FORCE,
+      checkVersion: true,
+      ...(props.postDeployHealthCheckProps ?? DEFAULT_HEALTH_CHECK_PROPS),
+    });
+  } catch (e) {
+    if (e instanceof DBHealthinessCheckError) {
+      e.message = `postDeployHealthcheck(): ${e.message}`;
+    }
+    throw e;
+  }
+
+  log.info(
+    chalk.green('Successfully deployed version ') +
+      chalk.blue(props.group.versionProps.label) +
+      chalk.green(' to beanstalk group ') +
+      chalk.blue(props.group.name),
+  );
+}
+
 /**
- * For each Beanstalk Environment in group, deploys the respective Application
- * Version and then waits to verify their healthiness.
+ * For each Beanstalk Environment in the group, deploys the respective
+ * Application Version.
  */
 async function deployAppVersionsToGroup(client: ElasticBeanstalkClient, props: IDeployToGroupProps) {
   log.info(`Asynchronously kicking off deployment to the ${props.group.name} group of beanstalks.`);
-  const triggerErr = new DBError('deployAppVersionsToGroup: ', []);
+  const triggerErr = new DBGroupDeployTriggerError('deployAppVersionsToGroup: ', []);
   const force = props.force ?? DEFAULT_FORCE;
   await Promise.all(
     props.group.environments.map(async (env) => {
@@ -80,59 +123,70 @@ async function deployAppVersionsToGroup(client: ElasticBeanstalkClient, props: I
       }
     }),
   );
-  try {
-    // Verify the group successfully receives the deployment.
-    await waitForGroupHealthiness({
-      client,
-      group: props.group,
-      force,
-      checkVersion: true,
-      ...(props.postDeployHealthCheckProps ?? DEFAULT_HEALTH_CHECK_PROPS),
-    });
-    log.info(
-      chalk.green('Successfully deployed version ') +
-        chalk.blue(props.group.versionProps.label) +
-        chalk.green(' to beanstalk group ') +
-        chalk.blue(props.group.name),
-    );
-  } catch (e) {
-    if (triggerErr.errors.length === 0) throw e;
-    triggerErr.errors.push(e as Error);
-    throw triggerErr;
-  }
+  if (triggerErr.errors.length !== 0) throw triggerErr;
 }
 
 /**
- * Iterates over a group of Beanstalk Environments, creates Application
- * Versions for their respective Beanstalk Applications, and then deploys
- * those versions to the Beanstalk Environments and verifies their health.
+ * Initializes the Beanstalk Client, creates the needed Application Versions,
+ * and verifies the Beanstalk Environments in the group are ready to receive
+ * the deployment.
  */
-export async function deployToGroup(props: IDeployToGroupProps) {
-  const group = props.group;
-  const force = props.force ?? DEFAULT_FORCE;
+async function preDeploySteps(props: IDeployToGroupProps): Promise<ElasticBeanstalkClient> {
   try {
-    log.setLevel(props.logLevel ?? log.levels.INFO);
-    log.info(chalk.green('Beginning deploy process for beanstalk group ') + chalk.blue(group.name));
     const client = new ElasticBeanstalkClient({
       maxAttempts: AWS_CLIENT_REQUEST_MAX_ATTEMPTS_DEFAULT,
-      region: group.region,
+      region: props.group.region,
     });
     await createAppVersionsForGroup(client, props);
-    log.info(chalk.blue('Verifying environments are ready to receive deployment before initiating...'));
-    await waitForGroupHealthiness({
-      client,
-      group,
-      force,
-      checkVersion: false,
-      ...(props.preDeployHealthCheckProps ?? DEFAULT_HEALTH_CHECK_PROPS),
-    });
-    await deployAppVersionsToGroup(client, props);
+    await preDeployHealthcheck(client, props);
+    return client;
   } catch (e) {
     log.error(chalk.red(e));
     if (e instanceof DBError) {
       e.errors.forEach((err) => log.error(chalk.red(err)));
     }
-    log.error(chalk.red('Deploy to beanstalk group ') + chalk.blue(group.name) + chalk.red(' failed.'));
+    log.error(chalk.red('Could not trigger deployment to beanstalk group ') + chalk.blue(props.group.name));
     throw e;
   }
 }
+
+/**
+ * Triggers the deployment of the newly created Application Version to each
+ * Beanstalk Environment in the group, then verifies they reach a healthy state
+ * and successfully land the expected version.
+ */
+async function deploySteps(client: ElasticBeanstalkClient, props: IDeployToGroupProps) {
+  let deployErrs: DBError = new DBError('deploySteps(): ', []);
+  try {
+    await deployAppVersionsToGroup(client, props);
+  } catch (e) {
+    // We still want to see status of Beanstalks who did have deploy triggered
+    deployErrs.errors.push(e as Error);
+  }
+
+  try {
+    await postDeployHealthcheck(client, props);
+  } catch (e) {
+    log.error(chalk.red(e));
+    if (e instanceof DBError) {
+      e.errors.forEach((err) => log.error(chalk.red(err)));
+    }
+    log.error(chalk.red('Deployment to beanstalk group ') + chalk.blue(props.group.name) + chalk.red(' failed.'));
+    deployErrs.errors.push(e as Error);
+  }
+
+  if (deployErrs.errors.length !== 0) throw deployErrs;
+}
+
+/**
+ * Iterates over a group of Beanstalk Environments, creates Application
+ * Versions for their respective Beanstalk Applications, and then deploys
+ * those versions to the Beanstalk Environments and verifies their health.
+ */
+export async function deployToGroup(props: IDeployToGroupProps) {
+  const group = props.group;
+  log.setLevel(props.logLevel ?? log.levels.INFO);
+  log.info(chalk.green('Beginning deploy process for beanstalk group ') + chalk.blue(group.name));
+
+  await deploySteps(await preDeploySteps(props), props);
+}

src/helpers/Errors.ts

@@ -1,6 +1,7 @@
 /**
  * Houses multiple errors. Since we handle a group of multiple beanstalk
- * environments, we want to track errors for each one individually.
+ * environments, we want to track errors for each one (and each type)
+ * individually.
  */
 export class DBError extends Error {
   private readonly _errors: Error[];
@@ -17,6 +18,11 @@ export class DBError extends Error {
     return this._errors;
   }
 }
+
+/**
+ * Represents a single Application Version creation error, i.e., should be
+ * thrown when a single Application Version could not be created.
+ */
 export class DBCreateApplicationVersionError extends Error {
   constructor(appName: string, versionLabel: string, error: Error) {
     const msg = `Beanstalk app version ${versionLabel} failed creation for app ${appName}. ${error}`;
@@ -27,16 +33,33 @@ export class DBCreateApplicationVersionError extends Error {
   }
 }
 
+/**
+ * Represents a single triggered deployment failure, i.e., should be thrown
+ * when one Beanstalk Environment fails to have a deployment triggered.
+ */
 export class DBTriggerDeployError extends Error {
   constructor(envName: string, versionLabel: string, error: Error) {
-    const msg = `Deployment of app version ${versionLabel} failed on environment ${envName}. ${error}`;
+    const msg = `Deployment of app version '${versionLabel}' failed on environment '${envName}'. ${error}`;
     super(msg);
 
     // Set the prototype explicitly.
     Object.setPrototypeOf(this, DBTriggerDeployError.prototype);
   }
 }
 
+/**
+ * Multiple beanstalk environments could fail to have their deploy triggered.
+ * Hence the extension of DBError.
+ */
+export class DBGroupDeployTriggerError extends DBError {
+  constructor(msg: string, errors: Error[]) {
+    super(msg, errors);
+
+    // Set the prototype explicitly.
+    Object.setPrototypeOf(this, DBGroupDeployTriggerError.prototype);
+  }
+}
+
 /**
  * Multiple beanstalk environments could fail to achieve a healthy state.
  * Hence the extension of DBError.

src/helpers/deploy-app-version-to-env.ts

@@ -33,11 +33,7 @@ async function deployApplicationVersion(props: IDeployProps): Promise<void> {
   if (statusCode && statusCode >= 200 && statusCode < 300) {
     log.info(`Deployment of app version '${props.version.label}' triggered for '${props.env.name}'.`);
   } else {
-    throw new Error(
-      `Triggered deployment of app version '${props.version.label}' failed for '${
-        props.env.name
-      }'. Response metadata: ${JSON.stringify(resp.$metadata, undefined, 2)}`,
-    );
+    throw new Error(`Response metadata: ${JSON.stringify(resp.$metadata, undefined, 2)}`);
   }
 }
 

test/deploy.test.ts

@@ -15,6 +15,7 @@ import {
   IBeanstalkGroup,
   IDeployToGroupProps,
   DBTriggerDeployError,
+  DBGroupDeployTriggerError,
 } from '../src/index';
 
 const ebMock = mockClient(ElasticBeanstalkClient);
@@ -172,15 +173,19 @@ describe('Deployment to beanstalks in different apps', () => {
         ],
       });
 
-    expect.assertions(5);
+    expect.hasAssertions();
     const expectedErrCount = 2;
     try {
       await deployToGroup(deployProps);
     } catch (e) {
       expect(e).toBeInstanceOf(DBError);
       const errs = (e as DBError).errors;
       expect(errs).toHaveLength(expectedErrCount);
-      expect(errs.filter((err) => err instanceof DBTriggerDeployError)).toHaveLength(1);
+      const triggerFailureErrs = errs.filter(
+        (err) => err instanceof DBGroupDeployTriggerError,
+      ) as DBGroupDeployTriggerError[];
+      expect(triggerFailureErrs).toHaveLength(1);
+      expect(triggerFailureErrs[0].errors.filter((err) => err instanceof DBTriggerDeployError)).toHaveLength(1);
       const healthCheckErrs = errs.filter((err) => err instanceof DBHealthinessCheckError);
       expect(healthCheckErrs).toHaveLength(1);
       // If multiple envs failed, this length would be higher
@@ -205,13 +210,17 @@ describe('Deployment to beanstalks in different apps', () => {
         ],
       });
 
-    expect.assertions(2);
+    expect.hasAssertions();
     const expectedErrs = 1;
     try {
       await deployToGroup(deployProps);
     } catch (e) {
-      expect(e).toBeInstanceOf(DBHealthinessCheckError);
-      expect((e as DBHealthinessCheckError).errors).toHaveLength(expectedErrs);
+      expect(e).toBeInstanceOf(DBError);
+      const healthinessErrs = (e as DBError).errors.filter(
+        (err) => err instanceof DBHealthinessCheckError,
+      ) as DBHealthinessCheckError[];
+      expect(healthinessErrs).toHaveLength(expectedErrs);
+      expect(healthinessErrs[0].errors).toHaveLength(expectedErrs);
     }
   });