diff --git a/internal/platform/httpx/httpx_test.go b/internal/platform/httpx/httpx_test.go index 16ac1318..1bd0d07b 100644 --- a/internal/platform/httpx/httpx_test.go +++ b/internal/platform/httpx/httpx_test.go @@ -4,6 +4,7 @@ import ( "bytes" "encoding/json" "errors" + "fmt" "io" "log/slog" "net/http" @@ -307,6 +308,25 @@ func TestWithUserWithoutIdentityIsAWiringError(t *testing.T) { assertError(t, rec, eb, http.StatusInternalServerError, "internal_error") } +// A 5xx tells the client only the safe message; the operator must still see +// why the dependency failed, so the cause goes to the log. +func TestUnavailableCauseIsLoggedButNotReturned(t *testing.T) { + logs := &bytes.Buffer{} + e := newEngine(t, logs) + e.GET("/down", func(c *gin.Context) { + cause := errors.New("dial tcp 10.0.0.7:5432: connect: connection refused") + httpx.Error(c, fmt.Errorf("select user: %w", apperr.Wrap(apperr.KindUnavailable, "database unavailable", cause))) + }) + rec, eb := do(t, e, http.MethodGet, "/down", "", nil) + assertError(t, rec, eb, http.StatusServiceUnavailable, "unavailable") + if strings.Contains(rec.Body.String(), "connection refused") { + t.Fatalf("cause leaked to the client: %s", rec.Body.String()) + } + if !strings.Contains(logs.String(), "connection refused") || !strings.Contains(logs.String(), eb.Error.RequestID) { + t.Fatalf("log must carry the cause and the request id, got:\n%s", logs.String()) + } +} + // Everything below Timeout sees one deadline, so waiting on a dependency // ends with the request instead of holding the client. func TestTimeoutBoundsTheRequestContext(t *testing.T) { diff --git a/internal/platform/httpx/respond.go b/internal/platform/httpx/respond.go index f28ac418..c89e9712 100644 --- a/internal/platform/httpx/respond.go +++ b/internal/platform/httpx/respond.go @@ -1,6 +1,7 @@ package httpx import ( + "errors" "net/http" "time" @@ -52,7 +53,9 @@ func Fail(c *gin.Context, status int, code, message string) { // Error maps an application error to its status. Anything that is not an // application error is logged with its text and reported as an opaque 500, -// so internal details never reach the client. +// so internal details never reach the client. A known error answered with a +// 5xx (a dependency outage) shows the client only its safe message, and its +// cause goes to the log for the operator. func Error(c *gin.Context, err error) { mapped, known := kinds[apperr.KindOf(err)] if !known { @@ -60,6 +63,13 @@ func Error(c *gin.Context, err error) { Fail(c, http.StatusInternalServerError, "internal_error", "internal error") return } + if mapped.status >= http.StatusInternalServerError { + attrs := []any{"request_id", RequestID(c), "error", err.Error()} + if e, ok := errors.AsType[*apperr.Error](err); ok && e.Cause != nil { + attrs = append(attrs, "cause", e.Cause.Error()) + } + logger(c).Error("request failed", attrs...) + } Fail(c, mapped.status, mapped.code, err.Error()) }