From f6a94d06cc09292d129f46320b0d52ffcb039235 Mon Sep 17 00:00:00 2001
From: thePR0M3TH3AN <53631862+PR0M3TH3AN@users.noreply.github.com>
Date: Tue, 1 Jul 2025 18:23:44 -0400
Subject: [PATCH] Use exc_info for error logging

---
 src/constants.py                            |  9 +-
 src/local_bip85/__init__.py                 |  3 +-
 src/local_bip85/bip85.py                    | 12 +--
 src/main.py                                 | 27 ++----
 src/nostr/event_handler.py                  |  3 +-
 src/nostr/key_manager.py                    | 12 +--
 src/password_manager/backup.py              | 16 ++--
 src/password_manager/encryption.py          | 61 +++++++-------
 src/password_manager/entry_management.py    | 37 ++++----
 src/password_manager/manager.py             | 93 +++++++++------------
 src/password_manager/password_generation.py |  9 +-
 src/utils/__init__.py                       |  3 +-
 src/utils/checksum.py                       | 21 +++--
 src/utils/fingerprint.py                    |  3 +-
 src/utils/fingerprint_manager.py            | 12 ++-
 src/utils/key_derivation.py                 |  6 +-
 src/utils/password_prompt.py                | 15 ++--
 17 files changed, 149 insertions(+), 193 deletions(-)

diff --git a/src/constants.py b/src/constants.py
index fa85374..9eec419 100644
--- a/src/constants.py
+++ b/src/constants.py
@@ -25,8 +25,7 @@ try:
         logger.info(f"Application directory created at {APP_DIR}")
 except Exception as e:
     if logger.isEnabledFor(logging.DEBUG):
-        logger.error(f"Failed to create application directory: {e}")
-        logger.error(traceback.format_exc())  # Log full traceback
+        logger.error(f"Failed to create application directory: {e}", exc_info=True)
 
 try:
     PARENT_SEED_FILE = APP_DIR / "parent_seed.enc"  # Encrypted parent seed
@@ -34,8 +33,7 @@ try:
         logger.info(f"Parent seed file path set to {PARENT_SEED_FILE}")
 except Exception as e:
     if logger.isEnabledFor(logging.DEBUG):
-        logger.error(f"Error setting file paths: {e}")
-        logger.error(traceback.format_exc())  # Log full traceback
+        logger.error(f"Error setting file paths: {e}", exc_info=True)
 
 # -----------------------------------
 # Checksum Files for Integrity
@@ -48,8 +46,7 @@ try:
         logger.info(f"Checksum file path set: Script {SCRIPT_CHECKSUM_FILE}")
 except Exception as e:
     if logger.isEnabledFor(logging.DEBUG):
-        logger.error(f"Error setting checksum file paths: {e}")
-        logger.error(traceback.format_exc())  # Log full traceback
+        logger.error(f"Error setting checksum file paths: {e}", exc_info=True)
 
 # -----------------------------------
 # Password Generation Constants
diff --git a/src/local_bip85/__init__.py b/src/local_bip85/__init__.py
index 3765c0b..2379252 100644
--- a/src/local_bip85/__init__.py
+++ b/src/local_bip85/__init__.py
@@ -12,7 +12,6 @@ try:
         logger.info("BIP85 module imported successfully.")
 except Exception as e:
     if logger.isEnabledFor(logging.DEBUG):
-        logger.error(f"Failed to import BIP85 module: {e}")
-        logger.error(traceback.format_exc())  # Log full traceback
+        logger.error(f"Failed to import BIP85 module: {e}", exc_info=True)
 
 __all__ = ["BIP85"]
diff --git a/src/local_bip85/bip85.py b/src/local_bip85/bip85.py
index beac8de..025292b 100644
--- a/src/local_bip85/bip85.py
+++ b/src/local_bip85/bip85.py
@@ -41,8 +41,7 @@ class BIP85:
                 self.bip32_ctx = Bip32Slip10Secp256k1.FromExtendedKey(seed_bytes)
             logging.debug("BIP32 context initialized successfully.")
         except Exception as e:
-            logging.error(f"Error initializing BIP32 context: {e}")
-            logging.error(traceback.format_exc())  # Log full traceback
+            logging.error(f"Error initializing BIP32 context: {e}", exc_info=True)
             print(f"{Fore.RED}Error initializing BIP32 context: {e}")
             sys.exit(1)
 
@@ -96,8 +95,7 @@ class BIP85:
             logging.debug(f"Derived entropy: {entropy.hex()}")
             return entropy
         except Exception as e:
-            logging.error(f"Error deriving entropy: {e}")
-            logging.error(traceback.format_exc())  # Log full traceback
+            logging.error(f"Error deriving entropy: {e}", exc_info=True)
             print(f"{Fore.RED}Error deriving entropy: {e}")
             sys.exit(1)
 
@@ -118,8 +116,7 @@ class BIP85:
             logging.debug(f"Derived mnemonic: {mnemonic}")
             return mnemonic.ToStr()
         except Exception as e:
-            logging.error(f"Error generating mnemonic: {e}")
-            logging.error(traceback.format_exc())  # Log full traceback
+            logging.error(f"Error generating mnemonic: {e}", exc_info=True)
             print(f"{Fore.RED}Error generating mnemonic: {e}")
             sys.exit(1)
 
@@ -130,7 +127,6 @@ class BIP85:
             logging.debug(f"Derived symmetric key: {key.hex()}")
             return key
         except Exception as e:
-            logging.error(f"Error deriving symmetric key: {e}")
-            logging.error(traceback.format_exc())
+            logging.error(f"Error deriving symmetric key: {e}", exc_info=True)
             print(f"{Fore.RED}Error deriving symmetric key: {e}")
             sys.exit(1)
diff --git a/src/main.py b/src/main.py
index 5c4287e..566ef2a 100644
--- a/src/main.py
+++ b/src/main.py
@@ -119,8 +119,7 @@ def handle_switch_fingerprint(password_manager: PasswordManager):
         else:
             print(colored("Failed to switch seed profile.", "red"))
     except Exception as e:
-        logging.error(f"Error during fingerprint switch: {e}")
-        logging.error(traceback.format_exc())
+        logging.error(f"Error during fingerprint switch: {e}", exc_info=True)
         print(colored(f"Error: Failed to switch seed profile: {e}", "red"))
 
 
@@ -133,8 +132,7 @@ def handle_add_new_fingerprint(password_manager: PasswordManager):
     try:
         password_manager.add_new_fingerprint()
     except Exception as e:
-        logging.error(f"Error adding new seed profile: {e}")
-        logging.error(traceback.format_exc())
+        logging.error(f"Error adding new seed profile: {e}", exc_info=True)
         print(colored(f"Error: Failed to add new seed profile: {e}", "red"))
 
 
@@ -178,8 +176,7 @@ def handle_remove_fingerprint(password_manager: PasswordManager):
         else:
             print(colored("Seed profile removal cancelled.", "yellow"))
     except Exception as e:
-        logging.error(f"Error removing seed profile: {e}")
-        logging.error(traceback.format_exc())
+        logging.error(f"Error removing seed profile: {e}", exc_info=True)
         print(colored(f"Error: Failed to remove seed profile: {e}", "red"))
 
 
@@ -199,8 +196,7 @@ def handle_list_fingerprints(password_manager: PasswordManager):
         for fp in fingerprints:
             print(colored(f"- {fp}", "cyan"))
     except Exception as e:
-        logging.error(f"Error listing seed profiles: {e}")
-        logging.error(traceback.format_exc())
+        logging.error(f"Error listing seed profiles: {e}", exc_info=True)
         print(colored(f"Error: Failed to list seed profiles: {e}", "red"))
 
 
@@ -217,8 +213,7 @@ def handle_display_npub(password_manager: PasswordManager):
             print(colored("Nostr public key not available.", "red"))
             logging.error("Nostr public key not available.")
     except Exception as e:
-        logging.error(f"Failed to display npub: {e}")
-        logging.error(traceback.format_exc())
+        logging.error(f"Failed to display npub: {e}", exc_info=True)
         print(colored(f"Error: Failed to display npub: {e}", "red"))
 
 
@@ -247,8 +242,7 @@ def handle_post_to_nostr(
             print(colored("No data available to post.", "yellow"))
             logging.warning("No data available to post to Nostr.")
     except Exception as e:
-        logging.error(f"Failed to post to Nostr: {e}")
-        logging.error(traceback.format_exc())
+        logging.error(f"Failed to post to Nostr: {e}", exc_info=True)
         print(colored(f"Error: Failed to post to Nostr: {e}", "red"))
 
 
@@ -270,8 +264,7 @@ def handle_retrieve_from_nostr(password_manager: PasswordManager):
             print(colored("Failed to retrieve data from Nostr.", "red"))
             logging.error("Failed to retrieve data from Nostr.")
     except Exception as e:
-        logging.error(f"Failed to retrieve from Nostr: {e}")
-        logging.error(traceback.format_exc())
+        logging.error(f"Failed to retrieve from Nostr: {e}", exc_info=True)
         print(colored(f"Error: Failed to retrieve from Nostr: {e}", "red"))
 
 
@@ -594,8 +587,7 @@ if __name__ == "__main__":
         password_manager = PasswordManager(encryption_mode=enc_mode)
         logger.info("PasswordManager initialized successfully.")
     except Exception as e:
-        logger.error(f"Failed to initialize PasswordManager: {e}")
-        logger.error(traceback.format_exc())  # Log full traceback
+        logger.error(f"Failed to initialize PasswordManager: {e}", exc_info=True)
         print(colored(f"Error: Failed to initialize PasswordManager: {e}", "red"))
         sys.exit(1)
 
@@ -632,8 +624,7 @@ if __name__ == "__main__":
             print(colored(f"Error during shutdown: {e}", "red"))
         sys.exit(0)
     except Exception as e:
-        logger.error(f"An unexpected error occurred: {e}")
-        logger.error(traceback.format_exc())  # Log full traceback
+        logger.error(f"An unexpected error occurred: {e}", exc_info=True)
         print(colored(f"Error: An unexpected error occurred: {e}", "red"))
         try:
             password_manager.nostr_client.close_client_pool()  # Attempt to close the ClientPool
diff --git a/src/nostr/event_handler.py b/src/nostr/event_handler.py
index 0d87d95..7586eb4 100644
--- a/src/nostr/event_handler.py
+++ b/src/nostr/event_handler.py
@@ -47,7 +47,6 @@ class EventHandler:
                 f"[New Event] ID: {evt.id} | Created At: {created_at_str} | Content: {evt.content}"
             )
         except Exception as e:
-            logger.error(f"Error handling new event: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Error handling new event: {e}", exc_info=True)
             # Optionally, handle the exception without re-raising
             # For example, continue processing other events
diff --git a/src/nostr/key_manager.py b/src/nostr/key_manager.py
index 71f8973..2436914 100644
--- a/src/nostr/key_manager.py
+++ b/src/nostr/key_manager.py
@@ -47,8 +47,7 @@ class KeyManager:
             logger.debug("Nostr Keys initialized successfully.")
 
         except Exception as e:
-            logger.error(f"Key initialization failed: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Key initialization failed: {e}", exc_info=True)
             raise
 
     def initialize_bip85(self):
@@ -64,8 +63,7 @@ class KeyManager:
             logger.debug("BIP85 initialized successfully.")
             return bip85
         except Exception as e:
-            logger.error(f"Failed to initialize BIP85: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to initialize BIP85: {e}", exc_info=True)
             raise
 
     def generate_nostr_keys(self) -> Keys:
@@ -93,8 +91,7 @@ class KeyManager:
             logger.debug(f"Nostr keys generated for fingerprint {self.fingerprint}.")
             return keys
         except Exception as e:
-            logger.error(f"Failed to generate Nostr keys: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to generate Nostr keys: {e}", exc_info=True)
             raise
 
     def get_public_key_hex(self) -> str:
@@ -129,6 +126,5 @@ class KeyManager:
             npub = bech32_encode("npub", data)
             return npub
         except Exception as e:
-            logger.error(f"Failed to generate npub: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to generate npub: {e}", exc_info=True)
             raise
diff --git a/src/password_manager/backup.py b/src/password_manager/backup.py
index 2f35c31..c094ab3 100644
--- a/src/password_manager/backup.py
+++ b/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"
diff --git a/src/password_manager/encryption.py b/src/password_manager/encryption.py
index db42c6b..81d7cd9 100644
--- a/src/password_manager/encryption.py
+++ b/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
diff --git a/src/password_manager/entry_management.py b/src/password_manager/entry_management.py
index b227bf9..346696f 100644
--- a/src/password_manager/entry_management.py
+++ b/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
diff --git a/src/password_manager/manager.py b/src/password_manager/manager.py
index f0da803..1f6f5dc 100644
--- a/src/password_manager/manager.py
+++ b/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"))
diff --git a/src/password_manager/password_generation.py b/src/password_manager/password_generation.py
index 8a3407c..af37684 100644
--- a/src/password_manager/password_generation.py
+++ b/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
diff --git a/src/utils/__init__.py b/src/utils/__init__.py
index c9bbe2f..6e21714 100644
--- a/src/utils/__init__.py
+++ b/src/utils/__init__.py
@@ -21,8 +21,7 @@ try:
         logger.info("Modules imported successfully.")
 except Exception as e:
     if logger.isEnabledFor(logging.DEBUG):
-        logger.error(f"Failed to import one or more modules: {e}")
-        logger.error(traceback.format_exc())  # Log full traceback
+        logger.error(f"Failed to import one or more modules: {e}", exc_info=True)
 
 __all__ = [
     "derive_key_from_password",
diff --git a/src/utils/checksum.py b/src/utils/checksum.py
index 37f2e45..60278f6 100644
--- a/src/utils/checksum.py
+++ b/src/utils/checksum.py
@@ -52,8 +52,9 @@ def calculate_checksum(file_path: str) -> Optional[str]:
         )
         return None
     except Exception as e:
-        logging.error(f"Error calculating checksum for '{file_path}': {e}")
-        logging.error(traceback.format_exc())  # Log full traceback
+        logging.error(
+            f"Error calculating checksum for '{file_path}': {e}", exc_info=True
+        )
         print(
             colored(
                 f"Error: Failed to calculate checksum for '{file_path}': {e}", "red"
@@ -87,8 +88,9 @@ def verify_checksum(current_checksum: str, checksum_file_path: str) -> bool:
         print(colored(f"Error: Checksum file '{checksum_file_path}' not found.", "red"))
         return False
     except Exception as e:
-        logging.error(f"Error reading checksum file '{checksum_file_path}': {e}")
-        logging.error(traceback.format_exc())  # Log full traceback
+        logging.error(
+            f"Error reading checksum file '{checksum_file_path}': {e}", exc_info=True
+        )
         print(
             colored(
                 f"Error: Failed to read checksum file '{checksum_file_path}': {e}",
@@ -118,8 +120,9 @@ def update_checksum(content: str, checksum_file_path: str) -> bool:
         logging.debug(f"Updated checksum for '{checksum_file_path}' to: {new_checksum}")
         return True
     except Exception as e:
-        logging.error(f"Failed to update checksum for '{checksum_file_path}': {e}")
-        logging.error(traceback.format_exc())  # Log full traceback
+        logging.error(
+            f"Failed to update checksum for '{checksum_file_path}': {e}", exc_info=True
+        )
         print(
             colored(
                 f"Error: Failed to update checksum for '{checksum_file_path}': {e}",
@@ -178,8 +181,10 @@ def initialize_checksum(file_path: str, checksum_file_path: str) -> bool:
         print(colored(f"Initialized checksum for '{file_path}'.", "green"))
         return True
     except Exception as e:
-        logging.error(f"Failed to initialize checksum file '{checksum_file_path}': {e}")
-        logging.error(traceback.format_exc())  # Log full traceback
+        logging.error(
+            f"Failed to initialize checksum file '{checksum_file_path}': {e}",
+            exc_info=True,
+        )
         print(
             colored(
                 f"Error: Failed to initialize checksum file '{checksum_file_path}': {e}",
diff --git a/src/utils/fingerprint.py b/src/utils/fingerprint.py
index 6e7046d..e525798 100644
--- a/src/utils/fingerprint.py
+++ b/src/utils/fingerprint.py
@@ -43,6 +43,5 @@ def generate_fingerprint(seed_phrase: str, length: int = 16) -> Optional[str]:
 
         return fingerprint
     except Exception as e:
-        logger.error(f"Failed to generate fingerprint: {e}")
-        logger.error(traceback.format_exc())
+        logger.error(f"Failed to generate fingerprint: {e}", exc_info=True)
         return None
diff --git a/src/utils/fingerprint_manager.py b/src/utils/fingerprint_manager.py
index 84c1929..a47a942 100644
--- a/src/utils/fingerprint_manager.py
+++ b/src/utils/fingerprint_manager.py
@@ -61,7 +61,6 @@ class FingerprintManager:
             logger.error(
                 f"Failed to create application directory at {self.app_dir}: {e}"
             )
-            logger.error(traceback.format_exc())
             raise
 
     def _load_fingerprints(self) -> List[str]:
@@ -84,8 +83,7 @@ class FingerprintManager:
                 )
                 return []
         except Exception as e:
-            logger.error(f"Failed to load fingerprints: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to load fingerprints: {e}", exc_info=True)
             return []
 
     def _save_fingerprints(self):
@@ -97,8 +95,7 @@ class FingerprintManager:
                 json.dump({"fingerprints": self.fingerprints}, f, indent=4)
             logger.debug(f"Fingerprints saved: {self.fingerprints}")
         except Exception as e:
-            logger.error(f"Failed to save fingerprints: {e}")
-            logger.error(traceback.format_exc())
+            logger.error(f"Failed to save fingerprints: {e}", exc_info=True)
             raise
 
     def add_fingerprint(self, seed_phrase: str) -> Optional[str]:
@@ -154,8 +151,9 @@ class FingerprintManager:
                 logger.info(f"Fingerprint {fingerprint} removed successfully.")
                 return True
             except Exception as e:
-                logger.error(f"Failed to remove fingerprint {fingerprint}: {e}")
-                logger.error(traceback.format_exc())
+                logger.error(
+                    f"Failed to remove fingerprint {fingerprint}: {e}", exc_info=True
+                )
                 return False
         else:
             logger.warning(f"Fingerprint {fingerprint} does not exist.")
diff --git a/src/utils/key_derivation.py b/src/utils/key_derivation.py
index eb022b2..0f9d6ff 100644
--- a/src/utils/key_derivation.py
+++ b/src/utils/key_derivation.py
@@ -96,8 +96,7 @@ def derive_key_from_password(password: str, iterations: int = 100_000) -> bytes:
         return key_b64
 
     except Exception as e:
-        logger.error(f"Error deriving key from password: {e}")
-        logger.error(traceback.format_exc())  # Log full traceback
+        logger.error(f"Error deriving key from password: {e}", exc_info=True)
         raise
 
 
@@ -139,8 +138,7 @@ def derive_key_from_parent_seed(parent_seed: str, fingerprint: str = None) -> by
 
         return derived_key
     except Exception as e:
-        logger.error(f"Failed to derive key using HKDF: {e}")
-        logger.error(traceback.format_exc())
+        logger.error(f"Failed to derive key using HKDF: {e}", exc_info=True)
         raise
 
 
diff --git a/src/utils/password_prompt.py b/src/utils/password_prompt.py
index 452c49a..79ba195 100644
--- a/src/utils/password_prompt.py
+++ b/src/utils/password_prompt.py
@@ -89,8 +89,9 @@ def prompt_new_password() -> str:
             logging.info("Password prompt interrupted by user.")
             sys.exit(0)
         except Exception as e:
-            logging.error(f"Unexpected error during password prompt: {e}")
-            logging.error(traceback.format_exc())  # Log full traceback
+            logging.error(
+                f"Unexpected error during password prompt: {e}", exc_info=True
+            )
             print(colored(f"Error: {e}", "red"))
             attempts += 1
 
@@ -132,8 +133,9 @@ def prompt_existing_password(prompt_message: str = "Enter your password: ") -> s
         logging.info("Existing password prompt interrupted by user.")
         sys.exit(0)
     except Exception as e:
-        logging.error(f"Unexpected error during existing password prompt: {e}")
-        logging.error(traceback.format_exc())  # Log full traceback
+        logging.error(
+            f"Unexpected error during existing password prompt: {e}", exc_info=True
+        )
         print(colored(f"Error: {e}", "red"))
         sys.exit(1)
 
@@ -171,8 +173,9 @@ def confirm_action(
         logging.info("Action confirmation interrupted by user.")
         sys.exit(0)
     except Exception as e:
-        logging.error(f"Unexpected error during action confirmation: {e}")
-        logging.error(traceback.format_exc())  # Log full traceback
+        logging.error(
+            f"Unexpected error during action confirmation: {e}", exc_info=True
+        )
         print(colored(f"Error: {e}", "red"))
         sys.exit(1)