use logger.exception() in some exception handlers, disable rule forcing it over logger.error

Use logger.exception for broad catches where the exception may be useful,
Use logger.error for expected cases where we know what we're dealing with already.

Suppress SonarQube rule python:S8572 globally — the blanket "always use
logger.exception in except blocks" recommendation doesn't fit our policy.

Assisted-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: himdel

apps/dashboard_reports/tasks.py

@@ -184,7 +184,7 @@ def _sync_jobs_atomically(job_results: list) -> list:
                 try:
                     JobData.create_or_update_from_awx(job)
                 except Exception as e:
-                    logger.error(f"Error creating/updating JobData for job {job['id']}: {str(e)}")
+                    logger.exception(f"Error creating/updating JobData for job {job['id']}: {str(e)}")
                     failed_jobs.append(job["id"])
             if failed_jobs:
                 raise _PartialSyncRollbackError()
@@ -664,7 +664,7 @@ def cleanup_dashboard_reports_old_data(**kwargs) -> dict[str, Any]:
         )
     except Exception as e:
         duration_ms = (time.monotonic() - start_time) * 1000
-        logger.error(f"Error during cleanup of old JobData records: {str(e)}")
+        logger.exception(f"Error during cleanup of old JobData records: {str(e)}")
         _save_telemetry_details(
             task_name=task_name,
             success=False,

apps/dynamic_settings/management/commands/reload_config.py

@@ -51,6 +51,6 @@ def handle(self, *args, **options):
 
         except Exception as e:
             error_msg = f"Failed to reload configuration: {str(e)}"
-            logger.error(error_msg)
+            logger.exception(error_msg)
             self.stdout.write(self.style.ERROR(f"{error_msg}"))
             raise

apps/dynamic_settings/utils.py

@@ -82,7 +82,7 @@ def log_setting_change(user, setting_key: str, new_value, old_value=None):
         return setting
 
     except Exception as e:
-        logger.error(f"Failed to log setting change for {setting_key}: {str(e)}")
+        logger.exception(f"Failed to log setting change for {setting_key}: {str(e)}")
         return None
 
 
@@ -144,7 +144,7 @@ def rollback_configuration_change(change_id, user):
         }
 
     except Exception as e:
-        logger.error(f"Failed to rollback configuration change {change_id}: {str(e)}")
+        logger.exception(f"Failed to rollback configuration change {change_id}: {str(e)}")
         return {"success": False, "error": f"Failed to rollback: {str(e)}"}
 
 

apps/tasks/cleanup/cleanup_metrics_data.py

@@ -108,5 +108,5 @@ def cleanup_metrics_data(**kwargs) -> dict[str, Any]:
         )
 
     except Exception as e:
-        logger.error(f"Error in cleanup_metrics_data: {str(e)}")
+        logger.exception(f"Error in cleanup_metrics_data: {str(e)}")
         return create_task_result("error", error=f"Cleanup failed: {str(e)}")

apps/tasks/collectors/daily_metrics_rollup.py

@@ -331,5 +331,5 @@ def daily_metrics_rollup(**kwargs) -> dict[str, Any]:
         )
 
     except Exception as e:
-        logger.error(f"Error in daily_metrics_rollup: {str(e)}")
+        logger.exception(f"Error in daily_metrics_rollup: {str(e)}")
         return create_task_result("error", error=f"Rollup failed: {str(e)}")

apps/tasks/cron_scheduler.py

@@ -148,7 +148,7 @@ def start(self):
                 logger.info(f"Periodic database sync will run every {self.check_interval} seconds")
 
             except Exception as e:
-                logger.error(f"Failed to start cron scheduler: {str(e)}")
+                logger.exception(f"Failed to start cron scheduler: {str(e)}")
                 raise
 
     def stop(self):
@@ -163,7 +163,7 @@ def stop(self):
                 self._db_task_jobs.clear()
                 logger.info("Task scheduler stopped")
             except Exception as e:
-                logger.error(f"Error stopping cron scheduler: {str(e)}")
+                logger.exception(f"Error stopping cron scheduler: {str(e)}")
 
     def _task_feature_flag_enabled(self, task) -> bool:
         """Return False if the task carries a feature flag that is currently disabled."""
@@ -201,7 +201,7 @@ def _sync_database_tasks(self):
             logger.info(f"Synchronized {added_scheduled} scheduled and {added_recurring} recurring database tasks")
 
         except Exception as e:
-            logger.error(f"Error synchronizing database tasks: {e}")
+            logger.exception(f"Error synchronizing database tasks: {e}")
 
     def _periodic_database_sync(self):
         """Periodically check for new database tasks and add them to the scheduler."""
@@ -376,7 +376,7 @@ def _add_database_scheduled_task(self, task):
             logger.info(f"Added scheduled database task: {task.name} (ID: {task.id}) at {task.scheduled_time}")
 
         except Exception as e:
-            logger.error(f"Failed to add scheduled database task {task.id}: {e}")
+            logger.exception(f"Failed to add scheduled database task {task.id}: {e}")
 
     def _add_database_recurring_task(self, task):
         """Add a recurring database task to the scheduler."""
@@ -404,7 +404,7 @@ def _add_database_recurring_task(self, task):
             logger.info(f"Added recurring database task: {task.name} (ID: {task.id}) with cron: {task.cron_expression}")
 
         except Exception as e:
-            logger.error(f"Failed to add recurring database task {task.id}: {e}")
+            logger.exception(f"Failed to add recurring database task {task.id}: {e}")
 
     def _execute_database_task(self, task_id: int):
         """Execute a database task by submitting it to dispatcherd."""
@@ -481,7 +481,7 @@ def _execute_database_task(self, task_id: int):
             self._remove_database_task(task_id)
 
         except Exception as e:
-            logger.error(f"Failed to execute database task {task_id}: {e}")
+            logger.exception(f"Failed to execute database task {task_id}: {e}")
 
     def _remove_database_task(self, task_id: int):
         """Remove a database task from the scheduler."""

apps/tasks/dispatcherd_config.py

@@ -69,7 +69,7 @@ def setup_dispatcherd_config() -> None:
         logger.error(f"Failed to import dispatcherd: {e}")
         raise
     except Exception as e:
-        logger.error(f"Failed to configure dispatcherd: {e}")
+        logger.exception(f"Failed to configure dispatcherd: {e}")
         raise
 
 
@@ -176,7 +176,7 @@ def build_config_from_django_settings() -> dict[str, Any]:
         return config
 
     except Exception as e:
-        logger.error(f"Failed to build config from Django settings: {e}")
+        logger.exception(f"Failed to build config from Django settings: {e}")
         raise
 
 
@@ -199,5 +199,5 @@ def ensure_dispatcherd_configured() -> None:
         logger.error("Dispatcherd not available")
         raise
     except Exception as e:
-        logger.error(f"Failed to ensure dispatcherd configuration: {e}")
+        logger.exception(f"Failed to ensure dispatcherd configuration: {e}")
         raise

apps/tasks/models.py

@@ -184,7 +184,7 @@ def retry(self, delay_seconds: int = 0) -> bool:
                 submit_task_to_dispatcher(self)
             except Exception as e:
                 # If submission fails, update the task status
-                logger.error(f"Failed to submit retried task {self.id} to dispatcher: {str(e)}")
+                logger.exception(f"Failed to submit retried task {self.id} to dispatcher: {str(e)}")
                 self.status = "failed"
                 self.error_message = f"Failed to submit to dispatcher: {str(e)}"
                 self.save(update_fields=["status", "error_message", "modified"])

apps/tasks/tasks_system.py

@@ -247,7 +247,7 @@ def submit_task_to_dispatcher(task: Any) -> None:
         if task.can_retry():
             logger.warning(f"Error submitting task to dispatcher: {str(e)}")
         else:
-            logger.error(f"Error submitting task to dispatcher: {str(e)}")
+            logger.exception(f"Error submitting task to dispatcher: {str(e)}")
 
 
 # runs during `manage.py metrics_service init-system-tasks`
@@ -307,7 +307,7 @@ def create_system_tasks() -> dict[str, Any]:
             _create_task_from_group(task_id, config, results, Task)
         except Exception as e:
             results["tasks"].append(f"Error with {task_id}: {str(e)}")
-            logger.error(f"Failed to create task {task_id}: {e}")
+            logger.exception(f"Failed to create task {task_id}: {e}")
 
     # Restore completed status for one-shot tasks that already ran successfully,
     # preventing them from re-running on the next upgrade.

apps/tasks/utils.py

@@ -36,8 +36,11 @@ def _fetch_task_by_id(task_id: int) -> Any:
         from .models import Task
 
         return Task.objects.get(id=task_id)
+    except Task.DoesNotExist:
+        logger.error(f"Task instance not found for task_id: {task_id}")
+        return None
     except Exception:
-        logger.error(f"Failed to get task instance for task_id: {task_id}")
+        logger.exception(f"Failed to get task instance for task_id: {task_id}")
         return None
 
 
@@ -47,8 +50,11 @@ def _fetch_execution_by_id(execution_id: int) -> Any:
         from .models import TaskExecution
 
         return TaskExecution.objects.get(id=execution_id)
+    except TaskExecution.DoesNotExist:
+        logger.error(f"Execution instance not found for execution_id: {execution_id}")
+        return None
     except Exception:
-        logger.error(f"Failed to get execution instance for execution_id: {execution_id}")
+        logger.exception(f"Failed to get execution instance for execution_id: {execution_id}")
         return None
 
 
@@ -118,7 +124,7 @@ def handle_task_error(
                 )
 
     except Exception as save_error:
-        logger.error(f"Failed to update task status after error: {save_error}")
+        logger.exception(f"Failed to update task status after error: {save_error}")
 
     # Deferred past the transaction so status=="failed" and attempts are incremented before can_retry() is called.
     # Defaults to ERROR when no task context is available.