diff --git a/enterprise/enterprise_hooks/banned_keywords.py b/enterprise/enterprise_hooks/banned_keywords.py
index 3f3e01f5b..4d6545eb0 100644
--- a/enterprise/enterprise_hooks/banned_keywords.py
+++ b/enterprise/enterprise_hooks/banned_keywords.py
@@ -82,7 +82,11 @@ class _ENTERPRISE_BannedKeywords(CustomLogger):
         except HTTPException as e:
             raise e
         except Exception as e:
-            verbose_proxy_logger.error(traceback.format_exc())
+            verbose_proxy_logger.exception(
+                "litellm.enterprise.enterprise_hooks.banned_keywords::async_pre_call_hook - Exception occurred - {}".format(
+                    str(e)
+                )
+            )
 
     async def async_post_call_success_hook(
         self,
diff --git a/enterprise/enterprise_hooks/blocked_user_list.py b/enterprise/enterprise_hooks/blocked_user_list.py
index 8e642a026..9bda140ba 100644
--- a/enterprise/enterprise_hooks/blocked_user_list.py
+++ b/enterprise/enterprise_hooks/blocked_user_list.py
@@ -118,4 +118,8 @@ class _ENTERPRISE_BlockedUserList(CustomLogger):
         except HTTPException as e:
             raise e
         except Exception as e:
-            verbose_proxy_logger.error(traceback.format_exc())
+            verbose_proxy_logger.exception(
+                "litellm.enterprise.enterprise_hooks.blocked_user_list::async_pre_call_hook - Exception occurred - {}".format(
+                    str(e)
+                )
+            )
diff --git a/enterprise/enterprise_hooks/llm_guard.py b/enterprise/enterprise_hooks/llm_guard.py
index 9db10cf79..9724e08a8 100644
--- a/enterprise/enterprise_hooks/llm_guard.py
+++ b/enterprise/enterprise_hooks/llm_guard.py
@@ -92,7 +92,11 @@ class _ENTERPRISE_LLMGuard(CustomLogger):
                         },
                     )
         except Exception as e:
-            verbose_proxy_logger.error(traceback.format_exc())
+            verbose_proxy_logger.exception(
+                "litellm.enterprise.enterprise_hooks.llm_guard::moderation_check - Exception occurred - {}".format(
+                    str(e)
+                )
+            )
             raise e
 
     def should_proceed(self, user_api_key_dict: UserAPIKeyAuth, data: dict) -> bool:
diff --git a/litellm/caching.py b/litellm/caching.py
index c9b659d3f..e37811b77 100644
--- a/litellm/caching.py
+++ b/litellm/caching.py
@@ -1570,8 +1570,9 @@ class DualCache(BaseCache):
             if self.redis_cache is not None and local_only == False:
                 await self.redis_cache.async_set_cache(key, value, **kwargs)
         except Exception as e:
-            verbose_logger.error(f"LiteLLM Cache: Excepton async add_cache: {str(e)}")
-            verbose_logger.debug(traceback.format_exc())
+            verbose_logger.exception(
+                f"LiteLLM Cache: Excepton async add_cache: {str(e)}"
+            )
 
     async def async_batch_set_cache(
         self, cache_list: list, local_only: bool = False, **kwargs
@@ -1593,8 +1594,9 @@ class DualCache(BaseCache):
                     cache_list=cache_list, ttl=kwargs.get("ttl", None), **kwargs
                 )
         except Exception as e:
-            verbose_logger.error(f"LiteLLM Cache: Excepton async add_cache: {str(e)}")
-            verbose_logger.debug(traceback.format_exc())
+            verbose_logger.exception(
+                f"LiteLLM Cache: Excepton async add_cache: {str(e)}"
+            )
 
     async def async_increment_cache(
         self, key, value: float, local_only: bool = False, **kwargs
@@ -1618,8 +1620,9 @@ class DualCache(BaseCache):
 
             return result
         except Exception as e:
-            verbose_logger.error(f"LiteLLM Cache: Excepton async add_cache: {str(e)}")
-            verbose_logger.debug(traceback.format_exc())
+            verbose_logger.exception(
+                f"LiteLLM Cache: Excepton async add_cache: {str(e)}"
+            )
             raise e
 
     async def async_set_cache_sadd(
@@ -1647,10 +1650,8 @@ class DualCache(BaseCache):
 
             return None
         except Exception as e:
-            verbose_logger.error(
-                "LiteLLM Cache: Excepton async set_cache_sadd: {}\n{}".format(
-                    str(e), traceback.format_exc()
-                )
+            verbose_logger.exception(
+                "LiteLLM Cache: Excepton async set_cache_sadd: {}".format(str(e))
             )
             raise e
 
@@ -2088,8 +2089,7 @@ class Cache:
             )
             self.cache.set_cache(cache_key, cached_data, **kwargs)
         except Exception as e:
-            verbose_logger.error(f"LiteLLM Cache: Excepton add_cache: {str(e)}")
-            verbose_logger.debug(traceback.format_exc())
+            verbose_logger.exception(f"LiteLLM Cache: Excepton add_cache: {str(e)}")
             pass
 
     async def async_add_cache(self, result, *args, **kwargs):
@@ -2106,8 +2106,7 @@ class Cache:
                 )
                 await self.cache.async_set_cache(cache_key, cached_data, **kwargs)
         except Exception as e:
-            verbose_logger.error(f"LiteLLM Cache: Excepton add_cache: {str(e)}")
-            verbose_logger.debug(traceback.format_exc())
+            verbose_logger.exception(f"LiteLLM Cache: Excepton add_cache: {str(e)}")
 
     async def async_add_cache_pipeline(self, result, *args, **kwargs):
         """
@@ -2137,8 +2136,7 @@ class Cache:
                     )
                 await asyncio.gather(*tasks)
         except Exception as e:
-            verbose_logger.error(f"LiteLLM Cache: Excepton add_cache: {str(e)}")
-            verbose_logger.debug(traceback.format_exc())
+            verbose_logger.exception(f"LiteLLM Cache: Excepton add_cache: {str(e)}")
 
     async def batch_cache_write(self, result, *args, **kwargs):
         cache_key, cached_data, kwargs = self._add_cache_logic(
diff --git a/litellm/integrations/braintrust_logging.py b/litellm/integrations/braintrust_logging.py
index 08676e968..3e1c429de 100644
--- a/litellm/integrations/braintrust_logging.py
+++ b/litellm/integrations/braintrust_logging.py
@@ -235,10 +235,8 @@ class BraintrustLogger(CustomLogger):
             except httpx.HTTPStatusError as e:
                 raise Exception(e.response.text)
         except Exception as e:
-            verbose_logger.error(
-                "Error logging to braintrust - Exception received - {}\n{}".format(
-                    str(e), traceback.format_exc()
-                )
+            verbose_logger.exception(
+                "Error logging to braintrust - Exception received - {}".format(str(e))
             )
             raise e
 
@@ -362,10 +360,8 @@ class BraintrustLogger(CustomLogger):
             except httpx.HTTPStatusError as e:
                 raise Exception(e.response.text)
         except Exception as e:
-            verbose_logger.error(
-                "Error logging to braintrust - Exception received - {}\n{}".format(
-                    str(e), traceback.format_exc()
-                )
+            verbose_logger.exception(
+                "Error logging to braintrust - Exception received - {}".format(str(e))
             )
             raise e
 
diff --git a/litellm/integrations/email_alerting.py b/litellm/integrations/email_alerting.py
index 434efb63b..f0ad43535 100644
--- a/litellm/integrations/email_alerting.py
+++ b/litellm/integrations/email_alerting.py
@@ -2,11 +2,12 @@
 Functions for sending Email Alerts
 """
 
-import os
-from typing import Optional, List
-from litellm.proxy._types import WebhookEvent
 import asyncio
+import os
+from typing import List, Optional
+
 from litellm._logging import verbose_logger, verbose_proxy_logger
+from litellm.proxy._types import WebhookEvent
 
 # we use this for the email header, please send a test email if you change this. verify it looks good on email
 LITELLM_LOGO_URL = "https://litellm-listing.s3.amazonaws.com/litellm_logo.png"
@@ -69,9 +70,8 @@ async def send_team_budget_alert(webhook_event: WebhookEvent) -> bool:
     Send an Email Alert to All Team Members when the Team Budget is crossed
     Returns -> True if sent, False if not.
     """
-    from litellm.proxy.utils import send_email
-
     from litellm.proxy.proxy_server import premium_user, prisma_client
+    from litellm.proxy.utils import send_email
 
     _team_id = webhook_event.team_id
     team_alias = webhook_event.team_alias
@@ -101,7 +101,7 @@ async def send_team_budget_alert(webhook_event: WebhookEvent) -> bool:
     email_html_content = "Alert from LiteLLM Server"
 
     if recipient_emails_str is None:
-        verbose_proxy_logger.error(
+        verbose_proxy_logger.warning(
             "Email Alerting: Trying to send email alert to no recipient, got recipient_emails=%s",
             recipient_emails_str,
         )
diff --git a/litellm/integrations/langfuse.py b/litellm/integrations/langfuse.py
index d6c235d0c..0fb2ea1f7 100644
--- a/litellm/integrations/langfuse.py
+++ b/litellm/integrations/langfuse.py
@@ -246,10 +246,9 @@ class LangFuseLogger:
 
             return {"trace_id": trace_id, "generation_id": generation_id}
         except Exception as e:
-            verbose_logger.error(
+            verbose_logger.exception(
                 "Langfuse Layer Error(): Exception occured - {}".format(str(e))
             )
-            verbose_logger.debug(traceback.format_exc())
             return {"trace_id": None, "generation_id": None}
 
     async def _async_log_event(
diff --git a/litellm/integrations/prometheus.py b/litellm/integrations/prometheus.py
index 08431fd7a..7fde5abff 100644
--- a/litellm/integrations/prometheus.py
+++ b/litellm/integrations/prometheus.py
@@ -329,10 +329,9 @@ class PrometheusLogger(CustomLogger):
             ).inc()
             self.set_llm_deployment_failure_metrics(kwargs)
         except Exception as e:
-            verbose_logger.error(
+            verbose_logger.exception(
                 "prometheus Layer Error(): Exception occured - {}".format(str(e))
             )
-            verbose_logger.debug(traceback.format_exc())
             pass
         pass
 
diff --git a/litellm/litellm_core_utils/litellm_logging.py b/litellm/litellm_core_utils/litellm_logging.py
index f96d2f234..c389a1737 100644
--- a/litellm/litellm_core_utils/litellm_logging.py
+++ b/litellm/litellm_core_utils/litellm_logging.py
@@ -346,9 +346,9 @@ class Logging:
                         self.model_call_details
                     )  # Expectation: any logger function passed in by the user should accept a dict object
                 except Exception as e:
-                    verbose_logger.error(
-                        "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {}\n{}".format(
-                            str(e), traceback.format_exc()
+                    verbose_logger.exception(
+                        "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {}".format(
+                            str(e)
                         )
                     )
             # Input Integration Logging -> If you want to log the fact that an attempt to call the model was made
@@ -398,9 +398,9 @@ class Logging:
                             callback_func=callback,
                         )
                 except Exception as e:
-                    verbose_logger.error(
-                        "litellm.Logging.pre_call(): Exception occured - {}\n{}".format(
-                            str(e), traceback.format_exc()
+                    verbose_logger.exception(
+                        "litellm.Logging.pre_call(): Exception occured - {}".format(
+                            str(e)
                         )
                     )
                     verbose_logger.debug(
@@ -408,10 +408,10 @@ class Logging:
                     )
                     if capture_exception:  # log this error to sentry for debugging
                         capture_exception(e)
-        except Exception:
-            verbose_logger.error(
-                "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {}\n{}".format(
-                    str(e), traceback.format_exc()
+        except Exception as e:
+            verbose_logger.exception(
+                "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {}".format(
+                    str(e)
                 )
             )
             verbose_logger.error(
@@ -456,9 +456,9 @@ class Logging:
                         self.model_call_details
                     )  # Expectation: any logger function passed in by the user should accept a dict object
                 except Exception as e:
-                    verbose_logger.debug(
-                        "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {}\n{}".format(
-                            str(e), traceback.format_exc()
+                    verbose_logger.exception(
+                        "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {}".format(
+                            str(e)
                         )
                     )
             original_response = redact_message_input_output_from_logging(
@@ -494,9 +494,9 @@ class Logging:
                             end_time=None,
                         )
                 except Exception as e:
-                    verbose_logger.error(
-                        "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while post-call logging with integrations {}\n{}".format(
-                            str(e), traceback.format_exc()
+                    verbose_logger.exception(
+                        "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while post-call logging with integrations {}".format(
+                            str(e)
                         )
                     )
                     verbose_logger.debug(
@@ -505,9 +505,9 @@ class Logging:
                     if capture_exception:  # log this error to sentry for debugging
                         capture_exception(e)
         except Exception as e:
-            verbose_logger.error(
-                "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {}\n{}".format(
-                    str(e), traceback.format_exc()
+            verbose_logger.exception(
+                "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while logging {}".format(
+                    str(e)
                 )
             )
 
@@ -669,9 +669,9 @@ class Logging:
                             end_time=end_time,
                         )
                     except Exception as e:
-                        verbose_logger.error(
-                            "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while building complete streaming response in success logging {}\n{}".format(
-                                str(e), traceback.format_exc()
+                        verbose_logger.exception(
+                            "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while building complete streaming response in success logging {}".format(
+                                str(e)
                             )
                         )
                         complete_streaming_response = None
@@ -1248,9 +1248,9 @@ class Logging:
                     if capture_exception:  # log this error to sentry for debugging
                         capture_exception(e)
         except Exception as e:
-            verbose_logger.error(
-                "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while success logging {}\n{}".format(
-                    str(e), traceback.format_exc()
+            verbose_logger.exception(
+                "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while success logging {}".format(
+                    str(e)
                 ),
             )
 
@@ -1282,11 +1282,10 @@ class Logging:
                         end_time=end_time,
                     )
                 except Exception as e:
-                    print_verbose(
-                        "Error occurred building stream chunk in success logging: {}\n{}".format(
-                            str(e), traceback.format_exc()
-                        ),
-                        log_level="ERROR",
+                    verbose_logger.exception(
+                        "Error occurred building stream chunk in success logging: {}".format(
+                            str(e)
+                        )
                     )
                     complete_streaming_response = None
             else:
@@ -1779,9 +1778,9 @@ class Logging:
                     if capture_exception:  # log this error to sentry for debugging
                         capture_exception(e)
         except Exception as e:
-            verbose_logger.error(
-                "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while failure logging {}\n{}".format(
-                    str(e), traceback.format_exc()
+            verbose_logger.exception(
+                "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while failure logging {}".format(
+                    str(e)
                 )
             )
 
@@ -1817,10 +1816,10 @@ class Logging:
                         callback_func=callback,
                     )
             except Exception as e:
-                verbose_logger.error(
+                verbose_logger.exception(
                     "LiteLLM.LoggingError: [Non-Blocking] Exception occurred while success \
-                        logging {}\n{}\nCallback={}".format(
-                        str(e), traceback.format_exc(), callback
+                        logging {}\nCallback={}".format(
+                        str(e), callback
                     )
                 )
 
@@ -2328,9 +2327,7 @@ def get_standard_logging_object_payload(
 
         return payload
     except Exception as e:
-        verbose_logger.warning(
-            "Error creating standard logging object - {}\n{}".format(
-                str(e), traceback.format_exc()
-            )
+        verbose_logger.error(
+            "Error creating standard logging object - {}".format(str(e))
         )
         return None
diff --git a/litellm/litellm_core_utils/llm_cost_calc/google.py b/litellm/litellm_core_utils/llm_cost_calc/google.py
index 0b4789dea..a9a04ad00 100644
--- a/litellm/litellm_core_utils/llm_cost_calc/google.py
+++ b/litellm/litellm_core_utils/llm_cost_calc/google.py
@@ -118,10 +118,9 @@ def cost_per_character(
             )
             prompt_cost = prompt_characters * model_info["input_cost_per_character"]
     except Exception as e:
-        verbose_logger.error(
-            "litellm.litellm_core_utils.llm_cost_calc.google.cost_per_character(): Exception occured - {}\n{}\n\
-                Defaulting to (cost_per_token * 4) calculation for prompt_cost".format(
-                str(e), traceback.format_exc()
+        verbose_logger.exception(
+            "litellm.litellm_core_utils.llm_cost_calc.google.cost_per_character(): Defaulting to (cost_per_token * 4) calculation for prompt_cost. Exception occured - {}".format(
+                str(e)
             )
         )
         initial_prompt_cost, _ = cost_per_token(
@@ -161,10 +160,10 @@ def cost_per_character(
                 completion_tokens * model_info["output_cost_per_character"]
             )
     except Exception as e:
-        verbose_logger.error(
-            "litellm.litellm_core_utils.llm_cost_calc.google.cost_per_character(): Exception occured - {}\n{}\n\
-                Defaulting to (cost_per_token * 4) calculation for completion_cost".format(
-                str(e), traceback.format_exc()
+        verbose_logger.exception(
+            "litellm.litellm_core_utils.llm_cost_calc.google.cost_per_character(): \
+                Defaulting to (cost_per_token * 4) calculation for completion_cost\nException occured - {}".format(
+                str(e)
             )
         )
         _, initial_completion_cost = cost_per_token(
diff --git a/litellm/litellm_core_utils/llm_cost_calc/utils.py b/litellm/litellm_core_utils/llm_cost_calc/utils.py
index e986a22a6..87799bc1f 100644
--- a/litellm/litellm_core_utils/llm_cost_calc/utils.py
+++ b/litellm/litellm_core_utils/llm_cost_calc/utils.py
@@ -54,9 +54,9 @@ def _generic_cost_per_character(
 
         prompt_cost = prompt_characters * custom_prompt_cost
     except Exception as e:
-        verbose_logger.error(
-            "litellm.litellm_core_utils.llm_cost_calc.utils.py::cost_per_character(): Exception occured - {}\n{}\nDefaulting to None".format(
-                str(e), traceback.format_exc()
+        verbose_logger.exception(
+            "litellm.litellm_core_utils.llm_cost_calc.utils.py::cost_per_character(): Exception occured - {}\nDefaulting to None".format(
+                str(e)
             )
         )
 
@@ -74,9 +74,9 @@ def _generic_cost_per_character(
             custom_completion_cost = model_info["output_cost_per_character"]
         completion_cost = completion_characters * custom_completion_cost
     except Exception as e:
-        verbose_logger.error(
-            "litellm.litellm_core_utils.llm_cost_calc.utils.py::cost_per_character(): Exception occured - {}\n{}\nDefaulting to None".format(
-                str(e), traceback.format_exc()
+        verbose_logger.exception(
+            "litellm.litellm_core_utils.llm_cost_calc.utils.py::cost_per_character(): Exception occured - {}\nDefaulting to None".format(
+                str(e)
             )
         )
 
diff --git a/litellm/llms/anthropic.py b/litellm/llms/anthropic.py
index cf5816346..d533fdbb2 100644
--- a/litellm/llms/anthropic.py
+++ b/litellm/llms/anthropic.py
@@ -952,11 +952,14 @@ class AnthropicChatCompletion(BaseLLM):
                     model=model, messages=messages, custom_llm_provider="anthropic"
                 )
             except Exception as e:
+                verbose_logger.exception(
+                    "litellm.llms.anthropic.py::completion() - Exception occurred - {}\nReceived Messages: {}".format(
+                        str(e), messages
+                    )
+                )
                 raise AnthropicError(
                     status_code=400,
-                    message="{}\n{}\nReceived Messages={}".format(
-                        str(e), traceback.format_exc(), messages
-                    ),
+                    message="{}\nReceived Messages={}".format(str(e), messages),
                 )
 
         ## Load Config
diff --git a/litellm/llms/gemini.py b/litellm/llms/gemini.py
index 3ce63e93f..179554ea4 100644
--- a/litellm/llms/gemini.py
+++ b/litellm/llms/gemini.py
@@ -274,7 +274,6 @@ class GeminiConfig:
 #         model_response.choices = choices_list
 #     except Exception as e:
 #         verbose_logger.error("LiteLLM.gemini.py: Exception occured - {}".format(str(e)))
-#         verbose_logger.debug(traceback.format_exc())
 #         raise GeminiError(
 #             message=traceback.format_exc(), status_code=response.status_code
 #         )
@@ -367,7 +366,6 @@ class GeminiConfig:
 #         model_response["choices"] = choices_list
 #     except Exception as e:
 #         verbose_logger.error("LiteLLM.gemini.py: Exception occured - {}".format(str(e)))
-#         verbose_logger.debug(traceback.format_exc())
 #         raise GeminiError(
 #             message=traceback.format_exc(), status_code=response.status_code
 #         )
diff --git a/litellm/llms/ollama.py b/litellm/llms/ollama.py
index f699cf0f5..ad8d40858 100644
--- a/litellm/llms/ollama.py
+++ b/litellm/llms/ollama.py
@@ -422,12 +422,11 @@ async def ollama_async_streaming(url, data, model_response, encoding, logging_ob
                 async for transformed_chunk in streamwrapper:
                     yield transformed_chunk
     except Exception as e:
-        verbose_logger.error(
+        verbose_logger.exception(
             "LiteLLM.ollama.py::ollama_async_streaming(): Exception occured - {}".format(
                 str(e)
             )
         )
-        verbose_logger.debug(traceback.format_exc())
 
         raise e
 
@@ -498,12 +497,11 @@ async def ollama_acompletion(
             )
             return model_response
     except Exception as e:
-        verbose_logger.error(
+        verbose_logger.exception(
             "LiteLLM.ollama.py::ollama_acompletion(): Exception occured - {}".format(
                 str(e)
             )
         )
-        verbose_logger.debug(traceback.format_exc())
         raise e
 
 
@@ -609,5 +607,4 @@ def ollama_embeddings(
             logging_obj=logging_obj,
             encoding=encoding,
         )
-
     )
diff --git a/litellm/llms/ollama_chat.py b/litellm/llms/ollama_chat.py
index ea84fa95c..2c55a3c0a 100644
--- a/litellm/llms/ollama_chat.py
+++ b/litellm/llms/ollama_chat.py
@@ -356,7 +356,7 @@ def ollama_completion_stream(url, api_key, data, logging_obj):
         "json": data,
         "method": "POST",
         "timeout": litellm.request_timeout,
-        "follow_redirects": True
+        "follow_redirects": True,
     }
     if api_key is not None:
         _request["headers"] = {"Authorization": "Bearer {}".format(api_key)}
@@ -471,8 +471,9 @@ async def ollama_async_streaming(
                 async for transformed_chunk in streamwrapper:
                     yield transformed_chunk
     except Exception as e:
-        verbose_logger.error("LiteLLM.gemini(): Exception occured - {}".format(str(e)))
-        verbose_logger.debug(traceback.format_exc())
+        verbose_logger.exception(
+            "LiteLLM.ollama(): Exception occured - {}".format(str(e))
+        )
 
 
 async def ollama_acompletion(
@@ -559,9 +560,8 @@ async def ollama_acompletion(
             )
             return model_response
     except Exception as e:
-        verbose_logger.error(
+        verbose_logger.exception(
             "LiteLLM.ollama_acompletion(): Exception occured - {}".format(str(e))
         )
-        verbose_logger.debug(traceback.format_exc())
 
         raise e
diff --git a/litellm/llms/palm.py b/litellm/llms/palm.py
index b750b800b..a17fd02be 100644
--- a/litellm/llms/palm.py
+++ b/litellm/llms/palm.py
@@ -168,10 +168,9 @@ def completion(
             choices_list.append(choice_obj)
         model_response.choices = choices_list  # type: ignore
     except Exception as e:
-        verbose_logger.error(
+        verbose_logger.exception(
             "litellm.llms.palm.py::completion(): Exception occured - {}".format(str(e))
         )
-        verbose_logger.debug(traceback.format_exc())
         raise PalmError(
             message=traceback.format_exc(), status_code=response.status_code
         )
diff --git a/litellm/llms/predibase.py b/litellm/llms/predibase.py
index d7a10c2f5..84e2810a5 100644
--- a/litellm/llms/predibase.py
+++ b/litellm/llms/predibase.py
@@ -17,6 +17,7 @@ import requests  # type: ignore
 import litellm
 import litellm.litellm_core_utils
 import litellm.litellm_core_utils.litellm_logging
+from litellm import verbose_logger
 from litellm.litellm_core_utils.core_helpers import map_finish_reason
 from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
 from litellm.utils import Choices, CustomStreamWrapper, Message, ModelResponse, Usage
@@ -563,9 +564,12 @@ class PredibaseChatCompletion(BaseLLM):
             for exception in litellm.LITELLM_EXCEPTION_TYPES:
                 if isinstance(e, exception):
                     raise e
-            raise PredibaseError(
-                status_code=500, message="{}\n{}".format(str(e), traceback.format_exc())
+            verbose_logger.exception(
+                "litellm.llms.predibase.py::async_completion() - Exception occurred - {}".format(
+                    str(e)
+                )
             )
+            raise PredibaseError(status_code=500, message="{}".format(str(e)))
         return self.process_response(
             model=model,
             response=response,
diff --git a/litellm/llms/text_completion_codestral.py b/litellm/llms/text_completion_codestral.py
index 7c758f5b5..a6865b953 100644
--- a/litellm/llms/text_completion_codestral.py
+++ b/litellm/llms/text_completion_codestral.py
@@ -15,6 +15,7 @@ import httpx  # type: ignore
 import requests  # type: ignore
 
 import litellm
+from litellm import verbose_logger
 from litellm.litellm_core_utils.core_helpers import map_finish_reason
 from litellm.llms.custom_httpx.http_handler import AsyncHTTPHandler
 from litellm.types.llms.databricks import GenericStreamingChunk
@@ -489,8 +490,13 @@ class CodestralTextCompletion(BaseLLM):
                 message="HTTPStatusError - {}".format(e.response.text),
             )
         except Exception as e:
+            verbose_logger.exception(
+                "litellm.llms.text_completion_codestral.py::async_completion() - Exception occurred - {}".format(
+                    str(e)
+                )
+            )
             raise TextCompletionCodestralError(
-                status_code=500, message="{}\n{}".format(str(e), traceback.format_exc())
+                status_code=500, message="{}".format(str(e))
             )
         return self.process_text_completion_response(
             model=model,
diff --git a/litellm/main.py b/litellm/main.py
index cf7a4a5e7..587386ff5 100644
--- a/litellm/main.py
+++ b/litellm/main.py
@@ -420,7 +420,9 @@ async def acompletion(
             )  # sets the logging event loop if the user does sync streaming (e.g. on proxy for sagemaker calls)
         return response
     except Exception as e:
-        verbose_logger.debug(traceback.format_exc())
+        verbose_logger.exception(
+            "litellm.main.py::acompletion() - Exception occurred - {}".format(str(e))
+        )
         custom_llm_provider = custom_llm_provider or "openai"
         raise exception_type(
             model=model,
@@ -585,10 +587,9 @@ def mock_completion(
     except Exception as e:
         if isinstance(e, openai.APIError):
             raise e
-        verbose_logger.error(
+        verbose_logger.exception(
             "litellm.mock_completion(): Exception occured - {}".format(str(e))
         )
-        verbose_logger.debug(traceback.format_exc())
         raise Exception("Mock completion response failed")
 
 
@@ -5232,9 +5233,9 @@ def stream_chunk_builder(
             end_time=end_time,
         )  # type: ignore
     except Exception as e:
-        verbose_logger.error(
-            "litellm.main.py::stream_chunk_builder() - Exception occurred - {}\n{}".format(
-                str(e), traceback.format_exc()
+        verbose_logger.exception(
+            "litellm.main.py::stream_chunk_builder() - Exception occurred - {}".format(
+                str(e)
             )
         )
         raise litellm.APIError(
diff --git a/litellm/proxy/auth/user_api_key_auth.py b/litellm/proxy/auth/user_api_key_auth.py
index 00e78f64e..4c77e3ed4 100644
--- a/litellm/proxy/auth/user_api_key_auth.py
+++ b/litellm/proxy/auth/user_api_key_auth.py
@@ -1123,9 +1123,9 @@ async def user_api_key_auth(
         else:
             raise Exception()
     except Exception as e:
-        verbose_proxy_logger.error(
-            "litellm.proxy.proxy_server.user_api_key_auth(): Exception occured - {}\n{}".format(
-                str(e), traceback.format_exc()
+        verbose_proxy_logger.exception(
+            "litellm.proxy.proxy_server.user_api_key_auth(): Exception occured - {}".format(
+                str(e)
             )
         )
 
diff --git a/litellm/proxy/guardrails/init_guardrails.py b/litellm/proxy/guardrails/init_guardrails.py
index de6181868..4d234576f 100644
--- a/litellm/proxy/guardrails/init_guardrails.py
+++ b/litellm/proxy/guardrails/init_guardrails.py
@@ -62,9 +62,7 @@ def initialize_guardrails(
 
         return litellm.guardrail_name_config_map
     except Exception as e:
-        verbose_proxy_logger.error(
-            "error initializing guardrails {}\n{}".format(
-                str(e), traceback.format_exc()
-            )
+        verbose_proxy_logger.exception(
+            "error initializing guardrails {}".format(str(e))
         )
         raise e
diff --git a/litellm/proxy/hooks/cache_control_check.py b/litellm/proxy/hooks/cache_control_check.py
index 238e2e6ab..d933bfc75 100644
--- a/litellm/proxy/hooks/cache_control_check.py
+++ b/litellm/proxy/hooks/cache_control_check.py
@@ -1,13 +1,15 @@
 # What this does?
 ## Checks if key is allowed to use the cache controls passed in to the completion() call
 
+import traceback
+
+from fastapi import HTTPException
+
 import litellm
 from litellm import verbose_logger
 from litellm.caching import DualCache
-from litellm.proxy._types import UserAPIKeyAuth
 from litellm.integrations.custom_logger import CustomLogger
-from fastapi import HTTPException
-import traceback
+from litellm.proxy._types import UserAPIKeyAuth
 
 
 class _PROXY_CacheControlCheck(CustomLogger):
@@ -54,9 +56,8 @@ class _PROXY_CacheControlCheck(CustomLogger):
         except HTTPException as e:
             raise e
         except Exception as e:
-            verbose_logger.error(
+            verbose_logger.exception(
                 "litellm.proxy.hooks.cache_control_check.py::async_pre_call_hook(): Exception occured - {}".format(
                     str(e)
                 )
             )
-            verbose_logger.debug(traceback.format_exc())
diff --git a/litellm/proxy/hooks/dynamic_rate_limiter.py b/litellm/proxy/hooks/dynamic_rate_limiter.py
index f5621055b..4bf08998a 100644
--- a/litellm/proxy/hooks/dynamic_rate_limiter.py
+++ b/litellm/proxy/hooks/dynamic_rate_limiter.py
@@ -65,9 +65,9 @@ class DynamicRateLimiterCache:
                 key=key_name, value=value, ttl=self.ttl
             )
         except Exception as e:
-            verbose_proxy_logger.error(
-                "litellm.proxy.hooks.dynamic_rate_limiter.py::async_set_cache_sadd(): Exception occured - {}\n{}".format(
-                    str(e), traceback.format_exc()
+            verbose_proxy_logger.exception(
+                "litellm.proxy.hooks.dynamic_rate_limiter.py::async_set_cache_sadd(): Exception occured - {}".format(
+                    str(e)
                 )
             )
             raise e
@@ -179,9 +179,9 @@ class _PROXY_DynamicRateLimitHandler(CustomLogger):
                 active_projects,
             )
         except Exception as e:
-            verbose_proxy_logger.error(
-                "litellm.proxy.hooks.dynamic_rate_limiter.py::check_available_usage: Exception occurred - {}\n{}".format(
-                    str(e), traceback.format_exc()
+            verbose_proxy_logger.exception(
+                "litellm.proxy.hooks.dynamic_rate_limiter.py::check_available_usage: Exception occurred - {}".format(
+                    str(e)
                 )
             )
             return None, None, None, None, None
@@ -290,9 +290,9 @@ class _PROXY_DynamicRateLimitHandler(CustomLogger):
                 user_api_key_dict, response
             )
         except Exception as e:
-            verbose_proxy_logger.error(
-                "litellm.proxy.hooks.dynamic_rate_limiter.py::async_post_call_success_hook(): Exception occured - {}\n{}".format(
-                    str(e), traceback.format_exc()
+            verbose_proxy_logger.exception(
+                "litellm.proxy.hooks.dynamic_rate_limiter.py::async_post_call_success_hook(): Exception occured - {}".format(
+                    str(e)
                 )
             )
             return response
diff --git a/litellm/proxy/hooks/max_budget_limiter.py b/litellm/proxy/hooks/max_budget_limiter.py
index c4b328bab..88614d4a2 100644
--- a/litellm/proxy/hooks/max_budget_limiter.py
+++ b/litellm/proxy/hooks/max_budget_limiter.py
@@ -1,11 +1,13 @@
-from litellm import verbose_logger
-import litellm
-from litellm.caching import DualCache
-from litellm.proxy._types import UserAPIKeyAuth
-from litellm.integrations.custom_logger import CustomLogger
-from fastapi import HTTPException
 import traceback
 
+from fastapi import HTTPException
+
+import litellm
+from litellm import verbose_logger
+from litellm.caching import DualCache
+from litellm.integrations.custom_logger import CustomLogger
+from litellm.proxy._types import UserAPIKeyAuth
+
 
 class _PROXY_MaxBudgetLimiter(CustomLogger):
     # Class variables or attributes
@@ -44,9 +46,8 @@ class _PROXY_MaxBudgetLimiter(CustomLogger):
         except HTTPException as e:
             raise e
         except Exception as e:
-            verbose_logger.error(
+            verbose_logger.exception(
                 "litellm.proxy.hooks.max_budget_limiter.py::async_pre_call_hook(): Exception occured - {}".format(
                     str(e)
                 )
             )
-            verbose_logger.debug(traceback.format_exc())
diff --git a/litellm/proxy/hooks/parallel_request_limiter.py b/litellm/proxy/hooks/parallel_request_limiter.py
index 65c30f10e..239c36b45 100644
--- a/litellm/proxy/hooks/parallel_request_limiter.py
+++ b/litellm/proxy/hooks/parallel_request_limiter.py
@@ -536,8 +536,8 @@ class _PROXY_MaxParallelRequestsHandler(CustomLogger):
                     request_count_api_key, new_val, ttl=60
                 )  # save in cache for up to 1 min.
         except Exception as e:
-            verbose_proxy_logger.info(
-                "Inside Parallel Request Limiter: An exception occurred - {}\n{}".format(
-                    str(e), traceback.format_exc()
+            verbose_proxy_logger.exception(
+                "Inside Parallel Request Limiter: An exception occurred - {}".format(
+                    str(e)
                 )
             )
diff --git a/litellm/proxy/pass_through_endpoints/pass_through_endpoints.py b/litellm/proxy/pass_through_endpoints/pass_through_endpoints.py
index 61893a3dc..ead0b7eb7 100644
--- a/litellm/proxy/pass_through_endpoints/pass_through_endpoints.py
+++ b/litellm/proxy/pass_through_endpoints/pass_through_endpoints.py
@@ -233,12 +233,11 @@ async def chat_completion_pass_through_endpoint(
         await proxy_logging_obj.post_call_failure_hook(
             user_api_key_dict=user_api_key_dict, original_exception=e, request_data=data
         )
-        verbose_proxy_logger.error(
-            "litellm.proxy.proxy_server.completion(): Exception occured - {}\n{}".format(
-                str(e), traceback.format_exc()
+        verbose_proxy_logger.exception(
+            "litellm.proxy.proxy_server.completion(): Exception occured - {}".format(
+                str(e)
             )
         )
-        verbose_proxy_logger.debug(traceback.format_exc())
         error_msg = f"{str(e)}"
         raise ProxyException(
             message=getattr(e, "message", error_msg),
@@ -369,12 +368,11 @@ async def pass_through_request(
             headers=dict(response.headers),
         )
     except Exception as e:
-        verbose_proxy_logger.error(
-            "litellm.proxy.proxy_server.pass_through_endpoint(): Exception occured - {}\n{}".format(
-                str(e), traceback.format_exc()
+        verbose_proxy_logger.exception(
+            "litellm.proxy.proxy_server.pass_through_endpoint(): Exception occured - {}".format(
+                str(e)
             )
         )
-        verbose_proxy_logger.debug(traceback.format_exc())
         if isinstance(e, HTTPException):
             raise ProxyException(
                 message=getattr(e, "message", str(e.detail)),
diff --git a/litellm/proxy/proxy_server.py b/litellm/proxy/proxy_server.py
index 10c06b2ec..f09ae7d35 100644
--- a/litellm/proxy/proxy_server.py
+++ b/litellm/proxy/proxy_server.py
@@ -199,7 +199,6 @@ from litellm.proxy.pass_through_endpoints.pass_through_endpoints import (
     router as pass_through_router,
 )
 from litellm.proxy.route_llm_request import route_request
-
 from litellm.proxy.secret_managers.aws_secret_manager import (
     load_aws_kms,
     load_aws_secret_manager,
@@ -913,8 +912,8 @@ async def update_database(
                         + prisma_client.key_list_transactons.get(hashed_token, 0)
                     )
             except Exception as e:
-                verbose_proxy_logger.error(
-                    f"Update Key DB Call failed to execute - {str(e)}\n{traceback.format_exc()}"
+                verbose_proxy_logger.exception(
+                    f"Update Key DB Call failed to execute - {str(e)}"
                 )
                 raise e
 
@@ -1206,8 +1205,8 @@ async def update_cache(
                 existing_spend_obj.spend = new_spend
                 user_api_key_cache.set_cache(key=_id, value=existing_spend_obj.json())
         except Exception as e:
-            verbose_proxy_logger.error(
-                f"An error occurred updating end user cache: {str(e)}\n\n{traceback.format_exc()}"
+            verbose_proxy_logger.exception(
+                f"An error occurred updating end user cache: {str(e)}"
             )
 
     ### UPDATE TEAM SPEND ###
@@ -1248,8 +1247,8 @@ async def update_cache(
                 existing_spend_obj.spend = new_spend
                 user_api_key_cache.set_cache(key=_id, value=existing_spend_obj)
         except Exception as e:
-            verbose_proxy_logger.error(
-                f"An error occurred updating end user cache: {str(e)}\n\n{traceback.format_exc()}"
+            verbose_proxy_logger.exception(
+                f"An error occurred updating end user cache: {str(e)}"
             )
 
     if token is not None and response_cost is not None:
@@ -2116,7 +2115,7 @@ class ProxyConfig:
                 self._add_deployment(db_models=new_models)
 
         except Exception as e:
-            verbose_proxy_logger.error(
+            verbose_proxy_logger.exception(
                 f"Error adding/deleting model to llm_router: {str(e)}"
             )
 
@@ -2264,7 +2263,7 @@ class ProxyConfig:
             try:
                 new_models = await prisma_client.db.litellm_proxymodeltable.find_many()
             except Exception as e:
-                verbose_proxy_logger.error(
+                verbose_proxy_logger.exception(
                     "litellm.proxy_server.py::add_deployment() - Error getting new models from DB - {}".format(
                         str(e)
                     )
@@ -2286,8 +2285,10 @@ class ProxyConfig:
                 )
 
         except Exception as e:
-            verbose_proxy_logger.error(
-                "{}\nTraceback:{}".format(str(e), traceback.format_exc())
+            verbose_proxy_logger.exception(
+                "litellm.proxy.proxy_server.py::ProxyConfig:add_deployment - {}".format(
+                    str(e)
+                )
             )
 
 
@@ -2454,12 +2455,11 @@ async def async_assistants_data_generator(
         done_message = "[DONE]"
         yield f"data: {done_message}\n\n"
     except Exception as e:
-        verbose_proxy_logger.error(
+        verbose_proxy_logger.exception(
             "litellm.proxy.proxy_server.async_assistants_data_generator(): Exception occured - {}".format(
                 str(e)
             )
         )
-        verbose_proxy_logger.debug(traceback.format_exc())
         await proxy_logging_obj.post_call_failure_hook(
             user_api_key_dict=user_api_key_dict,
             original_exception=e,
@@ -2512,9 +2512,9 @@ async def async_data_generator(
         done_message = "[DONE]"
         yield f"data: {done_message}\n\n"
     except Exception as e:
-        verbose_proxy_logger.error(
-            "litellm.proxy.proxy_server.async_data_generator(): Exception occured - {}\n{}".format(
-                str(e), traceback.format_exc()
+        verbose_proxy_logger.exception(
+            "litellm.proxy.proxy_server.async_data_generator(): Exception occured - {}".format(
+                str(e)
             )
         )
         await proxy_logging_obj.post_call_failure_hook(
@@ -2565,9 +2565,9 @@ async def async_data_generator_anthropic(
             except Exception as e:
                 yield f"event: {event_type}\ndata:{str(e)}\n\n"
     except Exception as e:
-        verbose_proxy_logger.error(
-            "litellm.proxy.proxy_server.async_data_generator(): Exception occured - {}\n{}".format(
-                str(e), traceback.format_exc()
+        verbose_proxy_logger.exception(
+            "litellm.proxy.proxy_server.async_data_generator(): Exception occured - {}".format(
+                str(e)
             )
         )
         await proxy_logging_obj.post_call_failure_hook(
@@ -3181,10 +3181,8 @@ async def chat_completion(
         _chat_response.usage = _usage  # type: ignore
         return _chat_response
     except Exception as e:
-        verbose_proxy_logger.error(
-            "litellm.proxy.proxy_server.chat_completion(): Exception occured - {}\n{}".format(
-                get_error_message_str(e=e), traceback.format_exc()
-            )
+        verbose_proxy_logger.exception(
+            f"litellm.proxy.proxy_server.chat_completion(): Exception occured - {str(e)}"
         )
         await proxy_logging_obj.post_call_failure_hook(
             user_api_key_dict=user_api_key_dict, original_exception=e, request_data=data
@@ -3567,12 +3565,11 @@ async def embeddings(
             e,
             litellm_debug_info,
         )
-        verbose_proxy_logger.error(
-            "litellm.proxy.proxy_server.embeddings(): Exception occured - {}\n{}".format(
-                str(e), traceback.format_exc()
+        verbose_proxy_logger.exception(
+            "litellm.proxy.proxy_server.embeddings(): Exception occured - {}".format(
+                str(e)
             )
         )
-        verbose_proxy_logger.debug(traceback.format_exc())
         if isinstance(e, HTTPException):
             message = get_error_message_str(e)
             raise ProxyException(
@@ -5381,9 +5378,9 @@ async def anthropic_response(
         await proxy_logging_obj.post_call_failure_hook(
             user_api_key_dict=user_api_key_dict, original_exception=e, request_data=data
         )
-        verbose_proxy_logger.error(
-            "litellm.proxy.proxy_server.anthropic_response(): Exception occured - {}\n{}".format(
-                str(e), traceback.format_exc()
+        verbose_proxy_logger.exception(
+            "litellm.proxy.proxy_server.anthropic_response(): Exception occured - {}".format(
+                str(e)
             )
         )
         error_msg = f"{str(e)}"
@@ -9540,12 +9537,11 @@ async def get_config():
             "available_callbacks": all_available_callbacks,
         }
     except Exception as e:
-        verbose_proxy_logger.error(
-            "litellm.proxy.proxy_server.get_config(): Exception occured - {}\n{}".format(
-                str(e), traceback.format_exc()
+        verbose_proxy_logger.exception(
+            "litellm.proxy.proxy_server.get_config(): Exception occured - {}".format(
+                str(e)
             )
         )
-        verbose_proxy_logger.debug(traceback.format_exc())
         if isinstance(e, HTTPException):
             raise ProxyException(
                 message=getattr(e, "detail", f"Authentication Error({str(e)})"),
diff --git a/litellm/proxy/spend_tracking/spend_tracking_utils.py b/litellm/proxy/spend_tracking/spend_tracking_utils.py
index 6a28d70b1..df4a2edfc 100644
--- a/litellm/proxy/spend_tracking/spend_tracking_utils.py
+++ b/litellm/proxy/spend_tracking/spend_tracking_utils.py
@@ -121,9 +121,7 @@ def get_logging_payload(
 
         return payload
     except Exception as e:
-        verbose_proxy_logger.error(
-            "Error creating spendlogs object - {}\n{}".format(
-                str(e), traceback.format_exc()
-            )
+        verbose_proxy_logger.exception(
+            "Error creating spendlogs object - {}".format(str(e))
         )
         raise e
diff --git a/litellm/router.py b/litellm/router.py
index 3f2be7cb2..7bc8acae4 100644
--- a/litellm/router.py
+++ b/litellm/router.py
@@ -3027,9 +3027,9 @@ class Router:
                 )
 
         except Exception as e:
-            verbose_router_logger.error(
-                "litellm.proxy.hooks.prompt_injection_detection.py::async_pre_call_hook(): Exception occured - {}\n{}".format(
-                    str(e), traceback.format_exc()
+            verbose_router_logger.exception(
+                "litellm.proxy.hooks.prompt_injection_detection.py::async_pre_call_hook(): Exception occured - {}".format(
+                    str(e)
                 )
             )
             pass
diff --git a/litellm/router_strategy/lowest_cost.py b/litellm/router_strategy/lowest_cost.py
index 46cbb2181..6c016aa03 100644
--- a/litellm/router_strategy/lowest_cost.py
+++ b/litellm/router_strategy/lowest_cost.py
@@ -1,16 +1,16 @@
 #### What this does ####
 #   picks based on response time (for streaming, this is time to first token)
-from pydantic import BaseModel
-from typing import Optional, Union, List, Dict
-from datetime import datetime, timedelta
-from litellm import verbose_logger
 import traceback
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Union
+
+from pydantic import BaseModel
+
+import litellm
+from litellm import ModelResponse, token_counter, verbose_logger
+from litellm._logging import verbose_router_logger
 from litellm.caching import DualCache
 from litellm.integrations.custom_logger import CustomLogger
-from litellm._logging import verbose_router_logger
-from litellm import ModelResponse
-from litellm import token_counter
-import litellm
 
 
 class LiteLLMBase(BaseModel):
@@ -117,12 +117,11 @@ class LowestCostLoggingHandler(CustomLogger):
                 if self.test_flag:
                     self.logged_success += 1
         except Exception as e:
-            verbose_logger.error(
+            verbose_logger.exception(
                 "litellm.proxy.hooks.prompt_injection_detection.py::async_pre_call_hook(): Exception occured - {}".format(
                     str(e)
                 )
             )
-            verbose_logger.debug(traceback.format_exc())
             pass
 
     async def async_log_success_event(self, kwargs, response_obj, start_time, end_time):
@@ -204,12 +203,11 @@ class LowestCostLoggingHandler(CustomLogger):
                 if self.test_flag:
                     self.logged_success += 1
         except Exception as e:
-            verbose_logger.error(
+            verbose_logger.exception(
                 "litellm.proxy.hooks.prompt_injection_detection.py::async_pre_call_hook(): Exception occured - {}".format(
                     str(e)
                 )
             )
-            verbose_logger.debug(traceback.format_exc())
             pass
 
     async def async_get_available_deployments(
diff --git a/litellm/router_strategy/lowest_latency.py b/litellm/router_strategy/lowest_latency.py
index 5d7184751..5807fa68d 100644
--- a/litellm/router_strategy/lowest_latency.py
+++ b/litellm/router_strategy/lowest_latency.py
@@ -1,16 +1,16 @@
 #### What this does ####
 #   picks based on response time (for streaming, this is time to first token)
-from pydantic import BaseModel
 import random
-from typing import Optional, Union, List, Dict
-from datetime import datetime, timedelta
 import traceback
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional, Union
+
+from pydantic import BaseModel
+
+import litellm
+from litellm import ModelResponse, token_counter, verbose_logger
 from litellm.caching import DualCache
 from litellm.integrations.custom_logger import CustomLogger
-from litellm import ModelResponse
-from litellm import token_counter
-import litellm
-from litellm import verbose_logger
 
 
 class LiteLLMBase(BaseModel):
@@ -165,12 +165,11 @@ class LowestLatencyLoggingHandler(CustomLogger):
                 if self.test_flag:
                     self.logged_success += 1
         except Exception as e:
-            verbose_logger.error(
+            verbose_logger.exception(
                 "litellm.proxy.hooks.prompt_injection_detection.py::async_pre_call_hook(): Exception occured - {}".format(
                     str(e)
                 )
             )
-            verbose_logger.debug(traceback.format_exc())
             pass
 
     async def async_log_failure_event(self, kwargs, response_obj, start_time, end_time):
@@ -234,12 +233,11 @@ class LowestLatencyLoggingHandler(CustomLogger):
                 # do nothing if it's not a timeout error
                 return
         except Exception as e:
-            verbose_logger.error(
+            verbose_logger.exception(
                 "litellm.proxy.hooks.prompt_injection_detection.py::async_pre_call_hook(): Exception occured - {}".format(
                     str(e)
                 )
             )
-            verbose_logger.debug(traceback.format_exc())
             pass
 
     async def async_log_success_event(self, kwargs, response_obj, start_time, end_time):
@@ -362,12 +360,11 @@ class LowestLatencyLoggingHandler(CustomLogger):
                 if self.test_flag:
                     self.logged_success += 1
         except Exception as e:
-            verbose_logger.error(
+            verbose_logger.exception(
                 "litellm.router_strategy.lowest_latency.py::async_log_success_event(): Exception occured - {}".format(
                     str(e)
                 )
             )
-            verbose_logger.debug(traceback.format_exc())
             pass
 
     def get_available_deployments(
diff --git a/litellm/router_strategy/lowest_tpm_rpm_v2.py b/litellm/router_strategy/lowest_tpm_rpm_v2.py
index e3b8c8b77..cefebf5e7 100644
--- a/litellm/router_strategy/lowest_tpm_rpm_v2.py
+++ b/litellm/router_strategy/lowest_tpm_rpm_v2.py
@@ -1,17 +1,19 @@
 #### What this does ####
 #   identifies lowest tpm deployment
-from pydantic import BaseModel
 import random
-from typing import Optional, Union, List, Dict
 import traceback
+from typing import Dict, List, Optional, Union
+
 import httpx
+from pydantic import BaseModel
+
 import litellm
 from litellm import token_counter
+from litellm._logging import verbose_logger, verbose_router_logger
 from litellm.caching import DualCache
 from litellm.integrations.custom_logger import CustomLogger
-from litellm._logging import verbose_router_logger, verbose_logger
-from litellm.utils import print_verbose, get_utc_datetime
 from litellm.types.router import RouterErrors
+from litellm.utils import get_utc_datetime, print_verbose
 
 
 class LiteLLMBase(BaseModel):
@@ -257,12 +259,11 @@ class LowestTPMLoggingHandler_v2(CustomLogger):
                 if self.test_flag:
                     self.logged_success += 1
         except Exception as e:
-            verbose_logger.error(
+            verbose_logger.exception(
                 "litellm.proxy.hooks.prompt_injection_detection.py::async_pre_call_hook(): Exception occured - {}".format(
                     str(e)
                 )
             )
-            verbose_logger.debug(traceback.format_exc())
             pass
 
     async def async_log_success_event(self, kwargs, response_obj, start_time, end_time):
@@ -308,12 +309,11 @@ class LowestTPMLoggingHandler_v2(CustomLogger):
                 if self.test_flag:
                     self.logged_success += 1
         except Exception as e:
-            verbose_logger.error(
+            verbose_logger.exception(
                 "litellm.proxy.hooks.prompt_injection_detection.py::async_pre_call_hook(): Exception occured - {}".format(
                     str(e)
                 )
             )
-            verbose_logger.debug(traceback.format_exc())
             pass
 
     def _common_checks_available_deployment(
diff --git a/litellm/tests/test_amazing_vertex_completion.py b/litellm/tests/test_amazing_vertex_completion.py
index a7327bde4..d41354a61 100644
--- a/litellm/tests/test_amazing_vertex_completion.py
+++ b/litellm/tests/test_amazing_vertex_completion.py
@@ -1589,7 +1589,8 @@ async def test_gemini_pro_httpx_custom_api_base(provider):
                 extra_headers={"hello": "world"},
             )
         except Exception as e:
-            print("Receives error - {}\n{}".format(str(e), traceback.format_exc()))
+            traceback.print_exc()
+            print("Receives error - {}".format(str(e)))
 
         mock_call.assert_called_once()
 
diff --git a/litellm/tests/test_exceptions.py b/litellm/tests/test_exceptions.py
index dfefe99d6..806e19569 100644
--- a/litellm/tests/test_exceptions.py
+++ b/litellm/tests/test_exceptions.py
@@ -806,7 +806,8 @@ def test_exception_mapping(provider):
         except expected_exception:
             continue
         except Exception as e:
-            response = "{}\n{}".format(str(e), traceback.format_exc())
+            traceback.print_exc()
+            response = "{}".format(str(e))
         pytest.fail(
             "Did not raise expected exception. Expected={}, Return={},".format(
                 expected_exception, response
diff --git a/litellm/utils.py b/litellm/utils.py
index 0875b0e0e..f35acbdeb 100644
--- a/litellm/utils.py
+++ b/litellm/utils.py
@@ -8894,12 +8894,11 @@ class CustomStreamWrapper:
                 "finish_reason": finish_reason,
             }
         except Exception as e:
-            verbose_logger.error(
+            verbose_logger.exception(
                 "litellm.CustomStreamWrapper.handle_predibase_chunk(): Exception occured - {}".format(
                     str(e)
                 )
             )
-            verbose_logger.debug(traceback.format_exc())
             raise e
 
     def handle_huggingface_chunk(self, chunk):
@@ -8943,12 +8942,11 @@ class CustomStreamWrapper:
                 "finish_reason": finish_reason,
             }
         except Exception as e:
-            verbose_logger.error(
+            verbose_logger.exception(
                 "litellm.CustomStreamWrapper.handle_huggingface_chunk(): Exception occured - {}".format(
                     str(e)
                 )
             )
-            verbose_logger.debug(traceback.format_exc())
             raise e
 
     def handle_ai21_chunk(self, chunk):  # fake streaming
@@ -9171,12 +9169,11 @@ class CustomStreamWrapper:
                 "usage": usage,
             }
         except Exception as e:
-            verbose_logger.error(
+            verbose_logger.exception(
                 "litellm.CustomStreamWrapper.handle_openai_chat_completion_chunk(): Exception occured - {}".format(
                     str(e)
                 )
             )
-            verbose_logger.debug(traceback.format_exc())
             raise e
 
     def handle_azure_text_completion_chunk(self, chunk):
@@ -9256,13 +9253,12 @@ class CustomStreamWrapper:
                     return ""
             else:
                 return ""
-        except:
-            verbose_logger.error(
+        except Exception as e:
+            verbose_logger.exception(
                 "litellm.CustomStreamWrapper.handle_baseten_chunk(): Exception occured - {}".format(
                     str(e)
                 )
             )
-            verbose_logger.debug(traceback.format_exc())
             return ""
 
     def handle_cloudlfare_stream(self, chunk):
@@ -9496,13 +9492,12 @@ class CustomStreamWrapper:
                 "text": text,
                 "is_finished": True,
             }
-        except:
-            verbose_logger.error(
+        except Exception as e:
+            verbose_logger.exception(
                 "litellm.CustomStreamWrapper.handle_clarifai_chunk(): Exception occured - {}".format(
                     str(e)
                 )
             )
-            verbose_logger.debug(traceback.format_exc())
             return ""
 
     def model_response_creator(
@@ -10103,12 +10098,11 @@ class CustomStreamWrapper:
                                         tool["type"] = "function"
                             model_response.choices[0].delta = Delta(**_json_delta)
                         except Exception as e:
-                            verbose_logger.error(
-                                "litellm.CustomStreamWrapper.chunk_creator(): Exception occured - {}\n{}".format(
-                                    str(e), traceback.format_exc()
+                            verbose_logger.exception(
+                                "litellm.CustomStreamWrapper.chunk_creator(): Exception occured - {}".format(
+                                    str(e)
                                 )
                             )
-                            verbose_logger.debug(traceback.format_exc())
                             model_response.choices[0].delta = Delta()
                     else:
                         try:
@@ -11088,10 +11082,8 @@ def trim_messages(
             return final_messages, response_tokens
         return final_messages
     except Exception as e:  # [NON-Blocking, if error occurs just return final_messages
-        verbose_logger.error(
-            "Got exception while token trimming - {}\n{}".format(
-                str(e), traceback.format_exc()
-            )
+        verbose_logger.exception(
+            "Got exception while token trimming - {}".format(str(e))
         )
         return messages