feat: add ability to inject external logger and pass AWS credentials through input props (#20)

* feat: allow external loggers to be plugged in.

* feat: allow externally passed credentials to AWS

* feat: fix log levels

Author: rdziarnowski

src/deploy.ts

@@ -1,12 +1,11 @@
-/* eslint-disable no-console */
 import { ElasticBeanstalkClient } from '@aws-sdk/client-elastic-beanstalk';
 import chalk from 'chalk';
-import log from 'loglevel';
+import loglevel from 'loglevel';
 import { create } from './helpers/create-app-version';
 import { deploy } from './helpers/deploy-app-version-to-env';
 import { DBError, DBGroupDeployTriggerError, DBHealthinessCheckError } from './helpers/Errors';
 import { waitForGroupHealthiness } from './helpers/healthiness';
-import { IDeployToGroupProps, IHealthCheckProps } from './helpers/Interfaces';
+import { IDeployToGroupProps, IHealthCheckProps, Logger } from './helpers/Interfaces';
 
 const AWS_CLIENT_REQUEST_MAX_ATTEMPTS_DEFAULT = 10;
 const DEFAULT_FORCE = false;
@@ -34,7 +33,7 @@ function verifyPromisesSettled(results: PromiseSettledResult<void>[]) {
  * Application. For each of those unique Applications, we must create an App
  * Version to use for deployments.
  */
-async function createAppVersionsForGroup(client: ElasticBeanstalkClient, props: IDeployToGroupProps) {
+async function createAppVersionsForGroup(client: ElasticBeanstalkClient, props: IDeployToGroupProps, log: Logger) {
   const appsWithCreatedVersions: string[] = [];
   const appVersionPromises: Promise<void>[] = [];
   log.info(`Creating application versions for beanstalk group ${props.group.name}`);
@@ -46,6 +45,7 @@ async function createAppVersionsForGroup(client: ElasticBeanstalkClient, props:
           version: props.group.versionProps,
           appName: env.app,
           dryRun: !props.force,
+          log,
         }),
       );
       appsWithCreatedVersions.push(env.app);
@@ -56,14 +56,15 @@ async function createAppVersionsForGroup(client: ElasticBeanstalkClient, props:
   log.info(chalk.green('All needed application versions exist.'));
 }
 
-async function preDeployHealthcheck(client: ElasticBeanstalkClient, props: IDeployToGroupProps) {
+async function preDeployHealthcheck(client: ElasticBeanstalkClient, props: IDeployToGroupProps, log: Logger) {
   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,
+      log,
       ...(props.preDeployHealthCheckProps ?? DEFAULT_HEALTH_CHECK_PROPS),
     });
   } catch (e) {
@@ -74,14 +75,15 @@ async function preDeployHealthcheck(client: ElasticBeanstalkClient, props: IDepl
   }
 }
 
-async function postDeployHealthcheck(client: ElasticBeanstalkClient, props: IDeployToGroupProps) {
+async function postDeployHealthcheck(client: ElasticBeanstalkClient, props: IDeployToGroupProps, log: Logger) {
   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,
+      log,
       ...(props.postDeployHealthCheckProps ?? DEFAULT_HEALTH_CHECK_PROPS),
     });
   } catch (e) {
@@ -103,7 +105,7 @@ async function postDeployHealthcheck(client: ElasticBeanstalkClient, props: IDep
  * For each Beanstalk Environment in the group, deploys the respective
  * Application Version.
  */
-async function deployAppVersionsToGroup(client: ElasticBeanstalkClient, props: IDeployToGroupProps) {
+async function deployAppVersionsToGroup(client: ElasticBeanstalkClient, props: IDeployToGroupProps, log: Logger) {
   log.info(`Asynchronously kicking off deployment to the ${props.group.name} group of beanstalks.`);
   const triggerErr = new DBGroupDeployTriggerError('deployAppVersionsToGroup: ', []);
   const force = props.force ?? DEFAULT_FORCE;
@@ -114,6 +116,7 @@ async function deployAppVersionsToGroup(client: ElasticBeanstalkClient, props: I
           client,
           force,
           env,
+          log,
           version: props.group.versionProps,
         });
       } catch (e) {
@@ -126,19 +129,33 @@ async function deployAppVersionsToGroup(client: ElasticBeanstalkClient, props: I
   if (triggerErr.errors.length !== 0) throw triggerErr;
 }
 
+/**
+ * Get AWS Credentials if provided
+ */
+function getCredentials(props: IDeployToGroupProps) {
+  if (props.accessKeyId && props.secretAccessKey) {
+    return {
+      accessKeyId: props.accessKeyId,
+      secretAccessKey: props.secretAccessKey,
+    };
+  }
+  return;
+}
 /**
  * Initializes the Beanstalk Client, creates the needed Application Versions,
  * and verifies the Beanstalk Environments in the group are ready to receive
  * the deployment.
  */
-async function preDeploySteps(props: IDeployToGroupProps): Promise<ElasticBeanstalkClient> {
+async function preDeploySteps(props: IDeployToGroupProps, log: Logger): Promise<ElasticBeanstalkClient> {
   try {
+    const credentials = getCredentials(props);
     const client = new ElasticBeanstalkClient({
       maxAttempts: AWS_CLIENT_REQUEST_MAX_ATTEMPTS_DEFAULT,
       region: props.group.region,
+      credentials,
     });
-    await createAppVersionsForGroup(client, props);
-    await preDeployHealthcheck(client, props);
+    await createAppVersionsForGroup(client, props, log);
+    await preDeployHealthcheck(client, props, log);
     return client;
   } catch (e) {
     log.error(chalk.red(e));
@@ -155,17 +172,17 @@ async function preDeploySteps(props: IDeployToGroupProps): Promise<ElasticBeanst
  * 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) {
+async function deploySteps(client: ElasticBeanstalkClient, props: IDeployToGroupProps, log: Logger) {
   let deployErrs: DBError = new DBError('deploySteps(): ', []);
   try {
-    await deployAppVersionsToGroup(client, props);
+    await deployAppVersionsToGroup(client, props, log);
   } 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);
+    await postDeployHealthcheck(client, props, log);
   } catch (e) {
     log.error(chalk.red(e));
     if (e instanceof DBError) {
@@ -183,10 +200,10 @@ async function deploySteps(client: ElasticBeanstalkClient, props: IDeployToGroup
  * 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) {
+export async function deployToGroup(props: IDeployToGroupProps, log: Logger = loglevel) {
   const group = props.group;
-  log.setLevel(props.logLevel ?? log.levels.INFO);
+  log.setLevel(props.logLevel ?? 'info');
   log.info(chalk.green('Beginning deploy process for beanstalk group ') + chalk.blue(group.name));
 
-  await deploySteps(await preDeploySteps(props), props);
+  await deploySteps(await preDeploySteps(props, log), props, log);
 }

src/helpers/Interfaces.ts

@@ -1,5 +1,6 @@
 import { S3Location, EnvironmentHealthStatus } from '@aws-sdk/client-elastic-beanstalk';
-import log from 'loglevel';
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error' | 'silent';
 
 /**
  * Properties consumed to deploy an Application Version to an existing
@@ -87,7 +88,7 @@ export interface IDeployToGroupProps {
   /**
    * Every level below the specified log level is silenced. Defaults to INFO.
    */
-  readonly logLevel?: log.LogLevelDesc;
+  readonly logLevel?: LogLevel;
   /**
    * Configuration for health checks prior to the deployment.
    */
@@ -96,4 +97,20 @@ export interface IDeployToGroupProps {
    * Configuration for health checks after the deployment.
    */
   readonly postDeployHealthCheckProps?: IHealthCheckProps;
+  /**
+   * AWS Access Key Id, if not present taken from i.e. ENV variable
+   */
+  readonly accessKeyId?: string;
+  /**
+   * AWS Secret Access Key, if not present taken from i.e. ENV variable
+   */
+  readonly secretAccessKey?: string;
+}
+
+export interface Logger {
+  debug: (msg: string) => void;
+  info: (msg: string) => void;
+  warn: (msg: string) => void;
+  error: (msg: string) => void;
+  setLevel: (level: LogLevel) => void;
 }

src/helpers/create-app-version.ts

@@ -1,18 +1,17 @@
-/* eslint-disable no-console */
 import {
   CreateApplicationVersionCommand,
   DescribeApplicationVersionsCommand,
   ElasticBeanstalkClient,
 } from '@aws-sdk/client-elastic-beanstalk';
-import log from 'loglevel';
 import { DBCreateApplicationVersionError } from './Errors';
-import { IAppVersionProps } from './Interfaces';
+import { IAppVersionProps, Logger } from './Interfaces';
 
 interface ICreateProps {
   appName: string;
   client: ElasticBeanstalkClient;
   dryRun?: boolean;
   version: IAppVersionProps;
+  log: Logger;
 }
 
 async function checkApplicationVersionExists(props: ICreateProps): Promise<boolean> {
@@ -24,7 +23,7 @@ async function checkApplicationVersionExists(props: ICreateProps): Promise<boole
   return getExistingVersionsResp.ApplicationVersions ? getExistingVersionsResp.ApplicationVersions.length > 0 : false;
 }
 
-async function createApplicationVersion(props: ICreateProps): Promise<void> {
+async function createApplicationVersion(props: ICreateProps, log: Logger): Promise<void> {
   if (props.dryRun) {
     log.info(`DRY RUN: Would have created application version ${props.version.label} for app ${props.appName}`);
     return;
@@ -61,11 +60,11 @@ export async function create(props: ICreateProps): Promise<void> {
       if (props.version.errorIfExists ?? false) {
         throw new Error(`Failed to create new application version ${props.version.label}, it already exists.`);
       }
-      log.info(
+      props.log.info(
         `Not creating new application version ${props.version.label} for app ${props.appName} since it already exists.`,
       );
     } else {
-      await createApplicationVersion(props);
+      await createApplicationVersion(props, props.log);
     }
   } catch (e) {
     throw new DBCreateApplicationVersionError(props.appName, props.version.label, e as Error);

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

@@ -1,25 +1,24 @@
-/* eslint-disable no-console */
 import { ElasticBeanstalkClient, UpdateEnvironmentCommand } from '@aws-sdk/client-elastic-beanstalk';
-import log from 'loglevel';
 import { DBTriggerDeployError } from './Errors';
-import { IAppVersionProps, IBeanstalkEnvironment } from './Interfaces';
+import { IAppVersionProps, IBeanstalkEnvironment, Logger } from './Interfaces';
 
 interface IDeployProps {
   client: ElasticBeanstalkClient;
   force: boolean;
   env: IBeanstalkEnvironment;
   version: IAppVersionProps;
+  log: Logger;
 }
 
 async function deployApplicationVersion(props: IDeployProps): Promise<void> {
   if (!props.force) {
-    log.info(
+    props.log.info(
       `DRY RUN: Would have deployed app version ${props.version.label} to beanstalk environment ${props.env.name}`,
     );
     return;
   }
 
-  log.info(`Initiating deployment of version ${props.version.label} to environment ${props.env.name}...`);
+  props.log.info(`Initiating deployment of version ${props.version.label} to environment ${props.env.name}...`);
   const resp = await props.client.send(
     new UpdateEnvironmentCommand({
       ApplicationName: props.env.app,
@@ -31,7 +30,7 @@ async function deployApplicationVersion(props: IDeployProps): Promise<void> {
   // Verify deployment initiated successfully
   const statusCode = resp.$metadata.httpStatusCode;
   if (statusCode && statusCode >= 200 && statusCode < 300) {
-    log.info(`Deployment of app version '${props.version.label}' triggered for '${props.env.name}'.`);
+    props.log.info(`Deployment of app version '${props.version.label}' triggered for '${props.env.name}'.`);
   } else {
     throw new Error(`Response metadata: ${JSON.stringify(resp.$metadata, undefined, 2)}`);
   }

src/helpers/healthiness.ts

@@ -1,14 +1,12 @@
-/* eslint-disable no-console */
 import {
   DescribeEnvironmentsCommand,
   DescribeEnvironmentsCommandOutput,
   ElasticBeanstalkClient,
   EnvironmentDescription,
   EnvironmentHealthStatus,
 } from '@aws-sdk/client-elastic-beanstalk';
-import log from 'loglevel';
 import { DBHealthinessCheckError } from './Errors';
-import { IBeanstalkEnvironment, IBeanstalkGroup, IHealthCheckProps } from './Interfaces';
+import { IBeanstalkEnvironment, IBeanstalkGroup, IHealthCheckProps, Logger } from './Interfaces';
 
 const AWS_EB_HEALTH_CHECK_UNHEALTHY_STATES: EnvironmentHealthStatus[] = ['Severe', 'Degraded', 'Warning'];
 
@@ -24,6 +22,7 @@ interface IHealthCheckPropsPrivate extends IHealthCheckProps {
   client: ElasticBeanstalkClient;
   force: boolean;
   group: IBeanstalkGroup;
+  log: Logger;
 }
 
 interface IBeanstalkHealthStatuses {
@@ -67,11 +66,12 @@ function groupEnvsByApp(envs: IBeanstalkEnvironment[]): IEnvironmentsByApp {
 function getEnvironmentsHealth(
   envs: EnvironmentDescription[],
   unhealthyStatuses: EnvironmentHealthStatus[],
+  log: Logger,
   expectedVersionLabel?: string,
 ): IBeanstalkHealthStatuses {
   return envs.reduce(
     (previousValue: IBeanstalkHealthStatuses, envDesc) => {
-      log.debug(envDesc);
+      log.debug(JSON.stringify(envDesc, null, 4));
       if (!(envDesc.Status && envDesc.HealthStatus)) {
         throw new Error(
           `Beanstalk status for '${envDesc.EnvironmentName}' could not be retrieved. Cannot proceed safely.`,
@@ -148,13 +148,14 @@ async function getGroupHealth(props: IHealthCheckPropsPrivate): Promise<IBeansta
       }
 
       if (!props.force) {
-        log.info(`DRY RUN: Would have waited for beanstalks in app '${key}' to become healthy.`);
+        props.log.info(`DRY RUN: Would have waited for beanstalks in app '${key}' to become healthy.`);
         continue;
       }
 
       const partitioned = getEnvironmentsHealth(
         resp.Environments,
         props.unhealthyStatuses ?? AWS_EB_HEALTH_CHECK_UNHEALTHY_STATES,
+        props.log,
         props.checkVersion ? props.group.versionProps.label : undefined,
       );
       statuses.healthy = [...statuses.healthy, ...partitioned.healthy];
@@ -173,7 +174,7 @@ async function getGroupHealth(props: IHealthCheckPropsPrivate): Promise<IBeansta
  */
 export async function waitForGroupHealthiness(props: IHealthCheckPropsPrivate): Promise<void> {
   for (let attempt = 1; attempt <= props.attempts; attempt++) {
-    log.info(`Checking beanstalks health... Attempt ${attempt} of ${props.attempts}`);
+    props.log.info(`Checking beanstalks health... Attempt ${attempt} of ${props.attempts}`);
     let statuses: IBeanstalkHealthStatuses;
     try {
       statuses = await getGroupHealth(props);
@@ -184,17 +185,17 @@ export async function waitForGroupHealthiness(props: IHealthCheckPropsPrivate):
     const allAreHealthy = !props.force || statuses.healthy.length === props.group.environments.length;
     if (isLastAttempt && !allAreHealthy) {
       // Log healthy beanstalk statuses
-      statuses.healthy.forEach((envStatus) => log.info(envStatus.msg));
+      statuses.healthy.forEach((envStatus) => props.log.info(envStatus.msg));
       const errs = statuses.unhealthy.map((envStatus) => new Error(envStatus.msg));
       throw new DBHealthinessCheckError(`Beanstalks are not healthy after ${props.attempts} attempt(s).`, errs);
     }
 
     // If we're not on the last attempt, log all statuses
     [statuses.healthy, statuses.unhealthy].forEach((statusSet) => {
-      statusSet.forEach((envStatus) => log.info(envStatus.msg));
+      statusSet.forEach((envStatus) => props.log.info(envStatus.msg));
     });
     if (allAreHealthy) {
-      log.info(`All beanstalks in group '${props.group.name}' are healthy!`);
+      props.log.info(`All beanstalks in group '${props.group.name}' are healthy!`);
       return;
     }
 

test/deploy.test.ts

@@ -6,7 +6,6 @@ import {
   UpdateEnvironmentCommand,
 } from '@aws-sdk/client-elastic-beanstalk';
 import { mockClient } from 'aws-sdk-client-mock';
-import { LogLevelDesc } from 'loglevel';
 import {
   DBError,
   DBCreateApplicationVersionError,
@@ -16,13 +15,14 @@ import {
   IDeployToGroupProps,
   DBTriggerDeployError,
   DBGroupDeployTriggerError,
+  LogLevel,
 } from '../src/index';
 
 const ebMock = mockClient(ElasticBeanstalkClient);
 
 const COMMON_DEPLOY_PROPS = {
   force: true,
-  logLevel: 'SILENT' as LogLevelDesc,
+  logLevel: 'silent' as LogLevel,
   preDeployHealthCheckProps: {
     attempts: 1,
     timeBetweenAttemptsMs: 0,