testcontainers 9.6.0 → 9.8.0-beta.1

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

@@ -24,7 +24,7 @@ const port_forwarder_1 = require("../port-forwarder");
 const pull_image_1 = require("../docker/functions/image/pull-image");
 const create_container_1 = require("../docker/functions/container/create-container");
 const connect_network_1 = require("../docker/functions/network/connect-network");
-const docker_client_1 = require("../docker/docker-client");
+const docker_client_1 = require("../docker/client/docker-client");
 const inspect_container_1 = require("../docker/functions/container/inspect-container");
 const start_container_1 = require("../docker/functions/container/start-container");
 const container_logs_1 = require("../docker/functions/container/container-logs");
@@ -52,8 +52,8 @@ class GenericContainer {
     }
     start() {
         return __awaiter(this, void 0, void 0, function* () {
-            const { dockerode, indexServerAddress } = yield (0, docker_client_1.dockerClient)();
-            yield (0, pull_image_1.pullImage)(dockerode, indexServerAddress, {
+            const { dockerode, info } = yield (0, docker_client_1.getDockerClient)();
+            yield (0, pull_image_1.pullImage)(dockerode, info.dockerInfo.indexServerAddress, {
                 imageName: this.opts.imageName,
                 force: this.pullPolicy.shouldPull(),
             });
@@ -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 {
@@ -102,7 +102,7 @@ class GenericContainer {
     }
     reuseContainer(container) {
         return __awaiter(this, void 0, void 0, function* () {
-            const { host, hostIps } = yield (0, docker_client_1.dockerClient)();
+            const { host, hostIps } = yield (0, docker_client_1.getDockerClient)();
             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) {
@@ -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);
-            const { host, hostIps } = yield (0, docker_client_1.dockerClient)();
+            logger_1.log.info(`Started container for image "${this.opts.imageName}"`, { containerId: container.id });
+            const { host, hostIps } = yield (0, docker_client_1.getDockerClient)();
             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

@@ -23,7 +23,7 @@ const stopped_generic_container_1 = require("./stopped-generic-container");
 const stop_container_1 = require("../docker/functions/container/stop-container");
 const restart_container_1 = require("../docker/functions/container/restart-container");
 const wait_for_container_1 = require("../wait-for-container");
-const docker_client_1 = require("../docker/docker-client");
+const docker_client_1 = require("../docker/client/docker-client");
 const async_lock_1 = __importDefault(require("async-lock"));
 class StartedGenericContainer {
     constructor(container, host, inspectResult, boundPorts, name, waitStrategy) {
@@ -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)();
+            const { hostIps } = yield (0, docker_client_1.getDockerClient)();
             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();
             }
@@ -107,8 +109,11 @@ 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);
+            const { dockerode, containerRuntime } = yield (0, docker_client_1.getDockerClient)();
+            logger_1.log.debug(`Executing command "${command.join(" ")}"...`, { containerId: this.container.id });
+            const output = yield (0, exec_container_1.execContainer)(dockerode, containerRuntime, 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.d.ts

@@ -1,5 +1,5 @@
 import Dockerode from "dockerode";
-import { Provider } from "./docker/docker-client";
+import { ContainerRuntime } from "./docker/types";
 export interface PortCheck {
     isBound(port: number): Promise<boolean>;
 }
@@ -10,11 +10,11 @@ export declare class HostPortCheck implements PortCheck {
 }
 export declare class InternalPortCheck implements PortCheck {
     private readonly dockerode;
-    private readonly provider;
+    private readonly containerRuntime;
     private readonly container;
     private isDistroless;
     private commandOutputs;
-    constructor(dockerode: Dockerode, provider: Provider, container: Dockerode.Container);
+    constructor(dockerode: Dockerode, containerRuntime: ContainerRuntime, container: Dockerode.Container);
     isBound(port: number): Promise<boolean>;
     private commandOutputsKey;
 }

package/dist/src/port-check.js

@@ -39,9 +39,9 @@ class HostPortCheck {
 }
 exports.HostPortCheck = HostPortCheck;
 class InternalPortCheck {
-    constructor(dockerode, provider, container) {
+    constructor(dockerode, containerRuntime, container) {
         this.dockerode = dockerode;
-        this.provider = provider;
+        this.containerRuntime = containerRuntime;
         this.container = container;
         this.isDistroless = false;
         this.commandOutputs = new Set();
@@ -54,14 +54,16 @@ class InternalPortCheck {
                 ["/bin/sh", "-c", `nc -vz -w 1 localhost ${port}`],
                 ["/bin/bash", "-c", `</dev/tcp/localhost/${port}`],
             ];
-            const commandResults = yield Promise.all(commands.map((command) => (0, exec_container_1.execContainer)(this.dockerode, this.provider, this.container, command, false)));
+            const commandResults = yield Promise.all(commands.map((command) => (0, exec_container_1.execContainer)(this.dockerode, this.containerRuntime, this.container, command, false)));
             const isBound = commandResults.some((result) => result.exitCode === 0);
             if (!isBound && logger_1.log.enabled()) {
                 const shellExists = commandResults.some((result) => result.exitCode !== 126);
                 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

@@ -15,7 +15,7 @@ const logger_1 = require("./logger");
 const generic_container_1 = require("./generic-container/generic-container");
 const uuid_1 = require("./uuid");
 const session_id_1 = require("./docker/session-id");
-const docker_client_1 = require("./docker/docker-client");
+const docker_client_1 = require("./docker/client/docker-client");
 const images_1 = require("./images");
 class PortForwarder {
     constructor(sshConnection, container) {
@@ -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"]
@@ -69,10 +70,11 @@ class PortForwarderInstance {
                 `echo "${username}:$PASSWORD" | chpasswd && /usr/sbin/sshd -D -o PermitRootLogin=yes -o AddressFamily=inet -o GatewayPorts=yes -o AllowAgentForwarding=yes -o AllowTcpForwarding=yes -o KexAlgorithms=+diffie-hellman-group1-sha1 -o HostkeyAlgorithms=+ssh-rsa`,
             ])
                 .start();
-            const host = (yield (0, docker_client_1.dockerClient)()).host;
+            const host = (yield (0, docker_client_1.getDockerClient)()).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

@@ -19,8 +19,8 @@ const port_1 = require("./port");
 const labels_1 = require("./labels");
 const wait_1 = require("./wait-strategy/wait");
 const retry_strategy_1 = require("./retry-strategy");
-const get_remote_docker_unix_socket_path_1 = require("./docker/get-remote-docker-unix-socket-path");
-const docker_client_1 = require("./docker/docker-client");
+const remote_docker_unix_socket_path_1 = require("./docker/remote-docker-unix-socket-path");
+const docker_client_1 = require("./docker/client/docker-client");
 class RealReaper {
     constructor(container, socket) {
         this.container = container;
@@ -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,13 +85,15 @@ 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}`);
+            const dockerClient = yield (0, docker_client_1.getDockerClient)();
+            const remoteDockerUnixSocketPath = (0, remote_docker_unix_socket_path_1.getRemoteDockerUnixSocketPath)(dockerClient);
+            logger_1.log.debug(`Creating new Reaper for session "${session_id_1.sessionId}" with socket path "${remoteDockerUnixSocketPath}"...`);
             const container = new generic_container_1.GenericContainer(images_1.REAPER_IMAGE)
                 .withName(`testcontainers-ryuk-${session_id_1.sessionId}`)
                 .withExposedPorts(containerPort)
                 .withBindMounts([
                 {
-                    source: (0, get_remote_docker_unix_socket_path_1.getRemoteDockerUnixSocketPath)((yield (0, docker_client_1.dockerClient)()).uri),
+                    source: remoteDockerUnixSocketPath,
                     target: "/var/run/docker.sock",
                 },
             ])
@@ -106,7 +108,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 +116,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;