feat: support filtering by field (#156)

Co-authored-by: Vojtěch Frič <vojtechfric@ibm.com>
Co-authored-by: Vojtěch Frič <you@example.com>

Author: 3 people

internal/app/statefiltered.go

@@ -18,19 +18,22 @@ type StateFilteredModel struct {
 	table         logsTableModel
 	logEntries    source.LazyLogEntries
 
-	filterText string
+	filterText  string
+	filterField string
 }
 
 func newStateFiltered(
 	previousState StateLoadedModel,
 	filterText string,
+	filterField string,
 ) StateFilteredModel {
 	return StateFilteredModel{
 		Application: previousState.Application,
 
 		previousState: previousState,
 
-		filterText: filterText,
+		filterText:  filterText,
+		filterField: filterField,
 	}
 }
 
@@ -43,9 +46,14 @@ func (s StateFilteredModel) Init() tea.Cmd {
 
 // View renders component. It implements tea.Model.
 func (s StateFilteredModel) View() string {
-	footer := s.FooterStyle.Render(
-		fmt.Sprintf("filtered %d by: %s", s.logEntries.Len(), s.filterText),
-	)
+	var msg string
+	if s.filterField == "" {
+		msg = fmt.Sprintf("filtered %d by: %s", s.logEntries.Len(), s.filterText)
+	} else {
+		msg = fmt.Sprintf("filtered %d by field: %s, query: %s", s.logEntries.Len(), s.filterField, s.filterText)
+	}
+
+	footer := s.FooterStyle.Render(msg)
 
 	return s.BaseStyle.Render(s.table.View()) + "\n" + footer
 }
@@ -94,7 +102,7 @@ func (s StateFilteredModel) handleKeyMsg(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 }
 
 func (s StateFilteredModel) handleStateFilteredModel() (StateFilteredModel, tea.Msg) {
-	entries, err := s.Application.Entries().Filter(s.filterText)
+	entries, err := s.Application.Entries().Filter(s.filterText, s.filterField, s.Config)
 	if err != nil {
 		return s, events.ShowError(err)()
 	}

internal/app/statefiltered_test.go

@@ -39,7 +39,7 @@ func TestStateFiltered(t *testing.T) {
 		})
 
 		lines := strings.Split(model.View(), "\n")
-		assert.Contains(t, lines[len(lines)-1], ">")
+		assert.Contains(t, lines[len(lines)-2], ">")
 
 		_, ok := model.(app.StateFilteringModel)
 		assert.Truef(t, ok, "%s", model)

internal/app/statefiltering.go

@@ -2,11 +2,11 @@ package app
 
 import (
 	"github.com/charmbracelet/bubbles/key"
-	"github.com/charmbracelet/bubbles/textinput"
 	tea "github.com/charmbracelet/bubbletea"
 
 	"github.com/hedhyw/json-log-viewer/internal/keymap"
 	"github.com/hedhyw/json-log-viewer/internal/pkg/events"
+	"github.com/hedhyw/json-log-viewer/internal/pkg/widgets"
 )
 
 // StateFilteringModel is a state to prompt for filter term.
@@ -16,14 +16,19 @@ type StateFilteringModel struct {
 	previousState StateLoadedModel
 	table         logsTableModel
 
-	textInput textinput.Model
+	textInput widgets.PillInputModel
 	keys      keymap.KeyMap
 }
 
 func newStateFiltering(
 	previousState StateLoadedModel,
 ) StateFilteringModel {
-	textInput := textinput.New()
+	fieldTitles := make([]string, len(previousState.Config.Fields))
+	for i, f := range previousState.Config.Fields {
+		fieldTitles[i] = f.Title
+	}
+
+	textInput := widgets.NewPillInputModel(fieldTitles)
 	textInput.Focus()
 
 	return StateFilteringModel{
@@ -39,7 +44,7 @@ func newStateFiltering(
 
 // Init initializes component. It implements tea.Model.
 func (s StateFilteringModel) Init() tea.Cmd {
-	return nil
+	return s.textInput.Init()
 }
 
 // View renders component. It implements tea.Model.
@@ -64,7 +69,11 @@ func (s StateFilteringModel) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		s.table, cmdBatch = batched(s.table.Update(msg))(cmdBatch)
 	}
 
-	s.textInput, cmdBatch = batched(s.textInput.Update(msg))(cmdBatch)
+	var cmd tea.Cmd
+	s.textInput, cmd = s.textInput.Update(msg)
+	if cmd != nil {
+		cmdBatch = append(cmdBatch, cmd)
+	}
 
 	return s, tea.Batch(cmdBatch...)
 }
@@ -81,13 +90,15 @@ func (s StateFilteringModel) handleKeyMsg(msg tea.KeyMsg) (tea.Model, tea.Cmd) {
 }
 
 func (s StateFilteringModel) handleEnterKeyClickedMsg() (tea.Model, tea.Cmd) {
-	if s.textInput.Value() == "" {
+	filterField, input := s.textInput.Value()
+	if input == "" {
 		return s, events.EscKeyClicked
 	}
 
 	return initializeModel(newStateFiltered(
 		s.previousState,
-		s.textInput.Value(),
+		input,
+		filterField,
 	))
 }
 

internal/pkg/source/entry.go

@@ -91,11 +91,13 @@ func (entries LazyLogEntries) Len() int {
 }
 
 // Filter filters entries by ignore case exact match.
-func (entries LazyLogEntries) Filter(term string) (LazyLogEntries, error) {
+func (entries LazyLogEntries) Filter(term string, fieldName string, c *config.Config) (LazyLogEntries, error) {
 	if term == "" {
 		return entries, nil
 	}
 
+	fieldIndex := getFilterFieldNameIndex(fieldName, c)
+
 	termLower := bytes.ToLower([]byte(term))
 
 	filtered := make([]LazyLogEntry, 0, len(entries.Entries))
@@ -106,8 +108,21 @@ func (entries LazyLogEntries) Filter(term string) (LazyLogEntries, error) {
 			return LazyLogEntries{}, err
 		}
 
-		if bytes.Contains(bytes.ToLower(line), termLower) {
-			filtered = append(filtered, f)
+		if len(fieldName) == 0 {
+			// fulltext mode
+			if bytes.Contains(bytes.ToLower(line), termLower) {
+				filtered = append(filtered, f)
+			}
+		} else {
+			// field mode
+			entry := f.LogEntry(entries.Seeker, c)
+			if entry.Error != nil {
+				return LazyLogEntries{}, entry.Error
+			}
+
+			if bytes.Contains(bytes.ToLower([]byte(entry.Fields[fieldIndex])), termLower) {
+				filtered = append(filtered, f)
+			}
 		}
 	}
 
@@ -117,6 +132,20 @@ func (entries LazyLogEntries) Filter(term string) (LazyLogEntries, error) {
 	}, nil
 }
 
+func getFilterFieldNameIndex(fieldName string, c *config.Config) int {
+	if c == nil || fieldName == "" {
+		return -1
+	}
+
+	for i, field := range c.Fields {
+		if strings.EqualFold(field.Title, fieldName) {
+			return i
+		}
+	}
+
+	return -1
+}
+
 func parseField(
 	parsedLine any,
 	field config.Field,

internal/pkg/source/entry_test.go

@@ -276,7 +276,7 @@ func TestLazyLogEntriesFilter(t *testing.T) {
 
 		logEntries, logEntry := createEntries(t)
 
-		filtered, err := logEntries.Filter(term)
+		filtered, err := logEntries.Filter(term, "", nil)
 		require.NoError(t, err)
 
 		if assert.Len(t, filtered.Entries, 1) {
@@ -289,7 +289,7 @@ func TestLazyLogEntriesFilter(t *testing.T) {
 
 		logEntries, logEntry := createEntries(t)
 
-		filtered, err := logEntries.Filter(strings.ToUpper(term))
+		filtered, err := logEntries.Filter(strings.ToUpper(term), "", nil)
 		require.NoError(t, err)
 
 		if assert.Len(t, filtered.Entries, 1) {
@@ -302,7 +302,7 @@ func TestLazyLogEntriesFilter(t *testing.T) {
 
 		logEntries, _ := createEntries(t)
 
-		filtered, err := logEntries.Filter("")
+		filtered, err := logEntries.Filter("", "", nil)
 		require.NoError(t, err)
 		assert.Len(t, filtered.Entries, logEntries.Len())
 	})
@@ -312,7 +312,7 @@ func TestLazyLogEntriesFilter(t *testing.T) {
 
 		logEntries, _ := createEntries(t)
 
-		filtered, err := logEntries.Filter(term + " - not found!")
+		filtered, err := logEntries.Filter(term+" - not found!", "", nil)
 		require.NoError(t, err)
 
 		assert.Empty(t, filtered.Entries)
@@ -331,11 +331,53 @@ func TestLazyLogEntriesFilter(t *testing.T) {
 
 		logEntries.Seeker = f
 
-		_, err = logEntries.Filter(term + " - not found!")
+		_, err = logEntries.Filter(term+" - not found!", "", nil)
 		require.Error(t, err)
 	})
 }
 
+func TestLazyLogEntriesFieldFilter(t *testing.T) {
+	t.Parallel()
+
+	const term = "info"
+
+	const logs = `
+{"level":"info","time":"2025-12-16T13:20:00-05:00","message":"2025-12-16 13:20:00.049  Day1|  Ana went home!"}
+{"level":"debug","time":"2025-12-16T13:20:00-05:00","message":"2025-12-16 13:21:00.049  Day2| Tom was daydreaming"}
+{"level":"error","time":"2025-12-16T13:20:00-05:00","message":"2025-12-16 13:22:00.049  Day3| Can't wait to be weekend!"}
+`
+
+	defaultConfig := config.GetDefaultConfig()
+
+	createEntries := func(tb testing.TB) (source.LazyLogEntries, source.LazyLogEntry) {
+		tb.Helper()
+		source, err := source.Reader(bytes.NewReader([]byte(logs)), defaultConfig)
+		require.NoError(tb, err)
+
+		tb.Cleanup(func() { assert.NoError(tb, source.Close()) })
+
+		logEntries, err := source.ParseLogEntries()
+		require.NoError(tb, err)
+
+		logEntry := logEntries.Entries[0]
+
+		return logEntries, logEntry
+	}
+
+	t.Run("found_exact", func(t *testing.T) {
+		t.Parallel()
+
+		logEntries, logEntry := createEntries(t)
+
+		filtered, err := logEntries.Filter(term, "level", defaultConfig)
+		require.NoError(t, err)
+
+		if assert.Len(t, filtered.Entries, 1) {
+			assert.Equal(t, logEntry, filtered.Entries[0])
+		}
+	})
+}
+
 func TestSecondTimeFormatting(t *testing.T) {
 	t.Parallel()