Added logs filter state management saperate from the panel list filter, Implemented the stream filtering code to support both tty and non-tty logs with ASCII filter support, Refactor filtering code to support both list filter and logs filter, Added new views for log filter with its new keybindings

Author: ManManavadaria

docs/Config.md

@@ -64,6 +64,16 @@ logs:
   timestamps: false
   since: '60m' # set to '' to show all logs
   tail: '' # set to 200 to show last 200 lines of logs
+
+### Logs Filtering
+
+When viewing container or service logs in the main panel, you can filter the log output in real-time:
+
+- Press `/` while viewing logs to open the filter prompt
+- Type a search string to filter log lines (case-sensitive substring match)
+- Press `Enter` to commit the filter and return to viewing filtered logs
+- Press `Esc` to cancel the filter and return to unfiltered logs
+
 commandTemplates:
   dockerCompose: docker compose # Determines the Docker Compose command to run, referred to as .DockerCompose in commandTemplates
   restartService: '{{ .DockerCompose }} restart {{ .Service.Name }}'

pkg/gui/arrangement.go

@@ -29,7 +29,7 @@ func (gui *Gui) getWindowDimensions(informationStr string, appStatus string) map
 		sidePanelsDirection = boxlayout.ROW
 	}
 
-	showInfoSection := gui.Config.UserConfig.Gui.ShowBottomLine || gui.State.Filter.active
+	showInfoSection := gui.Config.UserConfig.Gui.ShowBottomLine || gui.State.Filter.active || gui.State.LogsFilter.active
 	infoSectionSize := 0
 	if showInfoSection {
 		infoSectionSize = 1
@@ -112,6 +112,19 @@ func (gui *Gui) infoSectionChildren(informationStr string, appStatus string) []*
 		}...)
 	}
 
+	if gui.State.LogsFilter.active {
+		return append(result, []*boxlayout.Box{
+			{
+				Window: "logsfilterPrefix",
+				Size:   runewidth.StringWidth(gui.logsFilterPrompt()),
+			},
+			{
+				Window: "logsfilter",
+				Weight: 1,
+			},
+		}...)
+	}
+
 	result = append(result,
 		[]*boxlayout.Box{
 			{

pkg/gui/container_logs.go

@@ -1,11 +1,14 @@
 package gui
 
 import (
+	"bufio"
+	"bytes"
 	"context"
 	"fmt"
 	"io"
 	"os"
 	"os/signal"
+	"strings"
 	"time"
 
 	"github.com/docker/docker/api/types/container"
@@ -136,12 +139,26 @@ func (gui *Gui) writeContainerLogs(ctr *commands.Container, ctx context.Context,
 		}
 	}
 
+	var filterString string
+	var hasFilter bool
+
+	if gui.State.LogsFilter.active {
+		filterString = gui.State.LogsFilter.needle
+		hasFilter = filterString != ""
+	}
+
 	if ctr.Details.Config.Tty {
+		if hasFilter {
+			return gui.filterTTYLogs(readCloser, writer, filterString, ctx)
+		}
 		_, err = io.Copy(writer, readCloser)
 		if err != nil {
 			return err
 		}
 	} else {
+		if hasFilter {
+			return gui.filterNonTTYLogs(readCloser, writer, filterString, ctx)
+		}
 		_, err = stdcopy.StdCopy(writer, writer, readCloser)
 		if err != nil {
 			return err
@@ -150,3 +167,74 @@ func (gui *Gui) writeContainerLogs(ctr *commands.Container, ctx context.Context,
 
 	return nil
 }
+
+// filterTTYLogs filters TTY logs line by line based on the filter string
+func (gui *Gui) filterTTYLogs(reader io.Reader, writer io.Writer, filter string, ctx context.Context) error {
+	return streamFilterLines(reader, writer, filter, ctx)
+}
+
+// filterNonTTYLogs filters non-TTY logs (stdout/stderr) line by line
+func (gui *Gui) filterNonTTYLogs(reader io.Reader, writer io.Writer, filter string, ctx context.Context) error {
+	pipeReader, pipeWriter := io.Pipe()
+
+	go func() {
+		defer pipeWriter.Close()
+
+		done := make(chan struct{})
+		go func() {
+			select {
+			case <-ctx.Done():
+				pipeWriter.CloseWithError(ctx.Err())
+			case <-done:
+			}
+		}()
+
+		_, err := stdcopy.StdCopy(pipeWriter, pipeWriter, reader)
+		close(done)
+
+		if err != nil {
+			pipeWriter.CloseWithError(err)
+		}
+	}()
+
+	defer pipeReader.Close()
+	return streamFilterLines(pipeReader, writer, filter, ctx)
+}
+
+func streamFilterLines(reader io.Reader, writer io.Writer, filter string, ctx context.Context) error {
+	scanner := bufio.NewScanner(reader)
+	scanner.Buffer(make([]byte, 0, 4*1024), 10*1024*1024)
+
+	// Pre-convert filter to bytes for faster comparison when filter is ASCII
+	filterBytes := []byte(filter)
+	isASCIIFilter := len(filterBytes) == len(filter)
+
+	for scanner.Scan() {
+		select {
+		case <-ctx.Done():
+			return nil
+		default:
+		}
+
+		line := scanner.Bytes()
+
+		var shouldWrite bool
+		if isASCIIFilter {
+			shouldWrite = bytes.Contains(line, filterBytes)
+		} else {
+			// For non-ASCII filters, we need string conversion for proper UTF-8 handling
+			shouldWrite = strings.Contains(string(line), filter)
+		}
+
+		if shouldWrite {
+			if _, err := writer.Write(line); err != nil {
+				return err
+			}
+			if _, err := writer.Write([]byte("\n")); err != nil {
+				return err
+			}
+		}
+	}
+
+	return scanner.Err()
+}

pkg/gui/container_logs_test.go

@@ -0,0 +1,182 @@
+package gui
+
+import (
+	"bytes"
+	"context"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStreamFilterLines(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		filter   string
+		expected string
+	}{
+		{
+			name:     "simple match - single line",
+			input:    "hello world\n",
+			filter:   "hello",
+			expected: "hello world\n",
+		},
+		{
+			name:     "simple match - multiple lines",
+			input:    "hello world\nfoo bar\nbaz qux\n",
+			filter:   "foo",
+			expected: "foo bar\n",
+		},
+		{
+			name:     "multiple matches",
+			input:    "hello world\nhello again\nfoo bar\n",
+			filter:   "hello",
+			expected: "hello world\nhello again\n",
+		},
+		{
+			name:     "no matches",
+			input:    "hello world\nfoo bar\nbaz qux\n",
+			filter:   "xyz",
+			expected: "",
+		},
+		{
+			name:     "empty filter - matches all",
+			input:    "hello world\nfoo bar\n",
+			filter:   "",
+			expected: "hello world\nfoo bar\n",
+		},
+		{
+			name:     "case sensitive match",
+			input:    "Hello World\nhello world\nHELLO WORLD\n",
+			filter:   "hello",
+			expected: "hello world\n",
+		},
+		{
+			name:     "partial word match",
+			input:    "hello world\nhelloworld\n",
+			filter:   "hello",
+			expected: "hello world\nhelloworld\n",
+		},
+		{
+			name:     "filter in middle of line",
+			input:    "prefix hello suffix\n",
+			filter:   "hello",
+			expected: "prefix hello suffix\n",
+		},
+		{
+			name:     "empty input",
+			input:    "",
+			filter:   "hello",
+			expected: "",
+		},
+		{
+			name:     "newline only lines",
+			input:    "\n\n\n",
+			filter:   "",
+			expected: "\n\n\n",
+		},
+		{
+			name:     "filter with special characters",
+			input:    "error: something went wrong\ninfo: all good\n",
+			filter:   "error:",
+			expected: "error: something went wrong\n",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			reader := strings.NewReader(tt.input)
+			writer := &bytes.Buffer{}
+			ctx := context.Background()
+
+			err := streamFilterLines(reader, writer, tt.filter, ctx)
+
+			assert.NoError(t, err)
+			assert.Equal(t, tt.expected, writer.String())
+		})
+	}
+}
+
+func TestStreamFilterLines_ContextCancellation(t *testing.T) {
+	input := strings.Repeat("hello world\n", 1000)
+	reader := strings.NewReader(input)
+	writer := &bytes.Buffer{}
+	ctx, cancel := context.WithCancel(context.Background())
+
+	cancel()
+
+	err := streamFilterLines(reader, writer, "hello", ctx)
+
+	assert.NoError(t, err)
+}
+
+func TestStreamFilterLines_NonASCIIFilter(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    string
+		filter   string
+		expected string
+	}{
+		{
+			name:     "UTF-8 characters",
+			input:    "hello 世界\nfoo bar\n",
+			filter:   "世界",
+			expected: "hello 世界\n",
+		},
+		{
+			name:     "emoji filter",
+			input:    "error 🚨 occurred\ninfo: all good\n",
+			filter:   "🚨",
+			expected: "error 🚨 occurred\n",
+		},
+		{
+			name:     "mixed ASCII and UTF-8",
+			input:    "hello 世界 world\nfoo bar\n",
+			filter:   "世界",
+			expected: "hello 世界 world\n",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			reader := strings.NewReader(tt.input)
+			writer := &bytes.Buffer{}
+			ctx := context.Background()
+
+			err := streamFilterLines(reader, writer, tt.filter, ctx)
+
+			assert.NoError(t, err)
+			assert.Equal(t, tt.expected, writer.String())
+		})
+	}
+}
+
+func TestStreamFilterLines_LongLines(t *testing.T) {
+	longLine := strings.Repeat("a", 100000) + " target " + strings.Repeat("b", 100000) + "\n"
+	shortLine := "target\n"
+
+	input := longLine + shortLine
+	reader := strings.NewReader(input)
+	writer := &bytes.Buffer{}
+	ctx := context.Background()
+
+	err := streamFilterLines(reader, writer, "target", ctx)
+
+	assert.NoError(t, err)
+	assert.Contains(t, writer.String(), "target")
+	assert.Equal(t, 2, strings.Count(writer.String(), "target"))
+}
+
+func TestStreamFilterLines_EmptyLines(t *testing.T) {
+	input := "line with content\n\nanother line\n\n\n"
+	reader := strings.NewReader(input)
+	writer := &bytes.Buffer{}
+	ctx := context.Background()
+
+	err := streamFilterLines(reader, writer, "", ctx)
+
+	assert.NoError(t, err)
+	lines := strings.Split(writer.String(), "\n")
+	assert.GreaterOrEqual(t, len(lines), 5)
+}