grafos_profile/

timeline.rs

//! Lease timeline — Gantt chart of all leases held over time.
//!
//! Reconstructs per-lease lifecycles from [`ResourceSpan`] data and renders
//! as an interactive HTML Gantt chart with utilization overlay.

use alloc::collections::BTreeMap;
use alloc::string::String;
use alloc::vec::Vec;

use grafos_observe::event::ResourceType;

use crate::recording::ProfileRecording;

/// A single lease's lifecycle entry for the timeline.
#[derive(Debug, Clone)]
pub struct LeaseTimelineEntry {
    /// Lease ID.
    pub lease_id: u128,
    /// Dominant resource type (inferred from operations).
    pub resource_type: Option<ResourceType>,
    /// First time this lease was observed (Unix microseconds).
    pub acquired_at: u64,
    /// Last time this lease was observed (Unix microseconds).
    pub released_at: u64,
    /// Total bytes associated with this lease (from lease_cost / duration approximation).
    pub capacity_approx: u64,
    /// Peak bytes used (max of bytes_read + bytes_written across spans).
    pub peak_usage: u64,
    /// Total operations on this lease.
    pub total_ops: u64,
    /// Total acquire wait time across all spans touching this lease.
    pub total_acquire_wait_us: u64,
    /// Lease cost in byte-seconds.
    pub lease_cost_byte_secs: u64,
}

impl LeaseTimelineEntry {
    /// Utilization percentage: peak_usage / capacity_approx.
    pub fn utilization_pct(&self) -> f64 {
        if self.capacity_approx == 0 {
            0.0
        } else {
            (self.peak_usage as f64 / self.capacity_approx as f64) * 100.0
        }
    }

    /// Duration in microseconds.
    pub fn duration_us(&self) -> u64 {
        self.released_at.saturating_sub(self.acquired_at)
    }
}

/// Lease timeline (Gantt chart) computed from a recording.
#[derive(Debug, Clone)]
pub struct LeaseTimeline {
    /// Per-lease lifecycle entries, sorted by acquired_at.
    pub entries: Vec<LeaseTimelineEntry>,
    /// Overall start time (Unix microseconds).
    pub start_time: u64,
    /// Overall end time (Unix microseconds).
    pub end_time: u64,
}

impl LeaseTimeline {
    /// Build a timeline from a profile recording.
    pub fn from_recording(rec: &ProfileRecording) -> Self {
        let mut lease_map: BTreeMap<u128, LeaseTimelineEntry> = BTreeMap::new();

        for span in &rec.spans {
            for &lease_id in &span.lease_ids {
                let entry = lease_map
                    .entry(lease_id)
                    .or_insert_with(|| LeaseTimelineEntry {
                        lease_id,
                        resource_type: None,
                        acquired_at: span.start_time_unix_us,
                        released_at: span.end_time_unix_us,
                        capacity_approx: 0,
                        peak_usage: 0,
                        total_ops: 0,
                        total_acquire_wait_us: 0,
                        lease_cost_byte_secs: 0,
                    });

                // Update time bounds
                if span.start_time_unix_us < entry.acquired_at {
                    entry.acquired_at = span.start_time_unix_us;
                }
                if span.end_time_unix_us > entry.released_at {
                    entry.released_at = span.end_time_unix_us;
                }

                // Track peak usage
                let span_usage = span.bytes_read + span.bytes_written;
                if span_usage > entry.peak_usage {
                    entry.peak_usage = span_usage;
                }

                // Accumulate ops
                let span_ops: u64 = span.ops.iter().map(|(_, c)| c).sum();
                entry.total_ops += span_ops;

                // Accumulate cost (proportional to this lease's share)
                if !span.lease_ids.is_empty() {
                    let share = span.lease_cost_byte_secs / span.lease_ids.len() as u64;
                    entry.lease_cost_byte_secs += share;
                }

                // Accumulate acquire wait
                if !span.lease_ids.is_empty() {
                    let wait_share = span.lease_acquire_wait_us / span.lease_ids.len() as u64;
                    entry.total_acquire_wait_us += wait_share;
                }

                // Infer resource type from ops
                if entry.resource_type.is_none() && !span.ops.is_empty() {
                    // Use the resource type with the most ops
                    let mut type_counts: BTreeMap<String, u64> = BTreeMap::new();
                    for &(ref op_key, count) in &span.ops {
                        let key = alloc::format!("{}", op_key.resource_type);
                        *type_counts.entry(key).or_insert(0) += count;
                    }
                    if let Some((key, _)) = type_counts.iter().max_by_key(|(_, &v)| v) {
                        entry.resource_type = match key.as_str() {
                            "mem" => Some(ResourceType::Mem),
                            "block" => Some(ResourceType::Block),
                            "gpu" => Some(ResourceType::Gpu),
                            "cpu" => Some(ResourceType::Cpu),
                            _ => None,
                        };
                    }
                }
            }
        }

        // Approximate capacity from cost / duration
        for entry in lease_map.values_mut() {
            let duration_secs = entry.duration_us() as f64 / 1_000_000.0;
            if duration_secs > 0.0 {
                entry.capacity_approx = (entry.lease_cost_byte_secs as f64 / duration_secs) as u64;
            }
        }

        let mut entries: Vec<LeaseTimelineEntry> = lease_map.into_values().collect();
        entries.sort_by_key(|e| e.acquired_at);

        let start_time = entries.first().map(|e| e.acquired_at).unwrap_or(0);
        let end_time = entries.last().map(|e| e.released_at).unwrap_or(0);

        LeaseTimeline {
            entries,
            start_time,
            end_time,
        }
    }

    /// Render as self-contained HTML Gantt chart.
    #[cfg(feature = "html")]
    pub fn render_html(&self) -> String {
        let mut html = String::new();
        html.push_str("<!DOCTYPE html>\n<html>\n<head>\n");
        html.push_str("<meta charset=\"utf-8\">\n");
        html.push_str("<title>grafOS Lease Timeline</title>\n");
        html.push_str("<style>\n");
        html.push_str("body { font-family: monospace; margin: 0; padding: 20px; background: #1a1a2e; color: #eee; }\n");
        html.push_str("h1 { font-size: 18px; }\n");
        html.push_str(".timeline { position: relative; margin-top: 20px; }\n");
        html.push_str(".lease-row { position: relative; height: 28px; margin-bottom: 4px; }\n");
        html.push_str(".lease-label { position: absolute; left: 0; width: 120px; font-size: 11px; line-height: 28px; }\n");
        html.push_str(".lease-bar-bg { position: absolute; left: 130px; height: 24px; top: 2px; border-radius: 3px; opacity: 0.4; }\n");
        html.push_str(".lease-bar-fg { position: absolute; left: 130px; height: 24px; top: 2px; border-radius: 3px; }\n");
        html.push_str(
            ".tooltip { position: fixed; background: #333; color: #fff; padding: 8px 12px; ",
        );
        html.push_str("border-radius: 4px; font-size: 12px; pointer-events: none; z-index: 100; white-space: pre-wrap; }\n");
        html.push_str("</style>\n</head>\n<body>\n");
        html.push_str("<h1>grafOS Lease Timeline</h1>\n");

        let total_duration = self.end_time.saturating_sub(self.start_time);
        let chart_width = 800.0; // pixels for the bar area

        html.push_str(&alloc::format!(
            "<p>Duration: {} us | {} leases</p>\n",
            total_duration,
            self.entries.len()
        ));

        html.push_str("<div class=\"timeline\">\n");

        for entry in &self.entries {
            let offset_frac = if total_duration > 0 {
                (entry.acquired_at - self.start_time) as f64 / total_duration as f64
            } else {
                0.0
            };
            let width_frac = if total_duration > 0 {
                entry.duration_us() as f64 / total_duration as f64
            } else {
                1.0
            };
            let util_frac = if entry.capacity_approx > 0 {
                (entry.peak_usage as f64 / entry.capacity_approx as f64).min(1.0)
            } else {
                0.0
            };

            let bg_color = resource_type_color(entry.resource_type);
            let x = 130.0 + offset_frac * chart_width;
            let w_bg = (width_frac * chart_width).max(2.0);
            let w_fg = w_bg * util_frac;

            let lease_hex = alloc::format!("{:x}", entry.lease_id);
            let short_id = if lease_hex.len() > 8 {
                &lease_hex[..8]
            } else {
                &lease_hex
            };

            html.push_str("<div class=\"lease-row\">\n");
            html.push_str(&alloc::format!(
                "  <span class=\"lease-label\">{}</span>\n",
                short_id
            ));
            html.push_str(&alloc::format!(
                "  <div class=\"lease-bar-bg\" style=\"left:{x:.1}px;width:{w_bg:.1}px;background:{bg_color}\" \
                 data-id=\"{lease_hex}\" data-util=\"{:.1}\" data-ops=\"{}\" data-cost=\"{}\"></div>\n",
                entry.utilization_pct(),
                entry.total_ops,
                entry.lease_cost_byte_secs,
            ));
            html.push_str(&alloc::format!(
                "  <div class=\"lease-bar-fg\" style=\"left:{x:.1}px;width:{w_fg:.1}px;background:{bg_color}\"></div>\n",
            ));
            html.push_str("</div>\n");
        }

        html.push_str("</div>\n");

        // Tooltip JS
        html.push_str("<div class=\"tooltip\" id=\"tip\" style=\"display:none\"></div>\n");
        html.push_str("<script>\n");
        html.push_str("document.querySelectorAll('.lease-bar-bg').forEach(b => {\n");
        html.push_str("  b.addEventListener('mouseenter', e => {\n");
        html.push_str("    const t = document.getElementById('tip');\n");
        html.push_str("    t.textContent = `Lease: ${b.dataset.id}\\nUtilization: ${b.dataset.util}%\\nOps: ${b.dataset.ops}\\nCost: ${b.dataset.cost} byte-secs`;\n");
        html.push_str("    t.style.display = 'block';\n");
        html.push_str("  });\n");
        html.push_str("  b.addEventListener('mouseleave', () => document.getElementById('tip').style.display = 'none');\n");
        html.push_str("  b.addEventListener('mousemove', e => {\n");
        html.push_str("    const t = document.getElementById('tip');\n");
        html.push_str(
            "    t.style.left = (e.clientX + 10) + 'px'; t.style.top = (e.clientY + 10) + 'px';\n",
        );
        html.push_str("  });\n");
        html.push_str("});\n");
        html.push_str("</script>\n");
        html.push_str("</body>\n</html>\n");

        html
    }
}

fn resource_type_color(rt: Option<ResourceType>) -> &'static str {
    match rt {
        Some(ResourceType::Mem) => "#4a90d9",
        Some(ResourceType::Block) => "#50c878",
        Some(ResourceType::Gpu) => "#ff8c42",
        Some(ResourceType::Cpu) => "#9b59b6",
        Some(ResourceType::Net) => "#e74c3c",
        None => "#999",
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use grafos_observe::event::{OpType, ResourceType};
    use grafos_observe::span::ResourceSpan;
    use grafos_observe::trace::TraceContext;

    fn test_ctx() -> TraceContext {
        let mut bytes = [0u8; 24];
        for (i, b) in bytes.iter_mut().enumerate() {
            *b = (i as u8).wrapping_add(0x42);
        }
        TraceContext::new_root(&bytes)
    }

    #[test]
    fn timeline_three_overlapping_leases() {
        let ctx = test_ctx();
        let c1 = ctx.child(&[0xAA; 8]);
        let c2 = ctx.child(&[0xBB; 8]);

        // Span 1 touches lease 1 and 2
        let mut s1 = ResourceSpan::new("op_a", ctx);
        s1.start_time_unix_us = 1_000_000;
        s1.end_time_unix_us = 3_000_000;
        s1.add_lease_id(1);
        s1.add_lease_id(2);
        s1.bytes_read = 4096;
        s1.lease_cost_byte_secs = 200;
        s1.record_op(ResourceType::Mem, OpType::Read, 10);

        // Span 2 touches lease 2 and 3
        let mut s2 = ResourceSpan::new("op_b", c1);
        s2.start_time_unix_us = 2_000_000;
        s2.end_time_unix_us = 4_000_000;
        s2.add_lease_id(2);
        s2.add_lease_id(3);
        s2.bytes_written = 8192;
        s2.lease_cost_byte_secs = 300;
        s2.record_op(ResourceType::Block, OpType::WriteBlock, 5);

        // Span 3 touches lease 3 only
        let mut s3 = ResourceSpan::new("op_c", c2);
        s3.start_time_unix_us = 3_000_000;
        s3.end_time_unix_us = 5_000_000;
        s3.add_lease_id(3);
        s3.bytes_read = 2048;
        s3.lease_cost_byte_secs = 100;
        s3.record_op(ResourceType::Mem, OpType::Read, 3);

        let rec = ProfileRecording::from_spans(vec![s1, s2, s3]);
        let tl = LeaseTimeline::from_recording(&rec);

        assert_eq!(tl.entries.len(), 3);

        // Lease 1: only in s1
        let l1 = tl.entries.iter().find(|e| e.lease_id == 1).unwrap();
        assert_eq!(l1.acquired_at, 1_000_000);
        assert_eq!(l1.released_at, 3_000_000);

        // Lease 2: in s1 and s2
        let l2 = tl.entries.iter().find(|e| e.lease_id == 2).unwrap();
        assert_eq!(l2.acquired_at, 1_000_000);
        assert_eq!(l2.released_at, 4_000_000);

        // Lease 3: in s2 and s3
        let l3 = tl.entries.iter().find(|e| e.lease_id == 3).unwrap();
        assert_eq!(l3.acquired_at, 2_000_000);
        assert_eq!(l3.released_at, 5_000_000);

        // Timeline bounds
        assert_eq!(tl.start_time, 1_000_000);
        assert_eq!(tl.end_time, 5_000_000);
    }

    #[cfg(feature = "html")]
    #[test]
    fn timeline_html_structure() {
        let ctx = test_ctx();
        let mut span = ResourceSpan::new("test", ctx);
        span.start_time_unix_us = 0;
        span.end_time_unix_us = 1_000_000;
        span.add_lease_id(42);
        span.lease_cost_byte_secs = 100;

        let rec = ProfileRecording::from_spans(vec![span]);
        let tl = LeaseTimeline::from_recording(&rec);
        let html = tl.render_html();

        assert!(html.contains("<!DOCTYPE html>"));
        assert!(html.contains("Lease Timeline"));
        assert!(html.contains("</html>"));
    }
}