Added error handling for context.Canceled in log reading code

docker.go

@@ -728,7 +728,7 @@ func (c *DockerContainer) startLogProduction(ctx context.Context, opts ...LogPro
 						since = fmt.Sprintf("%d.%09d", now.Unix(), int64(now.Nanosecond()))
 						goto BEGIN
 					}
-					if errors.Is(err, context.DeadlineExceeded) {
+					if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
 						// Probably safe to continue here
 						continue
 					}
@@ -756,7 +756,7 @@ func (c *DockerContainer) startLogProduction(ctx context.Context, opts ...LogPro
 				if err != nil {
 					// TODO: add-logger: use logger to log out this error
 					_, _ = fmt.Fprintf(os.Stderr, "error occurred reading log with known length %s", err.Error())
-					if errors.Is(err, context.DeadlineExceeded) {
+					if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
 						// Probably safe to continue here
 						continue
 					}

logconsumer_test.go

@@ -1,13 +1,16 @@
 package testcontainers
 
 import (
+	"bytes"
 	"context"
 	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"os"
+	"os/signal"
 	"strings"
+	"syscall"
 	"testing"
 	"time"
 
@@ -508,3 +511,117 @@ func Test_StartLogProductionStillStartsWithTooHighTimeout(t *testing.T) {
 
 	terminateContainerOnEnd(t, ctx, c)
 }
+
+func Test_MultiContainerLogConsumer_CancelledContext(t *testing.T) {
+	// Redirect stderr to a buffer
+	oldStderr := os.Stderr
+	r, w, _ := os.Pipe()
+	os.Stderr = w
+
+	// Context with cancellation functionality for handling interrupt (SIGINT) and
+	// termination (SIGTERM) signals.
+	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+
+	first := TestLogConsumer{
+		Msgs:     []string{},
+		Done:     make(chan bool),
+		Accepted: devNullAcceptorChan(),
+	}
+
+	containerReq1 := ContainerRequest{
+		FromDockerfile: FromDockerfile{
+			Context:    "./testdata/",
+			Dockerfile: "echoserver.Dockerfile",
+		},
+		ExposedPorts: []string{"8080/tcp"},
+		WaitingFor:   wait.ForLog("ready"),
+		LogConsumerCfg: &LogConsumerConfig{
+			Consumers: []LogConsumer{&first},
+		},
+	}
+
+	genericReq1 := GenericContainerRequest{
+		ContainerRequest: containerReq1,
+		Started:          true,
+	}
+
+	c, err := GenericContainer(ctx, genericReq1)
+	require.NoError(t, err)
+
+	ep1, err := c.Endpoint(ctx, "http")
+	require.NoError(t, err)
+
+	_, err = http.Get(ep1 + "/stdout?echo=hello1")
+	require.NoError(t, err)
+
+	_, err = http.Get(ep1 + "/stdout?echo=there1")
+	require.NoError(t, err)
+
+	second := TestLogConsumer{
+		Msgs:     []string{},
+		Done:     make(chan bool),
+		Accepted: devNullAcceptorChan(),
+	}
+
+	containerReq2 := ContainerRequest{
+		FromDockerfile: FromDockerfile{
+			Context:    "./testdata/",
+			Dockerfile: "echoserver.Dockerfile",
+		},
+		ExposedPorts: []string{"8080/tcp"},
+		WaitingFor:   wait.ForLog("ready"),
+		LogConsumerCfg: &LogConsumerConfig{
+			Consumers: []LogConsumer{&second},
+		},
+	}
+
+	genericReq2 := GenericContainerRequest{
+		ContainerRequest: containerReq2,
+		Started:          true,
+	}
+
+	c2, err := GenericContainer(ctx, genericReq2)
+	require.NoError(t, err)
+
+	ep2, err := c2.Endpoint(ctx, "http")
+	require.NoError(t, err)
+
+	_, err = http.Get(ep2 + "/stdout?echo=hello2")
+	require.NoError(t, err)
+
+	_, err = http.Get(ep2 + "/stdout?echo=there2")
+	require.NoError(t, err)
+
+	// Handling the termination of the containers
+	defer func() {
+		shutdownCtx, shutdownCancel := context.WithTimeout(
+			context.Background(), 60*time.Second,
+		)
+		defer shutdownCancel()
+		_ = c.Terminate(shutdownCtx)
+		_ = c2.Terminate(shutdownCtx)
+	}()
+
+	// Deliberately calling context cancel
+	cancel()
+
+	// Check the log messages
+	assert.Equal(t, []string{"ready\n", "echo hello1\n", "echo there1\n"}, first.Msgs)
+	assert.Equal(t, []string{"ready\n", "echo hello2\n", "echo there2\n"}, second.Msgs)
+
+	// Restore stderr
+	w.Close()
+	os.Stderr = oldStderr
+
+	// Read the stderr output from the buffer
+	var buf bytes.Buffer
+	_, _ = buf.ReadFrom(r)
+
+	// Check the stderr message
+	actual := buf.String()
+
+	// The context cancel shouldn't cause the system to throw a
+	// logStoppedForOutOfSyncMessage, as it hangs the system with
+	// the multiple containers.
+	assert.False(t, strings.Contains(actual, logStoppedForOutOfSyncMessage))
+}