testcontainers 9.6.0 → 9.7.0

package/dist/src/generic-container/generic-container-builder.js

@@ -52,7 +52,7 @@ class GenericContainerBuilder {
             const imageName = docker_image_name_1.DockerImageName.fromString(image);
             yield reaper_1.ReaperInstance.getInstance();
             const dockerfile = path_1.default.resolve(this.context, this.dockerfileName);
-            logger_1.log.debug(`Preparing to build Dockerfile: ${dockerfile}`);
+            logger_1.log.debug(`Preparing to build Dockerfile "${dockerfile}" as image "${imageName}"...`);
             const imageNames = yield (0, dockerfile_parser_1.getDockerfileImages)(dockerfile, this.buildArgs);
             const { dockerode, indexServerAddress } = yield (0, docker_client_1.dockerClient)();
             const registryConfig = yield this.getRegistryConfig(indexServerAddress, imageNames);

package/dist/src/generic-container/generic-container.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import archiver from "archiver";
 import { BoundPorts } from "../bound-ports";
 import { PortWithOptionalBinding } from "../port";
@@ -9,6 +10,7 @@ import { CreateContainerOptions } from "../docker/functions/container/create-con
 import { InspectResult } from "../docker/functions/container/inspect-container";
 import { GenericContainerBuilder } from "./generic-container-builder";
 import { StartedNetwork } from "../network";
+import { Readable } from "stream";
 export declare class GenericContainer implements TestContainer {
     readonly image: string;
     static fromDockerfile(context: string, dockerfileName?: string): GenericContainerBuilder;
@@ -19,6 +21,7 @@ export declare class GenericContainer implements TestContainer {
     protected networkMode?: string;
     protected networkAliases: string[];
     protected pullPolicy: PullPolicy;
+    protected logConsumer?: (stream: Readable) => unknown;
     constructor(image: string);
     /**
      * @deprecated Since version 9.4.0. Will be removed in version 10.0.0. Use `beforeContainerStarted` instead.
@@ -65,4 +68,5 @@ export declare class GenericContainer implements TestContainer {
     protected getTarToCopy(): archiver.Archiver;
     withWorkingDir(workingDir: string): this;
     withResourcesQuota({ memory, cpu }: ResourcesQuota): this;
+    withLogConsumer(logConsumer: (stream: Readable) => unknown): this;
 }

package/dist/src/generic-container/generic-container.js

@@ -79,14 +79,14 @@ class GenericContainer {
             if (this.opts.reusable) {
                 const containerHash = (0, hash_1.hash)(JSON.stringify(this.opts));
                 this.opts.labels = Object.assign(Object.assign({}, this.opts.labels), { [labels_1.LABEL_TESTCONTAINERS_CONTAINER_HASH]: containerHash });
-                logger_1.log.debug(`Container reuse has been enabled, hash: ${containerHash}`);
+                logger_1.log.debug(`Container reuse has been enabled with hash "${containerHash}"`);
                 // We might have several async processes try to create a reusable container
                 // at once, to avoid possibly creating too many of these, use a lock
                 // on the containerHash, this ensures that only single reusable instance is created
                 return reusableContainerCreationLock.acquire(containerHash, () => __awaiter(this, void 0, void 0, function* () {
                     const container = yield (0, get_container_1.getContainerByHash)(containerHash);
                     if (container !== undefined) {
-                        logger_1.log.debug(`Found container to reuse with hash: ${containerHash}`);
+                        logger_1.log.debug(`Found container to reuse with hash "${containerHash}"`, { containerId: container.id });
                         return this.reuseContainer(container);
                     }
                     else {
@@ -148,21 +148,28 @@ class GenericContainer {
                 this.tarToCopy.finalize();
                 yield (0, put_container_archive_1.putContainerArchive)({ container, stream: this.tarToCopy, containerPath: "/" });
             }
-            logger_1.log.info(`Starting container ${this.opts.imageName} with ID: ${container.id}`);
+            logger_1.log.info(`Starting container for image "${this.opts.imageName}"...`, { containerId: container.id });
             if (this.containerCreated) {
                 yield this.containerCreated(container.id);
             }
             yield (0, start_container_1.startContainer)(container);
+            logger_1.log.info(`Started container for image "${this.opts.imageName}"`, { containerId: container.id });
             const { host, hostIps } = yield (0, docker_client_1.dockerClient)();
             const inspectResult = yield (0, inspect_container_1.inspectContainer)(container);
             const boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, inspectResult).filter(this.opts.exposedPorts);
             if (this.startupTimeout !== undefined) {
                 this.waitStrategy.withStartupTimeout(this.startupTimeout);
             }
-            if (logger_1.containerLog.enabled()) {
-                (yield (0, container_logs_1.containerLogs)(container))
-                    .on("data", (data) => logger_1.containerLog.trace(`${container.id}: ${data.trim()}`))
-                    .on("err", (data) => logger_1.containerLog.error(`${container.id}: ${data.trim()}`));
+            if (logger_1.containerLog.enabled() || this.logConsumer !== undefined) {
+                const logStream = yield (0, container_logs_1.containerLogs)(container);
+                if (this.logConsumer !== undefined) {
+                    this.logConsumer(logStream);
+                }
+                if (logger_1.containerLog.enabled()) {
+                    logStream
+                        .on("data", (data) => logger_1.containerLog.trace(data.trim(), { containerId: container.id }))
+                        .on("err", (data) => logger_1.containerLog.error(data.trim(), { containerId: container.id }));
+                }
             }
             if (this.containerStarting) {
                 yield this.containerStarting(inspectResult, false);
@@ -307,5 +314,9 @@ class GenericContainer {
         this.opts.resourcesQuota = { memory: ram, cpu: cpuQuota };
         return this;
     }
+    withLogConsumer(logConsumer) {
+        this.logConsumer = logConsumer;
+        return this;
+    }
 }
 exports.GenericContainer = GenericContainer;

package/dist/src/generic-container/started-generic-container.js

@@ -49,29 +49,31 @@ class StartedGenericContainer {
     restart(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             const resolvedOptions = Object.assign({ timeout: 0 }, options);
-            logger_1.log.info(`Restarting container with ID: ${this.container.id}`);
+            logger_1.log.info(`Restarting container...`, { containerId: this.container.id });
             yield (0, restart_container_1.restartContainer)(this.container, resolvedOptions);
             const { hostIps } = yield (0, docker_client_1.dockerClient)();
             this.inspectResult = yield (0, inspect_container_1.inspectContainer)(this.container);
             const startTime = this.inspectResult.state.startedAt;
             if (logger_1.containerLog.enabled()) {
                 (yield (0, container_logs_1.containerLogs)(this.container, { since: startTime }))
-                    .on("data", (data) => logger_1.containerLog.trace(`${this.container.id}: ${data.trim()}`))
-                    .on("err", (data) => logger_1.containerLog.error(`${this.container.id}: ${data.trim()}`));
+                    .on("data", (data) => logger_1.containerLog.trace(data.trim(), { containerId: this.container.id }))
+                    .on("err", (data) => logger_1.containerLog.error(data.trim(), { containerId: this.container.id }));
             }
             this.boundPorts = bound_ports_1.BoundPorts.fromInspectResult(hostIps, this.inspectResult).filter(Array.from(this.boundPorts.iterator()).map((port) => port[0]));
             yield (0, wait_for_container_1.waitForContainer)(this.container, this.waitStrategy, this.boundPorts, startTime);
+            logger_1.log.info(`Restarted container`, { containerId: this.container.id });
         });
     }
     stopContainer(options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.info(`Stopping container with ID: ${this.container.id}`);
+            logger_1.log.info(`Stopping container...`, { containerId: this.container.id });
             if (this.containerIsStopping) {
                 yield this.containerIsStopping();
             }
             const resolvedOptions = Object.assign({ timeout: 0, removeVolumes: true }, options);
             yield (0, stop_container_1.stopContainer)(this.container, { timeout: resolvedOptions.timeout });
             yield (0, remove_container_1.removeContainer)(this.container, { removeVolumes: resolvedOptions.removeVolumes });
+            logger_1.log.info(`Stopped container`, { containerId: this.container.id });
             if (this.containerIsStopped) {
                 yield this.containerIsStopped();
             }
@@ -108,7 +110,10 @@ class StartedGenericContainer {
     exec(command) {
         return __awaiter(this, void 0, void 0, function* () {
             const { dockerode, provider } = yield (0, docker_client_1.dockerClient)();
-            return (0, exec_container_1.execContainer)(dockerode, provider, this.container, command);
+            logger_1.log.debug(`Executing command "${command.join(" ")}"...`, { containerId: this.container.id });
+            const output = yield (0, exec_container_1.execContainer)(dockerode, provider, this.container, command);
+            logger_1.log.debug(`Executed command "${command.join(" ")}"...`, { containerId: this.container.id });
+            return output;
         });
     }
     logs() {

package/dist/src/images.js

@@ -2,5 +2,5 @@
 var _a, _b;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SSHD_IMAGE = exports.REAPER_IMAGE = void 0;
-exports.REAPER_IMAGE = (_a = process.env["RYUK_CONTAINER_IMAGE"]) !== null && _a !== void 0 ? _a : "testcontainers/ryuk:0.3.4";
+exports.REAPER_IMAGE = (_a = process.env["RYUK_CONTAINER_IMAGE"]) !== null && _a !== void 0 ? _a : "testcontainers/ryuk:0.4.0";
 exports.SSHD_IMAGE = (_b = process.env["SSHD_CONTAINER_IMAGE"]) !== null && _b !== void 0 ? _b : "testcontainers/sshd:1.1.0";

package/dist/src/logger.d.ts

@@ -1,36 +1,25 @@
 type Message = string;
-export interface Logger {
-    enabled(): boolean;
-    trace(message: Message): void;
-    debug(message: Message): void;
-    info(message: Message): void;
-    warn(message: Message): void;
-    error(message: Message): void;
-}
-declare class DebugLogger implements Logger {
+type Options = {
+    containerId?: string;
+    imageName?: string;
+};
+export declare class Logger {
+    private readonly showLevel;
     private readonly logger;
-    constructor(namespace: string);
-    enabled(): boolean;
-    trace(message: Message): void;
-    debug(message: Message): void;
-    info(message: Message): void;
-    warn(message: Message): void;
-    error(message: Message): void;
-}
-export declare class FakeLogger implements Logger {
-    readonly traceLogs: Message[];
-    readonly debugLogs: Message[];
-    readonly infoLogs: Message[];
-    readonly warnLogs: Message[];
-    readonly errorLogs: Message[];
+    constructor(namespace: string, showLevel?: boolean);
     enabled(): boolean;
-    trace(message: Message): void;
-    debug(message: Message): void;
-    info(message: Message): void;
-    warn(message: Message): void;
-    error(message: Message): void;
+    trace(message: Message, options?: Options): void;
+    debug(message: Message, options?: Options): void;
+    info(message: Message, options?: Options): void;
+    warn(message: Message, options?: Options): void;
+    error(message: Message, options?: Options): void;
+    private formatMessage;
+    private renderOptions;
 }
-export declare const log: DebugLogger;
-export declare const containerLog: DebugLogger;
-export declare const execLog: DebugLogger;
+export declare const log: Logger;
+export declare const containerLog: Logger;
+export declare const composeLog: Logger;
+export declare const buildLog: Logger;
+export declare const pullLog: Logger;
+export declare const execLog: Logger;
 export {};

package/dist/src/logger.js

@@ -3,59 +3,49 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.execLog = exports.containerLog = exports.log = exports.FakeLogger = void 0;
+exports.execLog = exports.pullLog = exports.buildLog = exports.composeLog = exports.containerLog = exports.log = exports.Logger = void 0;
 const debug_1 = __importDefault(require("debug"));
-class DebugLogger {
-    constructor(namespace) {
+class Logger {
+    constructor(namespace, showLevel = true) {
+        this.showLevel = showLevel;
         this.logger = (0, debug_1.default)(namespace);
     }
     enabled() {
         return this.logger.enabled;
     }
-    trace(message) {
-        this.logger(`TRACE ${message}`);
+    trace(message, options) {
+        this.logger(this.formatMessage(message, "TRACE", options));
     }
-    debug(message) {
-        this.logger(`DEBUG ${message}`);
+    debug(message, options) {
+        this.logger(this.formatMessage(message, "DEBUG", options));
     }
-    info(message) {
-        this.logger(`INFO  ${message}`);
+    info(message, options) {
+        this.logger(this.formatMessage(message, "INFO", options));
     }
-    warn(message) {
-        this.logger(`WARN  ${message}`);
+    warn(message, options) {
+        this.logger(this.formatMessage(message, "WARN", options));
     }
-    error(message) {
-        this.logger(`ERROR ${message}`);
+    error(message, options) {
+        this.logger(this.formatMessage(message, "ERROR", options));
     }
-}
-class FakeLogger {
-    constructor() {
-        this.traceLogs = [];
-        this.debugLogs = [];
-        this.infoLogs = [];
-        this.warnLogs = [];
-        this.errorLogs = [];
-    }
-    enabled() {
-        return true;
-    }
-    trace(message) {
-        this.traceLogs.push(message);
-    }
-    debug(message) {
-        this.debugLogs.push(message);
-    }
-    info(message) {
-        this.infoLogs.push(message);
-    }
-    warn(message) {
-        this.warnLogs.push(message);
+    formatMessage(message, level, options) {
+        return `${this.showLevel ? `[${level}] ` : ""}${this.renderOptions(options)}${message}`;
     }
-    error(message) {
-        this.errorLogs.push(message);
+    renderOptions(options) {
+        let str = "";
+        if (options === null || options === void 0 ? void 0 : options.containerId) {
+            str += `[${options.containerId.substring(0, 12)}] `;
+        }
+        if (options === null || options === void 0 ? void 0 : options.imageName) {
+            str += `[${options.imageName}] `;
+        }
+        return str;
     }
 }
-exports.FakeLogger = FakeLogger;
-exports.log = new DebugLogger("testcontainers");
-exports.containerLog = new DebugLogger("testcontainers:containers");
-exports.execLog = new DebugLogger("testcontainers:exec");
+exports.Logger = Logger;
+exports.log = new Logger("testcontainers");
+exports.containerLog = new Logger("testcontainers:containers", false);
+exports.composeLog = new Logger("testcontainers:compose", false);
+exports.buildLog = new Logger("testcontainers:build", false);
+exports.pullLog = new Logger("testcontainers:pull", false);
+exports.execLog = new Logger("testcontainers:exec", false);

package/dist/src/modules/nats/nats-container.js

@@ -19,7 +19,7 @@ const HTTP_MANAGEMENT_PORT = 8222;
 const USER_ARGUMENT_KEY = "--user";
 const PASS_ARGUMENT_KEY = "--pass";
 class NatsContainer extends generic_container_1.GenericContainer {
-    constructor(image = "nats:2.8-alpine") {
+    constructor(image = "nats:2.8.4-alpine") {
         super(image);
         this.args = {};
         this.args[USER_ARGUMENT_KEY] = "test";

package/dist/src/network.js

@@ -23,10 +23,12 @@ class Network {
     }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
-            const options = Object.assign({ name: this.uuid.nextUuid(), driver: "bridge", checkDuplicate: true, internal: false, attachable: false, ingress: false, enableIPv6: false }, this.createNetworkOptions);
+            const name = this.uuid.nextUuid();
+            const options = Object.assign({ name, driver: "bridge", checkDuplicate: true, internal: false, attachable: false, ingress: false, enableIPv6: false }, this.createNetworkOptions);
             yield reaper_1.ReaperInstance.getInstance();
+            logger_1.log.info(`Starting network "${name}"...`);
             const id = yield (0, create_network_1.createNetwork)(options);
-            logger_1.log.info(`Started network with ID: ${id}`);
+            logger_1.log.info(`Started network "${name}" with ID "${id}"`);
             return new StartedNetwork(id, options);
         });
     }
@@ -45,8 +47,9 @@ class StartedNetwork {
     }
     stop() {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.info(`Stopping network with ID: ${this.id}`);
+            logger_1.log.info(`Stopping network with ID "${this.id}"...`);
             yield (0, remove_network_1.removeNetwork)(this.id);
+            logger_1.log.info(`Stopped network with ID "${this.id}"`);
             return new StoppedNetwork();
         });
     }

package/dist/src/port-check.js

@@ -61,7 +61,9 @@ class InternalPortCheck {
                 if (!shellExists) {
                     if (!this.isDistroless) {
                         this.isDistroless = true;
-                        logger_1.log.error(`The HostPortWaitStrategy will not work on a distroless image, use an alternate wait strategy for container ${this.container.id}`);
+                        logger_1.log.error(`The HostPortWaitStrategy will not work on a distroless image, use an alternate wait strategy`, {
+                            containerId: this.container.id,
+                        });
                     }
                 }
                 else {
@@ -70,7 +72,9 @@ class InternalPortCheck {
                         .filter((result) => result.exitCode !== 126 && result.output.length > 0)
                         .forEach((result) => {
                         if (!this.commandOutputs.has(this.commandOutputsKey(result.output))) {
-                            logger_1.log.trace(`Port check result for container ${this.container.id} exit code ${result.exitCode}: ${result.output}`);
+                            logger_1.log.trace(`Port check result exit code ${result.exitCode}: ${result.output}`, {
+                                containerId: this.container.id,
+                            });
                             this.commandOutputs.add(this.commandOutputsKey(result.output));
                         }
                     });

package/dist/src/port-forwarder.js

@@ -24,8 +24,9 @@ class PortForwarder {
     }
     exposeHostPort(port) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.info(`Exposing host port ${port}`);
+            logger_1.log.info(`Exposing host port ${port}...`);
             yield this.sshConnection.remoteForward("localhost", port);
+            logger_1.log.info(`Exposed host port ${port}`);
         });
     }
     getNetworkId() {
@@ -53,7 +54,7 @@ class PortForwarderInstance {
     }
     static createInstance() {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Creating new Port Forwarder`);
+            logger_1.log.debug(`Creating new Port Forwarder...`);
             const username = "root";
             const password = new uuid_1.RandomUuid().nextUuid();
             const containerPort = process.env["TESTCONTAINERS_SSHD_PORT"]
@@ -71,8 +72,9 @@ class PortForwarderInstance {
                 .start();
             const host = (yield (0, docker_client_1.dockerClient)()).host;
             const port = container.getMappedPort(22);
-            logger_1.log.debug(`Connecting to Port Forwarder on ${host}:${port}`);
+            logger_1.log.debug(`Connecting to Port Forwarder on "${host}:${port}"...`);
             const connection = yield (0, ssh_remote_port_forward_1.createSshConnection)({ host, port, username, password });
+            logger_1.log.debug(`Connected to Port Forwarder on "${host}:${port}"`);
             connection.unref();
             return new PortForwarder(connection, container);
         });

package/dist/src/reaper.js

@@ -77,7 +77,7 @@ class ReaperInstance {
         return process.env.TESTCONTAINERS_RYUK_PRIVILEGED === "true";
     }
     static createDisabledInstance() {
-        logger_1.log.debug(`Not creating new Reaper for session: ${session_id_1.sessionId}`);
+        logger_1.log.debug(`Not creating new Reaper for session "${session_id_1.sessionId}"`);
         return Promise.resolve(new DisabledReaper());
     }
     static createRealInstance() {
@@ -85,7 +85,7 @@ class ReaperInstance {
             const containerPort = process.env["TESTCONTAINERS_RYUK_PORT"]
                 ? { container: 8080, host: Number(process.env["TESTCONTAINERS_RYUK_PORT"]) }
                 : 8080;
-            logger_1.log.debug(`Creating new Reaper for session: ${session_id_1.sessionId}`);
+            logger_1.log.debug(`Creating new Reaper for session "${session_id_1.sessionId}"...`);
             const container = new generic_container_1.GenericContainer(images_1.REAPER_IMAGE)
                 .withName(`testcontainers-ryuk-${session_id_1.sessionId}`)
                 .withExposedPorts(containerPort)
@@ -106,7 +106,7 @@ class ReaperInstance {
             const retryStrategy = new retry_strategy_1.IntervalRetryStrategy(1000);
             const retryResult = yield retryStrategy.retryUntil((attempt) => {
                 return new Promise((resolve) => {
-                    logger_1.log.debug(`Connecting to Reaper (attempt ${attempt + 1}) ${containerId} on ${host}:${port}`);
+                    logger_1.log.debug(`Connecting to Reaper (attempt ${attempt + 1}) on "${host}:${port}"...`, { containerId });
                     const socket = new net_1.Socket();
                     socket
                         .unref()
@@ -114,21 +114,25 @@ class ReaperInstance {
                         .on("error", (err) => logger_1.log.error(`Reaper ${containerId} socket error: ${err}`))
                         .on("close", (hadError) => {
                         if (hadError) {
-                            logger_1.log.error(`Connection to Reaper ${containerId} closed with error`);
+                            logger_1.log.error(`Connection to Reaper closed with error`, { containerId });
                         }
                         else {
-                            logger_1.log.warn(`Connection to Reaper ${containerId} closed`);
+                            logger_1.log.warn(`Connection to Reaper closed`, { containerId });
                         }
                         resolve(undefined);
                     })
                         .connect((0, port_1.getContainerPort)(port), host, () => {
-                        logger_1.log.debug(`Connected to Reaper ${containerId}`);
+                        logger_1.log.debug(`Connected to Reaper`, { containerId });
                         socket.write(`label=${labels_1.LABEL_TESTCONTAINERS_SESSION_ID}=${session_id_1.sessionId}\r\n`);
                         const reaper = new RealReaper(startedContainer, socket);
                         resolve(reaper);
                     });
                 });
-            }, (result) => result !== undefined, () => new Error(`Failed to connect to Reaper ${containerId}`), 4000);
+            }, (result) => result !== undefined, () => {
+                const message = `Failed to connect to Reaper`;
+                logger_1.log.error(message, { containerId });
+                return new Error(message);
+            }, 4000);
             if (retryResult instanceof RealReaper) {
                 return retryResult;
             }

package/dist/src/registry-auth-locator/credential-provider.js

@@ -21,20 +21,18 @@ class CredentialProvider {
                 return undefined;
             }
             const programName = `docker-credential-${credentialProviderName}`;
-            logger_1.log.debug(`Executing Docker credential provider: ${programName}`);
+            logger_1.log.debug(`Executing Docker credential provider "${programName}"`);
             const credentials = yield this.listCredentials(programName);
             if (!Object.keys(credentials).some((aRegistry) => (0, registry_matches_1.registryMatches)(aRegistry, registry))) {
-                logger_1.log.debug(`No credential found for registry: "${registry}"`);
+                logger_1.log.debug(`No credential found for registry "${registry}"`);
                 return undefined;
             }
             const response = yield this.runCredentialProvider(registry, programName);
-            const authConfig = {
+            return {
                 username: response.Username,
                 password: response.Secret,
                 registryAddress: response.ServerURL,
             };
-            logger_1.log.debug(`Docker credential provider found auth config for ${registry}`);
-            return authConfig;
         });
     }
     listCredentials(providerName) {

package/dist/src/registry-auth-locator/get-auth-config.js

@@ -47,18 +47,18 @@ const registryAuthLocators = [new cred_helpers_1.CredHelpers(), new creds_store_
 const authsCache = new Map();
 const getAuthConfig = (registry) => __awaiter(void 0, void 0, void 0, function* () {
     if (authsCache.has(registry)) {
-        logger_1.log.debug(`Re-using cached auth for registry ${registry}`);
+        logger_1.log.debug(`Auth config cache hit for registry "${registry}"`);
         return authsCache.get(registry);
     }
     for (const registryAuthLocator of registryAuthLocators) {
         const authConfig = yield registryAuthLocator.getAuthConfig(registry, yield dockerConfig);
         if (authConfig) {
-            logger_1.log.debug(`Found applicable registry auth locator for registry "${registry}": ${registryAuthLocator.getName()}`);
+            logger_1.log.debug(`Auth config found for registry "${registry}": ${registryAuthLocator.getName()}`);
             authsCache.set(registry, authConfig);
             return authConfig;
         }
     }
-    logger_1.log.debug(`No registry auth locator found for registry: "${registry}"`);
+    logger_1.log.debug(`No registry auth locator found for registry "${registry}"`);
     authsCache.set(registry, undefined);
     return undefined;
 });

package/dist/src/system-info.js

@@ -19,15 +19,12 @@ const getSystemInfo = (dockerode) => __awaiter(void 0, void 0, void 0, function*
     if (systemInfo !== undefined) {
         return systemInfo;
     }
-    logger_1.log.debug("Fetching system info");
+    logger_1.log.debug("Fetching system info...");
     const nodeInfo = getNodeInfo();
     const dockerInfo = yield (0, get_info_1.getDockerInfo)(dockerode);
     const dockerComposeInfo = yield getDockerComposeInfo();
     systemInfo = { nodeInfo, dockerInfo, dockerComposeInfo };
-    logger_1.log.debug(`System info:
-  System: Node version: ${nodeInfo.version}, Platform: ${nodeInfo.platform}, Arch: ${nodeInfo.architecture}
-  Container runtime: OS: ${dockerInfo.operatingSystem}, Version: ${dockerInfo.serverVersion}, Arch: ${dockerInfo.architecture}, CPUs: ${dockerInfo.cpus}, Memory: ${dockerInfo.memory} 
-  Compose: Installed: ${dockerComposeInfo !== undefined}, Version: ${(_a = dockerComposeInfo === null || dockerComposeInfo === void 0 ? void 0 : dockerComposeInfo.version) !== null && _a !== void 0 ? _a : "N/A"}`);
+    logger_1.log.debug(`Node version: ${nodeInfo.version}, Platform: ${nodeInfo.platform}, Arch: ${nodeInfo.architecture}, OS: ${dockerInfo.operatingSystem}, Version: ${dockerInfo.serverVersion}, Arch: ${dockerInfo.architecture}, CPUs: ${dockerInfo.cpus}, Memory: ${dockerInfo.memory}, Compose installed: ${dockerComposeInfo !== undefined}, Compose version: ${(_a = dockerComposeInfo === null || dockerComposeInfo === void 0 ? void 0 : dockerComposeInfo.version) !== null && _a !== void 0 ? _a : "N/A"}`);
     return systemInfo;
 });
 exports.getSystemInfo = getSystemInfo;

package/dist/src/test-container.d.ts

@@ -30,6 +30,7 @@ export interface TestContainer {
     withCopyContentToContainer(contentsToCopy: ContentToCopy[]): this;
     withWorkingDir(workingDir: string): this;
     withResourcesQuota(resourcesQuota: ResourcesQuota): this;
+    withLogConsumer(logConsumer: (stream: Readable) => unknown): this;
 }
 export interface RestartOptions {
     timeout: number;

package/dist/src/uuid.js

@@ -7,7 +7,7 @@ exports.RandomUuid = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 class RandomUuid {
     nextUuid() {
-        return crypto_1.default.randomUUID();
+        return crypto_1.default.createHash("md5").update(crypto_1.default.randomUUID()).digest("hex").substring(0, 12);
     }
 }
 exports.RandomUuid = RandomUuid;

package/dist/src/wait-for-container.js

@@ -14,19 +14,19 @@ const logger_1 = require("./logger");
 const stop_container_1 = require("./docker/functions/container/stop-container");
 const remove_container_1 = require("./docker/functions/container/remove-container");
 const waitForContainer = (container, waitStrategy, boundPorts, startTime) => __awaiter(void 0, void 0, void 0, function* () {
-    logger_1.log.debug(`Waiting for container to be ready: ${container.id}`);
+    logger_1.log.debug(`Waiting for container to be ready...`, { containerId: container.id });
     try {
         yield waitStrategy.waitUntilReady(container, boundPorts, startTime);
-        logger_1.log.info(`Container is ready: ${container.id}`);
+        logger_1.log.info(`Container is ready`, { containerId: container.id });
     }
     catch (err) {
-        logger_1.log.error(`Container failed to be ready: ${container.id}: ${err}`);
+        logger_1.log.error(`Container failed to be ready: ${err}`, { containerId: container.id });
         try {
             yield (0, stop_container_1.stopContainer)(container, { timeout: 0 });
             yield (0, remove_container_1.removeContainer)(container, { removeVolumes: true });
         }
         catch (stopErr) {
-            logger_1.log.error(`Failed to stop container after it failed to be ready: ${container.id}: ${stopErr}`);
+            logger_1.log.error(`Failed to stop container after it failed to be ready: ${stopErr}`, { containerId: container.id });
         }
         throw err;
     }

package/dist/src/wait-strategy/composite-wait-strategy.js

@@ -19,13 +19,13 @@ class CompositeWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     }
     waitUntilReady(container, boundPorts, startTime) {
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Starting composite wait strategy for ${container.id}`);
+            logger_1.log.debug(`Waiting for composite...`, { containerId: container.id });
             return new Promise((resolve, reject) => {
                 let deadlineTimeout;
                 if (this.deadline !== undefined) {
                     deadlineTimeout = setTimeout(() => {
-                        const message = `Composite wait strategy not successful after ${this.deadline}ms for ${container.id}`;
-                        logger_1.log.error(message);
+                        const message = `Composite wait strategy not successful after ${this.deadline}ms`;
+                        logger_1.log.error(message, { containerId: container.id });
                         reject(new Error(message));
                     }, this.deadline);
                 }
@@ -42,7 +42,7 @@ class CompositeWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     }
     withStartupTimeout(startupTimeout) {
         this.waitStrategies
-            .filter((waitStrategy) => waitStrategy.getStartupTimeout() === undefined)
+            .filter((waitStrategy) => !waitStrategy.isStartupTimeoutSet())
             .forEach((waitStrategy) => waitStrategy.withStartupTimeout(startupTimeout));
         return this;
     }

package/dist/src/wait-strategy/health-check-wait-strategy.js

@@ -16,15 +16,18 @@ const inspect_container_1 = require("../docker/functions/container/inspect-conta
 const wait_strategy_1 = require("./wait-strategy");
 class HealthCheckWaitStrategy extends wait_strategy_1.AbstractWaitStrategy {
     waitUntilReady(container) {
-        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            logger_1.log.debug(`Waiting for health check for ${container.id}`);
+            logger_1.log.debug(`Waiting for health check...`, { containerId: container.id });
             const status = yield new retry_strategy_1.IntervalRetryStrategy(100).retryUntil(() => __awaiter(this, void 0, void 0, function* () { return (yield (0, inspect_container_1.inspectContainer)(container)).healthCheckStatus; }), (healthCheckStatus) => healthCheckStatus === "healthy" || healthCheckStatus === "unhealthy", () => {
                 const timeout = this.startupTimeout;
-                throw new Error(`Health check not healthy after ${timeout}ms for ${container.id}`);
-            }, (_a = this.startupTimeout) !== null && _a !== void 0 ? _a : wait_strategy_1.DEFAULT_STARTUP_TIMEOUT);
+                const message = `Health check not healthy after ${timeout}ms`;
+                logger_1.log.error(message, { containerId: container.id });
+                throw new Error(message);
+            }, this.startupTimeout);
             if (status !== "healthy") {
-                throw new Error(`Health check failed: ${status} for ${container.id}`);
+                const message = `Health check failed: ${status}`;
+                logger_1.log.error(message, { containerId: container.id });
+                throw new Error(message);
             }
         });
     }