chore: release 0.29.0.rc0 (#1600)

pkg/log/eventlog/eventlog.go

@@ -1,21 +1,14 @@
 //go:build windows
-// +build windows
 
 // Package eventlog provides a Logger that writes to Windows Event Log.
 package eventlog
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"io"
-	"sync"
-	"syscall"
 
-	"github.com/go-kit/log"
-	"github.com/go-kit/log/level"
 	"golang.org/x/sys/windows"
-	goeventlog "golang.org/x/sys/windows/svc/eventlog"
 )
 
 const (
@@ -25,109 +18,36 @@ const (
 	neLogOemCode = uint32(3299)
 )
 
-type Priority struct {
-	etype int
+// Interface guard.
+var _ io.Writer = (*Writer)(nil)
+
+type Writer struct {
+	handle windows.Handle
 }
 
-// NewEventLogLogger returns a new Logger which writes to Windows EventLog in event log format.
-// The body of the log message is the formatted output from the Logger returned
-// by newLogger.
-func NewEventLogLogger(w *goeventlog.Log, newLogger func(io.Writer) log.Logger) log.Logger {
-	l := &eventlogLogger{
-		w:                w,
-		newLogger:        newLogger,
-		prioritySelector: defaultPrioritySelector,
-		bufPool: sync.Pool{New: func() interface{} {
-			return &loggerBuf{}
-		}},
+// NewEventLogWriter returns a new Writer which writes to Windows EventLog.
+func NewEventLogWriter(handle windows.Handle) *Writer {
+	return &Writer{handle: handle}
+}
+
+func (w *Writer) Write(p []byte) (int, error) {
+	var eType uint16
+
+	switch {
+	case bytes.Contains(p, []byte(" level=error")) || bytes.Contains(p, []byte(`"level":"error"`)):
+		eType = windows.EVENTLOG_ERROR_TYPE
+	case bytes.Contains(p, []byte(" level=warn")) || bytes.Contains(p, []byte(`"level":"warn"`)):
+		eType = windows.EVENTLOG_WARNING_TYPE
+	default:
+		eType = windows.EVENTLOG_INFORMATION_TYPE
 	}
 
-	return l
-}
-
-type eventlogLogger struct {
-	w                *goeventlog.Log
-	newLogger        func(io.Writer) log.Logger
-	prioritySelector PrioritySelector
-	bufPool          sync.Pool
-}
-
-func (l *eventlogLogger) Log(keyvals ...interface{}) error {
-	priority := l.prioritySelector(keyvals...)
-
-	lb, err := l.getLoggerBuf()
+	msg, err := windows.UTF16PtrFromString(string(p))
 	if err != nil {
-		return err
-	}
-
-	defer l.putLoggerBuf(lb)
-	if err := lb.logger.Log(keyvals...); err != nil {
-		return err
-	}
-
-	// golang.org/x/sys/windows/svc/eventlog does not provide func which allows to send more than one string.
-	// See: https://github.com/golang/go/issues/59780
-
-	msg, err := syscall.UTF16PtrFromString(lb.buf.String())
-	if err != nil {
-		return fmt.Errorf("error convert string to UTF-16: %w", err)
+		return 0, fmt.Errorf("error convert string to UTF-16: %w", err)
 	}
 
 	ss := []*uint16{msg, nil, nil, nil, nil, nil, nil, nil, nil}
-	return windows.ReportEvent(l.w.Handle, uint16(priority.etype), 0, neLogOemCode, 0, 9, 0, &ss[0], nil)
-}
-
-type loggerBuf struct {
-	buf    *bytes.Buffer
-	logger log.Logger
-}
-
-func (l *eventlogLogger) getLoggerBuf() (*loggerBuf, error) {
-	lb, ok := l.bufPool.Get().(*loggerBuf)
-	if !ok {
-		return nil, errors.New("failed to get loggerBuf from pool")
-	}
-
-	if lb.buf == nil {
-		lb.buf = &bytes.Buffer{}
-		lb.logger = l.newLogger(lb.buf)
-	} else {
-		lb.buf.Reset()
-	}
-	return lb, nil
-}
-
-func (l *eventlogLogger) putLoggerBuf(lb *loggerBuf) {
-	l.bufPool.Put(lb)
-}
-
-// PrioritySelector inspects the list of keyvals and selects an eventlog priority.
-type PrioritySelector func(keyvals ...interface{}) Priority
-
-// defaultPrioritySelector convert a kit/log level into a Windows Eventlog level.
-func defaultPrioritySelector(keyvals ...interface{}) Priority {
-	l := len(keyvals)
-
-	eType := windows.EVENTLOG_SUCCESS
-
-	for i := 0; i < l; i += 2 {
-		if keyvals[i] == level.Key() {
-			var val interface{}
-			if i+1 < l {
-				val = keyvals[i+1]
-			}
-			if v, ok := val.(level.Value); ok {
-				switch v {
-				case level.ErrorValue():
-					eType = windows.EVENTLOG_ERROR_TYPE
-				case level.WarnValue():
-					eType = windows.EVENTLOG_WARNING_TYPE
-				case level.InfoValue():
-					eType = windows.EVENTLOG_INFORMATION_TYPE
-				}
-			}
-		}
-	}
-
-	return Priority{etype: eType}
+
+	return len(p), windows.ReportEvent(w.handle, eType, 0, neLogOemCode, 0, 9, 0, &ss[0], nil)
 }

pkg/log/flag/flag.go

@@ -16,8 +16,8 @@ package flag
 import (
 	"github.com/alecthomas/kingpin/v2"
 	"github.com/prometheus-community/windows_exporter/pkg/log"
-	"github.com/prometheus/common/promlog"
-	promlogflag "github.com/prometheus/common/promlog/flag"
+	"github.com/prometheus/common/promslog"
+	"github.com/prometheus/common/promslog/flag"
 )
 
 // FileFlagName is the canonical flag name to configure the log file.
@@ -29,15 +29,9 @@ const FileFlagHelp = "Output file of log messages. One of [stdout, stderr, event
 // AddFlags adds the flags used by this package to the Kingpin application.
 // To use the default Kingpin application, call AddFlags(kingpin.CommandLine).
 func AddFlags(a *kingpin.Application, config *log.Config) {
-	config.Level = &promlog.AllowedLevel{}
-	a.Flag(promlogflag.LevelFlagName, promlogflag.LevelFlagHelp).
-		Default("info").SetValue(config.Level)
+	config.Config = new(promslog.Config)
+	flag.AddFlags(a, config.Config)
 
 	config.File = &log.AllowedFile{}
-	a.Flag(FileFlagName, FileFlagHelp).
-		Default("stderr").SetValue(config.File)
-
-	config.Format = &promlog.AllowedFormat{}
-	a.Flag(promlogflag.FormatFlagName, promlogflag.FormatFlagHelp).
-		Default("logfmt").SetValue(config.Format)
+	a.Flag(FileFlagName, FileFlagHelp).Default("stderr").SetValue(config.File)
 }

pkg/log/logger.go

@@ -4,12 +4,12 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"log/slog"
 	"os"
 
-	"github.com/go-kit/log"
 	"github.com/prometheus-community/windows_exporter/pkg/log/eventlog"
-	"github.com/prometheus/common/promlog"
-	goeventlog "golang.org/x/sys/windows/svc/eventlog"
+	"github.com/prometheus/common/promslog"
+	"golang.org/x/sys/windows"
 )
 
 // AllowedFile is a settable identifier for the output file that the logger can have.
@@ -25,71 +25,45 @@ func (f *AllowedFile) String() string {
 // Set updates the value of the allowed format.
 func (f *AllowedFile) Set(s string) error {
 	f.s = s
+
 	switch s {
 	case "stdout":
 		f.w = os.Stdout
 	case "stderr":
 		f.w = os.Stderr
 	case "eventlog":
-		f.w = nil
+		handle, err := windows.RegisterEventSource(nil, windows.StringToUTF16Ptr("windows_exporter"))
+		if err != nil {
+			return fmt.Errorf("failed to open event log: %w", err)
+		}
+
+		f.w = eventlog.NewEventLogWriter(handle)
 	default:
 		file, err := os.OpenFile(s, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0o200)
 		if err != nil {
-			return err
+			return fmt.Errorf("failed to open log file: %w", err)
 		}
+
 		f.w = file
 	}
+
 	return nil
 }
 
 // Config is a struct containing configurable settings for the logger.
 type Config struct {
-	promlog.Config
+	*promslog.Config
 
 	File *AllowedFile
 }
 
-func New(config *Config) (log.Logger, error) {
+func New(config *Config) (*slog.Logger, error) {
 	if config.File == nil {
 		return nil, errors.New("log file undefined")
 	}
 
-	if config.Format == nil {
-		return nil, errors.New("log format undefined")
-	}
+	config.Config.Writer = config.File.w
+	config.Config.Style = promslog.GoKitStyle
 
-	var (
-		l          log.Logger
-		loggerFunc func(io.Writer) log.Logger
-	)
-
-	switch config.Format.String() {
-	case "json":
-		loggerFunc = log.NewJSONLogger
-	case "logfmt":
-		loggerFunc = log.NewLogfmtLogger
-	default:
-		return nil, fmt.Errorf("unsupported log.format %q", config.Format.String())
-	}
-
-	switch {
-	case config.File.s == "eventlog":
-
-		w, err := goeventlog.Open("windows_exporter")
-		if err != nil {
-			return nil, err
-		}
-		l = eventlog.NewEventLogLogger(w, loggerFunc)
-	case config.File.w == nil:
-		panic("logger: file writer is nil")
-	default:
-		l = loggerFunc(log.NewSyncWriter(config.File.w))
-	}
-
-	promlogConfig := promlog.Config{
-		Format: config.Format,
-		Level:  config.Level,
-	}
-
-	return promlog.NewWithLogger(l, &promlogConfig), nil
+	return promslog.New(config.Config), nil
 }