WDP Part 1: Severity Field Specification

Severity.Component.Primary.Sequence -> CompactID
    ^         ^        ^        ^          ^
  Part 1    Part 2   Part 3   Part 4    Part 5

Severity.Component.Primary.Sequence -> CompactID
^^^^^^^^
Part 1: Single character indicating urgency (THIS DOCUMENT)

E.Auth.Token.001         - Missing authentication token
E.Parser.Syntax.003      - Invalid syntax in input
E.Database.Query.FAILED  - Database query failed
E.FileSystem.File.021    - File not found

B.Thread.Mutex.024       - Waiting for mutex lock
B.Io.Wait.TIMEOUT        - I/O operation blocked/timeout
B.Network.Connection.027 - Network connection unavailable
B.Database.Lock.024      - Database row locked by another transaction

C.Data.Integrity.025     - Data corruption detected
C.Memory.Exhausted.026   - Out of memory
C.Disk.Full.026          - Disk space exhausted
C.Security.Breach.008    - Security violation detected

W.Api.Deprecated.010     - API method deprecated
W.Cache.Miss.018         - Cache miss (degraded performance)
W.Config.Default.USED    - Using default configuration
W.Parser.Ambiguous.003   - Ambiguous syntax (guessing interpretation)

H.Usage.Tip.SUGGESTION   - Helpful usage suggestion
H.Perf.Optimization.001  - Performance optimization tip
H.Config.Recommended.001 - Recommended configuration
H.Security.BestPractice  - Security best practice

S.Auth.Login.SUCCESS     - Login successful
S.Upload.Complete.999    - File upload finished successfully
S.Transaction.Commit.999 - Transaction committed
S.Validation.Pass.999    - Validation passed

K.Build.Done.999         - Build completed
K.Migration.Finished.999 - Database migration finished
K.Backup.Complete.999    - Backup completed
K.BatchJob.Done.999      - Batch processing completed

I.Server.Startup.001     - Server starting up
I.Request.Received.001   - HTTP request received
I.Cache.Stats.001        - Cache statistics
I.Config.Loaded.001      - Configuration loaded

T.Function.Entry.001     - Function entered (profiling)
T.Timer.Start.001        - Timer started
T.Probe.Checkpoint.001   - Execution checkpoint
T.Variable.Dump.001      - Variable state dump

E, W, C, B, S, K, I, T, H

^[EWCBSHKIT]$

E  // valid
W  // valid
S  // valid

e  // invalid: lowercase not allowed
X  // invalid: not a defined severity
ER // invalid: multiple characters not allowed

T(0) < I(1) < K(2) < S(3) < H(4) < W(5) < C(6) < B(7) < E(8)

Show only priority >= 5:  W, C, B, E (warnings and above)
Show only priority >= 7:  B, E (blocking conditions only)
Show only priority >= 1:  All except Trace

Priority 8 (E): Page on-call engineer
Priority 7 (B): Alert operations team
Priority 6 (C): Email alerts
Priority 5 (W): Log aggregation
Priority 0-4: Standard logging

E.Auth.Token.001         → Cannot proceed without token
B.Thread.Mutex.024       → Waiting for lock release
E.Database.Connection.021 → Cannot query without connection

W.Api.Deprecated.010     → Can proceed, but API will be removed
C.Memory.Low.026         → System continues but at risk
S.Auth.Login.SUCCESS     → Operation succeeded, continue

Negative tone count: High → System unhealthy
Positive tone count: High → System healthy
Neutral tone: Informational only

Negative tone (E, B, C, W): Trigger alerts
Positive tone (S, K): Optional notifications
Neutral tone (H, I, T): Logging only

E.Auth.Token.001         - Missing authentication token
E.Auth.Token.003         - Invalid token format
E.Auth.Permission.008    - Permission denied

E.Parser.Syntax.003      - Invalid syntax in input
E.Parser.Token.001       - Unexpected token

E.Database.Query.FAILED  - Database query failed
E.Database.Connection.021 - Database not found

E.FileSystem.File.021    - File not found
E.FileSystem.File.008    - Permission denied

E.Network.Connection.028 - Host unreachable
E.Network.Timeout.017    - Connection timeout

B.Thread.Mutex.024       - Waiting for mutex lock
B.Thread.Deadlock.024    - Deadlock detected

B.Io.Wait.TIMEOUT        - I/O operation blocked/timeout
B.Io.Read.BLOCKED        - Read operation blocked

B.Network.Connection.027 - Network connection unavailable
B.Network.Retry.WAITING  - Waiting for retry

B.Database.Lock.024      - Database row locked
B.Database.Waiting.024   - Waiting for transaction

C.Data.Integrity.025     - Data corruption detected
C.Data.Checksum.025      - Checksum verification failed

C.Memory.Exhausted.026   - Out of memory
C.Memory.Leak.026        - Memory leak detected

C.Disk.Full.026          - Disk space exhausted
C.Disk.Failing.025       - Disk hardware failure detected

C.Security.Breach.008    - Security violation detected
C.Security.Intrusion.008 - Intrusion attempt detected

W.Api.Deprecated.010     - API method deprecated
W.Api.RateLimit.WARNING  - Approaching rate limit

W.Cache.Miss.018         - Cache miss (degraded performance)
W.Cache.Expiring.018     - Cache entries expiring soon

W.Config.Default.USED    - Using default configuration
W.Config.Missing.001     - Optional config missing

W.Parser.Ambiguous.003   - Ambiguous syntax (guessing)
W.Performance.Slow.017   - Operation slower than expected

H.Usage.Tip.SUGGESTION   - Helpful usage suggestion
H.Usage.Example.001      - Usage example

H.Perf.Optimization.001  - Performance optimization tip
H.Perf.Caching.001       - Consider enabling caching

H.Config.Recommended.001 - Recommended configuration
H.Config.BestPractice.001 - Configuration best practice

H.Security.BestPractice.001 - Security recommendation

S.Auth.Login.SUCCESS     - Login successful
S.Auth.Logout.SUCCESS    - Logout successful

S.Upload.Complete.999    - File upload finished successfully
S.Download.Complete.999  - Download successful

S.Transaction.Commit.999 - Transaction committed
S.Validation.Pass.999    - Validation passed

S.Payment.Success.999    - Payment processed successfully

K.Build.Done.999         - Build completed
K.Build.Success.999      - Build successful

K.Migration.Finished.999 - Database migration finished
K.Migration.Rollback.999 - Rollback completed

K.Backup.Complete.999    - Backup completed
K.Backup.Verified.999    - Backup verified

K.BatchJob.Done.999      - Batch processing completed
K.Import.Finished.999    - Data import finished

I.Server.Startup.001     - Server starting up
I.Server.Shutdown.001    - Server shutting down
I.Server.Ready.001       - Server ready to accept connections

I.Request.Received.001   - HTTP request received
I.Request.Processed.001  - Request processed

I.Cache.Stats.001        - Cache statistics
I.Cache.Hit.001          - Cache hit

I.Config.Loaded.001      - Configuration loaded
I.Config.Reloaded.001    - Configuration reloaded

T.Function.Entry.001     - Function entered (profiling)
T.Function.Exit.001      - Function exited

T.Timer.Start.001        - Timer started
T.Timer.Stop.001         - Timer stopped

T.Probe.Checkpoint.001   - Execution checkpoint
T.Probe.State.001        - State snapshot

T.Variable.Dump.001      - Variable state dump
T.Memory.Allocation.001  - Memory allocation trace

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Severity {
    Error = 8,      // E
    Blocked = 7,    // B
    Critical = 6,   // C
    Warning = 5,    // W
    Help = 4,       // H
    Success = 3,    // S
    Completed = 2,  // K
    Info = 1,       // I
    Trace = 0,      // T
}

impl Severity {
    pub fn code(&self) -> char {
        match self {
            Severity::Error => 'E',
            Severity::Blocked => 'B',
            Severity::Critical => 'C',
            Severity::Warning => 'W',
            Severity::Help => 'H',
            Severity::Success => 'S',
            Severity::Completed => 'K',
            Severity::Info => 'I',
            Severity::Trace => 'T',
        }
    }
    
    pub fn priority(&self) -> u8 {
        *self as u8
    }
    
    pub fn is_blocking(&self) -> bool {
        matches!(self, Severity::Error | Severity::Blocked)
    }
    
    pub fn tone(&self) -> Tone {
        match self {
            Severity::Error | Severity::Blocked | 
            Severity::Critical | Severity::Warning => Tone::Negative,
            Severity::Success | Severity::Completed => Tone::Positive,
            Severity::Help | Severity::Info | Severity::Trace => Tone::Neutral,
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Tone {
    Negative,  // Problems/concerns
    Positive,  // Success/completion
    Neutral,   // Informational
}

from enum import IntEnum

class Severity(IntEnum):
    TRACE = 0      # T
    INFO = 1       # I
    COMPLETED = 2  # K
    SUCCESS = 3    # S
    HELP = 4       # H
    WARNING = 5    # W
    CRITICAL = 6   # C
    BLOCKED = 7    # B
    ERROR = 8      # E
    
    def code(self) -> str:
        codes = {
            0: 'T', 1: 'I', 2: 'K', 3: 'S', 4: 'H',
            5: 'W', 6: 'C', 7: 'B', 8: 'E'
        }
        return codes[self.value]
    
    def is_blocking(self) -> bool:
        return self in (Severity.ERROR, Severity.BLOCKED)
    
    def tone(self) -> str:
        if self in (Severity.ERROR, Severity.BLOCKED, 
                    Severity.CRITICAL, Severity.WARNING):
            return 'negative'
        elif self in (Severity.SUCCESS, Severity.COMPLETED):
            return 'positive'
        else:
            return 'neutral'

enum Severity {
  Trace = 0,      // T
  Info = 1,       // I
  Completed = 2,  // K
  Success = 3,    // S
  Help = 4,       // H
  Warning = 5,    // W
  Critical = 6,   // C
  Blocked = 7,    // B
  Error = 8,      // E
}

function severityCode(s: Severity): string {
  const codes: Record<Severity, string> = {
    [Severity.Trace]: 'T',
    [Severity.Info]: 'I',
    [Severity.Completed]: 'K',
    [Severity.Success]: 'S',
    [Severity.Help]: 'H',
    [Severity.Warning]: 'W',
    [Severity.Critical]: 'C',
    [Severity.Blocked]: 'B',
    [Severity.Error]: 'E',
  };
  return codes[s];
}

function severityTone(s: Severity): string {
  if ([Severity.Error, Severity.Blocked, 
       Severity.Critical, Severity.Warning].includes(s)) {
    return 'negative';
  } else if ([Severity.Success, Severity.Completed].includes(s)) {
    return 'positive';
  } else {
    return 'neutral';
  }
}

fn parse_severity(c: char) -> Result<Severity, Error> {
    match c {
        'E' => Ok(Severity::Error),
        'B' => Ok(Severity::Blocked),
        'C' => Ok(Severity::Critical),
        'W' => Ok(Severity::Warning),
        'H' => Ok(Severity::Help),
        'S' => Ok(Severity::Success),
        'K' => Ok(Severity::Completed),
        'I' => Ok(Severity::Info),
        'T' => Ok(Severity::Trace),
        _ => Err(Error::InvalidSeverity(c)),
    }
}

fn filter_by_min_priority(codes: &[ErrorCode], min_priority: u8) -> Vec<ErrorCode> {
    codes.iter()
        .filter(|c| c.severity.priority() >= min_priority)
        .cloned()
        .collect()
}

// Usage:
let errors_and_warnings = filter_by_min_priority(&all_codes, 5);
let blocking_only = filter_by_min_priority(&all_codes, 7);

pub fn tone(&self) -> Tone {
    match self {
        Severity::Error | Severity::Blocked | 
        Severity::Critical | Severity::Warning => Tone::Negative,
        Severity::Success | Severity::Completed => Tone::Positive,
        Severity::Help | Severity::Info | Severity::Trace => Tone::Neutral,
    }
}

// Get all problems
let problems = errors.iter()
    .filter(|e| e.severity.tone() == Tone::Negative)
    .collect::<Vec<_>>();

// Get all successes
let successes = errors.iter()
    .filter(|e| e.severity.tone() == Tone::Positive)
    .collect::<Vec<_>>();

fn system_health(errors: &[Error]) -> HealthScore {
    let negative = errors.iter()
        .filter(|e| e.severity.tone() == Tone::Negative)
        .count();
    let positive = errors.iter()
        .filter(|e| e.severity.tone() == Tone::Positive)
        .count();
    
    HealthScore {
        negative_count: negative,
        positive_count: positive,
        health_ratio: positive as f64 / (negative + positive) as f64,
    }
}

match error.severity.tone() {
    Tone::Negative => send_alert_to_oncall(&error),
    Tone::Positive => send_notification(&error),
    Tone::Neutral => log_only(&error),
}

fn severity_color(severity: &Severity) -> &'static str {
    match severity.tone() {
        Tone::Negative => "red",
        Tone::Positive => "green",
        Tone::Neutral => "blue",
    }
}

E.Auth.Token.001            - Error: Missing token
E.Database.Connection.021   - Error: Database not found
E.Parser.Syntax.003         - Error: Invalid syntax

B.Thread.Lock.024           - Blocked: Waiting for lock
B.Network.Connection.027    - Blocked: Network unavailable
B.Io.Timeout.017            - Blocked: I/O timeout

C.Data.Corruption.025       - Critical: Data corrupted
C.Memory.Exhausted.026      - Critical: Out of memory
C.Security.Breach.008       - Critical: Security violation

W.Api.Deprecated.010        - Warning: API deprecated
W.Cache.Miss.018            - Warning: Cache miss
W.Config.Missing.001        - Warning: Config missing

H.Usage.Tip.001             - Help: Usage suggestion
H.Perf.Optimization.001     - Help: Performance tip
H.Config.Recommended.001    - Help: Recommended config

S.Auth.Login.999            - Success: Login successful
S.Upload.Complete.999       - Success: Upload complete
S.Validation.Pass.999       - Success: Validation passed

K.Build.Done.999            - Completed: Build finished
K.Migration.Finished.999    - Completed: Migration done
K.Backup.Complete.999       - Completed: Backup complete

I.Server.Startup.001        - Info: Server starting
I.Request.Received.001      - Info: Request received
I.Config.Loaded.001         - Info: Configuration loaded

T.Function.Entry.001        - Trace: Function entered
T.Timer.Start.001           - Trace: Timer started
T.Checkpoint.001            - Trace: Checkpoint reached

T(0) < I(1) < K(2) < S(3) < H(4) < W(5) < C(6) < B(7) < E(8)

^[EWCBSHKIT]$