taigrr/wails
1
0
Fork 0
mirror of https://github.com/taigrr/wails.git synced 2026-04-02 05:08:54 -07:00
Code Issues Packages Projects Releases Wiki Activity

Updated Logger interface

Browse Source
This commit is contained in:
Lea Anthony
2020-10-09 15:39:11 +11:00
parent 228285f693
commit 67861e4f70
5 changed files with 54 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
v2/internal/ffenestri/ffenestri_darwin.c
View File

@@ -185,21 +185,6 @@ void Debug(struct Application *app, const char *message, ... ) {
}
}
// // Debug works like sprintf but mutes if the global debug flag is true
// // Credit: https://stackoverflow.com/a/20639708
// void Debug(const char *message, ... ) {
// if ( debug ) {
// char *temp = concat("TRACE | Ffenestri (C) | ", message);
// message = concat(temp, "\n");
// free(temp);
// va_list args;
// va_start(args, message);
// vprintf(message, args);
// free((void*)message);
// va_end(args);
// }
// }
void TitlebarAppearsTransparent(struct Application* app) {
app->titlebarAppearsTransparent = 1;
}

17
v2/internal/logger/default_logger.go
View File

@@ -1,6 +1,7 @@
package logger
import (
"fmt"
"os"
"github.com/wailsapp/wails/v2/pkg/logger"
@@ -43,7 +44,7 @@ func (l *Logger) SetLogLevel(level uint8) {
// Writeln writes directly to the output with no log level
// Appends a carriage return to the message
func (l *Logger) Writeln(message string) error {
return l.output.Print(message + "\n")
return l.output.Print(message)
}
// Write writes directly to the output with no log level
@@ -60,7 +61,7 @@ func (l *Logger) Print(message string) error {
// Trace level logging. Works like Sprintf.
func (l *Logger) Trace(format string, args ...interface{}) error {
if l.logLevel <= TRACE {
return l.output.Trace(format, args...)
return l.output.Trace(fmt.Sprintf(format, args...))
}
return nil
}
@@ -69,14 +70,14 @@ func (l *Logger) Trace(format string, args ...interface{}) error {
// func (l *Logger) CustomTrace(name string) func(format string, args ...interface{}) {
// return func(format string, args ...interface{}) {
// format = name + " | " + format
// l.processLogMessage(format, args...)
// l.processLogMessage(fmt.Sprintf(format, args...))
// }
// }
// Debug level logging. Works like Sprintf.
func (l *Logger) Debug(format string, args ...interface{}) error {
if l.logLevel <= DEBUG {
return l.output.Debug(format, args...)
return l.output.Debug(fmt.Sprintf(format, args...))
}
return nil
}
@@ -84,7 +85,7 @@ func (l *Logger) Debug(format string, args ...interface{}) error {
// Info level logging. Works like Sprintf.
func (l *Logger) Info(format string, args ...interface{}) error {
if l.logLevel <= INFO {
return l.output.Info(format, args...)
return l.output.Info(fmt.Sprintf(format, args...))
}
return nil
}
@@ -92,7 +93,7 @@ func (l *Logger) Info(format string, args ...interface{}) error {
// Warning level logging. Works like Sprintf.
func (l *Logger) Warning(format string, args ...interface{}) error {
if l.logLevel <= WARNING {
return l.output.Warning(format, args...)
return l.output.Warning(fmt.Sprintf(format, args...))
}
return nil
}
@@ -100,14 +101,14 @@ func (l *Logger) Warning(format string, args ...interface{}) error {
// Error level logging. Works like Sprintf.
func (l *Logger) Error(format string, args ...interface{}) error {
if l.logLevel <= ERROR {
return l.output.Error(format, args...)
return l.output.Error(fmt.Sprintf(format, args...))
}
return nil
}
// Fatal level logging. Works like Sprintf.
func (l *Logger) Fatal(format string, args ...interface{}) {
err := l.output.Fatal(format, args...)
err := l.output.Fatal(fmt.Sprintf(format, args...))
// Not much we can do but print it out before exiting
if err != nil {
println(err.Error())

202
v2/internal/logger/logger_test.go
View File

@@ -1,202 +0,0 @@
package logger
import (
"bytes"
"io/ioutil"
"log"
"os"
"testing"
"github.com/matryer/is"
)
func TestByteBufferLogger(t *testing.T) {
is := is.New(t)
// Create new byte buffer logger
var buf bytes.Buffer
myLogger := New(&buf)
myLogger.SetLogLevel(TRACE)
tests := map[uint8]string{
TRACE: "TRACE | I am a message!\n",
DEBUG: "DEBUG | I am a message!\n",
WARNING: "WARN | I am a message!\n",
INFO: "INFO | I am a message!\n",
ERROR: "ERROR | I am a message!\n",
}
methods := map[uint8]func(string, ...interface{}) error{
TRACE: myLogger.Trace,
DEBUG: myLogger.Debug,
WARNING: myLogger.Warning,
INFO: myLogger.Info,
ERROR: myLogger.Error,
}
for level, expected := range tests {
buf.Reset()
method := methods[level]
// Write message
err := method("I am a message!")
if err != nil {
panic(err)
}
actual := buf.String()
is.Equal(actual, expected)
}
}
func TestCustomLogger(t *testing.T) {
is := is.New(t)
// Create new byte buffer logger
var buf bytes.Buffer
myLogger := New(&buf)
myLogger.SetLogLevel(TRACE)
customLogger := myLogger.CustomLogger("Test")
tests := map[uint8]string{
TRACE: "TRACE | Test | I am a message!\n",
DEBUG: "DEBUG | Test | I am a message!\n",
WARNING: "WARN | Test | I am a message!\n",
INFO: "INFO | Test | I am a message!\n",
ERROR: "ERROR | Test | I am a message!\n",
}
methods := map[uint8]func(string, ...interface{}) error{
TRACE: customLogger.Trace,
DEBUG: customLogger.Debug,
WARNING: customLogger.Warning,
INFO: customLogger.Info,
ERROR: customLogger.Error,
}
for level, expected := range tests {
buf.Reset()
method := methods[level]
// Write message
err := method("I am a message!")
if err != nil {
panic(err)
}
actual := buf.String()
is.Equal(actual, expected)
}
}
func TestWriteln(t *testing.T) {
is := is.New(t)
// Create new byte buffer logger
var buf bytes.Buffer
myLogger := New(&buf)
myLogger.SetLogLevel(DEBUG)
buf.Reset()
// Write message
err := myLogger.Writeln("I am a message!")
if err != nil {
panic(err)
}
actual := buf.String()
is.Equal(actual, "I am a message!\n")
buf.Reset()
// Write message
err = myLogger.Write("I am a message!")
if err != nil {
panic(err)
}
actual = buf.String()
is.Equal(actual, "I am a message!")
}
func TestLogLevel(t *testing.T) {
is := is.New(t)
// Create new byte buffer logger
var buf bytes.Buffer
myLogger := New(&buf)
myLogger.SetLogLevel(ERROR)
tests := map[uint8]string{
TRACE: "",
DEBUG: "",
WARNING: "",
INFO: "",
ERROR: "ERROR | I am a message!\n",
}
methods := map[uint8]func(string, ...interface{}) error{
TRACE: myLogger.Trace,
DEBUG: myLogger.Debug,
WARNING: myLogger.Warning,
INFO: myLogger.Info,
ERROR: myLogger.Error,
}
for level := range tests {
method := methods[level]
// Write message
err := method("I am a message!")
if err != nil {
panic(err)
}
}
actual := buf.String()
is.Equal(actual, "ERROR | I am a message!\n")
}
func TestFileLogger(t *testing.T) {
is := is.New(t)
// Create new byte buffer logger
file, err := ioutil.TempFile(".", "wailsv2test")
if err != nil {
log.Fatal(err)
}
defer os.Remove(file.Name())
myLogger := New(file)
myLogger.SetLogLevel(DEBUG)
// Write message
err = myLogger.Info("I am a message!")
if err != nil {
panic(err)
}
actual, err := ioutil.ReadFile(file.Name())
if err != nil {
panic(err)
}
is.Equal(string(actual), "INFO | I am a message!\n")
}

33
v2/pkg/logger/default.go
View File

@@ -1,12 +1,11 @@
package logger
import (
"fmt"
"os"
)
// DefaultLogger is a utlility to log messages to a number of destinations
type DefaultLogger struct {}
type DefaultLogger struct{}
// NewDefaultLogger creates a new Logger.
func NewDefaultLogger() Logger {
@@ -14,42 +13,44 @@ func NewDefaultLogger() Logger {
}
// Print works like Sprintf.
func (l *DefaultLogger) Print(message string, args ...interface{}) error {
fmt.Printf(message + "\n", args...)
func (l *DefaultLogger) Print(message string) error {
println(message)
return nil
}
// Trace level logging. Works like Sprintf.
func (l *DefaultLogger) Trace(message string, args ...interface{}) error {
fmt.Printf("TRACE | " + message + "\n", args...)
func (l *DefaultLogger) Trace(message string) error {
println("TRACE | " + message)
return nil
}
// Debug level logging. Works like Sprintf.
func (l *DefaultLogger) Debug(message string, args ...interface{}) error {
fmt.Printf("DEBUG | " + message + "\n", args...)
func (l *DefaultLogger) Debug(message string) error {
println("DEBUG | " + message)
return nil
}
// Info level logging. Works like Sprintf.
func (l *DefaultLogger) Info(message string, args ...interface{}) error {
fmt.Printf("INFO | " + message + "\n", args...)
func (l *DefaultLogger) Info(message string) error {
println("INFO | " + message)
return nil
}
// Warning level logging. Works like Sprintf.
func (l *DefaultLogger) Warning(message string, args ...interface{}) error {
fmt.Printf("WARN | " + message + "\n", args...)
func (l *DefaultLogger) Warning(message string) error {
println("WARN | " + message)
return nil
}
// Error level logging. Works like Sprintf.
func (l *DefaultLogger) Error(message string, args ...interface{}) error {
fmt.Printf("ERROR | " + message + "\n", args...)
func (l *DefaultLogger) Error(message string) error {
println("ERROR | " + message)
return nil
}
// Fatal level logging. Works like Sprintf.
func (l *DefaultLogger) Fatal(message string, args ...interface{}) error {
fmt.Printf("FATAL | " + message + "\n", args...)
func (l *DefaultLogger) Fatal(message string) error {
println("FATAL | " + message)
os.Exit(1)
return nil
}

53
v2/pkg/logger/logger.go
View File

@@ -1,33 +1,36 @@
package logger
// LogLevel is an unsigned 8bit int
type LogLevel uint8
const (
// TRACE level
TRACE LogLevel = 0
// DEBUG level logging
DEBUG LogLevel = 1
// INFO level logging
INFO LogLevel = 2
// WARNING level logging
WARNING LogLevel = 4
// ERROR level logging
ERROR LogLevel = 8
// FATAL level logging
FATAL LogLevel = 16
// TRACE level
TRACE LogLevel = 0
// DEBUG level logging
DEBUG LogLevel = 1
// INFO level logging
INFO LogLevel = 2
// WARNING level logging
WARNING LogLevel = 4
// ERROR level logging
ERROR LogLevel = 8
// FATAL level logging
FATAL LogLevel = 16
)
// Logger specifies the methods required to attach
// a logger to a Wails application
type Logger interface {
Print(message string, args ...interface{}) error
Trace(message string, args ...interface{}) error
Debug(message string, args ...interface{}) error
Info(message string, args ...interface{}) error
Warning(message string, args ...interface{}) error
Error(message string, args ...interface{}) error
Fatal(message string, args ...interface{}) error
}
Print(message string) error
Trace(message string) error
Debug(message string) error
Info(message string) error
Warning(message string) error
Error(message string) error
Fatal(message string) error
}