diff --git a/README.md b/README.md
index 3cc000183e635ba3032c7aafac63fcc8c2404a49..c85718ee13066ca8a689c63e7e3ce529559477e3 100644
--- a/README.md
+++ b/README.md
@@ -42,4 +42,6 @@ server:
grpc:
mock: lokalen gRPC Server mocken (bool)
url: URL des Ziel-gRPC-Servers im host:port Format (string)
+logging:
+ level: "ERROR" | "WARN" | "INFO" | "DEBUG"
```
\ No newline at end of file
diff --git a/cmd/fachstellen-proxy/main.go b/cmd/fachstellen-proxy/main.go
index 4b8898ca9272c0f841471b0d4b497c6af830fc1a..c6a993e9a18aedf3d364e250ff3e18c62cf8026c 100644
--- a/cmd/fachstellen-proxy/main.go
+++ b/cmd/fachstellen-proxy/main.go
@@ -29,16 +29,12 @@ import (
"fachstellen-proxy/internal/config"
"fachstellen-proxy/internal/mock"
"fachstellen-proxy/internal/server"
- "log"
)
var version = "v1.0.0-beta.1"
func main() {
- conf, err := config.LoadConfig()
- if err != nil {
- log.Fatalf("error loading config: %v", err)
- }
+ conf := config.LoadConfig()
if conf.Grpc.Mock {
go mock.StartGrpcServer()
diff --git a/config/config.yml b/config/config.yml
index d5f31932f3bc6d39f1aaf481538bd7976d85b771..8605b248d11050d5a8ad3c71b3e41e20eb8993d6 100755
--- a/config/config.yml
+++ b/config/config.yml
@@ -1,4 +1,6 @@
server:
port: 8082
grpc:
- mock: true
\ No newline at end of file
+ mock: true
+logging:
+ level: "INFO"
\ No newline at end of file
diff --git a/internal/config/config.go b/internal/config/config.go
index 06184cc057f55677bfe91bb53b9904ae78e3dcb6..b246c3d63d3ad026e142c890f9532722f122358e 100644
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -26,15 +26,19 @@
package config
import (
- "fmt"
"github.com/kelseyhightower/envconfig"
"gopkg.in/yaml.v3"
+ "log"
"os"
"regexp"
+ "testing"
)
-const defaultFilePath = "config/config.yml"
-const grpcUrlRegex = `^[A-Za-z\d-]+(\.[A-Za-z\d-]+){0,512}:\d{1,5}$`
+const (
+ defaultFilePath = "config/config.yml"
+ testFilePath = "testdata/test_config.yml"
+ grpcUrlRegex = `^[A-Za-z\d-]+(\.[A-Za-z\d-]+){0,512}:\d{1,5}$`
+)
type Config struct {
Server struct {
@@ -44,36 +48,41 @@ type Config struct {
Mock bool `yaml:"mock" envconfig:"GRPC_MOCK"`
Url string `yaml:"url" envconfig:"GRPC_URL"`
} `yaml:"grpc"`
+ Logging struct {
+ Level string `yaml:"level" envconfig:"LOGGING_LEVEL"`
+ } `yaml:"logging"`
}
-func LoadConfig(filePath ...string) (Config, error) {
+func LoadConfig(configFilePath ...string) Config {
var config Config
fp := defaultFilePath
- if len(filePath) > 0 {
- fp = filePath[0]
+ if len(configFilePath) > 0 {
+ fp = configFilePath[0]
+ } else if testing.Testing() {
+ fp = testFilePath
}
file, err := os.ReadFile(fp)
if err != nil {
- return config, fmt.Errorf("error reading YAML file: %v", err)
+ log.Fatalf("FATAL: error reading YAML file: %v", err)
}
err = yaml.Unmarshal(file, &config)
if err != nil {
- return config, fmt.Errorf("error unmarshalling YAML file: %v", err)
+ log.Fatalf("FATAL: error unmarshalling YAML file: %v", err)
}
err = envconfig.Process("", &config)
if err != nil {
- return config, fmt.Errorf("error reading env: %v", err)
+ log.Fatalf("FATAL: error reading env: %v", err)
}
if len(config.Grpc.Url) > 0 && !ValidateGrpcUrl(config.Grpc.Url) {
- return config, fmt.Errorf("gRPC URL is not in host:port format")
+ log.Fatalf("FATAL: gRPC URL is not in host:port format")
}
- return config, nil
+ return config
}
func ValidateGrpcUrl(grpcUrl string) bool {
diff --git a/internal/config/config_test.go b/internal/config/config_test.go
index 1b97338a29d3a9f36c1cd1c690bde4b88d51afa1..38cd14245895c0ba67c51af3f41cd7d3faf899f9 100644
--- a/internal/config/config_test.go
+++ b/internal/config/config_test.go
@@ -34,29 +34,29 @@ import (
func TestLoadConfig(t *testing.T) {
t.Run("should load config from file", func(t *testing.T) {
- config, err := LoadConfig("testdata/test_config.yml")
- assert.NoError(t, err, "LoadConfig should not return an error")
+ config := LoadConfig()
expectedConfig := Config{}
expectedConfig.Server.Port = 8080
expectedConfig.Grpc.Url = "localhost:50051"
expectedConfig.Grpc.Mock = false
+ expectedConfig.Logging.Level = "DEBUG"
assert.Equal(t, expectedConfig, config)
})
t.Run("should load config from env", func(t *testing.T) {
envVars := map[string]string{
- "SERVER_PORT": "9090",
- "GRPC_URL": "localhost:99999",
+ "SERVER_PORT": "9090",
+ "GRPC_URL": "localhost:99999",
+ "LOGGING_LEVEL": "ERROR",
}
for key, value := range envVars {
assert.NoError(t, os.Setenv(key, value), "Setenv "+key+" should not return an error")
}
- config, err := LoadConfig("testdata/empty_test_config.yml")
- assert.NoError(t, err, "LoadConfig should not return an error")
+ config := LoadConfig("testdata/empty_test_config.yml")
for key := range envVars {
assert.NoError(t, os.Unsetenv(key), "Unsetenv "+key+" should not return an error")
@@ -66,6 +66,7 @@ func TestLoadConfig(t *testing.T) {
expectedConfig.Server.Port = 9090
expectedConfig.Grpc.Url = "localhost:99999"
expectedConfig.Grpc.Mock = false
+ expectedConfig.Logging.Level = "ERROR"
assert.Equal(t, expectedConfig, config)
})
@@ -73,8 +74,7 @@ func TestLoadConfig(t *testing.T) {
t.Run("should overwrite config with env", func(t *testing.T) {
assert.NoError(t, os.Setenv("SERVER_PORT", "9090"), "Setenv SERVER_PORT should not return an error")
- config, err := LoadConfig("testdata/test_config.yml")
- assert.NoError(t, err, "LoadConfig should not return an error")
+ config := LoadConfig()
assert.NoError(t, os.Unsetenv("SERVER_PORT"), "Unsetenv SERVER_PORT should not return an error")
@@ -82,6 +82,7 @@ func TestLoadConfig(t *testing.T) {
expectedConfig.Server.Port = 9090
expectedConfig.Grpc.Url = "localhost:50051"
expectedConfig.Grpc.Mock = false
+ expectedConfig.Logging.Level = "DEBUG"
assert.Equal(t, expectedConfig, config)
})
diff --git a/internal/config/testdata/test_config.yml b/internal/config/testdata/test_config.yml
index 10a074db9816f23c5dd0f3199d86ee2f3385cc13..ea8925db9cb5af5c351a1af92d6fb7f878de4359 100644
--- a/internal/config/testdata/test_config.yml
+++ b/internal/config/testdata/test_config.yml
@@ -1,4 +1,6 @@
server:
port: 8080
grpc:
- url: "localhost:50051"
\ No newline at end of file
+ url: "localhost:50051"
+logging:
+ level: "DEBUG"
\ No newline at end of file
diff --git a/internal/logging/logger.go b/internal/logging/logger.go
new file mode 100644
index 0000000000000000000000000000000000000000..6ce32e5aa9333b372d482136855f19c67ca9c5d8
--- /dev/null
+++ b/internal/logging/logger.go
@@ -0,0 +1,113 @@
+/*
+ * Copyright (C) 2023-2024
+ * Das Land Schleswig-Holstein vertreten durch den
+ * Ministerpräsidenten des Landes Schleswig-Holstein
+ * Staatskanzlei
+ * Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
+ *
+ * Lizenziert unter der EUPL, Version 1.2 oder - sobald
+ * diese von der Europäischen Kommission genehmigt wurden -
+ * Folgeversionen der EUPL ("Lizenz");
+ * Sie dürfen dieses Werk ausschließlich gemäß
+ * dieser Lizenz nutzen.
+ * Eine Kopie der Lizenz finden Sie hier:
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Sofern nicht durch anwendbare Rechtsvorschriften
+ * gefordert oder in schriftlicher Form vereinbart, wird
+ * die unter der Lizenz verbreitete Software "so wie sie
+ * ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
+ * ausdrücklich oder stillschweigend - verbreitet.
+ * Die sprachspezifischen Genehmigungen und Beschränkungen
+ * unter der Lizenz sind dem Lizenztext zu entnehmen.
+ */
+
+package logging
+
+import (
+ "fachstellen-proxy/internal/config"
+ "fmt"
+ "log"
+ "os"
+ "sync"
+)
+
+const (
+ logLevelNumError = iota
+ logLevelNumWarning
+ logLevelNumInfo
+ logLevelNumDebug
+ LogLevelError = "ERROR"
+ LogLevelWarning = "WARN"
+ LogLevelInfo = "INFO"
+ LogLevelDebug = "DEBUG"
+)
+
+type Logger struct {
+ BaseLogger *log.Logger
+ level int
+}
+
+var (
+ logger *Logger
+ once sync.Once
+)
+
+func GetLogger() *Logger {
+ initializeLogger()
+
+ return logger
+}
+
+func initializeLogger() {
+ once.Do(func() {
+ logger = &Logger{
+ BaseLogger: log.New(os.Stdout, "", log.LstdFlags),
+ level: getLoggingLevel(),
+ }
+ })
+}
+
+func getLoggingLevel() int {
+ logLevelMap := map[string]int{
+ LogLevelError: logLevelNumError,
+ LogLevelWarning: logLevelNumWarning,
+ LogLevelInfo: logLevelNumInfo,
+ LogLevelDebug: logLevelNumDebug,
+ }
+
+ conf := config.LoadConfig()
+ logLevel, exists := logLevelMap[conf.Logging.Level]
+ if !exists {
+ logLevel = logLevelMap[LogLevelInfo]
+ }
+
+ return logLevel
+}
+
+func (l *Logger) log(level int, prefix, format string, v ...any) {
+ if l.level >= level {
+ l.BaseLogger.Println(fmt.Sprintf("%v: %v", prefix, fmt.Sprintf(format, v...)))
+ }
+}
+
+func (l *Logger) Fatal(format string, v ...any) {
+ l.BaseLogger.Fatalln(fmt.Sprintf("FATAL: "+format, v...))
+}
+
+func (l *Logger) Error(format string, v ...any) {
+ l.log(logLevelNumError, "ERROR", format, v...)
+}
+
+func (l *Logger) Warning(format string, v ...any) {
+ l.log(logLevelNumWarning, "WARNING", format, v...)
+}
+
+func (l *Logger) Info(format string, v ...any) {
+ l.log(logLevelNumInfo, "INFO", format, v...)
+}
+
+func (l *Logger) Debug(format string, v ...any) {
+ l.log(logLevelNumDebug, "DEBUG", format, v...)
+}
diff --git a/internal/logging/logger_test.go b/internal/logging/logger_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..11eff2f85f749fc9bcd884ee9d57c7a9b13fe12d
--- /dev/null
+++ b/internal/logging/logger_test.go
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2023-2024
+ * Das Land Schleswig-Holstein vertreten durch den
+ * Ministerpräsidenten des Landes Schleswig-Holstein
+ * Staatskanzlei
+ * Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
+ *
+ * Lizenziert unter der EUPL, Version 1.2 oder - sobald
+ * diese von der Europäischen Kommission genehmigt wurden -
+ * Folgeversionen der EUPL ("Lizenz");
+ * Sie dürfen dieses Werk ausschließlich gemäß
+ * dieser Lizenz nutzen.
+ * Eine Kopie der Lizenz finden Sie hier:
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Sofern nicht durch anwendbare Rechtsvorschriften
+ * gefordert oder in schriftlicher Form vereinbart, wird
+ * die unter der Lizenz verbreitete Software "so wie sie
+ * ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
+ * ausdrücklich oder stillschweigend - verbreitet.
+ * Die sprachspezifischen Genehmigungen und Beschränkungen
+ * unter der Lizenz sind dem Lizenztext zu entnehmen.
+ */
+
+package logging
+
+import (
+ "bytes"
+ "github.com/stretchr/testify/assert"
+ "log"
+ "testing"
+)
+
+func setUpLogger(t *testing.T, level string, msg string) *bytes.Buffer {
+ logger := GetLogger()
+
+ var buf bytes.Buffer
+ logger.BaseLogger.SetOutput(&buf)
+
+ originalFlags := log.Flags()
+ t.Cleanup(func() {
+ log.SetOutput(nil)
+ log.SetFlags(originalFlags)
+ })
+
+ if level == LogLevelError {
+ logger.Error(msg)
+ } else if level == LogLevelWarning {
+ logger.Warning(msg)
+ } else if level == LogLevelInfo {
+ logger.Info(msg)
+ } else {
+ logger.Debug(msg)
+ }
+
+ return &buf
+}
+
+func TestError(t *testing.T) {
+ buf := setUpLogger(t, LogLevelError, "test error")
+ logOutput := buf.String()
+ assert.Contains(t, logOutput, "ERROR: test error")
+}
+
+func TestWarning(t *testing.T) {
+ buf := setUpLogger(t, LogLevelWarning, "test warning")
+ logOutput := buf.String()
+ assert.Contains(t, logOutput, "WARNING: test warning")
+}
+
+func TestInfo(t *testing.T) {
+ buf := setUpLogger(t, LogLevelInfo, "test info")
+ logOutput := buf.String()
+ assert.Contains(t, logOutput, "INFO: test info")
+}
+
+func TestDebug(t *testing.T) {
+ buf := setUpLogger(t, LogLevelDebug, "test debug")
+ logOutput := buf.String()
+ assert.Empty(t, logOutput)
+}
diff --git a/internal/logging/testdata/test_config.yml b/internal/logging/testdata/test_config.yml
new file mode 100644
index 0000000000000000000000000000000000000000..6021893b2e1982f4f8d4215707fa6300e2cd6e8e
--- /dev/null
+++ b/internal/logging/testdata/test_config.yml
@@ -0,0 +1,6 @@
+server:
+ port: 8080
+grpc:
+ url: "localhost:50051"
+logging:
+ level: "INFO"
\ No newline at end of file
diff --git a/internal/mock/globals.go b/internal/mock/globals.go
new file mode 100644
index 0000000000000000000000000000000000000000..b08a0f5c817db69d342f9704224dbe0c3789b883
--- /dev/null
+++ b/internal/mock/globals.go
@@ -0,0 +1,5 @@
+package mock
+
+import "fachstellen-proxy/internal/logging"
+
+var logger = logging.GetLogger()
diff --git a/internal/mock/grpc_server.go b/internal/mock/grpc_server.go
index 8050c2414e1a61176c7a70e8769eed3e14115ae7..729525c994e777903b5877ef109e254031293bcc 100644
--- a/internal/mock/grpc_server.go
+++ b/internal/mock/grpc_server.go
@@ -32,7 +32,6 @@ import (
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
- "log"
"net"
)
@@ -61,14 +60,15 @@ func (s *server) Register(ctx context.Context, in *pb.GrpcFachstelleRegistration
func StartGrpcServer() *grpc.Server {
s := grpc.NewServer()
pb.RegisterFachstelleRegistrationServiceServer(s, &server{})
+
lis, err := net.Listen("tcp", fmt.Sprintf(":%d", GrpcMockPort))
if err != nil {
- log.Fatalf("gRPC server failed to listen: %v", err)
+ logger.Fatal("gRPC server failed to listen: %v", err)
}
- log.Printf("gRPC server listening on port %d", GrpcMockPort)
+ logger.Info("gRPC server listening on port %v", GrpcMockPort)
if err := s.Serve(lis); err != nil {
- log.Fatalf("gRPC server failed to serve: %v", err)
+ logger.Fatal("gRPC server failed to serve: %v", err)
}
return s
diff --git a/internal/mock/grpc_server_test.go b/internal/mock/grpc_server_test.go
index 1cdef0ca1bf5e4c5150c84f30df00f59e005c6c2..b7a4309ea9fb7b52f372928488b849f5c3ef84ca 100644
--- a/internal/mock/grpc_server_test.go
+++ b/internal/mock/grpc_server_test.go
@@ -36,14 +36,24 @@ import (
)
func TestStartGrpcServer(t *testing.T) {
- t.Run("should have no error", func(t *testing.T) {
+ setUpGrpcEnv := func() (pb.FachstelleRegistrationServiceClient, func()) {
SetUpGrpcServer()
conn, err := grpc.NewClient(fmt.Sprintf("localhost:%d", GrpcMockPort), grpc.WithTransportCredentials(insecure.NewCredentials()))
assert.NoError(t, err)
- defer conn.Close()
+ cleanup := func() {
+ conn.Close()
+ }
client := pb.NewFachstelleRegistrationServiceClient(conn)
+
+ return client, cleanup
+ }
+
+ t.Run("should have no error", func(t *testing.T) {
+ client, cleanUp := setUpGrpcEnv()
+ defer cleanUp()
+
resp, err := client.Register(context.Background(), &pb.GrpcFachstelleRegistrationRequest{Fachstelle: &pb.GrpcFachstelle{MukId: "testMukId"}})
assert.NoError(t, err)
@@ -51,13 +61,9 @@ func TestStartGrpcServer(t *testing.T) {
})
t.Run("should have error", func(t *testing.T) {
- SetUpGrpcServer()
+ client, cleanUp := setUpGrpcEnv()
+ defer cleanUp()
- conn, err := grpc.NewClient(fmt.Sprintf("localhost:%d", GrpcMockPort), grpc.WithTransportCredentials(insecure.NewCredentials()))
- assert.NoError(t, err)
- defer conn.Close()
-
- client := pb.NewFachstelleRegistrationServiceClient(conn)
resp, err := client.Register(context.Background(), &pb.GrpcFachstelleRegistrationRequest{})
assert.Error(t, err)
diff --git a/internal/mock/testdata/test_config.yml b/internal/mock/testdata/test_config.yml
new file mode 100644
index 0000000000000000000000000000000000000000..ea8925db9cb5af5c351a1af92d6fb7f878de4359
--- /dev/null
+++ b/internal/mock/testdata/test_config.yml
@@ -0,0 +1,6 @@
+server:
+ port: 8080
+grpc:
+ url: "localhost:50051"
+logging:
+ level: "DEBUG"
\ No newline at end of file
diff --git a/internal/server/globals.go b/internal/server/globals.go
new file mode 100644
index 0000000000000000000000000000000000000000..2ac6c4f087be0e6c7ac987c16203e805fe33a552
--- /dev/null
+++ b/internal/server/globals.go
@@ -0,0 +1,5 @@
+package server
+
+import "fachstellen-proxy/internal/logging"
+
+var logger = logging.GetLogger()
diff --git a/internal/server/handler.go b/internal/server/handler.go
index 1cc208f81155b920f04f44a980623fb30a8596f9..3d22eb8fc72bcd32d2e28f676fb07f87aeafdd13 100644
--- a/internal/server/handler.go
+++ b/internal/server/handler.go
@@ -31,7 +31,6 @@ import (
"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
- "log"
"net/http"
)
@@ -39,14 +38,14 @@ func RegisterHomeEndpoint(mux *runtime.ServeMux) {
err := mux.HandlePath("GET", "/", func(w http.ResponseWriter, r *http.Request, pathParams map[string]string) {
defer func() {
if err := recover(); err != nil {
- log.Printf("failed to recover: %v", err)
+ logger.Error("failed to recover: %v", err)
http.Error(w, fmt.Sprintf("failed to recover: %v", err), http.StatusInternalServerError)
}
}()
})
if err != nil {
- log.Fatalf("failed to register home endpoint: %v", err)
+ logger.Fatal("failed to register home endpoint: %v", err)
}
}
@@ -74,6 +73,6 @@ func ErrorHandler(ctx context.Context, mux *runtime.ServeMux, marshaler runtime.
_, writeErr := w.Write([]byte(st.Message()))
if writeErr != nil {
- log.Fatalf("failed to handle grpc error: %v", writeErr)
+ logger.Fatal("failed to handle grpc error: %v", writeErr)
}
}
diff --git a/internal/server/handler_test.go b/internal/server/handler_test.go
index b29d1722fb885d2e149619b5eba2e20a18f28c52..6cf686e466a16158d655f42a73d99d84f8118564 100644
--- a/internal/server/handler_test.go
+++ b/internal/server/handler_test.go
@@ -44,47 +44,37 @@ func TestRegisterHomeEndpoint(t *testing.T) {
}
func TestErrorHandler(t *testing.T) {
- t.Run("should have bad request error", func(t *testing.T) {
+ assertErroneousRequest := func(jsonData []byte, expectedStatusCode int) {
mock.SetUpGrpcServer()
SetUpHttpGateway()
- jsonData := []byte(`{}`)
resp, err := http.Post(fmt.Sprintf("http://localhost:8080%v", RegisterFachstelleUrlPath), "application/json", bytes.NewBuffer(jsonData))
assert.NoError(t, err)
- assert.Equal(t, http.StatusBadRequest, resp.StatusCode)
+ assert.Equal(t, expectedStatusCode, resp.StatusCode)
+ }
+
+ t.Run("should have bad request error", func(t *testing.T) {
+ jsonData := []byte(`{}`)
+
+ assertErroneousRequest(jsonData, http.StatusBadRequest)
})
t.Run("should have conflict error", func(t *testing.T) {
- mock.SetUpGrpcServer()
- SetUpHttpGateway()
-
jsonData := []byte(`{"fachstelle": {"mukId": "conflictMukId"}}`)
- resp, err := http.Post(fmt.Sprintf("http://localhost:8080%v", RegisterFachstelleUrlPath), "application/json", bytes.NewBuffer(jsonData))
- assert.NoError(t, err)
- assert.Equal(t, http.StatusConflict, resp.StatusCode)
+ assertErroneousRequest(jsonData, http.StatusConflict)
})
t.Run("should have unavailable error", func(t *testing.T) {
- mock.SetUpGrpcServer()
- SetUpHttpGateway()
-
jsonData := []byte(`{"fachstelle": {"mukId": "unavailableMukId"}}`)
- resp, err := http.Post(fmt.Sprintf("http://localhost:8080%v", RegisterFachstelleUrlPath), "application/json", bytes.NewBuffer(jsonData))
- assert.NoError(t, err)
- assert.Equal(t, http.StatusServiceUnavailable, resp.StatusCode)
+ assertErroneousRequest(jsonData, http.StatusServiceUnavailable)
})
t.Run("should have internal server error", func(t *testing.T) {
- mock.SetUpGrpcServer()
- SetUpHttpGateway()
-
jsonData := []byte(`{"fachstelle": {"mukId": "erroneousMukId"}}`)
- resp, err := http.Post(fmt.Sprintf("http://localhost:8080%v", RegisterFachstelleUrlPath), "application/json", bytes.NewBuffer(jsonData))
- assert.NoError(t, err)
- assert.Equal(t, http.StatusInternalServerError, resp.StatusCode)
+ assertErroneousRequest(jsonData, http.StatusInternalServerError)
})
}
diff --git a/internal/server/http_gateway.go b/internal/server/http_gateway.go
index bcf3cf7dc7a8214e24a7e45fda3d4255feb448da..5906889cb9e2847e6c6466443fc813ec4adafde7 100644
--- a/internal/server/http_gateway.go
+++ b/internal/server/http_gateway.go
@@ -31,7 +31,6 @@ import (
"fachstellen-proxy/internal/mock"
"fmt"
"google.golang.org/grpc/credentials/insecure"
- "log"
"net/http"
"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
@@ -54,7 +53,7 @@ func StartHttpGateway(conf config.Config) *http.Server {
opts := []grpc.DialOption{grpc.WithTransportCredentials(insecure.NewCredentials())}
err := pb.RegisterFachstelleRegistrationServiceHandlerFromEndpoint(ctx, mux, grpcEndpoint, opts)
if err != nil {
- log.Fatalf("failed to start HTTP gateway: %v", err)
+ logger.Fatal("failed to start HTTP gateway: %v", err)
}
RegisterHomeEndpoint(mux)
@@ -64,9 +63,9 @@ func StartHttpGateway(conf config.Config) *http.Server {
Handler: RequestLoggingMiddleware(mux),
}
- log.Printf("HTTP gateway listening on port %d", conf.Server.Port)
+ logger.Info("HTTP gateway listening on port %d", conf.Server.Port)
if err := httpServer.ListenAndServe(); err != nil {
- log.Fatalf("HTTP gateway failed to serve: %v", err)
+ logger.Fatal("HTTP gateway failed to serve: %v", err)
}
return httpServer
diff --git a/internal/server/middleware.go b/internal/server/middleware.go
index ab9ed8b25b022cece0f5a814589fd3a4624ba4fc..fdab80b369121d04af22fe2cc6a0f2dd85a01b34 100644
--- a/internal/server/middleware.go
+++ b/internal/server/middleware.go
@@ -28,9 +28,7 @@ package server
import (
"bytes"
"fmt"
- "google.golang.org/grpc/grpclog"
"io"
- "log"
"net/http"
)
@@ -55,21 +53,21 @@ func RequestLoggingMiddleware(h http.Handler) http.Handler {
body, err := io.ReadAll(r.Body)
if err != nil {
- log.Printf("failed to read request body: %v", err)
+ logger.Error("failed to read request body: %v", err)
http.Error(w, fmt.Sprintf("failed to read request body: %v", err), http.StatusBadRequest)
return
}
r.Body = io.NopCloser(bytes.NewReader(body))
- log.Printf("received request with body: %v", string(body))
+ logger.Debug("received request with body: %v", string(body))
lw := &logResponseWriter{w, http.StatusOK}
h.ServeHTTP(lw, r)
if lw.statusCode == http.StatusOK {
- log.Printf("successfully handled request with body: %v", string(body))
+ logger.Debug("successfully handled request with body: %v", string(body))
} else {
- grpclog.Errorf("failed handling request with body: %v, status code: %d", string(body), lw.statusCode)
+ logger.Error("failed handling request with body: %v, status code: %d", string(body), lw.statusCode)
}
})
}
diff --git a/internal/server/middleware_test.go b/internal/server/middleware_test.go
index 06aaa8ea764ae586d820ebc821bb9f97d8488620..b69bed46805ec058e48d8b01d33b0f50eb075901 100644
--- a/internal/server/middleware_test.go
+++ b/internal/server/middleware_test.go
@@ -40,7 +40,7 @@ func TestRequestLoggingMiddleware(t *testing.T) {
SetUpHttpGateway()
var buf bytes.Buffer
- log.SetOutput(&buf)
+ logger.BaseLogger.SetOutput(&buf)
originalFlags := log.Flags()
defer func() {
diff --git a/internal/server/test_setup.go b/internal/server/test_setup.go
index bd5f4e29d14cdbc7014d5f77d2d630faf722d102..5c3fd654df03385a9d008e716c93c7a60843b6cf 100644
--- a/internal/server/test_setup.go
+++ b/internal/server/test_setup.go
@@ -35,9 +35,7 @@ var setUpOnce sync.Once
func SetUpHttpGateway() {
setUpOnce.Do(func() {
- conf := config.Config{}
- conf.Server.Port = 8080
- conf.Grpc.Mock = true
+ conf := config.LoadConfig()
go StartHttpGateway(conf)
time.Sleep(time.Second) // Wait for the server to start
diff --git a/internal/server/testdata/test_config.yml b/internal/server/testdata/test_config.yml
new file mode 100644
index 0000000000000000000000000000000000000000..6235966c8828f67d39820aeb96b70781ca9300f7
--- /dev/null
+++ b/internal/server/testdata/test_config.yml
@@ -0,0 +1,6 @@
+server:
+ port: 8080
+grpc:
+ mock: true
+logging:
+ level: "DEBUG"
\ No newline at end of file