forked from
tangled.org/core
Mirror of @tangled.org/core. Running on a Raspberry Pi Zero 2 (Please be gentle).
knotserver: improve the logging situation
Signed-off-by: oppiliappan <me@oppi.li>
authored by
oppiliappan
and committed by
Tangled
3ebdcdbd
57573097
+109
-47
+6
-3
cmd/knot/main.go
+6
-3
cmd/knot/main.go
···
2
2
3
3
import (
4
4
"context"
5
+
"log/slog"
5
6
"os"
6
7
7
8
"github.com/urfave/cli/v3"
···
10
9
"tangled.org/core/hook"
11
10
"tangled.org/core/keyfetch"
12
11
"tangled.org/core/knotserver"
13
-
"tangled.org/core/log"
12
+
tlog "tangled.org/core/log"
14
13
)
15
14
16
15
func main() {
···
25
24
},
26
25
}
27
26
27
+
logger := tlog.New("knot")
28
+
slog.SetDefault(logger)
29
+
28
30
ctx := context.Background()
29
-
logger := log.New("knot")
30
-
ctx = log.IntoContext(ctx, logger.With("command", cmd.Name))
31
+
ctx = tlog.IntoContext(ctx, logger)
31
32
32
33
if err := cmd.Run(ctx, os.Args); err != nil {
33
34
logger.Error(err.Error())
+2
-3
knotserver/events.go
+2
-3
knotserver/events.go
···
8
8
"time"
9
9
10
10
"github.com/gorilla/websocket"
11
+
"tangled.org/core/log"
11
12
)
12
13
13
14
var upgrader = websocket.Upgrader{
···
17
16
}
18
17
19
18
func (h *Knot) Events(w http.ResponseWriter, r *http.Request) {
20
-
l := h.l.With("handler", "OpLog")
19
+
l := log.SubLogger(h.l, "eventstream")
21
20
l.Debug("received new connection")
22
21
23
22
conn, err := upgrader.Upgrade(w, r, nil)
···
76
75
}
77
76
case <-time.After(30 * time.Second):
78
77
// send a keep-alive
79
-
l.Debug("sent keepalive")
80
78
if err = conn.WriteControl(websocket.PingMessage, []byte{}, time.Now().Add(time.Second)); err != nil {
81
79
l.Error("failed to write control", "err", err)
82
80
}
···
89
89
h.l.Error("failed to fetch events from db", "err", err, "cursor", cursor)
90
90
return err
91
91
}
92
-
h.l.Debug("ops", "ops", events)
93
92
94
93
for _, event := range events {
95
94
// first extract the inner json into a map
+18
-18
knotserver/git.go
+18
-18
knotserver/git.go
···
13
13
"tangled.org/core/knotserver/git/service"
14
14
)
15
15
16
-
func (d *Knot) InfoRefs(w http.ResponseWriter, r *http.Request) {
16
+
func (h *Knot) InfoRefs(w http.ResponseWriter, r *http.Request) {
17
17
did := chi.URLParam(r, "did")
18
18
name := chi.URLParam(r, "name")
19
19
repoName, err := securejoin.SecureJoin(did, name)
20
20
if err != nil {
21
21
gitError(w, "repository not found", http.StatusNotFound)
22
-
d.l.Error("git: failed to secure join repo path", "handler", "InfoRefs", "error", err)
22
+
h.l.Error("git: failed to secure join repo path", "handler", "InfoRefs", "error", err)
23
23
return
24
24
}
25
25
26
-
repoPath, err := securejoin.SecureJoin(d.c.Repo.ScanPath, repoName)
26
+
repoPath, err := securejoin.SecureJoin(h.c.Repo.ScanPath, repoName)
27
27
if err != nil {
28
28
gitError(w, "repository not found", http.StatusNotFound)
29
-
d.l.Error("git: failed to secure join repo path", "handler", "InfoRefs", "error", err)
29
+
h.l.Error("git: failed to secure join repo path", "handler", "InfoRefs", "error", err)
30
30
return
31
31
}
32
32
···
46
46
47
47
if err := cmd.InfoRefs(); err != nil {
48
48
gitError(w, err.Error(), http.StatusInternalServerError)
49
-
d.l.Error("git: process failed", "handler", "InfoRefs", "service", serviceName, "error", err)
49
+
h.l.Error("git: process failed", "handler", "InfoRefs", "service", serviceName, "error", err)
50
50
return
51
51
}
52
52
case "git-receive-pack":
53
-
d.RejectPush(w, r, name)
53
+
h.RejectPush(w, r, name)
54
54
default:
55
55
gitError(w, fmt.Sprintf("service unsupported: '%s'", serviceName), http.StatusForbidden)
56
56
}
57
57
}
58
58
59
-
func (d *Knot) UploadPack(w http.ResponseWriter, r *http.Request) {
59
+
func (h *Knot) UploadPack(w http.ResponseWriter, r *http.Request) {
60
60
did := chi.URLParam(r, "did")
61
61
name := chi.URLParam(r, "name")
62
-
repo, err := securejoin.SecureJoin(d.c.Repo.ScanPath, filepath.Join(did, name))
62
+
repo, err := securejoin.SecureJoin(h.c.Repo.ScanPath, filepath.Join(did, name))
63
63
if err != nil {
64
64
gitError(w, err.Error(), http.StatusInternalServerError)
65
-
d.l.Error("git: failed to secure join repo path", "handler", "UploadPack", "error", err)
65
+
h.l.Error("git: failed to secure join repo path", "handler", "UploadPack", "error", err)
66
66
return
67
67
}
68
68
···
77
77
gzipReader, err := gzip.NewReader(r.Body)
78
78
if err != nil {
79
79
gitError(w, err.Error(), http.StatusInternalServerError)
80
-
d.l.Error("git: failed to create gzip reader", "handler", "UploadPack", "error", err)
80
+
h.l.Error("git: failed to create gzip reader", "handler", "UploadPack", "error", err)
81
81
return
82
82
}
83
83
defer gzipReader.Close()
···
88
88
w.Header().Set("Connection", "Keep-Alive")
89
89
w.Header().Set("Cache-Control", "no-cache, max-age=0, must-revalidate")
90
90
91
-
d.l.Info("git: executing git-upload-pack", "handler", "UploadPack", "repo", repo)
91
+
h.l.Info("git: executing git-upload-pack", "handler", "UploadPack", "repo", repo)
92
92
93
93
cmd := service.ServiceCommand{
94
94
GitProtocol: r.Header.Get("Git-Protocol"),
···
100
100
w.WriteHeader(http.StatusOK)
101
101
102
102
if err := cmd.UploadPack(); err != nil {
103
-
d.l.Error("git: failed to execute git-upload-pack", "handler", "UploadPack", "error", err)
103
+
h.l.Error("git: failed to execute git-upload-pack", "handler", "UploadPack", "error", err)
104
104
return
105
105
}
106
106
}
107
107
108
-
func (d *Knot) ReceivePack(w http.ResponseWriter, r *http.Request) {
108
+
func (h *Knot) ReceivePack(w http.ResponseWriter, r *http.Request) {
109
109
did := chi.URLParam(r, "did")
110
110
name := chi.URLParam(r, "name")
111
-
_, err := securejoin.SecureJoin(d.c.Repo.ScanPath, filepath.Join(did, name))
111
+
_, err := securejoin.SecureJoin(h.c.Repo.ScanPath, filepath.Join(did, name))
112
112
if err != nil {
113
113
gitError(w, err.Error(), http.StatusForbidden)
114
-
d.l.Error("git: failed to secure join repo path", "handler", "ReceivePack", "error", err)
114
+
h.l.Error("git: failed to secure join repo path", "handler", "ReceivePack", "error", err)
115
115
return
116
116
}
117
117
118
-
d.RejectPush(w, r, name)
118
+
h.RejectPush(w, r, name)
119
119
}
120
120
121
-
func (d *Knot) RejectPush(w http.ResponseWriter, r *http.Request, unqualifiedRepoName string) {
121
+
func (h *Knot) RejectPush(w http.ResponseWriter, r *http.Request, unqualifiedRepoName string) {
122
122
// A text/plain response will cause git to print each line of the body
123
123
// prefixed with "remote: ".
124
124
w.Header().Set("content-type", "text/plain; charset=UTF-8")
···
131
131
ownerHandle := r.Header.Get("x-tangled-repo-owner-handle")
132
132
ownerHandle = strings.TrimPrefix(ownerHandle, "@")
133
133
if ownerHandle != "" && !strings.ContainsAny(ownerHandle, ":") {
134
-
hostname := d.c.Server.Hostname
134
+
hostname := h.c.Server.Hostname
135
135
if strings.Contains(hostname, ":") {
136
136
hostname = strings.Split(hostname, ":")[0]
137
137
}
+4
-1
knotserver/internal.go
+4
-1
knotserver/internal.go
···
20
20
"tangled.org/core/knotserver/config"
21
21
"tangled.org/core/knotserver/db"
22
22
"tangled.org/core/knotserver/git"
23
+
"tangled.org/core/log"
23
24
"tangled.org/core/notifier"
24
25
"tangled.org/core/rbac"
25
26
"tangled.org/core/workflow"
···
315
314
return h.db.InsertEvent(event, h.n)
316
315
}
317
316
318
-
func Internal(ctx context.Context, c *config.Config, db *db.DB, e *rbac.Enforcer, l *slog.Logger, n *notifier.Notifier) http.Handler {
317
+
func Internal(ctx context.Context, c *config.Config, db *db.DB, e *rbac.Enforcer, n *notifier.Notifier) http.Handler {
319
318
r := chi.NewRouter()
319
+
l := log.FromContext(ctx)
320
+
l = log.SubLogger(l, "internal")
320
321
321
322
h := InternalHandle{
322
323
db,
+35
knotserver/middleware.go
+35
knotserver/middleware.go
···
1
+
package knotserver
2
+
3
+
import (
4
+
"log/slog"
5
+
"net/http"
6
+
"time"
7
+
)
8
+
9
+
func (h *Knot) RequestLogger(next http.Handler) http.Handler {
10
+
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
11
+
start := time.Now()
12
+
13
+
next.ServeHTTP(w, r)
14
+
15
+
// Build query params as slog.Attrs for the group
16
+
queryParams := r.URL.Query()
17
+
queryAttrs := make([]any, 0, len(queryParams))
18
+
for key, values := range queryParams {
19
+
if len(values) == 1 {
20
+
queryAttrs = append(queryAttrs, slog.String(key, values[0]))
21
+
} else {
22
+
queryAttrs = append(queryAttrs, slog.Any(key, values))
23
+
}
24
+
}
25
+
26
+
h.l.LogAttrs(r.Context(), slog.LevelInfo, "",
27
+
slog.Group("request",
28
+
slog.String("method", r.Method),
29
+
slog.String("path", r.URL.Path),
30
+
slog.Group("query", queryAttrs...),
31
+
slog.Duration("duration", time.Since(start)),
32
+
),
33
+
)
34
+
})
35
+
}
+16
-9
knotserver/router.go
+16
-9
knotserver/router.go
···
12
12
"tangled.org/core/knotserver/config"
13
13
"tangled.org/core/knotserver/db"
14
14
"tangled.org/core/knotserver/xrpc"
15
-
tlog "tangled.org/core/log"
15
+
"tangled.org/core/log"
16
16
"tangled.org/core/notifier"
17
17
"tangled.org/core/rbac"
18
18
"tangled.org/core/xrpc/serviceauth"
···
28
28
resolver *idresolver.Resolver
29
29
}
30
30
31
-
func Setup(ctx context.Context, c *config.Config, db *db.DB, e *rbac.Enforcer, jc *jetstream.JetstreamClient, l *slog.Logger, n *notifier.Notifier) (http.Handler, error) {
32
-
r := chi.NewRouter()
33
-
31
+
func Setup(ctx context.Context, c *config.Config, db *db.DB, e *rbac.Enforcer, jc *jetstream.JetstreamClient, n *notifier.Notifier) (http.Handler, error) {
34
32
h := Knot{
35
33
c: c,
36
34
db: db,
37
35
e: e,
38
-
l: l,
36
+
l: log.FromContext(ctx),
39
37
jc: jc,
40
38
n: n,
41
39
resolver: idresolver.DefaultResolver(),
···
65
67
return nil, fmt.Errorf("failed to start jetstream: %w", err)
66
68
}
67
69
70
+
return h.Router(), nil
71
+
}
72
+
73
+
func (h *Knot) Router() http.Handler {
74
+
r := chi.NewRouter()
75
+
76
+
r.Use(h.RequestLogger)
77
+
68
78
r.Get("/", func(w http.ResponseWriter, r *http.Request) {
69
79
w.Write([]byte("This is a knot server. More info at https://tangled.sh"))
70
80
})
···
92
86
// Socket that streams git oplogs
93
87
r.Get("/events", h.Events)
94
88
95
-
return r, nil
89
+
return r
96
90
}
97
91
98
92
func (h *Knot) XrpcRouter() http.Handler {
99
-
logger := tlog.New("knots")
100
-
101
93
serviceAuth := serviceauth.NewServiceAuth(h.l, h.resolver, h.c.Server.Did().String())
94
+
95
+
l := log.SubLogger(h.l, "xrpc")
102
96
103
97
xrpc := &xrpc.Xrpc{
104
98
Config: h.c,
105
99
Db: h.db,
106
100
Ingester: h.jc,
107
101
Enforcer: h.e,
108
-
Logger: logger,
102
+
Logger: l,
109
103
Notifier: h.n,
110
104
Resolver: h.resolver,
111
105
ServiceAuth: serviceAuth,
112
106
}
107
+
113
108
return xrpc.Router()
114
109
}
115
110
+5
-4
knotserver/server.go
+5
-4
knotserver/server.go
···
43
43
44
44
func Run(ctx context.Context, cmd *cli.Command) error {
45
45
logger := log.FromContext(ctx)
46
-
iLogger := log.New("knotserver/internal")
46
+
logger = log.SubLogger(logger, cmd.Name)
47
+
ctx = log.IntoContext(ctx, logger)
47
48
48
49
c, err := config.Load(ctx)
49
50
if err != nil {
···
81
80
tangled.KnotMemberNSID,
82
81
tangled.RepoPullNSID,
83
82
tangled.RepoCollaboratorNSID,
84
-
}, nil, logger, db, true, c.Server.LogDids)
83
+
}, nil, log.SubLogger(logger, "jetstream"), db, true, c.Server.LogDids)
85
84
if err != nil {
86
85
logger.Error("failed to setup jetstream", "error", err)
87
86
}
88
87
89
88
notifier := notifier.New()
90
89
91
-
mux, err := Setup(ctx, c, db, e, jc, logger, ¬ifier)
90
+
mux, err := Setup(ctx, c, db, e, jc, ¬ifier)
92
91
if err != nil {
93
92
return fmt.Errorf("failed to setup server: %w", err)
94
93
}
95
94
96
-
imux := Internal(ctx, c, db, e, iLogger, ¬ifier)
95
+
imux := Internal(ctx, c, db, e, ¬ifier)
97
96
98
97
logger.Info("starting internal server", "address", c.Server.InternalListenAddr)
99
98
go http.ListenAndServe(c.Server.InternalListenAddr, imux)
+23
-9
log/log.go
+23
-9
log/log.go
···
4
4
"context"
5
5
"log/slog"
6
6
"os"
7
+
8
+
"github.com/charmbracelet/log"
7
9
)
8
10
9
-
// NewHandler sets up a new slog.Handler with the service name
10
-
// as an attribute
11
11
func NewHandler(name string) slog.Handler {
12
-
handler := slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
13
-
Level: slog.LevelDebug,
12
+
return log.NewWithOptions(os.Stderr, log.Options{
13
+
ReportTimestamp: true,
14
+
Prefix: name,
15
+
Level: log.DebugLevel,
14
16
})
15
-
16
-
var attrs []slog.Attr
17
-
attrs = append(attrs, slog.Attr{Key: "service", Value: slog.StringValue(name)})
18
-
handler.WithAttrs(attrs)
19
-
return handler
20
17
}
21
18
22
19
func New(name string) *slog.Logger {
···
45
48
}
46
49
47
50
return slog.Default()
51
+
}
52
+
53
+
// sublogger derives a new logger from an existing one by appending a suffix to its prefix.
54
+
func SubLogger(base *slog.Logger, suffix string) *slog.Logger {
55
+
// try to get the underlying charmbracelet logger
56
+
if cl, ok := base.Handler().(*log.Logger); ok {
57
+
prefix := cl.GetPrefix()
58
+
if prefix != "" {
59
+
prefix = prefix + "/" + suffix
60
+
} else {
61
+
prefix = suffix
62
+
}
63
+
return slog.New(NewHandler(prefix))
64
+
}
65
+
66
+
// Fallback: no known handler type
67
+
return slog.New(NewHandler(suffix))
48
68
}