497 lines
13 KiB
Go
497 lines
13 KiB
Go
package gui
|
|
|
|
import (
|
|
"context"
|
|
"log/slog"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"gioui.org/layout"
|
|
"gioui.org/op/clip"
|
|
"gioui.org/text"
|
|
"gioui.org/widget"
|
|
"gioui.org/widget/material"
|
|
|
|
"tslink/core"
|
|
"tslink/netdiag"
|
|
)
|
|
|
|
type logsPage struct {
|
|
app *App
|
|
list widget.List
|
|
|
|
search widget.Editor
|
|
level widget.Enum
|
|
source widget.Enum
|
|
follow widget.Bool
|
|
redact widget.Bool
|
|
|
|
copyBtn widget.Clickable
|
|
saveBtn widget.Clickable
|
|
uploadBtn widget.Clickable
|
|
urlCopyBtn widget.Clickable
|
|
|
|
// mu guards the upload/save result fields, written from a goroutine.
|
|
mu sync.Mutex
|
|
uploading bool
|
|
uploadURL string
|
|
uploadTarget string
|
|
uploadErr string
|
|
savedPath string
|
|
|
|
// Cached filter result. Re-running the query over the whole ring on every
|
|
// frame is wasted work: it can only change when a record is appended or
|
|
// the query itself changes.
|
|
cached []core.LogEntry
|
|
cachedSeq uint64
|
|
cachedLen int
|
|
cachedQ core.LogQuery
|
|
}
|
|
|
|
// entries returns the filtered records, recomputing only when the buffer or
|
|
// the query moved.
|
|
func (p *logsPage) entries(buf *core.LogBuffer) []core.LogEntry {
|
|
q := p.query()
|
|
seq, n := buf.LastSeq(), buf.Len()
|
|
if p.cached != nil && seq == p.cachedSeq && n == p.cachedLen && q == p.cachedQ {
|
|
return p.cached
|
|
}
|
|
p.cached = buf.Filter(q)
|
|
p.cachedSeq, p.cachedLen, p.cachedQ = seq, n, q
|
|
return p.cached
|
|
}
|
|
|
|
func newLogsPage(a *App) *logsPage {
|
|
p := &logsPage{app: a}
|
|
p.list.Axis = layout.Vertical
|
|
p.search.SingleLine = true
|
|
p.level.Value = "all"
|
|
p.source.Value = "all"
|
|
p.follow.Value = true
|
|
p.redact.Value = true
|
|
return p
|
|
}
|
|
|
|
func (p *logsPage) minLevel() slog.Level {
|
|
switch p.level.Value {
|
|
case "debug":
|
|
return slog.LevelDebug
|
|
case "info":
|
|
return slog.LevelInfo
|
|
case "warn":
|
|
return slog.LevelWarn
|
|
case "error":
|
|
return slog.LevelError
|
|
default:
|
|
return slog.LevelDebug - 4 // below everything
|
|
}
|
|
}
|
|
|
|
func (p *logsPage) query() core.LogQuery {
|
|
q := core.LogQuery{
|
|
MinLevel: p.minLevel(),
|
|
Text: strings.TrimSpace(p.search.Text()),
|
|
}
|
|
if p.source.Value != "all" {
|
|
q.Source = p.source.Value
|
|
}
|
|
return q
|
|
}
|
|
|
|
func (p *logsPage) Layout(a *App, gtx C, st core.State) D {
|
|
th := a.th
|
|
if a.opt.Logs == nil {
|
|
return th.EmptyState(gtx, IconList, th.T(KLogsEmpty), "")
|
|
}
|
|
buf := a.opt.Logs
|
|
|
|
p.handleActions(a, gtx, buf)
|
|
p.list.ScrollToEnd = p.follow.Value
|
|
|
|
entries := p.entries(buf)
|
|
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
|
|
layout.Rigid(func(gtx C) D {
|
|
return layout.Inset{Bottom: SpaceMD}.Layout(gtx, func(gtx C) D {
|
|
return p.toolbar(a, gtx, buf, len(entries))
|
|
})
|
|
}),
|
|
layout.Flexed(1, func(gtx C) D {
|
|
return p.logList(a, gtx, entries)
|
|
}),
|
|
)
|
|
}
|
|
|
|
func (p *logsPage) handleActions(a *App, gtx C, buf *core.LogBuffer) {
|
|
th := a.th
|
|
export := func() string {
|
|
return buf.ExportText(core.ExportOptions{
|
|
Query: p.query(),
|
|
NoRedact: !p.redact.Value,
|
|
Header: a.diagnosticHeader(),
|
|
})
|
|
}
|
|
|
|
if p.copyBtn.Clicked(gtx) {
|
|
a.copyToClipboard(gtx, export(), th.T(KCopied))
|
|
}
|
|
if p.saveBtn.Clicked(gtx) {
|
|
path, err := saveLogFile(export())
|
|
p.mu.Lock()
|
|
if err != nil {
|
|
p.savedPath = ""
|
|
p.uploadErr = err.Error()
|
|
} else {
|
|
p.savedPath = path
|
|
p.uploadErr = ""
|
|
}
|
|
p.mu.Unlock()
|
|
if err != nil {
|
|
a.notify(th.T(KError)+": "+err.Error(), LevelFail)
|
|
} else {
|
|
a.notify(path, LevelOK)
|
|
}
|
|
}
|
|
if p.uploadBtn.Clicked(gtx) {
|
|
p.startUpload(a, export())
|
|
}
|
|
if p.urlCopyBtn.Clicked(gtx) {
|
|
p.mu.Lock()
|
|
url := p.uploadURL
|
|
p.mu.Unlock()
|
|
if url != "" {
|
|
a.copyToClipboard(gtx, url, th.T(KCopied))
|
|
}
|
|
}
|
|
}
|
|
|
|
// startUpload publishes the bundle to a public paste service.
|
|
//
|
|
// This sends the user's logs off the machine, so the redaction toggle is on by
|
|
// default and the button label says "upload and share" rather than something
|
|
// vaguer: nobody should be surprised about what just left their computer.
|
|
func (p *logsPage) startUpload(a *App, text string) {
|
|
p.mu.Lock()
|
|
if p.uploading {
|
|
p.mu.Unlock()
|
|
return
|
|
}
|
|
p.uploading = true
|
|
p.uploadURL = ""
|
|
p.uploadErr = ""
|
|
p.mu.Unlock()
|
|
|
|
go func() {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
|
|
defer cancel()
|
|
res, err := netdiag.Upload(ctx, "", text, a.logger.With("from", "paste"))
|
|
|
|
p.mu.Lock()
|
|
p.uploading = false
|
|
if err != nil {
|
|
p.uploadErr = err.Error()
|
|
} else {
|
|
p.uploadURL = res.URL
|
|
p.uploadTarget = res.Target
|
|
}
|
|
p.mu.Unlock()
|
|
|
|
if err != nil {
|
|
a.notify(a.th.T(KLogsUploadFail)+": "+Truncate(err.Error(), 80), LevelFail)
|
|
} else {
|
|
a.notify(a.th.T(KLogsUploaded)+" "+res.URL, LevelOK)
|
|
}
|
|
if a.win != nil {
|
|
a.win.Invalidate()
|
|
}
|
|
}()
|
|
}
|
|
|
|
// saveLogFile writes the bundle next to the user's home directory. There is no
|
|
// native file picker without pulling in another dependency, so the app picks a
|
|
// predictable path and reports it rather than silently doing nothing.
|
|
func saveLogFile(content string) (string, error) {
|
|
dir, err := os.UserHomeDir()
|
|
if err != nil || dir == "" {
|
|
dir = "."
|
|
}
|
|
name := "tslink-log-" + time.Now().Format("20060102-150405") + ".txt"
|
|
path := filepath.Join(dir, name)
|
|
if err := os.WriteFile(path, []byte(content), 0o600); err != nil {
|
|
return "", err
|
|
}
|
|
return path, nil
|
|
}
|
|
|
|
func (p *logsPage) toolbar(a *App, gtx C, buf *core.LogBuffer, shown int) D {
|
|
th := a.th
|
|
counts := buf.Counts()
|
|
total := buf.Len()
|
|
|
|
card := th.Card()
|
|
card.Pad = SpaceMD
|
|
return card.Layout(th, gtx, func(gtx C) D {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
|
|
// Row 1: search + level filter.
|
|
layout.Rigid(func(gtx C) D {
|
|
return layout.Flex{Alignment: layout.Middle}.Layout(gtx,
|
|
layout.Flexed(1, func(gtx C) D {
|
|
return p.searchField(a, gtx)
|
|
}),
|
|
HGap(SpaceMD),
|
|
layout.Rigid(func(gtx C) D {
|
|
return th.Segmented(gtx, &p.level, []SegmentOption{
|
|
{Key: "all", Label: th.T(KLogsAll), Count: total},
|
|
{Key: "debug", Label: "DBG", Count: counts[slog.LevelDebug]},
|
|
{Key: "info", Label: "INF", Count: counts[slog.LevelInfo]},
|
|
{Key: "warn", Label: "WRN", Count: counts[slog.LevelWarn], Level: LevelWarn},
|
|
{Key: "error", Label: "ERR", Count: counts[slog.LevelError], Level: LevelFail},
|
|
})
|
|
}),
|
|
)
|
|
}),
|
|
// Row 2: source filter.
|
|
layout.Rigid(func(gtx C) D {
|
|
sources := buf.Sources()
|
|
if len(sources) == 0 {
|
|
return D{}
|
|
}
|
|
if len(sources) > 6 {
|
|
sources = sources[:6]
|
|
}
|
|
opts := make([]SegmentOption, 0, len(sources)+1)
|
|
opts = append(opts, SegmentOption{Key: "all", Label: th.T(KLogsAll), Count: -1})
|
|
for _, s := range sources {
|
|
opts = append(opts, SegmentOption{Key: s, Label: s, Count: -1})
|
|
}
|
|
return layout.Inset{Top: SpaceSM}.Layout(gtx, func(gtx C) D {
|
|
return th.Segmented(gtx, &p.source, opts)
|
|
})
|
|
}),
|
|
// Row 3: toggles + actions.
|
|
layout.Rigid(func(gtx C) D {
|
|
return layout.Inset{Top: SpaceMD}.Layout(gtx, func(gtx C) D {
|
|
return layout.Flex{Alignment: layout.Middle}.Layout(gtx,
|
|
layout.Rigid(func(gtx C) D {
|
|
return th.Toggle(gtx, &p.follow, th.T(KLogsFollow))
|
|
}),
|
|
HGap(SpaceLG),
|
|
layout.Rigid(func(gtx C) D {
|
|
return th.Toggle(gtx, &p.redact, th.T(KLogsRedact))
|
|
}),
|
|
layout.Flexed(1, func(gtx C) D {
|
|
return layout.E.Layout(gtx, func(gtx C) D {
|
|
return p.actions(a, gtx)
|
|
})
|
|
}),
|
|
)
|
|
})
|
|
}),
|
|
// Row 4: counts + upload result.
|
|
layout.Rigid(func(gtx C) D {
|
|
return layout.Inset{Top: SpaceSM}.Layout(gtx, func(gtx C) D {
|
|
return p.statusLine(a, gtx, buf, shown, total)
|
|
})
|
|
}),
|
|
)
|
|
})
|
|
}
|
|
|
|
func (p *logsPage) searchField(a *App, gtx C) D {
|
|
th := a.th
|
|
return layout.Stack{}.Layout(gtx,
|
|
layout.Expanded(func(gtx C) D {
|
|
FillRRect(gtx, gtx.Constraints.Min, RadiusSM, th.P.BgElevated)
|
|
StrokeRRect(gtx, gtx.Constraints.Min, RadiusSM, 1, th.P.Border)
|
|
return D{Size: gtx.Constraints.Min}
|
|
}),
|
|
layout.Stacked(func(gtx C) D {
|
|
gtx.Constraints.Min.X = gtx.Constraints.Max.X
|
|
return layout.Inset{
|
|
Top: 7, Bottom: 7, Left: SpaceMD, Right: SpaceMD,
|
|
}.Layout(gtx, func(gtx C) D {
|
|
return layout.Flex{Alignment: layout.Middle}.Layout(gtx,
|
|
layout.Rigid(func(gtx C) D {
|
|
return IconSearch(gtx, gtx.Dp(14), th.P.TextDim)
|
|
}),
|
|
HGap(SpaceSM),
|
|
layout.Flexed(1, func(gtx C) D {
|
|
ed := material.Editor(th.Theme, &p.search, th.T(KLogsSearch))
|
|
ed.TextSize = SizeBody
|
|
ed.Color = th.P.TextPri
|
|
ed.HintColor = th.P.TextDim
|
|
return ed.Layout(gtx)
|
|
}),
|
|
)
|
|
})
|
|
}),
|
|
)
|
|
}
|
|
|
|
func (p *logsPage) actions(a *App, gtx C) D {
|
|
th := a.th
|
|
p.mu.Lock()
|
|
uploading := p.uploading
|
|
p.mu.Unlock()
|
|
|
|
uploadLabel := th.T(KLogsUpload)
|
|
if uploading {
|
|
uploadLabel = th.T(KLogsUploading)
|
|
}
|
|
return layout.Flex{Alignment: layout.Middle}.Layout(gtx,
|
|
layout.Rigid(func(gtx C) D {
|
|
return th.Button(gtx, &p.copyBtn, ButtonStyle{
|
|
Kind: ButtonGhost, Text: th.T(KLogsCopyAll), Icon: IconCopy,
|
|
})
|
|
}),
|
|
HGap(SpaceSM),
|
|
layout.Rigid(func(gtx C) D {
|
|
return th.Button(gtx, &p.saveBtn, ButtonStyle{
|
|
Kind: ButtonGhost, Text: th.T(KLogsSaveFile), Icon: IconSave,
|
|
})
|
|
}),
|
|
HGap(SpaceSM),
|
|
layout.Rigid(func(gtx C) D {
|
|
return th.Button(gtx, &p.uploadBtn, ButtonStyle{
|
|
Kind: ButtonSubtle,
|
|
Text: uploadLabel,
|
|
Icon: IconUpload,
|
|
Disabled: uploading,
|
|
})
|
|
}),
|
|
)
|
|
}
|
|
|
|
func (p *logsPage) statusLine(a *App, gtx C, buf *core.LogBuffer, shown, total int) D {
|
|
th := a.th
|
|
p.mu.Lock()
|
|
url, target, upErr, saved := p.uploadURL, p.uploadTarget, p.uploadErr, p.savedPath
|
|
p.mu.Unlock()
|
|
|
|
return layout.Flex{Alignment: layout.Middle}.Layout(gtx,
|
|
layout.Rigid(func(gtx C) D {
|
|
txt := th.T(KLogsShown) + " " + itoa(shown) + " / " + itoa(total)
|
|
if d := buf.Dropped(); d > 0 {
|
|
txt += " · " + itoa(int(d)) + " " + th.T(KLogsDropped)
|
|
}
|
|
return th.Caption(txt).Layout(gtx)
|
|
}),
|
|
layout.Flexed(1, func(gtx C) D {
|
|
return layout.E.Layout(gtx, func(gtx C) D {
|
|
switch {
|
|
case url != "":
|
|
return layout.Flex{Alignment: layout.Middle}.Layout(gtx,
|
|
layout.Rigid(func(gtx C) D {
|
|
return OneLine(th.MonoLabel(SizeCaption, th.P.OK, url)).Layout(gtx)
|
|
}),
|
|
layout.Rigid(func(gtx C) D {
|
|
if target == "" {
|
|
return D{}
|
|
}
|
|
return layout.Inset{Left: 6}.Layout(gtx,
|
|
th.Caption("("+target+")").Layout)
|
|
}),
|
|
layout.Rigid(func(gtx C) D {
|
|
return th.IconButton(gtx, &p.urlCopyBtn, IconCopy, LevelOK)
|
|
}),
|
|
)
|
|
case upErr != "":
|
|
return OneLine(th.Text(SizeCaption, th.P.Fail, Truncate(upErr, 90))).Layout(gtx)
|
|
case saved != "":
|
|
return OneLine(th.MonoLabel(SizeCaption, th.P.TextSec, saved)).Layout(gtx)
|
|
default:
|
|
return OneLine(th.Caption(th.T(KLogsRedactHint))).Layout(gtx)
|
|
}
|
|
})
|
|
}),
|
|
)
|
|
}
|
|
|
|
func (p *logsPage) logList(a *App, gtx C, entries []core.LogEntry) D {
|
|
th := a.th
|
|
card := th.Card()
|
|
card.Pad = SpaceSM
|
|
return card.Layout(th, gtx, func(gtx C) D {
|
|
if len(entries) == 0 {
|
|
return th.EmptyState(gtx, IconSearch, th.T(KLogsEmpty), "")
|
|
}
|
|
gtx.Constraints.Min.Y = gtx.Constraints.Max.Y
|
|
defer clip.Rect{Max: gtx.Constraints.Max}.Push(gtx.Ops).Pop()
|
|
return material.List(th.Theme, &p.list).Layout(gtx, len(entries), func(gtx C, i int) D {
|
|
return p.logRow(th, gtx, entries[i])
|
|
})
|
|
})
|
|
}
|
|
|
|
func (p *logsPage) logRow(th *Theme, gtx C, e core.LogEntry) D {
|
|
lvlCol := th.P.TextDim
|
|
switch {
|
|
case e.Level >= slog.LevelError:
|
|
lvlCol = th.P.Fail
|
|
case e.Level >= slog.LevelWarn:
|
|
lvlCol = th.P.Warn
|
|
case e.Level >= slog.LevelInfo:
|
|
lvlCol = th.P.Info
|
|
}
|
|
msgCol := th.P.TextSec
|
|
if e.Level >= slog.LevelWarn {
|
|
msgCol = th.P.TextPri
|
|
}
|
|
|
|
msg := e.Msg
|
|
attrs := make([]string, 0, len(e.Attrs))
|
|
for _, at := range e.Attrs {
|
|
if at.Key == "from" {
|
|
continue
|
|
}
|
|
attrs = append(attrs, at.Key+"="+core.Redact(at.Value))
|
|
}
|
|
|
|
return layout.Inset{Top: 2, Bottom: 2, Left: SpaceSM, Right: SpaceSM}.Layout(gtx, func(gtx C) D {
|
|
return layout.Flex{Alignment: layout.Start}.Layout(gtx,
|
|
layout.Rigid(func(gtx C) D {
|
|
return th.MonoLabel(SizeMono, WithAlpha(th.P.TextDim, 0.9),
|
|
e.Time.Format("15:04:05.000")).Layout(gtx)
|
|
}),
|
|
HGap(SpaceSM),
|
|
layout.Rigid(func(gtx C) D {
|
|
gtx.Constraints.Min.X = gtx.Dp(28)
|
|
return th.MonoLabel(SizeMono, lvlCol, core.LevelLabel(e.Level)).Layout(gtx)
|
|
}),
|
|
HGap(SpaceSM),
|
|
layout.Rigid(func(gtx C) D {
|
|
if e.Source == "" {
|
|
return D{}
|
|
}
|
|
gtx.Constraints.Max.X = gtx.Dp(96)
|
|
l := th.MonoLabel(SizeMono, WithAlpha(th.P.Info, 0.85), e.Source)
|
|
l.MaxLines = 1
|
|
l.Alignment = text.End
|
|
return l.Layout(gtx)
|
|
}),
|
|
HGap(SpaceSM),
|
|
layout.Flexed(1, func(gtx C) D {
|
|
return layout.Flex{Axis: layout.Vertical}.Layout(gtx,
|
|
layout.Rigid(func(gtx C) D {
|
|
l := th.MonoLabel(SizeMono, msgCol, core.Redact(msg))
|
|
l.MaxLines = 3
|
|
return l.Layout(gtx)
|
|
}),
|
|
layout.Rigid(func(gtx C) D {
|
|
if len(attrs) == 0 {
|
|
return D{}
|
|
}
|
|
l := th.MonoLabel(SizeMono, WithAlpha(th.P.TextDim, 0.95),
|
|
strings.Join(attrs, " "))
|
|
l.MaxLines = 2
|
|
return l.Layout(gtx)
|
|
}),
|
|
)
|
|
}),
|
|
)
|
|
})
|
|
}
|