mirror of
https://github.com/minio/mc.git
synced 2025-04-18 10:04:03 +03:00
86907df91d
Allows traces to be replayed in stats mode from `mc admin trace -json ALIAS >trace.json`, using `mc admin trace -in=trace.json`. `.zst` are automatically decompressed. This is replayed at full speed, since I don't really see any value in keeping original speed. Add scrolling to stats. Up+Down+Home+End Add 'r' to reset min/max stats.
355 lines
9.9 KiB
Go
355 lines
9.9 KiB
Go
// Copyright (c) 2015-2024 MinIO, Inc.
|
|
//
|
|
// This file is part of MinIO Object Storage stack
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package cmd
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/charmbracelet/bubbles/spinner"
|
|
tea "github.com/charmbracelet/bubbletea"
|
|
"github.com/charmbracelet/lipgloss"
|
|
"github.com/dustin/go-humanize"
|
|
"github.com/fatih/color"
|
|
"github.com/minio/madmin-go/v3"
|
|
"github.com/minio/pkg/v3/console"
|
|
"github.com/muesli/reflow/truncate"
|
|
"github.com/olekukonko/tablewriter"
|
|
"golang.org/x/term"
|
|
)
|
|
|
|
type traceStatsUI struct {
|
|
current *statTrace
|
|
started time.Time
|
|
meter spinner.Model
|
|
quitting bool
|
|
maxEntries int
|
|
offset int
|
|
allFlag bool
|
|
}
|
|
|
|
func (m *traceStatsUI) Init() tea.Cmd {
|
|
return m.meter.Tick
|
|
}
|
|
|
|
func (m *traceStatsUI) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
|
|
if m.quitting {
|
|
return m, tea.Quit
|
|
}
|
|
switch msg := msg.(type) {
|
|
case tea.KeyMsg:
|
|
switch msg.String() {
|
|
case "q", "esc", "ctrl+c":
|
|
m.quitting = true
|
|
return m, tea.Quit
|
|
case "r":
|
|
// Reset min/max
|
|
m.current.mu.Lock()
|
|
defer m.current.mu.Unlock()
|
|
for k, si := range m.current.Calls {
|
|
si.MaxDur, si.MinDur = 0, 0
|
|
si.MaxTTFB = 0
|
|
m.current.Calls[k] = si
|
|
}
|
|
return m, nil
|
|
case "down":
|
|
m.offset++
|
|
case "up":
|
|
m.offset--
|
|
case "home":
|
|
m.offset = 0
|
|
case "end":
|
|
m.offset = len(m.current.Calls)
|
|
default:
|
|
return m, nil
|
|
}
|
|
case spinner.TickMsg:
|
|
var cmd tea.Cmd
|
|
m.meter, cmd = m.meter.Update(msg)
|
|
return m, cmd
|
|
}
|
|
return m, nil
|
|
}
|
|
|
|
func (m *traceStatsUI) View() string {
|
|
var s strings.Builder
|
|
|
|
dur := m.current.Latest.Sub(m.current.Oldest)
|
|
s.WriteString(fmt.Sprintf("%s %s\n",
|
|
console.Colorize("metrics-top-title", "Duration: "+dur.Round(time.Second).String()), m.meter.View()))
|
|
|
|
// Set table header - akin to k8s style
|
|
// https://github.com/olekukonko/tablewriter#example-10---set-nowhitespace-and-tablepadding-option
|
|
table := tablewriter.NewWriter(&s)
|
|
table.SetAutoWrapText(false)
|
|
table.SetAutoFormatHeaders(true)
|
|
table.SetHeaderAlignment(tablewriter.ALIGN_LEFT)
|
|
table.SetAlignment(tablewriter.ALIGN_LEFT)
|
|
table.SetCenterSeparator("")
|
|
table.SetColumnSeparator("")
|
|
table.SetRowSeparator("")
|
|
table.SetHeaderLine(false)
|
|
table.SetBorder(false)
|
|
table.SetTablePadding(" ") // pad with tabs
|
|
table.SetNoWhiteSpace(true)
|
|
var entries []statItem
|
|
|
|
m.current.mu.Lock()
|
|
var (
|
|
totalCnt = 0
|
|
totalRX = 0
|
|
totalTX = 0
|
|
)
|
|
for _, v := range m.current.Calls {
|
|
totalCnt += v.Count
|
|
totalRX += v.CallStats.Rx
|
|
totalTX += v.CallStats.Tx
|
|
entries = append(entries, v)
|
|
}
|
|
m.current.mu.Unlock()
|
|
if len(entries) == 0 {
|
|
s.WriteString("(waiting for data)")
|
|
return s.String()
|
|
}
|
|
sort.Slice(entries, func(i, j int) bool {
|
|
if entries[i].Count == entries[j].Count {
|
|
return entries[i].Name < entries[j].Name
|
|
}
|
|
return entries[i].Count > entries[j].Count
|
|
})
|
|
|
|
frontTrunc := false
|
|
endTrunc := false
|
|
m.offset = min(max(0, m.offset), len(entries))
|
|
offset := m.offset
|
|
if m.maxEntries > 0 && len(entries) > m.maxEntries {
|
|
entLeft := len(entries) - offset
|
|
if entLeft > m.maxEntries {
|
|
// Truncate both ends
|
|
entries = entries[offset : m.maxEntries+offset]
|
|
frontTrunc = offset > 0
|
|
endTrunc = true
|
|
} else {
|
|
entries = entries[len(entries)-m.maxEntries:]
|
|
frontTrunc = true
|
|
}
|
|
}
|
|
hasTTFB := false
|
|
for _, e := range entries {
|
|
if e.TTFB > 0 {
|
|
hasTTFB = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if !m.allFlag {
|
|
if totalRX > 0 {
|
|
s.WriteString(console.Colorize("metrics-top-title", fmt.Sprintf("RX Rate:↑ %s/m\n",
|
|
humanize.IBytes(uint64(float64(totalRX)/dur.Minutes())))))
|
|
}
|
|
if totalTX > 0 {
|
|
s.WriteString(console.Colorize("metrics-top-title", fmt.Sprintf("TX Rate:↓ %s/m\n",
|
|
humanize.IBytes(uint64(float64(totalTX)/dur.Minutes())))))
|
|
}
|
|
}
|
|
s.WriteString(console.Colorize("metrics-top-title", fmt.Sprintf("RPM : %0.1f\n", float64(totalCnt)/dur.Minutes())))
|
|
s.WriteString("-------------\n")
|
|
|
|
preCall := ""
|
|
if frontTrunc {
|
|
preCall = console.Colorize("metrics-error", "↑ ")
|
|
}
|
|
|
|
t := []string{
|
|
preCall + console.Colorize("metrics-top-title", "Call"),
|
|
console.Colorize("metrics-top-title", "Count"),
|
|
console.Colorize("metrics-top-title", "RPM"),
|
|
console.Colorize("metrics-top-title", "Avg Time"),
|
|
console.Colorize("metrics-top-title", "Min Time"),
|
|
console.Colorize("metrics-top-title", "Max Time"),
|
|
}
|
|
if hasTTFB {
|
|
t = append(t,
|
|
console.Colorize("metrics-top-title", "Avg TTFB"),
|
|
console.Colorize("metrics-top-title", "Max TTFB"),
|
|
)
|
|
}
|
|
t = append(t,
|
|
console.Colorize("metrics-top-title", "Avg Size"),
|
|
console.Colorize("metrics-top-title", "Rate /min"),
|
|
console.Colorize("metrics-top-title", "Errors"),
|
|
)
|
|
|
|
table.Append(t)
|
|
|
|
for i, v := range entries {
|
|
if v.Count <= 0 {
|
|
continue
|
|
}
|
|
errs := "0"
|
|
if v.Errors > 0 {
|
|
errs = console.Colorize("metrics-error", strconv.Itoa(v.Errors))
|
|
}
|
|
avg := v.Duration / time.Duration(v.Count)
|
|
avgTTFB := v.TTFB / time.Duration(v.Count)
|
|
avgColor := "metrics-dur"
|
|
if avg > 10*time.Second {
|
|
avgColor = "metrics-dur-high"
|
|
} else if avg > 2*time.Second {
|
|
avgColor = "metrics-dur-med"
|
|
}
|
|
|
|
minColor := "metrics-dur"
|
|
if v.MinDur > 10*time.Second {
|
|
minColor = "metrics-dur-high"
|
|
} else if v.MinDur > 2*time.Second {
|
|
minColor = "metrics-dur-med"
|
|
}
|
|
|
|
maxColor := "metrics-dur"
|
|
if v.MaxDur > 10*time.Second {
|
|
maxColor = "metrics-dur-high"
|
|
} else if v.MaxDur > time.Second {
|
|
maxColor = "metrics-dur-med"
|
|
}
|
|
|
|
sz := "-"
|
|
rate := "-"
|
|
if v.Size > 0 && v.Count > 0 {
|
|
sz = ibytesShort(uint64(v.Size) / uint64(v.Count))
|
|
rate = ibytesShort(uint64(float64(v.Size) / dur.Minutes()))
|
|
}
|
|
if v.CallStatsCount > 0 {
|
|
var s, r []string
|
|
if v.CallStats.Rx > 0 {
|
|
s = append(s, fmt.Sprintf("↑%s", ibytesShort(uint64(v.CallStats.Rx/v.CallStatsCount))))
|
|
r = append(r, fmt.Sprintf("↑%s", ibytesShort(uint64(float64(v.CallStats.Rx)/dur.Minutes()))))
|
|
}
|
|
if v.CallStats.Tx > 0 {
|
|
s = append(s, fmt.Sprintf("↓%s", ibytesShort(uint64(v.CallStats.Tx/v.CallStatsCount))))
|
|
r = append(r, fmt.Sprintf("↓%s", ibytesShort(uint64(float64(v.CallStats.Tx)/dur.Minutes()))))
|
|
}
|
|
if len(s)+len(r) > 0 {
|
|
sz = strings.Join(s, " ")
|
|
}
|
|
if len(r) > 0 {
|
|
rate = strings.Join(r, " ")
|
|
}
|
|
}
|
|
if sz != "-" {
|
|
sz = console.Colorize("metrics-size", sz)
|
|
rate = console.Colorize("metrics-size", rate)
|
|
}
|
|
|
|
preCall = ""
|
|
if endTrunc && i == len(entries)-1 {
|
|
preCall = console.Colorize("metrics-error", "↓ ")
|
|
}
|
|
|
|
t := []string{
|
|
preCall + console.Colorize("metrics-title", metricsTitle(v.Name)),
|
|
console.Colorize("metrics-number", fmt.Sprintf("%d ", v.Count)) +
|
|
console.Colorize("metrics-number-secondary", fmt.Sprintf("(%0.1f%%)", float64(v.Count)/float64(totalCnt)*100)),
|
|
console.Colorize("metrics-number", fmt.Sprintf("%0.1f", float64(v.Count)/dur.Minutes())),
|
|
console.Colorize(avgColor, fmt.Sprintf("%v", roundDur(avg))),
|
|
console.Colorize(minColor, roundDur(v.MinDur)),
|
|
console.Colorize(maxColor, roundDur(v.MaxDur)),
|
|
}
|
|
if hasTTFB {
|
|
if v.TTFB > 0 {
|
|
t = append(t,
|
|
console.Colorize(avgColor, fmt.Sprintf("%v", roundDur(avgTTFB))),
|
|
console.Colorize(maxColor, roundDur(v.MaxTTFB)))
|
|
} else {
|
|
t = append(t, "-", "-")
|
|
}
|
|
}
|
|
t = append(t, sz, rate, errs)
|
|
table.Append(t)
|
|
}
|
|
|
|
table.Render()
|
|
if globalTermWidth <= 10 {
|
|
return s.String()
|
|
}
|
|
w := globalTermWidth
|
|
if nw, _, e := term.GetSize(int(os.Stdout.Fd())); e == nil {
|
|
w = nw
|
|
}
|
|
split := strings.Split(s.String(), "\n")
|
|
for i, line := range split {
|
|
split[i] = truncate.StringWithTail(line, uint(w), "»")
|
|
}
|
|
return strings.Join(split, "\n")
|
|
}
|
|
|
|
// ibytesShort returns a short un-padded version of the value from humanize.IBytes.
|
|
func ibytesShort(v uint64) string {
|
|
return strings.ReplaceAll(strings.TrimSuffix(humanize.IBytes(v), "iB"), " ", "")
|
|
}
|
|
|
|
// roundDur will round the duration to a nice, printable number, with "reasonable" precision.
|
|
func roundDur(d time.Duration) time.Duration {
|
|
if d > time.Minute {
|
|
return d.Round(time.Second)
|
|
}
|
|
if d > time.Second {
|
|
return d.Round(time.Millisecond)
|
|
}
|
|
if d > time.Millisecond {
|
|
return d.Round(time.Millisecond / 10)
|
|
}
|
|
return d.Round(time.Microsecond)
|
|
}
|
|
|
|
func initTraceStatsUI(allFlag bool, maxEntries int, traces <-chan madmin.ServiceTraceInfo) *traceStatsUI {
|
|
meter := spinner.New()
|
|
meter.Spinner = spinner.Meter
|
|
meter.Style = lipgloss.NewStyle().Foreground(lipgloss.Color("205"))
|
|
// Use half the default fps to reduce flickering
|
|
meter.Spinner.FPS = time.Second / 3
|
|
console.SetColor("metrics-duration", color.New(color.FgWhite))
|
|
console.SetColor("metrics-size", color.New(color.FgGreen))
|
|
console.SetColor("metrics-dur", color.New(color.FgGreen))
|
|
console.SetColor("metrics-dur-med", color.New(color.FgYellow))
|
|
console.SetColor("metrics-dur-high", color.New(color.FgRed))
|
|
console.SetColor("metrics-error", color.New(color.FgYellow))
|
|
console.SetColor("metrics-title", color.New(color.FgCyan))
|
|
console.SetColor("metrics-top-title", color.New(color.FgHiCyan))
|
|
console.SetColor("metrics-number", color.New(color.FgWhite))
|
|
console.SetColor("metrics-number-secondary", color.New(color.FgBlue))
|
|
console.SetColor("metrics-zero", color.New(color.FgWhite))
|
|
stats := &statTrace{Calls: make(map[string]statItem, 20)}
|
|
go func() {
|
|
for t := range traces {
|
|
stats.add(t)
|
|
}
|
|
}()
|
|
return &traceStatsUI{
|
|
started: time.Now(),
|
|
meter: meter,
|
|
maxEntries: maxEntries,
|
|
current: stats,
|
|
allFlag: allFlag,
|
|
}
|
|
}
|