remove: custom logging in favor of standard lib log package

6 files changed, 29 insertions, 161 deletions

diff --git a/internal/client/client.go b/internal/client/client.go
index c2ef6e1..3345a9f 100644
--- a/internal/client/client.go
+++ b/internal/client/client.go
@@ -6,11 +6,10 @@ import (
 	"crypto/x509"
 	_ "embed"
 	"fmt"
+	"log"
 	"os"
 	"strings"
 	"time"
-
-	"github.com/kyren223/eko/internal/utils/log"
 )
 
 //go:embed server.crt
@@ -19,7 +18,7 @@ var certPEM []byte
 func Run() {
 	certPool := x509.NewCertPool()
 	if !certPool.AppendCertsFromPEM(certPEM) {
-		log.Fatal("failed to append server certificate")
+		log.Fatalf("failed to append server certificate")
 	}
 
 	tlsConfig := &tls.Config{
@@ -27,7 +26,7 @@ func Run() {
 		ServerName: "localhost",
 	}
 
-	log.Info("Client started, waiting for user input...")
+	log.Println("client started, waiting for user input...")
 	for {
 		fmt.Print("> ")
 		input, _ := bufio.NewReader(os.Stdin).ReadString('\n')
@@ -37,32 +36,32 @@ func Run() {
 		}
 		err := processRequest(input, tlsConfig)
 		if err != nil {
-			log.Error("%v", err)
+			log.Println(err)
 		}
 	}
 }
 
 func processRequest(request string, tlsConfig *tls.Config) error {
-	conn, err := tls.Dial("tcp", ":7223", tlsConfig)
+	conn, err := tls.Dial("tcp4", ":7223", tlsConfig)
 	if err != nil {
-		return fmt.Errorf("Unable to establish connection with server: %v", err)
+		return fmt.Errorf("error establishing connection with server: %v", err)
 	}
 	defer conn.Close()
 
 	conn.SetDeadline(time.Now().Add(time.Second))
-	log.Info("Established connection to server: %v", conn.RemoteAddr().String())
+	log.Println("established connection with server:", conn.RemoteAddr().String())
 
 	_, err = conn.Write([]byte(request))
 	if err != nil {
-		return fmt.Errorf("Unable to send request: %v", err)
+		return fmt.Errorf("error sending request: %v", err)
 	}
 
 	buffer := make([]byte, 1024)
 	n, err := conn.Read(buffer)
 	if err != nil {
-		return fmt.Errorf("Unable to receive response: %v", err)
+		return fmt.Errorf("error receiving response: %v", err)
 	}
 
-	log.Info("Response from server: %v", string(buffer[:n]))
+	log.Println("server response:", string(buffer[:n]))
 	return nil
 }
diff --git a/internal/server/handler.go b/internal/server/handler.go
index 88309b4..83d3e6e 100644
--- a/internal/server/handler.go
+++ b/internal/server/handler.go
@@ -2,33 +2,31 @@ package server
 
 import (
 	"fmt"
+	"log"
 	"net"
 	"sync"
-
-	"github.com/kyren223/eko/internal/utils/log"
 )
 
 func handleConnection(conn net.Conn, wg *sync.WaitGroup) {
-	log.Info("Accepted client: %v", conn.RemoteAddr().String())
-	defer log.Info("Disconnecting client: %v", conn.RemoteAddr().String())
+	log.Println("accepted client:", conn.RemoteAddr().String())
+	defer log.Println("disconnected client:", conn.RemoteAddr().String())
 	defer conn.Close()
 	defer wg.Done()
 
 	buffer := make([]byte, 1024)
 	bytesRead, err := conn.Read(buffer)
 	if err != nil {
-		log.Error("Failed reading: %v", err)
+		log.Println("failed reading request:", err)
 		return
 	}
 	request := string(buffer[:bytesRead])
-	log.Info("Read %v bytes: %v", bytesRead, request)
+	log.Printf("Read %v bytes: %v\n", bytesRead, request)
 
 	response := []byte(fmt.Sprintf("Eko \"%v\"", request))
 	bytesWritten, err := conn.Write(response)
 	if err != nil {
-		log.Error("Failed writing response: %v", err)
+		log.Println("failed writing response:", err)
 		return
 	}
-	log.Info("Written %v bytes", bytesWritten)
+	log.Printf("written %v bytes\n", bytesWritten)
 }
-
diff --git a/internal/server/server.go b/internal/server/server.go
index aeb97f8..55e0763 100644
--- a/internal/server/server.go
+++ b/internal/server/server.go
@@ -3,14 +3,14 @@ package server
 import (
 	"crypto/tls"
 	_ "embed"
+	"errors"
+	"log"
 	"net"
 	"os"
 	"os/signal"
 	"strconv"
 	"sync"
 	"syscall"
-
-	"github.com/kyren223/eko/internal/utils/log"
 )
 
 const port = 7223
@@ -24,16 +24,16 @@ var keyPEM []byte
 func Start() {
 	cert, err := tls.X509KeyPair(certPEM, keyPEM)
 	if err != nil {
-		log.Fatal("Error loading certificate: %s", err)
+		log.Fatalf("error loading certificate: %s", err)
 	}
 
 	tlsConfig := &tls.Config{
 		Certificates: []tls.Certificate{cert},
 	}
 
-	listener, err := tls.Listen("tcp", ":"+strconv.Itoa(port), tlsConfig)
+	listener, err := tls.Listen("tcp4", ":"+strconv.Itoa(port), tlsConfig)
 	if err != nil {
-		log.Fatal("Error starting listener: %s", err)
+		log.Fatal("error starting server: %s", err)
 	}
 	defer listener.Close()
 
@@ -47,22 +47,23 @@ func Start() {
 }
 
 func handleInterrupt(listener net.Listener, stopChan <-chan os.Signal) {
-	<-stopChan
-	log.Info("Interrupt Signal")
-	log.Info("Closing listener from receiving new connections")
+	signal := <-stopChan
+	log.Println(signal.String())
 	listener.Close()
 }
 
 func listen(listener net.Listener, wg *sync.WaitGroup) {
-	log.Info("Started listening on port %v...", port)
+	log.Printf("started listening on port %v...\n", port)
 	for {
 		conn, err := listener.Accept()
 		if err != nil {
-			log.Warn("Failed to accept connection: %v", err)
+			if !errors.Is(err, net.ErrClosed) {
+				log.Println("error accepting connection:", err)
+			}
 			break
 		}
 		wg.Add(1)
 		go handleConnection(conn, wg)
 	}
-	log.Info("Stopped listening on port %v...", port)
+	log.Printf("stopped listening on port %v...\n", port)
 }
diff --git a/internal/utils/log/level.go b/internal/utils/log/level.go
deleted file mode 100644
index 1d3ca1b..0000000
--- a/internal/utils/log/level.go
+++ /dev/null
@@ -1,28 +0,0 @@
-package log
-
-type Level int
-
-func (l Level) String() string {
-	switch l {
-	case LevelDebug:
-		return "DEBUG"
-	case LevelInfo:
-		return "INFO"
-	case LevelWarn:
-		return "WARN"
-	case LevelError:
-		return "ERROR"
-	case LevelFatal:
-		return "FATAL"
-	default:
-		return ""
-	}
-}
-
-const (
-	LevelDebug Level = -4
-	LevelInfo  Level = 0
-	LevelWarn  Level = 4
-	LevelError Level = 8
-	LevelFatal Level = 12
-)
diff --git a/internal/utils/log/log.go b/internal/utils/log/log.go
deleted file mode 100644
index 453c998..0000000
--- a/internal/utils/log/log.go
+++ /dev/null
@@ -1,38 +0,0 @@
-package log
-
-var logger *Logger
-
-func SetDefault(l *Logger) {
-	logger = l
-}
-
-func Debug(message string, a ...any) {
-	_ = logger.Debug(message, a...)
-}
-
-func Info(message string, a ...any) {
-	_ = logger.Info(message, a...)
-}
-
-func Warn(message string, a ...any) {
-	_ = logger.Warn(message, a...)
-}
-
-func Error(message string, a ...any) {
-	_ = logger.Error(message, a...)
-}
-
-func Fatal(message string, a ...any) {
-	_ = logger.Fatal(message, a...)
-}
-
-func SetLevel(level Level) (oldLevel Level) {
-	oldLevel = logger.Level
-	logger.Level = level
-	return
-}
-
-func GetLevel() Level {
-	return logger.Level
-}
-
diff --git a/internal/utils/log/logger.go b/internal/utils/log/logger.go
deleted file mode 100644
index 942003d..0000000
--- a/internal/utils/log/logger.go
+++ /dev/null
@@ -1,64 +0,0 @@
-package log
-
-import (
-	"fmt"
-	"io"
-	"os"
-	"sync"
-	"time"
-)
-
-type Logger struct {
-	name   string
-	Level
-	writer io.Writer
-	mu sync.Mutex
-	color bool
-}
-
-func NewLogger(name string, writer io.Writer, ansi bool) *Logger {
-	color := ansi && (writer == os.Stdout || writer == os.Stderr)
-	return &Logger{name, LevelInfo, writer, sync.Mutex{}, color}
-}
-
-func (l *Logger) Log(level Level, message string, a ...any) error {
-	if l.Level > level {
-		return nil
-	}
-
-	timestamp := time.Now().Format(time.TimeOnly)
-	severity := level.String()
-	formattedMessage := fmt.Sprintf(message, a...)
-
-	// TODO: add support for ANSI coloring
-	l.mu.Lock()
-	_, err := fmt.Fprintf(l.writer, "[%s] [%s/%s]: %s\n", timestamp, l.name, severity, formattedMessage)
-	l.mu.Unlock()
-	return err
-}
-
-func (l *Logger) Debug(message string, a ...any) error {
-	return l.Log(LevelDebug, message, a...)
-}
-
-func (l *Logger) Info(message string, a ...any) error {
-	return l.Log(LevelInfo, message, a...)
-}
-
-func (l *Logger) Warn(message string, a ...any) error {
-	return l.Log(LevelWarn, message, a...)
-}
-
-func (l *Logger) Error(message string, a ...any) error {
-	return l.Log(LevelError, message, a...)
-}
-
-func (l *Logger) Fatal(message string, a ...any) error {
-	err := l.Log(LevelError, message, a...)
-	if err != nil {
-		return err
-	}
-	os.Exit(1)
-	return nil
-}
-