%s
", message); err != nil { - logging.Event(ctx, slog.Default(), slog.LevelWarn, "mcp.operation.warn", "写入 OAuth 授权结果失败", "module", "mcp", "operation", "Callback", "connector_id", id, "credential_id", credential, "failure_reason", "response_write_failed", "error_type", fmt.Sprintf("%T", err)) + logging.Event(ctx, slog.Default(), slog.LevelWarn, "mcp.operation.warn", "写入 OAuth 授权结果失败", "module", "mcp", "operation", "Callback", "connector_id", id, "credential_id", credential, "failure_reason", "response_write_failed", "error_type", fmt.Sprintf("%T", err), "error", err) } } @@ -372,39 +378,38 @@ type tokenExchangeError struct { func (e tokenExchangeError) Error() string { return e.reason } -// 上游及回调错误可能携带 URL 查询串、授权码或 Token，仅输出受控分类与状态。 func safeMCPFailure(err error) []any { if exchangeErr, ok := errors.AsType[tokenExchangeError](err); ok { if exchangeErr.status != 0 { - return []any{"reason", exchangeErr.reason, "upstream_status", exchangeErr.status} + return []any{"error", err, "reason", exchangeErr.reason, "upstream_status", exchangeErr.status} } - return []any{"reason", exchangeErr.reason} + return []any{"error", err, "reason", exchangeErr.reason} } if failure, ok := errors.AsType[*resource.Error](err); ok { - return []any{"reason", failure.Code, "status", failure.Status} + return []any{"error", err, "reason", failure.Code, "status", failure.Status} } if upstream, ok := errors.AsType[remoteStatus](err); ok { - return []any{"reason", "upstream_http_error", "upstream_status", int(upstream)} + return []any{"error", err, "reason", "upstream_http_error", "upstream_status", int(upstream)} } if errors.Is(err, context.DeadlineExceeded) { - return []any{"reason", "timeout"} + return []any{"error", err, "reason", "timeout"} } if errors.Is(err, context.Canceled) { - return []any{"reason", "canceled"} + return []any{"error", err, "reason", "canceled"} } if network, ok := errors.AsType[net.Error](err); ok { - return []any{"reason", "network_error", "timeout", network.Timeout()} + return []any{"error", err, "reason", "network_error", "timeout", network.Timeout()} } if _, ok := errors.AsType[*url.Error](err); ok { - return []any{"reason", "transport_error"} + return []any{"error", err, "reason", "transport_error"} } if databaseErr, ok := errors.AsType[*pgconn.PgError](err); ok { - return []any{"reason", "database_error", "sqlstate", databaseErr.Code} + return []any{"error", err, "reason", "database_error", "sqlstate", databaseErr.Code} } if errors.Is(err, pgx.ErrNoRows) { - return []any{"error", pgx.ErrNoRows} + return []any{"error", err} } - return []any{"reason", "internal_error", "error_type", fmt.Sprintf("%T", err)} + return []any{"error", err, "reason", "internal_error"} } type configuredProxyKey struct{} @@ -444,6 +449,7 @@ func exchangeWithProxy(ctx context.Context, c resource.Object, v url.Values, pro defer cancel() req, err := http.NewRequestWithContext(ctx, "POST", o.TokenURL, strings.NewReader(v.Encode())) if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "mcp", "operation", "exchangeWithProxy", "error", err) return tokens{}, tokenExchangeError{reason: "invalid_token_url"} } if o.TokenAuthMethod == "client_secret_basic" { @@ -473,6 +479,7 @@ func exchangeWithProxy(ctx context.Context, c resource.Object, v url.Values, pro }() data, err := io.ReadAll(io.LimitReader(resp.Body, (1<<20)+1)) if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "mcp", "operation", "exchangeWithProxy", "error", err) return tokens{}, tokenExchangeError{reason: "response_read_error", status: resp.StatusCode} } if len(data) > 1<<20 { @@ -489,6 +496,7 @@ func exchangeWithProxy(ctx context.Context, c resource.Object, v url.Values, pro if json.Unmarshal(data, &payload) != nil { form, err = url.ParseQuery(string(data)) if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "mcp", "operation", "exchangeWithProxy", "error", err) return tokens{}, tokenExchangeError{reason: "invalid_token_response", status: resp.StatusCode} } payload.Access = form.Get("access_token") @@ -509,6 +517,7 @@ func exchangeWithProxy(ctx context.Context, c resource.Object, v url.Values, pro if expires := form.Get("expires_in"); expires != "" { seconds, err := strconv.ParseInt(expires, 10, 64) if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "mcp", "operation", "exchangeWithProxy", "error", err) return tokens{}, tokenExchangeError{reason: "invalid_expires_in", status: resp.StatusCode} } payload.Expires = seconds diff --git a/monkeyai/backend/internal/mcp/oauth_test.go b/monkeyai/backend/internal/mcp/oauth_test.go index d57500d45..1b5fe75b4 100644 --- a/monkeyai/backend/internal/mcp/oauth_test.go +++ b/monkeyai/backend/internal/mcp/oauth_test.go @@ -89,10 +89,10 @@ func TestExchangeRejectsHTTPProxyTarget(t *testing.T) { } } -func TestOAuthFailureDoesNotExposeURL(t *testing.T) { +func TestOAuthFailurePreservesOriginalError(t *testing.T) { err := &url.Error{Op: "POST", URL: "https://oauth.example/token?code=private-code", Err: errors.New("private-token")} logged := fmt.Sprint(safeMCPFailure(err)) - if strings.Contains(logged, "private-code") || strings.Contains(logged, "private-token") || !strings.Contains(logged, "network_error") { + if !strings.Contains(logged, err.Error()) || !strings.Contains(logged, "network_error") { t.Fatalf("上游错误分类不安全: %s", logged) } } diff --git a/monkeyai/backend/internal/mcp/proxy.go b/monkeyai/backend/internal/mcp/proxy.go index e16c5d3c5..c0588b1ad 100644 --- a/monkeyai/backend/internal/mcp/proxy.go +++ b/monkeyai/backend/internal/mcp/proxy.go @@ -4,6 +4,7 @@ import ( "context" "crypto/tls" "fmt" + "log/slog" "net" "net/http" @@ -16,6 +17,9 @@ func (p checkedProxy) RoundTrip(req *http.Request) (*http.Response, error) { name := req.URL.Hostname() ips, err := net.DefaultResolver.LookupNetIP(req.Context(), "ip", name) if err != nil || len(ips) == 0 { + if err != nil { + slog.WarnContext(req.Context(), "操作失败", "module", "mcp", "operation", "RoundTrip", "error", err) + } return nil, fmt.Errorf("无法解析连接目标") } for _, ip := range ips { diff --git a/monkeyai/backend/internal/mcp/registration.go b/monkeyai/backend/internal/mcp/registration.go index 0628a0cb1..53b351aec 100644 --- a/monkeyai/backend/internal/mcp/registration.go +++ b/monkeyai/backend/internal/mcp/registration.go @@ -5,13 +5,14 @@ import ( "context" "encoding/json" "fmt" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "io" "log/slog" "net/http" "strings" "time" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/mcp/sqlc" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/mcp/sqlc/connector" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resource" @@ -107,6 +108,7 @@ func registerOAuthClientWithClient(ctx context.Context, o oauthConfig, redirect } req, err := http.NewRequestWithContext(ctx, http.MethodPost, o.RegistrationURL, bytes.NewReader(data)) if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "mcp", "operation", "registerOAuthClientWithClient", "error", err) return fail() } req.Header.Set("Content-Type", "application/json") @@ -114,6 +116,7 @@ func registerOAuthClientWithClient(ctx context.Context, o oauthConfig, redirect defer h.CloseIdleConnections() resp, err := h.Do(req) if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "mcp", "operation", "registerOAuthClientWithClient", "error", err) return fail() } defer func() { @@ -126,6 +129,9 @@ func registerOAuthClientWithClient(ctx context.Context, o oauthConfig, redirect } data, err = io.ReadAll(io.LimitReader(resp.Body, (1<<20)+1)) if err != nil || len(data) > 1<<20 { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "mcp", "operation", "registerOAuthClientWithClient", "error", err) + } return fail() } var result oauthRegistration diff --git a/monkeyai/backend/internal/mcp/remote.go b/monkeyai/backend/internal/mcp/remote.go index 4d8146079..60e0f2029 100644 --- a/monkeyai/backend/internal/mcp/remote.go +++ b/monkeyai/backend/internal/mcp/remote.go @@ -6,13 +6,14 @@ import ( "context" "encoding/json" "fmt" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "io" "log/slog" "mime" "net/http" "strings" "time" + + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" ) type remoteClient struct { @@ -87,6 +88,7 @@ func (c *remoteClient) call(ctx context.Context, id int, method string, params a } media, _, err := mime.ParseMediaType(response.Header.Get("Content-Type")) if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "mcp", "operation", "call", "error", err) return nil, fmt.Errorf("MCP 响应类型无效") } var data []byte @@ -120,6 +122,9 @@ func (c *remoteClient) call(ctx context.Context, id int, method string, params a case "application/json": data, err = io.ReadAll(io.LimitReader(response.Body, (4<<20)+1)) if err != nil || len(data) > 4<<20 { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "mcp", "operation", "call", "error", err) + } return nil, fmt.Errorf("MCP 响应超限或不完整") } default: @@ -132,6 +137,9 @@ func (c *remoteClient) call(ctx context.Context, id int, method string, params a Error json.RawMessage `json:"error"` } if err = json.Unmarshal(data, &reply); err != nil || reply.ID != id || reply.Version != "2.0" || (len(reply.Result) == 0) == (len(reply.Error) == 0) { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "mcp", "operation", "call", "error", err) + } return nil, fmt.Errorf("MCP 协议响应无效") } if len(reply.Error) > 0 { diff --git a/monkeyai/backend/internal/mcp/service.go b/monkeyai/backend/internal/mcp/service.go index e9f808295..a637d7941 100644 --- a/monkeyai/backend/internal/mcp/service.go +++ b/monkeyai/backend/internal/mcp/service.go @@ -3,11 +3,12 @@ package mcp import ( "context" "errors" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "log/slog" "net/http" "strings" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/billing" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/identity" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/mcp/sqlc" @@ -44,11 +45,11 @@ func NewService(store *resource.Store, publicURL string) *Service { s := &Service{Store: store, PublicURL: strings.TrimRight(publicURL, "/")} s.Connectors = resource.NewCRUD(store, resource.Definition{ Kind: "connector", Path: "/connectors", - Repository: func(q resource.Queryer) resource.Repository { return connector.New(q) }, - Fields: []string{"name", "description", "url", "authorization_mode", "authorization_method", "oauth_config", "oauth_client_secret", "auth_header_name", "proxy_id", "enabled", "config_revision", "connection_status"}, - UserFields: []string{"name", "description", "url", "authorization_mode", "authorization_method", "oauth_config", "oauth_client_secret", "tag_ids"}, - OverrideFields: []string{"name", "description", "url", "proxy_id", "authorization_mode", "authorization_method", "oauth_config", "oauth_client_secret", "auth_header_name", "tag_ids"}, - Hidden: []string{"oauth_client_secret", "icon_s3_key"}, + Repository: func(q resource.Queryer) resource.Repository { return connector.New(q) }, + Fields: []string{"name", "description", "url", "authorization_mode", "authorization_method", "oauth_config", "oauth_client_secret", "auth_header_name", "proxy_id", "enabled", "config_revision", "connection_status"}, + UserFields: []string{"name", "description", "url", "authorization_mode", "authorization_method", "oauth_config", "oauth_client_secret", "tag_ids"}, + OverrideFields: []string{"name", "description", "url", "proxy_id", "authorization_mode", "authorization_method", "oauth_config", "oauth_client_secret", "auth_header_name", "tag_ids"}, + Hidden: []string{"oauth_client_secret", "icon_s3_key"}, PrepareOverride: s.validateConnector, Validate: s.validateConnector, Decorate: s.decorateConnector, UserDecorate: userIcon, References: func(ctx context.Context, tx pgx.Tx, id string) ([]resource.Object, error) { @@ -79,6 +80,7 @@ func (s *Service) validateConnector(ctx context.Context, tx pgx.Tx, in, old reso return resource.Invalid("系统代理不可用") } if _, err := s.proxies.ProxyURL(ctx, id); err != nil { + slog.WarnContext(ctx, "操作失败", "module", "mcp", "operation", "validateConnector", "error", err) return resource.Invalid("系统代理不存在") } } @@ -281,6 +283,9 @@ func (s *Service) updateTool(w http.ResponseWriter, r *http.Request) { Credits billing.Amount `json:"credits_per_call"` } if err := resource.Decode(w, r, &in); err != nil || in.Enabled == nil || in.Credits < 0 { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "mcp", "operation", "updateTool", "error", err) + } resource.Fail(r.Context(), w, resource.Invalid("工具配置无效")) return } diff --git a/monkeyai/backend/internal/mcp/tools.go b/monkeyai/backend/internal/mcp/tools.go index f969590a0..e31a79a55 100644 --- a/monkeyai/backend/internal/mcp/tools.go +++ b/monkeyai/backend/internal/mcp/tools.go @@ -5,6 +5,7 @@ import ( "encoding/json" "errors" "fmt" + "log/slog" "net/http" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/identity" @@ -177,6 +178,7 @@ func (s *Service) testConnection(ctx context.Context, c, cred resource.Object, u _, err = queries.InvalidateTools(ctx, sqlc.InvalidateToolsParams{ConnectorID: c.String("id"), CredentialID: cred.String("id")}) for _, tool := range tools { if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "mcp", "operation", "testConnection", "error", err) break } schema, marshalErr := json.Marshal(tool.InputSchema) @@ -206,6 +208,7 @@ func (s *Service) testConnection(ctx context.Context, c, cred resource.Object, u return nil, err } if discoveryErr != nil { + slog.WarnContext(ctx, "操作失败", "module", "mcp", "operation", "testConnection", "error", discoveryErr) return nil, &resource.Error{Status: 502, Code: "upstream_error", Message: message} } return resource.Object{"credential_id": cred.String("id"), "connection_status": status, "tool_count": len(tools)}, nil diff --git a/monkeyai/backend/internal/mcp/transport.go b/monkeyai/backend/internal/mcp/transport.go index 9c3c233b5..3023b29cc 100644 --- a/monkeyai/backend/internal/mcp/transport.go +++ b/monkeyai/backend/internal/mcp/transport.go @@ -5,6 +5,7 @@ import ( "crypto/tls" "encoding/json" "fmt" + "log/slog" "net" "net/http" "net/netip" @@ -150,6 +151,7 @@ func discoverWithClient(ctx context.Context, target string, headers map[string]s NextCursor string `json:"nextCursor"` } if err = json.Unmarshal(data, &list); err != nil { + slog.WarnContext(ctx, "操作失败", "module", "mcp", "operation", "discoverWithClient", "error", err) return nil, fmt.Errorf("工具目录格式无效") } for _, t := range list.Tools { diff --git a/monkeyai/backend/internal/model/admin.go b/monkeyai/backend/internal/model/admin.go index 2463d890e..30d8f8002 100644 --- a/monkeyai/backend/internal/model/admin.go +++ b/monkeyai/backend/internal/model/admin.go @@ -4,10 +4,11 @@ import ( "context" "encoding/json" "errors" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "log/slog" "net/http" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/identity" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/rootgroup" "github.com/go-chi/chi/v5" @@ -54,6 +55,7 @@ func (s *Service) RegisterAdmin(router chi.Router) { func (s *Service) createModel(w http.ResponseWriter, r *http.Request) { var input SaveInput if err := decodeModelRequest(w, r, &input); err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "model", "operation", "createModel", "error", err) modelError(w, http.StatusBadRequest, "请求格式无效") return } @@ -69,6 +71,7 @@ func (s *Service) createModel(w http.ResponseWriter, r *http.Request) { func (s *Service) updateModel(w http.ResponseWriter, r *http.Request) { var input SaveInput if err := decodeModelRequest(w, r, &input); err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "model", "operation", "updateModel", "error", err) modelError(w, http.StatusBadRequest, "请求格式无效") return } @@ -92,6 +95,9 @@ func (s *Service) setModelEnabled(w http.ResponseWriter, r *http.Request) { Enabled *bool `json:"enabled"` } if err := decodeModelRequest(w, r, &input); err != nil || input.Enabled == nil { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "model", "operation", "setModelEnabled", "error", err) + } modelError(w, http.StatusBadRequest, "enabled 必须是布尔值") return } diff --git a/monkeyai/backend/internal/model/image.go b/monkeyai/backend/internal/model/image.go index 61ca90c57..e4672fa1e 100644 --- a/monkeyai/backend/internal/model/image.go +++ b/monkeyai/backend/internal/model/image.go @@ -3,6 +3,7 @@ package model import ( "encoding/json" "errors" + "log/slog" "slices" "strconv" "strings" @@ -56,6 +57,9 @@ func validateImageModel(item *Model) error { if len(item.ProviderOptions) != 0 { var options map[string]json.RawMessage if err := json.Unmarshal(item.ProviderOptions, &options); err != nil || options == nil { + if err != nil { + slog.Warn("操作失败", "module", "model", "operation", "validateImageModel", "error", err) + } return errors.New("provider_options 必须是 JSON 对象") } } @@ -112,6 +116,9 @@ func validRatio(value string) bool { func validateImagePricing(config *ImageConfig, pricing *ImagePricing) error { base, err := billing.ParseAmount(pricing.BaseCreditsPerImage) if err != nil || base < 0 { + if err != nil { + slog.Warn("操作失败", "module", "model", "operation", "validateImagePricing", "error", err) + } return errors.New("base_credits_per_image 必须是非负积分") } seen := make(map[string]bool, len(pricing.QualityMultipliers)) @@ -122,6 +129,9 @@ func validateImagePricing(config *ImageConfig, pricing *ImagePricing) error { seen[entry.Name] = true value, err := billing.ParseAmount(entry.Multiplier) if err != nil || value <= 0 { + if err != nil { + slog.Warn("操作失败", "module", "model", "operation", "validateImagePricing", "error", err) + } return errors.New("quality 倍率必须大于 0") } } diff --git a/monkeyai/backend/internal/model/page.go b/monkeyai/backend/internal/model/page.go index 44bce8111..2cc4cdbf3 100644 --- a/monkeyai/backend/internal/model/page.go +++ b/monkeyai/backend/internal/model/page.go @@ -4,11 +4,12 @@ import ( "context" "encoding/json" "errors" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "log/slog" "net/http" "strconv" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/database" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/model/sqlc" ) @@ -78,6 +79,9 @@ func (s *Service) listModels(w http.ResponseWriter, r *http.Request) { if raw := query.Get("limit"); raw != "" { limit, err = strconv.Atoi(raw) if err != nil || limit < 1 || limit > 500 { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "model", "operation", "listModels", "error", err) + } modelError(w, http.StatusBadRequest, "limit 必须在 1—500 之间") return } diff --git a/monkeyai/backend/internal/model/service.go b/monkeyai/backend/internal/model/service.go index 2b345c200..79e8ae419 100644 --- a/monkeyai/backend/internal/model/service.go +++ b/monkeyai/backend/internal/model/service.go @@ -3,12 +3,13 @@ package model import ( "context" "errors" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "log/slog" "net/url" "slices" "strings" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resource" ) @@ -222,6 +223,9 @@ func (s *Service) AgentModels(ctx context.Context, userID string, isAdmin bool) if item.Kind == KindVideo && item.VideoConfig != nil { cap, err := VideoCapabilitiesFor(item.Provider, item.ModelID) if err != nil || ValidateVideoCapabilities(item, cap) != nil { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "model", "operation", "AgentModels", "error", err) + } continue } videoConfig = &AgentVideoConfig{VideoConfig: *item.VideoConfig, @@ -272,6 +276,7 @@ func (s *Service) Resolve(ctx context.Context, credential, requestedModel string } userID, err := s.keys.Authenticate(ctx, credential, "model:invoke") if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "model", "operation", "Resolve", "error", err) return Target{}, ErrUnauthorized } item, err := s.repository.Resolve(ctx, userID, requestedModel) @@ -354,6 +359,9 @@ func modelFromInput(input SaveInput) (Model, error) { } parsed, err := url.Parse(item.BaseURL) if err != nil || (parsed.Scheme != "http" && parsed.Scheme != "https") || parsed.Hostname() == "" || parsed.User != nil { + if err != nil { + slog.Warn("操作失败", "module", "model", "operation", "modelFromInput", "error", err) + } return Model{}, errors.New("base_url 必须是有效的 HTTP(S) 地址") } if kind == KindVideo && (parsed.RawQuery != "" || parsed.Fragment != "") { diff --git a/monkeyai/backend/internal/model/video.go b/monkeyai/backend/internal/model/video.go index 812baf69e..2bba943e1 100644 --- a/monkeyai/backend/internal/model/video.go +++ b/monkeyai/backend/internal/model/video.go @@ -5,6 +5,7 @@ import ( "encoding/json" "errors" "fmt" + "log/slog" "slices" "strconv" "strings" @@ -33,7 +34,11 @@ func marshalVideoFields(item Model) ([]byte, []byte, error) { func videoValues(values ...any) []json.RawMessage { result := make([]json.RawMessage, 0, len(values)) for _, value := range values { - data, _ := json.Marshal(value) + data, err := json.Marshal(value) + if err != nil { + slog.Error("编码视频能力失败", "error", err) + continue + } result = append(result, data) } return result @@ -179,6 +184,7 @@ func userVideoPricing(kind Kind, provider Provider, modelID string, config *Vide } cap, err := VideoCapabilitiesFor(provider, modelID) if err != nil { + slog.Warn("操作失败", "module", "model", "operation", "userVideoPricing", "error", err) return nil } pricing := &VideoPricing{Rates: []VideoResolutionRate{}} @@ -290,6 +296,9 @@ func ValidateVideoCapabilities(item Model, cap VideoCapabilities) error { for _, entry := range item.VideoPricing.Rates { amount, err := billing.ParseAmount(entry.CreditsPerSecond) if !resolutions[entry.Resolution] || err != nil || amount < 0 { + if err != nil { + slog.Warn("操作失败", "module", "model", "operation", "ValidateVideoCapabilities", "error", err) + } return errors.New("视频清晰度或每秒积分无效") } delete(resolutions, entry.Resolution) @@ -428,12 +437,22 @@ func VideoMaxDuration(cap VideoCapabilities) (int64, error) { func VideoDuration(values map[string]json.RawMessage) (int64, error) { var seconds int64 if err := json.Unmarshal(values["duration_seconds"], &seconds); err != nil || seconds < 1 || seconds > billing.MaxVideoDurationMs/1000 { + if err != nil { + slog.Warn("操作失败", "module", "model", "operation", "VideoDuration", "error", err) + } return 0, errors.New("视频时长无效") } return seconds, nil } func VideoResolution(values map[string]json.RawMessage) string { - value, _ := strconv.Unquote(strings.TrimSpace(string(values["resolution"]))) + if len(values["resolution"]) == 0 { + return "" + } + value, err := strconv.Unquote(strings.TrimSpace(string(values["resolution"]))) + if err != nil { + slog.Error("解析视频分辨率失败", "error", err) + return "" + } return value } diff --git a/monkeyai/backend/internal/proxy/billing.go b/monkeyai/backend/internal/proxy/billing.go index 3cc666396..34a327eea 100644 --- a/monkeyai/backend/internal/proxy/billing.go +++ b/monkeyai/backend/internal/proxy/billing.go @@ -4,11 +4,12 @@ import ( "context" "encoding/json" "fmt" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "log/slog" "net/http" "time" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resource" ) @@ -96,6 +97,9 @@ func prepareRequest(body []byte, path string, limit int64, stream bool) ([]byte, options := map[string]json.RawMessage{} if b, ok := data["stream_options"]; ok { if err := json.Unmarshal(b, &options); err != nil || options == nil { + if err != nil { + slog.Warn("操作失败", "module", "proxy", "operation", "prepareRequest", "error", err) + } return nil, resource.Invalid("stream_options 无效") } } diff --git a/monkeyai/backend/internal/proxy/encoding.go b/monkeyai/backend/internal/proxy/encoding.go index 087436380..2c5cffe0c 100644 --- a/monkeyai/backend/internal/proxy/encoding.go +++ b/monkeyai/backend/internal/proxy/encoding.go @@ -1,6 +1,7 @@ package proxy import ( + "log/slog" "strconv" "strings" ) @@ -28,6 +29,9 @@ func negotiateEncoding(values []string) (string, bool) { } q, err := strconv.ParseFloat(strings.TrimSpace(weight), 64) if err != nil || !(q >= 0 && q <= 1) { + if err != nil { + slog.Warn("操作失败", "module", "proxy", "operation", "negotiateEncoding", "error", err) + } quality = 0 break } diff --git a/monkeyai/backend/internal/proxy/estimate.go b/monkeyai/backend/internal/proxy/estimate.go index c55c565c5..1fd76de33 100644 --- a/monkeyai/backend/internal/proxy/estimate.go +++ b/monkeyai/backend/internal/proxy/estimate.go @@ -4,6 +4,7 @@ import ( "bytes" "encoding/json" "fmt" + "log/slog" "strings" "sync" "unicode/utf8" @@ -15,11 +16,19 @@ const maxEstimateBytes = 32 << 20 var ( o200kCodec = sync.OnceValue(func() tokenizer.Codec { - codec, _ := tokenizer.Get(tokenizer.O200kBase) + codec, err := tokenizer.Get(tokenizer.O200kBase) + if err != nil { + slog.Error("加载分词器失败", "error", err) + return nil + } return codec }) cl100kCodec = sync.OnceValue(func() tokenizer.Codec { - codec, _ := tokenizer.Get(tokenizer.Cl100kBase) + codec, err := tokenizer.Get(tokenizer.Cl100kBase) + if err != nil { + slog.Error("加载分词器失败", "error", err) + return nil + } return codec }) ) @@ -44,6 +53,7 @@ func newTokenEstimate(pc *proxyContext) *tokenEstimate { var err error e.request, err = estimateObject(pc.requestBody) if err != nil { + slog.Warn("操作失败", "module", "proxy", "operation", "newTokenEstimate", "error", err) return nil } model := pc.target.UpstreamModel @@ -167,6 +177,7 @@ func (e *tokenEstimate) jsonPart(key string, value any) { } data, err := json.Marshal(value) if err != nil { + slog.Warn("操作失败", "module", "proxy", "operation", "jsonPart", "error", err) e.supported = false return } @@ -256,6 +267,9 @@ func (e *tokenEstimate) response(path string, data []byte) { } response, err := estimateObject(data) if err != nil || response == nil { + if err != nil { + slog.Warn("操作失败", "module", "proxy", "operation", "response", "error", err) + } e.supported = false return } @@ -300,6 +314,9 @@ func (e *tokenEstimate) event(path string, event sseEvent) { } data, err := estimateObject(event.Data) if err != nil || data == nil { + if err != nil { + slog.Warn("操作失败", "module", "proxy", "operation", "event", "error", err) + } e.supported = false return } diff --git a/monkeyai/backend/internal/proxy/observation.go b/monkeyai/backend/internal/proxy/observation.go index c88f84b77..973cf3d29 100644 --- a/monkeyai/backend/internal/proxy/observation.go +++ b/monkeyai/backend/internal/proxy/observation.go @@ -27,7 +27,6 @@ func (p *Proxy) logCall(ctx context.Context, pc *proxyContext, call Call, cause if ctx.Err() != nil && result == "failed" && (call.ErrorCode == "stream_interrupted" || call.ErrorCode == "upstream_connection_failed") { result, level = "canceled", slog.LevelDebug } - logging.CountCall(p.logger, result) attrs := []slog.Attr{slog.String("module", "proxy"), slog.String("operation", "proxy_request"), slog.String("model_id", pc.target.ModelID), slog.String("transaction_id", pc.reservation.ID), slog.String("response_id", call.RequestID), slog.String("result", result), slog.Bool("stream", pc.stream), diff --git a/monkeyai/backend/internal/proxy/observation_test.go b/monkeyai/backend/internal/proxy/observation_test.go index dd41038d0..369e42b68 100644 --- a/monkeyai/backend/internal/proxy/observation_test.go +++ b/monkeyai/backend/internal/proxy/observation_test.go @@ -32,11 +32,10 @@ func TestModelFailureObservedWithoutBillingOrRecorder(t *testing.T) { })) defer upstream.Close() var output bytes.Buffer - logs, _ := logging.NewRuntime(&output, slog.LevelDebug, logging.DefaultSettings()) - defer logs.Close() + logger := logging.New(&output, slog.LevelDebug) p := NewProxy(ResolverFunc(func(context.Context, string, string) (Target, error) { return Target{ModelID: "model-1", BaseURL: upstream.URL}, nil - }), logs.Logger()) + }), logger) body := `{"model":"test","messages":[],"stream":false}` if test.stream { body = `{"model":"test","messages":[],"stream":true}` @@ -44,7 +43,7 @@ func TestModelFailureObservedWithoutBillingOrRecorder(t *testing.T) { r := httptest.NewRequest("POST", "/v1/chat/completions", strings.NewReader(body)) r.Header.Set("Authorization", "Bearer private-key") response := httptest.NewRecorder() - logging.HTTP(logs.Logger())(p).ServeHTTP(response, r) + logging.HTTP(logger)(p).ServeHTTP(response, r) if err := p.Wait(t.Context()); err != nil { t.Fatal(err) } diff --git a/monkeyai/backend/internal/proxy/proxy.go b/monkeyai/backend/internal/proxy/proxy.go index f407eab56..8c4f853f7 100644 --- a/monkeyai/backend/internal/proxy/proxy.go +++ b/monkeyai/backend/internal/proxy/proxy.go @@ -166,11 +166,13 @@ func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) { } body, err := io.ReadAll(http.MaxBytesReader(w, r.Body, 32<<20)) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "proxy", "operation", "ServeHTTP", "error", err) http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest) return } meta, err := readRequestMeta(body) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "proxy", "operation", "ServeHTTP", "error", err) http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest) return } @@ -207,6 +209,7 @@ func (p *Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) { if target.UpstreamModel != "" && target.UpstreamModel != meta.Model { body, err = rewriteModel(body, target.UpstreamModel) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "proxy", "operation", "ServeHTTP", "error", err) http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest) return } @@ -281,6 +284,9 @@ func protocolForPath(requestPath string) string { func rewriteModel(body []byte, upstreamModel string) ([]byte, error) { var request map[string]json.RawMessage if err := json.Unmarshal(body, &request); err != nil || request == nil { + if err != nil { + slog.Warn("操作失败", "module", "proxy", "operation", "rewriteModel", "error", err) + } return nil, errors.New("请求体必须是 JSON 对象") } encoded, err := json.Marshal(upstreamModel) diff --git a/monkeyai/backend/internal/proxy/proxy_test.go b/monkeyai/backend/internal/proxy/proxy_test.go index 617428b34..fcfa151b9 100644 --- a/monkeyai/backend/internal/proxy/proxy_test.go +++ b/monkeyai/backend/internal/proxy/proxy_test.go @@ -304,7 +304,7 @@ func (r *usageRecorderStub) Record(_ context.Context, call Call) error { return nil } -func TestProxyErrorHandlerRedactsUpstreamError(t *testing.T) { +func TestProxyErrorHandlerLogsUpstreamError(t *testing.T) { var logs bytes.Buffer proxy := NewProxy(nil, slog.New(slog.NewTextHandler(&logs, nil))) pc := &proxyContext{target: Target{ModelID: "model-1"}, reservation: Reservation{ID: "transaction-1"}} @@ -316,7 +316,7 @@ func TestProxyErrorHandlerRedactsUpstreamError(t *testing.T) { t.Fatalf("代理错误响应不正确: %d %q", recorder.Code, recorder.Body.String()) } text := logs.String() - if !strings.Contains(text, "model-1") || !strings.Contains(text, "transaction-1") || !strings.Contains(text, "proxy_request") || strings.Contains(text, "upstream-token-and-private-response") { - t.Fatalf("代理日志缺少安全上下文或泄漏上游详情: %s", text) + if !strings.Contains(text, "model-1") || !strings.Contains(text, "transaction-1") || !strings.Contains(text, "proxy_request") || !strings.Contains(text, "upstream-token-and-private-response") { + t.Fatalf("代理日志缺少上下文或原始错误: %s", text) } } diff --git a/monkeyai/backend/internal/proxy/reconcile.go b/monkeyai/backend/internal/proxy/reconcile.go index dfd9d60c1..cf89ef7ff 100644 --- a/monkeyai/backend/internal/proxy/reconcile.go +++ b/monkeyai/backend/internal/proxy/reconcile.go @@ -4,11 +4,12 @@ import ( "context" "errors" "fmt" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "io" "log/slog" "net/http" "strings" + + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" ) type ResponseReconciliationState string @@ -77,8 +78,7 @@ func (r *ResponseReconciler) Reconcile(ctx context.Context, target Target, respo } defer func() { if closeErr := response.Body.Close(); closeErr != nil && ctx.Err() == nil && !errors.Is(closeErr, context.Canceled) && !errors.Is(closeErr, io.ErrClosedPipe) { - // 自定义 Transport 的关闭错误可能包含凭据或响应内容。 - logging.Event(ctx, slog.Default(), slog.LevelWarn, "proxy.operation.warn", "关闭上游对账响应失败", "module", "proxy", "operation", "Reconcile", "model_id", target.ModelID, "operation", "close_reconciliation_response", "error_type", fmt.Sprintf("%T", closeErr)) + logging.Event(ctx, slog.Default(), slog.LevelWarn, "proxy.operation.warn", "关闭上游对账响应失败", "module", "proxy", "operation", "Reconcile", "model_id", target.ModelID, "operation", "close_reconciliation_response", "error_type", fmt.Sprintf("%T", closeErr), "error", closeErr) } }() diff --git a/monkeyai/backend/internal/proxy/reconcile_test.go b/monkeyai/backend/internal/proxy/reconcile_test.go index 81c35385c..9fdbde13c 100644 --- a/monkeyai/backend/internal/proxy/reconcile_test.go +++ b/monkeyai/backend/internal/proxy/reconcile_test.go @@ -103,7 +103,7 @@ func TestResponseReconciliationCloseLogIsSafe(t *testing.T) { t.Fatalf("响应关闭不能改变对账结果: %+v %v", result, err) } text := logs.String() - if strings.Contains(text, "private-upstream-key-and-body") || tc.logged && (!strings.Contains(text, "close_reconciliation_response") || !strings.Contains(text, "model-1")) || !tc.logged && text != "" { + if tc.logged && !strings.Contains(text, tc.closeErr.Error()) || tc.logged && (!strings.Contains(text, "close_reconciliation_response") || !strings.Contains(text, "model-1")) || !tc.logged && text != "" { t.Fatalf("关闭响应时的日志不安全或有误报: %s", text) } }) diff --git a/monkeyai/backend/internal/proxy/transport.go b/monkeyai/backend/internal/proxy/transport.go index 83584aded..ecfb6c85c 100644 --- a/monkeyai/backend/internal/proxy/transport.go +++ b/monkeyai/backend/internal/proxy/transport.go @@ -4,6 +4,7 @@ import ( "context" "crypto/tls" "fmt" + "log/slog" "net" "net/http" "net/url" @@ -26,6 +27,9 @@ func (e *ConnectError) DiagnosticCode() string { func TransportFor(raw string) (*http.Transport, error) { address, err := url.Parse(raw) if err != nil || address.Host == "" { + if err != nil { + slog.Warn("操作失败", "module", "proxy", "operation", "TransportFor", "error", err) + } return nil, fmt.Errorf("系统代理配置无效") } transport := DirectTransport() diff --git a/monkeyai/backend/internal/proxy/usage_test.go b/monkeyai/backend/internal/proxy/usage_test.go index df6ba9a8d..13903fa76 100644 --- a/monkeyai/backend/internal/proxy/usage_test.go +++ b/monkeyai/backend/internal/proxy/usage_test.go @@ -208,7 +208,7 @@ func TestUsageCapturePipeErrorLogsDetailWithoutResponse(t *testing.T) { t.Fatal(err) } text := logs.String() - if strings.Count(text, "write_usage_pipe") != 1 || !strings.Contains(text, "error.error_code=internal_error") || strings.Contains(text, "用量解析器意外失败") || !strings.Contains(text, "transaction-1") || !strings.Contains(text, "model-1") || strings.Contains(text, "private-upstream-response") { + if strings.Count(text, "write_usage_pipe") != 1 || !strings.Contains(text, "error.error_code=internal_error") || !strings.Contains(text, "用量解析器意外失败") || !strings.Contains(text, "transaction-1") || !strings.Contains(text, "model-1") || strings.Contains(text, "private-upstream-response") { t.Fatalf("管道错误日志缺少详情或泄漏响应: %s", text) } } diff --git a/monkeyai/backend/internal/relay/bridge.go b/monkeyai/backend/internal/relay/bridge.go index e11ab75d3..d698b141e 100644 --- a/monkeyai/backend/internal/relay/bridge.go +++ b/monkeyai/backend/internal/relay/bridge.go @@ -7,12 +7,13 @@ import ( "encoding/base64" "encoding/json" "errors" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "log/slog" "net/http" "time" "uuid" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/endpoint" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/identity" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resource" @@ -59,18 +60,23 @@ func (s *Service) bridge(w http.ResponseWriter, r *http.Request) { defer func() { s.mu.Lock(); s.slots--; s.mu.Unlock() }() ws, err := websocket.Accept(w, r, &websocket.AcceptOptions{InsecureSkipVerify: true, CompressionMode: websocket.CompressionDisabled}) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "bridge", "error", err) return } s.mu.Lock() if s.draining.Load() { s.mu.Unlock() - ws.CloseNow() + if err := ws.CloseNow(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "bridge", "error", err) + } return } s.active[ws] = struct{}{} s.mu.Unlock() defer func() { - ws.CloseNow() + if err := ws.CloseNow(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "bridge", "error", err) + } s.mu.Lock() delete(s.active, ws) s.mu.Unlock() @@ -106,6 +112,7 @@ func (s *Service) bridge(w http.ResponseWriter, r *http.Request) { defer cancel() nonce, err := randomSecret() if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "bridge", "error", err) return } challenge := Challenge{Type: "challenge", ServerID: s.config.ServerID, OwnerUserID: p.UserID, ChallengeID: uuid.New().String(), Nonce: nonce, TTLMS: 60000, ServerTime: time.Now().UTC(), GrantID: p.GrantID, RegistrationVersion: state.RegistrationVersion} @@ -114,12 +121,22 @@ func (s *Service) bridge(w http.ResponseWriter, r *http.Request) { } var proof Proof if err := readWS(handshake, ws, &proof); err != nil || proof.Type != "proof" || proof.ChallengeID != challenge.ChallengeID { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "bridge", "error", err) + } s.wsError(handshake, ws, errProtocol) return } signature, err := base64.RawURLEncoding.Strict().DecodeString(proof.Signature) - message, _ := ProofBytes(hello, challenge) + message, encodeErr := ProofBytes(hello, challenge) + if encodeErr != nil { + s.wsError(handshake, ws, encodeErr) + return + } if err != nil || len(public) != ed25519.PublicKeySize || !ed25519.Verify(public, message, signature) { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "bridge", "error", err) + } s.wsError(handshake, ws, &resource.Error{Status: 403, Code: "invalid_device_proof", Message: "设备证明无效"}) return } @@ -188,6 +205,9 @@ func (s *Service) bridge(w http.ResponseWriter, r *http.Request) { } var ack ReadyAck if err := readWS(handshake, ws, &ack); err != nil || ack.Type != "ready_ack" || ack.RegistrationVersion != ready.RegistrationVersion || !identityOnly && ack.LeaseEpoch != ready.LeaseEpoch { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "bridge", "error", err) + } s.wsError(handshake, ws, errProtocol) return } @@ -199,9 +219,14 @@ func (s *Service) bridge(w http.ResponseWriter, r *http.Request) { ws.SetReadLimit(1 << 20) mux, err := yamux.Server(conn, muxConfig()) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "bridge", "error", err) return } - defer mux.Close() + defer func() { + if err := mux.Close(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "bridge", "error", err) + } + }() if channel == "data" { gate.Lock() s.mu.Lock() @@ -217,7 +242,9 @@ func (s *Service) bridge(w http.ResponseWriter, r *http.Request) { gate.Unlock() logging.Event(r.Context(), s.logger, slog.LevelInfo, "relay.bridge.ready", "设备数据通道已就绪") if previous != nil { - previous.Close() + if err := previous.Close(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "bridge", "error", err) + } } defer func() { s.mu.Lock() @@ -228,7 +255,9 @@ func (s *Service) bridge(w http.ResponseWriter, r *http.Request) { }() // 数据通道只接受控制面打开的业务流，拒绝执行端反向拨号。 if incoming, err := mux.AcceptStream(); err == nil { - incoming.Close() + if err := incoming.Close(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "bridge", "error", err) + } } return } @@ -265,7 +294,9 @@ func (s *Service) wsError(ctx context.Context, ws *websocket.Conn, err error) { } else if errors.Is(err, errProtocol) { code = "invalid_tunnel_message" } - _ = writeWS(ctx, ws, map[string]any{"type": "error", "code": code}) + if err := writeWS(ctx, ws, map[string]any{"type": "error", "code": code}); err != nil { + slog.Error("操作失败", "module", "relay", "operation", "wsError", "error", err) + } logCode := "internal_error" switch code { case "authorization_state_unavailable", "invalid_tunnel_message", "permission_denied", "invalid_device_proof", "device_process_conflict", "device_registration_changed", "device_revoked", "device_not_found": diff --git a/monkeyai/backend/internal/relay/connection.go b/monkeyai/backend/internal/relay/connection.go index 9e20f3b80..90a304ffe 100644 --- a/monkeyai/backend/internal/relay/connection.go +++ b/monkeyai/backend/internal/relay/connection.go @@ -4,6 +4,7 @@ import ( "context" "encoding/json" "errors" + "log/slog" "net/http" "slices" "time" @@ -55,6 +56,9 @@ func (s *Service) connections(w http.ResponseWriter, r *http.Request) { var in ConnectionRequest data, err := readBody(w, r, maxControlMessage) if err != nil || decodeMessage(data, &in) != nil { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "connections", "error", err) + } failure(r.Context(), w, 400, "invalid_request") return } @@ -82,22 +86,30 @@ func (s *Service) connections(w http.ResponseWriter, r *http.Request) { } ticket, err := randomSecret() if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "connections", "error", err) failure(r.Context(), w, 503, "authorization_state_unavailable") return } tx, err := s.pool.Begin(r.Context()) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "connections", "error", err) failure(r.Context(), w, 503, "authorization_state_unavailable") return } - defer tx.Rollback(context.WithoutCancel(r.Context())) + defer func() { + if err := tx.Rollback(context.WithoutCancel(r.Context())); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + slog.Error("回滚事务失败", "module", "relay", "operation", "connections", "error", err) + } + }() q := sqlc.New(tx) if _, err = q.LockUser(r.Context(), p.UserID); err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "connections", "error", err) failure(r.Context(), w, 503, "authorization_state_unavailable") return } valid, err := s.identity.AuthorizeDevice(r.Context(), tx, p, "device:connect") if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "connections", "error", err) failure(r.Context(), w, 503, "authorization_state_unavailable") return } @@ -116,6 +128,7 @@ func (s *Service) connections(w http.ResponseWriter, r *http.Request) { } hostValid, hostErr := s.identity.AuthorizeDevice(r.Context(), tx, route.principal, "device:publish") if hostErr != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "connections", "error", hostErr) failure(r.Context(), w, 503, "authorization_state_unavailable") return } @@ -135,6 +148,9 @@ func (s *Service) connections(w http.ResponseWriter, r *http.Request) { row, err = q.LockConnection(r.Context(), sqlc.LockConnectionParams{ID: in.ConnectionID, UserID: p.UserID, ClientGrantID: p.GrantID}) if err != nil || row.MachineID != machine || row.RevokedAt != nil || !time.Now().Before(row.ExpiresAt) || row.GrantVersion != state.GrantVersion { if err != nil && !errors.Is(err, pgx.ErrNoRows) { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "connections", "error", err) + } failure(r.Context(), w, 503, "authorization_state_unavailable") } else { failure(r.Context(), w, 401, "connection_expired") @@ -168,6 +184,7 @@ func (s *Service) connections(w http.ResponseWriter, r *http.Request) { } count, err := q.CountConnections(r.Context(), sqlc.CountConnectionsParams{UserID: p.UserID, MachineID: machine, GrantVersion: state.GrantVersion}) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "connections", "error", err) failure(r.Context(), w, 503, "authorization_state_unavailable") return } @@ -194,7 +211,13 @@ func (s *Service) connections(w http.ResponseWriter, r *http.Request) { } negotiated[name] = 1 } - protocol, _ = json.Marshal(negotiated) + var encodeErr error + protocol, encodeErr = json.Marshal(negotiated) + if encodeErr != nil { + s.logger.ErrorContext(r.Context(), "编码连接协议失败", "error", encodeErr) + failure(r.Context(), w, 500, "internal_error") + return + } if in.ConnectionID != "" && !sameProtocol(row.Protocol, protocol) { failure(r.Context(), w, 409, "upgrade_required") return @@ -207,10 +230,12 @@ func (s *Service) connections(w http.ResponseWriter, r *http.Request) { row, err = q.RotateTicket(r.Context(), sqlc.RotateTicketParams{ID: row.ID, TicketHash: secretHash(ticket), Scopes: scopes, ExpiresAt: expiry}) } if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "connections", "error", err) failure(r.Context(), w, 503, "authorization_state_unavailable") return } if err = tx.Commit(r.Context()); err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "connections", "error", err) failure(r.Context(), w, 503, "authorization_state_unavailable") return } diff --git a/monkeyai/backend/internal/relay/directory.go b/monkeyai/backend/internal/relay/directory.go index 8adf0a3d2..905375a10 100644 --- a/monkeyai/backend/internal/relay/directory.go +++ b/monkeyai/backend/internal/relay/directory.go @@ -5,6 +5,7 @@ import ( "crypto/sha256" "encoding/hex" "encoding/json" + "log/slog" "net/http" "strconv" "time" @@ -54,6 +55,7 @@ func (s *Service) directory(w http.ResponseWriter, r *http.Request) { if value := r.URL.Query().Get("page"); value != "" { page, err = strconv.Atoi(value) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "directory", "error", err) failure(r.Context(), w, 400, "invalid_request") return } @@ -61,6 +63,7 @@ func (s *Service) directory(w http.ResponseWriter, r *http.Request) { if value := r.URL.Query().Get("page_size"); value != "" { size, err = strconv.Atoi(value) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "directory", "error", err) failure(r.Context(), w, 400, "invalid_request") return } @@ -72,6 +75,7 @@ func (s *Service) directory(w http.ResponseWriter, r *http.Request) { } rows, err := s.devices.Snapshot(ctx, p.UserID, capability == "execute") if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "directory", "error", err) failure(r.Context(), w, 503, "authorization_state_unavailable") return } @@ -87,6 +91,7 @@ func (s *Service) directory(w http.ResponseWriter, r *http.Request) { } else if online { valid, err := s.identity.VerifyGrant(ctx, current.principal) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "directory", "error", err) failure(r.Context(), w, 503, "authorization_state_unavailable") return } @@ -115,6 +120,7 @@ func (s *Service) directory(w http.ResponseWriter, r *http.Request) { } encoded, err := json.Marshal(out) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "directory", "error", err) failure(r.Context(), w, 503, "authorization_state_unavailable") return } diff --git a/monkeyai/backend/internal/relay/file.go b/monkeyai/backend/internal/relay/file.go index ab14c3264..ea74f3ddb 100644 --- a/monkeyai/backend/internal/relay/file.go +++ b/monkeyai/backend/internal/relay/file.go @@ -6,6 +6,7 @@ import ( "encoding/base64" "encoding/json" "errors" + "log/slog" "net/http" "net/url" "slices" @@ -14,6 +15,7 @@ import ( "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/relay/sqlc" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resource" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "github.com/go-chi/chi/v5" ) @@ -81,6 +83,9 @@ func (s *Service) verifyFileV1(ctx context.Context, machine, raw, requested stri payload, err := base64.RawURLEncoding.Strict().DecodeString(parts[1]) var in FileGrantV1 if err != nil || len(payload) > 8<<10 || decodeMessage(payload, &in) != nil || in.Type != "monkeyai.file-grant.v1" || in.Version != 1 || in.KeyID == "" || in.SessionID == "" || in.Path == "" || (in.Purpose != "resource" && in.Purpose != "download") { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "relay", "operation", "verifyFileV1", "error", err) + } return FileGrant{}, nil, denied } if !safePath("/"+in.Path) || requested != "/"+in.Path { @@ -107,8 +112,14 @@ func (s *Service) verifyFileV1(ctx context.Context, machine, raw, requested stri return FileGrant{}, nil, err } signature, err := base64.RawURLEncoding.Strict().DecodeString(parts[2]) - message, _ := FileGrantV1Bytes(in) + message, encodeErr := FileGrantV1Bytes(in) + if encodeErr != nil { + return FileGrant{}, nil, encodeErr + } if err != nil || len(state.PublicKey) != ed25519.PublicKeySize || in.KeyID != state.KeyID || !ed25519.Verify(state.PublicKey, message, signature) { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "relay", "operation", "verifyFileV1", "error", err) + } return FileGrant{}, nil, denied } now := time.Now() @@ -152,6 +163,9 @@ func (s *Service) verifyFile(ctx context.Context, machine, raw, requested string payload, err := base64.RawURLEncoding.Strict().DecodeString(parts[0]) var grant FileGrant if err != nil || decodeMessage(payload, &grant) != nil || grant.Version != 1 || grant.ServerID != s.config.ServerID || grant.MachineID != machine || !validUUID(grant.OwnerUserID) || !validUUID(grant.SessionID) { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "relay", "operation", "verifyFile", "error", err) + } return grant, nil, denied } state, err := s.devices.State(ctx, grant.OwnerUserID, machine) @@ -163,8 +177,14 @@ func (s *Service) verifyFile(ctx context.Context, machine, raw, requested string return grant, nil, err } signature, err := base64.RawURLEncoding.Strict().DecodeString(parts[1]) - message, _ := FileGrantBytes(grant) + message, encodeErr := FileGrantBytes(grant) + if encodeErr != nil { + return grant, nil, encodeErr + } if err != nil || len(state.PublicKey) != ed25519.PublicKeySize || grant.KeyID != state.KeyID || !ed25519.Verify(state.PublicKey, message, signature) { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "relay", "operation", "verifyFile", "error", err) + } return grant, nil, denied } now := time.Now() @@ -189,7 +209,12 @@ func (s *Service) verifyFile(ctx context.Context, machine, raw, requested string } func (s *Service) file(w http.ResponseWriter, r *http.Request) { - origin, _ := url.Parse(s.config.FilesOrigin) + origin, err := url.Parse(s.config.FilesOrigin) + if err != nil { + logging.Diagnostic(r.Context(), s.logger, slog.LevelError, "relay.file.failed", err) + failure(r.Context(), w, 500, "internal_error") + return + } if !strings.EqualFold(r.Host, origin.Host) || r.Method != "GET" && r.Method != "HEAD" { failure(r.Context(), w, 403, "permission_denied") return @@ -197,6 +222,9 @@ func (s *Service) file(w http.ResponseWriter, r *http.Request) { machine, raw := chi.URLParam(r, "machine"), chi.URLParam(r, "grant") requested, pathErr := requestPath(r, "/"+chi.URLParam(r, "*")) if pathErr != nil || !safePath(requested) { + if pathErr != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "file", "error", pathErr) + } failure(r.Context(), w, 400, "invalid_request") return } @@ -214,6 +242,7 @@ func (s *Service) file(w http.ResponseWriter, r *http.Request) { "authorization": map[string]any{"server_id": s.config.ServerID, "owner_user_id": grant.OwnerUserID, "machine_id": machine, "connection_id": grant.ConnectionID, "client_grant_id": grant.ClientGrantID, "grant_version": grant.GrantVersion, "access_version": grant.AccessVersion, "lease_epoch": grant.LeaseEpoch, "scopes": grant.Scopes}, "expires_at": grant.ExpiresAt.UTC().Format(time.RFC3339Nano)}) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "file", "error", err) failure(r.Context(), w, 503, "authorization_state_unavailable") return } diff --git a/monkeyai/backend/internal/relay/identity.go b/monkeyai/backend/internal/relay/identity.go index e6c24c60e..c4c89525e 100644 --- a/monkeyai/backend/internal/relay/identity.go +++ b/monkeyai/backend/internal/relay/identity.go @@ -9,6 +9,7 @@ import ( "errors" "fmt" "io" + "log/slog" "os" "path/filepath" "runtime" @@ -64,8 +65,16 @@ func loadIdentity(dir string) (serverIdentity, error) { if err != nil { return serverIdentity{}, fmt.Errorf("创建远程执行身份文件: %w", err) } - defer os.Remove(temp.Name()) - defer temp.Close() + defer func() { + if err := os.Remove(temp.Name()); err != nil && !os.IsNotExist(err) { + slog.Error("清理临时文件失败", "module", "relay", "operation", "loadIdentity", "error", err) + } + }() + defer func() { + if err := temp.Close(); err != nil && !errors.Is(err, os.ErrClosed) { + slog.Error("关闭资源失败", "module", "relay", "operation", "loadIdentity", "error", err) + } + }() if _, err = temp.Write(data); err != nil { return serverIdentity{}, err } @@ -85,7 +94,9 @@ func loadIdentity(dir string) (serverIdentity, error) { return serverIdentity{}, err } err = directory.Sync() - directory.Close() + if err := directory.Close(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "loadIdentity", "error", err) + } if err != nil { return serverIdentity{}, err } @@ -98,7 +109,11 @@ func readIdentity(path string) (serverIdentity, error) { if err != nil { return serverIdentity{}, err } - defer file.Close() + defer func() { + if err := file.Close(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "readIdentity", "error", err) + } + }() info, err := file.Stat() if err != nil { return serverIdentity{}, err @@ -110,12 +125,16 @@ func readIdentity(path string) (serverIdentity, error) { decoder := json.NewDecoder(io.LimitReader(file, 16<<10)) decoder.DisallowUnknownFields() if err := decoder.Decode(&state); err != nil || !validUUID(state.ServerID) { + if err != nil { + slog.Warn("操作失败", "module", "relay", "operation", "readIdentity", "error", err) + } return serverIdentity{}, errors.New("远程执行身份文件无效，拒绝覆盖已有身份") } if decoder.Decode(new(any)) != io.EOF { return serverIdentity{}, errors.New("远程执行身份文件含多余内容，拒绝覆盖已有身份") } if _, err := parseSigningKey([]byte(state.PrivateKey)); err != nil { + slog.Warn("操作失败", "module", "relay", "operation", "readIdentity", "error", err) return serverIdentity{}, errors.New("远程执行身份私钥无效，拒绝覆盖已有身份") } return state, nil diff --git a/monkeyai/backend/internal/relay/lease.go b/monkeyai/backend/internal/relay/lease.go index 58ad3419c..22846926a 100644 --- a/monkeyai/backend/internal/relay/lease.go +++ b/monkeyai/backend/internal/relay/lease.go @@ -3,7 +3,7 @@ package relay import ( "context" "encoding/json" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "errors" "io" "log/slog" "net" @@ -12,6 +12,8 @@ import ( "sync" "time" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/relay/sqlc" "github.com/hashicorp/yamux" ) @@ -45,7 +47,9 @@ func (a *access) closeReason(reason string) { cancel() } if conn != nil { - conn.Close() + if err := conn.Close(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "closeReason", "error", err) + } } } func (a *access) deadline() time.Time { @@ -64,7 +68,9 @@ func (a *access) renew(verified, expires time.Time) { } a.verifiedAt, a.expiresAt = verified, expires if a.stream != nil { - a.stream.SetDeadline(minTime(expires, verified.Add(180*time.Second))) + if err := a.stream.SetDeadline(minTime(expires, verified.Add(180*time.Second))); err != nil { + slog.Error("设置连接截止时间失败", "module", "relay", "operation", "renew", "error", err) + } } } func minTime(a, b time.Time) time.Time { @@ -122,7 +128,11 @@ func (s *Service) revocation(r *route, connection string, version int64) string payload["connection_id"] = connection payload["access_version"] = version } - wire, _ := signWire(s.key, s.kid, payload) + wire, err := signWire(s.key, s.kid, payload) + if err != nil { + s.logger.Error("签发中转凭据失败", "error", err) + return "" + } return wire } func (s *Service) pushControl(r *route, value any) bool { @@ -264,11 +274,13 @@ func (s *Service) lease(ctx context.Context, r *route, in LeaseRequest) (leaseRe } state := "fresh" if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "relay", "operation", "lease", "error", err) state = "grace" } wire, err := signWire(s.key, s.kid, map[string]any{"type": "monkeyai.access.lease.v1", "issuer": s.config.PublicURL, "audience": "monkeyai-runtime", "kid": s.kid, "authorization": auth, "nonce": in.Nonce, "lease_seq": in.LeaseSeq, "boot_id": in.BootID, "ttl_ms": ttl.Milliseconds(), "ticket_remaining_ms": min(int64(900000), max(0, time.Until(expires).Milliseconds())), "auth_age_ms": age, "server_time": now.UTC().Format(time.RFC3339Nano), "verification_state": state}) if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "relay", "operation", "lease", "error", err) return leaseResponse{Code: "authorization_state_unavailable"}, 503 } return leaseResponse{Signed: wire}, 200 @@ -299,7 +311,9 @@ func (l *controlListener) Accept() (net.Conn, error) { case l.slots <- struct{}{}: return &controlConn{Conn: c, slots: l.slots}, nil default: - c.Close() + if err := c.Close(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "Accept", "error", err) + } } } } @@ -322,8 +336,14 @@ func (s *Service) control(ctx context.Context, r *route) { go s.probe(r, stop) server := &http.Server{ErrorLog: logging.ErrorLog(s.logger), ReadHeaderTimeout: 5 * time.Second, ReadTimeout: 10 * time.Second, IdleTimeout: 10 * time.Second, MaxHeaderBytes: 16 << 10, BaseContext: func(net.Listener) context.Context { return ctx }, Handler: http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { s.controlHTTP(w, req, r) })} - defer server.Close() - _ = server.Serve(&controlListener{session: r.control, slots: make(chan struct{}, 16)}) + defer func() { + if err := server.Close(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "control", "error", err) + } + }() + if err := server.Serve(&controlListener{session: r.control, slots: make(chan struct{}, 16)}); err != nil && !errors.Is(err, http.ErrServerClosed) { + slog.Error("操作失败", "module", "relay", "operation", "control", "error", err) + } } func (s *Service) probe(r *route, stop <-chan struct{}) { ticker := time.NewTicker(15 * time.Second) @@ -334,6 +354,7 @@ func (s *Service) probe(r *route, stop <-chan struct{}) { return case <-ticker.C: if _, err := r.control.Ping(); err != nil { + slog.Warn("操作失败", "module", "relay", "operation", "probe", "error", err) s.closeRoute(r) return } @@ -351,7 +372,9 @@ func (s *Service) controlHTTP(w http.ResponseWriter, req *http.Request, r *route return } rc := http.NewResponseController(w) - _ = rc.SetWriteDeadline(time.Now().Add(5 * time.Second)) + if err := rc.SetWriteDeadline(time.Now().Add(5 * time.Second)); err != nil { + slog.Error("设置连接截止时间失败", "module", "relay", "operation", "controlHTTP", "error", err) + } w.Header().Set("Content-Type", "application/json") w.Header().Set("Cache-Control", "no-store") switch { @@ -359,19 +382,27 @@ func (s *Service) controlHTTP(w http.ResponseWriter, req *http.Request, r *route s.mu.Lock() online := r.data != nil && !r.data.IsClosed() s.mu.Unlock() - json.NewEncoder(w).Encode(map[string]any{"lease_epoch": r.state.LeaseEpoch, "data_online": online}) + if err := json.NewEncoder(w).Encode(map[string]any{"lease_epoch": r.state.LeaseEpoch, "data_online": online}); err != nil { + slog.Error("写入输出失败", "module", "relay", "operation", "controlHTTP", "error", err) + } case req.Method == "POST" && req.URL.Path == "/_control/access-lease": raw, err := io.ReadAll(http.MaxBytesReader(w, req.Body, maxControlMessage)) var in LeaseRequest if err != nil || decodeMessage(raw, &in) != nil { w.WriteHeader(400) - json.NewEncoder(w).Encode(leaseResponse{Code: "invalid_tunnel_message"}) + if err := json.NewEncoder(w).Encode(leaseResponse{Code: "invalid_tunnel_message"}); err != nil { + slog.Error("写入输出失败", "module", "relay", "operation", "controlHTTP", "error", err) + } return } result, status := s.lease(req.Context(), r, in) - _ = rc.SetWriteDeadline(time.Now().Add(5 * time.Second)) + if err := rc.SetWriteDeadline(time.Now().Add(5 * time.Second)); err != nil { + slog.Error("设置连接截止时间失败", "module", "relay", "operation", "controlHTTP", "error", err) + } w.WriteHeader(status) - json.NewEncoder(w).Encode(result) + if err := json.NewEncoder(w).Encode(result); err != nil { + slog.Error("写入输出失败", "module", "relay", "operation", "controlHTTP", "error", err) + } case req.Method == "GET" && req.URL.Path == "/_control/events": s.mu.Lock() duplicate := r.eventsActive @@ -384,15 +415,23 @@ func (s *Service) controlHTTP(w http.ResponseWriter, req *http.Request, r *route return } defer func() { s.closeRoute(r) }() - _ = rc.SetReadDeadline(time.Time{}) + if err := rc.SetReadDeadline(time.Time{}); err != nil { + slog.Error("设置连接截止时间失败", "module", "relay", "operation", "controlHTTP", "error", err) + } w.Header().Set("Content-Type", "application/x-ndjson") send := func(value any) bool { - _ = rc.SetWriteDeadline(time.Now().Add(5 * time.Second)) + if err := rc.SetWriteDeadline(time.Now().Add(5 * time.Second)); err != nil { + slog.Error("设置连接截止时间失败", "module", "relay", "operation", "controlHTTP", "error", err) + } raw, err := json.Marshal(value) if err != nil || len(raw) > maxControlMessage { + if err != nil { + slog.WarnContext(req.Context(), "操作失败", "module", "relay", "operation", "controlHTTP", "error", err) + } return false } if _, err = w.Write(append(raw, '\n')); err != nil { + slog.WarnContext(req.Context(), "操作失败", "module", "relay", "operation", "controlHTTP", "error", err) return false } return rc.Flush() == nil @@ -418,7 +457,9 @@ func (s *Service) controlHTTP(w http.ResponseWriter, req *http.Request, r *route } default: w.WriteHeader(404) - json.NewEncoder(w).Encode(map[string]string{"code": "not_found"}) + if err := json.NewEncoder(w).Encode(map[string]string{"code": "not_found"}); err != nil { + slog.Error("写入输出失败", "module", "relay", "operation", "controlHTTP", "error", err) + } } } @@ -488,6 +529,9 @@ func (s *Service) monitor(r *route, stop <-chan struct{}) { continue } if a.id == "" || verifyErr != nil { + if verifyErr != nil { + slog.Warn("操作失败", "module", "relay", "operation", "monitor", "error", verifyErr) + } continue } row, found := states[a.id] diff --git a/monkeyai/backend/internal/relay/preview.go b/monkeyai/backend/internal/relay/preview.go index 4d6e7863f..a0758f62e 100644 --- a/monkeyai/backend/internal/relay/preview.go +++ b/monkeyai/backend/internal/relay/preview.go @@ -5,6 +5,7 @@ import ( "crypto/sha256" "encoding/hex" "errors" + "log/slog" "net" "net/http" "net/url" @@ -23,6 +24,9 @@ func validatePreviewTemplate(template, control, files string) error { } u, err := url.Parse(strings.Replace(template, "{artifact}", strings.Repeat("a", 32), 1)) if err != nil || u.User != nil || u.Path != "" || u.RawQuery != "" || u.Fragment != "" || u.Port() != "" { + if err != nil { + slog.Warn("操作失败", "module", "relay", "operation", "validatePreviewTemplate", "error", err) + } return errors.New("预览 origin 模板不能包含端口、路径或凭据") } base := strings.TrimPrefix(u.Hostname(), strings.Repeat("a", 32)+".") @@ -51,14 +55,18 @@ func previewHost(template, host string) bool { if template == "" { return false } - u, _ := url.Parse(strings.Replace(template, "{artifact}", "artifact", 1)) + u, err := url.Parse(strings.Replace(template, "{artifact}", "artifact", 1)) + if err != nil { + slog.Error("解析预览域名失败", "error", err) + return false + } base := strings.TrimPrefix(u.Host, "artifact.") host = strings.ToLower(host) if !strings.HasSuffix(host, "."+base) { return false } label := strings.TrimSuffix(host, "."+base) - _, err := hex.DecodeString(label) + _, err = hex.DecodeString(label) return len(label) == 32 && err == nil } @@ -71,6 +79,7 @@ func previewDomain(template, host string) bool { } u, err := url.Parse(strings.Replace(template, "{artifact}", "artifact", 1)) if err != nil { + slog.Warn("操作失败", "module", "relay", "operation", "previewDomain", "error", err) return false } base := strings.TrimPrefix(u.Host, "artifact.") @@ -104,6 +113,7 @@ func (s *Service) preview(w http.ResponseWriter, r *http.Request) { if r.URL.RawPath != "" { decoded, err := url.PathUnescape(requested) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "preview", "error", err) failure(r.Context(), w, 400, "invalid_request") return } @@ -119,6 +129,9 @@ func (s *Service) preview(w http.ResponseWriter, r *http.Request) { expected := PreviewOrigin(s.config.PreviewOriginTemplate, grant.ServerID, grant.OwnerUserID, grant.MachineID, grant.SessionID, grant.ArtifactID) u, err := url.Parse(expected) if err != nil || !validUUID(grant.ArtifactID) || grant.PreviewOrigin != expected || r.Host != u.Host || grant.Scope != "directory" { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "preview", "error", err) + } failure(r.Context(), w, 403, "permission_denied") return } diff --git a/monkeyai/backend/internal/relay/protocol.go b/monkeyai/backend/internal/relay/protocol.go index b861de5cc..622abb3e7 100644 --- a/monkeyai/backend/internal/relay/protocol.go +++ b/monkeyai/backend/internal/relay/protocol.go @@ -7,6 +7,7 @@ import ( "encoding/json" "errors" "io" + "log/slog" "reflect" "slices" "strings" @@ -126,6 +127,9 @@ func validateHello(h Hello, channel string, tunnelVersion int) ([]byte, error) { } public, err := base64.RawURLEncoding.Strict().DecodeString(h.ExecutionPublicKey) if err != nil || len(public) != ed25519.PublicKeySize { + if err != nil { + slog.Warn("操作失败", "module", "relay", "operation", "validateHello", "error", err) + } return nil, errProtocol } return public, nil @@ -138,6 +142,7 @@ func decodeMessage(data []byte, out any) error { check := json.NewDecoder(bytes.NewReader(data)) check.UseNumber() if err := checkJSON(check, 0); err != nil { + slog.Warn("操作失败", "module", "relay", "operation", "decodeMessage", "error", err) return errProtocol } if _, err := check.Token(); err != io.EOF { @@ -149,6 +154,7 @@ func decodeMessage(data []byte, out any) error { decoder := json.NewDecoder(bytes.NewReader(data)) decoder.DisallowUnknownFields() if err := decoder.Decode(out); err != nil { + slog.Warn("操作失败", "module", "relay", "operation", "decodeMessage", "error", err) return errProtocol } return nil @@ -233,6 +239,9 @@ func checkJSON(d *json.Decoder, depth int) error { } end, err := d.Token() if err != nil || delim == '{' && end != json.Delim('}') || delim == '[' && end != json.Delim(']') { + if err != nil { + slog.Warn("操作失败", "module", "relay", "operation", "checkJSON", "error", err) + } return errProtocol } return nil diff --git a/monkeyai/backend/internal/relay/proxy.go b/monkeyai/backend/internal/relay/proxy.go index 5bfa0060f..07e9ded55 100644 --- a/monkeyai/backend/internal/relay/proxy.go +++ b/monkeyai/backend/internal/relay/proxy.go @@ -102,6 +102,9 @@ func (s *Service) proxy(w http.ResponseWriter, r *http.Request) { machine := chi.URLParam(r, "machine") p, pathErr := requestPath(r, "/"+chi.URLParam(r, "*")) if pathErr != nil || !validUUID(machine) || !safePath(p) { + if pathErr != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "proxy", "error", pathErr) + } failure(r.Context(), w, 400, "invalid_request") return } @@ -253,6 +256,7 @@ func (s *Service) proxy(w http.ResponseWriter, r *http.Request) { "authorization": map[string]any{"server_id": s.config.ServerID, "owner_user_id": row.UserID, "machine_id": machine, "connection_id": row.ID, "client_grant_id": row.ClientGrantID, "grant_version": row.GrantVersion, "access_version": row.AccessVersion, "lease_epoch": current.state.LeaseEpoch, "scopes": row.Scopes}, "expires_at": row.ExpiresAt.UTC().Format(time.RFC3339Nano)}) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "proxy", "error", err) failure(r.Context(), w, 503, "authorization_state_unavailable") return } @@ -394,6 +398,7 @@ func (s *Service) forward(w http.ResponseWriter, r *http.Request, route *route, DialContext: func(_ context.Context, _, _ string) (net.Conn, error) { stream, err := s.openStream(ctx, mux, opens, a, permit) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "forward", "error", err) s.metrics.openFailed.Add(1) } return stream, err @@ -431,7 +436,9 @@ func (s *Service) forward(w http.ResponseWriter, r *http.Request, route *route, } if terminal { if response.StatusCode == http.StatusSwitchingProtocols && !validTerminalUpgrade(response, r.Header.Get("Sec-WebSocket-Key")) { - response.Body.Close() + if err := response.Body.Close(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "forward", "error", err) + } return errors.New("执行端终端 Upgrade 无效") } handshakeTimer.Stop() diff --git a/monkeyai/backend/internal/relay/service.go b/monkeyai/backend/internal/relay/service.go index 2b60ff045..1358e28ce 100644 --- a/monkeyai/backend/internal/relay/service.go +++ b/monkeyai/backend/internal/relay/service.go @@ -7,7 +7,6 @@ import ( "crypto/sha256" "errors" "fmt" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "hash/fnv" "io" "log/slog" @@ -19,6 +18,8 @@ import ( "sync/atomic" "time" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/endpoint" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/identity" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/relay/sqlc" @@ -109,6 +110,9 @@ func NewService(pool *pgxpool.Pool, identities *identity.Service, devices *endpo } { u, err := url.Parse(origin.value) if err != nil || u.Hostname() == "" || u.User != nil || u.RawQuery != "" || u.ForceQuery || u.Fragment != "" || u.Path != "" || (u.Scheme != "http" && u.Scheme != "https") { + if err != nil { + slog.Warn("操作失败", "module", "relay", "operation", "NewService", "error", err) + } return nil, fmt.Errorf("%s 必须为不含账号、路径、查询参数或片段的 HTTP(S) origin", origin.name) } } @@ -118,6 +122,9 @@ func NewService(pool *pgxpool.Pool, identities *identity.Service, devices *endpo } u, err := url.Parse(origin) if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Host == "" || u.User != nil || u.Path != "" || u.RawQuery != "" || u.Fragment != "" || u.ForceQuery { + if err != nil { + slog.Warn("操作失败", "module", "relay", "operation", "NewService", "error", err) + } return nil, errors.New("Desktop Origin 必须为完整 HTTP(S) origin") } } @@ -282,13 +289,19 @@ func (s *Service) closeRoute(r *route) { a.close() } if data != nil { - data.Close() + if err := data.Close(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "closeRoute", "error", err) + } } if control != nil { - control.Close() + if err := control.Close(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "closeRoute", "error", err) + } } if r.ws != nil { - r.ws.CloseNow() + if err := r.ws.CloseNow(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "closeRoute", "error", err) + } } } @@ -346,7 +359,9 @@ func (s *Service) Shutdown(ctx context.Context) error { s.closeRoute(r) } for _, ws := range connections { - ws.CloseNow() + if err := ws.CloseNow(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "Shutdown", "error", err) + } } finished := make(chan struct{}) go func() { s.workers.Wait(); close(finished) }() @@ -382,6 +397,9 @@ func (s *Service) revoke(w http.ResponseWriter, r *http.Request) { versionText := strings.Trim(r.Header.Get("If-Match"), "\"") version, err := strconv.ParseInt(versionText, 10, 64) if err != nil || version < 0 { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "revoke", "error", err) + } failure(r.Context(), w, http.StatusPreconditionRequired, "device_registration_changed") return } diff --git a/monkeyai/backend/internal/relay/signing.go b/monkeyai/backend/internal/relay/signing.go index 1278bc385..15e12a974 100644 --- a/monkeyai/backend/internal/relay/signing.go +++ b/monkeyai/backend/internal/relay/signing.go @@ -9,6 +9,7 @@ import ( "encoding/json" "encoding/pem" "errors" + "log/slog" "os" "strings" @@ -65,6 +66,9 @@ func normalizeVerificationKey(key map[string]string) (map[string]string, error) } public, err := base64.RawURLEncoding.Strict().DecodeString(encoded) if err != nil || len(public) != ed25519.PublicKeySize || key["kid"] != endpoint.KeyID(public) { + if err != nil { + slog.Warn("操作失败", "module", "relay", "operation", "normalizeVerificationKey", "error", err) + } return nil, errors.New("中转公钥集合包含无效 Ed25519 公钥") } return verificationKey(ed25519.PublicKey(public)), nil @@ -127,10 +131,16 @@ func verifyWire(public ed25519.PublicKey, wire string) (json.RawMessage, bool) { } payload, err := base64.RawURLEncoding.Strict().DecodeString(parts[0]) if err != nil || len(payload) == 0 || len(payload) > 8<<10 { + if err != nil { + slog.Warn("操作失败", "module", "relay", "operation", "verifyWire", "error", err) + } return nil, false } signature, err := base64.RawURLEncoding.Strict().DecodeString(parts[1]) if err != nil || !ed25519.Verify(public, []byte("monkeyai.access.signed.v1."+parts[0]), signature) { + if err != nil { + slog.Warn("操作失败", "module", "relay", "operation", "verifyWire", "error", err) + } return nil, false } return payload, true diff --git a/monkeyai/backend/internal/relay/stream.go b/monkeyai/backend/internal/relay/stream.go index 6bb192e14..2ff7ff147 100644 --- a/monkeyai/backend/internal/relay/stream.go +++ b/monkeyai/backend/internal/relay/stream.go @@ -4,6 +4,7 @@ import ( "context" "errors" "io" + "log/slog" "net" "time" @@ -17,7 +18,9 @@ type meteredConn struct { func (c *meteredConn) Close() error { // yamux.Close 是半关闭；先中断读写，确保代理两侧都能退出。 - c.Conn.SetDeadline(time.Now()) + if err := c.Conn.SetDeadline(time.Now()); err != nil { + slog.Error("设置连接截止时间失败", "module", "relay", "operation", "Close", "error", err) + } return c.Conn.Close() } @@ -78,18 +81,24 @@ func (s *Service) openStream(ctx context.Context, mux *yamux.Session, opens chan a.mu.Lock() if a.closed || ctx.Err() != nil { a.mu.Unlock() - conn.Close() + if err := conn.Close(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "openStream", "error", err) + } return } a.stream = conn - conn.SetDeadline(minTime(a.expiresAt, a.verifiedAt.Add(180*time.Second))) + if err := conn.SetDeadline(minTime(a.expiresAt, a.verifiedAt.Add(180*time.Second))); err != nil { + slog.Error("设置连接截止时间失败", "module", "relay", "operation", "openStream", "error", err) + } a.mu.Unlock() } select { case done <- result{conn, err}: case <-ctx.Done(): if conn != nil { - conn.Close() + if err := conn.Close(); err != nil { + slog.Error("关闭资源失败", "module", "relay", "operation", "openStream", "error", err) + } } } }() diff --git a/monkeyai/backend/internal/relay/terminal.go b/monkeyai/backend/internal/relay/terminal.go index 97c136659..61c10c3f9 100644 --- a/monkeyai/backend/internal/relay/terminal.go +++ b/monkeyai/backend/internal/relay/terminal.go @@ -3,6 +3,7 @@ package relay import ( "crypto/sha1" "encoding/base64" + "log/slog" "net/http" "net/url" "slices" @@ -32,6 +33,9 @@ func terminalHandshake(r *http.Request) (string, bool, bool) { } key, err := base64.StdEncoding.Strict().DecodeString(keys[0]) if err != nil || len(key) != 16 { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "terminalHandshake", "error", err) + } return "", false, false } if len(r.URL.RawQuery) > 64 { @@ -40,6 +44,9 @@ func terminalHandshake(r *http.Request) (string, bool, bool) { query, err := url.ParseQuery(r.URL.RawQuery) candidate := false if err != nil || r.URL.ForceQuery { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "relay", "operation", "terminalHandshake", "error", err) + } return "", false, false } if r.URL.RawQuery != "" { diff --git a/monkeyai/backend/internal/resource/grants.go b/monkeyai/backend/internal/resource/grants.go index f4c5fa057..bfd05cf64 100644 --- a/monkeyai/backend/internal/resource/grants.go +++ b/monkeyai/backend/internal/resource/grants.go @@ -5,15 +5,14 @@ import ( "encoding/json" "errors" "fmt" + "log/slog" "net/http" - "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resource/sqlc" - "github.com/jackc/pgx/v5" - "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/identity" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resource/sqlc" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/rootgroup" - "github.com/go-chi/chi/v5" + "github.com/jackc/pgx/v5" ) func checkRetiredGrants(ctx context.Context, tx pgx.Tx, kind, id string, raw any) error { @@ -42,6 +41,9 @@ func checkRetiredGrants(ctx context.Context, tx pgx.Tx, kind, id string, raw any var requested []Object data, err := json.Marshal(raw) if err != nil || json.Unmarshal(data, &requested) != nil { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "resource", "operation", "checkRetiredGrants", "error", err) + } return Invalid("授权格式无效") } for _, entry := range requested { diff --git a/monkeyai/backend/internal/resource/page.go b/monkeyai/backend/internal/resource/page.go index 57e0afbd3..d06bd1fb5 100644 --- a/monkeyai/backend/internal/resource/page.go +++ b/monkeyai/backend/internal/resource/page.go @@ -1,6 +1,7 @@ package resource import ( + "log/slog" "net/http" "strconv" ) @@ -19,6 +20,9 @@ func PageParamsWithLimit(r *http.Request, maxSize int) (page, size int, err erro if raw := r.URL.Query().Get(field.name); raw != "" { n, parseErr := strconv.Atoi(raw) if parseErr != nil || n < 1 || n > field.max { + if parseErr != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "resource", "operation", "PageParamsWithLimit", "error", parseErr) + } return 0, 0, Invalid(field.name + " 无效") } *field.value = n diff --git a/monkeyai/backend/internal/resource/store.go b/monkeyai/backend/internal/resource/store.go index 992433eb3..6e4a3c37f 100644 --- a/monkeyai/backend/internal/resource/store.go +++ b/monkeyai/backend/internal/resource/store.go @@ -117,6 +117,7 @@ func Decode(w http.ResponseWriter, r *http.Request, v any) error { d := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)) var body json.RawMessage if err := d.Decode(&body); err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "resource", "operation", "Decode", "error", err) return Invalid("请求格式无效") } if data := bytes.TrimSpace(body); len(data) == 0 || data[0] != '{' { @@ -126,6 +127,7 @@ func Decode(w http.ResponseWriter, r *http.Request, v any) error { return Invalid("请求只能包含一个 JSON 对象") } if err := json.Unmarshal(body, v); err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "resource", "operation", "Decode", "error", err) return Invalid("请求格式无效") } return nil @@ -177,6 +179,7 @@ func SaveGrants(ctx context.Context, tx pgx.Tx, kind, id, actor string, raw any, Usage string `json:"usage_requirement"` } if err := json.Unmarshal(b, &grants); err != nil { + slog.WarnContext(ctx, "操作失败", "module", "resource", "operation", "SaveGrants", "error", err) return Invalid("授权格式无效") } if _, err := sqlc.New(tx).DeleteGrants(ctx, sqlc.DeleteGrantsParams{ResourceType: kind, ResourceID: id}); err != nil { @@ -629,6 +632,9 @@ func (c *CRUD) Register(r chi.Router) { if raw := r.URL.Query().Get("limit"); raw != "" { n, err := strconv.Atoi(raw) if err != nil || n < 1 || n > 500 { + if err != nil { + slog.Warn("操作失败", "module", "resource", "operation", "Register", "error", err) + } Fail(r.Context(), w, Invalid("limit 必须在 1—500 之间")) return } diff --git a/monkeyai/backend/internal/resource/tags.go b/monkeyai/backend/internal/resource/tags.go index 7b6f5eadf..76a4a16c3 100644 --- a/monkeyai/backend/internal/resource/tags.go +++ b/monkeyai/backend/internal/resource/tags.go @@ -3,6 +3,7 @@ package resource import ( "context" "encoding/json" + "log/slog" "net/http" "slices" "strings" @@ -80,6 +81,7 @@ func Tags(ctx context.Context, q Queryer, kind, id string) ([]Object, error) { func SaveTags(ctx context.Context, q Queryer, kind, id, actor string, raw any) error { data, err := json.Marshal(raw) if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "resource", "operation", "SaveTags", "error", err) return Invalid("标签格式无效") } var ids []string diff --git a/monkeyai/backend/internal/resourceimport/artifact.go b/monkeyai/backend/internal/resourceimport/artifact.go index 19944ede2..680840c68 100644 --- a/monkeyai/backend/internal/resourceimport/artifact.go +++ b/monkeyai/backend/internal/resourceimport/artifact.go @@ -8,6 +8,7 @@ import ( "encoding/hex" "encoding/json" "fmt" + "log/slog" "maps" "slices" "strings" @@ -218,7 +219,11 @@ func normalizeDescription(data []byte) ([]byte, string, bool) { if !strings.Contains(value, ": ") || value == "" || strings.ContainsAny(value[:1], `"'|>`) { return nil, "", false } - quoted, _ := json.Marshal(value) + quoted, err := json.Marshal(value) + if err != nil { + slog.Error("编码资源属性失败", "error", err) + return nil, "", false + } ending := "\n" if strings.HasSuffix(original, "\r\n") { ending = "\r\n" diff --git a/monkeyai/backend/internal/resourceimport/design.go b/monkeyai/backend/internal/resourceimport/design.go index 1f7b4bd02..968d25578 100644 --- a/monkeyai/backend/internal/resourceimport/design.go +++ b/monkeyai/backend/internal/resourceimport/design.go @@ -4,6 +4,7 @@ import ( "context" "encoding/json" "errors" + "log/slog" "net/http" "slices" "time" @@ -266,7 +267,9 @@ func (s *Service) applySections(ctx context.Context, loaded loadedImport) (Secti if err == nil { err = tx.Commit(ctx) } - _ = tx.Rollback(context.WithoutCancel(ctx)) + if err := tx.Rollback(context.WithoutCancel(ctx)); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + slog.Error("回滚事务失败", "module", "resourceimport", "operation", "applySections", "error", err) + } } } } @@ -285,6 +288,7 @@ func (s *Service) applySections(ctx context.Context, loaded loadedImport) (Secti recordErr := saveSection(recordCtx, s.Pool, loaded, section, plan.PlanDigest, result) cancel() if recordErr != nil { + slog.WarnContext(ctx, "操作失败", "module", "resourceimport", "operation", "applySections", "error", recordErr) result.Error = &SectionError{"service_unavailable", "分区结果未能持久化，请重新预览恢复状态"} result.HTTPStatus = 503 failureStatus = 503 diff --git a/monkeyai/backend/internal/resourceimport/load.go b/monkeyai/backend/internal/resourceimport/load.go index e8ae57711..6a4f79bdd 100644 --- a/monkeyai/backend/internal/resourceimport/load.go +++ b/monkeyai/backend/internal/resourceimport/load.go @@ -5,9 +5,12 @@ import ( "crypto/sha256" "encoding/hex" "encoding/json" + "errors" "io" + "log/slog" "mime/multipart" "net/http" + "os" "strings" "sync" @@ -57,6 +60,7 @@ func (s *Service) loadImport(w http.ResponseWriter, r *http.Request) (loaded loa }) } if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "resourceimport", "operation", "loadImport", "error", err) loaded.cleanup() } }() @@ -71,6 +75,7 @@ func (s *Service) loadImport(w http.ResponseWriter, r *http.Request) (loaded loa } if strings.HasPrefix(r.Header.Get("Content-Type"), "application/json") { if err = resource.Decode(w, r, &loaded.input); err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "resourceimport", "operation", "loadImport", "error", err) return } actor, ok := identity.UserFromContext(r.Context()) @@ -81,9 +86,14 @@ func (s *Service) loadImport(w http.ResponseWriter, r *http.Request) (loaded loa var upload Upload upload, loaded.tx, err = s.lockUpload(r.Context(), loaded.input.UploadID, actor.ID) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "resourceimport", "operation", "loadImport", "error", err) return } - loaded.cleanup = func() { _ = loaded.tx.Rollback(context.WithoutCancel(r.Context())) } + loaded.cleanup = func() { + if err := loaded.tx.Rollback(context.WithoutCancel(r.Context())); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + slog.Error("回滚事务失败", "module", "resourceimport", "operation", "loadImport", "error", err) + } + } if upload.Status != "ready" && upload.Status != "imported" { err = resource.Invalid("请先完成资源包上传和完整性检查") return @@ -91,11 +101,14 @@ func (s *Service) loadImport(w http.ResponseWriter, r *http.Request) (loaded loa var cleanup func() reader, loaded.sha, cleanup, err = s.openUpload(r.Context(), upload) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "resourceimport", "operation", "loadImport", "error", err) return } loaded.cleanup = func() { cleanup() - _ = loaded.tx.Rollback(context.WithoutCancel(r.Context())) + if err := loaded.tx.Rollback(context.WithoutCancel(r.Context())); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + slog.Error("回滚事务失败", "module", "resourceimport", "operation", "loadImport", "error", err) + } } size = upload.TotalSize } else { @@ -103,10 +116,14 @@ func (s *Service) loadImport(w http.ResponseWriter, r *http.Request) (loaded loa var file multipart.File loaded.cleanup = func() { if file != nil { - _ = file.Close() + if err := file.Close(); err != nil { + slog.Error("关闭资源失败", "module", "resourceimport", "operation", "loadImport", "error", err) + } } if r.MultipartForm != nil { - _ = r.MultipartForm.RemoveAll() + if err := r.MultipartForm.RemoveAll(); err != nil && !os.IsNotExist(err) { + slog.Error("清理临时文件失败", "module", "resourceimport", "operation", "loadImport", "error", err) + } } } if err = r.ParseMultipartForm(8 << 20); err != nil { @@ -145,6 +162,7 @@ func (s *Service) loadImport(w http.ResponseWriter, r *http.Request) (loaded loa loaded.input.DiscoverOnly = r.FormValue("discover_only") == "true" hash := sha256.New() if _, err = io.Copy(hash, io.NewSectionReader(file, 0, header.Size)); err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "resourceimport", "operation", "loadImport", "error", err) return } loaded.sha = "sha256:" + hex.EncodeToString(hash.Sum(nil)) @@ -160,6 +178,7 @@ func (s *Service) loadImport(w http.ResponseWriter, r *http.Request) (loaded loa } loaded.sections, err = selectSections(loaded.input.Sections, loaded.inspection) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "resourceimport", "operation", "loadImport", "error", err) return } if containsSection(loaded.sections, "design") { @@ -174,7 +193,12 @@ func (s *Service) loadImport(w http.ResponseWriter, r *http.Request) (loaded loa } previous := loaded.cleanup pkg := loaded.design - loaded.cleanup = func() { pkg.Close(); previous() } + loaded.cleanup = func() { + if err := pkg.Close(); err != nil { + slog.Error("关闭资源失败", "module", "resourceimport", "operation", "loadImport", "error", err) + } + previous() + } } if containsSection(loaded.sections, "agent") { loaded.pkg, err = ParseReader(reader, size) diff --git a/monkeyai/backend/internal/resourceimport/package.go b/monkeyai/backend/internal/resourceimport/package.go index c930a9874..d7ce01fa8 100644 --- a/monkeyai/backend/internal/resourceimport/package.go +++ b/monkeyai/backend/internal/resourceimport/package.go @@ -8,6 +8,7 @@ import ( "encoding/json" "fmt" "io" + "log/slog" "os" "path" "regexp" @@ -120,6 +121,9 @@ func (p Package) ReadFile(name string) ([]byte, error) { data, readErr := io.ReadAll(io.LimitReader(reader, int64(entry.UncompressedSize64)+1)) closeErr := reader.Close() if readErr != nil || closeErr != nil || uint64(len(data)) != entry.UncompressedSize64 { + if closeErr != nil { + slog.Warn("操作失败", "module", "resourceimport", "operation", "ReadFile", "error", closeErr) + } return nil, fmt.Errorf("资源包中文件损坏: %s", name) } return data, nil @@ -189,12 +193,17 @@ func readZIP(data []byte, maxSize, maxExpanded, maxFile int) (map[string][]byte, } limit := min(maxFile, maxExpanded-total) if limit < 0 { - reader.Close() + if err := reader.Close(); err != nil { + slog.Error("关闭资源失败", "module", "resourceimport", "operation", "readZIP", "error", err) + } return nil, fmt.Errorf("ZIP 解压大小超限") } content, readErr := io.ReadAll(io.LimitReader(reader, int64(limit)+1)) closeErr := reader.Close() if readErr != nil || closeErr != nil || len(content) > limit || uint64(len(content)) != f.UncompressedSize64 { + if closeErr != nil { + slog.Warn("操作失败", "module", "resourceimport", "operation", "readZIP", "error", closeErr) + } return nil, fmt.Errorf("ZIP 文件损坏或解压大小超限: %q", name) } total += len(content) @@ -229,7 +238,9 @@ func decodeJSON(data []byte, out any) error { return fmt.Errorf("JSON 格式无效") } // 字段类型不匹配时保留可读取的字段，其余使用导入默认值。 - _ = json.Unmarshal(data, out) + if err := json.Unmarshal(data, out); err != nil { + slog.Error("解析数据失败", "module", "resourceimport", "operation", "decodeJSON", "error", err) + } return nil } diff --git a/monkeyai/backend/internal/resourceimport/reader.go b/monkeyai/backend/internal/resourceimport/reader.go index 3960e9c9f..2a08b9999 100644 --- a/monkeyai/backend/internal/resourceimport/reader.go +++ b/monkeyai/backend/internal/resourceimport/reader.go @@ -6,6 +6,7 @@ import ( "encoding/hex" "fmt" "io" + "log/slog" "os" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resource" @@ -50,8 +51,12 @@ func (s *Service) openUpload(ctx context.Context, upload Upload) (*archiveReader reader := &archiveReader{} cleanup := func() { for _, file := range reader.files { - _ = file.Close() - _ = os.Remove(file.Name()) + if err := file.Close(); err != nil { + slog.Error("关闭资源失败", "module", "resourceimport", "operation", "openUpload", "error", err) + } + if err := os.Remove(file.Name()); err != nil && !os.IsNotExist(err) { + slog.Error("清理临时文件失败", "module", "resourceimport", "operation", "openUpload", "error", err) + } } } fail := func(err error) (*archiveReader, string, func(), error) { @@ -72,7 +77,9 @@ func (s *Service) openUpload(ctx context.Context, upload Upload) (*archiveReader } file, err := os.CreateTemp("", "resource-import-*") if err != nil { - _ = stream.Close() + if err := stream.Close(); err != nil { + slog.Error("关闭资源失败", "module", "resourceimport", "operation", "openUpload", "error", err) + } return fail(err) } reader.files = append(reader.files, file) @@ -80,7 +87,13 @@ func (s *Service) openUpload(ctx context.Context, upload Upload) (*archiveReader chunkHash := sha256.New() n, readErr := io.Copy(io.MultiWriter(file, hash, chunkHash), io.LimitReader(stream, chunk.Size+1)) closeErr := stream.Close() - if readErr != nil || closeErr != nil || n != chunk.Size || "sha256:"+hex.EncodeToString(chunkHash.Sum(nil)) != chunk.SHA256 { + if readErr != nil { + return fail(readErr) + } + if closeErr != nil { + return fail(closeErr) + } + if n != chunk.Size || "sha256:"+hex.EncodeToString(chunkHash.Sum(nil)) != chunk.SHA256 { return fail(resource.Invalid(fmt.Sprintf("资源包传输块 %d 损坏，请重新上传", index+1))) } } diff --git a/monkeyai/backend/internal/resourceimport/service.go b/monkeyai/backend/internal/resourceimport/service.go index 7c289c4b1..2a66294a4 100644 --- a/monkeyai/backend/internal/resourceimport/service.go +++ b/monkeyai/backend/internal/resourceimport/service.go @@ -6,7 +6,6 @@ import ( "encoding/json" "errors" "fmt" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "hash/fnv" "log/slog" "net/http" @@ -17,6 +16,8 @@ import ( "time" "uuid" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/identity" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resource" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resourceimport/sqlc" @@ -39,6 +40,9 @@ func decodeHistoryCursor(value string) ([]byte, error) { } data, err := base64.RawURLEncoding.DecodeString(value) if err != nil || len(data) > 256 { + if err != nil { + slog.Warn("操作失败", "module", "resourceimport", "operation", "decodeHistoryCursor", "error", err) + } return nil, resource.Invalid("分页游标无效") } var cursor historyCursor @@ -46,6 +50,7 @@ func decodeHistoryCursor(value string) ([]byte, error) { return nil, resource.Invalid("分页游标无效") } if _, err = uuid.Parse(cursor.ID); err != nil { + slog.Warn("操作失败", "module", "resourceimport", "operation", "decodeHistoryCursor", "error", err) return nil, resource.Invalid("分页游标无效") } return json.Marshal(cursor) @@ -102,6 +107,7 @@ func (s *Service) RegisterAdmin(router chi.Router) { return } if err = s.finishSections(r.Context(), loaded); err != nil { + slog.Warn("操作失败", "module", "resourceimport", "operation", "RegisterAdmin", "error", err) out.Warning = "分区已提交，上传状态未更新；请刷新恢复" } resource.JSON(r.Context(), w, status, out) @@ -133,6 +139,9 @@ func (s *Service) RegisterAdmin(router chi.Router) { if raw := r.URL.Query().Get("limit"); raw != "" { n, err := strconv.Atoi(raw) if err != nil || n < 1 || n > 500 { + if err != nil { + slog.Warn("操作失败", "module", "resourceimport", "operation", "RegisterAdmin", "error", err) + } resource.Fail(r.Context(), w, resource.Invalid("limit 必须为 1 至 500")) return } @@ -181,6 +190,7 @@ func (s *Service) RegisterAdmin(router chi.Router) { router.Get("/resource-imports/{id}", func(w http.ResponseWriter, r *http.Request) { id := chi.URLParam(r, "id") if _, err := uuid.Parse(id); err != nil { + slog.Warn("操作失败", "module", "resourceimport", "operation", "RegisterAdmin", "error", err) resource.Fail(r.Context(), w, resource.NotFound) return } @@ -368,7 +378,11 @@ func (s *Service) apply(ctx context.Context, p Package, r Resources, opts Option if err != nil { return pre, err } - defer tx.Rollback(context.WithoutCancel(ctx)) + defer func() { + if err := tx.Rollback(context.WithoutCancel(ctx)); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + slog.Error("回滚事务失败", "module", "resourceimport", "operation", "apply", "error", err) + } + }() if err = s.lockBindings(ctx, tx, pre.Publisher); err != nil { return pre, err } @@ -671,7 +685,11 @@ func mapOrEmpty(value map[string]string) map[string]string { } func payload(value any) []byte { - data, _ := json.Marshal(value) + data, err := json.Marshal(value) + if err != nil { + slog.Error("编码资源数据失败", "error", err) + return nil + } return data } diff --git a/monkeyai/backend/internal/resourceimport/upload.go b/monkeyai/backend/internal/resourceimport/upload.go index 076d6b9fd..741867348 100644 --- a/monkeyai/backend/internal/resourceimport/upload.go +++ b/monkeyai/backend/internal/resourceimport/upload.go @@ -6,7 +6,6 @@ import ( "encoding/hex" "errors" "fmt" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "io" "log/slog" "net/http" @@ -18,6 +17,8 @@ import ( "unicode/utf8" "uuid" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/identity" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resource" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resourceimport/sqlc" @@ -70,7 +71,10 @@ func validateUpload(files []UploadFile) (int64, error) { if match == nil { return 0, resource.Invalid("请选择普通 ZIP，或按字节拆分的 .zip.001、.002 等全部分卷；不支持 .z01 或 7z 分卷") } - n, _ := strconv.Atoi(match[2]) + n, err := strconv.Atoi(match[2]) + if err != nil { + return 0, resource.Invalid(err.Error()) + } if n != i+1 || (base != "" && !strings.EqualFold(base, match[1])) { return 0, resource.Invalid("分卷编号必须从 001 连续递增，且属于同一资源包") } @@ -114,6 +118,7 @@ func (s *Service) uploadChunks(ctx context.Context, q resource.Queryer, upload * func (s *Service) lockUpload(ctx context.Context, id, actor string) (Upload, pgx.Tx, error) { if _, err := uuid.Parse(id); err != nil { + slog.WarnContext(ctx, "操作失败", "module", "resourceimport", "operation", "lockUpload", "error", err) return Upload{}, nil, resource.NotFound } logging.Bind(ctx, slog.String("upload_id", id), slog.String("module", "resourceimport"), slog.String("phase", "lock_upload")) @@ -123,7 +128,9 @@ func (s *Service) lockUpload(ctx context.Context, id, actor string) (Upload, pgx } data, err := sqlc.New(tx).LockImportUpload(ctx, sqlc.LockImportUploadParams{ID: id, ActorUserID: actor}) if err != nil { - _ = tx.Rollback(context.WithoutCancel(ctx)) + if err := tx.Rollback(context.WithoutCancel(ctx)); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + slog.Error("回滚事务失败", "module", "resourceimport", "operation", "lockUpload", "error", err) + } return Upload{}, nil, err } upload, err := decodeUpload(data) @@ -131,7 +138,9 @@ func (s *Service) lockUpload(ctx context.Context, id, actor string) (Upload, pgx err = s.uploadChunks(ctx, tx, &upload) } if err != nil { - _ = tx.Rollback(context.WithoutCancel(ctx)) + if err := tx.Rollback(context.WithoutCancel(ctx)); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + slog.Error("回滚事务失败", "module", "resourceimport", "operation", "lockUpload", "error", err) + } return Upload{}, nil, err } return upload, tx, nil @@ -216,6 +225,7 @@ func (s *Service) listUploads(w http.ResponseWriter, r *http.Request) { func (s *Service) getUpload(w http.ResponseWriter, r *http.Request) { id := chi.URLParam(r, "id") if _, err := uuid.Parse(id); err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "resourceimport", "operation", "getUpload", "error", err) resource.Fail(r.Context(), w, resource.NotFound) return } @@ -243,10 +253,17 @@ func (s *Service) putChunk(w http.ResponseWriter, r *http.Request) { resource.Fail(r.Context(), w, err) return } - defer tx.Rollback(context.WithoutCancel(r.Context())) + defer func() { + if err := tx.Rollback(context.WithoutCancel(r.Context())); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + slog.Error("回滚事务失败", "module", "resourceimport", "operation", "putChunk", "error", err) + } + }() index, err := strconv.Atoi(chi.URLParam(r, "index")) size := upload.chunkSize(index) if err != nil || size == 0 { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "resourceimport", "operation", "putChunk", "error", err) + } resource.Fail(r.Context(), w, resource.Invalid("传输块编号无效")) return } @@ -265,10 +282,20 @@ func (s *Service) putChunk(w http.ResponseWriter, r *http.Request) { resource.Fail(r.Context(), w, err) return } - defer func() { _ = file.Close(); _ = os.Remove(file.Name()) }() + defer func() { + if err := file.Close(); err != nil { + slog.Error("关闭资源失败", "module", "resourceimport", "operation", "putChunk", "error", err) + } + if err := os.Remove(file.Name()); err != nil && !os.IsNotExist(err) { + slog.Error("清理临时文件失败", "module", "resourceimport", "operation", "putChunk", "error", err) + } + }() hash := sha256.New() length, err := io.Copy(io.MultiWriter(file, hash), http.MaxBytesReader(w, r.Body, size)) if err != nil || length != size || "sha256:"+hex.EncodeToString(hash.Sum(nil)) != expected { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "resourceimport", "operation", "putChunk", "error", err) + } resource.Fail(r.Context(), w, resource.Invalid("传输块大小或校验值不匹配，请重试")) return } @@ -323,7 +350,11 @@ func (s *Service) completeUpload(w http.ResponseWriter, r *http.Request) { resource.Fail(r.Context(), w, err) return } - defer tx.Rollback(context.WithoutCancel(r.Context())) + defer func() { + if err := tx.Rollback(context.WithoutCancel(r.Context())); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + slog.Error("回滚事务失败", "module", "resourceimport", "operation", "completeUpload", "error", err) + } + }() if upload.Status != "uploading" { resource.JSON(r.Context(), w, http.StatusOK, upload) return @@ -346,6 +377,9 @@ func (s *Service) completeUpload(w http.ResponseWriter, r *http.Request) { n, readErr := io.Copy(io.Discard, io.LimitReader(stream, int64(entry.UncompressedSize64)+1)) closeErr := stream.Close() if readErr != nil || closeErr != nil || uint64(n) != entry.UncompressedSize64 { + if closeErr != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "resourceimport", "operation", "completeUpload", "error", closeErr) + } err = fmt.Errorf("文件 %s 损坏，请检查分卷是否完整且来自同一资源包", name) break } @@ -375,7 +409,11 @@ func (s *Service) cancelUpload(w http.ResponseWriter, r *http.Request) { resource.Fail(r.Context(), w, err) return } - defer tx.Rollback(context.WithoutCancel(r.Context())) + defer func() { + if err := tx.Rollback(context.WithoutCancel(r.Context())); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + slog.Error("回滚事务失败", "module", "resourceimport", "operation", "cancelUpload", "error", err) + } + }() if upload.Status == "imported" { resource.Fail(r.Context(), w, conflict("该任务已完成导入")) return @@ -396,7 +434,11 @@ func (s *Service) CleanupUploads(ctx context.Context) error { if err != nil { return err } - defer tx.Rollback(context.WithoutCancel(ctx)) + defer func() { + if err := tx.Rollback(context.WithoutCancel(ctx)); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + slog.Error("回滚事务失败", "module", "resourceimport", "operation", "CleanupUploads", "error", err) + } + }() rows, err := sqlc.New(tx).ListExpiredImportUploads(ctx) if err != nil { return err diff --git a/monkeyai/backend/internal/session/agent.go b/monkeyai/backend/internal/session/agent.go index b92b13733..19a4341d1 100644 --- a/monkeyai/backend/internal/session/agent.go +++ b/monkeyai/backend/internal/session/agent.go @@ -5,6 +5,7 @@ import ( "crypto/sha256" "encoding/hex" "encoding/json" + "log/slog" "net/http" "strings" @@ -219,6 +220,7 @@ func validateState(in sessionInput, row sessionRow) (bool, []byte, error) { in.Runtime = nil data, err := json.Marshal(in) if err != nil { + slog.Warn("操作失败", "module", "session", "operation", "validateState", "error", err) return false, nil, invalidState("会话快照无法规范化") } digest := sha256.Sum256(data) @@ -276,6 +278,7 @@ func turnHash(in turnInput, facts int32) ([]byte, error) { Turn turnInput `json:"turn"` }{FactsVersion: facts, Turn: in}) if err != nil { + slog.Warn("操作失败", "module", "session", "operation", "turnHash", "error", err) return nil, invalidState("轮次无法规范化") } digest := sha256.Sum256(data) diff --git a/monkeyai/backend/internal/session/decode.go b/monkeyai/backend/internal/session/decode.go index b303d0ff4..8bc0249aa 100644 --- a/monkeyai/backend/internal/session/decode.go +++ b/monkeyai/backend/internal/session/decode.go @@ -6,6 +6,7 @@ import ( "encoding/json" "errors" "io" + "log/slog" "net/http" "strings" "time" @@ -224,7 +225,11 @@ func decodeBody(w http.ResponseWriter, r *http.Request, limit int, target any) e } return resource.Invalid("gzip 请求格式无效") } - defer unzipped.Close() + defer func() { + if err := unzipped.Close(); err != nil { + slog.Error("关闭资源失败", "module", "session", "operation", "decodeBody", "error", err) + } + }() body = http.MaxBytesReader(w, unzipped, int64(decodedLimit)) } decoder := json.NewDecoder(body) @@ -240,6 +245,7 @@ func decodeBody(w http.ResponseWriter, r *http.Request, limit int, target any) e return resource.Invalid("请求必须为 JSON 对象") } if err := validateUniqueJSON(raw); err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "session", "operation", "decodeBody", "error", err) return resource.Invalid("请求 JSON 字段重复或格式无效") } if err := decoder.Decode(new(json.RawMessage)); !errors.Is(err, io.EOF) { @@ -252,6 +258,7 @@ func decodeBody(w http.ResponseWriter, r *http.Request, limit int, target any) e return resource.Invalid("请求格式无效") } if err := json.Unmarshal(raw, target); err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "session", "operation", "decodeBody", "error", err) return resource.Invalid("请求字段或格式无效") } return nil diff --git a/monkeyai/backend/internal/session/index.go b/monkeyai/backend/internal/session/index.go index 6fc232606..eac8b117f 100644 --- a/monkeyai/backend/internal/session/index.go +++ b/monkeyai/backend/internal/session/index.go @@ -3,6 +3,7 @@ package session import ( "context" "encoding/json" + "log/slog" "net/http" "time" @@ -70,6 +71,7 @@ func (s *Service) sessionIndex(w http.ResponseWriter, r *http.Request) { p, _ := identity.PrincipalFromContext(ctx) enabled, full, err := s.indexPolicy(ctx) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "session", "operation", "sessionIndex", "error", err) resource.Fail(r.Context(), w, sessionFailure(503, "authorization_state_unavailable", "摘要策略暂不可用")) return } @@ -135,6 +137,7 @@ func (s *Service) sessionIndex(w http.ResponseWriter, r *http.Request) { if s.runtime != nil { current.status, current.boot, current.epoch, err = s.runtime.RuntimeStatus(ctx, p.UserID, machine) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "session", "operation", "sessionIndex", "error", err) resource.Fail(r.Context(), w, sessionFailure(503, "authorization_state_unavailable", "设备状态暂不可用")) return } diff --git a/monkeyai/backend/internal/session/turns.go b/monkeyai/backend/internal/session/turns.go index c3ec262b6..5c1fe64be 100644 --- a/monkeyai/backend/internal/session/turns.go +++ b/monkeyai/backend/internal/session/turns.go @@ -8,6 +8,7 @@ import ( "encoding/json" "errors" "fmt" + "log/slog" "net/http" "sort" "strconv" @@ -169,6 +170,9 @@ func parseAfterTurn(r *http.Request) (int32, error) { } value, err := strconv.ParseInt(values[0], 10, 32) if err != nil || value < 0 { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "session", "operation", "parseAfterTurn", "error", err) + } return 0, invalidState("after_turn 无效") } return int32(value), nil @@ -541,13 +545,23 @@ func persistSnapshot(ctx context.Context, tx pgx.Tx, sessionID string, snapshot func sameSnapshotJSON(stored, expected []byte) bool { var left, right any if err := json.Unmarshal(stored, &left); err != nil { + slog.Warn("操作失败", "module", "session", "operation", "sameSnapshotJSON", "error", err) return false } if err := json.Unmarshal(expected, &right); err != nil { + slog.Warn("操作失败", "module", "session", "operation", "sameSnapshotJSON", "error", err) + return false + } + leftData, err := json.Marshal(left) + if err != nil { + slog.Error("编码会话状态失败", "error", err) + return false + } + rightData, err := json.Marshal(right) + if err != nil { + slog.Error("编码会话状态失败", "error", err) return false } - leftData, _ := json.Marshal(left) - rightData, _ := json.Marshal(right) return bytes.Equal(leftData, rightData) } diff --git a/monkeyai/backend/internal/setting/admin.go b/monkeyai/backend/internal/setting/admin.go index 89958af7f..d527d872f 100644 --- a/monkeyai/backend/internal/setting/admin.go +++ b/monkeyai/backend/internal/setting/admin.go @@ -4,10 +4,11 @@ import ( "context" "encoding/json" "errors" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "log/slog" "net/http" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/identity" "github.com/go-chi/chi/v5" ) @@ -46,6 +47,7 @@ func (s *Service) putSetting(w http.ResponseWriter, r *http.Request) { SchemaVersion int `json:"schema_version"` } if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 2<<20)).Decode(&input); err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "setting", "operation", "putSetting", "error", err) settingError(r.Context(), w, http.StatusBadRequest, "请求格式无效") return } diff --git a/monkeyai/backend/internal/setting/email.go b/monkeyai/backend/internal/setting/email.go index dfff0bef4..eebb9d9e7 100644 --- a/monkeyai/backend/internal/setting/email.go +++ b/monkeyai/backend/internal/setting/email.go @@ -7,7 +7,6 @@ import ( "encoding/json" "errors" "fmt" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "log/slog" "mime" "net" @@ -18,6 +17,8 @@ import ( "strconv" "strings" "time" + + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" ) type emailConfig struct { @@ -33,6 +34,9 @@ type emailConfig struct { func (c emailConfig) validate() error { address, err := mail.ParseAddress(c.SenderEmail) if err != nil || address.Address != c.SenderEmail || strings.ContainsAny(c.SenderName, "\r\n") { + if err != nil { + slog.Warn("操作失败", "module", "setting", "operation", "validate", "error", err) + } return errors.New("发件人邮箱或名称无效") } if strings.TrimSpace(c.Host) == "" || strings.ContainsAny(c.Host, "\r\n /\\") || c.Port < 1 || c.Port > 65535 { @@ -62,6 +66,9 @@ func sendEmail(ctx context.Context, cfg emailConfig, to, subject, body string) e } recipient, err := mail.ParseAddress(to) if err != nil || recipient.Address != to { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "setting", "operation", "sendEmail", "error", err) + } return errors.New("收件邮箱无效") } ctx, cancel := context.WithTimeout(ctx, 15*time.Second) @@ -73,12 +80,12 @@ func sendEmail(ctx context.Context, cfg emailConfig, to, subject, body string) e } defer func() { if err := conn.Close(); err != nil && !errors.Is(err, net.ErrClosed) { - logging.Event(ctx, slog.Default(), slog.LevelWarn, "setting.operation.warn", "关闭 SMTP 连接失败", "module", "setting", "operation", "sendEmail", "failure", smtpFailure(err)) + logging.Event(ctx, slog.Default(), slog.LevelWarn, "setting.operation.warn", "关闭 SMTP 连接失败", "module", "setting", "operation", "sendEmail", "error", err) } }() stop := context.AfterFunc(ctx, func() { if err := conn.Close(); err != nil && !errors.Is(err, net.ErrClosed) { - logging.Event(ctx, slog.Default(), slog.LevelWarn, "setting.operation.warn", "取消 SMTP 连接时关闭失败", "module", "setting", "operation", "sendEmail", "failure", smtpFailure(err)) + logging.Event(ctx, slog.Default(), slog.LevelWarn, "setting.operation.warn", "取消 SMTP 连接时关闭失败", "module", "setting", "operation", "sendEmail", "error", err) } }) defer stop() @@ -101,7 +108,7 @@ func sendEmail(ctx context.Context, cfg emailConfig, to, subject, body string) e } defer func() { if err := client.Close(); err != nil && !errors.Is(err, net.ErrClosed) { - logging.Event(ctx, slog.Default(), slog.LevelWarn, "setting.operation.warn", "关闭 SMTP 客户端失败", "module", "setting", "operation", "sendEmail", "failure", smtpFailure(err)) + logging.Event(ctx, slog.Default(), slog.LevelWarn, "setting.operation.warn", "关闭 SMTP 客户端失败", "module", "setting", "operation", "sendEmail", "error", err) } }() if cfg.Encryption == "starttls" { @@ -141,7 +148,7 @@ func sendEmail(ctx context.Context, cfg emailConfig, to, subject, body string) e } // DATA 已确认接收后，QUIT 失败不应误报发送失败。 if err := client.Quit(); err != nil && !errors.Is(err, net.ErrClosed) { - logging.Event(ctx, slog.Default(), slog.LevelWarn, "setting.operation.warn", "SMTP QUIT 失败", "module", "setting", "operation", "sendEmail", "failure", smtpFailure(err)) + logging.Event(ctx, slog.Default(), slog.LevelWarn, "setting.operation.warn", "SMTP QUIT 失败", "module", "setting", "operation", "sendEmail", "error", err) } return nil } @@ -157,30 +164,32 @@ func (s *Service) testEmail(w http.ResponseWriter, r *http.Request) { input.Recipient = strings.TrimSpace(input.Recipient) address, err := mail.ParseAddress(input.Recipient) if err != nil || address.Address != input.Recipient { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "setting", "operation", "testEmail", "error", err) + } settingError(r.Context(), w, 400, "收件邮箱无效") return } if err := s.Send(r.Context(), input.Recipient, "MonkeyAI 测试邮件", "这是一封 MonkeyAI 测试邮件，SMTP 发件配置已生效。"); err != nil { - logging.Event(r.Context(), slog.Default(), slog.LevelError, "setting.operation.error", "测试邮件发送失败", "module", "setting", "operation", "testEmail", "failure", smtpFailure(err)) + logging.Event(r.Context(), slog.Default(), slog.LevelError, "setting.operation.error", "测试邮件发送失败", "module", "setting", "operation", "testEmail", "error", err) settingError(r.Context(), w, http.StatusBadGateway, "邮件发送失败，请检查已保存的 SMTP 配置和服务连接") return } settingJSON(r.Context(), w, http.StatusOK, map[string]bool{"sent": true}) } -// SMTP 响应和网络错误可能回显收件人或认证信息，只记录协议状态及错误类别。 func smtpFailure(err error) []any { if response, ok := errors.AsType[*textproto.Error](err); ok { - return []any{"reason", "smtp_rejected", "smtp_status", response.Code} + return []any{"error", err, "reason", "smtp_rejected", "smtp_status", response.Code} } if errors.Is(err, ErrNotFound) { - return []any{"error", ErrNotFound} + return []any{"error", err} } if errors.Is(err, context.DeadlineExceeded) { - return []any{"reason", "timeout"} + return []any{"error", err, "reason", "timeout"} } if network, ok := errors.AsType[net.Error](err); ok { - return []any{"reason", "network_error", "timeout", network.Timeout()} + return []any{"error", err, "reason", "network_error", "timeout", network.Timeout()} } - return []any{"reason", "email_error", "error_type", fmt.Sprintf("%T", err)} + return []any{"error", err, "reason", "email_error"} } diff --git a/monkeyai/backend/internal/setting/email_test.go b/monkeyai/backend/internal/setting/email_test.go index 7245f30eb..2241123b8 100644 --- a/monkeyai/backend/internal/setting/email_test.go +++ b/monkeyai/backend/internal/setting/email_test.go @@ -149,9 +149,9 @@ func TestDefaultAuthenticationAndEmailSecret(t *testing.T) { } } -func TestSMTPFailureExcludesResponse(t *testing.T) { +func TestSMTPFailurePreservesResponse(t *testing.T) { logged := fmt.Sprint(smtpFailure(&textproto.Error{Code: 535, Msg: "secret@example.com private-token"})) - if strings.Contains(logged, "private-token") || strings.Contains(logged, "secret@example.com") || !strings.Contains(logged, "535") { + if !strings.Contains(logged, "private-token") || !strings.Contains(logged, "secret@example.com") || !strings.Contains(logged, "535") { t.Fatalf("SMTP 日志分类不安全: %s", logged) } } diff --git a/monkeyai/backend/internal/setting/proxy.go b/monkeyai/backend/internal/setting/proxy.go index 3e76b0dff..cfb59330a 100644 --- a/monkeyai/backend/internal/setting/proxy.go +++ b/monkeyai/backend/internal/setting/proxy.go @@ -5,6 +5,7 @@ import ( "encoding/json" "errors" "fmt" + "log/slog" "net/url" "strconv" "strings" @@ -21,16 +22,25 @@ type outboundProxy struct { func validateProxies(raw json.RawMessage) error { var proxies []outboundProxy if err := json.Unmarshal(raw, &proxies); err != nil || proxies == nil { + if err != nil { + slog.Warn("操作失败", "module", "setting", "operation", "validateProxies", "error", err) + } return errors.New("proxies 必须是数组") } seen := map[string]bool{} for _, proxy := range proxies { address, err := url.Parse(proxy.URL) if err != nil || (address.Scheme != "http" && address.Scheme != "https" && address.Scheme != "socks5") || address.Host == "" || address.User != nil || address.RawQuery != "" || address.Fragment != "" || address.Path != "" || address.Hostname() == "" || address.Port() == "" { + if err != nil { + slog.Warn("操作失败", "module", "setting", "operation", "validateProxies", "error", err) + } return errors.New("代理 URL 必须是 http、https 或 socks5 地址（含端口）") } port, err := strconv.Atoi(address.Port()) if err != nil || port < 1 || port > 65535 { + if err != nil { + slog.Warn("操作失败", "module", "setting", "operation", "validateProxies", "error", err) + } return errors.New("代理端口无效") } if proxy.ID == "" || proxy.Name == "" || seen[proxy.ID] || strings.TrimSpace(proxy.Name) != proxy.Name || (proxy.Password != "" && proxy.Username == "") { diff --git a/monkeyai/backend/internal/setting/service.go b/monkeyai/backend/internal/setting/service.go index 5e8692932..d70d2d5c0 100644 --- a/monkeyai/backend/internal/setting/service.go +++ b/monkeyai/backend/internal/setting/service.go @@ -5,6 +5,7 @@ import ( "encoding/json" "errors" "fmt" + "log/slog" "slices" "time" @@ -79,6 +80,9 @@ func (s *Service) Put(ctx context.Context, key string, value json.RawMessage, sc } var object map[string]json.RawMessage if err := json.Unmarshal(value, &object); err != nil || object == nil { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "setting", "operation", "Put", "error", err) + } return Record{}, errors.New("value 必须是 JSON 对象") } if key == "authentication" { @@ -114,6 +118,9 @@ func (s *Service) Put(ctx context.Context, key string, value json.RawMessage, sc if key == "proxies" { var proxies []map[string]json.RawMessage if err := json.Unmarshal(object["proxies"], &proxies); err != nil || proxies == nil { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "setting", "operation", "Put", "error", err) + } return Record{}, errors.New("proxies 必须是数组") } for _, proxy := range proxies { @@ -121,17 +128,30 @@ func (s *Service) Put(ctx context.Context, key string, value json.RawMessage, sc return Record{}, errors.New("代理配置无效") } if rawString(proxy["id"]) == "" { - proxy["id"], _ = json.Marshal(resource.ID()) + encoded, encodeErr := json.Marshal(resource.ID()) + if encodeErr != nil { + return Record{}, encodeErr + } + proxy["id"] = encoded } } - object["proxies"], _ = json.Marshal(proxies) - value, _ = json.Marshal(object) + encoded, encodeErr := json.Marshal(proxies) + if encodeErr != nil { + return Record{}, encodeErr + } + object["proxies"] = encoded + encoded, encodeErr = json.Marshal(object) + if encodeErr != nil { + return Record{}, encodeErr + } + value = encoded } value, err := s.mergeSecrets(ctx, key, value) if err != nil { return Record{}, err } if err := json.Unmarshal(value, &object); err != nil { + slog.WarnContext(ctx, "操作失败", "module", "setting", "operation", "Put", "error", err) return Record{}, errors.New("value 必须是 JSON 对象") } if err := validate(key, object); err != nil { @@ -280,6 +300,7 @@ func (s *Service) mergeSecrets(ctx context.Context, key string, value json.RawMe } var next, previous map[string]any if err := json.Unmarshal(value, &next); err != nil { + slog.WarnContext(ctx, "操作失败", "module", "setting", "operation", "mergeSecrets", "error", err) return nil, errors.New("value 必须是 JSON 对象") } if err := json.Unmarshal(existing.Value, &previous); err != nil { @@ -377,6 +398,7 @@ func validate(key string, value map[string]json.RawMessage) error { case "email": data, err := json.Marshal(value) if err != nil { + slog.Warn("操作失败", "module", "setting", "operation", "validate", "error", err) return errors.New("邮件配置格式无效") } var config emailConfig @@ -400,6 +422,7 @@ func validate(key string, value map[string]json.RawMessage) error { func rawString(value json.RawMessage) string { var result string if err := json.Unmarshal(value, &result); err != nil { + slog.Warn("操作失败", "module", "setting", "operation", "rawString", "error", err) return "" } return result diff --git a/monkeyai/backend/internal/skill/package.go b/monkeyai/backend/internal/skill/package.go index a32251578..b9a386012 100644 --- a/monkeyai/backend/internal/skill/package.go +++ b/monkeyai/backend/internal/skill/package.go @@ -7,6 +7,7 @@ import ( "encoding/hex" "fmt" "io" + "log/slog" "path" "regexp" "sort" @@ -35,6 +36,7 @@ func Parse(b []byte) (Package, error) { } r, err := zip.NewReader(bytes.NewReader(b), int64(len(b))) if err != nil { + slog.Warn("操作失败", "module", "skill", "operation", "Parse", "error", err) return p, fmt.Errorf("无效 ZIP") } root := "" @@ -61,9 +63,14 @@ func Parse(b []byte) (Package, error) { return p, err } data, err := io.ReadAll(io.LimitReader(rd, int64(MaxExpanded-total+1))) - rd.Close() + if err := rd.Close(); err != nil { + slog.Error("关闭资源失败", "module", "skill", "operation", "Parse", "error", err) + } total += len(data) if err != nil || total > MaxExpanded { + if err != nil { + slog.Warn("操作失败", "module", "skill", "operation", "Parse", "error", err) + } return p, fmt.Errorf("技能包损坏或解包大小超限") } p.Files[name] = data @@ -99,6 +106,7 @@ func Parse(b []byte) (Package, error) { return p, fmt.Errorf("SKILL.md 元信息未闭合") } if err = yaml.Unmarshal([]byte(text[4:4+end]), &p.Front); err != nil { + slog.Warn("操作失败", "module", "skill", "operation", "Parse", "error", err) return p, fmt.Errorf("SKILL.md 元信息无效") } p.Name, _ = p.Front["name"].(string) diff --git a/monkeyai/backend/internal/skill/service.go b/monkeyai/backend/internal/skill/service.go index 45a6c4811..7be9744b5 100644 --- a/monkeyai/backend/internal/skill/service.go +++ b/monkeyai/backend/internal/skill/service.go @@ -4,12 +4,13 @@ import ( "context" "encoding/json" "fmt" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "io" "log/slog" "net/http" "strconv" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/identity" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resource" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/skill/sqlc" @@ -47,6 +48,9 @@ func (s *Service) read(ctx context.Context, object resource.Object) (Package, er } p, err := Parse(b) if err != nil || int64(len(b)) != object.Int("package_size_bytes") || p.SHA != object.String("package_sha256") { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "skill", "operation", "read", "error", err) + } return Package{}, &resource.Error{Status: 502, Code: "storage_corrupted", Message: "技能包大小或摘要不一致，请重新上传"} } return p, nil @@ -158,6 +162,7 @@ func (s *Service) manifest(w http.ResponseWriter, r *http.Request, personal bool func (s *Service) upload(w http.ResponseWriter, r *http.Request, personal bool) { r.Body = http.MaxBytesReader(w, r.Body, MaxPackage+(1<<20)) if err := r.ParseMultipartForm(1 << 20); err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "skill", "operation", "upload", "error", err) resource.Fail(r.Context(), w, resource.Invalid("技能包上传无效或超限")) return } @@ -168,6 +173,7 @@ func (s *Service) upload(w http.ResponseWriter, r *http.Request, personal bool) }() f, _, err := r.FormFile("package") if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "skill", "operation", "upload", "error", err) resource.Fail(r.Context(), w, resource.Invalid("缺少 package")) return } @@ -189,6 +195,9 @@ func (s *Service) upload(w http.ResponseWriter, r *http.Request, personal bool) in := resource.Object{} if meta := r.FormValue("metadata"); meta != "" { if err = json.Unmarshal([]byte(meta), &in); err != nil || in == nil { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "skill", "operation", "upload", "error", err) + } resource.Fail(r.Context(), w, resource.Invalid("元数据格式无效")) return } diff --git a/monkeyai/backend/internal/stats/conversations.go b/monkeyai/backend/internal/stats/conversations.go index d8b53f3f7..1b6ddddd3 100644 --- a/monkeyai/backend/internal/stats/conversations.go +++ b/monkeyai/backend/internal/stats/conversations.go @@ -2,6 +2,7 @@ package stats import ( "context" + "log/slog" "net/http" "strconv" "strings" @@ -39,6 +40,9 @@ func parseConversationFilter(r *http.Request) (conversationFilter, error) { if f.params.TaskID != "" { var id pgtype.UUID if err := id.Scan(f.params.TaskID); err != nil || !id.Valid { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "stats", "operation", "parseConversationFilter", "error", err) + } return f, resource.Invalid("task_id 无效") } } @@ -52,6 +56,7 @@ func parseConversationFilter(r *http.Request) (conversationFilter, error) { if value := q.Get(field.name); value != "" { at, err := time.Parse(time.RFC3339, value) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "stats", "operation", "parseConversationFilter", "error", err) return f, resource.Invalid(field.name + " 需使用带时区的 RFC3339 时间") } *field.target = &at @@ -71,6 +76,9 @@ func parseConversationFilter(r *http.Request) (conversationFilter, error) { if value := q.Get(field.name); value != "" { n, err := strconv.Atoi(value) if err != nil || n < 1 || n > field.maximum { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "stats", "operation", "parseConversationFilter", "error", err) + } return f, resource.Invalid(field.message) } *field.target = n diff --git a/monkeyai/backend/internal/stats/history.go b/monkeyai/backend/internal/stats/history.go index f7a18ceac..3680d8e8a 100644 --- a/monkeyai/backend/internal/stats/history.go +++ b/monkeyai/backend/internal/stats/history.go @@ -2,6 +2,7 @@ package stats import ( "context" + "log/slog" "net/http" "strconv" "strings" @@ -9,7 +10,6 @@ import ( "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resource" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/stats/sqlc" - "github.com/jackc/pgx/v5" ) @@ -25,6 +25,7 @@ func (s *Service) history(w http.ResponseWriter, r *http.Request) { if value := q.Get(key); value != "" { at, err := time.Parse(time.RFC3339, value) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "stats", "operation", "history", "error", err) resource.Fail(r.Context(), w, resource.Invalid("筛选时间需使用带时区的 ISO 格式")) return } @@ -40,6 +41,9 @@ func (s *Service) history(w http.ResponseWriter, r *http.Request) { if value := q.Get(key); value != "" { n, err := strconv.Atoi(value) if err != nil || n < 1 || n > 1_000_000 || (key == "page_size" && n > 500) { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "stats", "operation", "history", "error", err) + } resource.Fail(r.Context(), w, resource.Invalid("分页参数无效")) return } diff --git a/monkeyai/backend/internal/stats/reporting_detail.go b/monkeyai/backend/internal/stats/reporting_detail.go index ee6957d6b..bc683fb79 100644 --- a/monkeyai/backend/internal/stats/reporting_detail.go +++ b/monkeyai/backend/internal/stats/reporting_detail.go @@ -2,6 +2,7 @@ package stats import ( "context" + "log/slog" "net/http" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/resource" @@ -15,6 +16,9 @@ func (s *Service) reportingDetail(w http.ResponseWriter, r *http.Request) { id := chi.URLParam(r, "id") var uuid pgtype.UUID if err := uuid.Scan(id); err != nil || !uuid.Valid { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "stats", "operation", "reportingDetail", "error", err) + } w.Header().Set("Cache-Control", "private, no-store") resource.Fail(r.Context(), w, resource.Invalid("会话 ID 无效")) return diff --git a/monkeyai/backend/internal/stats/reporting_filter.go b/monkeyai/backend/internal/stats/reporting_filter.go index 621866220..ec038e24a 100644 --- a/monkeyai/backend/internal/stats/reporting_filter.go +++ b/monkeyai/backend/internal/stats/reporting_filter.go @@ -7,6 +7,7 @@ import ( "encoding/hex" "encoding/json" "errors" + "log/slog" "net/http" "net/url" "strconv" @@ -36,6 +37,7 @@ func parseReportingFilter(r *http.Request, now time.Time, maxLimit int) (reporti } at, err := time.Parse(time.RFC3339, q.Get(key)) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "stats", "operation", "parseReportingFilter", "error", err) return f, resource.Invalid(key + " 需使用 RFC3339 时间") } if key == "from" { @@ -47,6 +49,9 @@ func parseReportingFilter(r *http.Request, now time.Time, maxLimit int) (reporti if q.Has("limit") { n, err := strconv.Atoi(q.Get("limit")) if err != nil || n < 1 || n > maxLimit { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "stats", "operation", "parseReportingFilter", "error", err) + } return f, resource.Invalid("limit 必须为 1 至 " + strconv.Itoa(maxLimit)) } f.limit = n @@ -64,6 +69,9 @@ func parseReportingFilter(r *http.Request, now time.Time, maxLimit int) (reporti if *item.target != "" { var id pgtype.UUID if err := id.Scan(*item.target); err != nil || !id.Valid { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "stats", "operation", "parseReportingFilter", "error", err) + } return f, resource.Invalid(item.name + " 无效") } } @@ -96,6 +104,7 @@ func parseReportingFilter(r *http.Request, now time.Time, maxLimit int) (reporti if q.Has(item.name) { value, err := strconv.ParseBool(q.Get(item.name)) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "stats", "operation", "parseReportingFilter", "error", err) return f, resource.Invalid(item.name + " 无效") } *item.target = value @@ -109,17 +118,22 @@ func parseReportingFilter(r *http.Request, now time.Time, maxLimit int) (reporti var c reportCursor raw, err := base64.RawURLEncoding.DecodeString(f.cursor) if err != nil || json.Unmarshal(raw, &c) != nil { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "stats", "operation", "parseReportingFilter", "error", err) + } return f, resource.Invalid("cursor 无效") } if !q.Has("from") { f.from, err = time.Parse(time.RFC3339Nano, c.From) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "stats", "operation", "parseReportingFilter", "error", err) return f, resource.Invalid("cursor 时间无效") } } if !q.Has("until") { f.until, err = time.Parse(time.RFC3339Nano, c.Until) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "stats", "operation", "parseReportingFilter", "error", err) return f, resource.Invalid("cursor 时间无效") } } @@ -169,7 +183,11 @@ func (f reportingFilter) sqlParams(c reportCursor, sessionID string) []byte { "outcome": optional(f.outcome), "include_placeholders": f.placeholders, "include_purged": f.purged, "cursor_key": optional(c.Key), "session_id": optional(sessionID), } - data, _ := json.Marshal(values) + data, err := json.Marshal(values) + if err != nil { + slog.Error("编码统计筛选条件失败", "error", err) + return nil + } return data } @@ -182,6 +200,9 @@ func (f reportingFilter) decodeCursor() (reportCursor, error) { var c reportCursor raw, err := base64.RawURLEncoding.DecodeString(f.cursor) if err != nil || json.Unmarshal(raw, &c) != nil || c.Fingerprint != f.fingerprint || c.From != f.from.Format(time.RFC3339Nano) || c.Until != f.until.Format(time.RFC3339Nano) { + if err != nil { + slog.Warn("操作失败", "module", "stats", "operation", "decodeCursor", "error", err) + } return c, resource.Invalid("cursor 无效或筛选条件已变化") } return c, nil @@ -189,7 +210,11 @@ func (f reportingFilter) decodeCursor() (reportCursor, error) { func (f reportingFilter) encodeCursor(c reportCursor) string { c.Fingerprint = f.fingerprint c.From, c.Until = f.from.Format(time.RFC3339Nano), f.until.Format(time.RFC3339Nano) - raw, _ := json.Marshal(c) + raw, err := json.Marshal(c) + if err != nil { + slog.Error("编码统计游标失败", "error", err) + return "" + } return base64.RawURLEncoding.EncodeToString(raw) } diff --git a/monkeyai/backend/internal/testmember/member.go b/monkeyai/backend/internal/testmember/member.go index e92596e64..77f7356b8 100644 --- a/monkeyai/backend/internal/testmember/member.go +++ b/monkeyai/backend/internal/testmember/member.go @@ -3,6 +3,7 @@ package testmember import ( "context" "errors" + "log/slog" "time" groupdb "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/group/sqlc" @@ -26,7 +27,11 @@ func (w userWriter) EnsureInitialAdmin(ctx context.Context, in member.InitialAdm if err != nil { return err } - defer tx.Rollback(context.WithoutCancel(ctx)) + defer func() { + if err := tx.Rollback(context.WithoutCancel(ctx)); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + slog.Error("回滚事务失败", "module", "testmember", "operation", "EnsureInitialAdmin", "error", err) + } + }() q := sqlc.New(tx) if _, err = q.LockInitialAdmin(ctx); err != nil { return err @@ -53,7 +58,11 @@ func (w userWriter) CreateUser(ctx context.Context, in member.CreateUser) (membe if err != nil { return member.User{}, err } - defer tx.Rollback(context.WithoutCancel(ctx)) + defer func() { + if err := tx.Rollback(context.WithoutCancel(ctx)); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + slog.Error("回滚事务失败", "module", "testmember", "operation", "CreateUser", "error", err) + } + }() q := sqlc.New(tx) if err = q.LockUserCreationGroups(ctx); err != nil { return member.User{}, err diff --git a/monkeyai/backend/internal/videogen/cleanup.go b/monkeyai/backend/internal/videogen/cleanup.go index 3ef1a3802..d98cad400 100644 --- a/monkeyai/backend/internal/videogen/cleanup.go +++ b/monkeyai/backend/internal/videogen/cleanup.go @@ -2,8 +2,11 @@ package videogen import ( "context" + "errors" + "log/slog" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/videogen/sqlc" + "github.com/jackc/pgx/v5" ) func (s *Service) Cleanup(ctx context.Context) error { @@ -26,7 +29,9 @@ func (s *Service) Cleanup(ctx context.Context) error { err = q.RemoveExpiredVideoInput(ctx, input.ID) } if err != nil { - _ = transaction.Rollback(ctx) + if err := transaction.Rollback(ctx); err != nil && !errors.Is(err, pgx.ErrTxClosed) { + slog.Error("回滚事务失败", "module", "videogen", "operation", "Cleanup", "error", err) + } return err } if err := transaction.Commit(ctx); err != nil { diff --git a/monkeyai/backend/internal/videogen/diagnostics_test.go b/monkeyai/backend/internal/videogen/diagnostics_test.go index a1f53c985..b8fdd551e 100644 --- a/monkeyai/backend/internal/videogen/diagnostics_test.go +++ b/monkeyai/backend/internal/videogen/diagnostics_test.go @@ -92,7 +92,8 @@ func TestOutputFailureDiagnostics(t *testing.T) { Code string `json:"error_code"` } `json:"error"` } - if err := json.Unmarshal(logs.Bytes(), &row); err != nil { + lines := bytes.Split(bytes.TrimSpace(logs.Bytes()), []byte("\n")) + if err := json.Unmarshal(lines[len(lines)-1], &row); err != nil { t.Fatal(err) } if row.Phase != "save_output" || !row.Proxy || row.Output.Phase != tc.phase || row.Error.Code != tc.code { diff --git a/monkeyai/backend/internal/videogen/http.go b/monkeyai/backend/internal/videogen/http.go index b0860430c..4f54835ec 100644 --- a/monkeyai/backend/internal/videogen/http.go +++ b/monkeyai/backend/internal/videogen/http.go @@ -6,6 +6,7 @@ import ( "encoding/json" "errors" "io" + "log/slog" "math/big" "net" "net/http" @@ -59,6 +60,9 @@ func providerClient() *http.Client { } ips, err := net.DefaultResolver.LookupNetIP(ctx, "ip", host) if err != nil || len(ips) == 0 { + if err != nil { + slog.Warn("操作失败", "module", "videogen", "operation", "providerClient", "error", err) + } return nil, errResolveFailed } for _, ip := range ips { @@ -84,10 +88,16 @@ func providerClient() *http.Client { func providerURL(base, endpoint string) (string, error) { u, err := url.Parse(base) if err != nil || (u.Scheme != "http" && u.Scheme != "https") || u.Hostname() == "" || u.User != nil || u.Fragment != "" || u.RawQuery != "" { + if err != nil { + slog.Warn("操作失败", "module", "videogen", "operation", "providerURL", "error", err) + } return "", errUpstreamURL } suffix, err := url.Parse(endpoint) if err != nil || suffix.IsAbs() || suffix.Host != "" || suffix.User != nil || suffix.Fragment != "" { + if err != nil { + slog.Warn("操作失败", "module", "videogen", "operation", "providerURL", "error", err) + } return "", errUpstreamEndpoint } u.Path = strings.TrimRight(u.Path, "/") + "/" + strings.TrimLeft(suffix.Path, "/") @@ -104,6 +114,9 @@ func providerJSON(ctx context.Context, client *http.Client, method, base, endpoi if payload != nil { encoded, err := json.Marshal(payload) if err != nil || len(encoded) > 40<<20 { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "videogen", "operation", "providerJSON", "error", err) + } return nil, 0, errors.New("视频上游请求超过大小限制") } body = bytes.NewReader(encoded) @@ -120,9 +133,16 @@ func providerJSON(ctx context.Context, client *http.Client, method, base, endpoi if err != nil { return nil, 0, err } - defer response.Body.Close() + defer func() { + if err := response.Body.Close(); err != nil { + slog.Error("关闭资源失败", "module", "videogen", "operation", "providerJSON", "error", err) + } + }() content, err := io.ReadAll(io.LimitReader(response.Body, maxProviderResponse+1)) if err != nil || len(content) > maxProviderResponse { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "videogen", "operation", "providerJSON", "error", err) + } return nil, 0, errors.New("视频上游响应过大或读取失败") } return content, response.StatusCode, nil @@ -152,6 +172,9 @@ func downloadClient(client *http.Client) *http.Client { func providerMedia(ctx context.Context, client *http.Client, address string) (io.ReadCloser, int64, error) { u, err := url.Parse(address) if err != nil || u.Scheme != "https" || u.Hostname() == "" || u.User != nil || u.Fragment != "" { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "videogen", "operation", "providerMedia", "error", err) + } return nil, 0, errOutputURL } client = downloadClient(client) @@ -173,7 +196,9 @@ func providerMedia(ctx context.Context, client *http.Client, address string) (io invalid = errOutputEmpty } if invalid.code != "" { - response.Body.Close() + if err := response.Body.Close(); err != nil { + slog.Error("关闭资源失败", "module", "videogen", "operation", "providerMedia", "error", err) + } return nil, 0, &mediaResponseError{diagnosticError: invalid, status: response.StatusCode, expected: response.ContentLength} } return response.Body, response.ContentLength, nil diff --git a/monkeyai/backend/internal/videogen/inputs.go b/monkeyai/backend/internal/videogen/inputs.go index d44fae26b..8a4b8f258 100644 --- a/monkeyai/backend/internal/videogen/inputs.go +++ b/monkeyai/backend/internal/videogen/inputs.go @@ -8,7 +8,10 @@ import ( "errors" "fmt" "image" + "log/slog" + _ "image/jpeg" + _ "image/png" "io" "math/big" @@ -40,6 +43,9 @@ func (s *Service) Upload(ctx context.Context, userID string, data []byte) (Input } config, format, err := image.DecodeConfig(bytes.NewReader(data)) if err != nil || config.Width < 1 || config.Height < 1 || int64(config.Width)*int64(config.Height) > maxInputPixels { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "videogen", "operation", "Upload", "error", err) + } return InputFile{}, resource.Invalid("视频参考图像素无效") } mime := "" @@ -66,7 +72,9 @@ func (s *Service) Upload(ctx context.Context, userID string, data []byte) (Input if err != nil { cleanup, cancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second) defer cancel() - _ = s.storage.Delete(cleanup, key) + if err := s.storage.Delete(cleanup, key); err != nil { + slog.Error("清理存储对象失败", "module", "videogen", "operation", "Upload", "error", err) + } return InputFile{}, err } return InputFile{FileID: id, MIMEType: mime, Width: config.Width, Height: config.Height, ExpiresAt: expiry}, nil @@ -97,9 +105,16 @@ func (s *Service) loadInput(ctx context.Context, userID string, ref Reference, s if err != nil { return Reference{}, err } - defer body.Close() + defer func() { + if err := body.Close(); err != nil { + slog.Error("关闭资源失败", "module", "videogen", "operation", "loadInput", "error", err) + } + }() data, err := io.ReadAll(io.LimitReader(body, maxInputBytes+1)) if err != nil || len(data) != int(row.ByteSize) { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "videogen", "operation", "loadInput", "error", err) + } return Reference{}, errors.New("参考图读取或大小校验失败") } digest := sha256.Sum256(data) diff --git a/monkeyai/backend/internal/videogen/outputs.go b/monkeyai/backend/internal/videogen/outputs.go index 9cf38bfb1..79b198243 100644 --- a/monkeyai/backend/internal/videogen/outputs.go +++ b/monkeyai/backend/internal/videogen/outputs.go @@ -7,6 +7,7 @@ import ( "errors" "fmt" "io" + "log/slog" "net/http" "os" "time" @@ -54,15 +55,27 @@ func (s *Service) saveOutput(ctx context.Context, client *http.Client, jobID, ad if err != nil { return VideoOutput{}, err } - defer stream.Close() + defer func() { + if err := stream.Close(); err != nil { + slog.Error("关闭资源失败", "module", "videogen", "operation", "saveOutput", "error", err) + } + }() failure.expected = expected failure.phase = "create_temp" file, err := os.CreateTemp("", "monkeyai-video-*.mp4") if err != nil { return VideoOutput{}, err } - defer os.Remove(file.Name()) - defer file.Close() + defer func() { + if err := os.Remove(file.Name()); err != nil && !os.IsNotExist(err) { + slog.Error("清理临时文件失败", "module", "videogen", "operation", "saveOutput", "error", err) + } + }() + defer func() { + if err := file.Close(); err != nil { + slog.Error("关闭资源失败", "module", "videogen", "operation", "saveOutput", "error", err) + } + }() failure.phase = "download_body" count, err := io.Copy(file, io.LimitReader(stream, maxOutputBytes+1)) failure.received = count @@ -81,6 +94,7 @@ func (s *Service) saveOutput(ctx context.Context, client *http.Client, jobID, ad failure.phase = "inspect_media" info, err := inspectMP4(file, count) if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "videogen", "operation", "saveOutput", "error", err) info = mediaInfo{DurationMs: upstreamDurationMs} } failure.phase = "hash_output" @@ -114,7 +128,9 @@ func (s *Service) saveOutput(ctx context.Context, client *http.Client, jobID, ad if err != nil { cleanup, cancel := context.WithTimeout(context.WithoutCancel(ctx), 5*time.Second) defer cancel() - _ = s.storage.Delete(cleanup, key) + if err := s.storage.Delete(cleanup, key); err != nil { + slog.Error("清理存储对象失败", "module", "videogen", "operation", "saveOutput", "error", err) + } return VideoOutput{}, err } return VideoOutput{FileID: id, URL: "/v1/videos/outputs/" + id, MIMEType: "video/mp4", Width: info.Width, Height: info.Height, diff --git a/monkeyai/backend/internal/videogen/provider.go b/monkeyai/backend/internal/videogen/provider.go index 7a7120083..cda3ef6eb 100644 --- a/monkeyai/backend/internal/videogen/provider.go +++ b/monkeyai/backend/internal/videogen/provider.go @@ -6,6 +6,7 @@ import ( "encoding/json" "errors" "fmt" + "log/slog" "net/http" "net/url" "strconv" @@ -90,6 +91,7 @@ func submitProvider(ctx context.Context, client *http.Client, target proxy.Targe endpoint = "/contents/generations/tasks" var audio bool if err := json.Unmarshal(input.Params["generate_audio"], &audio); err != nil { + slog.WarnContext(ctx, "操作失败", "module", "videogen", "operation", "submitProvider", "error", err) return "", errors.New("视频音频开关无效") } request["generate_audio"] = audio @@ -254,6 +256,9 @@ func queryProvider(ctx context.Context, client *http.Client, target proxy.Target result.Status = "succeeded" result.DurationMs, err = durationMillis(value, maxSeconds) if err != nil || result.URL == "" { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "videogen", "operation", "queryProvider", "error", err) + } return providerResult{}, errors.New("视频供应商未提供可验证的结果") } case "failed", "expired", "cancelled": diff --git a/monkeyai/backend/internal/videogen/service.go b/monkeyai/backend/internal/videogen/service.go index 8c48b5bfd..54284c0ce 100644 --- a/monkeyai/backend/internal/videogen/service.go +++ b/monkeyai/backend/internal/videogen/service.go @@ -6,13 +6,14 @@ import ( "encoding/hex" "encoding/json" "errors" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "log/slog" "net/http" "strings" "sync" "time" + "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" + "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/billing" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/model" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/proxy" @@ -94,6 +95,9 @@ func (s *Service) Submit(ctx context.Context, target proxy.Target, input Generat } cap, err := model.VideoCapabilitiesFor(item.Provider, item.ModelID) if err != nil || model.ValidateVideoCapabilities(item, cap) != nil { + if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "videogen", "operation", "Submit", "error", err) + } return Task{}, resource.Invalid("视频模型能力不可用") } values, err := model.NormalizeVideoParams(item.VideoConfig, cap, input.Mode, input.Params) @@ -173,14 +177,21 @@ func (s *Service) Submit(ctx context.Context, target proxy.Target, input Generat }) if err != nil { if key != "" { - if existing, _ := s.idempotent(ctx, target.UserID, key, requestHash); existing != "" { + existing, lookupErr := s.idempotent(ctx, target.UserID, key, requestHash) + if lookupErr != nil { + return Task{}, errors.Join(err, lookupErr) + } + if existing != "" { return s.GetTask(ctx, target.UserID, existing) } } return Task{}, err } jobID := resource.ID() - priceJSON, _ := json.Marshal(price) + priceJSON, err := json.Marshal(price) + if err != nil { + return Task{}, errors.Join(err, s.billing.Release(context.WithoutCancel(ctx), reservation.ID, "task_encode_failed")) + } err = sqlc.New(s.pool).InsertVideoJob(ctx, sqlc.InsertVideoJobParams{ ID: jobID, UserID: target.UserID, ModelID: item.ID, SessionID: target.SessionID, Provider: string(item.Provider), Mode: string(input.Mode), RequestHash: requestHash, @@ -188,7 +199,9 @@ func (s *Service) Submit(ctx context.Context, target proxy.Target, input Generat BillingTransactionID: reservation.ID, }) if err != nil { - _ = s.billing.Release(context.WithoutCancel(ctx), reservation.ID, "task_create_failed") + if err := s.billing.Release(context.WithoutCancel(ctx), reservation.ID, "task_create_failed"); err != nil { + slog.Error("释放计费预留失败", "module", "videogen", "operation", "Submit", "error", err) + } return Task{}, err } for ordinal, ref := range loaded { @@ -320,16 +333,21 @@ func (s *Service) fail(ctx context.Context, id, transactionID, reason string) { if err := s.billing.Release(ctx, transactionID, reason); err != nil { logging.Event(ctx, slog.Default(), slog.LevelError, "videogen.operation.error", "释放视频计费预留失败", "module", "videogen", "operation", "fail", "job_id", id, "error", err) code := "billing_unknown" - _ = sqlc.New(s.pool).MarkVideoJobUnknown(ctx, sqlc.MarkVideoJobUnknownParams{ID: id, ErrorCode: &code}) + if err := sqlc.New(s.pool).MarkVideoJobUnknown(ctx, sqlc.MarkVideoJobUnknownParams{ID: id, ErrorCode: &code}); err != nil { + slog.Error("更新视频任务状态失败", "module", "videogen", "operation", "fail", "error", err) + } return } - _ = sqlc.New(s.pool).MarkVideoJobFailed(ctx, sqlc.MarkVideoJobFailedParams{ID: id, ErrorCode: &reason}) + if err := sqlc.New(s.pool).MarkVideoJobFailed(ctx, sqlc.MarkVideoJobFailedParams{ID: id, ErrorCode: &reason}); err != nil { + slog.Error("更新视频任务状态失败", "module", "videogen", "operation", "fail", "error", err) + } } func (s *Service) dispatch(ctx context.Context, target proxy.Target, jobID, reservationID string, input GenerateInput) { ctx, cancel := context.WithTimeout(ctx, time.Minute) defer cancel() if err := s.billing.Start(ctx, reservationID); err != nil { + logging.Diagnostic(ctx, slog.Default(), slog.LevelError, "billing.start.failed", err, slog.String("job_id", jobID), slog.String("transaction_id", reservationID)) s.fail(ctx, jobID, reservationID, "billing_start_failed") return } @@ -337,19 +355,27 @@ func (s *Service) dispatch(ctx context.Context, target proxy.Target, jobID, rese if err != nil { var rejected providerRejected if errors.As(err, &rejected) { + logging.Diagnostic(ctx, slog.Default(), slog.LevelWarn, "video.provider.rejected", err, slog.String("job_id", jobID)) s.fail(ctx, jobID, reservationID, "provider_rejected") return } logging.Event(ctx, slog.Default(), slog.LevelWarn, "videogen.operation.warn", "视频上游受理结果未知", "module", "videogen", "operation", "dispatch", "job_id", jobID, "error", err) code := "provider_submit_unknown" - _ = sqlc.New(s.pool).MarkVideoJobUnknown(ctx, sqlc.MarkVideoJobUnknownParams{ID: jobID, ErrorCode: &code}) + if err := sqlc.New(s.pool).MarkVideoJobUnknown(ctx, sqlc.MarkVideoJobUnknownParams{ID: jobID, ErrorCode: &code}); err != nil { + slog.Error("更新视频任务状态失败", "module", "videogen", "operation", "dispatch", "error", err) + } return } if affected, e := sqlc.New(s.pool).MarkVideoJobSubmitted(ctx, sqlc.MarkVideoJobSubmittedParams{ID: jobID, ProviderJobID: &providerID}); e != nil || affected != 1 { err = e + if err == nil { + err = errors.New("视频任务状态已变化，未登记上游任务") + } logging.Event(ctx, slog.Default(), slog.LevelError, "videogen.operation.error", "登记视频上游任务失败", "module", "videogen", "operation", "dispatch", "job_id", jobID, "error", err) code := "provider_job_unknown" - _ = sqlc.New(s.pool).MarkVideoJobUnknown(ctx, sqlc.MarkVideoJobUnknownParams{ID: jobID, ErrorCode: &code}) + if err := sqlc.New(s.pool).MarkVideoJobUnknown(ctx, sqlc.MarkVideoJobUnknownParams{ID: jobID, ErrorCode: &code}); err != nil { + slog.Error("更新视频任务状态失败", "module", "videogen", "operation", "dispatch", "error", err) + } } } diff --git a/monkeyai/backend/internal/videoproxy/proxy.go b/monkeyai/backend/internal/videoproxy/proxy.go index 909d66a83..b67a3faa0 100644 --- a/monkeyai/backend/internal/videoproxy/proxy.go +++ b/monkeyai/backend/internal/videoproxy/proxy.go @@ -6,6 +6,7 @@ import ( "errors" "fmt" "io" + "log/slog" "net/http" "strconv" "strings" @@ -54,6 +55,9 @@ func (p *Proxy) authorize(w http.ResponseWriter, r *http.Request) (string, strin } userID, err := p.keys.Authenticate(r.Context(), credential, "model:invoke") if err != nil || userID == "" { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "videoproxy", "operation", "authorize", "error", err) + } resource.Fail(r.Context(), w, &resource.Error{Status: http.StatusUnauthorized, Code: "unauthorized", Message: "API Key 无效"}) return "", "", false } @@ -68,16 +72,23 @@ func (p *Proxy) upload(w http.ResponseWriter, r *http.Request) { r.Body = http.MaxBytesReader(w, r.Body, 11<<20) parts, err := r.MultipartReader() if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "videoproxy", "operation", "upload", "error", err) resource.Fail(r.Context(), w, resource.Invalid("参考图上传格式无效")) return } part, err := parts.NextPart() if err != nil || part.FormName() != "file" { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "videoproxy", "operation", "upload", "error", err) + } resource.Fail(r.Context(), w, resource.Invalid("缺少参考图 file 字段")) return } data, err := io.ReadAll(io.LimitReader(part, (10<<20)+1)) if err != nil || len(data) == 0 || len(data) > 10<<20 { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "videoproxy", "operation", "upload", "error", err) + } resource.Fail(r.Context(), w, &resource.Error{Status: http.StatusRequestEntityTooLarge, Code: "video_input_too_large", Message: "视频参考图超过大小限制"}) return } @@ -106,6 +117,9 @@ func (p *Proxy) generate(w http.ResponseWriter, r *http.Request) { decoder := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)) decoder.DisallowUnknownFields() if err := decoder.Decode(&input); err != nil || input.Model == "" || input.Mode == "" { + if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "videoproxy", "operation", "generate", "error", err) + } resource.Fail(r.Context(), w, resource.Invalid("视频生成请求格式无效")) return } @@ -172,30 +186,40 @@ func (p *Proxy) output(w http.ResponseWriter, r *http.Request) { resource.Fail(r.Context(), w, err) return } - defer body.Close() + defer func() { + if err := body.Close(); err != nil { + slog.Error("关闭资源失败", "module", "videoproxy", "operation", "output", "error", err) + } + }() w.Header().Set("Cache-Control", "private, no-store") w.Header().Set("X-Content-Type-Options", "nosniff") w.Header().Set("Content-Type", mime) w.Header().Set("Accept-Ranges", "bytes") start, end, ranged, err := parseRange(r.Header.Get("Range"), size) if err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "videoproxy", "operation", "output", "error", err) w.Header().Set("Content-Range", fmt.Sprintf("bytes */%d", size)) w.WriteHeader(http.StatusRequestedRangeNotSatisfiable) return } if ranged { if _, err := io.CopyN(io.Discard, body, start); err != nil { + slog.WarnContext(r.Context(), "操作失败", "module", "videoproxy", "operation", "output", "error", err) return } w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", start, end, size)) w.Header().Set("Content-Length", strconv.FormatInt(end-start+1, 10)) w.WriteHeader(http.StatusPartialContent) - _, _ = io.CopyN(w, body, end-start+1) + if _, err := io.CopyN(w, body, end-start+1); err != nil { + slog.Error("传输响应失败", "module", "videoproxy", "operation", "output", "error", err) + } return } w.Header().Set("Content-Length", strconv.FormatInt(size, 10)) w.WriteHeader(http.StatusOK) - _, _ = io.CopyN(w, body, size) + if _, err := io.CopyN(w, body, size); err != nil { + slog.Error("传输响应失败", "module", "videoproxy", "operation", "output", "error", err) + } } func parseRange(header string, size int64) (int64, int64, bool, error) { @@ -212,6 +236,9 @@ func parseRange(header string, size int64) (int64, int64, bool, error) { if parts[0] == "" { length, err := strconv.ParseInt(parts[1], 10, 64) if err != nil || length <= 0 { + if err != nil { + slog.Warn("操作失败", "module", "videoproxy", "operation", "parseRange", "error", err) + } return 0, 0, false, errors.New("视频 Range 长度无效") } if length > size { @@ -221,12 +248,18 @@ func parseRange(header string, size int64) (int64, int64, bool, error) { } start, err := strconv.ParseInt(parts[0], 10, 64) if err != nil || start >= size || start < 0 { + if err != nil { + slog.Warn("操作失败", "module", "videoproxy", "operation", "parseRange", "error", err) + } return 0, 0, false, errors.New("视频 Range 起点无效") } end := size - 1 if parts[1] != "" { end, err = strconv.ParseInt(parts[1], 10, 64) if err != nil || end < start { + if err != nil { + slog.Warn("操作失败", "module", "videoproxy", "operation", "parseRange", "error", err) + } return 0, 0, false, errors.New("视频 Range 终点无效") } if end >= size { diff --git a/monkeyai/backend/logging/benchmark_test.go b/monkeyai/backend/logging/benchmark_test.go index 32da0805d..ee2b583ac 100644 --- a/monkeyai/backend/logging/benchmark_test.go +++ b/monkeyai/backend/logging/benchmark_test.go @@ -9,12 +9,8 @@ import ( ) func BenchmarkHTTPStreaming(b *testing.B) { - r, err := NewRuntime(io.Discard, slog.LevelInfo, DefaultSettings()) - if err != nil { - b.Fatal(err) - } - defer r.Close() - handler := HTTP(r.Logger())(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + logger := New(io.Discard, slog.LevelInfo) + handler := HTTP(logger)(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/event-stream") for i := 0; i < 10; i++ { _, _ = io.WriteString(w, "data: hello\n\n") diff --git a/monkeyai/backend/logging/context.go b/monkeyai/backend/logging/context.go index 471b8ca5c..458ef1d0b 100644 --- a/monkeyai/backend/logging/context.go +++ b/monkeyai/backend/logging/context.go @@ -122,11 +122,9 @@ func Event(ctx context.Context, logger *slog.Logger, level slog.Level, event, me runtime.Callers(2, pc[:]) clean := slog.NewRecord(record.Time, level, message, pc[0]) clean.AddAttrs(mergeAttrs(attrs)...) - _ = logger.Handler().Handle(ctx, clean) + handle(ctx, logger, clean) } -// Diagnostic records ownership before level filtering or deduplication. This -// prevents HTTP fallback errors from bypassing the primary event's policy. func syncRoute(ctx context.Context) { if state, ok := ctx.Value(contextKey{}).(*observation); ok { state.mu.Lock() @@ -161,7 +159,7 @@ func Diagnostic(ctx context.Context, logger *slog.Logger, level slog.Level, even } } record.AddAttrs(mergeAttrs(clean)...) - _ = logger.Handler().Handle(ctx, record) + handle(ctx, logger, record) } func contextAttrs(ctx context.Context) []slog.Attr { diff --git a/monkeyai/backend/logging/dedup.go b/monkeyai/backend/logging/dedup.go deleted file mode 100644 index 481bc845c..000000000 --- a/monkeyai/backend/logging/dedup.go +++ /dev/null @@ -1,343 +0,0 @@ -package logging - -import ( - "context" - "crypto/sha256" - "encoding/hex" - "errors" - "io" - "log/slog" - "os" - "sync" - "time" -) - -type Settings struct { - Enabled bool - Window time.Duration - MaxKeys int -} - -func DefaultSettings() Settings { return Settings{Enabled: true, Window: time.Minute, MaxKeys: 4096} } -func (s Settings) Validate() error { - if s.Window < time.Second || s.Window > 10*time.Minute || s.MaxKeys < 128 || s.MaxKeys > 65536 { - return errors.New("日志去重窗口或容量超出允许范围") - } - return nil -} - -type Snapshot struct { - Candidates, Details, Suppressed, Summaries, Overflow, OutputErrors uint64 - Calls, FailedCalls uint64 - Requests, FailedRequests uint64 - ActiveKeys int -} - -type entry struct { - key string - fields []slog.Attr - level slog.Level - event, fingerprint string - start, end, first, last, idle time.Time - window time.Duration - count, details uint64 - samples []string - sampleKey string - idleRound bool -} - -type Runtime struct { - mu sync.Mutex - settings Settings - output slog.Handler - logger *slog.Logger - entries map[string]*entry - stats Snapshot - now func() time.Time - stop, done chan struct{} - closed bool - closeOnce sync.Once - lastWarning time.Time -} - -// NewRuntime creates one scheduler and state container shared by all derived -// loggers. Its owner must close it after business workers and final events. -func NewRuntime(output io.Writer, level slog.Leveler, settings Settings) (*Runtime, error) { - if err := settings.Validate(); err != nil { - return nil, err - } - r := &Runtime{settings: settings, entries: make(map[string]*entry), now: time.Now, - stop: make(chan struct{}), done: make(chan struct{})} - r.output = jsonHandler(output, level) - r.logger = slog.New(&safeHandler{next: r.output, runtime: r}) - go func() { - defer close(r.done) - ticker := time.NewTicker(time.Second) - defer ticker.Stop() - for { - select { - case <-r.stop: - return - case <-ticker.C: - r.Flush() - } - } - }() - return r, nil -} - -func CountCall(logger *slog.Logger, result string) { - if r := runtimeFor(logger); r != nil { - r.mu.Lock() - r.stats.Calls++ - if result == "failed" { - r.stats.FailedCalls++ - } - r.mu.Unlock() - } -} - -func (r *Runtime) Logger() *slog.Logger { return r.logger } -func (r *Runtime) Snapshot() Snapshot { - r.mu.Lock() - defer r.mu.Unlock() - s := r.stats - s.ActiveKeys = len(r.entries) - return s -} - -func (r *Runtime) emit(ctx context.Context, record slog.Record) error { - err := r.output.Handle(ctx, record) - if err != nil { - r.mu.Lock() - r.stats.OutputErrors++ - now := r.now() - warn := r.lastWarning.IsZero() || now.Sub(r.lastWarning) >= time.Minute - if warn { - r.lastWarning = now - } - r.mu.Unlock() - if warn { - _, _ = io.WriteString(os.Stderr, "结构化日志输出失败\n") - } - } - return err -} - -func (r *Runtime) submit(ctx context.Context, record slog.Record) error { - fields := scalars(record) - event := fields["event"].Value.String() - policy, registered := policies[event] - key := "" - var safeFields []slog.Attr - if registered && r.settings.Enabled { - key, safeFields = fingerprint(record.Level, fields, policy) - } - r.mu.Lock() - r.stats.Candidates++ - if !r.settings.Enabled || !registered || key == "" || r.closed { - r.stats.Details++ - r.mu.Unlock() - return r.emit(ctx, record) - } - now := r.now() - var pending []slog.Record - e := r.entries[key] - if e != nil && !now.Before(e.end) { - empty := e.count == 0 - if summary, ok := r.settle(e, "window"); ok { - pending = append(pending, summary) - } - if empty || now.Sub(e.end) >= e.window { - e.idleRound = true - e.start, e.end = now, now.Add(e.window) - } else { - e.start = e.end - e.end = e.start.Add(e.window) - } - } - if e == nil { - if len(r.entries) >= r.settings.MaxKeys { - for k, old := range r.entries { - ttl := max(10*time.Minute, 2*old.window) - if old.count == 0 && now.Sub(old.idle) >= ttl { - delete(r.entries, k) - } - } - } - if len(r.entries) >= r.settings.MaxKeys { - r.stats.Overflow++ - overflow := r.stats.Overflow - r.stats.Details++ - warn := r.lastWarning.IsZero() || now.Sub(r.lastWarning) >= time.Minute - if warn { - r.lastWarning = now - } - r.mu.Unlock() - for _, p := range pending { - _ = r.emit(ctx, p) - } - if warn { - warning := slog.NewRecord(now, slog.LevelWarn, "日志去重容量已满", 0) - warning.AddAttrs(slog.String("event", "logging.capacity.exceeded"), slog.Uint64("overflow_count", overflow)) - if r.output.Enabled(ctx, warning.Level) { - _ = r.emit(ctx, warning) - } - } - return r.emit(ctx, record) - } - window := max(r.settings.Window, policy.window) - hash := sha256.Sum256([]byte(key)) - e = &entry{key: key, fields: safeFields, level: record.Level, event: event, - fingerprint: hex.EncodeToString(hash[:16]), start: now, end: now.Add(window), window: window, - details: 1, sampleKey: policy.sample} - r.entries[key] = e - r.stats.Details++ - } else { - if e.idleRound { - e.details = 1 - e.idleRound = false - e.start, e.end = now, now.Add(e.window) - r.stats.Details++ - } else { - r.stats.Suppressed++ - } - } - e.count++ - if e.first.IsZero() { - e.first = now - } - e.last, e.idle = now, now - if sample, ok := fields[policy.sample]; ok && sample.Value.String() != "" && len(e.samples) < 3 { - value := sample.Value.String() - found := false - for _, previous := range e.samples { - if previous == value { - found = true - } - } - if !found { - e.samples = append(e.samples, value) - } - } - detail := e.count == 1 && e.details == 1 - r.mu.Unlock() - for _, p := range pending { - _ = r.emit(ctx, p) - } - if detail { - return r.emit(ctx, record) - } - return nil -} - -// settle is called under mu. Filtering still settles the window; discarded -// summaries are never replayed after a runtime level change. -func (r *Runtime) settle(e *entry, reason string) (slog.Record, bool) { - defer func() { e.count, e.details = 0, 0; e.first = time.Time{}; e.samples = nil }() - if e.count <= e.details || !r.output.Enabled(context.Background(), e.level) { - return slog.Record{}, false - } - ended := e.end - if reason != "window" && r.now().Before(ended) { - ended = r.now() - } - record := slog.NewRecord(r.now(), e.level, "重复故障汇总", 0) - record.AddAttrs(e.fields...) - record.AddAttrs(slog.String("event", "logging.error.summary"), slog.String("original_event", e.event), - slog.String("original_level", e.level.String()), slog.String("fingerprint", e.fingerprint), - slog.Time("window_started_at", e.start), slog.Time("window_ended_at", ended), - slog.Float64("window_seconds", e.window.Seconds()), slog.String("flush_reason", reason), - slog.Time("first_seen_at", e.first), slog.Time("last_seen_at", e.last), - slog.Uint64("occurrence_count", e.count), slog.Uint64("detail_count", e.details), - slog.Uint64("suppressed_count", e.count-e.details)) - if len(e.samples) > 0 { - // The only collection retained by deduplication is a bounded list of - // validated scalar IDs; no errors, records or contexts are retained. - record.AddAttrs(slog.Any("sample_"+e.sampleKey+"s", append([]string(nil), e.samples...))) - } - r.stats.Summaries++ - return record, true -} - -func (r *Runtime) drain(all bool, reason string) { - r.mu.Lock() - now := r.now() - var pending []slog.Record - for key, e := range r.entries { - if all || !now.Before(e.end) { - empty := e.count == 0 - if summary, ok := r.settle(e, reason); ok { - pending = append(pending, summary) - } - if all { - delete(r.entries, key) - continue - } - if now.Sub(e.idle) >= max(10*time.Minute, 2*e.window) { - delete(r.entries, key) - } else { - if empty || now.Sub(e.end) >= e.window { - e.idleRound = true - e.start, e.end = now, now.Add(e.window) - } else { - e.start = e.end - e.end = e.start.Add(e.window) - } - } - } - } - r.mu.Unlock() - for _, record := range pending { - _ = r.emit(context.Background(), record) - } -} - -func (r *Runtime) Flush() { r.drain(false, "window") } -func (r *Runtime) Close() error { - r.closeOnce.Do(func() { - close(r.stop) - <-r.done - r.mu.Lock() - r.closed = true - r.mu.Unlock() - r.drain(true, "shutdown") - }) - return nil -} - -// Recovered ends exactly the selected failure scope. The observing worker, -// rather than silence in the log, decides when a dependency has recovered. -func (r *Runtime) Recovered(ctx context.Context, event string, fields ...slog.Attr) { - scope := slog.NewRecord(r.now(), slog.LevelWarn, "", 0) - scope.AddAttrs(fields...) - scope.AddAttrs(slog.String("event", event)) - values := scalars(scope) - r.mu.Lock() - var pending []slog.Record - for key, e := range r.entries { - if e.event != event { - continue - } - match := true - for _, a := range e.fields { - if a.Key == "event" || a.Key == "error_code" || a.Key == "error_type" || a.Key == "sqlstate" { - continue - } - if value, ok := values[a.Key]; !ok || !value.Equal(a) { - match = false - break - } - } - if match { - if record, ok := r.settle(e, "recovered"); ok { - pending = append(pending, record) - } - delete(r.entries, key) - } - } - r.mu.Unlock() - for _, record := range pending { - _ = r.emit(ctx, record) - } -} diff --git a/monkeyai/backend/logging/dedup_test.go b/monkeyai/backend/logging/dedup_test.go deleted file mode 100644 index e9fd7dbe1..000000000 --- a/monkeyai/backend/logging/dedup_test.go +++ /dev/null @@ -1,162 +0,0 @@ -package logging - -import ( - "bytes" - "context" - "encoding/json" - "fmt" - "io" - "log/slog" - "sync" - "testing" - "time" -) - -func runtimeTest(t *testing.T) (*Runtime, *bytes.Buffer, *slog.LevelVar, func(time.Duration)) { - t.Helper() - var output bytes.Buffer - level := new(slog.LevelVar) - level.Set(slog.LevelDebug) - r, err := NewRuntime(&output, level, Settings{true, time.Second, 128}) - if err != nil { - t.Fatal(err) - } - now := time.Unix(1700000000, 0) - r.mu.Lock() - r.now = func() time.Time { return now } - r.mu.Unlock() - t.Cleanup(func() { _ = r.Close() }) - return r, &output, level, func(d time.Duration) { r.mu.Lock(); now = now.Add(d); r.mu.Unlock() } -} -func records(t *testing.T, output *bytes.Buffer) []map[string]any { - t.Helper() - var result []map[string]any - decoder := json.NewDecoder(bytes.NewReader(output.Bytes())) - for { - var row map[string]any - err := decoder.Decode(&row) - if err == io.EOF { - return result - } - if err != nil { - t.Fatal(err) - } - result = append(result, row) - } -} -func repeatFailure(logger *slog.Logger, count int) { - for i := 0; i < count; i++ { - logger.Error("故障", "event", "model.call.completed", "operation", "proxy_request", "model_id", "m1", "request_id", fmt.Sprintf("r%d", i), "error_code", "connection_refused") - } -} -func TestDedupFixedWindowsAndIdle(t *testing.T) { - r, out, _, advance := runtimeTest(t) - derived := r.Logger().With("module", "proxy") - repeatFailure(derived, 1000) - advance(time.Second) - r.Flush() - rows := records(t, out) - if len(rows) != 2 || rows[1]["occurrence_count"] != float64(1000) || rows[1]["detail_count"] != float64(1) || rows[1]["suppressed_count"] != float64(999) { - t.Fatalf("首窗口计数错误: %v", rows) - } - if _, ok := rows[1]["request_id"]; ok { - t.Fatal("摘要含单一请求 ID") - } - repeatFailure(derived.WithGroup("gateway"), 600) - advance(time.Second) - r.Flush() - rows = records(t, out) - if len(rows) != 3 || rows[2]["occurrence_count"] != float64(600) || rows[2]["detail_count"] != float64(0) { - t.Fatalf("持续窗口计数错误: %v", rows) - } - advance(time.Second) - r.Flush() - repeatFailure(derived, 1) - if len(records(t, out)) != 4 { - t.Fatal("空闲后未直出首条") - } -} -func TestDedupFilteringCloseAndLateEvents(t *testing.T) { - r, out, level, advance := runtimeTest(t) - repeatFailure(r.Logger(), 10) - level.Set(slog.Level(12)) - advance(time.Second) - r.Flush() - level.Set(slog.LevelDebug) - r.Flush() - if len(records(t, out)) != 1 { - t.Fatal("重新调级补发了过期摘要") - } - repeatFailure(r.Logger(), 10) - _ = r.Close() - _ = r.Close() - rows := records(t, out) - if len(rows) != 2 || rows[1]["occurrence_count"] != float64(10) { - t.Fatalf("关闭刷新错误: %v", rows) - } - repeatFailure(r.Logger(), 2) - if len(records(t, out)) != 4 || r.Snapshot().ActiveKeys != 0 { - t.Fatal("迟到事件未直出") - } -} -func TestDedupCapacityAndUnknownEvents(t *testing.T) { - r, _, _, _ := runtimeTest(t) - for i := 0; i < 140; i++ { - r.Logger().Error("故障", "event", "model.call.completed", "operation", "proxy_request", "model_id", fmt.Sprint(i)) - } - if s := r.Snapshot(); s.ActiveKeys != 128 || s.Overflow != 12 { - t.Fatalf("容量错误: %+v", s) - } - r.Logger().Error("最终失败", "event", "billing.settlement.failed") - r.Logger().Error("最终失败", "event", "billing.settlement.failed") - if r.Snapshot().Suppressed != 0 { - t.Fatal("未登记事件被压制") - } -} -func TestDedupConcurrentAndRecovery(t *testing.T) { - r, out, _, _ := runtimeTest(t) - var wg sync.WaitGroup - for i := 0; i < 20; i++ { - wg.Go(func() { repeatFailure(r.Logger(), 50) }) - } - wg.Wait() - r.Recovered(context.Background(), "model.call.completed", slog.String("operation", "proxy_request"), slog.String("model_id", "m1")) - repeatFailure(r.Logger(), 1) - _ = r.Close() - rows := records(t, out) - if len(rows) != 3 || rows[1]["occurrence_count"] != float64(1000) { - t.Fatalf("恢复或并发计数错误: %v", rows) - } -} - -type failedOutput struct{} - -func (failedOutput) Write([]byte) (int, error) { return 0, io.ErrClosedPipe } -func TestOutputErrorStatistics(t *testing.T) { - r, err := NewRuntime(failedOutput{}, slog.LevelDebug, DefaultSettings()) - if err != nil { - t.Fatal(err) - } - defer r.Close() - r.Logger().Error("测试") - if r.Snapshot().OutputErrors != 1 { - t.Fatal("未统计输出故障") - } -} -func BenchmarkDedup(b *testing.B) { - for _, enabled := range []bool{false, true} { - b.Run(fmt.Sprint(enabled), func(b *testing.B) { - settings := DefaultSettings() - settings.Enabled = enabled - r, _ := NewRuntime(io.Discard, slog.LevelDebug, settings) - defer r.Close() - b.ReportAllocs() - b.ResetTimer() - b.RunParallel(func(pb *testing.PB) { - for pb.Next() { - repeatFailure(r.Logger(), 1) - } - }) - }) - } -} diff --git a/monkeyai/backend/logging/error.go b/monkeyai/backend/logging/error.go index b5a56a141..c27c35f84 100644 --- a/monkeyai/backend/logging/error.go +++ b/monkeyai/backend/logging/error.go @@ -5,6 +5,7 @@ import ( "crypto/tls" "crypto/x509" "errors" + "fmt" "log/slog" "net" "net/url" @@ -21,7 +22,7 @@ type dependencyError struct { cause error } -func (e *dependencyError) Error() string { return "依赖检查失败" } +func (e *dependencyError) Error() string { return e.name + ": " + e.cause.Error() } func (e *dependencyError) Unwrap() error { return e.cause } func Dependency(name string, err error) error { if err == nil { @@ -35,7 +36,7 @@ type DiagnosticCoder interface { DiagnosticCode() string } -// ErrorAttrs never formats the error, URL, SQL, certificate or its payload. +// ErrorAttrs 保留原始错误文本及用于检索的分类字段。 func ErrorAttrs(err error) []slog.Attr { if err == nil { return nil @@ -106,7 +107,7 @@ func ErrorAttrs(err error) []slog.Attr { if inner, ok := innerURLCause(err); ok { extra = append(extra, slog.String("cause_type", reflect.TypeOf(inner).String())) } - attrs := []slog.Attr{slog.String("error_code", code), slog.String("error_type", reflect.TypeOf(cause).String())} + attrs := []slog.Attr{slog.String("error_code", code), slog.String("error_type", reflect.TypeOf(cause).String()), slog.String("error_message", fmt.Sprint(err))} var dependency *dependencyError if errors.As(err, &dependency) { attrs = append(attrs, slog.String("dependency", dependency.name)) @@ -131,8 +132,7 @@ func tlsReason(err error) string { return "unknown" } -// innerURLCause unwraps nested *url.Error values so logs can show the root -// transport error's type without exposing its URL or message. +// innerURLCause 提取 URL 错误链中最内层的传输错误。 func innerURLCause(err error) (error, bool) { cause := err for range 8 { diff --git a/monkeyai/backend/logging/error_test.go b/monkeyai/backend/logging/error_test.go index 5f858361f..e95b281f0 100644 --- a/monkeyai/backend/logging/error_test.go +++ b/monkeyai/backend/logging/error_test.go @@ -16,7 +16,7 @@ import ( "github.com/jackc/pgx/v5/pgconn" ) -func TestErrorClassificationAndWrappedSecrets(t *testing.T) { +func TestErrorClassificationAndWrappedMessages(t *testing.T) { for _, test := range []struct { name string err error @@ -38,10 +38,13 @@ func TestErrorClassificationAndWrappedSecrets(t *testing.T) { values := map[string]string{} for _, a := range attrs { values[a.Key] = a.Value.String() - if strings.Contains(a.Value.String(), "private-") { + if a.Key != "error_message" && strings.Contains(a.Value.String(), "private-") { t.Fatal("错误分类泄漏秘密", a) } } + if values["error_message"] != fmt.Sprint(Dependency("database", err)) { + t.Fatalf("原始错误丢失: %v", values) + } if values["error_code"] != test.code || values["dependency"] != "database" || test.kind != "" && values["error_type"] != test.kind { t.Fatalf("分类错误: %v", values) } @@ -78,7 +81,7 @@ func TestErrorAttrsKeepsURLRootCause(t *testing.T) { values := map[string]string{} for _, a := range ErrorAttrs(err) { values[a.Key] = a.Value.String() - if strings.Contains(a.Value.String(), "private-") || strings.Contains(a.Value.String(), "example.test") { + if a.Key != "error_message" && (strings.Contains(a.Value.String(), "private-") || strings.Contains(a.Value.String(), "example.test")) { t.Fatal("根错误分类泄漏秘密", a) } } @@ -93,9 +96,9 @@ func (e domainError) Error() string { return "domain failure" } func (e domainError) DiagnosticCode() string { return e.code } func TestEventKeepsPollDiagnostics(t *testing.T) { - r, out, _, _ := runtimeTest(t) + logger, out := testLogger() err := &url.Error{Op: "Get", URL: "https://private-host.example/path?video_id=private", Err: domainError{code: "upstream_address_blocked"}} - Event(t.Context(), r.Logger(), slog.LevelWarn, "video.job.retry", "重试", "module", "videogen", "operation", "poll", "job_id", "job-1", "failures", int32(1), "phase", "query_provider", "proxy_used", true, "error", err) + Event(t.Context(), logger, slog.LevelWarn, "video.job.retry", "重试", "module", "videogen", "operation", "poll", "job_id", "job-1", "failures", int32(1), "phase", "query_provider", "proxy_used", true, "error", err) row := records(t, out)[0] if row["phase"] != "query_provider" || row["proxy_used"] != true { t.Fatalf("阶段或代理标记丢失: %v", row) @@ -104,14 +107,14 @@ func TestEventKeepsPollDiagnostics(t *testing.T) { if !ok || fields["error_code"] != "upstream_address_blocked" || fields["error_type"] != "*url.Error" || fields["cause_type"] != "logging.domainError" { t.Fatalf("根错误字段错误: %v", row) } - if strings.Contains(out.String(), "private") { + if fields["error_message"] != err.Error() { t.Fatal(out.String()) } } func TestDerivedHandlerPreservesSource(t *testing.T) { - r, out, _, _ := runtimeTest(t) - Event(t.Context(), r.Logger().With("module", "proxy").WithGroup("call"), slog.LevelInfo, "test.event", "测试") + logger, out := testLogger() + Event(t.Context(), logger.With("module", "proxy").WithGroup("call"), slog.LevelInfo, "test.event", "测试") row := records(t, out)[0] source, ok := row["source"].(map[string]any) if !ok || source["file"] != "error_test.go" || !strings.Contains(source["function"].(string), "TestDerivedHandlerPreservesSource") { diff --git a/monkeyai/backend/logging/http.go b/monkeyai/backend/logging/http.go index bbfbb6c82..199939021 100644 --- a/monkeyai/backend/logging/http.go +++ b/monkeyai/backend/logging/http.go @@ -44,11 +44,13 @@ func HTTP(logger *slog.Logger) func(http.Handler) http.Handler { } } Diagnostic(ctx, logger, slog.LevelError, "http.request.panicked", nil, - slog.String("error_type", fmt.Sprintf("%T", fault)), slog.Attr{Key: "stack", Value: slog.GroupValue(stack...)}) + slog.String("error_type", fmt.Sprintf("%T", fault)), slog.String("error_message", fmt.Sprint(fault)), slog.Attr{Key: "stack", Value: slog.GroupValue(stack...)}) if writer.status == 0 && !writer.hijacked { writer.Header().Set("Content-Type", "application/json; charset=utf-8") writer.WriteHeader(http.StatusInternalServerError) - _, _ = io.WriteString(writer, "{\"error\":{\"code\":\"internal_error\",\"message\":\"服务内部错误\"}}\n") + if _, err := io.WriteString(writer, "{\"error\":{\"code\":\"internal_error\",\"message\":\"服务内部错误\"}}\n"); err != nil { + Diagnostic(ctx, logger, slog.LevelError, "http.response.failed", err) + } } else { abort = true } @@ -64,14 +66,6 @@ func HTTP(logger *slog.Logger) func(http.Handler) http.Handler { diagnosed, expected := state.diagnosed, state.expected state.mu.Unlock() failed := writer.status >= 500 || writer.aborted || r.Context().Err() != nil - if rt := runtimeFor(logger); rt != nil { - rt.mu.Lock() - rt.stats.Requests++ - if failed { - rt.stats.FailedRequests++ - } - rt.mu.Unlock() - } result := "completed" if writer.hijacked { result = "upgraded" diff --git a/monkeyai/backend/logging/http_test.go b/monkeyai/backend/logging/http_test.go index eac317dae..35f69e373 100644 --- a/monkeyai/backend/logging/http_test.go +++ b/monkeyai/backend/logging/http_test.go @@ -17,12 +17,11 @@ import ( func TestHTTPRequestIdentityAndDiagnosticOwnership(t *testing.T) { var out bytes.Buffer - runtime, _ := NewRuntime(&out, slog.LevelDebug, DefaultSettings()) - defer runtime.Close() + logger := New(&out, slog.LevelDebug) router := chi.NewRouter() - router.Use(HTTP(runtime.Logger())) + router.Use(HTTP(logger)) router.Get("/items/{id}", func(w http.ResponseWriter, r *http.Request) { - Diagnostic(r.Context(), runtime.Logger(), slog.LevelError, "resource.operation.failed", errors.New("private")) + Diagnostic(r.Context(), logger, slog.LevelError, "resource.operation.failed", errors.New("数据库连接失败")) w.Header().Set("X-Request-ID", "upstream-forgery") w.WriteHeader(503) }) @@ -43,8 +42,8 @@ func TestHTTPRequestIdentityAndDiagnosticOwnership(t *testing.T) { t.Fatal("日志泄漏", secret) } } - if s := runtime.Snapshot(); s.Requests != 1 || s.FailedRequests != 1 { - t.Fatalf("请求计数错误: %+v", s) + if rows[0]["error_message"] != "数据库连接失败" { + t.Fatalf("原始错误丢失: %v", rows) } } func TestHTTPPanicAndAbort(t *testing.T) { @@ -88,8 +87,11 @@ func TestHTTPPanicAndAbort(t *testing.T) { t.Fatalf("异常恢复未返回通用 JSON 错误: %s", response.Body.String()) } } - if strings.Contains(out.String(), "secret-panic-value") || strings.Contains(response.Body.String(), "secret-panic-value") { - t.Fatal("panic 泄漏") + if strings.Contains(response.Body.String(), "secret-panic-value") { + t.Fatal("panic 泄漏到响应") + } + if !test.control && records(t, &out)[0]["error_message"] != "secret-panic-value" { + t.Fatal("panic 原因丢失") } }) } diff --git a/monkeyai/backend/logging/lifecycle_test.go b/monkeyai/backend/logging/lifecycle_test.go deleted file mode 100644 index 4d4d8de40..000000000 --- a/monkeyai/backend/logging/lifecycle_test.go +++ /dev/null @@ -1,58 +0,0 @@ -package logging - -import ( - "io" - "log/slog" - "runtime" - "sync" - "testing" -) - -func TestConcurrentCloseAccountsForEveryEvent(t *testing.T) { - r, out, _, _ := runtimeTest(t) - var wg sync.WaitGroup - for i := 0; i < 8; i++ { - wg.Go(func() { repeatFailure(r.Logger(), 100) }) - } - wg.Go(func() { _ = r.Close() }) - wg.Go(func() { _ = r.Close() }) - wg.Wait() - _ = r.Close() - var occurrences float64 - for _, row := range records(t, out) { - if row["event"] == "logging.error.summary" { - occurrences += row["suppressed_count"].(float64) - } else { - occurrences++ - } - } - stats := r.Snapshot() - if occurrences != 800 || stats.Candidates != 800 || stats.Details+stats.Suppressed != 800 || stats.ActiveKeys != 0 { - t.Fatalf("并发关闭漏计: %.0f %+v", occurrences, stats) - } -} -func TestRuntimeChurnKeepsSchedulersAndStateBounded(t *testing.T) { - before := runtime.NumGoroutine() - for pass := 0; pass < 8; pass++ { - r, err := NewRuntime(io.Discard, slog.LevelDebug, Settings{true, DefaultSettings().Window, 128}) - if err != nil { - t.Fatal(err) - } - for i := 0; i < 1000; i++ { - r.Logger().Error("故障", "event", "model.call.completed", "operation", "proxy_request", "model_id", stringID(i)) - } - if r.Snapshot().ActiveKeys != 128 { - t.Fatal("指纹容量失控") - } - if runtime.NumGoroutine() > before+3 { - t.Fatal("为每个指纹创建了调度器") - } - _ = r.Close() - if r.Snapshot().ActiveKeys != 0 { - t.Fatal("关闭后仍保留聚合状态") - } - } - if runtime.NumGoroutine() > before+2 { - t.Fatal("日志调度器未退出") - } -} diff --git a/monkeyai/backend/logging/logger.go b/monkeyai/backend/logging/logger.go index fd77d5e40..db1260e54 100644 --- a/monkeyai/backend/logging/logger.go +++ b/monkeyai/backend/logging/logger.go @@ -3,6 +3,7 @@ package logging import ( "context" + "fmt" "io" "log" "log/slog" @@ -32,10 +33,9 @@ func New(output io.Writer, level slog.Leveler) *slog.Logger { } type safeHandler struct { - next slog.Handler - runtime *Runtime - attrs []slog.Attr - groups []string + next slog.Handler + attrs []slog.Attr + groups []string } func (h *safeHandler) Enabled(ctx context.Context, level slog.Level) bool { @@ -90,10 +90,9 @@ func (h *safeHandler) Handle(ctx context.Context, record slog.Record) error { attrs = append(attrs, contextAttrs(ctx)...) clean := slog.NewRecord(record.Time, record.Level, record.Message, record.PC) clean.AddAttrs(mergeAttrs(attrs)...) - if h.runtime != nil { - return h.runtime.submit(ctx, clean) - } - return h.next.Handle(ctx, clean) + err := h.next.Handle(ctx, clean) + reportOutput(err) + return err } func (h *safeHandler) WithAttrs(attrs []slog.Attr) slog.Handler { @@ -130,13 +129,22 @@ func ErrorLog(logger *slog.Logger) *log.Logger { return log.New(runtimeWriter{lo type runtimeWriter struct{ logger *slog.Logger } func (w runtimeWriter) Write(p []byte) (int, error) { - w.logger.Error("HTTP 运行时错误", "event", "runtime.http.error") + w.logger.Error("HTTP 运行时错误", "event", "runtime.http.error", "error_message", string(p)) return len(p), nil } -func runtimeFor(logger *slog.Logger) *Runtime { - if h, ok := logger.Handler().(*safeHandler); ok { - return h.runtime +func reportOutput(err error) { + if err == nil { + return + } + if _, fallback := fmt.Fprintln(os.Stderr, "结构化日志输出失败:", err); fallback != nil { + println("结构化日志及 stderr 输出失败:", err.Error(), fallback.Error()) + } +} + +func handle(ctx context.Context, logger *slog.Logger, record slog.Record) { + err := logger.Handler().Handle(ctx, record) + if _, ok := logger.Handler().(*safeHandler); !ok { + reportOutput(err) } - return nil } diff --git a/monkeyai/backend/logging/logger_test.go b/monkeyai/backend/logging/logger_test.go index 42f5d145e..e34c4ff8a 100644 --- a/monkeyai/backend/logging/logger_test.go +++ b/monkeyai/backend/logging/logger_test.go @@ -5,10 +5,13 @@ import ( "context" "encoding/json" "errors" + "fmt" + "io" "log/slog" "net/url" "os" "strings" + "sync" "syscall" "testing" ) @@ -58,16 +61,16 @@ func TestSafetyBeforeJSONResolution(t *testing.T) { t.Fatal(err) } logger.Error("wrapped", "error", &url.Error{Op: "get", URL: "https://private.test?token=secret", Err: errors.New("private response")}) - if strings.Contains(output.String(), "private.test") || strings.Contains(output.String(), "private response") { + if records(t, &output)[1]["error"].(map[string]any)["error_message"] != `get "https://private.test?token=secret": private response` { t.Fatal(output.String()) } } -func TestSafeRuntimeAdapter(t *testing.T) { +func TestRuntimeAdapterPreservesError(t *testing.T) { var output bytes.Buffer logger := New(&output, slog.LevelInfo) ErrorLog(logger).Print("panic secret https://private.test?token=hidden") - if strings.Contains(output.String(), "secret") || !strings.Contains(output.String(), "runtime.http.error") { + if records(t, &output)[0]["error_message"] != "panic secret https://private.test?token=hidden\n" || !strings.Contains(output.String(), "runtime.http.error") { t.Fatal(output.String()) } attrs := ErrorAttrs(context.DeadlineExceeded) @@ -76,7 +79,7 @@ func TestSafeRuntimeAdapter(t *testing.T) { } } -func TestErrorAttrsDoNotFormatErrors(t *testing.T) { +func TestErrorAttrsPreservesMessages(t *testing.T) { _ = ErrorAttrs(hostile{}) for _, test := range []struct { cause error @@ -91,8 +94,114 @@ func TestErrorAttrsDoNotFormatErrors(t *testing.T) { logger := New(&output, slog.LevelInfo) err := &os.PathError{Op: "private-operation", Path: "private-file", Err: test.cause} logger.Error("safe", "error", err) - if !strings.Contains(output.String(), test.code) || strings.Contains(output.String(), "private-") { + if !strings.Contains(output.String(), test.code) || records(t, &output)[0]["error"].(map[string]any)["error_message"] != err.Error() { t.Fatal(output.String()) } } } + +func testLogger() (*slog.Logger, *bytes.Buffer) { + output := new(bytes.Buffer) + return New(output, slog.LevelDebug), output +} + +func records(t *testing.T, output *bytes.Buffer) []map[string]any { + t.Helper() + var result []map[string]any + decoder := json.NewDecoder(bytes.NewReader(output.Bytes())) + for { + var row map[string]any + err := decoder.Decode(&row) + if err == io.EOF { + return result + } + if err != nil { + t.Fatal(err) + } + result = append(result, row) + } +} + +func TestRepeatedErrorsPreserveEveryOccurrence(t *testing.T) { + logger, output := testLogger() + logger = logger.With("module", "proxy").WithGroup("call") + var wg sync.WaitGroup + for i := range 100 { + wg.Go(func() { + err := fmt.Errorf("请求 %d: %w", i, io.ErrUnexpectedEOF) + Event(t.Context(), logger, slog.LevelError, "model.call.completed", "模型调用失败", + "model_id", "m1", "operation", "proxy_request", "request_id", fmt.Sprintf("r%d", i), "error", err) + }) + } + wg.Wait() + rows := records(t, output) + if len(rows) != 100 { + t.Fatalf("错误被合并: %d", len(rows)) + } + seen := make(map[string]bool) + for _, row := range rows { + call := row["call"].(map[string]any) + id := call["request_id"].(string) + if seen[id] { + t.Fatalf("重复请求: %s", id) + } + seen[id] = true + expected := fmt.Sprintf("请求 %s: unexpected EOF", strings.TrimPrefix(id, "r")) + if call["event"] != "model.call.completed" || call["error"].(map[string]any)["error_message"] != expected { + t.Fatalf("错误详情丢失: %v", row) + } + } +} + +func TestErrorMessagesSurviveAllEntryPoints(t *testing.T) { + message := "数据库查询失败：" + strings.Repeat("column does not exist; ", 20) + "\n原始错误" + for _, test := range []struct { + name string + log func(*slog.Logger) + }{ + {"诊断", func(logger *slog.Logger) { + Diagnostic(t.Context(), logger, slog.LevelError, "resource.operation.failed", errors.New(message)) + }}, + {"错误属性", func(logger *slog.Logger) { + logger.LogAttrs(t.Context(), slog.LevelError, "失败", ErrorAttrs(errors.New(message))...) + }}, + {"文本属性", func(logger *slog.Logger) { logger.Error("失败", "error_message", message) }}, + {"派生属性", func(logger *slog.Logger) { logger.With("error_message", message).Error("失败") }}, + } { + t.Run(test.name, func(t *testing.T) { + logger, output := testLogger() + test.log(logger) + if records(t, output)[0]["error_message"] != message { + t.Fatal("错误文本被过滤或截断") + } + }) + } +} + +type brokenOutput struct{} + +func (brokenOutput) Write([]byte) (int, error) { return 0, io.ErrClosedPipe } + +func TestOutputFailureFallsBackToStderr(t *testing.T) { + file, err := os.CreateTemp(t.TempDir(), "stderr") + if err != nil { + t.Fatal(err) + } + original := os.Stderr + os.Stderr = file + t.Cleanup(func() { + os.Stderr = original + if err := file.Close(); err != nil { + t.Error(err) + } + }) + New(brokenOutput{}, slog.LevelDebug).Error("业务失败", "error", errors.New("数据库不可用")) + Event(t.Context(), slog.New(slog.NewJSONHandler(brokenOutput{}, nil)), slog.LevelError, "test.failed", "业务失败") + content, err := os.ReadFile(file.Name()) + if err != nil { + t.Fatal(err) + } + if strings.Count(string(content), io.ErrClosedPipe.Error()) != 2 { + t.Fatalf("日志输出错误被忽略: %s", content) + } +} diff --git a/monkeyai/backend/logging/policy.go b/monkeyai/backend/logging/policy.go deleted file mode 100644 index d30995af4..000000000 --- a/monkeyai/backend/logging/policy.go +++ /dev/null @@ -1,77 +0,0 @@ -package logging - -import ( - "encoding/json" - "log/slog" - "time" -) - -type policy struct { - scope []string - sample string - window time.Duration -} - -var policies = map[string]policy{ - "model.call.completed": {scope: []string{"model_id", "operation"}, sample: "request_id"}, - "model.usage.failed": {scope: []string{"model_id"}, sample: "request_id"}, - "http.request.failed": {scope: []string{"route", "method"}, sample: "request_id"}, - "resource.operation.failed": {scope: []string{"route", "method"}, sample: "request_id"}, - "readiness.failed": {scope: []string{"dependency"}, sample: "request_id"}, - "relay.stream.failed": {scope: []string{"server_id", "user_id", "machine_id", "operation", "phase"}, sample: "connection_id"}, - "resource.upload.operation.failed": {scope: []string{"upload_id", "phase"}, sample: "request_id"}, - "mcp.credential.retry": {scope: []string{"connector_id", "operation"}, sample: "worker_run_id", window: 5 * time.Minute}, - "resource.upload.failed": {scope: []string{"upload_id", "chunk_index", "phase"}, sample: "request_id"}, - "billing.retry.failed": {scope: []string{"transaction_id", "operation"}, sample: "transaction_id", window: 5 * time.Minute}, - "image.job.retry": {scope: []string{"job_id", "operation"}, sample: "job_id", window: 5 * time.Minute}, - "video.job.retry": {scope: []string{"job_id", "operation"}, sample: "job_id", window: 5 * time.Minute}, - "worker.scan.failed": {scope: []string{"module", "operation", "dependency"}, sample: "worker_run_id", window: 5 * time.Minute}, -} - -func scalars(record slog.Record) map[string]slog.Attr { - result := make(map[string]slog.Attr) - var add func(slog.Attr) - add = func(a slog.Attr) { - if a.Value.Kind() == slog.KindGroup { - for _, child := range a.Value.Group() { - add(child) - } - return - } - if a.Value.Kind() != slog.KindAny && a.Value.Kind() != slog.KindLogValuer { - result[a.Key] = a - } - } - record.Attrs(func(a slog.Attr) bool { add(a); return true }) - return result -} - -func fingerprint(level slog.Level, fields map[string]slog.Attr, p policy) (string, []slog.Attr) { - if level < slog.LevelWarn { - return "", nil - } - keys := []string{"event", "module", "operation", "error_code", "error_type", "upstream_status", "sqlstate"} - for _, key := range p.scope { - if a, ok := fields[key]; !ok || a.Value.String() == "" { - return "", nil - } - } - keys = append(keys, p.scope...) - seen := make(map[string]bool) - tuple := []any{level.String()} - var attrs []slog.Attr - for _, key := range keys { - if seen[key] { - continue - } - seen[key] = true - if a, ok := fields[key]; ok { - tuple = append(tuple, key, a.Value.String()) - if key != "event" { - attrs = append(attrs, a) - } - } - } - data, _ := json.Marshal(tuple) - return string(data), attrs -} diff --git a/monkeyai/backend/logging/safe.go b/monkeyai/backend/logging/safe.go index 473581c19..16c279429 100644 --- a/monkeyai/backend/logging/safe.go +++ b/monkeyai/backend/logging/safe.go @@ -17,7 +17,6 @@ var stringFields = map[string]bool{ "previous_level": true, "current_level": true, "origin": true, "intent": true, "code": true, "kind": true, "status": true, "provider": true, "usage_error_code": true, "file": true, "resource_id": true, "key_id": true, - "original_event": true, "original_level": true, "fingerprint": true, "flush_reason": true, "input_source": true, "output_source": true, } @@ -29,7 +28,7 @@ func sensitive(key string) bool { } } switch key { - case "key", "path", "url", "endpoint", "body", "query", "args", "config", "dsn", "message", "error_message", "panic", "source", "time", "level", "msg": + case "key", "path", "url", "endpoint", "body", "query", "args", "config", "dsn", "message", "panic", "source", "time", "level", "msg": return true } return false @@ -40,10 +39,7 @@ func safeAttr(a slog.Attr) slog.Attr { return slog.Attr{} } switch a.Value.Kind() { - case slog.KindLogValuer: - // JSONHandler resolves LogValuer before ReplaceAttr, so filter here. - return slog.Attr{} - case slog.KindAny: + case slog.KindAny, slog.KindLogValuer: if err, ok := a.Value.Any().(error); ok && err != nil { attrs := ErrorAttrs(err) return slog.Attr{Key: a.Key, Value: slog.GroupValue(attrs...)} @@ -65,6 +61,9 @@ func safeAttr(a slog.Attr) slog.Attr { if value == "" { return slog.Attr{} } + if a.Key == "error_message" || a.Key == "error" || a.Key == "err" { + return a + } if a.Key == "function" { if len(value) > 256 { return slog.Attr{} diff --git a/monkeyai/backend/logging/worker.go b/monkeyai/backend/logging/worker.go index d2cb4c2b4..f8834ae62 100644 --- a/monkeyai/backend/logging/worker.go +++ b/monkeyai/backend/logging/worker.go @@ -49,9 +49,6 @@ func (w *Worker) Report(ctx context.Context, err error) { w.logger.LogAttrs(ctx, slog.LevelWarn, "后台依赖检查失败", fields...) return } - if r := runtimeFor(w.logger); r != nil { - r.Recovered(ctx, "worker.scan.failed", fields...) - } fields = append(fields, slog.String("event", "dependency.recovered"), slog.Uint64("failure_count", count), slog.Int64("duration_ms", time.Since(first).Milliseconds())) w.logger.LogAttrs(ctx, slog.LevelInfo, "后台依赖已恢复", fields...) } diff --git a/monkeyai/backend/logging/worker_test.go b/monkeyai/backend/logging/worker_test.go index fd8c0bf33..d6334b714 100644 --- a/monkeyai/backend/logging/worker_test.go +++ b/monkeyai/backend/logging/worker_test.go @@ -4,57 +4,31 @@ import ( "context" "io" "log/slog" - "sync/atomic" "testing" - "time" ) -func TestWorkerRecoveryFlushesBeforeRecovery(t *testing.T) { - r, out, _, _ := runtimeTest(t) - worker := NewWorker(r.Logger(), "resourceimport", "cleanup_uploads", "object_storage") +func TestWorkerReportsEveryFailureAndRecovery(t *testing.T) { + logger, out := testLogger() + worker := NewWorker(logger, "resourceimport", "cleanup_uploads", "object_storage") worker.Report(context.Background(), io.ErrUnexpectedEOF) worker.Report(context.Background(), io.ErrUnexpectedEOF) worker.Report(context.Background(), nil) worker.Report(context.Background(), nil) worker.Report(context.Background(), io.ErrUnexpectedEOF) rows := records(t, out) - if len(rows) != 4 || rows[1]["event"] != "logging.error.summary" || rows[1]["occurrence_count"] != float64(2) || rows[2]["event"] != "dependency.recovered" || rows[2]["failure_count"] != float64(2) { + if len(rows) != 4 || rows[1]["event"] != "worker.scan.failed" || rows[1]["error_message"] != io.ErrUnexpectedEOF.Error() || rows[2]["event"] != "dependency.recovered" || rows[2]["failure_count"] != float64(2) { t.Fatalf("恢复顺序或计数错误: %v", rows) } } -type countWriter struct{ count atomic.Uint64 } - -func (w *countWriter) Write(p []byte) (int, error) { w.count.Add(1); return len(p), nil } -func TestSchedulerFlushesWithoutNewEvents(t *testing.T) { - var out countWriter - r, err := NewRuntime(&out, slog.LevelError, Settings{true, time.Second, 128}) - if err != nil { - t.Fatal(err) - } - defer r.Close() - repeatFailure(r.Logger(), 2) - deadline := time.NewTimer(3 * time.Second) - defer deadline.Stop() - ticker := time.NewTicker(10 * time.Millisecond) - defer ticker.Stop() - for out.count.Load() < 2 { - select { - case <-deadline.C: - t.Fatal("无后续请求时未刷新摘要") - case <-ticker.C: - } - } -} func BenchmarkLoggerDistribution(b *testing.B) { for _, count := range []int{1, 4096, 5000} { b.Run(stringID(count), func(b *testing.B) { - r, _ := NewRuntime(io.Discard, slog.LevelDebug, DefaultSettings()) - defer r.Close() + logger := New(io.Discard, slog.LevelDebug) b.ReportAllocs() b.ResetTimer() for i := 0; i < b.N; i++ { - r.Logger().Error("故障", "event", "model.call.completed", "model_id", stringID(i%count), "operation", "proxy_request") + logger.Error("故障", "event", "model.call.completed", "model_id", stringID(i%count), "operation", "proxy_request") } }) } diff --git a/monkeyai/backend/server/reset.go b/monkeyai/backend/server/reset.go index 35a4290e4..fed0f1108 100644 --- a/monkeyai/backend/server/reset.go +++ b/monkeyai/backend/server/reset.go @@ -7,6 +7,7 @@ import ( "flag" "fmt" "io" + "log/slog" "net/mail" "os" "strings" @@ -37,6 +38,7 @@ func Reset(ctx context.Context, args []string, input io.Reader, output io.Writer } pool, err := database.Open(ctx, url) if err != nil { + slog.WarnContext(ctx, "操作失败", "module", "server", "operation", "Reset", "error", err) return errors.New("无法连接数据库，请检查 MONKEYAI_DATABASE_URL 或 --database-url") } defer pool.Close() @@ -75,5 +77,7 @@ func Reset(ctx context.Context, args []string, input io.Reader, output io.Writer } func PrintResetUsage(output io.Writer) { - _, _ = io.WriteString(output, "用法: monkeyai-server reset [--database-url PostgreSQL连接地址]\n优先重置 admin@baizhi.cloud；未找到时提示填写管理员邮箱。\n数据库连接默认读取 MONKEYAI_DATABASE_URL，成功后输出账号和随机新密码。\n") + if _, err := io.WriteString(output, "用法: monkeyai-server reset [--database-url PostgreSQL连接地址]\n优先重置 admin@baizhi.cloud；未找到时提示填写管理员邮箱。\n数据库连接默认读取 MONKEYAI_DATABASE_URL，成功后输出账号和随机新密码。\n"); err != nil { + slog.Error("写入输出失败", "module", "server", "operation", "PrintResetUsage", "error", err) + } } diff --git a/monkeyai/backend/server/reset_test.go b/monkeyai/backend/server/reset_test.go index 9b1936545..2eb8ca21b 100644 --- a/monkeyai/backend/server/reset_test.go +++ b/monkeyai/backend/server/reset_test.go @@ -171,7 +171,7 @@ func TestResetFlags(t *testing.T) { func TestEmbeddedResetCommand(t *testing.T) { t.Setenv("MONKEYAI_DATABASE_URL", "") args := []string{"reset", "--database-url", "postgres://test", "--help"} - if _, _, err := ParseLogging([]string{"reset", "--database-url", "postgres://test"}); err != nil { + if _, err := ParseLogLevel([]string{"reset", "--database-url", "postgres://test"}); err != nil { t.Fatalf("嵌入入口未识别 reset: %v", err) } if _, err := ParseLogLevel([]string{"reset"}); err != nil { diff --git a/monkeyai/backend/server/server.go b/monkeyai/backend/server/server.go index 89495f0f4..370180d3a 100644 --- a/monkeyai/backend/server/server.go +++ b/monkeyai/backend/server/server.go @@ -9,7 +9,6 @@ import ( "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/app" "github.com/chaitin/MonkeyCode/monkeyai/backend/internal/config" - "github.com/chaitin/MonkeyCode/monkeyai/backend/logging" "github.com/chaitin/MonkeyCode/monkeyai/backend/member" "github.com/go-chi/chi/v5" "github.com/jackc/pgx/v5/pgxpool" @@ -32,13 +31,6 @@ func ParseLogLevel(args []string) (slog.Level, error) { return config.ParseLogLevel(args) } -func ParseLogging(args []string) (slog.Level, logging.Settings, error) { - if len(args) > 0 && args[0] == "reset" { - args = args[1:] - } - return config.ParseLogging(args) -} - // PrintUsage writes startup help without reading environment secrets. func PrintUsage(output io.Writer) { config.PrintUsage(output) } diff --git a/monkeyai/design/error-logging-optimization-plan.md b/monkeyai/design/error-logging-optimization-plan.md index efc985913..db03437d6 100644 --- a/monkeyai/design/error-logging-optimization-plan.md +++ b/monkeyai/design/error-logging-optimization-plan.md @@ -1,5 +1,7 @@ # 后端错误日志优化方案 +> 后续修订：已移除日志去重、定时摘要及 Runtime，入口使用 `logging.New`，错误原文写入 `error_message`。下文保留原方案及历史验收记录，当前行为以[运行日志说明](../backend/docs/logging.md)为准。 + - 创建日期：2026-10-16；修订日期：2026-10-21 - 代码基线：最初基于 `5b5c3d91` 实施；提交 PR 前同步 `a1cccb86` 主线，保留统计小时汇总和会话分组修复。 - 状态：后端日志和容器日志轮转已完成；已执行专用数据库、对象存储、协议、预览浏览器和竞态回归。2026-10-21 调整范围，暂缓 Nginx 日志改造并还原相关配置。性能及验证边界见[实施验收记录](../backend/docs/logging-validation.md)，不代表镜像已发布或部署。 diff --git a/monkeyai/docker-compose.yml b/monkeyai/docker-compose.yml index 4bd250176..91b1b083e 100644 --- a/monkeyai/docker-compose.yml +++ b/monkeyai/docker-compose.yml @@ -83,9 +83,6 @@ services: MONKEYAI_HTTP_ADDR: :8080 TMPDIR: /app/import-tmp MONKEYAI_LOG_LEVEL: ${MONKEYAI_LOG_LEVEL:-warn} - MONKEYAI_LOG_DEDUP_ENABLED: ${MONKEYAI_LOG_DEDUP_ENABLED:-true} - MONKEYAI_LOG_DEDUP_WINDOW: ${MONKEYAI_LOG_DEDUP_WINDOW:-60s} - MONKEYAI_LOG_DEDUP_MAX_KEYS: ${MONKEYAI_LOG_DEDUP_MAX_KEYS:-4096} MONKEYAI_ENDPOINT_MAX_CONNECTIONS: ${MONKEYAI_ENDPOINT_MAX_CONNECTIONS:-1000} MONKEYAI_RUNTIME_RELAY: ${MONKEYAI_RUNTIME_RELAY:-true} MONKEYAI_RUNTIME_STATE_DIR: /app/runtime