dar-backup 1.0.1__py3-none-any.whl → 1.0.2__py3-none-any.whl

dar_backup/cleanup.py

@@ -48,6 +48,7 @@ from dar_backup.util import is_archive_name_allowed
 from dar_backup.util import is_safe_filename
 from dar_backup.util import safe_remove_file
 from dar_backup.util import show_scriptname
+from dar_backup.util import send_discord_message
 
 from dar_backup.command_runner import CommandRunner   
 from dar_backup.command_runner import CommandResult
@@ -67,7 +68,6 @@ def _delete_par2_files(
     else:
         par2_config = {
             "par2_dir": None,
-            "par2_mode": None,
         }
 
     par2_dir = par2_config.get("par2_dir") or backup_dir
@@ -76,49 +76,33 @@ def _delete_par2_files(
         logger.warning(f"PAR2 directory not found, skipping cleanup: {par2_dir}")
         return
 
-    par2_mode = (par2_config.get("par2_mode") or "per-slice").lower()
-
-    if par2_mode == "per-archive":
-        par2_glob = os.path.join(par2_dir, f"{archive_name}*.par2")
-        targets = glob.glob(par2_glob)
-        manifest_path = os.path.join(par2_dir, f"{archive_name}.par2.manifest.ini")
-        if os.path.exists(manifest_path):
-            targets.append(manifest_path)
-        if not targets:
-            logger.info("No par2 files matched the per-archive cleanup pattern.")
-            return
-        for file_path in sorted(set(targets)):
-            try:
-                if dry_run:
-                    logger.info(f"Dry run: would delete PAR2 file: {file_path}")
-                else:
-                    safe_remove_file(file_path, base_dir=Path(par2_dir))
-                    logger.info(f"Deleted PAR2 file: {file_path}")
-            except Exception as e:
-                logger.error(f"Error deleting PAR2 file {file_path}: {e}")
-        return
-
-    if par2_mode != "per-slice":
-        logger.error(f"Unsupported PAR2_MODE during cleanup: {par2_mode}")
-        return
+    par2_glob = os.path.join(par2_dir, f"{archive_name}*.par2")
+    targets = set(glob.glob(par2_glob))
+    manifest_path = os.path.join(par2_dir, f"{archive_name}.par2.manifest.ini")
+    if os.path.exists(manifest_path):
+        targets.add(manifest_path)
 
     par2_regex = re.compile(rf"^{re.escape(archive_name)}\.[0-9]+\.dar.*\.par2$")
-    files_deleted = False
-    for filename in sorted(os.listdir(par2_dir)):
+    for entry in os.scandir(par2_dir):
+        if not entry.is_file():
+            continue
+        filename = entry.name
         if par2_regex.match(filename):
-            file_path = os.path.join(par2_dir, filename)
-            try:
-                if dry_run:
-                    logger.info(f"Dry run: would delete PAR2 file: {file_path}")
-                else:
-                    safe_remove_file(file_path, base_dir=Path(par2_dir))
-                    logger.info(f"Deleted PAR2 file: {file_path}")
-                    files_deleted = True
-            except Exception as e:
-                logger.error(f"Error deleting PAR2 file {file_path}: {e}")
+            targets.add(entry.path)
 
-    if not files_deleted:
-        logger.info("No .par2 matched the regex for deletion.")
+    if not targets:
+        logger.info("No par2 files matched the cleanup patterns.")
+        return
+
+    for file_path in sorted(targets):
+        try:
+            if dry_run:
+                logger.info(f"Dry run: would delete PAR2 file: {file_path}")
+            else:
+                safe_remove_file(file_path, base_dir=Path(par2_dir))
+                logger.info(f"Deleted PAR2 file: {file_path}")
+        except Exception as e:
+            logger.error(f"Error deleting PAR2 file {file_path}: {e}")
 
 
 def delete_old_backups(backup_dir, age, backup_type, args, backup_definition=None, config_settings: ConfigSettings = None):
@@ -138,7 +122,10 @@ def delete_old_backups(backup_dir, age, backup_type, args, backup_definition=Non
     archives_deleted = {}
 
     dry_run = getattr(args, "dry_run", False) is True
-    for filename in sorted(os.listdir(backup_dir)):
+    for entry in os.scandir(backup_dir):
+        if not entry.is_file():
+            continue
+        filename = entry.name
         if not filename.endswith('.dar'):
             continue
         if backup_definition and not filename.startswith(backup_definition):
@@ -152,7 +139,7 @@ def delete_old_backups(backup_dir, age, backup_type, args, backup_definition=Non
                 raise
 
             if file_date < cutoff_date:
-                file_path = os.path.join(backup_dir, filename)
+                file_path = entry.path
                 try:
                     if dry_run:
                         logger.info(f"Dry run: would delete {backup_type} backup: {file_path}")
@@ -190,9 +177,12 @@ def delete_archive(backup_dir, archive_name, args, config_settings: ConfigSettin
     # Delete the specified .dar files according to the naming convention
     files_deleted = False
     dry_run = getattr(args, "dry_run", False) is True
-    for filename in sorted(os.listdir(backup_dir)):
+    for entry in os.scandir(backup_dir):
+        if not entry.is_file():
+            continue
+        filename = entry.name
         if archive_regex.match(filename):
-            file_path = os.path.join(backup_dir, filename)
+            file_path = entry.path
             try:
                 if dry_run:
                     logger.info(f"Dry run: would delete archive slice: {file_path}")
@@ -308,15 +298,35 @@ def main():
             raise SystemExit(127)
     args.config_file = config_settings_path
 
-    config_settings = ConfigSettings(args.config_file)
+    try:
+        config_settings = ConfigSettings(args.config_file)
+    except Exception as exc:
+        msg = f"Config error: {exc}"
+        print(msg, file=stderr)
+        ts = datetime.now().strftime("%Y-%m-%d_%H:%M")
+        send_discord_message(f"{ts} - cleanup: FAILURE - {msg}")
+        sys.exit(127)
 
     start_time=int(time())
 
 #    command_output_log = os.path.join(config_settings.logfile_location.removesuffix("dar-backup.log"), "dar-backup-commands.log")
     command_output_log = config_settings.logfile_location.replace("dar-backup.log", "dar-backup-commands.log")
-    logger = setup_logging(config_settings.logfile_location, command_output_log, args.log_level, args.log_stdout, logfile_max_bytes=config_settings.logfile_max_bytes, logfile_backup_count=config_settings.logfile_backup_count)
+    logger = setup_logging(
+        config_settings.logfile_location,
+        command_output_log,
+        args.log_level,
+        args.log_stdout,
+        logfile_max_bytes=config_settings.logfile_max_bytes,
+        logfile_backup_count=config_settings.logfile_backup_count,
+        trace_log_max_bytes=getattr(config_settings, "trace_log_max_bytes", 10485760),
+        trace_log_backup_count=getattr(config_settings, "trace_log_backup_count", 1)
+    )
     command_logger = get_logger(command_output_logger = True)
-    runner = CommandRunner(logger=logger, command_logger=command_logger)
+    runner = CommandRunner(
+        logger=logger,
+        command_logger=command_logger,
+        default_capture_limit_bytes=getattr(config_settings, "command_capture_max_bytes", None)
+    )
 
     start_msgs: List[Tuple[str, str]] = []
 
@@ -341,65 +351,89 @@ def main():
     print_aligned_settings(start_msgs, highlight_keywords=dangerous_keywords, quiet=not args.verbose)
 
     # run PREREQ scripts
-    requirements('PREREQ', config_settings)
-
-    if args.alternate_archive_dir:
-        if not os.path.exists(args.alternate_archive_dir):
-            logger.error(f"Alternate archive directory does not exist: {args.alternate_archive_dir}, exiting")
-            sys.exit(1) 
-        if  not os.path.isdir(args.alternate_archive_dir):
-            logger.error(f"Alternate archive directory is not a directory, exiting")
-            sys.exit(1) 
-        config_settings.backup_dir = args.alternate_archive_dir
-
-    if args.cleanup_specific_archives is None and args.test_mode:
-        logger.info("No --cleanup-specific-archives provided; skipping specific archive deletion in test mode.")
-
-    if args.cleanup_specific_archives or args.cleanup_specific_archives_list:
-        combined = []
-        if args.cleanup_specific_archives:
-            combined.extend(args.cleanup_specific_archives.split(','))
-        combined.extend(args.cleanup_specific_archives_list or [])
-        archive_names = [name.strip() for name in combined if name.strip()]
-        logger.info(f"Cleaning up specific archives: {', '.join(archive_names)}")
-        for archive_name in archive_names:
-            if "_FULL_" in archive_name:
-                if not confirm_full_archive_deletion(archive_name, args.test_mode):
+    try:
+        requirements('PREREQ', config_settings)
+    except Exception as exc:
+        msg = f"PREREQ failed: {exc}"
+        logger.error(msg)
+        ts = datetime.now().strftime("%Y-%m-%d_%H:%M")
+        send_discord_message(f"{ts} - cleanup: FAILURE - {msg}", config_settings=config_settings)
+        sys.exit(1)
+
+    try:
+        if args.alternate_archive_dir:
+            if not os.path.exists(args.alternate_archive_dir):
+                logger.error(f"Alternate archive directory does not exist: {args.alternate_archive_dir}, exiting")
+                sys.exit(1) 
+            if  not os.path.isdir(args.alternate_archive_dir):
+                logger.error(f"Alternate archive directory is not a directory, exiting")
+                sys.exit(1) 
+            config_settings.backup_dir = args.alternate_archive_dir
+
+        if args.cleanup_specific_archives is None and args.test_mode:
+            logger.info("No --cleanup-specific-archives provided; skipping specific archive deletion in test mode.")
+
+        if args.cleanup_specific_archives or args.cleanup_specific_archives_list:
+            combined = []
+            if args.cleanup_specific_archives:
+                combined.extend(args.cleanup_specific_archives.split(','))
+            combined.extend(args.cleanup_specific_archives_list or [])
+            archive_names = [name.strip() for name in combined if name.strip()]
+            logger.info(f"Cleaning up specific archives: {', '.join(archive_names)}")
+            for archive_name in archive_names:
+                if not is_archive_name_allowed(archive_name):
+                    logger.error(f"Refusing unsafe archive name: {archive_name}")
                     continue
-            archive_path = os.path.join(config_settings.backup_dir, archive_name.strip())
-            logger.info(f"Deleting archive: {archive_path}")
-            delete_archive(config_settings.backup_dir, archive_name.strip(), args, config_settings)
-    elif args.list:
-        list_backups(config_settings.backup_dir, args.backup_definition)
-    else:
-        backup_definitions = []
-        if args.backup_definition:
-            backup_definitions.append(args.backup_definition)
+                if "_FULL_" in archive_name:
+                    if not confirm_full_archive_deletion(archive_name, args.test_mode):
+                        continue
+                archive_path = os.path.join(config_settings.backup_dir, archive_name.strip())
+                logger.info(f"Deleting archive: {archive_path}")
+                delete_archive(config_settings.backup_dir, archive_name.strip(), args, config_settings)
+        elif args.list:
+            list_backups(config_settings.backup_dir, args.backup_definition)
         else:
-            for root, _, files in os.walk(config_settings.backup_d_dir):
-                for file in files:
-                    backup_definitions.append(file.split('.')[0])
-
-        for definition in backup_definitions:
-            delete_old_backups(
-                config_settings.backup_dir,
-                config_settings.diff_age,
-                'DIFF',
-                args,
-                backup_definition=definition,
-                config_settings=config_settings
-            )
-            delete_old_backups(
-                config_settings.backup_dir,
-                config_settings.incr_age,
-                'INCR',
-                args,
-                backup_definition=definition,
-                config_settings=config_settings
-            )
+            backup_definitions = []
+            if args.backup_definition:
+                backup_definitions.append(args.backup_definition)
+            else:
+                for root, _, files in os.walk(config_settings.backup_d_dir):
+                    for file in files:
+                        backup_definitions.append(file.split('.')[0])
+
+            for definition in backup_definitions:
+                delete_old_backups(
+                    config_settings.backup_dir,
+                    config_settings.diff_age,
+                    'DIFF',
+                    args,
+                    backup_definition=definition,
+                    config_settings=config_settings
+                )
+                delete_old_backups(
+                    config_settings.backup_dir,
+                    config_settings.incr_age,
+                    'INCR',
+                    args,
+                    backup_definition=definition,
+                    config_settings=config_settings
+                )
+    except Exception as e:
+        msg = f"Unexpected error during cleanup: {e}"
+        logger.error(msg, exc_info=True)
+        ts = datetime.now().strftime("%Y-%m-%d_%H:%M")
+        send_discord_message(f"{ts} - cleanup: FAILURE - {msg}", config_settings=config_settings)
+        sys.exit(1)
 
     # run POST scripts
-    requirements('POSTREQ', config_settings)
+    try:
+        requirements('POSTREQ', config_settings)
+    except Exception as exc:
+        msg = f"POSTREQ failed: {exc}"
+        logger.error(msg)
+        ts = datetime.now().strftime("%Y-%m-%d_%H:%M")
+        send_discord_message(f"{ts} - cleanup: FAILURE - {msg}", config_settings=config_settings)
+        sys.exit(1)
 
 
     end_time=int(time())

dar_backup/command_runner.py

@@ -84,11 +84,13 @@ class CommandRunner:
         self,
         logger: Optional[logging.Logger] = None,
         command_logger: Optional[logging.Logger] = None,
-        default_timeout: int = 30
+        default_timeout: int = 30,
+        default_capture_limit_bytes: Optional[int] = None
     ):
         self.logger = logger or get_logger()
         self.command_logger = command_logger or get_logger(command_output_logger=True)
         self.default_timeout = default_timeout
+        self.default_capture_limit_bytes = default_capture_limit_bytes
 
         if not self.logger or not self.command_logger:
             self.logger_fallback()
@@ -129,12 +131,18 @@ class CommandRunner:
         timeout: Optional[int] = None,
         check: bool = False,
         capture_output: bool = True,
+        capture_output_limit_bytes: Optional[int] = None,
+        log_output: bool = True,
         text: bool = True,
         cwd: Optional[str] = None,
         stdin: Optional[int] = subprocess.DEVNULL
     ) -> CommandResult:
         self._text_mode = text
         timeout = timeout or self.default_timeout
+        if capture_output_limit_bytes is None:
+            capture_output_limit_bytes = self.default_capture_limit_bytes
+        if capture_output_limit_bytes is not None and capture_output_limit_bytes < 0:
+            capture_output_limit_bytes = None
 
         tty_fd = None
         tty_file = None
@@ -163,9 +171,13 @@ class CommandRunner:
             except ValueError as e:
                 stack = traceback.format_exc()
                 self.logger.error(f"Command sanitation failed: {e}")
+                if isinstance(cmd, list):
+                    cmd_text = " ".join(map(str, cmd))
+                else:
+                    cmd_text = str(cmd)
                 return CommandResult(
                     returncode=-1,
-                    note=f"Sanitizing failed: command: {' '.join(cmd)}",
+                    note=f"Sanitizing failed: command: {cmd_text}",
                     stdout='',
                     stderr=str(e),
                     stack=stack,
@@ -183,12 +195,15 @@ class CommandRunner:
 
             stdout_lines = []
             stderr_lines = []
+            truncated_stdout = {"value": False}
+            truncated_stderr = {"value": False}
 
             try:
+                use_pipes = capture_output or log_output
                 process = subprocess.Popen(
                     cmd,
-                    stdout=subprocess.PIPE if capture_output else None,
-                    stderr=subprocess.PIPE if capture_output else None,
+                    stdout=subprocess.PIPE if use_pipes else None,
+                    stderr=subprocess.PIPE if use_pipes else None,
                     stdin=stdin,
                     text=False,
                     bufsize=-1,
@@ -203,7 +218,8 @@ class CommandRunner:
                     stack=stack
                 )
 
-            def stream_output(stream, lines, level):
+            def stream_output(stream, lines, level, truncated_flag):
+                captured_bytes = 0
                 try:
                     while True:
                         chunk = stream.read(1024)
@@ -211,10 +227,40 @@ class CommandRunner:
                             break
                         if self._text_mode:
                             decoded = chunk.decode('utf-8', errors='replace')
-                            lines.append(decoded)
-                            self.command_logger.log(level, decoded.strip())
+                            if log_output:
+                                self.command_logger.log(level, decoded.strip())
+                            if capture_output:
+                                if capture_output_limit_bytes is None:
+                                    lines.append(decoded)
+                                else:
+                                    remaining = capture_output_limit_bytes - captured_bytes
+                                    if remaining > 0:
+                                        if len(chunk) <= remaining:
+                                            lines.append(decoded)
+                                            captured_bytes += len(chunk)
+                                        else:
+                                            piece = chunk[:remaining]
+                                            lines.append(piece.decode('utf-8', errors='replace'))
+                                            captured_bytes = capture_output_limit_bytes
+                                            truncated_flag["value"] = True
+                                    else:
+                                        truncated_flag["value"] = True
                         else:
-                            lines.append(chunk)
+                            if capture_output:
+                                if capture_output_limit_bytes is None:
+                                    lines.append(chunk)
+                                else:
+                                    remaining = capture_output_limit_bytes - captured_bytes
+                                    if remaining > 0:
+                                        if len(chunk) <= remaining:
+                                            lines.append(chunk)
+                                            captured_bytes += len(chunk)
+                                        else:
+                                            lines.append(chunk[:remaining])
+                                            captured_bytes = capture_output_limit_bytes
+                                            truncated_flag["value"] = True
+                                    else:
+                                        truncated_flag["value"] = True
                             # Avoid logging raw binary data to prevent garbled logs
                 except Exception as e:
                     self.logger.warning(f"stream_output decode error: {e}")
@@ -222,12 +268,18 @@ class CommandRunner:
                     stream.close()
 
             threads = []
-            if capture_output and process.stdout:
-                t_out = threading.Thread(target=stream_output, args=(process.stdout, stdout_lines, logging.INFO))
+            if (capture_output or log_output) and process.stdout:
+                t_out = threading.Thread(
+                    target=stream_output,
+                    args=(process.stdout, stdout_lines, logging.INFO, truncated_stdout)
+                )
                 t_out.start()
                 threads.append(t_out)
-            if capture_output and process.stderr:
-                t_err = threading.Thread(target=stream_output, args=(process.stderr, stderr_lines, logging.ERROR))
+            if (capture_output or log_output) and process.stderr:
+                t_err = threading.Thread(
+                    target=stream_output,
+                    args=(process.stderr, stderr_lines, logging.ERROR, truncated_stderr)
+                )
                 t_err.start()
                 threads.append(t_err)
 
@@ -254,6 +306,15 @@ class CommandRunner:
                 stdout_combined = b''.join(stdout_lines)
                 stderr_combined = b''.join(stderr_lines)
 
+            note = None
+            if truncated_stdout["value"] or truncated_stderr["value"]:
+                parts = []
+                if truncated_stdout["value"]:
+                    parts.append("stdout truncated")
+                if truncated_stderr["value"]:
+                    parts.append("stderr truncated")
+                note = ", ".join(parts)
+
             if check and process.returncode != 0:
                 self.logger.error(f"Command failed with exit code {process.returncode}")
                 return CommandResult(
@@ -266,7 +327,8 @@ class CommandRunner:
             return CommandResult(
                 process.returncode,
                 stdout_combined,
-                stderr_combined
+                stderr_combined,
+                note=note
             )
         finally:
             if termios is not None and saved_tty_attrs is not None and tty_fd is not None:

dar_backup/config_settings.py

@@ -39,6 +39,7 @@ class ConfigSettings:
     min_size_verification_mb: int = field(init=False)
     no_files_verification: int = field(init=False)
     command_timeout_secs: int = field(init=False)
+    command_capture_max_bytes: Optional[int] = field(init=False, default=None)
     backup_dir: str = field(init=False)
     test_restore_dir: str = field(init=False)
     backup_d_dir: str = field(init=False)
@@ -47,14 +48,14 @@ class ConfigSettings:
     error_correction_percent: int = field(init=False)
     par2_enabled: bool = field(init=False)
     par2_dir: Optional[str] = field(init=False, default=None)
-    par2_layout: Optional[str] = field(init=False, default=None)
-    par2_mode: Optional[str] = field(init=False, default=None)
     par2_ratio_full: Optional[int] = field(init=False, default=None)
     par2_ratio_diff: Optional[int] = field(init=False, default=None)
     par2_ratio_incr: Optional[int] = field(init=False, default=None)
     par2_run_verify: Optional[bool] = field(init=False, default=None)
     logfile_max_bytes: int = field(init=False)
     logfile_no_count: int = field(init=False)    
+    trace_log_max_bytes: int = field(init=False)
+    trace_log_backup_count: int = field(init=False)
     dar_backup_discord_webhook_url: Optional[str] = field(init=False, default=None)
     restoretest_exclude_prefixes: list[str] = field(init=False, default_factory=list)
     restoretest_exclude_suffixes: list[str] = field(init=False, default_factory=list)
@@ -83,6 +84,20 @@ class ConfigSettings:
             "type": int,
             "default": 5,
         },
+        {
+            "section": "MISC",
+            "key": "TRACE_LOG_MAX_BYTES",
+            "attr": "trace_log_max_bytes",
+            "type": int,
+            "default": 10485760, # 10 MB
+        },
+        {
+            "section": "MISC",
+            "key": "TRACE_LOG_BACKUP_COUNT",
+            "attr": "trace_log_backup_count",
+            "type": int,
+            "default": 1,
+        },
         {
             "section": "MISC",
             "key": "DAR_BACKUP_DISCORD_WEBHOOK_URL",
@@ -90,6 +105,13 @@ class ConfigSettings:
             "type": str,
             "default": None,
         },
+        {
+            "section": "MISC",
+            "key": "COMMAND_CAPTURE_MAX_BYTES",
+            "attr": "command_capture_max_bytes",
+            "type": int,
+            "default": 102400,
+        },
         # Add more optional fields here
     ]
 
@@ -98,7 +120,7 @@ class ConfigSettings:
             raise ConfigSettingsError("`config_file` must be specified.")
 
         try:
-            self.config = configparser.ConfigParser()
+            self.config = configparser.ConfigParser(inline_comment_prefixes=['#'])
             loaded_files = self.config.read(self.config_file)
             if not loaded_files:
                 raise RuntimeError(f"Configuration file not found or unreadable: '{self.config_file}'")
@@ -124,8 +146,6 @@ class ConfigSettings:
                 raise ConfigSettingsError(f"Invalid boolean value for 'ENABLED' in [PAR2]: '{val}'")
 
             self.par2_dir = self._get_optional_str("PAR2", "PAR2_DIR", default=None)
-            self.par2_layout = self._get_optional_str("PAR2", "PAR2_LAYOUT", default="by-backup")
-            self.par2_mode = self._get_optional_str("PAR2", "PAR2_MODE", default=None)
             self.par2_ratio_full = self._get_optional_int("PAR2", "PAR2_RATIO_FULL", default=None)
             self.par2_ratio_diff = self._get_optional_int("PAR2", "PAR2_RATIO_DIFF", default=None)
             self.par2_ratio_incr = self._get_optional_int("PAR2", "PAR2_RATIO_INCR", default=None)
@@ -240,8 +260,6 @@ class ConfigSettings:
         """
         par2_config = {
             "par2_dir": self.par2_dir,
-            "par2_layout": self.par2_layout,
-            "par2_mode": self.par2_mode,
             "par2_ratio_full": self.par2_ratio_full,
             "par2_ratio_diff": self.par2_ratio_diff,
             "par2_ratio_incr": self.par2_ratio_incr,
@@ -260,10 +278,6 @@ class ConfigSettings:
                 continue
             if key == "PAR2_DIR":
                 par2_config["par2_dir"] = value
-            elif key == "PAR2_LAYOUT":
-                par2_config["par2_layout"] = value
-            elif key == "PAR2_MODE":
-                par2_config["par2_mode"] = value
             elif key == "PAR2_RATIO_FULL":
                 par2_config["par2_ratio_full"] = int(value)
             elif key == "PAR2_RATIO_DIFF":

dar_backup/dar-backup.conf

@@ -17,7 +17,14 @@ NO_FILES_VERIFICATION = 5
 # The author has such `dar` tasks running for 10-15 hours on the yearly backups, so a value of 24 hours is used.
 # If a timeout is not specified when using the CommandRunner, a default timeout of 30 secs is used.
 COMMAND_TIMEOUT_SECS = 86400
+# Optional limit on captured command output (in bytes). Output beyond this
+# size is still logged but not kept in memory. Use 0 to avoid buffering entirely.
+# Default is 102400.
+# COMMAND_CAPTURE_MAX_BYTES = 102400
 #DAR_BACKUP_DISCORD_WEBHOOK_URL = https://discord.com/api/webhooks/<id>/<token>
+# Optional Trace log configuration (debug level logs with stack traces)
+# TRACE_LOG_MAX_BYTES = 10485760  # 10 MB default
+# TRACE_LOG_BACKUP_COUNT = 1      # 1 backup file default
 
 [DIRECTORIES]
 BACKUP_DIR = @@BACKUP_DIR@@

dar_backup/dar-backup.conf.j2

@@ -31,6 +31,9 @@ LOGFILE_LOCATION = {{ vars_map.DAR_BACKUP_DIR -}}/dar-backup.log
 # LOGFILE_BACKUP_COUNT = 5      # default, change as needed
 # DAR_BACKUP_DISCORD_WEBHOOK_URL **should really** be given as an environment variable for security reasons
 # DAR_BACKUP_DISCORD_WEBHOOK_URL = https://discord.com/api/webhooks/<id>/<token>
+# Optional Trace log configuration (debug level logs with stack traces)
+# TRACE_LOG_MAX_BYTES = 10485760  # 10 MB default
+# TRACE_LOG_BACKUP_COUNT = 1      # 1 backup file default
 
 MAX_SIZE_VERIFICATION_MB = 2
 MIN_SIZE_VERIFICATION_MB = 0
@@ -64,7 +67,6 @@ ERROR_CORRECTION_PERCENT = 5
 ENABLED = True
 # Optional PAR2 configuration
 # PAR2_DIR = /path/to/par2-store
-# PAR2_LAYOUT = by-backup
 # PAR2_RATIOs are meuasured as percentages. Same function as ERROR_CORRECTION_PERCENT
 # PAR2_RATIO_FULL = 10
 # PAR2_RATIO_DIFF = 5