back round 0 view raw

feat(middleware): use slogger #19

merged

opened by

brookjeynes.dev 2 months ago targeting master from push-trrpxxyxxmot

Signed-off-by: brookjeynes me@brookjeynes.dev

options

unified split

Changed files

+15 -6

internal

server

handlers

router.go

middleware

middleware.go

internal/server/handlers/router.go

···

       7
       7
        
       	"github.com/go-chi/chi/v5"

     

       8
       8
        
       

     

       9
       9
        
       	"yoten.app/internal/server"

     

       10
       10
       +
       	"yoten.app/internal/server/log"

     

       10
       11
        
       	"yoten.app/internal/server/middleware"

     

       11
       12
        
       	"yoten.app/internal/server/views"

     

       12
       13
        
       )

     
···

       25
       26
        
       		h.Oauth,

     

       26
       27
        
       		h.Db,

     

       27
       28
        
       		h.IdResolver,

     

       29
       29
       +
       		log.SubLogger(h.Logger, "middleware"),

     

       28
       30
        
       	)

     

       29
       31
        
       

     

       30
       32
        
       	router.HandleFunc("/*", func(w http.ResponseWriter, r *http.Request) {

+13 -6

internal/server/middleware/middleware.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
        
       	"fmt"

     

       6
       6
       -
       	"log"

     

       6
       6
       +
       	"log/slog"

     

       7
       7
        
       	"net/http"

     

       8
       8
        
       	"net/url"

     

       9
       9
        
       	"slices"

     
···

       25
       25
        
       	oauth      *oauth.OAuth

     

       26
       26
        
       	db         *db.DB

     

       27
       27
        
       	idResolver *atproto.Resolver

     

       28
       28
       +
       	logger     *slog.Logger

     

       28
       29
        
       }

     

       29
       30
        
       

     

       30
       30
       -
       func New(oauth *oauth.OAuth, db *db.DB, idResolver *atproto.Resolver) Middleware {

     

       31
       31
       +
       func New(oauth *oauth.OAuth, db *db.DB, idResolver *atproto.Resolver, logger *slog.Logger) Middleware {

     

       31
       32
        
       	return Middleware{

     

       32
       33
        
       		oauth:      oauth,

     

       33
       34
        
       		db:         db,

     

       34
       35
        
       		idResolver: idResolver,

     

       36
       36
       +
       		logger:     logger,

     

       35
       37
        
       	}

     

       36
       38
        
       }

     

       37
       39
        
       

     

       38
       40
        
       type middlewareFunc func(http.Handler) http.Handler

     

       39
       41
        
       

     

       40
       42
        
       func AuthMiddleware(o *oauth.OAuth) middlewareFunc {

     

       43
       43
       +
       	l := o.Logger.With("middleware", "AuthMiddleware")

     

       44
       44
       +
       

     

       41
       45
        
       	return func(next http.Handler) http.Handler {

     

       42
       46
        
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       43
       47
        
       			returnURL := "/"

     
···

       59
       63
        
       

     

       60
       64
        
       			sess, err := o.ResumeSession(r)

     

       61
       65
        
       			if err != nil {

     

       62
       62
       -
       				log.Println("failed to resume session, redirecting...", "err", err, "url", r.URL.String())

     

       66
       66
       +
       				l.Error("failed to resume session, redirecting...", "err", err, "url", r.URL.String())

     

       63
       67
        
       				redirectFunc(w, r)

     

       64
       68
        
       				return

     

       65
       69
        
       			}

     

       66
       70
        
       

     

       67
       71
        
       			if sess == nil {

     

       68
       68
       -
       				log.Printf("session is nil, redirecting...")

     

       72
       72
       +
       				l.Warn("session is nil, redirecting...")

     

       69
       73
        
       				redirectFunc(w, r)

     

       70
       74
        
       				return

     

       71
       75
        
       			}

     
···

       76
       80
        
       }

     

       77
       81
        
       

     

       78
       82
        
       func (mw Middleware) ResolveIdent() middlewareFunc {

     

       83
       83
       +
       	l := mw.logger.With("middleware", "ResolveIdent")

     

       79
       84
        
       	excluded := []string{"favicon.ico"}

     

       80
       85
        
       

     

       81
       86
        
       	return func(next http.Handler) http.Handler {

     
···

       90
       95
        
       

     

       91
       96
        
       			id, err := mw.idResolver.ResolveIdent(r.Context(), didOrHandle)

     

       92
       97
        
       			if err != nil {

     

       93
       93
       -
       				log.Println("failed to resolve did/handle:", err)

     

       98
       98
       +
       				l.Error("failed to resolve did/handle", "err", err)

     

       94
       99
        
       				w.WriteHeader(http.StatusNotFound)

     

       95
       100
        
       				views.NotFoundPage(views.NotFoundPageParams{}).Render(r.Context(), w)

     

       96
       101
        
       				return

     
···

       104
       109
        
       }

     

       105
       110
        
       

     

       106
       111
        
       func (mw Middleware) LoadUnreadNotificationCount() middlewareFunc {

     

       112
       112
       +
       	l := mw.logger.With("middleware", "LoadUnreadNotificationCount")

     

       113
       113
       +
       

     

       107
       114
        
       	return func(next http.Handler) http.Handler {

     

       108
       115
        
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       109
       116
        
       			user := mw.oauth.GetUser(r)

     
···

       114
       121
        
       

     

       115
       122
        
       			count, err := db.GetUnreadNotificationCount(mw.db, user.Did)

     

       116
       123
        
       			if err != nil {

     

       117
       117
       -
       				log.Println("failed to get notification count:", err)

     

       124
       124
       +
       				l.Error("failed to get notification count", "err", err)

     

       118
       125
        
       			}

     

       119
       126
        
       

     

       120
       127
        
       			ctx := context.WithValue(r.Context(), UnreadNotificationCountCtxKey, count)