pipe-audit-core 0.1.12

Universal data validation and compliance audit engine
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
96
97

//! Centralized logging functionality for engine operations

use crate::logging::schema::{AuditLogEntry, Executor};
use crate::logging::writer::log_event;
use chrono::Utc;
use hostname;
use whoami;

/// Centralized logging function for all engine operations
/// Logs full details to crypto-signed audit log and returns PII-safe console message
pub fn log_action(
    event: &str,
    details: Option<&str>,
    contract: Option<&str>,
    version: Option<&str>,
    target: Option<&str>,
) -> String {
    let hostname = hostname::get()
        .unwrap_or_default()
        .to_string_lossy()
        .to_string();

    let executor = Executor {
        user: whoami::username(),
        host: hostname,
    };

    let entry = AuditLogEntry {
        timestamp: Utc::now().to_rfc3339(),
        level: "AUDIT",
        event,
        contract: contract.map(|name| crate::logging::schema::Contract {
            name,
            version: version.unwrap_or("N/A"),
        }),
        target: target.map(|file| crate::logging::schema::Target {
            file,
            column: None,
            rule: None,
        }),
        results: None,
        executor,
        details,
        summary: None,
    };

    log_event(&entry);

    // Return PII-safe message based on event type
    match event {
        "contracts_listed" => "📋 Contracts listed".to_string(),
        "contract_retrieved" => {
            format!("📄 Contract '{}' retrieved", contract.unwrap_or("unknown"))
        }
        "contract_validated" => {
            format!("✅ Contract '{}' validated", contract.unwrap_or("unknown"))
        }
        "profiles_listed" => "👤 Profiles listed".to_string(),
        "profile_tested" => {
            if let Some(detail) = details {
                if detail.contains("connected=true") {
                    format!(
                        "✅ Profile '{}' connectivity verified",
                        target.unwrap_or("unknown")
                    )
                } else if detail.contains("exists=true") {
                    format!("❌ Profile '{}' test failed", target.unwrap_or("unknown"))
                } else {
                    format!("❌ Profile '{}' not found", target.unwrap_or("unknown"))
                }
            } else {
                "👤 Profile tested".to_string()
            }
        }
        "logs_verified" => {
            if let Some(detail) = details {
                if detail.contains("valid=true") {
                    "✅ Log integrity verified".to_string()
                } else {
                    "❌ Log integrity check failed".to_string()
                }
            } else {
                "📊 Logs verified".to_string()
            }
        }
        "contract_validation_started" => format!(
            "🚀 Starting validation for '{}'",
            contract.unwrap_or("unknown")
        ),
        "contract_validation_completed" => format!(
            "✅ Validation completed for '{}'",
            contract.unwrap_or("unknown")
        ),
        "health_check" => "🏥 Health check completed".to_string(),
        _ => format!("📝 Action: {}", event),
    }
}