Update db logging

server/internal/db/db.go

@@ -117,19 +117,16 @@ func Init(dbPath string, secretsService secrets.Service) (Database, error) {
 
 	db, err := sql.Open("sqlite3", dbPath)
 	if err != nil {
-		log.Error("failed to open database", "error", err)
 		return nil, fmt.Errorf("failed to open database: %w", err)
 	}
 
 	if err := db.Ping(); err != nil {
-		log.Error("failed to ping database", "error", err)
 		return nil, fmt.Errorf("failed to ping database: %w", err)
 	}
 	log.Debug("database ping successful")
 
 	// Enable foreign keys for this connection
 	if _, err := db.Exec("PRAGMA foreign_keys = ON"); err != nil {
-		log.Error("failed to enable foreign keys", "error", err)
 		return nil, fmt.Errorf("failed to enable foreign keys: %w", err)
 	}
 	log.Debug("foreign keys enabled")
@@ -149,7 +146,6 @@ func (db *database) Close() error {
 	log.Info("closing database connection")
 
 	if err := db.DB.Close(); err != nil {
-		log.Error("failed to close database", "error", err)
 		return fmt.Errorf("failed to close database: %w", err)
 	}
 
@@ -168,7 +164,6 @@ func (db *database) encryptToken(token string) (string, error) {
 
 	encrypted, err := db.secretsService.Encrypt(token)
 	if err != nil {
-		log.Error("failed to encrypt token", "error", err)
 		return "", fmt.Errorf("failed to encrypt token: %w", err)
 	}
 
@@ -186,7 +181,6 @@ func (db *database) decryptToken(token string) (string, error) {
 
 	decrypted, err := db.secretsService.Decrypt(token)
 	if err != nil {
-		log.Error("failed to decrypt token", "error", err)
 		return "", fmt.Errorf("failed to decrypt token: %w", err)
 	}
 

server/internal/db/migrations.go

@@ -87,7 +87,6 @@ func (db *database) Migrate() error {
         version INTEGER PRIMARY KEY
     )`)
 	if err != nil {
-		log.Error("failed to create migrations table", "error", err)
 		return fmt.Errorf("failed to create migrations table: %w", err)
 	}
 
@@ -96,7 +95,6 @@ func (db *database) Migrate() error {
 	var currentVersion int
 	err = db.QueryRow("SELECT COALESCE(MAX(version), 0) FROM migrations").Scan(&currentVersion)
 	if err != nil {
-		log.Error("failed to get current migration version", "error", err)
 		return fmt.Errorf("failed to get current migration version: %w", err)
 	}
 	log.Info("current database version", "version", currentVersion)
@@ -109,7 +107,6 @@ func (db *database) Migrate() error {
 
 			tx, err := db.Begin()
 			if err != nil {
-				log.Error("failed to begin transaction", "error", err)
 				return fmt.Errorf("failed to begin transaction for migration %d: %w", migration.Version, err)
 			}
 
@@ -117,11 +114,7 @@ func (db *database) Migrate() error {
 			log.Debug("executing migration SQL")
 			_, err = tx.Exec(migration.SQL)
 			if err != nil {
-				log.Error("migration failed", "error", err)
 				if rbErr := tx.Rollback(); rbErr != nil {
-					log.Error("rollback failed after migration error",
-						"migration_error", err,
-						"rollback_error", rbErr)
 					return fmt.Errorf("migration %d failed: %v, rollback failed: %v",
 						migration.Version, err, rbErr)
 				}
@@ -133,11 +126,7 @@ func (db *database) Migrate() error {
 			log.Debug("updating migrations version")
 			_, err = tx.Exec("INSERT INTO migrations (version) VALUES (?)", migration.Version)
 			if err != nil {
-				log.Error("failed to update migration version", "error", err)
 				if rbErr := tx.Rollback(); rbErr != nil {
-					log.Error("rollback failed after version update error",
-						"update_error", err,
-						"rollback_error", rbErr)
 					return fmt.Errorf("failed to update migration version: %v, rollback failed: %v",
 						err, rbErr)
 				}
@@ -149,7 +138,6 @@ func (db *database) Migrate() error {
 			log.Debug("committing migration")
 			err = tx.Commit()
 			if err != nil {
-				log.Error("failed to commit migration", "error", err)
 				return fmt.Errorf("failed to commit migration %d: %w", migration.Version, err)
 			}
 

server/internal/db/sessions.go

@@ -22,10 +22,6 @@ func (db *database) CreateSession(session *models.Session) error {
 		session.ID, session.UserID, session.RefreshToken, session.ExpiresAt, session.CreatedAt,
 	)
 	if err != nil {
-		log.Error("failed to store session",
-			"error", err,
-			"session_id", session.ID,
-			"user_id", session.UserID)
 		return fmt.Errorf("failed to store session: %w", err)
 	}
 
@@ -53,7 +49,6 @@ func (db *database) GetSessionByRefreshToken(refreshToken string) (*models.Sessi
 		return nil, fmt.Errorf("session not found or expired")
 	}
 	if err != nil {
-		log.Error("failed to fetch session by refresh token", "error", err)
 		return nil, fmt.Errorf("failed to fetch session: %w", err)
 	}
 
@@ -81,9 +76,6 @@ func (db *database) GetSessionByID(sessionID string) (*models.Session, error) {
 		return nil, fmt.Errorf("session not found")
 	}
 	if err != nil {
-		log.Error("failed to fetch session by ID",
-			"error", err,
-			"session_id", sessionID)
 		return nil, fmt.Errorf("failed to fetch session: %w", err)
 	}
 
@@ -100,17 +92,11 @@ func (db *database) DeleteSession(sessionID string) error {
 
 	result, err := db.Exec("DELETE FROM sessions WHERE id = ?", sessionID)
 	if err != nil {
-		log.Error("failed to delete session",
-			"error", err,
-			"session_id", sessionID)
 		return fmt.Errorf("failed to delete session: %w", err)
 	}
 
 	rowsAffected, err := result.RowsAffected()
 	if err != nil {
-		log.Error("failed to get rows affected after session deletion",
-			"error", err,
-			"session_id", sessionID)
 		return fmt.Errorf("failed to get rows affected: %w", err)
 	}
 
@@ -130,13 +116,11 @@ func (db *database) CleanExpiredSessions() error {
 
 	result, err := db.Exec("DELETE FROM sessions WHERE expires_at <= ?", time.Now())
 	if err != nil {
-		log.Error("failed to clean expired sessions", "error", err)
 		return fmt.Errorf("failed to clean expired sessions: %w", err)
 	}
 
 	rowsAffected, err := result.RowsAffected()
 	if err != nil {
-		log.Error("failed to get count of cleaned sessions", "error", err)
 		return fmt.Errorf("failed to get rows affected: %w", err)
 	}
 

server/internal/db/system.go

@@ -2,7 +2,6 @@ package db
 
 import (
 	"crypto/rand"
-	"database/sql"
 	"encoding/base64"
 	"fmt"
 )
@@ -37,14 +36,12 @@ func (db *database) EnsureJWTSecret() (string, error) {
 	// Generate new secret if none exists
 	newSecret, err := generateRandomSecret(32) // 256 bits
 	if err != nil {
-		log.Error("failed to generate JWT secret", "error", err)
 		return "", fmt.Errorf("failed to generate JWT secret: %w", err)
 	}
 
 	// Store the new secret
 	err = db.SetSystemSetting(JWTSecretKey, newSecret)
 	if err != nil {
-		log.Error("failed to store JWT secret", "error", err)
 		return "", fmt.Errorf("failed to store JWT secret: %w", err)
 	}
 
@@ -60,13 +57,6 @@ func (db *database) GetSystemSetting(key string) (string, error) {
 	var value string
 	err := db.QueryRow("SELECT value FROM system_settings WHERE key = ?", key).Scan(&value)
 	if err != nil {
-		if err == sql.ErrNoRows {
-			log.Debug("system setting not found", "key", key)
-		} else {
-			log.Error("failed to retrieve system setting",
-				"error", err,
-				"key", key)
-		}
 		return "", err
 	}
 
@@ -86,9 +76,6 @@ func (db *database) SetSystemSetting(key, value string) error {
 		key, value, value)
 
 	if err != nil {
-		log.Error("failed to store system setting",
-			"error", err,
-			"key", key)
 		return fmt.Errorf("failed to store system setting: %w", err)
 	}
 
@@ -104,9 +91,6 @@ func generateRandomSecret(bytes int) (string, error) {
 	b := make([]byte, bytes)
 	_, err := rand.Read(b)
 	if err != nil {
-		log.Error("failed to generate random bytes",
-			"error", err,
-			"bytes", bytes)
 		return "", fmt.Errorf("failed to generate random bytes: %w", err)
 	}
 
@@ -125,7 +109,6 @@ func (db *database) GetSystemStats() (*UserStats, error) {
 	// Get total users
 	err := db.QueryRow("SELECT COUNT(*) FROM users").Scan(&stats.TotalUsers)
 	if err != nil {
-		log.Error("failed to get total users count", "error", err)
 		return nil, fmt.Errorf("failed to get total users count: %w", err)
 	}
 	log.Debug("got total users count", "count", stats.TotalUsers)
@@ -133,7 +116,6 @@ func (db *database) GetSystemStats() (*UserStats, error) {
 	// Get total workspaces
 	err = db.QueryRow("SELECT COUNT(*) FROM workspaces").Scan(&stats.TotalWorkspaces)
 	if err != nil {
-		log.Error("failed to get total workspaces count", "error", err)
 		return nil, fmt.Errorf("failed to get total workspaces count: %w", err)
 	}
 	log.Debug("got total workspaces count", "count", stats.TotalWorkspaces)
@@ -145,14 +127,8 @@ func (db *database) GetSystemStats() (*UserStats, error) {
         WHERE created_at > datetime('now', '-30 days')`).
 		Scan(&stats.ActiveUsers)
 	if err != nil {
-		log.Error("failed to get active users count", "error", err)
 		return nil, fmt.Errorf("failed to get active users count: %w", err)
 	}
 	log.Debug("got active users count", "count", stats.ActiveUsers)
-
-	log.Info("system statistics collected successfully",
-		"total_users", stats.TotalUsers,
-		"total_workspaces", stats.TotalWorkspaces,
-		"active_users", stats.ActiveUsers)
 	return stats, nil
 }

server/internal/db/users.go

@@ -9,13 +9,12 @@ import (
 // CreateUser inserts a new user record into the database
 func (db *database) CreateUser(user *models.User) (*models.User, error) {
 	log := getLogger().WithGroup("users")
-	log.Info("creating new user",
+	log.Debug("creating new user",
 		"email", user.Email,
 		"role", user.Role)
 
 	tx, err := db.Begin()
 	if err != nil {
-		log.Error("failed to begin transaction", "error", err)
 		return nil, fmt.Errorf("failed to begin transaction: %w", err)
 	}
 	defer tx.Rollback()
@@ -25,15 +24,11 @@ func (db *database) CreateUser(user *models.User) (*models.User, error) {
         VALUES (?, ?, ?, ?)`,
 		user.Email, user.DisplayName, user.PasswordHash, user.Role)
 	if err != nil {
-		log.Error("failed to insert user",
-			"error", err,
-			"email", user.Email)
 		return nil, fmt.Errorf("failed to insert user: %w", err)
 	}
 
 	userID, err := result.LastInsertId()
 	if err != nil {
-		log.Error("failed to get last insert ID", "error", err)
 		return nil, fmt.Errorf("failed to get last insert ID: %w", err)
 	}
 	user.ID = int(userID)
@@ -41,9 +36,6 @@ func (db *database) CreateUser(user *models.User) (*models.User, error) {
 	// Retrieve the created_at timestamp
 	err = tx.QueryRow("SELECT created_at FROM users WHERE id = ?", user.ID).Scan(&user.CreatedAt)
 	if err != nil {
-		log.Error("failed to get created timestamp",
-			"error", err,
-			"user_id", user.ID)
 		return nil, fmt.Errorf("failed to get created timestamp: %w", err)
 	}
 
@@ -58,9 +50,6 @@ func (db *database) CreateUser(user *models.User) (*models.User, error) {
 	// Create workspace with settings
 	err = db.createWorkspaceTx(tx, defaultWorkspace)
 	if err != nil {
-		log.Error("failed to create default workspace",
-			"error", err,
-			"user_id", user.ID)
 		return nil, fmt.Errorf("failed to create default workspace: %w", err)
 	}
 
@@ -70,23 +59,16 @@ func (db *database) CreateUser(user *models.User) (*models.User, error) {
 		"workspace_id", defaultWorkspace.ID)
 	_, err = tx.Exec("UPDATE users SET last_workspace_id = ? WHERE id = ?", defaultWorkspace.ID, user.ID)
 	if err != nil {
-		log.Error("failed to update last workspace ID",
-			"error", err,
-			"user_id", user.ID,
-			"workspace_id", defaultWorkspace.ID)
 		return nil, fmt.Errorf("failed to update last workspace ID: %w", err)
 	}
 
 	err = tx.Commit()
 	if err != nil {
-		log.Error("failed to commit transaction",
-			"error", err,
-			"user_id", user.ID)
 		return nil, fmt.Errorf("failed to commit transaction: %w", err)
 	}
 
 	user.LastWorkspaceID = defaultWorkspace.ID
-	log.Info("user created successfully",
+	log.Info("user created",
 		"user_id", user.ID,
 		"email", user.Email,
 		"workspace_id", defaultWorkspace.ID)
@@ -115,15 +97,11 @@ func (db *database) createWorkspaceTx(tx *sql.Tx, workspace *models.Workspace) e
 		workspace.GitCommitName, workspace.GitCommitEmail,
 	)
 	if err != nil {
-		log.Error("failed to insert workspace",
-			"error", err,
-			"user_id", workspace.UserID)
 		return fmt.Errorf("failed to insert workspace: %w", err)
 	}
 
 	id, err := result.LastInsertId()
 	if err != nil {
-		log.Error("failed to get workspace ID", "error", err)
 		return fmt.Errorf("failed to get workspace ID: %w", err)
 	}
 	workspace.ID = int(id)
@@ -153,9 +131,6 @@ func (db *database) GetUserByID(id int) (*models.User, error) {
 		return nil, fmt.Errorf("user not found")
 	}
 	if err != nil {
-		log.Error("failed to fetch user",
-			"error", err,
-			"user_id", id)
 		return nil, fmt.Errorf("failed to fetch user: %w", err)
 	}
 
@@ -182,9 +157,6 @@ func (db *database) GetUserByEmail(email string) (*models.User, error) {
 		return nil, fmt.Errorf("user not found")
 	}
 	if err != nil {
-		log.Error("failed to fetch user",
-			"error", err,
-			"email", email)
 		return nil, fmt.Errorf("failed to fetch user: %w", err)
 	}
 
@@ -194,10 +166,6 @@ func (db *database) GetUserByEmail(email string) (*models.User, error) {
 
 func (db *database) UpdateUser(user *models.User) error {
 	log := getLogger().WithGroup("users")
-	log.Info("updating user",
-		"user_id", user.ID,
-		"email", user.Email)
-
 	result, err := db.Exec(`
         UPDATE users
         SET email = ?, display_name = ?, password_hash = ?, role = ?, last_workspace_id = ?
@@ -206,17 +174,11 @@ func (db *database) UpdateUser(user *models.User) error {
 		user.LastWorkspaceID, user.ID)
 
 	if err != nil {
-		log.Error("failed to update user",
-			"error", err,
-			"user_id", user.ID)
 		return fmt.Errorf("failed to update user: %w", err)
 	}
 
 	rowsAffected, err := result.RowsAffected()
 	if err != nil {
-		log.Error("failed to get rows affected",
-			"error", err,
-			"user_id", user.ID)
 		return fmt.Errorf("failed to get rows affected: %w", err)
 	}
 
@@ -225,7 +187,7 @@ func (db *database) UpdateUser(user *models.User) error {
 		return fmt.Errorf("user not found")
 	}
 
-	log.Info("user updated successfully", "user_id", user.ID)
+	log.Info("user updated", "user_id", user.ID)
 	return nil
 }
 
@@ -240,7 +202,6 @@ func (db *database) GetAllUsers() ([]*models.User, error) {
         FROM users
         ORDER BY id ASC`)
 	if err != nil {
-		log.Error("failed to query users", "error", err)
 		return nil, fmt.Errorf("failed to query users: %w", err)
 	}
 	defer rows.Close()
@@ -253,7 +214,6 @@ func (db *database) GetAllUsers() ([]*models.User, error) {
 			&user.CreatedAt, &user.LastWorkspaceID,
 		)
 		if err != nil {
-			log.Error("failed to scan user row", "error", err)
 			return nil, fmt.Errorf("failed to scan user row: %w", err)
 		}
 		users = append(users, user)
@@ -271,7 +231,6 @@ func (db *database) UpdateLastWorkspace(userID int, workspaceName string) error
 
 	tx, err := db.Begin()
 	if err != nil {
-		log.Error("failed to begin transaction", "error", err)
 		return fmt.Errorf("failed to begin transaction: %w", err)
 	}
 	defer tx.Rollback()
@@ -280,30 +239,21 @@ func (db *database) UpdateLastWorkspace(userID int, workspaceName string) error
 	err = tx.QueryRow("SELECT id FROM workspaces WHERE user_id = ? AND name = ?",
 		userID, workspaceName).Scan(&workspaceID)
 	if err != nil {
-		log.Error("failed to find workspace",
-			"error", err,
-			"user_id", userID,
-			"workspace_name", workspaceName)
 		return fmt.Errorf("failed to find workspace: %w", err)
 	}
 
 	_, err = tx.Exec("UPDATE users SET last_workspace_id = ? WHERE id = ?",
 		workspaceID, userID)
 	if err != nil {
-		log.Error("failed to update last workspace",
-			"error", err,
-			"user_id", userID,
-			"workspace_id", workspaceID)
 		return fmt.Errorf("failed to update last workspace: %w", err)
 	}
 
 	err = tx.Commit()
 	if err != nil {
-		log.Error("failed to commit transaction", "error", err)
 		return fmt.Errorf("failed to commit transaction: %w", err)
 	}
 
-	log.Info("last workspace updated successfully",
+	log.Info("last workspace updated",
 		"user_id", userID,
 		"workspace_id", workspaceID)
 	return nil
@@ -311,11 +261,10 @@ func (db *database) UpdateLastWorkspace(userID int, workspaceName string) error
 
 func (db *database) DeleteUser(id int) error {
 	log := getLogger().WithGroup("users")
-	log.Info("deleting user", "user_id", id)
+	log.Debug("deleting user", "user_id", id)
 
 	tx, err := db.Begin()
 	if err != nil {
-		log.Error("failed to begin transaction", "error", err)
 		return fmt.Errorf("failed to begin transaction: %w", err)
 	}
 	defer tx.Rollback()
@@ -324,15 +273,11 @@ func (db *database) DeleteUser(id int) error {
 	log.Debug("deleting user workspaces", "user_id", id)
 	result, err := tx.Exec("DELETE FROM workspaces WHERE user_id = ?", id)
 	if err != nil {
-		log.Error("failed to delete workspaces",
-			"error", err,
-			"user_id", id)
 		return fmt.Errorf("failed to delete workspaces: %w", err)
 	}
 
 	workspacesDeleted, err := result.RowsAffected()
 	if err != nil {
-		log.Error("failed to get deleted workspaces count", "error", err)
 		return fmt.Errorf("failed to get deleted workspaces count: %w", err)
 	}
 
@@ -340,15 +285,11 @@ func (db *database) DeleteUser(id int) error {
 	log.Debug("deleting user record", "user_id", id)
 	result, err = tx.Exec("DELETE FROM users WHERE id = ?", id)
 	if err != nil {
-		log.Error("failed to delete user",
-			"error", err,
-			"user_id", id)
 		return fmt.Errorf("failed to delete user: %w", err)
 	}
 
 	userDeleted, err := result.RowsAffected()
 	if err != nil {
-		log.Error("failed to get deleted user count", "error", err)
 		return fmt.Errorf("failed to get deleted user count: %w", err)
 	}
 
@@ -359,11 +300,10 @@ func (db *database) DeleteUser(id int) error {
 
 	err = tx.Commit()
 	if err != nil {
-		log.Error("failed to commit transaction", "error", err)
 		return fmt.Errorf("failed to commit transaction: %w", err)
 	}
 
-	log.Info("user deleted successfully",
+	log.Info("user deleted",
 		"user_id", id,
 		"workspaces_deleted", workspacesDeleted)
 	return nil
@@ -387,9 +327,6 @@ func (db *database) GetLastWorkspaceName(userID int) (string, error) {
 		return "", fmt.Errorf("no last workspace found")
 	}
 	if err != nil {
-		log.Error("failed to fetch last workspace name",
-			"error", err,
-			"user_id", userID)
 		return "", fmt.Errorf("failed to fetch last workspace name: %w", err)
 	}
 
@@ -407,7 +344,6 @@ func (db *database) CountAdminUsers() (int, error) {
 	var count int
 	err := db.QueryRow("SELECT COUNT(*) FROM users WHERE role = 'admin'").Scan(&count)
 	if err != nil {
-		log.Error("failed to count admin users", "error", err)
 		return 0, fmt.Errorf("failed to count admin users: %w", err)
 	}
 

server/internal/db/workspaces.go

@@ -9,7 +9,7 @@ import (
 // CreateWorkspace inserts a new workspace record into the database
 func (db *database) CreateWorkspace(workspace *models.Workspace) error {
 	log := getLogger().WithGroup("workspaces")
-	log.Info("creating new workspace",
+	log.Debug("creating new workspace",
 		"user_id", workspace.UserID,
 		"name", workspace.Name,
 		"git_enabled", workspace.GitEnabled)
@@ -23,7 +23,6 @@ func (db *database) CreateWorkspace(workspace *models.Workspace) error {
 	// Encrypt token if present
 	encryptedToken, err := db.encryptToken(workspace.GitToken)
 	if err != nil {
-		log.Error("failed to encrypt git token", "error", err)
 		return fmt.Errorf("failed to encrypt token: %w", err)
 	}
 
@@ -39,18 +38,16 @@ func (db *database) CreateWorkspace(workspace *models.Workspace) error {
 		workspace.GitAutoCommit, workspace.GitCommitMsgTemplate, workspace.GitCommitName, workspace.GitCommitEmail,
 	)
 	if err != nil {
-		log.Error("failed to insert workspace", "error", err)
 		return fmt.Errorf("failed to insert workspace: %w", err)
 	}
 
 	id, err := result.LastInsertId()
 	if err != nil {
-		log.Error("failed to get workspace ID", "error", err)
 		return fmt.Errorf("failed to get workspace ID: %w", err)
 	}
 	workspace.ID = int(id)
 
-	log.Info("workspace created successfully",
+	log.Info("workspace created",
 		"workspace_id", workspace.ID,
 		"user_id", workspace.UserID)
 	return nil
@@ -87,22 +84,16 @@ func (db *database) GetWorkspaceByID(id int) (*models.Workspace, error) {
 		return nil, fmt.Errorf("workspace not found")
 	}
 	if err != nil {
-		log.Error("failed to fetch workspace",
-			"error", err,
-			"workspace_id", id)
 		return nil, fmt.Errorf("failed to fetch workspace: %w", err)
 	}
 
 	// Decrypt token
 	workspace.GitToken, err = db.decryptToken(encryptedToken)
 	if err != nil {
-		log.Error("failed to decrypt git token",
-			"error", err,
-			"workspace_id", id)
 		return nil, fmt.Errorf("failed to decrypt token: %w", err)
 	}
 
-	log.Debug("workspace retrieved successfully",
+	log.Debug("workspace retrieved",
 		"workspace_id", id,
 		"user_id", workspace.UserID)
 	return workspace, nil
@@ -143,19 +134,12 @@ func (db *database) GetWorkspaceByName(userID int, workspaceName string) (*model
 		return nil, fmt.Errorf("workspace not found")
 	}
 	if err != nil {
-		log.Error("failed to fetch workspace",
-			"error", err,
-			"user_id", userID,
-			"workspace_name", workspaceName)
 		return nil, fmt.Errorf("failed to fetch workspace: %w", err)
 	}
 
 	// Decrypt token
 	workspace.GitToken, err = db.decryptToken(encryptedToken)
 	if err != nil {
-		log.Error("failed to decrypt git token",
-			"error", err,
-			"workspace_id", workspace.ID)
 		return nil, fmt.Errorf("failed to decrypt token: %w", err)
 	}
 
@@ -168,7 +152,7 @@ func (db *database) GetWorkspaceByName(userID int, workspaceName string) (*model
 // UpdateWorkspace updates a workspace record in the database
 func (db *database) UpdateWorkspace(workspace *models.Workspace) error {
 	log := getLogger().WithGroup("workspaces")
-	log.Info("updating workspace",
+	log.Debug("updating workspace",
 		"workspace_id", workspace.ID,
 		"user_id", workspace.UserID,
 		"git_enabled", workspace.GitEnabled)
@@ -176,7 +160,6 @@ func (db *database) UpdateWorkspace(workspace *models.Workspace) error {
 	// Encrypt token before storing
 	encryptedToken, err := db.encryptToken(workspace.GitToken)
 	if err != nil {
-		log.Error("failed to encrypt git token", "error", err)
 		return fmt.Errorf("failed to encrypt token: %w", err)
 	}
 
@@ -212,17 +195,11 @@ func (db *database) UpdateWorkspace(workspace *models.Workspace) error {
 		workspace.UserID,
 	)
 	if err != nil {
-		log.Error("failed to update workspace",
-			"error", err,
-			"workspace_id", workspace.ID)
 		return fmt.Errorf("failed to update workspace: %w", err)
 	}
 
 	rowsAffected, err := result.RowsAffected()
 	if err != nil {
-		log.Error("failed to get rows affected",
-			"error", err,
-			"workspace_id", workspace.ID)
 		return fmt.Errorf("failed to get rows affected: %w", err)
 	}
 
@@ -233,7 +210,7 @@ func (db *database) UpdateWorkspace(workspace *models.Workspace) error {
 		return fmt.Errorf("workspace not found")
 	}
 
-	log.Info("workspace updated successfully",
+	log.Debug("workspace updated",
 		"workspace_id", workspace.ID,
 		"user_id", workspace.UserID)
 	return nil
@@ -256,9 +233,6 @@ func (db *database) GetWorkspacesByUserID(userID int) ([]*models.Workspace, erro
 		userID,
 	)
 	if err != nil {
-		log.Error("failed to query workspaces",
-			"error", err,
-			"user_id", userID)
 		return nil, fmt.Errorf("failed to query workspaces: %w", err)
 	}
 	defer rows.Close()
@@ -275,16 +249,12 @@ func (db *database) GetWorkspacesByUserID(userID int) ([]*models.Workspace, erro
 			&workspace.GitCommitName, &workspace.GitCommitEmail,
 		)
 		if err != nil {
-			log.Error("failed to scan workspace row", "error", err)
 			return nil, fmt.Errorf("failed to scan workspace row: %w", err)
 		}
 
 		// Decrypt token
 		workspace.GitToken, err = db.decryptToken(encryptedToken)
 		if err != nil {
-			log.Error("failed to decrypt git token",
-				"error", err,
-				"workspace_id", workspace.ID)
 			return nil, fmt.Errorf("failed to decrypt token: %w", err)
 		}
 
@@ -292,9 +262,6 @@ func (db *database) GetWorkspacesByUserID(userID int) ([]*models.Workspace, erro
 	}
 
 	if err = rows.Err(); err != nil {
-		log.Error("error iterating workspace rows",
-			"error", err,
-			"user_id", userID)
 		return nil, fmt.Errorf("error iterating workspace rows: %w", err)
 	}
 
@@ -307,7 +274,7 @@ func (db *database) GetWorkspacesByUserID(userID int) ([]*models.Workspace, erro
 // UpdateWorkspaceSettings updates only the settings portion of a workspace
 func (db *database) UpdateWorkspaceSettings(workspace *models.Workspace) error {
 	log := getLogger().WithGroup("workspaces")
-	log.Info("updating workspace settings",
+	log.Debug("updating workspace settings",
 		"workspace_id", workspace.ID,
 		"git_enabled", workspace.GitEnabled)
 
@@ -340,17 +307,11 @@ func (db *database) UpdateWorkspaceSettings(workspace *models.Workspace) error {
 		workspace.ID,
 	)
 	if err != nil {
-		log.Error("failed to update workspace settings",
-			"error", err,
-			"workspace_id", workspace.ID)
 		return fmt.Errorf("failed to update workspace settings: %w", err)
 	}
 
 	rowsAffected, err := result.RowsAffected()
 	if err != nil {
-		log.Error("failed to get rows affected",
-			"error", err,
-			"workspace_id", workspace.ID)
 		return fmt.Errorf("failed to get rows affected: %w", err)
 	}
 
@@ -360,7 +321,7 @@ func (db *database) UpdateWorkspaceSettings(workspace *models.Workspace) error {
 		return fmt.Errorf("workspace not found")
 	}
 
-	log.Info("workspace settings updated successfully",
+	log.Info("workspace settings updated",
 		"workspace_id", workspace.ID)
 	return nil
 }
@@ -368,21 +329,15 @@ func (db *database) UpdateWorkspaceSettings(workspace *models.Workspace) error {
 // DeleteWorkspace removes a workspace record from the database
 func (db *database) DeleteWorkspace(id int) error {
 	log := getLogger().WithGroup("workspaces")
-	log.Info("deleting workspace", "workspace_id", id)
+	log.Debug("deleting workspace", "workspace_id", id)
 
 	result, err := db.Exec("DELETE FROM workspaces WHERE id = ?", id)
 	if err != nil {
-		log.Error("failed to delete workspace",
-			"error", err,
-			"workspace_id", id)
 		return fmt.Errorf("failed to delete workspace: %w", err)
 	}
 
 	rowsAffected, err := result.RowsAffected()
 	if err != nil {
-		log.Error("failed to get rows affected",
-			"error", err,
-			"workspace_id", id)
 		return fmt.Errorf("failed to get rows affected: %w", err)
 	}
 
@@ -391,7 +346,7 @@ func (db *database) DeleteWorkspace(id int) error {
 		return fmt.Errorf("workspace not found")
 	}
 
-	log.Info("workspace deleted successfully", "workspace_id", id)
+	log.Info("workspace deleted", "workspace_id", id)
 	return nil
 }
 
@@ -402,17 +357,11 @@ func (db *database) DeleteWorkspaceTx(tx *sql.Tx, id int) error {
 
 	result, err := tx.Exec("DELETE FROM workspaces WHERE id = ?", id)
 	if err != nil {
-		log.Error("failed to delete workspace in transaction",
-			"error", err,
-			"workspace_id", id)
 		return fmt.Errorf("failed to delete workspace in transaction: %w", err)
 	}
 
 	rowsAffected, err := result.RowsAffected()
 	if err != nil {
-		log.Error("failed to get rows affected in transaction",
-			"error", err,
-			"workspace_id", id)
 		return fmt.Errorf("failed to get rows affected in transaction: %w", err)
 	}
 
@@ -437,18 +386,11 @@ func (db *database) UpdateLastWorkspaceTx(tx *sql.Tx, userID, workspaceID int) e
 	result, err := tx.Exec("UPDATE users SET last_workspace_id = ? WHERE id = ?",
 		workspaceID, userID)
 	if err != nil {
-		log.Error("failed to update last workspace in transaction",
-			"error", err,
-			"user_id", userID,
-			"workspace_id", workspaceID)
 		return fmt.Errorf("failed to update last workspace in transaction: %w", err)
 	}
 
 	rowsAffected, err := result.RowsAffected()
 	if err != nil {
-		log.Error("failed to get rows affected in transaction",
-			"error", err,
-			"user_id", userID)
 		return fmt.Errorf("failed to get rows affected in transaction: %w", err)
 	}
 
@@ -474,17 +416,11 @@ func (db *database) UpdateLastOpenedFile(workspaceID int, filePath string) error
 	result, err := db.Exec("UPDATE workspaces SET last_opened_file_path = ? WHERE id = ?",
 		filePath, workspaceID)
 	if err != nil {
-		log.Error("failed to update last opened file",
-			"error", err,
-			"workspace_id", workspaceID)
 		return fmt.Errorf("failed to update last opened file: %w", err)
 	}
 
 	rowsAffected, err := result.RowsAffected()
 	if err != nil {
-		log.Error("failed to get rows affected",
-			"error", err,
-			"workspace_id", workspaceID)
 		return fmt.Errorf("failed to get rows affected: %w", err)
 	}
 
@@ -513,9 +449,6 @@ func (db *database) GetLastOpenedFile(workspaceID int) (string, error) {
 		return "", fmt.Errorf("workspace not found")
 	}
 	if err != nil {
-		log.Error("failed to fetch last opened file",
-			"error", err,
-			"workspace_id", workspaceID)
 		return "", fmt.Errorf("failed to fetch last opened file: %w", err)
 	}
 
@@ -545,7 +478,6 @@ func (db *database) GetAllWorkspaces() ([]*models.Workspace, error) {
         FROM workspaces`,
 	)
 	if err != nil {
-		log.Error("failed to query workspaces", "error", err)
 		return nil, fmt.Errorf("failed to query workspaces: %w", err)
 	}
 	defer rows.Close()
@@ -562,16 +494,12 @@ func (db *database) GetAllWorkspaces() ([]*models.Workspace, error) {
 			&workspace.GitCommitName, &workspace.GitCommitEmail,
 		)
 		if err != nil {
-			log.Error("failed to scan workspace row", "error", err)
 			return nil, fmt.Errorf("failed to scan workspace row: %w", err)
 		}
 
 		// Decrypt token
 		workspace.GitToken, err = db.decryptToken(encryptedToken)
 		if err != nil {
-			log.Error("failed to decrypt git token",
-				"error", err,
-				"workspace_id", workspace.ID)
 			return nil, fmt.Errorf("failed to decrypt token: %w", err)
 		}
 
@@ -579,7 +507,6 @@ func (db *database) GetAllWorkspaces() ([]*models.Workspace, error) {
 	}
 
 	if err = rows.Err(); err != nil {
-		log.Error("error iterating workspace rows", "error", err)
 		return nil, fmt.Errorf("error iterating workspace rows: %w", err)
 	}