Skip to content

armgit / cua

Public Imported from GitHub
0

Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.

feat: add repo-wide errorswallow analyzer (#6996)

r33drichards4e1bd0e4ba73
diff --git a/libs/fleet/backend/auth/auth.go b/libs/fleet/backend/auth/auth.go
index 666591779c..fb31c8ceef 100644
--- a/libs/fleet/backend/auth/auth.go
+++ b/libs/fleet/backend/auth/auth.go
@@ -107,7 +107,8 @@ func ClassifyDatabaseError(err error) error {
return err
}
if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
- return DatabaseUnavailable(err)
+ return errors.Join(DatabaseUnavailable(err), err)
+
}
var postgresError *pgconn.PgError
@@ -116,11 +117,13 @@ func ClassifyDatabaseError(err error) error {
}
var connectError *pgconn.ConnectError
if errors.As(err, &connectError) {
- return DatabaseUnavailable(err)
+ return errors.Join(DatabaseUnavailable(err), err)
+
}
var networkError net.Error
if errors.As(err, &networkError) || errors.Is(err, net.ErrClosed) || errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) {
- return DatabaseUnavailable(err)
+ return errors.Join(DatabaseUnavailable(err), err)
+
}
return err
}
@@ -341,7 +344,8 @@ func validateGitHub(ctx context.Context, raw string) (*User, error) {
func validateGitHubAudience(claims jwt.MapClaims, primary string, legacy []string) error {
audiences, err := claims.GetAudience()
if err != nil || len(audiences) == 0 {
- return fmt.Errorf("missing or invalid github oidc audience")
+ return errors.Join(fmt.Errorf("missing or invalid github oidc audience"), err)
+
}
accepted := append([]string{primary}, legacy...)
for _, audience := range audiences {
diff --git a/libs/fleet/backend/auth/policy_middleware.go b/libs/fleet/backend/auth/policy_middleware.go
index f53be72faa..7407afacc8 100644
--- a/libs/fleet/backend/auth/policy_middleware.go
+++ b/libs/fleet/backend/auth/policy_middleware.go
@@ -374,8 +374,9 @@ func (input *requestPolicyInput) loadBody(maxBytes int64) ([]byte, error) {
input.request.Body = spliceBody(input.body, original)
}
}
- if input.bodyErr != nil {
- return input.body, input.bodyErr
+ bodyErr := input.bodyErr
+ if bodyErr != nil {
+ return input.body, bodyErr
}
if int64(len(input.body)) > maxBytes {
return input.body, policyBodyError{message: "request body exceeds policy limit"}
diff --git a/libs/fleet/backend/auth/safe_error.go b/libs/fleet/backend/auth/safe_error.go
new file mode 100644
index 0000000000..f8ddd91411
--- /dev/null
+++ b/libs/fleet/backend/auth/safe_error.go
@@ -0,0 +1,25 @@
+package auth
+
+// SanitizedError keeps an internal cause available to errors.Is/errors.As while
+// exposing only a reviewed message at rendering boundaries.
+type SanitizedError struct {
+ Message string
+ Cause error
+}
+
+func (err SanitizedError) Error() string { return err.Message }
+func (err SanitizedError) Unwrap() error { return err.Cause }
+
+func NewSanitizedError(message string, cause error) error {
+ if cause == nil {
+ return nil
+ }
+ return SanitizedError{Message: message, Cause: cause}
+}
+
+func NewFactUnavailableError(namespace, message string, cause error) error {
+ return &FactUnavailableError{
+ Namespace: namespace,
+ Err: NewSanitizedError(message, cause),
+ }
+}
diff --git a/libs/fleet/backend/billing/service.go b/libs/fleet/backend/billing/service.go
index bfe63ee11a..1d9f06335c 100644
--- a/libs/fleet/backend/billing/service.go
+++ b/libs/fleet/backend/billing/service.go
@@ -116,7 +116,11 @@ func (s *Service) FindOrCreateCustomer(ctx context.Context, subject string) (Cus
}
metadata := map[string]string{MetadataSubject: subject}
digest := sha256.Sum256([]byte(subject))
- return s.gateway.CreateCustomer(ctx, metadata, CustomerIdempotencyPrefix+hex.EncodeToString(digest[:]))
+ created, createErr := s.gateway.CreateCustomer(ctx, metadata, CustomerIdempotencyPrefix+hex.EncodeToString(digest[:]))
+ if createErr != nil {
+ return created, errors.Join(createErr, err)
+ }
+ return created, nil
}
type CardSummary struct {
diff --git a/libs/fleet/backend/billing/service_test.go b/libs/fleet/backend/billing/service_test.go
index 0bbc564ff6..b38cc8fc53 100644
--- a/libs/fleet/backend/billing/service_test.go
+++ b/libs/fleet/backend/billing/service_test.go
@@ -50,8 +50,9 @@ func (f *fakeGateway) CreateCustomer(_ context.Context, metadata map[string]stri
func (f *fakeGateway) UpdateCustomerMetadata(_ context.Context, customerID string, metadata map[string]string) (Customer, error) {
f.operations = append(f.operations, "publish")
f.updatedMetadata = metadata
- if f.updateErr != nil {
- return Customer{}, f.updateErr
+ updateErr := f.updateErr
+ if updateErr != nil {
+ return Customer{}, updateErr
}
if f.updatedCustomer.ID != "" {
return f.updatedCustomer, nil
@@ -78,8 +79,9 @@ func (f *fakeGateway) SetDefaultPaymentMethodForSetupGeneration(_ context.Contex
func (f *fakeGateway) CreateSetupSession(_ context.Context, request SetupSessionRequest) (string, error) {
f.operations = append(f.operations, "create")
f.setupRequest = request
- if f.setupErr != nil {
- return "", f.setupErr
+ setupErr := f.setupErr
+ if setupErr != nil {
+ return "", setupErr
}
return "https://checkout.stripe.test/session", nil
}
diff --git a/libs/fleet/backend/chat/litellm.go b/libs/fleet/backend/chat/litellm.go
index f33f50c87e..982126cf33 100644
--- a/libs/fleet/backend/chat/litellm.go
+++ b/libs/fleet/backend/chat/litellm.go
@@ -152,8 +152,8 @@ func (client *LiteLLMClient) Complete(ctx context.Context, messages []Message, o
}
response, err := httpClient.Do(request)
if err != nil {
- if ctx.Err() != nil {
- return Message{}, ctx.Err()
+ if ctxErr := ctx.Err(); ctxErr != nil {
+ return Message{}, errors.Join(ctxErr, err)
}
return Message{}, fmt.Errorf("send LiteLLM request: %w", err)
}
@@ -166,17 +166,19 @@ func (client *LiteLLMClient) Complete(ctx context.Context, messages []Message, o
var content strings.Builder
toolCalls := make(map[int]ToolCall)
done := false
+ var streamErrors error
reader := bufio.NewReader(response.Body)
for {
data, err := readSSEData(reader)
if err != nil {
if errors.Is(err, io.EOF) {
+ streamErrors = errors.Join(streamErrors, err)
break
}
- if ctx.Err() != nil {
- return Message{}, ctx.Err()
+ if ctxErr := ctx.Err(); ctxErr != nil {
+ return Message{}, errors.Join(ctxErr, err, streamErrors)
}
- return Message{}, fmt.Errorf("read LiteLLM stream: %w", err)
+ return Message{}, errors.Join(fmt.Errorf("read LiteLLM stream: %w", err), streamErrors)
}
if err := ctx.Err(); err != nil {
return Message{}, err
@@ -234,12 +236,14 @@ func (client *LiteLLMClient) Complete(ctx context.Context, messages []Message, o
}
}
if !done {
- return Message{}, errors.New("LiteLLM stream ended without [DONE]")
+ return Message{}, errors.Join(errors.New("LiteLLM stream ended without [DONE]"), streamErrors)
+
}
id, err := newUUID()
if err != nil {
- return Message{}, fmt.Errorf("generate assistant message ID: %w", err)
+ return Message{}, errors.Join(fmt.Errorf("generate assistant message ID: %w", err), streamErrors)
+
}
return Message{
ID: id,
@@ -345,24 +349,33 @@ func liteLLMResponseError(response *http.Response) error {
}
message := strings.TrimSpace(string(body))
+ var parseErrors error
var payload struct {
Error json.RawMessage `json:"error"`
}
- if json.Unmarshal(body, &payload) == nil && len(payload.Error) > 0 {
+ payloadErr := json.Unmarshal(body, &payload)
+ if payloadErr == nil && len(payload.Error) > 0 {
var detail struct {
Message string `json:"message"`
}
- if json.Unmarshal(payload.Error, &detail) == nil && detail.Message != "" {
+ detailErr := json.Unmarshal(payload.Error, &detail)
+ if detailErr == nil && detail.Message != "" {
message = detail.Message
} else {
+ parseErrors = errors.Join(parseErrors, detailErr)
var errorString string
- if json.Unmarshal(payload.Error, &errorString) == nil && errorString != "" {
+ stringErr := json.Unmarshal(payload.Error, &errorString)
+ if stringErr == nil && errorString != "" {
message = errorString
+ } else {
+ parseErrors = errors.Join(parseErrors, stringErr)
}
}
+ } else {
+ parseErrors = errors.Join(parseErrors, payloadErr)
}
if message == "" {
message = response.Status
}
- return fmt.Errorf("LiteLLM request failed: status %d: %s", response.StatusCode, message)
+ return errors.Join(fmt.Errorf("LiteLLM request failed: status %d: %s", response.StatusCode, message), parseErrors)
}
diff --git a/libs/fleet/backend/database/migrator.go b/libs/fleet/backend/database/migrator.go
index 0105aaf832..83bafa2df0 100644
--- a/libs/fleet/backend/database/migrator.go
+++ b/libs/fleet/backend/database/migrator.go
@@ -162,7 +162,8 @@ func embeddedMigrations() ([]migrationFile, error) {
}
version, err := strconv.ParseInt(prefix, 10, 64)
if err != nil || version < 1 {
- return nil, fmt.Errorf("migration %q has invalid version", entry.Name())
+ return nil, errors.Join(fmt.Errorf("migration %q has invalid version", entry.Name()), err)
+
}
contents, err := migrationFS.ReadFile("migrations/" + entry.Name())
@@ -260,7 +261,8 @@ func databaseTarget(connectionConfig *pgx.ConnConfig) string {
func parseMigrationConfig(url string) (*pgx.ConnConfig, error) {
connectionConfig, err := pgx.ParseConfig(url)
if err != nil {
- return nil, errors.New("parse migration database URL")
+ return nil, newSanitizedError("parse migration database URL", err)
+
}
return connectionConfig, nil
}
@@ -305,7 +307,8 @@ func Run(ctx context.Context, config Config) (runErr error) {
connection, err := pgx.ConnectConfig(ctx, connectionConfig)
if err != nil {
- return fmt.Errorf("connect migration database%s", databaseTarget(connectionConfig))
+ return newSanitizedError(fmt.Sprintf("connect migration database%s", databaseTarget(connectionConfig)), err)
+
}
defer connection.Close(ctx)
@@ -457,7 +460,8 @@ func parseCredentialURLs(urls CredentialURLs) ([]credential, error) {
for _, input := range inputs {
connectionConfig, err := pgx.ParseConfig(input.URL)
if err != nil {
- return nil, fmt.Errorf("parse %s credential database URL", input.Name)
+ return nil, newSanitizedError(fmt.Sprintf("parse %s credential database URL", input.Name), err)
+
}
expectedRole := expectedCredentialRoles[input.Name]
if connectionConfig.User != expectedRole {
@@ -814,6 +818,7 @@ func reconcileStaticMembershipContracts(ctx context.Context, transaction pgx.Tx,
}
membershipEvents := make([]membershipReconciliationEvent, 0, len(membershipContracts))
+ var toleratedErrors error
for index, contract := range membershipContracts {
started := time.Now()
if !isStaticMembershipRepair(contract, repairs) {
@@ -822,18 +827,23 @@ func reconcileStaticMembershipContracts(ctx context.Context, transaction pgx.Tx,
}
authoritativeGrant, err := authoritativeStaticMembershipGrant(contract, migrationOwner, grantsByContract[index])
- if err != nil && !errors.Is(err, errStaticMembershipGrantMissing) && !errors.Is(err, errStaticMembershipGrantOwnerOptions) {
- return nil, err
+ if err != nil {
+ if !errors.Is(err, errStaticMembershipGrantMissing) && !errors.Is(err, errStaticMembershipGrantOwnerOptions) {
+ return nil, errors.Join(err, toleratedErrors)
+ }
+ toleratedErrors = errors.Join(toleratedErrors, err)
}
ddl := newRuntimeDDL(transaction)
if authoritativeGrant != nil {
if err := ddl.revokeStaticMembership(ctx, contract, migrationOwner); err != nil {
- return nil, fmt.Errorf("remove drifted static role membership %s -> %s: %w", contract.role, contract.member, err)
+ return nil, errors.Join(fmt.Errorf("remove drifted static role membership %s -> %s: %w", contract.role, contract.member, err), toleratedErrors)
+
}
}
if err := ddl.grantStaticMembership(ctx, contract, migrationOwner); err != nil {
- return nil, fmt.Errorf("reconcile static role membership %s -> %s: %w", contract.role, contract.member, err)
+ return nil, errors.Join(fmt.Errorf("reconcile static role membership %s -> %s: %w", contract.role, contract.member, err), toleratedErrors)
+
}
membershipEvents = append(membershipEvents, membershipReconciliationEvent{Role: contract.role, DurationMS: time.Since(started).Milliseconds()})
}
@@ -873,33 +883,37 @@ func foreignStaticMembershipGrantError(contract staticMembershipContract, granto
}
func validateStaticRoleMemberships(ctx context.Context, transaction pgx.Tx, migrationOwner string, contracts []staticMembershipContract) error {
+ var toleratedErrors error
for _, contract := range contracts {
grants, err := readStaticMembershipGrants(ctx, transaction, contract)
if err != nil {
- return err
+ return errors.Join(err, toleratedErrors)
}
_, err = authoritativeStaticMembershipGrant(contract, migrationOwner, grants)
- if err != nil && !errors.Is(err, errStaticMembershipGrantMissing) && !errors.Is(err, errStaticMembershipGrantOwnerOptions) {
- return err
+ if err != nil {
+ if !errors.Is(err, errStaticMembershipGrantMissing) && !errors.Is(err, errStaticMembershipGrantOwnerOptions) {
+ return errors.Join(err, toleratedErrors)
+ }
+ toleratedErrors = errors.Join(toleratedErrors, err)
}
}
dynamicTenants, err := validateQueryTenantRoleMembers(ctx, transaction, migrationOwner, contracts)
if err != nil {
- return err
+ return errors.Join(err, toleratedErrors)
}
for _, contract := range staticRoleContracts() {
if contract.role == "k8s_query_tenant" {
continue
}
if err := validateStaticRoleMembers(ctx, transaction, migrationOwner, contract.role, contracts); err != nil {
- return err
+ return errors.Join(err, toleratedErrors)
}
}
for _, contract := range staticRoleContracts() {
if err := validateStaticRoleParents(ctx, transaction, contract.role, contracts, dynamicTenants); err != nil {
- return err
+ return errors.Join(err, toleratedErrors)
}
}
return nil
@@ -1384,11 +1398,13 @@ func reconcilePasswords(ctx context.Context, transaction pgx.Tx, credentials []c
func CurrentVersion(ctx context.Context, url string) (int64, error) {
connectionConfig, err := pgx.ParseConfig(url)
if err != nil {
- return 0, errors.New("parse database URL")
+ return 0, newSanitizedError("parse database URL", err)
+
}
connection, err := pgx.ConnectConfig(ctx, connectionConfig)
if err != nil {
- return 0, fmt.Errorf("connect database%s", databaseTarget(connectionConfig))
+ return 0, newSanitizedError(fmt.Sprintf("connect database%s", databaseTarget(connectionConfig)), err)
+
}
defer connection.Close(ctx)
diff --git a/libs/fleet/backend/database/safe_error.go b/libs/fleet/backend/database/safe_error.go
new file mode 100644
index 0000000000..ac23f20322
--- /dev/null
+++ b/libs/fleet/backend/database/safe_error.go
@@ -0,0 +1,16 @@
+package database
+
+type sanitizedError struct {
+ message string
+ cause error
+}
+
+func (err sanitizedError) Error() string { return err.message }
+func (err sanitizedError) Unwrap() error { return err.cause }
+
+func newSanitizedError(message string, cause error) error {
+ if cause == nil {
+ return nil
+ }
+ return sanitizedError{message: message, cause: cause}
+}
diff --git a/libs/fleet/backend/handlers/billing_facts.go b/libs/fleet/backend/handlers/billing_facts.go
index dad38a843a..080e95daa9 100644
--- a/libs/fleet/backend/handlers/billing_facts.go
+++ b/libs/fleet/backend/handlers/billing_facts.go
@@ -29,10 +29,8 @@ func (facts stripeCardFacts) LoadFacts(ctx context.Context, request *http.Reques
}
createdAt, err := facts.handlers.UserAccounts.UserCreatedAt(ctx, user.ID)
if err != nil {
- return nil, &auth.FactUnavailableError{
- Namespace: auth.StripeCardsFactNamespace,
- Err: fmt.Errorf("Keycloak user lookup failed"),
- }
+ return nil, auth.NewFactUnavailableError(auth.StripeCardsFactNamespace, "Keycloak user lookup failed", err)
+
}
if createdAt.Before(billingCardRequiredFrom) {
return auth.FactSet{
@@ -46,10 +44,8 @@ func (facts stripeCardFacts) LoadFacts(ctx context.Context, request *http.Reques
cards, err := facts.handlers.Billing.AttachedCards(ctx, user.ID)
if err != nil {
- return nil, &auth.FactUnavailableError{
- Namespace: auth.StripeCardsFactNamespace,
- Err: fmt.Errorf("Stripe attached-card lookup failed"),
- }
+ return nil, auth.NewFactUnavailableError(auth.StripeCardsFactNamespace, "Stripe attached-card lookup failed", err)
+
}
projected := make([]map[string]any, 0, len(cards))
for _, card := range cards {
diff --git a/libs/fleet/backend/handlers/chat.go b/libs/fleet/backend/handlers/chat.go
index 13c12ca800..79cb59ee16 100644
--- a/libs/fleet/backend/handlers/chat.go
+++ b/libs/fleet/backend/handlers/chat.go
@@ -319,7 +319,8 @@ func validateTurn(history, messages []chat.Message) error {
return errors.New("invalid tool message")
}
if err := validateBashToolResult(message.Content); err != nil {
- return errors.New("invalid tool result")
+ return errors.Join(errors.New("invalid tool result"), err)
+
}
}
@@ -402,7 +403,8 @@ func decodeTurnRequest(body io.Reader) (TurnRequest, error) {
}
var rawMessages []json.RawMessage
if err := json.Unmarshal(*raw.Messages, &rawMessages); err != nil || rawMessages == nil {
- return TurnRequest{}, errors.New("messages must be an array")
+ return TurnRequest{}, errors.Join(errors.New("messages must be an array"), err)
+
}
request := TurnRequest{Messages: make([]chat.Message, 0, len(rawMessages))}
diff --git a/libs/fleet/backend/handlers/github_trust_policies.go b/libs/fleet/backend/handlers/github_trust_policies.go
index fda7f4ff4b..a7670b85c7 100644
--- a/libs/fleet/backend/handlers/github_trust_policies.go
+++ b/libs/fleet/backend/handlers/github_trust_policies.go
@@ -203,11 +203,14 @@ func (r githubTrustResolver) ResolveGitHubTrustPolicies(ctx context.Context, rep
defer cancel()
policies, err := r.store.ResolveByRepository(databaseCtx, repository)
if err != nil {
+ originErr := err
err = auth.ClassifyDatabaseError(err)
if auth.IsDatabaseUnavailable(err) {
- return nil, auth.DatabaseUnavailable(err)
+ return nil, errors.Join(auth.DatabaseUnavailable(err), originErr)
+
}
- return nil, err
+ return nil, errors.Join(err, originErr)
+
}
out := make([]auth.GitHubTrustPolicy, 0, len(policies))
for _, policy := range policies {
diff --git a/libs/fleet/backend/handlers/github_trust_policies_test.go b/libs/fleet/backend/handlers/github_trust_policies_test.go
index 6a70df263d..c2dd3ea3bc 100644
--- a/libs/fleet/backend/handlers/github_trust_policies_test.go
+++ b/libs/fleet/backend/handlers/github_trust_policies_test.go
@@ -45,8 +45,10 @@ type fakeGitHubTrustStore struct {
func (f *fakeGitHubTrustStore) List(ctx context.Context, ownerSub string) ([]*githubtrust.Policy, error) {
f.listContext = ctx
- if f.listErr != nil {
- return nil, f.listErr
+ listErr := f.listErr
+ if listErr != nil {
+ return nil, listErr
+
}
out := make([]*githubtrust.Policy, len(f.listByOwner))
copy(out, f.listByOwner)
@@ -55,8 +57,10 @@ func (f *fakeGitHubTrustStore) List(ctx context.Context, ownerSub string) ([]*gi
func (f *fakeGitHubTrustStore) Create(ctx context.Context, policy *githubtrust.Policy) error {
f.createContext = ctx
- if f.createErr != nil {
- return f.createErr
+ createErr := f.createErr
+ if createErr != nil {
+ return createErr
+
}
cp := *policy
f.createInput = &cp
@@ -67,8 +71,10 @@ func (f *fakeGitHubTrustStore) Get(ctx context.Context, ownerSub, id string) (*g
f.getContext = ctx
_ = ownerSub
_ = id
- if f.getErr != nil {
- return nil, f.getErr
+ getErr := f.getErr
+ if getErr != nil {
+ return nil, getErr
+
}
if f.getResult == nil {
return nil, nil
@@ -79,8 +85,10 @@ func (f *fakeGitHubTrustStore) Get(ctx context.Context, ownerSub, id string) (*g
func (f *fakeGitHubTrustStore) Update(ctx context.Context, policy *githubtrust.Policy) error {
f.updateContext = ctx
- if f.updateErr != nil {
- return f.updateErr
+ updateErr := f.updateErr
+ if updateErr != nil {
+ return updateErr
+
}
cp := *policy
f.updateInput = &cp
@@ -91,8 +99,10 @@ func (f *fakeGitHubTrustStore) Delete(ctx context.Context, ownerSub, id string)
f.deleteContext = ctx
f.deleteOwner = ownerSub
f.deleteID = id
- if f.deleteErr != nil {
- return false, f.deleteErr
+ deleteErr := f.deleteErr
+ if deleteErr != nil {
+ return false, deleteErr
+
}
return f.deleteFound, nil
}
@@ -100,8 +110,10 @@ func (f *fakeGitHubTrustStore) Delete(ctx context.Context, ownerSub, id string)
func (f *fakeGitHubTrustStore) ResolveByRepository(ctx context.Context, repository string) ([]*githubtrust.Policy, error) {
f.resolveContext = ctx
f.resolvedRepoName = repository
- if f.resolveErr != nil {
- return nil, f.resolveErr
+ resolveErr := f.resolveErr
+ if resolveErr != nil {
+ return nil, resolveErr
+
}
out := make([]*githubtrust.Policy, len(f.resolveResult))
copy(out, f.resolveResult)
diff --git a/libs/fleet/backend/handlers/ownership.go b/libs/fleet/backend/handlers/ownership.go
index d5e8240ee8..d2ffb7cd77 100644
--- a/libs/fleet/backend/handlers/ownership.go
+++ b/libs/fleet/backend/handlers/ownership.go
@@ -17,6 +17,7 @@ package handlers
import (
"context"
+ "errors"
"fmt"
"log/slog"
"net/http"
@@ -103,7 +104,8 @@ func (facts namespaceRBACFacts) LoadFacts(ctx context.Context, r *http.Request)
if err != nil {
slog.Warn("namespace access check unavailable",
"sub", user.ID, "azp", user.AZP, "namespace", namespace, "err", err)
- return nil, &auth.FactUnavailableError{Namespace: auth.NamespaceRBACFactNamespace, Err: err}
+ return nil, errors.Join(&auth.FactUnavailableError{Namespace: auth.NamespaceRBACFactNamespace, Err: err}, err)
+
}
if !allowed {
// The verdict is the policy's to reach, but this is the only place the
diff --git a/libs/fleet/backend/handlers/state_query.go b/libs/fleet/backend/handlers/state_query.go
index 114b6c8f2a..c48d3e1e39 100644
--- a/libs/fleet/backend/handlers/state_query.go
+++ b/libs/fleet/backend/handlers/state_query.go
@@ -3,6 +3,7 @@ package handlers
import (
"context"
"encoding/json"
+ "errors"
"io"
"log/slog"
"mime"
@@ -65,9 +66,11 @@ func (writer *stateQueryStreamWriter) WriteRow(values []any) error {
func (writer *stateQueryStreamWriter) Finish(err error) error {
if err != nil {
if auth.IsDatabaseUnavailable(err) {
- return writer.write(stateQueryErrorEvent{Type: "error", Error: "state query unavailable"})
+ return errors.Join(writer.write(stateQueryErrorEvent{Type: "error", Error: "state query unavailable"}), err)
+
}
- return writer.write(stateQueryErrorEvent{Type: "error", Error: err.Error()})
+ return errors.Join(writer.write(stateQueryErrorEvent{Type: "error", Error: err.Error()}), err)
+
}
return writer.write(stateQueryDoneEvent{Type: "done"})
}
diff --git a/libs/fleet/backend/keycloak/admin.go b/libs/fleet/backend/keycloak/admin.go
index bee06a7304..9608bf3a81 100644
--- a/libs/fleet/backend/keycloak/admin.go
+++ b/libs/fleet/backend/keycloak/admin.go
@@ -5,6 +5,7 @@ package keycloak
import (
"context"
+ "errors"
"fmt"
"strings"
"time"
@@ -196,7 +197,8 @@ func (a *Admin) ListKeyClients(ctx context.Context, ownerSub string) ([]KeyClien
clients, listErr := a.client.GetClients(ctx, tok, a.realm, params)
if listErr != nil {
err = fmt.Errorf("list clients: %w", listErr)
- return nil, err
+ return nil, errors.Join(err, listErr)
+
}
for _, c := range clients {
attrs := derefMap(c.Attributes)
@@ -382,7 +384,8 @@ func (a *Admin) ListUserKeyClients(ctx context.Context, ownerSub string) ([]User
clients, listErr := a.client.GetClients(ctx, tok, a.realm, params)
if listErr != nil {
err = fmt.Errorf("list clients: %w", listErr)
- return nil, err
+ return nil, errors.Join(err, listErr)
+
}
for _, c := range clients {
attrs := derefMap(c.Attributes)
diff --git a/libs/fleet/backend/keycloak/workload.go b/libs/fleet/backend/keycloak/workload.go
index a79868548d..15a20757f5 100644
--- a/libs/fleet/backend/keycloak/workload.go
+++ b/libs/fleet/backend/keycloak/workload.go
@@ -2,6 +2,7 @@ package keycloak
import (
"context"
+ "errors"
"fmt"
"time"
@@ -133,12 +134,14 @@ func (a *Admin) EnsureTenantWorkloadClient(
// Likely a create race (another replica created it concurrently) or
// a pre-existing client our initial lookup missed — recover by
// re-looking-up and returning the existing secret.
- if cid, secret, found, lookErr := a.lookupClientSecret(ctx, tok, clientID); lookErr == nil && found {
+ cid, secret, found, lookErr := a.lookupClientSecret(ctx, tok, clientID)
+ if lookErr == nil && found {
return cid, secret, nil
}
span.RecordError(err)
span.SetStatus(codes.Error, "create client failed")
- return "", "", fmt.Errorf("create client: %w", err)
+ return "", "", errors.Join(fmt.Errorf("create client: %w", err), lookErr)
+
}
cs, err := a.client.GetClientSecret(ctx, tok, a.realm, kcUUID)
diff --git a/libs/fleet/backend/main.go b/libs/fleet/backend/main.go
index b1f4091889..145c8b6adc 100644
--- a/libs/fleet/backend/main.go
+++ b/libs/fleet/backend/main.go
@@ -21,6 +21,7 @@ package main
import (
"context"
+ "errors"
"fmt"
"log/slog"
"net/http"
@@ -243,6 +244,8 @@ func main() {
func run() error {
slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stdout, nil)))
ctx := context.Background()
+ var startupErrors error
+ var telemetryErr error
cfg, err := config.LoadConfig()
if err != nil {
@@ -259,6 +262,7 @@ func run() error {
Environment: cfg.Telemetry.Environment,
ResourceAttrs: cfg.Telemetry.ResourceAttrs,
}); err != nil {
+ telemetryErr = err
slog.Warn("otel: init failed; tracing disabled", "err", err)
} else {
telemetryShutdown = shutdown
@@ -282,6 +286,7 @@ func run() error {
SecretAccessKey: os.Getenv("AWS_SECRET_ACCESS_KEY"),
Region: os.Getenv("AWS_REGION"),
}); err != nil {
+ startupErrors = errors.Join(startupErrors, err)
slog.Warn("openfeature: provider setup degraded", "err", err)
}
slog.Info("init: OpenFeature ok, loading OPA")
@@ -349,7 +354,7 @@ func run() error {
srv := &http.Server{Addr: cfg.WebServer.Addr, Handler: router}
if err := srv.ListenAndServe(); err != nil {
- return fmt.Errorf("server exited: %w", err)
+ return errors.Join(fmt.Errorf("server exited: %w", err), startupErrors, telemetryErr)
}
return nil
}
diff --git a/libs/fleet/backend/main_test.go b/libs/fleet/backend/main_test.go
index 2fb4d424c9..0cdd835cbe 100644
--- a/libs/fleet/backend/main_test.go
+++ b/libs/fleet/backend/main_test.go
@@ -664,16 +664,20 @@ func TestInitializeDatabaseFeatures(t *testing.T) {
},
newStateQueryExecutor: func(_ string, _ string) (handlers.StateQueryExecutor, error) {
newExecutorCalls++
- if test.newExecutorError != nil {
- return nil, test.newExecutorError
+ newExecutorError := test.newExecutorError
+ if newExecutorError != nil {
+ return nil, newExecutorError
+
}
return stateQueryExecutorStub{}, nil
},
newGitHubTrustStore: func(ctx context.Context, _ string) (githubtrust.Store, error) {
newStoreCalls++
storeContext = ctx
- if test.newStoreError != nil {
- return nil, test.newStoreError
+ newStoreError := test.newStoreError
+ if newStoreError != nil {
+ return nil, newStoreError
+
}
return githubTrustStoreStub{}, nil
},
@@ -824,14 +828,18 @@ func TestInitializeDatabaseFeaturesReportsReadinessMetric(t *testing.T) {
return test.requireVersionError
},
newStateQueryExecutor: func(string, string) (handlers.StateQueryExecutor, error) {
- if test.newExecutorError != nil {
- return nil, test.newExecutorError
+ newExecutorError := test.newExecutorError
+ if newExecutorError != nil {
+ return nil, newExecutorError
+
}
return stateQueryExecutorStub{}, nil
},
newGitHubTrustStore: func(context.Context, string) (githubtrust.Store, error) {
- if test.newStoreError != nil {
- return nil, test.newStoreError
+ newStoreError := test.newStoreError
+ if newStoreError != nil {
+ return nil, newStoreError
+
}
return githubTrustStoreStub{}, nil
},
diff --git a/libs/fleet/backend/statequery/executor.go b/libs/fleet/backend/statequery/executor.go
index a4ac7462f9..8a2f466f26 100644
--- a/libs/fleet/backend/statequery/executor.go
+++ b/libs/fleet/backend/statequery/executor.go
@@ -52,19 +52,22 @@ func (e *Executor) Execute(ctx context.Context, tenant, sql string, writer Resul
}
conn, err := pgx.ConnectConfig(ctx, e.connectionConfig(tenant))
if err != nil {
- return fmt.Errorf("%w: connect tenant role: %v", ErrExecution, err)
+ return errors.Join(fmt.Errorf("%w: connect tenant role: %v", ErrExecution, err), err)
+
}
defer conn.Close(ctx)
tx, err := conn.BeginTx(ctx, pgx.TxOptions{AccessMode: pgx.ReadOnly})
if err != nil {
- return fmt.Errorf("%w: begin transaction", ErrExecution)
+ return errors.Join(fmt.Errorf("%w: begin transaction", ErrExecution), err)
+
}
defer tx.Rollback(ctx)
rows, err := tx.Query(ctx, sql)
if err != nil {
- return fmt.Errorf("%w: execute query", ErrExecution)
+ return errors.Join(fmt.Errorf("%w: execute query", ErrExecution), err)
+
}
defer rows.Close()
if err := writer.WriteFieldDescriptions(rows.FieldDescriptions()); err != nil {
@@ -73,7 +76,8 @@ func (e *Executor) Execute(ctx context.Context, tenant, sql string, writer Resul
for rows.Next() {
values, err := rows.Values()
if err != nil {
- return fmt.Errorf("%w: decode result row", ErrExecution)
+ return errors.Join(fmt.Errorf("%w: decode result row", ErrExecution), err)
+
}
if err := writer.WriteRow(values); err != nil {
return err