FreedomLogger 1.1.0

A professional, reusable logging library with pattern formatting, log rotation, and file management
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

// File: src/error/types.rs

/*
Error types for FreedomLogger internal operations.
These errors represents failures that can occur within the logger itself.
When these errors occur, they are silently handled and optionally.
Written to a separate error log fie for debugging.
 */
use std::fmt;

/// Represents all possible internal failures of the FreedomLogger.
#[derive(Debug, Clone, PartialEq)]
pub enum LoggerError {
    /*
    Failed to create the log file
    Occurs when: file doesn't exist and creation fails
     */
    FileCreationFailed {
        path: String,
        reason: String,
    },

    /*
    Failed to create the necessary directories
    Occurs when: directory doesn't exist and creation fails
     */
    DirectoryCreationFailed {
        path: String,
        reason: String,
    },

    /*
    Not enough permissions to write to log file
    Occurs when: file exists but can't write to it
     */
    WritePermissionDenied {
        path: String,
    },

    /*
    Disk space insufficient for writing
    Occurs when: write operation fails due disk full
     */
    DiskFull {
        path: String,
        bytes_attempted: usize,
    },

    /*
    Log rotation operation failed
    Occurs when: log rotation fails
     */
    RotationFailed {
        current_file: String,
        backup_file: String,
        reason: String,
    },
}

impl fmt::Display for LoggerError {
    /*
    Human-readable error messages for debugging
    These will be written to the error log file.
     */
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            LoggerError::FileCreationFailed {path, reason} => {
                write!(f, "Failed to create log file '{}' : {}", path, reason)
            }
            LoggerError::DirectoryCreationFailed {path,reason} => {
                write!(f, "Failed to create directory '{}': {}", path, reason)
            }

            LoggerError::WritePermissionDenied {path} => {
                write!(f, "Persmission denied writing to '{}'", path)
            }

            LoggerError::DiskFull {path, bytes_attempted} => {
                write!(f, "Disk full: could not write {} bytes to '{}'", bytes_attempted, path)
            }

            LoggerError::RotationFailed {current_file, backup_file, reason} => {
                write!(f, "Log rotation failed: '{}' -> '{}': {}", current_file, backup_file, reason)
            }
        }
    }
}

impl std::error::Error for LoggerError {}

/*
Result type for logging operations
Used internally - user never sees this result
 */
pub type LoggerResult<T> = Result<T, LoggerError>;