debug.go

package ph

import (
	"fmt"
	"io"
	"os"
	"strings"

	"github.com/prometheus/client_golang/prometheus"
	ipc "github.com/prometheus/client_model/go"
)

// DebugGather is function to get all metrics from gatherer, useful for debugging
func DebugGather(gatherer prometheus.Gatherer) {
	mf, err := gatherer.Gather()
	if err != nil {
		panic(err)
	}
	pp := newDefaultDebugPrinter(os.Stdout).
		setCounter(1).
		printf("Gathered %d metrics", len(mf)).
		blankLine()

	for _, m := range mf {
		pp.
			printfCounted("Gathered metric: %s", m.GetName()).
			indent().
			printf("Help: %s", m.GetName()).
			printf("Type: %s", m.GetType()).
			printf("Values: %s", func() any {
				return m.GetMetric()
			}()).
			dedent().
			separator()
	}

	return
}

// DebugMetric is a struct to hold metric information for debugging purposes
type DebugMetric struct {
	Name   string
	Help   string
	Type   ipc.MetricType
	Values []*ipc.Metric
}

func newDebugPrinter(writer io.Writer, prefix string) *debugPrinter {
	return &debugPrinter{
		prefix:   prefix,
		writer:   writer,
		counters: []uint{0},
	}
}

func newDefaultDebugPrinter(writer io.Writer) *debugPrinter {
	return newDebugPrinter(writer, "  ")
}

// dead simple writer
type debugPrinter struct {
	prefix   string
	level    uint
	writer   io.Writer
	counters []uint
}

func (p *debugPrinter) dedent() *debugPrinter {
	return p.dedentWith(1)
}
func (p *debugPrinter) dedentWith(count uint) *debugPrinter {
	result := p.level - count
	if result <= 0 {
		p.level = 0
		p.counters = p.counters[:1]
	} else {
		p.level -= result
		p.counters = p.counters[len(p.counters)-int(result):]
	}
	return p
}

func (p *debugPrinter) indent() *debugPrinter {
	return p.indentWith(1)
}

func (p *debugPrinter) indentWith(count uint) *debugPrinter {
	p.level += count
	for i := uint(0); i < count; i++ {
		p.counters = append(p.counters, 0)
	}
	return p
}

func (p *debugPrinter) printf(format string, args ...any) *debugPrinter {
	p.writeln(p.currentIndent() + fmt.Sprintf(format, args...))
	return p
}

func (p *debugPrinter) printfCounted(format string, args ...any) *debugPrinter {
	builder := strings.Builder{}
	builder.WriteString(p.currentIndent())
	builder.WriteString(fmt.Sprintf("[%d] ", p.counters[len(p.counters)-1]))
	builder.WriteString(fmt.Sprintf(format, args...))

	p.counters[len(p.counters)-1]++

	p.writeln(p.currentIndent() + builder.String())
	return p
}

func (p *debugPrinter) currentIndent() string {
	builder := strings.Builder{}
	for i := uint(0); i < p.level; i++ {
		builder.WriteString(p.prefix)
	}
	return builder.String()
}

func (p *debugPrinter) blankLine() *debugPrinter {
	p.writeln("")
	return p
}

func (p *debugPrinter) separator() *debugPrinter {
	return p.separatorSized(80)

}
func (p *debugPrinter) separatorSized(size uint) *debugPrinter {
	p.separatorSizedWithCharacter(size, '-')
	return p
}
func (p *debugPrinter) separatorSizedWithCharacter(size uint, character rune) *debugPrinter {
	builder := strings.Builder{}
	builder.Grow(int(size))
	for i := uint(0); i < size; i++ {
		builder.WriteString("-")
	}

	p.writeln(p.currentIndent() + builder.String())
	return p
}
func (p *debugPrinter) write(what string) *debugPrinter {
	_, _ = fmt.Fprint(p.writer, what)
	return p

}
func (p *debugPrinter) writeln(what string) *debugPrinter {
	_, _ = fmt.Fprintln(p.writer, what)
	return p

}
func (p *debugPrinter) setCounter(counter uint) *debugPrinter {
	p.counters[len(p.counters)-1] = counter
	return p
}
func (p *debugPrinter) incrCounter() *debugPrinter {
	p.counters[len(p.counters)-1]++
	return p
}