diff --git a/envbuilder.go b/envbuilder.go index 9360fe22..7f3c983a 100644 --- a/envbuilder.go +++ b/envbuilder.go @@ -278,9 +278,13 @@ func Run(ctx context.Context, opts options.Options) error { } } - HijackLogrus(func(entry *logrus.Entry) { + lvl := log.LevelInfo + if opts.Verbose { + lvl = log.LevelDebug + } + log.HijackLogrus(lvl, func(entry *logrus.Entry) { for _, line := range strings.Split(entry.Message, "\r") { - opts.Logger(log.LevelInfo, "#%d: %s", stageNumber, color.HiBlackString(line)) + opts.Logger(log.FromLogrus(entry.Level), "#%d: %s", stageNumber, color.HiBlackString(line)) } }) @@ -1050,9 +1054,13 @@ func RunCacheProbe(ctx context.Context, opts options.Options) (v1.Image, error) return nil, fmt.Errorf("no Dockerfile or devcontainer.json found") } - HijackLogrus(func(entry *logrus.Entry) { + lvl := log.LevelInfo + if opts.Verbose { + lvl = log.LevelDebug + } + log.HijackLogrus(lvl, func(entry *logrus.Entry) { for _, line := range strings.Split(entry.Message, "\r") { - opts.Logger(log.LevelInfo, "#%d: %s", stageNumber, color.HiBlackString(line)) + opts.Logger(log.FromLogrus(entry.Level), "#%d: %s", stageNumber, color.HiBlackString(line)) } }) diff --git a/log.go b/log.go deleted file mode 100644 index ad476c1d..00000000 --- a/log.go +++ /dev/null @@ -1,28 +0,0 @@ -package envbuilder - -import ( - "io" - - "github.com/sirupsen/logrus" -) - -// HijackLogrus hijacks the logrus logger and calls the callback for each log entry. -// This is an abuse of logrus, the package that Kaniko uses, but it exposes -// no other way to obtain the log entries. -func HijackLogrus(callback func(entry *logrus.Entry)) { - logrus.StandardLogger().SetOutput(io.Discard) - logrus.StandardLogger().SetFormatter(&logrusFormatter{ - callback: callback, - empty: []byte{}, - }) -} - -type logrusFormatter struct { - callback func(entry *logrus.Entry) - empty []byte -} - -func (f *logrusFormatter) Format(entry *logrus.Entry) ([]byte, error) { - f.callback(entry) - return f.empty, nil -} diff --git a/log/logrus.go b/log/logrus.go new file mode 100644 index 00000000..3d70b114 --- /dev/null +++ b/log/logrus.go @@ -0,0 +1,61 @@ +package log + +import ( + "io" + + "github.com/sirupsen/logrus" +) + +// HijackLogrus hijacks the logrus logger and calls the callback for each log entry. +// This is an abuse of logrus, the package that Kaniko uses, but it exposes +// no other way to obtain the log entries. +func HijackLogrus(lvl Level, callback func(entry *logrus.Entry)) { + logrus.StandardLogger().SetOutput(io.Discard) + logrus.StandardLogger().SetLevel(ToLogrus(lvl)) + logrus.StandardLogger().SetFormatter(&logrusFormatter{ + callback: callback, + empty: []byte{}, + }) +} + +type logrusFormatter struct { + callback func(entry *logrus.Entry) + empty []byte +} + +func (f *logrusFormatter) Format(entry *logrus.Entry) ([]byte, error) { + f.callback(entry) + return f.empty, nil +} + +func ToLogrus(lvl Level) logrus.Level { + switch lvl { + case LevelTrace: + return logrus.TraceLevel + case LevelDebug: + return logrus.DebugLevel + case LevelInfo: + return logrus.InfoLevel + case LevelWarn: + return logrus.WarnLevel + case LevelError: + return logrus.ErrorLevel + default: + return logrus.InfoLevel + } +} + +func FromLogrus(lvl logrus.Level) Level { + switch lvl { + case logrus.TraceLevel: + return LevelTrace + case logrus.DebugLevel: + return LevelDebug + case logrus.InfoLevel: + return LevelInfo + case logrus.WarnLevel: + return LevelWarn + default: // Error, Fatal, Panic + return LevelError + } +} diff --git a/log/logrus_test.go b/log/logrus_test.go new file mode 100644 index 00000000..7b606696 --- /dev/null +++ b/log/logrus_test.go @@ -0,0 +1,110 @@ +package log_test + +import ( + "context" + "testing" + "time" + + "github.com/coder/envbuilder/log" + "github.com/sirupsen/logrus" + "github.com/stretchr/testify/require" +) + +func TestHijackLogrus_Info(t *testing.T) { + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + t.Cleanup(cancel) + messages := make(chan *logrus.Entry) + + logf := func(entry *logrus.Entry) { + t.Logf("got msg level: %s msg: %q", entry.Level, entry.Message) + messages <- entry + } + + log.HijackLogrus(log.LevelInfo, logf) + + done := make(chan struct{}) + go func() { + defer close(done) + // The following should be filtered out. + logrus.Trace("Tracing!") + logrus.Debug("Debugging!") + // We should receive the below. + logrus.Info("Testing!") + logrus.Warn("Warning!") + logrus.Error("Error!") + }() + + require.Equal(t, "Testing!", rcvCtx(ctx, t, messages).Message) + require.Equal(t, "Warning!", rcvCtx(ctx, t, messages).Message) + require.Equal(t, "Error!", rcvCtx(ctx, t, messages).Message) + <-done +} + +func TestHijackLogrus_Debug(t *testing.T) { + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + t.Cleanup(cancel) + messages := make(chan *logrus.Entry) + + logf := func(entry *logrus.Entry) { + t.Logf("got msg level: %s msg: %q", entry.Level, entry.Message) + messages <- entry + } + + log.HijackLogrus(log.LevelDebug, logf) + + done := make(chan struct{}) + go func() { + defer close(done) + // The following should be filtered out. + logrus.Trace("Tracing!") + // We should receive the below. + logrus.Debug("Debugging!") + logrus.Info("Testing!") + logrus.Warn("Warning!") + logrus.Error("Error!") + }() + + require.Equal(t, "Debugging!", rcvCtx(ctx, t, messages).Message) + require.Equal(t, "Testing!", rcvCtx(ctx, t, messages).Message) + require.Equal(t, "Warning!", rcvCtx(ctx, t, messages).Message) + require.Equal(t, "Error!", rcvCtx(ctx, t, messages).Message) + <-done +} + +func TestHijackLogrus_Error(t *testing.T) { + ctx, cancel := context.WithTimeout(context.Background(), time.Second) + t.Cleanup(cancel) + messages := make(chan *logrus.Entry) + + logf := func(entry *logrus.Entry) { + t.Logf("got msg level: %s msg: %q", entry.Level, entry.Message) + messages <- entry + } + + log.HijackLogrus(log.LevelError, logf) + + done := make(chan struct{}) + go func() { + defer close(done) + // The following should be filtered out. + logrus.Trace("Tracing!") + logrus.Debug("Debugging!") + logrus.Info("Testing!") + logrus.Warn("Warning!") + // We should receive the below. + logrus.Error("Error!") + }() + + require.Equal(t, "Error!", rcvCtx(ctx, t, messages).Message) + <-done +} + +func rcvCtx[T any](ctx context.Context, t *testing.T, ch <-chan T) (v T) { + t.Helper() + select { + case <-ctx.Done(): + t.Fatal("timeout") + case v = <-ch: + } + return v +} diff --git a/log_test.go b/log_test.go deleted file mode 100644 index 63d5e6cd..00000000 --- a/log_test.go +++ /dev/null @@ -1,19 +0,0 @@ -package envbuilder_test - -import ( - "testing" - - "github.com/coder/envbuilder" - "github.com/sirupsen/logrus" - "github.com/stretchr/testify/require" -) - -func TestHijackLogrus(t *testing.T) { - messages := make(chan *logrus.Entry, 1) - envbuilder.HijackLogrus(func(entry *logrus.Entry) { - messages <- entry - }) - logrus.Infof("Testing!") - message := <-messages - require.Equal(t, "Testing!", message.Message) -}