feat: emit all shell logging to publishProgressListener

bin/logging.ts

@@ -2,13 +2,13 @@ import * as fs from 'fs';
 import * as path from 'path';
 
 export type LogLevel = 'verbose' | 'info' | 'error';
-let logThreshold: LogLevel = 'info';
+export let logThreshold: LogLevel = 'info';
 
 export const VERSION = JSON.parse(
   fs.readFileSync(path.join(__dirname, '..', 'package.json'), { encoding: 'utf-8' })
 ).version;
 
-const LOG_LEVELS: Record<LogLevel, number> = {
+export const LOG_LEVELS: Record<LogLevel, number> = {
   verbose: 1,
   info: 2,
   error: 3,
@@ -18,9 +18,12 @@ export function setLogThreshold(threshold: LogLevel) {
   logThreshold = threshold;
 }
 
-export function log(level: LogLevel, message: string) {
+export function log(level: LogLevel, message: string, forceStdOut = false) {
   if (LOG_LEVELS[level] >= LOG_LEVELS[logThreshold]) {
-    // eslint-disable-next-line no-console
-    console.error(`${level.padEnd(7, ' ')}: ${message}`);
+    if (forceStdOut) {
+      console.log(`${level.padEnd(7, ' ')}: ${message}`);
+    } else {
+      console.error(`${level.padEnd(7, ' ')}: ${message}`);
+    }
   }
 }

bin/publish.ts

@@ -37,7 +37,7 @@ export async function publish(args: { path: string; assets?: string[]; profile?:
   }
 }
 
-const EVENT_TO_LEVEL: Record<EventType, LogLevel> = {
+export const EVENT_TO_LEVEL: Record<EventType, LogLevel> = {
   build: 'verbose',
   cached: 'verbose',
   check: 'verbose',
@@ -49,8 +49,8 @@ const EVENT_TO_LEVEL: Record<EventType, LogLevel> = {
   upload: 'verbose',
 };
 
-class ConsoleProgress implements IPublishProgressListener {
-  public onPublishEvent(type: EventType, event: IPublishProgress): void {
-    log(EVENT_TO_LEVEL[type], `[${event.percentComplete}%] ${type}: ${event.message}`);
+export class ConsoleProgress implements IPublishProgressListener {
+  public onPublishEvent(type: EventType, event: IPublishProgress, forceStdOut?: boolean): void {
+    log(EVENT_TO_LEVEL[type], `[${event.percentComplete}%] ${type}: ${event.message}`, forceStdOut);
   }
 }

lib/private/asset-handler.ts

@@ -42,10 +42,3 @@ export interface IHandlerHost {
 
   emitMessage(type: EventType, m: string): void;
 }
-
-export interface IHandlerOptions {
-  /**
-   * Suppress all output
-   */
-  readonly quiet?: boolean;
-}

lib/private/docker-credentials.ts

@@ -1,8 +1,9 @@
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
-import { Logger } from './shell';
+import { EventPublisher } from './shell';
 import { IAws, IECRClient } from '../aws';
+import { EventType } from '../progress';
 
 export interface DockerCredentials {
   readonly Username: string;
@@ -106,9 +107,9 @@ export async function fetchDockerLoginCredentials(
   }
 }
 
-export async function obtainEcrCredentials(ecr: IECRClient, logger?: Logger) {
-  if (logger) {
-    logger('Fetching ECR authorization token');
+export async function obtainEcrCredentials(ecr: IECRClient, eventPublisher?: EventPublisher) {
+  if (eventPublisher) {
+    eventPublisher(EventType.DEBUG, 'Fetching ECR authorization token');
   }
 
   const authData = (await ecr.getAuthorizationToken()).authorizationData || [];

lib/private/docker.ts

@@ -2,7 +2,7 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { cdkCredentialsConfig, obtainEcrCredentials } from './docker-credentials';
-import { Logger, shell, ShellOptions, ProcessFailedError } from './shell';
+import { EventPublisher, shell, ShellOptions, ProcessFailedError } from './shell';
 import { createCriticalSection } from './util';
 import { IECRClient } from '../aws';
 
@@ -24,12 +24,10 @@ interface BuildOptions {
   readonly cacheFrom?: DockerCacheOption[];
   readonly cacheTo?: DockerCacheOption;
   readonly cacheDisabled?: boolean;
-  readonly quiet?: boolean;
 }
 
 interface PushOptions {
   readonly tag: string;
-  readonly quiet?: boolean;
 }
 
 export interface DockerCredentialsConfig {
@@ -55,14 +53,14 @@ export interface DockerCacheOption {
 export class Docker {
   private configDir: string | undefined = undefined;
 
-  constructor(private readonly logger?: Logger) {}
+  constructor(private readonly eventPublisher: EventPublisher) {}
 
   /**
    * Whether an image with the given tag exists
    */
   public async exists(tag: string) {
     try {
-      await this.execute(['inspect', tag], { quiet: true });
+      await this.execute(['inspect', tag], { eventPublisher: this.eventPublisher });
       return true;
     } catch (e: any) {
       const error: ProcessFailedError = e;
@@ -123,7 +121,7 @@ export class Docker {
     ];
     await this.execute(buildCommand, {
       cwd: options.directory,
-      quiet: options.quiet,
+      eventPublisher: this.eventPublisher,
     });
   }
 
@@ -143,16 +141,19 @@ export class Docker {
         // 'WARNING! Your password will be stored unencrypted'
         // doesn't really matter since it's a token.
         quiet: true,
+        eventPublisher: this.eventPublisher,
       }
     );
   }
 
   public async tag(sourceTag: string, targetTag: string) {
-    await this.execute(['tag', sourceTag, targetTag]);
+    await this.execute(['tag', sourceTag, targetTag], { eventPublisher: this.eventPublisher });
   }
 
   public async push(options: PushOptions) {
-    await this.execute(['push', options.tag], { quiet: options.quiet });
+    await this.execute(['push', options.tag], {
+      eventPublisher: this.eventPublisher,
+    });
   }
 
   /**
@@ -194,13 +195,12 @@ export class Docker {
     this.configDir = undefined;
   }
 
-  private async execute(args: string[], options: ShellOptions = {}) {
+  private async execute(args: string[], options: ShellOptions) {
     const configArgs = this.configDir ? ['--config', this.configDir] : [];
 
     const pathToCdkAssets = path.resolve(__dirname, '..', '..', 'bin');
     try {
       await shell([getDockerCmd(), ...configArgs, ...args], {
-        logger: this.logger,
         ...options,
         env: {
           ...process.env,

lib/private/handlers/container-images.ts

@@ -4,7 +4,7 @@ import { destinationToClientOptions } from './client-options';
 import { DockerImageManifestEntry } from '../../asset-manifest';
 import type { IECRClient } from '../../aws';
 import { EventType } from '../../progress';
-import { IAssetHandler, IHandlerHost, IHandlerOptions } from '../asset-handler';
+import { IAssetHandler, IHandlerHost } from '../asset-handler';
 import { Docker } from '../docker';
 import { replaceAwsPlaceholders } from '../placeholders';
 import { shell } from '../shell';
@@ -22,8 +22,7 @@ export class ContainerImageAssetHandler implements IAssetHandler {
   constructor(
     private readonly workDir: string,
     private readonly asset: DockerImageManifestEntry,
-    private readonly host: IHandlerHost,
-    private readonly options: IHandlerOptions
+    private readonly host: IHandlerHost
   ) {}
 
   public async build(): Promise<void> {
@@ -46,10 +45,7 @@ export class ContainerImageAssetHandler implements IAssetHandler {
       dockerForBuilding,
       this.workDir,
       this.asset,
-      this.host,
-      {
-        quiet: this.options.quiet,
-      }
+      this.host
     );
     const localTagName = await builder.build();
 
@@ -65,7 +61,7 @@ export class ContainerImageAssetHandler implements IAssetHandler {
 
   public async isPublished(): Promise<boolean> {
     try {
-      const initOnce = await this.initOnce({ quiet: true });
+      const initOnce = await this.initOnce();
       return initOnce.destinationAlreadyExists;
     } catch (e: any) {
       this.host.emitMessage(EventType.DEBUG, `${e.message}`);
@@ -94,20 +90,17 @@ export class ContainerImageAssetHandler implements IAssetHandler {
     }
 
     this.host.emitMessage(EventType.UPLOAD, `Push ${initOnce.imageUri}`);
-    await dockerForPushing.push({ tag: initOnce.imageUri, quiet: this.options.quiet });
+    await dockerForPushing.push({ tag: initOnce.imageUri });
   }
 
-  private async initOnce(
-    options: { quiet?: boolean } = {}
-  ): Promise<ContainerImageAssetHandlerInit> {
+  private async initOnce(): Promise<ContainerImageAssetHandlerInit> {
     if (this.init) {
       return this.init;
     }
 
     const destination = await replaceAwsPlaceholders(this.asset.destination, this.host.aws);
     const ecr = await this.host.aws.ecrClient({
       ...destinationToClientOptions(destination),
-      quiet: options.quiet,
     });
     const account = async () => (await this.host.aws.discoverCurrentAccount())?.accountId;
 
@@ -152,17 +145,12 @@ export class ContainerImageAssetHandler implements IAssetHandler {
   }
 }
 
-interface ContainerImageBuilderOptions {
-  readonly quiet?: boolean;
-}
-
 class ContainerImageBuilder {
   constructor(
     private readonly docker: Docker,
     private readonly workDir: string,
     private readonly asset: DockerImageManifestEntry,
-    private readonly host: IHandlerHost,
-    private readonly options: ContainerImageBuilderOptions
+    private readonly host: IHandlerHost
   ) {}
 
   async build(): Promise<string | undefined> {
@@ -208,7 +196,12 @@ class ContainerImageBuilder {
       return undefined;
     }
 
-    return (await shell(executable, { cwd: assetPath, quiet: true })).trim();
+    return (
+      await shell(executable, {
+        cwd: assetPath,
+        eventPublisher: this.host.emitMessage,
+      })
+    ).trim();
   }
 
   private async buildImage(localTagName: string): Promise<void> {
@@ -236,7 +229,6 @@ class ContainerImageBuilder {
       cacheFrom: source.cacheFrom,
       cacheTo: source.cacheTo,
       cacheDisabled: source.cacheDisabled,
-      quiet: this.options.quiet,
     });
   }
 

lib/private/handlers/files.ts

@@ -39,7 +39,6 @@ export class FileAssetHandler implements IAssetHandler {
     try {
       const s3 = await this.host.aws.s3Client({
         ...destinationToClientOptions(destination),
-        quiet: true,
       });
       this.host.emitMessage(EventType.CHECK, `Check ${s3Url}`);
 
@@ -204,7 +203,7 @@ export class FileAssetHandler implements IAssetHandler {
     this.host.emitMessage(EventType.BUILD, `Building asset source using command: '${executable}'`);
 
     return {
-      packagedPath: (await shell(executable, { quiet: true })).trim(),
+      packagedPath: (await shell(executable, { eventPublisher: this.host.emitMessage })).trim(),
       contentType: 'application/zip',
     };
   }

lib/private/handlers/index.ts

@@ -6,19 +6,18 @@ import {
   FileManifestEntry,
   type IManifestEntry,
 } from '../../asset-manifest';
-import type { IAssetHandler, IHandlerHost, IHandlerOptions } from '../asset-handler';
+import type { IAssetHandler, IHandlerHost } from '../asset-handler';
 
 export function makeAssetHandler(
   manifest: AssetManifest,
   asset: IManifestEntry,
-  host: IHandlerHost,
-  options: IHandlerOptions
+  host: IHandlerHost
 ): IAssetHandler {
   if (asset instanceof FileManifestEntry) {
     return new FileAssetHandler(manifest.directory, asset, host);
   }
   if (asset instanceof DockerImageManifestEntry) {
-    return new ContainerImageAssetHandler(manifest.directory, asset, host, options);
+    return new ContainerImageAssetHandler(manifest.directory, asset, host);
   }
 
   throw new Error(`Unrecognized asset type: '${asset}'`);

lib/private/shell.ts

@@ -1,10 +1,11 @@
 import * as child_process from 'child_process';
+import { EventType } from '../progress';
 
-export type Logger = (x: string) => void;
+export type EventPublisher = (event: EventType, message: string, forceStdOut?: boolean) => void;
 
 export interface ShellOptions extends child_process.SpawnOptions {
   readonly quiet?: boolean;
-  readonly logger?: Logger;
+  readonly eventPublisher: EventPublisher;
   readonly input?: string;
 }
 
@@ -14,10 +15,8 @@ export interface ShellOptions extends child_process.SpawnOptions {
  * Shell function which both prints to stdout and collects the output into a
  * string.
  */
-export async function shell(command: string[], options: ShellOptions = {}): Promise<string> {
-  if (options.logger) {
-    options.logger(renderCommandLine(command));
-  }
+export async function shell(command: string[], options: ShellOptions): Promise<string> {
+  options.eventPublisher(EventType.DEBUG, renderCommandLine(command));
   const child = child_process.spawn(command[0], command.slice(1), {
     ...options,
     stdio: [options.input ? 'pipe' : 'ignore', 'pipe', 'pipe'],
@@ -32,19 +31,21 @@ export async function shell(command: string[], options: ShellOptions = {}): Prom
     const stdout = new Array<any>();
     const stderr = new Array<any>();
 
-    // Both write to stdout and collect
+    // Both log to debug and collect
     child.stdout!.on('data', (chunk) => {
       if (!options.quiet) {
-        process.stdout.write(chunk);
+        const message = Buffer.isBuffer(chunk) ? chunk.toString() : chunk;
+        // Emit events on stdout since we received the output on stdout
+        options.eventPublisher(EventType.DEBUG, message, true);
       }
       stdout.push(chunk);
     });
 
     child.stderr!.on('data', (chunk) => {
       if (!options.quiet) {
-        process.stderr.write(chunk);
+        const message = Buffer.isBuffer(chunk) ? chunk.toString() : chunk;
+        options.eventPublisher(EventType.DEBUG, message);
       }
-
       stderr.push(chunk);
     });
 

lib/progress.ts

@@ -7,7 +7,7 @@ export interface IPublishProgressListener {
   /**
    * Asset build event
    */
-  onPublishEvent(type: EventType, event: IPublishProgress): void;
+  onPublishEvent(type: EventType, event: IPublishProgress, forceStdOut?: boolean): void;
 }
 
 /**

lib/publishing.ts

@@ -51,6 +51,7 @@ export interface AssetPublishingOptions {
    * Whether to print publishing logs
    *
    * @default true
+   * @deprecated Implement a custom IPublishProgressListener with the desired behavior instead
    */
   readonly quiet?: boolean;
 }
@@ -281,9 +282,7 @@ export class AssetPublishing implements IPublishProgress {
     if (existing) {
       return existing;
     }
-    const ret = makeAssetHandler(this.manifest, asset, this.handlerHost, {
-      quiet: this.options.quiet,
-    });
+    const ret = makeAssetHandler(this.manifest, asset, this.handlerHost);
     this.handlerCache.set(asset, ret);
     return ret;
   }