Monorepo for Tangled
tangled.org
appview/middleware: replace log package with structured slog logging
Add logger *slog.Logger to Middleware struct and thread it through New().
Replace all log.Println/log.Printf calls with mw.logger.Error/Warn using
structured key-value pairs. Standalone functions (AuthMiddleware, Paginate)
use slog.Default() to avoid signature breakage. Update router.go call site
to pass s.logger.
Signed-off-by: Matías Insaurralde <matias@insaurral.de>
authored by
Matías Insaurralde
and committed by
tangled.org
df56d3db
0f576540
+31
-22
+30
-22
appview/middleware/middleware.go
+30
-22
appview/middleware/middleware.go
···
3
3
import (
4
4
"context"
5
5
"fmt"
6
-
"log"
6
+
"log/slog"
7
7
"net/http"
8
8
"net/url"
9
9
"slices"
···
31
31
repoResolver *reporesolver.RepoResolver
32
32
idResolver *idresolver.Resolver
33
33
pages *pages.Pages
34
+
logger *slog.Logger
34
35
}
35
36
36
-
func New(oauth *oauth.OAuth, db *db.DB, enforcer *rbac.Enforcer, repoResolver *reporesolver.RepoResolver, idResolver *idresolver.Resolver, pages *pages.Pages) Middleware {
37
+
func New(oauth *oauth.OAuth, db *db.DB, enforcer *rbac.Enforcer, repoResolver *reporesolver.RepoResolver, idResolver *idresolver.Resolver, pages *pages.Pages, logger *slog.Logger) Middleware {
37
38
return Middleware{
38
39
oauth: oauth,
39
40
db: db,
···
41
42
repoResolver: repoResolver,
42
43
idResolver: idResolver,
43
44
pages: pages,
45
+
logger: logger,
44
46
}
45
47
}
46
48
···
68
70
69
71
sess, err := o.ResumeSession(r)
70
72
if err != nil {
71
-
log.Println("failed to resume session, redirecting...", "err", err, "url", r.URL.String())
73
+
slog.Default().Warn("failed to resume session, redirecting", "err", err, "url", r.URL.String())
72
74
redirectFunc(w, r)
73
75
return
74
76
}
75
77
76
78
if sess == nil {
77
-
log.Printf("session is nil, redirecting...")
79
+
slog.Default().Warn("session is nil, redirecting")
78
80
redirectFunc(w, r)
79
81
return
80
82
}
···
92
94
if offsetVal != "" {
93
95
offset, err := strconv.Atoi(offsetVal)
94
96
if err != nil {
95
-
log.Println("invalid offset")
97
+
slog.Default().Warn("invalid offset", "value", offsetVal)
96
98
} else {
97
99
page.Offset = offset
98
100
}
···
102
104
if limitVal != "" {
103
105
limit, err := strconv.Atoi(limitVal)
104
106
if err != nil {
105
-
log.Println("invalid limit")
107
+
slog.Default().Warn("invalid limit", "value", limitVal)
106
108
} else {
107
109
page.Limit = limit
108
110
}
···
116
118
func (mw Middleware) knotRoleMiddleware(group string) middlewareFunc {
117
119
return func(next http.Handler) http.Handler {
118
120
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
121
+
l := mw.logger.With("middleware", "knotRoleMiddleware")
119
122
// requires auth also
120
123
actor := mw.oauth.GetMultiAccountUser(r)
121
124
if actor == nil {
122
125
// we need a logged in user
123
-
log.Printf("not logged in, redirecting")
126
+
l.Warn("not logged in, redirecting")
124
127
http.Error(w, "Forbiden", http.StatusUnauthorized)
125
128
return
126
129
}
···
132
135
133
136
ok, err := mw.enforcer.E.HasGroupingPolicy(actor.Active.Did, group, domain)
134
137
if err != nil || !ok {
135
-
log.Printf("%s does not have perms of a %s in domain %s", actor.Active.Did, group, domain)
138
+
l.Warn("permission denied", "did", actor.Active.Did, "group", group, "domain", domain)
136
139
http.Error(w, "Forbiden", http.StatusUnauthorized)
137
140
return
138
141
}
···
149
152
func (mw Middleware) RepoPermissionMiddleware(requiredPerm string) middlewareFunc {
150
153
return func(next http.Handler) http.Handler {
151
154
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
155
+
l := mw.logger.With("middleware", "RepoPermissionMiddleware")
152
156
// requires auth also
153
157
actor := mw.oauth.GetMultiAccountUser(r)
154
158
if actor == nil {
155
159
// we need a logged in user
156
-
log.Printf("not logged in, redirecting")
160
+
l.Warn("not logged in, redirecting")
157
161
http.Error(w, "Forbiden", http.StatusUnauthorized)
158
162
return
159
163
}
···
165
169
166
170
ok, err := mw.enforcer.E.Enforce(actor.Active.Did, f.Knot, f.RepoIdentifier(), requiredPerm)
167
171
if err != nil || !ok {
168
-
log.Printf("%s does not have perms of a %s in repo %s", actor.Active.Did, requiredPerm, f.RepoIdentifier())
172
+
l.Warn("permission denied", "did", actor.Active.Did, "perm", requiredPerm, "repo", f.RepoIdentifier())
169
173
http.Error(w, "Forbiden", http.StatusUnauthorized)
170
174
return
171
175
}
···
197
201
}
198
202
}
199
203
if err != nil {
200
-
log.Printf("failed to resolve did/handle '%s': %s\n", didOrHandle, err)
204
+
mw.logger.Error("failed to resolve did/handle", "didOrHandle", didOrHandle, "err", err)
201
205
mw.pages.Error404(w)
202
206
return
203
207
}
···
212
216
func (mw Middleware) ResolveRepo() middlewareFunc {
213
217
return func(next http.Handler) http.Handler {
214
218
return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
219
+
l := mw.logger.With("middleware", "ResolveRepo")
215
220
repoName := chi.URLParam(req, "repo")
216
221
repoName = strings.TrimSuffix(repoName, ".git")
217
222
218
223
id, ok := req.Context().Value("resolvedId").(identity.Identity)
219
224
if !ok {
220
-
log.Println("malformed middleware")
225
+
l.Error("malformed middleware")
221
226
w.WriteHeader(http.StatusInternalServerError)
222
227
return
223
228
}
···
228
233
orm.FilterEq("name", repoName),
229
234
)
230
235
if err != nil {
231
-
log.Println("failed to resolve repo", "err", err)
236
+
l.Error("failed to resolve repo", "err", err)
232
237
w.WriteHeader(http.StatusNotFound)
233
238
mw.pages.ErrorKnot404(w)
234
239
return
···
244
249
func (mw Middleware) ResolvePull() middlewareFunc {
245
250
return func(next http.Handler) http.Handler {
246
251
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
252
+
l := mw.logger.With("middleware", "ResolvePull")
247
253
f, err := mw.repoResolver.Resolve(r)
248
254
if err != nil {
249
-
log.Println("failed to fully resolve repo", err)
255
+
l.Error("failed to fully resolve repo", "err", err)
250
256
w.WriteHeader(http.StatusNotFound)
251
257
mw.pages.ErrorKnot404(w)
252
258
return
···
255
261
prId := chi.URLParam(r, "pull")
256
262
prIdInt, err := strconv.Atoi(prId)
257
263
if err != nil {
258
-
log.Println("failed to parse pr id", err)
264
+
l.Error("failed to parse pr id", "err", err)
259
265
mw.pages.Error404(w)
260
266
return
261
267
}
262
268
263
269
pr, err := db.GetPull(mw.db, f.RepoAt(), prIdInt)
264
270
if err != nil {
265
-
log.Println("failed to get pull and comments", err)
271
+
l.Error("failed to get pull and comments", "err", err)
266
272
mw.pages.Error404(w)
267
273
return
268
274
}
···
272
278
if pr.IsStacked() {
273
279
stack, err := db.GetStack(mw.db, pr.StackId)
274
280
if err != nil {
275
-
log.Println("failed to get stack", err)
281
+
l.Error("failed to get stack", "err", err)
276
282
return
277
283
}
278
284
abandonedPulls, err := db.GetAbandonedPulls(mw.db, pr.StackId)
279
285
if err != nil {
280
-
log.Println("failed to get abandoned pulls", err)
286
+
l.Error("failed to get abandoned pulls", "err", err)
281
287
return
282
288
}
283
289
···
292
298
293
299
// middleware that is tacked on top of /{user}/{repo}/issues/{issue}
294
300
func (mw Middleware) ResolveIssue(next http.Handler) http.Handler {
301
+
l := mw.logger.With("middleware", "ResolveIssue")
295
302
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
296
303
f, err := mw.repoResolver.Resolve(r)
297
304
if err != nil {
298
-
log.Println("failed to fully resolve repo", err)
305
+
l.Error("failed to fully resolve repo", "err", err)
299
306
w.WriteHeader(http.StatusNotFound)
300
307
mw.pages.ErrorKnot404(w)
301
308
return
···
304
311
issueIdStr := chi.URLParam(r, "issue")
305
312
issueId, err := strconv.Atoi(issueIdStr)
306
313
if err != nil {
307
-
log.Println("failed to fully resolve issue ID", err)
314
+
l.Error("failed to fully resolve issue ID", "err", err)
308
315
mw.pages.Error404(w)
309
316
return
310
317
}
311
318
312
319
issue, err := db.GetIssue(mw.db, f.RepoAt(), issueId)
313
320
if err != nil {
314
-
log.Println("failed to get issues", "err", err)
321
+
l.Error("failed to get issues", "err", err)
315
322
mw.pages.Error404(w)
316
323
return
317
324
}
···
330
337
func (mw Middleware) GoImport() middlewareFunc {
331
338
return func(next http.Handler) http.Handler {
332
339
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
340
+
l := mw.logger.With("middleware", "GoImport")
333
341
f, err := mw.repoResolver.Resolve(r)
334
342
if err != nil {
335
-
log.Println("failed to fully resolve repo", err)
343
+
l.Error("failed to fully resolve repo", "err", err)
336
344
w.WriteHeader(http.StatusNotFound)
337
345
mw.pages.ErrorKnot404(w)
338
346
return