mirror of
https://github.com/tiennm99/miti99bot.git
synced 2026-06-09 04:19:43 +00:00
tiennm99
3aab95daf0
Phase 11 partial of the go-port-cloud-run plan. Code-side
observability hooks ready ahead of Phase 01 GCP rollout.
- internal/server/log_middleware.go: HTTP middleware that wraps the
router and emits {msg:"req", method, path, status, ms} per
request. statusRecorder defaults to 200 when the inner handler
doesn't call WriteHeader (Go writes 200 implicitly on first body
write). Wired into server.New so /, /webhook, /cron/* all log.
- internal/metrics/counters.go: in-memory Registry with
IncCommand/IncError/IncAI. Atomic Int64 per name + RWMutex on the
map; steady-state increments are mutex-free. Periodic Run flushes
via the project logger every 60s and one final flush on ctx done.
Empty flush is silent (no-noise default).
- Dispatcher instrumented: every command invocation calls
metrics.IncCommand; every handler error calls
metrics.IncError("handler-error"). Logger keeps the full error
detail; counters keep the rate.
- cmd/server/main.go: go metrics.Run(rootCtx) so the flush loop
cancels with SIGTERM and emits the trailing window before exit.
Test coverage: 12 new tests (7 metrics, 3 middleware, 2 default-
registry round-trip). go test -race -count=1 ./... clean
(20 packages); golangci-lint clean.
Soak / cold-start measurement / log-based metrics setup deferred to
post-deployment (Phase 01 prerequisite).
53 lines
1.4 KiB
Go
53 lines
1.4 KiB
Go
package server
|
|
|
|
import (
|
|
"net/http"
|
|
"time"
|
|
|
|
"github.com/tiennm99/miti99bot-go/internal/log"
|
|
)
|
|
|
|
// statusRecorder wraps http.ResponseWriter to capture the final status
|
|
// code. http.ResponseWriter doesn't expose what was written; the middleware
|
|
// needs the status to log a per-request `req` line.
|
|
type statusRecorder struct {
|
|
http.ResponseWriter
|
|
status int
|
|
}
|
|
|
|
func (r *statusRecorder) WriteHeader(code int) {
|
|
r.status = code
|
|
r.ResponseWriter.WriteHeader(code)
|
|
}
|
|
|
|
// status returns the recorded status code, defaulting to 200 when no
|
|
// explicit WriteHeader was called (Go's net/http implicitly writes 200 on
|
|
// the first body write).
|
|
func (r *statusRecorder) effectiveStatus() int {
|
|
if r.status == 0 {
|
|
return http.StatusOK
|
|
}
|
|
return r.status
|
|
}
|
|
|
|
// LogRequests wraps an http.Handler with a request log line:
|
|
//
|
|
// {"msg":"req","method":"POST","path":"/webhook","status":200,"ms":12}
|
|
//
|
|
// Cloud Logging filters on `jsonPayload.msg=req AND jsonPayload.status>=500`
|
|
// for 5xx-rate alerting. Mirrors the JS source's index.js shape so existing
|
|
// dashboards keep working post-cutover.
|
|
func LogRequests(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
rec := &statusRecorder{ResponseWriter: w}
|
|
next.ServeHTTP(rec, r)
|
|
log.Info("req",
|
|
"method", r.Method,
|
|
"path", r.URL.Path,
|
|
"status", rec.effectiveStatus(),
|
|
"ms", time.Since(start).Milliseconds(),
|
|
)
|
|
})
|
|
}
|