levels_http.go

package logging

import (
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"sort"
)

// maxLevelsRequestSize limits the PUT request body of LevelsHandler.
const maxLevelsRequestSize = 4 << 10

// LevelsState is the response of LevelsHandler: the global level and the effective level of every known
// named logger, which is a logger created by name or configured in Config.CustomLevels.
type LevelsState struct {
	Level   string            `json:"level"`
	Loggers map[string]string `json:"loggers"`
}

// LevelsRequest is the PUT request body of LevelsHandler.
//
//	{"level": "debug"}                   set the global level
//	{"logger": "db", "level": "debug"}   set the level of the named loggers
//	{"logger": "db", "reset": true}      restore the configured level of the named loggers
type LevelsRequest struct {
	Logger string `json:"logger,omitempty"`
	Level  string `json:"level,omitempty"`
	Reset  bool   `json:"reset,omitempty"`
}

// levels returns the global level and effective levels of the known named loggers.
func (st *state) levels() (Level, map[string]Level) {
	names := make(map[string]struct{}, len(st.config.CustomLevels))
	for name := range st.config.CustomLevels {
		names[name] = struct{}{}
	}

	st.mu.Lock()
	for name := range st.named {
		names[name] = struct{}{}
	}
	st.mu.Unlock()

	global := st.global.load()
	res := make(map[string]Level, len(names))

	for name := range names {
		if level := st.namedVar(name).load(); level != levelUnset {
			res[name] = level
		} else {
			res[name] = global
		}
	}

	return global, res
}

// LevelsHandler returns http.Handler to view and change logging levels of the active backend at run time.
// It follows Init: every request is served using the backend active at that moment.
//
//	GET  returns LevelsState as JSON
//	PUT  takes LevelsRequest as JSON, applies it and returns the new LevelsState
//
// Levels are named the way ParseLevel takes them. Any other method gets 405, malformed or invalid request gets 400.
//
// SECURITY: the handler is disabled by default and answers 404 until Config.LevelsEndpoint is set
// (levelsEndpoint: true, WithLevelsEndpoint). It has no authentication: anyone able to reach an enabled one
// may make the service log every detail or hide its errors. Mount it on an administrative listener
// closed from the outside.
func LevelsHandler() http.Handler {
	return levelsHandler(activeBackend)
}

// LevelsHandler returns http.Handler to view and change logging levels of the backend, see LevelsHandler.
func (backend *Backend) LevelsHandler() http.Handler {
	return levelsHandler(func() *Backend { return backend })
}

type levelsHandlerFunc func() *Backend

func levelsHandler(get levelsHandlerFunc) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		backend := get()

		if !backend.state().config.LevelsEndpoint {
			http.NotFound(w, r) // do not tell the endpoint exists

			return
		}

		switch r.Method {
		case http.MethodGet:
		case http.MethodPut:
			if err := applyLevelsRequest(backend, w, r); err != nil {
				writeLevelsError(w, http.StatusBadRequest, err)

				return
			}
		default:
			w.Header().Set("Allow", "GET, PUT")
			writeLevelsError(w, http.StatusMethodNotAllowed, fmt.Errorf("method %s not allowed", r.Method))

			return
		}

		writeLevelsState(w, backend)
	})
}

func applyLevelsRequest(backend *Backend, w http.ResponseWriter, r *http.Request) error {
	var req LevelsRequest

	decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, maxLevelsRequestSize))
	decoder.DisallowUnknownFields()

	if err := decoder.Decode(&req); err != nil {
		return fmt.Errorf("invalid request: %w", err)
	}

	if req.Reset {
		if req.Logger == "" || req.Level != "" {
			return errors.New("reset takes a logger name and no level")
		}

		backend.ResetNamedLevel(req.Logger)

		return nil
	}

	level, err := ParseLevel(req.Level)
	if err != nil {
		return err
	}

	if req.Logger == "" {
		return backend.SetLevel(level)
	}

	return backend.SetNamedLevel(req.Logger, level)
}

func writeLevelsState(w http.ResponseWriter, backend *Backend) {
	global, named := backend.state().levels()
	res := LevelsState{Level: global.String(), Loggers: make(map[string]string, len(named))}

	names := make([]string, 0, len(named))
	for name := range named {
		names = append(names, name)
	}

	sort.Strings(names) // encoding/json sorts map keys anyway, keep the order explicit for readers

	for _, name := range names {
		res.Loggers[name] = named[name].String()
	}

	writeLevelsJSON(w, http.StatusOK, res)
}

func writeLevelsError(w http.ResponseWriter, status int, err error) {
	writeLevelsJSON(w, status, map[string]string{"error": err.Error()})
}

func writeLevelsJSON(w http.ResponseWriter, status int, value any) {
	w.Header().Set("Content-Type", "application/json")
	w.WriteHeader(status)
	_ = json.NewEncoder(w).Encode(value)
}