greggd 1.0.14

Lightweight Linux, macOS, and Windows metrics daemon that exposes a read-only JSON API for the gregg client.
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! Detected startup-manager state for restart/update decisions.

#[cfg(all(unix, target_os = "macos"))]
use super::launchd::{launchd_is_loaded, launchd_plist_exists};
#[cfg(all(unix, target_os = "linux"))]
use super::method::is_systemd_environment;
#[cfg(all(unix, target_os = "linux"))]
use super::systemd::{systemd_is_active, systemd_unit_exists};
use std::fmt;

// ── Manager state detection for restart / update ──────────────────────────
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StartupState {
    SystemdActive,
    SystemdInstalledStopped,
    LaunchdLoaded,
    LaunchdInstalledUnloaded,
    WindowsServiceRunning,
    WindowsServiceStopped,
    UnmanagedOrCron,
}
impl fmt::Display for StartupState {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s = match self {
            Self::SystemdActive => "systemd-active",
            Self::SystemdInstalledStopped => "systemd-installed-stopped",
            Self::LaunchdLoaded => "launchd-loaded",
            Self::LaunchdInstalledUnloaded => "launchd-installed-unloaded",
            Self::WindowsServiceRunning => "windows-running",
            Self::WindowsServiceStopped => "windows-stopped",
            Self::UnmanagedOrCron => "unmanaged-or-cron",
        };
        write!(f, "{s}")
    }
}

/// Pure helper: decide systemd state from injected probes.
pub fn systemd_state_with(unit_exists: bool, is_active: bool) -> StartupState {
    if is_active {
        StartupState::SystemdActive
    } else if unit_exists {
        StartupState::SystemdInstalledStopped
    } else {
        StartupState::UnmanagedOrCron
    }
}

/// Pure helper: decide launchd state from injected probes.
pub fn launchd_state_with(plist_exists: bool, is_loaded: bool) -> StartupState {
    if is_loaded {
        StartupState::LaunchdLoaded
    } else if plist_exists {
        StartupState::LaunchdInstalledUnloaded
    } else {
        StartupState::UnmanagedOrCron
    }
}
pub fn startup_state() -> StartupState {
    #[cfg(target_os = "windows")]
    {
        // Delegate to existing SCM manager when on Windows.
        match crate::service::platform_service_manager().is_active() {
            Ok(true) => StartupState::WindowsServiceRunning,
            Ok(false) => StartupState::WindowsServiceStopped,
            Err(_) => StartupState::UnmanagedOrCron,
        }
    }
    #[cfg(all(unix, target_os = "macos"))]
    {
        let plist_exists = launchd_plist_exists();
        let loaded = launchd_is_loaded();
        let state = launchd_state_with(plist_exists, loaded);
        if state != StartupState::UnmanagedOrCron {
            return state;
        }
        // Not launchd-managed: fall through to systemd/cron check.
        // On macOS, systemd is not relevant, so return unmanaged.
        StartupState::UnmanagedOrCron
    }
    #[cfg(all(unix, target_os = "linux"))]
    {
        let unit_exists = systemd_unit_exists();
        let active = if unit_exists || is_systemd_environment() {
            systemd_is_active()
        } else {
            false
        };
        let state = systemd_state_with(unit_exists, active);
        if state != StartupState::UnmanagedOrCron {
            return state;
        }
        StartupState::UnmanagedOrCron
    }
    #[cfg(all(unix, not(any(target_os = "linux", target_os = "macos"))))]
    {
        StartupState::UnmanagedOrCron
    }
}
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn startup_state_helpers() {
        assert_eq!(systemd_state_with(true, true), StartupState::SystemdActive);
        assert_eq!(
            systemd_state_with(true, false),
            StartupState::SystemdInstalledStopped
        );
        assert_eq!(
            systemd_state_with(false, false),
            StartupState::UnmanagedOrCron
        );
        assert_eq!(launchd_state_with(false, true), StartupState::LaunchdLoaded);
        assert_eq!(
            launchd_state_with(true, false),
            StartupState::LaunchdInstalledUnloaded
        );
    }
}