standard log output and context handling

[jaypipes]

Continues the work from #417 in two important ways. First, this finalizes the move towards passing only a context.Context argument to the inner InfoXXX.load() methods instead of the old pkg/option.Options struct. Using a context.Context is more modern Go idiomatic and aligned with modern Go packages like log/slog. Each InfoXXX.load() method ensures a context.Context is created to store various options and context that is passed between modules in ghw. The function signature for the main module constructors like pkg/cpu.CPU() or pkg/block.Block() have all been changed from this:

func CPU(opt ...option.Option) (*Info, error)

to

func CPU(args ...any) (*Info, error)

which is a backwards compatible API change. We then examine each of the args arguments and set various keys on the context.Context. The context.Context is examined by other modules like pkg/linuxpath or pkg/linuxdmi instead of the prior pkg/option.Options struct.

The second major part of this patch is the addition of log/output formatting to use log/slog and log/slog.Handler overrides to control the output of warning and debug log lines.

The default log output in ghw only writes WARN-level messages to stderr in a simple WARN: <msg> log record format:

$ ghwc baseboard
WARN:  Unable to read board_serial: open /sys/class/dmi/id/board_serial: permission denied
baseboard vendor=System76 version=thelio-mira-b4.1 product=Thelio Mira

You can control a number of log output options programmatically or by using environs variables.

To change the log level ghw uses, set the GHW_LOG_LEVEL environs variable:

$ GHW_LOG_LEVEL=debug ghwc baseboard
DEBUG: reading from "/sys/class/dmi/id/board_asset_tag"
DEBUG: reading from "/sys/class/dmi/id/board_serial"
WARN:  Unable to read board_serial: open /sys/class/dmi/id/board_serial: permission denied
DEBUG: reading from "/sys/class/dmi/id/board_vendor"
DEBUG: reading from "/sys/class/dmi/id/board_version"
DEBUG: reading from "/sys/class/dmi/id/board_name"
baseboard vendor=System76 version=thelio-mira-b4.1 product=Thelio Mira

Changing GHW_LOG_LEVEL to error has the same effect of setting GHW_DISABLE_WARNINGS:

$ GHW_LOG_LEVEL=error ghwc baseboard
baseboard vendor=System76 version=thelio-mira-b4.1 product=Thelio Mira

You can change the log level programmatically using the WithLogLevel modifier:

import (
    "log/slog"

	"github.com/jaypipes/ghw"
)

bb, err := ghw.Baseboard(ghw.WithLogLevel(slog.LevelDebug))

To use the logfmt standard log output format, set the GHW_LOG_LOGFMT envrions variable:

$ GHW_LOG_LOGFMT=1 ghwc baseboard
time=2025-12-28T07:31:08.614-05:00 level=WARN msg="Unable to read board_serial: open /sys/class/dmi/id/board_serial: permission denied"
baseboard vendor=System76 version=thelio-mira-b4.1 product=Thelio Mira

You can tell ghw to use logfmt standard output formatting using the WithLogLogfmt modifier:

import (
    "log/slog"

	"github.com/jaypipes/ghw"
)

bb, err := ghw.Baseboard(ghw.WithLogLogfmt())

You can now programmatically override the logger that ghw uses with the WithLogger modifier. You pass in an instance of slog.Logger, like this example that shows how to use a simple logger with colored log output:

package main

import (
    "context"
    "encoding/json"
    "io"
    "log"
    "log/slog"

    "github.com/fatih/color"
    "github.com/jaypipes/ghw"
)

type PrettyHandlerOptions struct {
    SlogOpts slog.HandlerOptions
}

type PrettyHandler struct {
    slog.Handler
    l *log.Logger
}

func (h *PrettyHandler) Handle(ctx context.Context, r slog.Record) error {
    level := r.Level.String() + ":"

    switch r.Level {
    case slog.LevelDebug:
        level = color.MagentaString(level)
    case slog.LevelInfo:
        level = color.BlueString(level)
    case slog.LevelWarn:
        level = color.YellowString(level)
    case slog.LevelError:
        level = color.RedString(level)
    }

    fields := make(map[string]interface{}, r.NumAttrs())
    r.Attrs(func(a slog.Attr) bool {
        fields[a.Key] = a.Value.Any()

        return true
    })

    b, err := json.MarshalIndent(fields, "", "  ")
    if err != nil {
        return err
    }

    timeStr := r.Time.Format("[15:05:05.000]")
    msg := color.CyanString(r.Message)

    h.l.Println(timeStr, level, msg, color.WhiteString(string(b)))

    return nil
}

func NewPrettyHandler(
    out io.Writer,
    opts PrettyHandlerOptions,
) *PrettyHandler {
    h := &PrettyHandler{
        Handler: slog.NewJSONHandler(out, &opts.SlogOpts),
        l:       log.New(out, "", 0),
    }

    return h
}

func main() {
    opts := PrettyHandlerOptions{
        SlogOpts: slog.HandlerOptions{
            Level: slog.LevelDebug,
        },
    }
    handler := NewPrettyHandler(os.Stdout, opts)
    logger := slog.New(handler)
    bb, err := ghw.Baseboard(ghw.WithLogger(logger))
    if err != nil {
        logger.Error(err.String())
    }
    fmt.Println(bb)
}

[jaypipes]

@ffromani happy holidays, mate :) This patch addresses a couple of the comments you'd had on #417. let me know what you think!

[ffromani]

Thanks for the followup! will review shortly!

[ffromani]

Thanks @jaypipes ! this is another massive improvement.
I left comments inside for possible improvements, overall I'm largely in favor of this change.
The only somehow grey-ish area is the fact we are still changing the signature of public functions, belonging to sub-packages.
That made me think: perhaps we can refine our stance and ensure that only the top-level exported symbols (alias.go) are stable, and this could allow to save 90% of the pain from our users, and still allow us to evolve the codebase - and maybe tighten again the types again?

Perhaps we can explore this option?

[ffromani]

This is a bit puzzling because 3 lines above we instruct users to NOT use a WithXXX function

[ffromani]

nit: map[string]any (please do NOT resubmit just for this)

[ffromani]

in a followup PR we may want to try to add a test helper like kube did during the transition to contextual logger. I can play with this concept later on.

[ffromani]

I'm thinking if we can avoid the name clash with the stdlib. I don't have good suggestions here.

[ffromani]

do we want or need to export this? If exported, should it be ContextKey or just Key?
e.g.

ghwcontext.ContextKey

ghwcontext.Key

[ffromani]

this needs to be exported indeed, but maybe just Modifier ?

[ffromani]

(here and everywhere else). I'm just a little off by the fact we need to use variadic args and the any type. But it's a necessary evil (and the best/only option to keep backward compat). The code is massively better with this change, so I think this is the sweet spot. In the future we will tighten the function signatures again I reckon.

[ffromani]

minorish: does this belong in the context package? do we want or need to add a dedicated log package?
I don't have strong opinions either way but I think is worth raising the point.

[ffromani]

on hindsight, looking at this (and other) function callsites, I'm leaning towards adding a log package somehow. Or whatever better name we can find. WDYT?