graph TD
    F[frontend] -->|236 calls| CART[cartservice]
    F -->|184 calls| PROD[productcatalogservice]
    F -->|124 calls| REC[recommendationservice]
    F -->|89 calls| CHECK[checkoutservice]
    CART -->|172 calls| REDIS[redis-cart]
    PROD -->|184 calls| AD[adservice]
    CHECK -->|89 calls| SHIP[shippingservice]
    CHECK -->|61 calls| PAY[paymentservice]
    CHECK -->|46 calls| EMAIL[emailservice]
    CHECK -->|26 calls| CURR[currencyservice]
    SHIP -->|89 calls| EMAIL

flowchart LR
    A["📄 sample_traces.json<br/>300 traces"] --> B["🔄 Parse traces<br/>find parent-child links"]
    B --> C["🧠 Build DiGraph<br/>nodes=services, edges=calls"]
    C --> D["🔍 Anomaly check<br/>per-service P95, flag >2× slower"]
    D --> E["🎨 Render HTML<br/>orange nodes, yellow text"]
    E --> F["🌐 topology.html<br/>open in browser!"]

graph LR
    subgraph "hops=0 (just cartservice)"
        C0[cartservice]
    end

    subgraph "hops=1 (+ direct neighbours)"
        C1[cartservice] --> F1[frontend]
        C1 --> R1[redis-cart]
    end

    subgraph "hops=2 (+ next ring out)"
        C2[cartservice] --> F2[frontend]
        C2 --> R2[redis-cart]
        F2 --> P2[productcatalogservice]
        F2 --> CH2[checkoutservice]
        F2 --> RC2[recommendationservice]
    end

flowchart TD
    subgraph sync["🟢 Sync calls (fast RPCs)"]
        S1["frontend → cartservice<br/>P99 = 58ms"] -->|"58/1000/60 × 10 = 0.01"| S2["clamped to 1.0 min"]
        S3["cartservice → redis-cart<br/>P99 = 6ms"] -->|"6/1000/60 × 10 = 0.001"| S4["clamped to 1.0 min"]
    end

    subgraph async["🟠 Async calls (queues/email)"]
        A1["shippingservice → email<br/>P99 = 120,000ms"] -->|"120/60 × 10 = 20"| A2["23.9 min"]
    end

    sync --> LAG["lag_windows.json → cross-correlation<br/>causal analysis pipeline"]
    async --> LAG

flowchart TD
    SRC["📡 Trace Source<br/>Jaeger API  OR  sample_traces.json"] --> FETCH

    subgraph FETCH["Fetcher (Component 1.1)"]
        F1["Paginate API, rate-limit 100ms"]
        F2["Parse JSON → Span/Trace objects"]
        F3["Normalise parentSpanID: '' → None"]
        F4["Convert µs timestamps"]
    end

    FETCH --> BUILD

    subgraph BUILD["Graph Builder (Component 1.2)"]
        B1["For each trace: build span_map"]
        B2["Match child → parent span"]
        B3["Record edge: parent.svc → child.svc"]
        B4["Store: weight, durations, avg, P50, P95, P99"]
    end

    BUILD --> ANOM
    BUILD --> LAG

    subgraph ANOM["Anomaly Highlighter (1.3)"]
        A1["Per service: collect all durations"]
        A2["Compute P95 baseline"]
        A3["Count spans > 2× P95"]
        A4["Score → healthy | degraded | critical"]
    end

    subgraph LAG["Lag Window Computer (1.4)"]
        L1["Per edge: P99 of durations"]
        L2["Convert ms → minutes × 10"]
        L3["Clamp between 1.0 and 30.0"]
    end

    ANOM --> RENDER
    LAG --> LAG_FILE["lag_windows.json<br/>(→ causal analysis)"]

    subgraph RENDER["Renderer (Component 1.5)"]
        R1["Custom vis.js HTML"]
        R2["Orange nodes + yellow text"]
        R3["Side panel, search, tooltips"]
        R4["Dark theme, glow shadows"]
    end

    RENDER --> OUT["topology.html<br/>Open in browser!"]

graph LR
    subgraph Core["Core Logic"]
        direction TB
        MODELS["models/<br/>span.py + trace.py<br/>@dataclass contracts"]
        FETCHER["fetcher/<br/>jaeger_client.py<br/>HTTP → Span/Trace"]
        GRAPH["graph/<br/>builder.py<br/>anomalies.py<br/>lag_windows.py"]
    end

    subgraph Output["Output Layer"]
        direction TB
        RENDERER["renderer/<br/>interactive.py<br/>static.py"]
        EXPORT["export/<br/>json_exporter.py<br/>dot_exporter.py"]
    end

    subgraph Interface["User Interface"]
        CLI["cli/main.py<br/>Click: render, export,<br/>lag-windows"]
    end

    MODELS --> FETCHER --> GRAPH
    GRAPH --> RENDERER
    GRAPH --> EXPORT
    CLI --> FETCHER --> GRAPH
    GRAPH --> RENDERER --> HTML["topology.html"]
    GRAPH --> EXPORT --> JSON["graph.json<br/>graph.dot"]

classDiagram
    class Span {
        +str trace_id
        +str span_id
        +str? parent_id
        +str service_name
        +str operation_name
        +int start_time_micros
        +int duration_micros
        +bool is_error
        +dict tags
        +float duration_ms
        +float duration_s
        +bool is_root
        Normalises: "0","" → None
    }

    class Trace {
        +str trace_id
        +list~Span~ spans
        +str? root_service
        +int num_spans
        +bool is_simple
        +dict~str,Span~ span_map
        O(1) parent lookup
    }

    class DiGraph {
        +set~str~ nodes
        +dict edges
        Per edge: weight, durations,
        avg_ms, p50_ms, p95_ms, p99_ms,
        min_ms, max_ms
    }

    class LagWindows {
        +dict edge → minutes
        1.0 min (sync RPCs)
        23.9 min (async queues)
    }

    Span "*" -- "1" Trace : contained in
    Trace "*" -- "1" DiGraph : builds
    DiGraph "1" -- "1" LagWindows : computes

flowchart TD
    START["For each service in the graph"] --> GATHER["Gather every span duration<br/>involving this service<br/>(all edges in + out)"]
    GATHER --> BASELINE["Find the P95 — the speed<br/>that 95% of requests are<br/>faster than"]
    BASELINE --> THRESHOLD["Double it: 2 × P95<br/>Anything slower than this<br/>is 'anomalous'"]
    THRESHOLD --> COUNT["Count: how many spans<br/>crossed this line?"]
    COUNT --> SCORE["Score = anomalous ÷ total"]

    SCORE --> CHECK{"What's the score?"}
    CHECK -->|"< 0.05 (less than 5%)"| HEALTHY["🟢 HEALTHY<br/>Everything looks normal"]
    CHECK -->|"0.05 to 0.15"| DEGRADED["🟡 DEGRADED<br/>Something's a bit off"]
    CHECK -->|"> 0.15 (more than 15%)"| CRITICAL["🔴 CRITICAL<br/>This service needs attention"]

    HEALTHY --> EXAMPLE
    DEGRADED --> EXAMPLE
    CRITICAL --> EXAMPLE

    EXAMPLE["Example: cartservice<br/>408 spans, P95=52ms<br/>threshold=104ms<br/>3 spans exceed → 3/408 = 0.007<br/>→ HEALTHY ✓"]

flowchart LR
    EDGE["For each edge<br/>(source → target)"] --> P99["Step 1: Get P99<br/>numpy.percentile(durations, 99)"]
    P99 --> MINUTES["Step 2: To minutes<br/>P99_ms ÷ 1000 ÷ 60"]
    MINUTES --> SAFETY["Step 3: Safety margin<br/>× 10 (incidents make<br/>things 5-10× slower)"]
    SAFETY --> CLAMP["Step 4: Keep it reasonable<br/>clamp between 1 and 30 min"]

    CLAMP --> SYNC["Sync RPC: 58ms → 1.0 min"]
    CLAMP --> ASYNC["Async msg: 120s → 23.9 min"]