feat: logging

internal/pkg/log/log.go

@@ -0,0 +1,23 @@
+package log
+
+import (
+	"context"
+
+	"go.uber.org/zap"
+)
+
+type ctxLogKey struct{}
+
+func ToCtx(ctx context.Context, lg *zap.Logger) context.Context {
+	return context.WithValue(ctx, ctxLogKey{}, lg)
+}
+
+func Ctx(ctx context.Context) *zap.Logger {
+	lg, ok := ctx.Value(ctxLogKey{}).(*zap.Logger)
+	if !ok || lg == nil {
+		zap.L().Error("no logger in context, using global")
+		return zap.L()
+	}
+
+	return lg
+}

internal/transport/middleware/log.go

@@ -0,0 +1,44 @@
+package middleware
+
+import (
+	"time"
+
+	"git.intra.yksa.space/gsn/gsn-proxy/internal/pkg/errcodes"
+	"git.intra.yksa.space/gsn/gsn-proxy/internal/pkg/log"
+	"github.com/ogen-go/ogen/middleware"
+	"go.uber.org/zap"
+)
+
+func Logging(logger *zap.Logger) middleware.Middleware {
+	return func(req middleware.Request, next func(req middleware.Request) (middleware.Response, error)) (middleware.Response, error) {
+		lg := logger.With(
+			zap.String("operationId", req.OperationID),
+		)
+
+		lg.Info("started request")
+
+		req.Context = log.ToCtx(req.Context, lg)
+
+		start := time.Now()
+		resp, err := next(req)
+		dur := time.Since(start).Microseconds()
+
+		if err != nil {
+			if errcode, ok := err.(*errcodes.ErrorCode); ok {
+				lg.Error("request error",
+					zap.Int("status_code", errcode.StatusCode),
+					zap.String("message", errcode.Message),
+					zap.String("details", errcode.Details),
+				)
+			} else {
+				lg.Error("request internal error",
+					zap.Error(err),
+				)
+			}
+		}
+
+		lg.Info("done request", zap.Float64("duration_ms", float64(dur)/float64(1000)))
+
+		return resp, err
+	}
+}

internal/transport/rest/transport.go

@@ -2,32 +2,37 @@ package rest
 
 import (
 	"fmt"
-	"log"
 	"net/http"
 
+	"git.intra.yksa.space/gsn/gsn-proxy/internal/transport/middleware"
 	handler "git.intra.yksa.space/gsn/gsn-proxy/internal/transport/rest/handler"
 	api "git.intra.yksa.space/gsn/gsn-proxy/pkg/rest"
+	"go.uber.org/zap"
 )
 
 type Transport struct {
+	lg  *zap.Logger
 	cfg *Config
 	srv *api.Server
 }
 
-func New(handler *handler.Handler, cfg *Config) (*Transport, error) {
-	srv, err := api.NewServer(handler)
+func New(lg *zap.Logger, handler *handler.Handler, cfg *Config) (*Transport, error) {
+	srv, err := api.NewServer(handler, api.WithMiddleware(middleware.Logging(lg)))
 	if err != nil {
 		return nil, err
 	}
 
 	return &Transport{
+		lg:  lg,
 		srv: srv,
 		cfg: cfg,
 	}, nil
 }
 
 func (t *Transport) Run() {
+	t.lg.Info("started")
+
 	if err := http.ListenAndServe(fmt.Sprintf(":%d", t.cfg.Port), t.srv); err != nil {
-		log.Panic(err)
+		panic(err)
 	}
 }