Monorepo for Tangled
tangled.org
appview/repo: use slog logger in artifact handlers
Signed-off-by: oppiliappan <me@oppi.li>
author
oppiliappan
date
(Feb 2, 2026, 8:39 AM UTC)
commit
48a5e6a6
48a5e6a604664dfdb1bf1b194ded868cd74d4015
parent
ca47e44a
ca47e44a581efbfde589337cc33bb03ba533a4f5
change-id
ttpysklp
ttpysklpuslzlyrtmmlunooswsnnnxxq
+39
-30
+39
-30
appview/repo/artifact.go
+39
-30
appview/repo/artifact.go
···
5
5
"encoding/json"
6
6
"fmt"
7
7
"io"
8
-
"log"
9
8
"net/http"
10
9
"net/url"
11
10
"time"
···
31
30
32
31
// TODO: proper statuses here on early exit
33
32
func (rp *Repo) AttachArtifact(w http.ResponseWriter, r *http.Request) {
33
+
l := rp.logger.With("handler", "AttachArtifact")
34
+
34
35
user := rp.oauth.GetMultiAccountUser(r)
35
36
tagParam := chi.URLParam(r, "tag")
36
37
f, err := rp.repoResolver.Resolve(r)
37
38
if err != nil {
38
-
log.Println("failed to get repo and knot", err)
39
+
l.Error("failed to get repo and knot", "err", err)
39
40
rp.pages.Notice(w, "upload", "failed to upload artifact, error in repo resolution")
40
41
return
41
42
}
42
43
43
44
tag, err := rp.resolveTag(r.Context(), f, tagParam)
44
45
if err != nil {
45
-
log.Println("failed to resolve tag", err)
46
+
l.Error("failed to resolve tag", "err", err)
46
47
rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")
47
48
return
48
49
}
49
50
50
51
file, header, err := r.FormFile("artifact")
51
52
if err != nil {
52
-
log.Println("failed to upload artifact", err)
53
+
l.Error("failed to upload artifact", "err", err)
53
54
rp.pages.Notice(w, "upload", "failed to upload artifact")
54
55
return
55
56
}
···
57
58
58
59
client, err := rp.oauth.AuthorizedClient(r)
59
60
if err != nil {
60
-
log.Println("failed to get authorized client", err)
61
+
l.Error("failed to get authorized client", "err", err)
61
62
rp.pages.Notice(w, "upload", "failed to get authorized client")
62
63
return
63
64
}
64
65
65
66
uploadBlobResp, err := xrpc.RepoUploadBlob(r.Context(), client, file, header.Header.Get("Content-Type"))
66
67
if err != nil {
67
-
log.Println("failed to upload blob", err)
68
+
l.Error("failed to upload blob", "err", err)
68
69
rp.pages.Notice(w, "upload", "Failed to upload blob to your PDS. Try again later.")
69
70
return
70
71
}
71
72
72
-
log.Println("uploaded blob", humanize.Bytes(uint64(uploadBlobResp.Blob.Size)), uploadBlobResp.Blob.Ref.String())
73
+
l.Info("uploaded blob", "size", humanize.Bytes(uint64(uploadBlobResp.Blob.Size)), "blobRef", uploadBlobResp.Blob.Ref.String())
73
74
74
75
rkey := tid.TID()
75
76
createdAt := time.Now()
···
89
90
},
90
91
})
91
92
if err != nil {
92
-
log.Println("failed to create record", err)
93
+
l.Error("failed to create record", "err", err)
93
94
rp.pages.Notice(w, "upload", "Failed to create artifact record. Try again later.")
94
95
return
95
96
}
96
97
97
-
log.Println(putRecordResp.Uri)
98
+
l.Debug("created record for blob", "aturi", putRecordResp.Uri)
98
99
99
100
tx, err := rp.db.BeginTx(r.Context(), nil)
100
101
if err != nil {
101
-
log.Println("failed to start tx")
102
+
l.Error("failed to start tx")
102
103
rp.pages.Notice(w, "upload", "Failed to create artifact. Try again later.")
103
104
return
104
105
}
···
118
119
119
120
err = db.AddArtifact(tx, artifact)
120
121
if err != nil {
121
-
log.Println("failed to add artifact record to db", err)
122
+
l.Error("failed to add artifact record to db", "err", err)
122
123
rp.pages.Notice(w, "upload", "Failed to create artifact. Try again later.")
123
124
return
124
125
}
125
126
126
127
err = tx.Commit()
127
128
if err != nil {
128
-
log.Println("failed to add artifact record to db")
129
+
l.Error("failed to add artifact record to db")
129
130
rp.pages.Notice(w, "upload", "Failed to create artifact. Try again later.")
130
131
return
131
132
}
···
138
139
}
139
140
140
141
func (rp *Repo) DownloadArtifact(w http.ResponseWriter, r *http.Request) {
142
+
l := rp.logger.With("handler", "DownloadArtifact")
143
+
141
144
f, err := rp.repoResolver.Resolve(r)
142
145
if err != nil {
143
-
log.Println("failed to get repo and knot", err)
146
+
l.Error("failed to get repo and knot", "err", err)
144
147
http.Error(w, "failed to resolve repo", http.StatusInternalServerError)
145
148
return
146
149
}
···
150
153
151
154
tag, err := rp.resolveTag(r.Context(), f, tagParam)
152
155
if err != nil {
153
-
log.Println("failed to resolve tag", err)
156
+
l.Error("failed to resolve tag", "err", err)
154
157
rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")
155
158
return
156
159
}
···
162
165
orm.FilterEq("name", filename),
163
166
)
164
167
if err != nil {
165
-
log.Println("failed to get artifacts", err)
168
+
l.Error("failed to get artifacts", "err", err)
166
169
http.Error(w, "failed to get artifact", http.StatusInternalServerError)
167
170
return
168
171
}
169
172
170
173
if len(artifacts) != 1 {
171
-
log.Printf("too many or too few artifacts found")
174
+
l.Error("too many or too few artifacts found")
172
175
http.Error(w, "artifact not found", http.StatusNotFound)
173
176
return
174
177
}
···
177
180
178
181
ownerId, err := rp.idResolver.ResolveIdent(r.Context(), f.Did)
179
182
if err != nil {
180
-
log.Println("failed to resolve repo owner did", f.Did, err)
183
+
l.Error("failed to resolve repo owner did", f.Did, "err", err)
181
184
http.Error(w, "repository owner not found", http.StatusNotFound)
182
185
return
183
186
}
···
191
194
192
195
req, err := http.NewRequest(http.MethodGet, url.String(), nil)
193
196
if err != nil {
194
-
log.Println("failed to create request", err)
197
+
l.Error("failed to create request", "err", err)
195
198
http.Error(w, "failed to create request", http.StatusInternalServerError)
196
199
return
197
200
}
···
199
202
200
203
resp, err := http.DefaultClient.Do(req)
201
204
if err != nil {
202
-
log.Println("failed to make request", err)
205
+
l.Error("failed to make request", "err", err)
203
206
http.Error(w, "failed to make request to PDS", http.StatusInternalServerError)
204
207
return
205
208
}
···
215
218
216
219
// stream the body directly to the client
217
220
if _, err := io.Copy(w, resp.Body); err != nil {
218
-
log.Println("error streaming response to client:", err)
221
+
l.Error("error streaming response to client:", "err", err)
219
222
}
220
223
}
221
224
222
225
// TODO: proper statuses here on early exit
223
226
func (rp *Repo) DeleteArtifact(w http.ResponseWriter, r *http.Request) {
227
+
l := rp.logger.With("handler", "DeleteArtifact")
228
+
224
229
user := rp.oauth.GetMultiAccountUser(r)
225
230
tagParam := chi.URLParam(r, "tag")
226
231
filename := chi.URLParam(r, "file")
227
232
f, err := rp.repoResolver.Resolve(r)
228
233
if err != nil {
229
-
log.Println("failed to get repo and knot", err)
234
+
l.Error("failed to get repo and knot", "err", err)
230
235
return
231
236
}
232
237
···
241
246
orm.FilterEq("name", filename),
242
247
)
243
248
if err != nil {
244
-
log.Println("failed to get artifacts", err)
249
+
l.Error("failed to get artifacts", "err", err)
245
250
rp.pages.Notice(w, "remove", "Failed to delete artifact. Try again later.")
246
251
return
247
252
}
···
253
258
artifact := artifacts[0]
254
259
255
260
if user.Active.Did != artifact.Did {
256
-
log.Println("user not authorized to delete artifact", err)
261
+
l.Error("user not authorized to delete artifact", "err", err)
257
262
rp.pages.Notice(w, "remove", "Unauthorized deletion of artifact.")
258
263
return
259
264
}
···
264
269
Rkey: artifact.Rkey,
265
270
})
266
271
if err != nil {
267
-
log.Println("failed to get blob from pds", err)
272
+
l.Error("failed to get blob from pds", "err", err)
268
273
rp.pages.Notice(w, "remove", "Failed to remove blob from PDS.")
269
274
return
270
275
}
271
276
272
277
tx, err := rp.db.BeginTx(r.Context(), nil)
273
278
if err != nil {
274
-
log.Println("failed to start tx")
279
+
l.Error("failed to start tx")
275
280
rp.pages.Notice(w, "remove", "Failed to delete artifact. Try again later.")
276
281
return
277
282
}
···
283
288
orm.FilterEq("name", filename),
284
289
)
285
290
if err != nil {
286
-
log.Println("failed to remove artifact record from db", err)
291
+
l.Error("failed to remove artifact record from db", "err", err)
287
292
rp.pages.Notice(w, "remove", "Failed to delete artifact. Try again later.")
288
293
return
289
294
}
290
295
291
296
err = tx.Commit()
292
297
if err != nil {
293
-
log.Println("failed to remove artifact record from db")
298
+
l.Error("failed to remove artifact record from db")
294
299
rp.pages.Notice(w, "remove", "Failed to delete artifact. Try again later.")
295
300
return
296
301
}
302
+
303
+
l.Info("successfully deleted artifact", "tag", tagParam, "file", filename)
297
304
298
305
w.Write([]byte{})
299
306
}
300
307
301
308
func (rp *Repo) resolveTag(ctx context.Context, f *models.Repo, tagParam string) (*types.TagReference, error) {
309
+
l := rp.logger.With("handler", "resolveTag")
310
+
302
311
tagParam, err := url.QueryUnescape(tagParam)
303
312
if err != nil {
304
313
return nil, err
···
317
326
xrpcBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repo)
318
327
if err != nil {
319
328
if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
320
-
log.Println("failed to call XRPC repo.tags", xrpcerr)
329
+
l.Error("failed to call XRPC repo.tags", "err", xrpcerr)
321
330
return nil, xrpcerr
322
331
}
323
-
log.Println("failed to reach knotserver", err)
332
+
l.Error("failed to reach knotserver", "err", err)
324
333
return nil, err
325
334
}
326
335
327
336
var result types.RepoTagsResponse
328
337
if err := json.Unmarshal(xrpcBytes, &result); err != nil {
329
-
log.Println("failed to decode XRPC tags response", err)
338
+
l.Error("failed to decode XRPC tags response", "err", err)
330
339
return nil, err
331
340
}
332
341