Use exc_info for error logging

src/password_manager/backup.py

@@ -73,8 +73,7 @@ class BackupManager:
             logger.info(f"Backup created successfully at '{backup_file}'.")
             print(colored(f"Backup created successfully at '{backup_file}'.", "green"))
         except Exception as e:
-            logger.error(f"Failed to create backup: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to create backup: {e}", exc_info=True)
             print(colored(f"Error: Failed to create backup: {e}", "red"))
 
     def restore_latest_backup(self) -> None:
@@ -100,8 +99,9 @@ class BackupManager:
                 )
             )
         except Exception as e:
-            logger.error(f"Failed to restore from backup '{latest_backup}': {e}")
-            logger.error(traceback.format_exc())
+            logger.error(
+                f"Failed to restore from backup '{latest_backup}': {e}", exc_info=True
+            )
             print(
                 colored(
                     f"Error: Failed to restore from backup '{latest_backup}': {e}",
@@ -129,8 +129,7 @@ class BackupManager:
                 )
                 print(colored(f"- {backup.name} (Created on: {creation_time})", "cyan"))
         except Exception as e:
-            logger.error(f"Failed to list backups: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to list backups: {e}", exc_info=True)
             print(colored(f"Error: Failed to list backups: {e}", "red"))
 
     def restore_backup_by_timestamp(self, timestamp: int) -> None:
@@ -152,8 +151,9 @@ class BackupManager:
                 )
             )
         except Exception as e:
-            logger.error(f"Failed to restore from backup '{backup_file}': {e}")
-            logger.error(traceback.format_exc())
+            logger.error(
+                f"Failed to restore from backup '{backup_file}': {e}", exc_info=True
+            )
             print(
                 colored(
                     f"Error: Failed to restore from backup '{backup_file}': {e}", "red"

src/password_manager/encryption.py

@@ -58,7 +58,6 @@ class EncryptionManager:
             logger.error(
                 f"Failed to initialize Fernet with provided encryption key: {e}"
             )
-            logger.error(traceback.format_exc())
             print(
                 colored(f"Error: Failed to initialize encryption manager: {e}", "red")
             )
@@ -95,8 +94,7 @@ class EncryptionManager:
                 )
             )
         except Exception as e:
-            logger.error(f"Failed to encrypt and save parent seed: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to encrypt and save parent seed: {e}", exc_info=True)
             print(colored(f"Error: Failed to encrypt and save parent seed: {e}", "red"))
             raise
 
@@ -126,8 +124,7 @@ class EncryptionManager:
             print(colored("Error: Invalid encryption key or corrupted data.", "red"))
             raise
         except Exception as e:
-            logger.error(f"Failed to decrypt parent seed: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to decrypt parent seed: {e}", exc_info=True)
             print(colored(f"Error: Failed to decrypt parent seed: {e}", "red"))
             raise
 
@@ -143,8 +140,7 @@ class EncryptionManager:
             logger.debug("Data encrypted successfully.")
             return encrypted_data
         except Exception as e:
-            logger.error(f"Failed to encrypt data: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to encrypt data: {e}", exc_info=True)
             print(colored(f"Error: Failed to encrypt data: {e}", "red"))
             raise
 
@@ -166,8 +162,7 @@ class EncryptionManager:
             print(colored("Error: Invalid encryption key or corrupted data.", "red"))
             raise
         except Exception as e:
-            logger.error(f"Failed to decrypt data: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to decrypt data: {e}", exc_info=True)
             print(colored(f"Error: Failed to decrypt data: {e}", "red"))
             raise
 
@@ -199,8 +194,10 @@ class EncryptionManager:
             logger.info(f"Data encrypted and saved to '{file_path}'.")
             print(colored(f"Data encrypted and saved to '{file_path}'.", "green"))
         except Exception as e:
-            logger.error(f"Failed to encrypt and save data to '{relative_path}': {e}")
-            logger.error(traceback.format_exc())
+            logger.error(
+                f"Failed to encrypt and save data to '{relative_path}': {e}",
+                exc_info=True,
+            )
             print(
                 colored(
                     f"Error: Failed to encrypt and save data to '{relative_path}': {e}",
@@ -236,8 +233,9 @@ class EncryptionManager:
             print(colored("Error: Invalid encryption key or corrupted data.", "red"))
             raise
         except Exception as e:
-            logger.error(f"Failed to decrypt data from '{relative_path}': {e}")
-            logger.error(traceback.format_exc())
+            logger.error(
+                f"Failed to decrypt data from '{relative_path}': {e}", exc_info=True
+            )
             print(
                 colored(
                     f"Error: Failed to decrypt data from '{relative_path}': {e}", "red"
@@ -263,8 +261,9 @@ class EncryptionManager:
                 colored(f"JSON data encrypted and saved to '{relative_path}'.", "green")
             )
         except Exception as e:
-            logger.error(f"Failed to save JSON data to '{relative_path}': {e}")
-            logger.error(traceback.format_exc())  # Log full traceback
+            logger.error(
+                f"Failed to save JSON data to '{relative_path}': {e}", exc_info=True
+            )
             print(
                 colored(
                     f"Error: Failed to save JSON data to '{relative_path}': {e}", "red"
@@ -304,8 +303,9 @@ class EncryptionManager:
             logger.debug(f"JSON data loaded and decrypted from '{file_path}': {data}")
             return data
         except json.JSONDecodeError as e:
-            logger.error(f"Failed to decode JSON data from '{file_path}': {e}")
-            logger.error(traceback.format_exc())
+            logger.error(
+                f"Failed to decode JSON data from '{file_path}': {e}", exc_info=True
+            )
             print(
                 colored(
                     f"Error: Failed to decode JSON data from '{file_path}': {e}", "red"
@@ -319,8 +319,9 @@ class EncryptionManager:
             print(colored("Error: Invalid encryption key or corrupted data.", "red"))
             raise
         except Exception as e:
-            logger.error(f"Failed to load JSON data from '{file_path}': {e}")
-            logger.error(traceback.format_exc())
+            logger.error(
+                f"Failed to load JSON data from '{file_path}': {e}", exc_info=True
+            )
             print(
                 colored(
                     f"Error: Failed to load JSON data from '{file_path}': {e}", "red"
@@ -363,8 +364,9 @@ class EncryptionManager:
             )
             print(colored(f"Checksum for '{file_path}' updated.", "green"))
         except Exception as e:
-            logger.error(f"Failed to update checksum for '{relative_path}': {e}")
-            logger.error(traceback.format_exc())  # Log full traceback
+            logger.error(
+                f"Failed to update checksum for '{relative_path}': {e}", exc_info=True
+            )
             print(
                 colored(
                     f"Error: Failed to update checksum for '{relative_path}': {e}",
@@ -399,8 +401,10 @@ class EncryptionManager:
             logger.debug(f"Encrypted index data read from '{relative_path}'.")
             return encrypted_data
         except Exception as e:
-            logger.error(f"Failed to read encrypted index file '{relative_path}': {e}")
-            logger.error(traceback.format_exc())  # Log full traceback
+            logger.error(
+                f"Failed to read encrypted index file '{relative_path}': {e}",
+                exc_info=True,
+            )
             print(
                 colored(
                     f"Error: Failed to read encrypted index file '{relative_path}': {e}",
@@ -429,8 +433,9 @@ class EncryptionManager:
             logger.info("Index file updated from Nostr successfully.")
             print(colored("Index file updated from Nostr successfully.", "green"))
         except Exception as e:
-            logger.error(f"Failed to decrypt and save data from Nostr: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(
+                f"Failed to decrypt and save data from Nostr: {e}", exc_info=True
+            )
             print(
                 colored(
                     f"Error: Failed to decrypt and save data from Nostr: {e}", "red"
@@ -458,8 +463,7 @@ class EncryptionManager:
             logger.debug("Seed phrase validated successfully.")
             return True
         except Exception as e:
-            logging.error(f"Error validating seed phrase: {e}")
-            logging.error(traceback.format_exc())  # Log full traceback
+            logging.error(f"Error validating seed phrase: {e}", exc_info=True)
             print(colored(f"Error: Failed to validate seed phrase: {e}", "red"))
             return False
 
@@ -485,7 +489,6 @@ class EncryptionManager:
             logger.debug("Seed derived successfully from mnemonic.")
             return seed
         except Exception as e:
-            logger.error(f"Failed to derive seed from mnemonic: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to derive seed from mnemonic: {e}", exc_info=True)
             print(colored(f"Error: Failed to derive seed from mnemonic: {e}", "red"))
             raise

src/password_manager/entry_management.py

@@ -92,8 +92,7 @@ class EntryManager:
             logger.debug(f"Next index determined: {next_index}")
             return next_index
         except Exception as e:
-            logger.error(f"Error determining next index: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Error determining next index: {e}", exc_info=True)
             print(colored(f"Error determining next index: {e}", "red"))
             sys.exit(1)
 
@@ -141,8 +140,7 @@ class EntryManager:
             return index  # Return the assigned index
 
         except Exception as e:
-            logger.error(f"Failed to add entry: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to add entry: {e}", exc_info=True)
             print(colored(f"Error: Failed to add entry: {e}", "red"))
             sys.exit(1)
 
@@ -155,8 +153,7 @@ class EntryManager:
         try:
             return self.vault.get_encrypted_index()
         except Exception as e:
-            logger.error(f"Failed to retrieve encrypted index file: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to retrieve encrypted index file: {e}", exc_info=True)
             print(
                 colored(f"Error: Failed to retrieve encrypted index file: {e}", "red")
             )
@@ -182,8 +179,9 @@ class EntryManager:
                 return None
 
         except Exception as e:
-            logger.error(f"Failed to retrieve entry at index {index}: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(
+                f"Failed to retrieve entry at index {index}: {e}", exc_info=True
+            )
             print(
                 colored(f"Error: Failed to retrieve entry at index {index}: {e}", "red")
             )
@@ -247,8 +245,7 @@ class EntryManager:
             )
 
         except Exception as e:
-            logger.error(f"Failed to modify entry at index {index}: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to modify entry at index {index}: {e}", exc_info=True)
             print(
                 colored(f"Error: Failed to modify entry at index {index}: {e}", "red")
             )
@@ -292,8 +289,7 @@ class EntryManager:
             return entries
 
         except Exception as e:
-            logger.error(f"Failed to list entries: {e}")
-            logger.error(traceback.format_exc())  # Log full traceback
+            logger.error(f"Failed to list entries: {e}", exc_info=True)
             print(colored(f"Error: Failed to list entries: {e}", "red"))
             return []
 
@@ -329,8 +325,7 @@ class EntryManager:
                 )
 
         except Exception as e:
-            logger.error(f"Failed to delete entry at index {index}: {e}")
-            logger.error(traceback.format_exc())  # Log full traceback
+            logger.error(f"Failed to delete entry at index {index}: {e}", exc_info=True)
             print(
                 colored(f"Error: Failed to delete entry at index {index}: {e}", "red")
             )
@@ -354,8 +349,7 @@ class EntryManager:
             print(colored(f"[+] Checksum updated successfully.", "green"))
 
         except Exception as e:
-            logger.error(f"Failed to update checksum: {e}")
-            logger.error(traceback.format_exc())  # Log full traceback
+            logger.error(f"Failed to update checksum: {e}", exc_info=True)
             print(colored(f"Error: Failed to update checksum: {e}", "red"))
 
     def backup_index_file(self) -> None:
@@ -384,8 +378,7 @@ class EntryManager:
             print(colored(f"[+] Backup created at '{backup_path}'.", "green"))
 
         except Exception as e:
-            logger.error(f"Failed to create backup: {e}")
-            logger.error(traceback.format_exc())  # Log full traceback
+            logger.error(f"Failed to create backup: {e}", exc_info=True)
             print(colored(f"Warning: Failed to create backup: {e}", "yellow"))
 
     def restore_from_backup(self, backup_path: str) -> None:
@@ -420,8 +413,9 @@ class EntryManager:
             self.update_checksum()
 
         except Exception as e:
-            logger.error(f"Failed to restore from backup '{backup_path}': {e}")
-            logger.error(traceback.format_exc())  # Log full traceback
+            logger.error(
+                f"Failed to restore from backup '{backup_path}': {e}", exc_info=True
+            )
             print(
                 colored(
                     f"Error: Failed to restore from backup '{backup_path}': {e}", "red"
@@ -451,7 +445,6 @@ class EntryManager:
                 print("-" * 40)
 
         except Exception as e:
-            logger.error(f"Failed to list all entries: {e}")
-            logger.error(traceback.format_exc())  # Log full traceback
+            logger.error(f"Failed to list all entries: {e}", exc_info=True)
             print(colored(f"Error: Failed to list all entries: {e}", "red"))
             return

src/password_manager/manager.py

@@ -141,8 +141,7 @@ class PasswordManager:
             self.fingerprint_manager = FingerprintManager(APP_DIR)
             logger.debug("FingerprintManager initialized successfully.")
         except Exception as e:
-            logger.error(f"Failed to initialize FingerprintManager: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to initialize FingerprintManager: {e}", exc_info=True)
             print(
                 colored(f"Error: Failed to initialize FingerprintManager: {e}", "red")
             )
@@ -187,8 +186,7 @@ class PasswordManager:
                 self.select_fingerprint(selected_fingerprint)
 
         except Exception as e:
-            logger.error(f"Error during seed profile selection: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Error during seed profile selection: {e}", exc_info=True)
             print(colored(f"Error: Failed to select seed profile: {e}", "red"))
             sys.exit(1)
 
@@ -218,8 +216,7 @@ class PasswordManager:
             )
 
         except Exception as e:
-            logger.error(f"Error adding new seed profile: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Error adding new seed profile: {e}", exc_info=True)
             print(colored(f"Error: Failed to add new seed profile: {e}", "red"))
             sys.exit(1)
 
@@ -290,8 +287,7 @@ class PasswordManager:
                 print(colored("Invalid password. Exiting.", "red"))
                 sys.exit(1)
         except Exception as e:
-            logger.error(f"Failed to set up EncryptionManager: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to set up EncryptionManager: {e}", exc_info=True)
             print(colored(f"Error: Failed to set up encryption: {e}", "red"))
             sys.exit(1)
 
@@ -313,8 +309,7 @@ class PasswordManager:
             seed_bytes = Bip39SeedGenerator(self.parent_seed).Generate()
             self.bip85 = BIP85(seed_bytes)
         except Exception as e:
-            logger.error(f"Failed to load parent seed: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to load parent seed: {e}", exc_info=True)
             print(colored(f"Error: Failed to load parent seed: {e}", "red"))
             sys.exit(1)
 
@@ -385,8 +380,7 @@ class PasswordManager:
             return True  # Return True to indicate success
 
         except Exception as e:
-            logging.error(f"Error during seed profile switching: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Error during seed profile switching: {e}", exc_info=True)
             print(colored(f"Error: Failed to switch seed profiles: {e}", "red"))
             return False  # Return False to indicate failure
 
@@ -454,8 +448,7 @@ class PasswordManager:
             self.initialize_bip85()
             logging.debug("Parent seed decrypted and validated successfully.")
         except Exception as e:
-            logging.error(f"Failed to decrypt parent seed: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Failed to decrypt parent seed: {e}", exc_info=True)
             print(colored(f"Error: Failed to decrypt parent seed: {e}", "red"))
             sys.exit(1)
 
@@ -655,8 +648,7 @@ class PasswordManager:
             mnemonic = bip85.derive_mnemonic(index=0, words_num=12)
             return mnemonic
         except Exception as e:
-            logging.error(f"Failed to generate BIP-85 seed: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Failed to generate BIP-85 seed: {e}", exc_info=True)
             print(colored(f"Error: Failed to generate BIP-85 seed: {e}", "red"))
             sys.exit(1)
 
@@ -702,8 +694,7 @@ class PasswordManager:
             self.initialize_managers()
             self.sync_index_from_nostr_if_missing()
         except Exception as e:
-            logging.error(f"Failed to encrypt and save parent seed: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Failed to encrypt and save parent seed: {e}", exc_info=True)
             print(colored(f"Error: Failed to encrypt and save parent seed: {e}", "red"))
             sys.exit(1)
 
@@ -716,8 +707,7 @@ class PasswordManager:
             self.bip85 = BIP85(seed_bytes)
             logging.debug("BIP-85 initialized successfully.")
         except Exception as e:
-            logging.error(f"Failed to initialize BIP-85: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Failed to initialize BIP-85: {e}", exc_info=True)
             print(colored(f"Error: Failed to initialize BIP-85: {e}", "red"))
             sys.exit(1)
 
@@ -763,8 +753,7 @@ class PasswordManager:
             logger.debug("Managers re-initialized for the new fingerprint.")
 
         except Exception as e:
-            logger.error(f"Failed to initialize managers: {e}")
-            logging.error(traceback.format_exc())
+            logger.error(f"Failed to initialize managers: {e}", exc_info=True)
             print(colored(f"Error: Failed to initialize managers: {e}", "red"))
             sys.exit(1)
 
@@ -840,12 +829,13 @@ class PasswordManager:
                         "Encrypted index posted to Nostr after entry addition."
                     )
             except Exception as nostr_error:
-                logging.error(f"Failed to post updated index to Nostr: {nostr_error}")
-                logging.error(traceback.format_exc())
+                logging.error(
+                    f"Failed to post updated index to Nostr: {nostr_error}",
+                    exc_info=True,
+                )
 
         except Exception as e:
-            logging.error(f"Error during password generation: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Error during password generation: {e}", exc_info=True)
             print(colored(f"Error: Failed to generate password: {e}", "red"))
 
     def handle_retrieve_entry(self) -> None:
@@ -912,8 +902,7 @@ class PasswordManager:
             else:
                 print(colored("Error: Failed to retrieve the password.", "red"))
         except Exception as e:
-            logging.error(f"Error during password retrieval: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Error during password retrieval: {e}", exc_info=True)
             print(colored(f"Error: Failed to retrieve password: {e}", "red"))
 
     def handle_modify_entry(self) -> None:
@@ -1009,12 +998,13 @@ class PasswordManager:
                         "Encrypted index posted to Nostr after entry modification."
                     )
             except Exception as nostr_error:
-                logging.error(f"Failed to post updated index to Nostr: {nostr_error}")
-                logging.error(traceback.format_exc())
+                logging.error(
+                    f"Failed to post updated index to Nostr: {nostr_error}",
+                    exc_info=True,
+                )
 
         except Exception as e:
-            logging.error(f"Error during modifying entry: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Error during modifying entry: {e}", exc_info=True)
             print(colored(f"Error: Failed to modify entry: {e}", "red"))
 
     def delete_entry(self) -> None:
@@ -1049,12 +1039,13 @@ class PasswordManager:
                         "Encrypted index posted to Nostr after entry deletion."
                     )
             except Exception as nostr_error:
-                logging.error(f"Failed to post updated index to Nostr: {nostr_error}")
-                logging.error(traceback.format_exc())
+                logging.error(
+                    f"Failed to post updated index to Nostr: {nostr_error}",
+                    exc_info=True,
+                )
 
         except Exception as e:
-            logging.error(f"Error during entry deletion: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Error during entry deletion: {e}", exc_info=True)
             print(colored(f"Error: Failed to delete entry: {e}", "red"))
 
     def handle_verify_checksum(self) -> None:
@@ -1075,8 +1066,7 @@ class PasswordManager:
                 )
                 logging.error("Checksum verification failed.")
         except Exception as e:
-            logging.error(f"Error during checksum verification: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Error during checksum verification: {e}", exc_info=True)
             print(colored(f"Error: Failed to verify checksum: {e}", "red"))
 
     def get_encrypted_data(self) -> Optional[bytes]:
@@ -1095,8 +1085,7 @@ class PasswordManager:
                 print(colored("Error: Failed to retrieve encrypted index data.", "red"))
                 return None
         except Exception as e:
-            logging.error(f"Error retrieving encrypted data: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Error retrieving encrypted data: {e}", exc_info=True)
             print(colored(f"Error: Failed to retrieve encrypted data: {e}", "red"))
             return None
 
@@ -1111,8 +1100,9 @@ class PasswordManager:
             logging.info("Index file updated from Nostr successfully.")
             print(colored("Index file updated from Nostr successfully.", "green"))
         except Exception as e:
-            logging.error(f"Failed to decrypt and save data from Nostr: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(
+                f"Failed to decrypt and save data from Nostr: {e}", exc_info=True
+            )
             print(
                 colored(
                     f"Error: Failed to decrypt and save data from Nostr: {e}", "red"
@@ -1129,8 +1119,7 @@ class PasswordManager:
             self.backup_manager.create_backup()
             print(colored("Backup created successfully.", "green"))
         except Exception as e:
-            logging.error(f"Failed to create backup: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Failed to create backup: {e}", exc_info=True)
             print(colored(f"Error: Failed to create backup: {e}", "red"))
 
     def restore_database(self) -> None:
@@ -1145,8 +1134,7 @@ class PasswordManager:
                 )
             )
         except Exception as e:
-            logging.error(f"Failed to restore backup: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Failed to restore backup: {e}", exc_info=True)
             print(colored(f"Error: Failed to restore backup: {e}", "red"))
 
     def handle_backup_reveal_parent_seed(self) -> None:
@@ -1222,8 +1210,7 @@ class PasswordManager:
                 )
 
         except Exception as e:
-            logging.error(f"Error during parent seed backup/reveal: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Error during parent seed backup/reveal: {e}", exc_info=True)
             print(colored(f"Error: Failed to backup/reveal parent seed: {e}", "red"))
 
     def verify_password(self, password: str) -> bool:
@@ -1258,8 +1245,7 @@ class PasswordManager:
                 logging.warning("Password verification failed.")
             return is_correct
         except Exception as e:
-            logging.error(f"Error verifying password: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Error verifying password: {e}", exc_info=True)
             print(colored(f"Error: Failed to verify password: {e}", "red"))
             return False
 
@@ -1311,8 +1297,7 @@ class PasswordManager:
                 "User password hashed and stored successfully (using alternative method)."
             )
         except Exception as e:
-            logging.error(f"Failed to store hashed password: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Failed to store hashed password: {e}", exc_info=True)
             print(colored(f"Error: Failed to store hashed password: {e}", "red"))
             raise
 
@@ -1381,8 +1366,6 @@ class PasswordManager:
                 logging.error(
                     f"Failed to post updated index to Nostr after password change: {nostr_error}"
                 )
-                logging.error(traceback.format_exc())
         except Exception as e:
-            logging.error(f"Failed to change password: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Failed to change password: {e}", exc_info=True)
             print(colored(f"Error: Failed to change password: {e}", "red"))

src/password_manager/password_generation.py

@@ -68,8 +68,7 @@ class PasswordGenerator:
 
             logger.debug("PasswordGenerator initialized successfully.")
         except Exception as e:
-            logger.error(f"Failed to initialize PasswordGenerator: {e}")
-            logger.error(traceback.format_exc())  # Log full traceback
+            logger.error(f"Failed to initialize PasswordGenerator: {e}", exc_info=True)
             print(colored(f"Error: Failed to initialize PasswordGenerator: {e}", "red"))
             raise
 
@@ -177,8 +176,7 @@ class PasswordGenerator:
             return password
 
         except Exception as e:
-            logger.error(f"Error generating password: {e}")
-            logger.error(traceback.format_exc())  # Log full traceback
+            logger.error(f"Error generating password: {e}", exc_info=True)
             print(colored(f"Error: Failed to generate password: {e}", "red"))
             raise
 
@@ -331,7 +329,6 @@ class PasswordGenerator:
             return "".join(password_chars)
 
         except Exception as e:
-            logger.error(f"Error ensuring password complexity: {e}")
-            logger.error(traceback.format_exc())  # Log full traceback
+            logger.error(f"Error ensuring password complexity: {e}", exc_info=True)
             print(colored(f"Error: Failed to ensure password complexity: {e}", "red"))
             raise