Vantry — Fleet Intelligence Platform

A production-grade laboratory PC fleet monitoring and management platform designed for academic institutions. Features real-time workstation telemetry via RFID keyboard-wedge client agents, tap-in/tap-out occupancy tracking, live CPU/RAM/temperature dashboards, browser activity auditing with search-query extraction, app usage analytics, ghost-session detection, offline-resilient log queuing, rule-based threshold alerting with webhook delivery, and a multi-lab admin dashboard deployed to the cloud — all in a tightly-typed TypeScript monorepo.

Features

Core Functionality

• Fleet Overview: Real-time grid of all lab workstations — online/offline/idle status, live CPU & RAM bars, last-seen timestamps, lab grouping, and CSV export
• PC Detail View: Per-workstation deep-dive with a 12-widget hardware grid (CPU, RAM, Cores, Speed, OS, OS Version, Hostname, Last Seen, Uptime, Antivirus Status, Primary Disk SMART Health, Pending Updates), live load stats with threshold-coloured bars, app usage timeline, browser search audit, performance logs, temperature history, power & voltage charts, and disk storage breakdown
• Multi-Lab Scoping: Lab selector in the sidebar scopes all stats, charts, and exports to a specific lab group without page reloads
• Live Status Header: Dynamic h1 shows page purpose with a live status line — "{online} of {total} workstations online · Last sync {relativeTime}"
• Admin Authentication: JWT-protected dashboard with bcrypt password hashing; token stored in localStorage and injected into all API requests

Configurable Threshold Alerting

• Threshold Rule Definition: Admins can define warning thresholds for system metrics (cpu, ram, diskUsePercent, cpuTemp) scoped to the entire fleet, a single lab room (labId), or a specific workstation (pcName).
• Sustained Evaluation Windows: Avoids single-sample spike false-positives. Rules support instant (fires immediately) or 5m/15m evaluation windows (fires only if the metric continuously exceeds threshold for the entire period).
• Deduplicated Firing Engine: When a threshold breach is detected, a single active AlertEvent is opened. The system will never spam duplicate events for the same ongoing condition.
• Auto-Resolution: Once the telemetry values drop back below the threshold, the system automatically marks the active event as resolved (resolvedAt timestamp is recorded) and frees the constraint.
• Acknowledge vs. Resolve: Operators can click "Acknowledge" on active alerts. This flags them as seen (acknowledged = true) and dims them in the UI, but the alert remains active until the workstation's telemetry actually recovers.
• Visual Alert Banners:
  • Sidebar Badge: A red count bubble next to the Alerts menu item shows unacknowledged open alerts.
  • Fleet Cards: Amber alert badges (⚠ N active alerts) show up on affected workstation cards.
  • PC Detail Header: An amber pulsing warning indicator appears next to the hostname.
  • Deep-linking: Clicking any card or detail header badge navigates to the Alerts page with the PC name filter pre-populated.
• Sensible Seeds: Ships with default rules pre-seeded (disabled by default) for high disk usage (>90% sustained 15m), CPU overheating (>85°C sustained 5m), and high RAM usage (>90% sustained 15m).

Security Posture Monitoring

• Antivirus Status Reporting: Detects running antivirus engine name (Windows Defender or third-party AVs) and real-time protection state (Active/Disabled).
• Update Compliance Tracking: Queries count of pending Windows updates, last check timestamp, and last successful install timestamp.
• USB Device Activity Auditing: Delta-polls active controllers to detect and log peripheral plug-in / unplug events (device name, class type, occurred timestamp).
• Fleet Security Analytics: Dedicate dashboard view scopes KPIs (AV coverage %, Update Backlogs, Stale AV definitions) and aggregates a fleet-wide real-time USB connection timeline feed.
• PC Security Inspector: Detail sub-tab shows compliance state, antivirus definition age alerts, and workstation-local chronological USB logs.

RFID Tap-In / Tap-Out Session Tracking

• Badge Tap Detection: The Vantry Client Logger reads RFID keyboard-wedge scans and fires rfid_tap WebSocket events to the central server in real time
• Tap-In / Tap-Out Toggle: First scan on a PC = tap-in (session opens); same badge scanned again = tap-out (session closes). No manual buttons needed
• Badge Conflict Detection: If a different badge scans while a session is already active, both the outgoing and incoming events are flagged as conflict in the audit log and highlighted in amber across the dashboard
• Unregistered Badge Support: Any unknown badge ID creates a session immediately — sessions show the raw badge ID. No registration required before scanning
• Badge Registry: POST /rfid/badges maps a badge ID to a full name and role (student / staff / guest). GET /rfid/badges lists all registered badges
• Fleet-Wide Occupancy: GET /rfid/sessions/active returns a live snapshot of every currently-occupied workstation across all labs
• Tap History: GET /rfid/sessions?pc_name=X returns the full paginated tap-in/out audit trail for any PC
• Ghost Session Alerts: Any online PC logging app or browser activity with no active RFID tap-in is flagged as a "ghost session" — surfaced in three places: the PC Detail occupancy strip, the Fleet card indicator, and the Overview alert banner
• Live Occupancy KPI: Overview page shows a "Live Occupancy X / Y" stat card alongside the existing fleet counters
• Client Logger UI: The Electron tray app shows a "Current Session" info row with a live green dot (occupied) or grey text (unoccupied) — updated instantly on each scan without waiting for the 4-second status poll

Agent Monitoring (Client Logger)

• Keyboard-Wedge RFID Listener: rfidListener.ts buffers characters from the HID reader and fires a scan event on Enter — hardware-agnostic, works with any USB RFID reader configured as a keyboard
• Hardware Telemetry: CPU usage %, RAM usage %, CPU temperature, power & voltage — streamed every 4 seconds via system_load, cpu_temperature_log, and power_voltage_log WebSocket events
• App Usage Tracking: Tracks active foreground window title and executable; fires app_usage_start, app_usage_update, and app_usage_end events with per-session CPU, memory, GPU, and duration metrics
• Browser Activity Auditing: Polls browser history databases (Chrome, Edge, Firefox) on Windows and extracts URLs, timestamps, and browser names — filtered to the last 60 seconds to avoid re-logging
• Search Query Extraction: Automatically detects search-engine result URLs (Google, Bing, DuckDuckGo, Yahoo, YouTube) and extracts the q / p query parameter. Non-search pages (Maps, Mail, etc.) are excluded to prevent false positives
• Offline Queue: offlineQueue.ts persists unsent logs to a local SQLite WAL database (better-sqlite3). On reconnect, queued events are flushed to the server in order — no data is lost during network outages
• Idle Detection: idle_status events fire when the system is idle (no mouse/keyboard activity), allowing the dashboard to show "Idle" vs "Active" states
• System Info Broadcast: On startup, the client sends full hardware metadata — CPU model, cores, speed, total RAM, GPU, OS platform/version, hostname, and disk models — so the dashboard always has an accurate hardware fingerprint even if the PC has never been manually registered

Central Server (WebSocket + REST)

• WebSocket Hub: socketHub.ts handles all incoming agent events via a Zod-validated discriminated union — validates telemetry logs and triggers real-time alert evaluation
• Session Lifecycle Management: SessionService opens, updates, and closes PC sessions based on start/stop/heartbeat events; handles reconciliation for sessions left open after an ungraceful shutdown
• Usage Service: Persists app usage logs, browser search logs, temperature logs, and performance snapshots to PostgreSQL via Prisma
• RFID Service: RfidService.handleTap() implements the full tap-in/out/conflict state machine backed by ActiveRfidSession (one row per PC) and RfidTapLog
• REST API: Full CRUD under /pcs, /logs, /browser-logs, /temperature-logs, /admin, /alerts, and /rfid — JWT-protected where applicable
• Prisma ORM → Supabase (PostgreSQL): Typed database access with migrations and generated client; connection pooling via Supabase's pooler endpoint

Dashboard (Web)

• Overview Page: Fleet-wide KPI cards (Workstation Fleet, Active Online, Idle, Sessions Logged, Live Occupancy), ghost session alert strip, per-lab performance summary cards with avg CPU/RAM bars, and live fleet status feed
• Fleet Page (PC Grid): Filterable, searchable grid of PC cards; each card shows status dot, occupant indicator (green = occupied, red = ghost), specs table, active warning badges, and live CPU/RAM bars with threshold colouring
• PC Detail Page: 12-widget system info grid (CPU, Cores, Speed, RAM, OS, OS Version, Hostname, Last Seen, Uptime, Antivirus Status, Primary Disk SMART Health, Pending Updates), sub-tabs (App Usage, Browser Searches, Performance, Temperature, Power & Voltage, Storage, Security, Session History), occupancy strip, active warning badges, and asset lifecycle metadata management
• Alerts Board: Live table tracking open and resolved alerts. Allows one-click acknowledgement. Dimmed rows stay on screen for reference, fading out only when resolved
• Alert Rules Settings: Modal UI to manage metric scopes, define warning triggers, configure windows, and delete rules
• Browser Searches Tab: Stat strip (Searches Today, Top Engine, Most-Used Browser), click-to-expand recent search queries with engine branding, engine-share donut visualization, and a filtered audit table with "Searches Only" toggle and search-vs-browse indicators
• Performance Tab: Time-series chart of CPU and RAM usage over the stored log window
• Temperature Tab: CPU temperature timeline with threshold annotations
• Power & Voltage Tab: CPU voltage and power draw history
• Storage Tab: Per-disk usage bars (used / total GB, % fill colour-coded green → amber → rose)
• Session History Tab: Paginated RFID tap-in/out table — person name, badge ID, role, timestamp, conflict flag — with ghost session banner when applicable
• Direct Link Copy: Each PC Detail page has a one-click copyable deep link for sharing with the mobile scanner companion app

Electron Tray Apps

• Vantry Client Logger: Minimal tray app that runs silently on each lab PC, connects to the central server over WebSocket, streams telemetry, queues offline events, reads RFID taps, and exposes a status window
• Vantry Server Control Panel: Tray wrapper for the Express + WebSocket server process — start/stop/restart controls, live log feed, and connection count display

Tech Stack

Layer	Technology
Client shell	Electron 37 + electron-vite + React 18 + TypeScript
Client RFID	Keyboard-wedge HID listener (rfidListener.ts)
Client telemetry	node-os-utils · systeminformation · pidusage
Client offline cache	better-sqlite3 (SQLite WAL)
Server runtime	Express 5 + TypeScript
Real-time transport	ws (WebSocket) — raw, no Socket.io overhead
Schema validation	Zod discriminated union (shared-types package)
ORM	Prisma 5 → PostgreSQL (Supabase)
Alert Delivery	HTTP Webhook POST notifications (notify.service.ts)
Dashboard	Vite + React 18 + TypeScript + Tailwind CSS v3
Charts	Recharts
Icons	Lucide React
Auth	JWT (bcrypt + jsonwebtoken)
Monorepo tooling	pnpm workspaces + Turborepo
Deployment	Render (dashboard) · Supabase (DB)

System Architecture

graph TD
    subgraph LabPC ["Lab Workstation (Electron Client)"]
        RfidHW["USB RFID Reader (HID)"]
        RfidListener["rfidListener.ts"]
        Telemetry["HardwareMonitor + BrowserHistory"]
        OfflineQ["OfflineQueue (SQLite)"]
        Renderer["React Status Window"]
    end

    subgraph Server ["Central Server (Express + WS)"]
        WSHub["SocketHub — WS Event Handler"]
        RfidSvc["RfidService (tap-in/out/conflict)"]
        SessionSvc["SessionService"]
        UsageSvc["UsageService"]
        AlertSvc["AlertService (Evaluation Engine)"]
        REST["REST API (/pcs /rfid /alerts ...)"]
        Prisma["Prisma ORM"]
        NotifySvc["NotifyService (Webhook Poster)"]
    end

    subgraph Dashboard ["Vantry Dashboard (React/Vite)"]
        Overview["Overview — KPIs + Ghost Alerts"]
        Fleet["PcFleet — Card Grid + Occupant + Alert Badges"]
        Detail["PcDetail — 7-Tab Deep Dive + Alerts"]
        AlertsPage["AlertsPage — Table + Rule Settings"]
        ApiClient["api-client (HTTP + WS)"]
    end

    subgraph Storage ["Storage"]
        DB[("PostgreSQL (Supabase)")]
    end

    subgraph External ["External Services"]
        Webhook["IT Slack / Discord / Custom Webhook"]
    end

    RfidHW -->|keyboard events| RfidListener
    RfidListener -->|scan event| OfflineQ
    Telemetry --> OfflineQ
    OfflineQ -->|WS rfid_tap / telemetry| WSHub
    Renderer <-->|IPC| RfidListener

    WSHub --> RfidSvc
    WSHub --> SessionSvc
    WSHub --> UsageSvc
    WSHub --> AlertSvc
    AlertSvc --> NotifySvc
    NotifySvc -->|JSON HTTP POST| Webhook
    RfidSvc --> Prisma
    SessionSvc --> Prisma
    UsageSvc --> Prisma
    AlertSvc --> Prisma
    Prisma --> DB

    ApiClient -->|HTTP poll| REST
    REST --> Prisma
    Overview --> ApiClient
    Fleet --> ApiClient
    Detail --> ApiClient
    AlertsPage --> ApiClient

Loading

Module Dependency Flow

graph LR
    subgraph SharedPkgs ["Shared Packages"]
        SharedTypes["@juglone/shared-types\nZod schemas + TS types"]
        ApiClientPkg["@juglone/api-client\nHTTP + WS client"]
    end

    subgraph ServerModules ["Server Modules"]
        SocketHub["socketHub.ts"] --> RfidSvc["rfid.service.ts"]
        SocketHub --> SessionSvc["session.service.ts"]
        SocketHub --> UsageSvc["usage.service.ts"]
        SocketHub --> AlertSvc["alert.service.ts"]
        AlertSvc --> NotifySvc["notify.service.ts"]
        RfidRoutes["rfid.routes.ts"] --> RfidSvc
        PcRoutes["pcs.routes.ts"] --> SessionSvc
        AlertRoutes["alerts.routes.ts"] --> AlertSvc
        SharedTypes -->|event schemas| SocketHub
    end

    subgraph ClientModules ["Client Electron Modules"]
        RfidListener["rfidListener.ts"] -->|scan| MainTS["main.ts"]
        HWMonitor["hardware-monitor.ts"] --> MainTS
        BrowserHistory["browserHistory.ts"] --> MainTS
        OfflineQueue["offlineQueue.ts"] --> MainTS
        MainTS -->|WS events| SocketHub
        SharedTypes -->|event types| MainTS
    end

    subgraph DashboardModules ["Dashboard Modules"]
        AppTSX["App.tsx"] -->|rfidSessions map| Overview["Overview.tsx"]
        AppTSX -->|rfidSessions map| PcFleet["PcFleet.tsx"]
        AppTSX -->|openAlertsMap| PcFleet
        PcDetail["PcDetail.tsx"] --> ApiClientPkg
        Alerts["Alerts.tsx"] --> ApiClientPkg
        AlertRules["AlertRules.tsx"] --> ApiClientPkg
        AppTSX --> ApiClientPkg
        ApiClientPkg --> RfidRoutes
        ApiClientPkg --> PcRoutes
        ApiClientPkg --> AlertRoutes
    end

Loading

Project Structure

juglone-rebuild/
├── apps/
│   ├── client/                       # Electron + React/TS — lab PC client
│   │   ├── electron/
│   │   │   ├── main.ts               # Main process: WS client, IPC handlers, RFID wiring
│   │   │   ├── rfidListener.ts       # Keyboard-wedge HID reader (EventEmitter)
│   │   │   ├── hardware-monitor.ts   # CPU/RAM/temp/power telemetry
│   │   │   ├── browserHistory.ts     # Browser DB poller + search query extraction
│   │   │   ├── offlineQueue.ts       # SQLite-backed offline event queue
│   │   │   ├── ipc.ts                # IPC channel constants
│   │   │   └── preload.ts            # contextBridge API surface (incl. rfidTap + onRfidScan)
│   │   └── src/
│   │       ├── App.tsx               # Status window root; RFID scanner hook → api.rfidTap()
│   │       └── components/
│   │           └── ConnectionStatus.tsx   # Info rows incl. live "Current Session" row
│   │
│   ├── server/                       # Express + TS + Prisma — WS + REST
│   │   ├── prisma/
│   │   │   └── schema.prisma         # All models incl. RfidTapLog + ActiveRfidSession + Alerts
│   │   └── src/
│   │       ├── index.ts              # App bootstrap + router registration (/rfid and /alerts)
│   │       ├── routes/
│   │       │   ├── rfid.routes.ts    # POST /tap · GET /sessions/active · GET /sessions · /badges
│   │       │   ├── alerts.routes.ts  # GET /alerts · /open-count · /open-by-pc · PATCH /acknowledge · /rules
│   │       │   └── pcs.routes.ts     # GET /pcs · /detail · /performance · /app-usages
│   │       ├── services/
│   │       │   ├── rfid.service.ts   # Tap-in/out/conflict state machine + badge registry
│   │       │   ├── alert.service.ts  # Rule evaluation logic, triggers, auto-resolutions, and default seeding
│   │       │   ├── notify.service.ts # Webhook message delivery poster
│   │       │   ├── session.service.ts
│   │       │   └── usage.service.ts
│   │       ├── jobs/
│   │       │   └── alertEvaluator.ts # Background 60-second rule evaluation runner
│   │       └── ws/
│   │           └── socketHub.ts      # Zod-validated WS event dispatcher (triggers alert evaluation)
│   │
│   ├── server-tray/                  # Electron tray wrapper for the server process
│   └── dashboard/                    # Vite + React/TS + Tailwind — deployed to Render
│       └── src/
│           ├── App.tsx               # Fleet + rfidSessions + alert counts poll; passes state down
│           ├── pages/
│           │   ├── Overview.tsx      # 5-card KPI row + ghost session alert strip
│           │   ├── PcFleet.tsx       # PC card grid + occupant + active warnings badges
│           │   ├── PcDetail.tsx      # 8-tab deep dive + occupancy strip + alert badges + Security tab
│           │   ├── Alerts.tsx        # Active and resolved alerts viewer with acknowledge action
│           │   ├── AlertRules.tsx    # Modal UI for alert thresholds and scopes
│           │   └── Security.tsx      # Fleet-wide AV/Update metrics & USB events timeline
│           ├── components/
│           │   └── Layout.tsx        # Sidebar, top bar, live status subtitle, alerts count indicator, Security tab
│           └── lib/
│               └── apiClient.ts      # Initialises @juglone/api-client
│
├── packages/
│   ├── shared-types/                 # Zod schemas + inferred TS types (all apps)
│   │   └── src/
│   │       ├── ws-events.ts          # Discriminated union incl. RfidTapEventSchema + UsbEventSchema
│   │       └── db-types.ts
│   └── api-client/                   # Typed HTTP + WS client
│       └── src/
│           ├── http.ts               # ApiHttpClient methods for RFID, fleet stats, alerts, and USB logs
│           └── ws-client.ts
│
└── docs/

API Reference

Fleet

Method	Path	Description
GET	/pcs	All PC fleet records with live stats
GET	/pcs/:hostname/detail	Full metadata + live load for one PC
GET	/pcs/:hostname/app-usages	App usage logs + distribution
GET	/pcs/:hostname/performance	CPU/RAM performance log
GET	/pcs/usb-events/fleet	Recent USB logs for all workstations
GET	/pcs/:hostname/usb-events	Recent USB events for one workstation

Alerts

Method	Path	Description
GET	/alerts	Get alert events (supports ?resolved=false&pc_name=X)
GET	/alerts/open-count	Live count of unacknowledged open events (for sidebar badge)
GET	/alerts/open-by-pc	Map of { [pcName]: activeCount } (for Fleet badges)
PATCH	/alerts/:id/acknowledge	Mark an alert as acknowledged (dimmed in UI)
GET	/alerts/rules	List all alert trigger rules
POST	/alerts/rules	Create a new alert rule
PATCH	/alerts/rules/:id	Update or enable/disable a rule
DELETE	/alerts/rules/:id	Delete an alert rule (cascades to events)

RFID

Method	Path	Description
GET	/rfid/sessions/active	All currently-occupied PCs fleet-wide
GET	/rfid/sessions?pc_name=X&limit=N	Tap-in/out audit trail for one PC
POST	/rfid/tap	Manual tap event (testing without Electron client)
GET	/rfid/badges	All registered badge ↔ person mappings
POST	/rfid/badges	Register or update a badge

Register a badge:

POST /rfid/badges
{ "badge_id": "NDC-0042", "person_name": "Juan dela Cruz", "role": "student" }

Manual tap (testing):

POST /rfid/tap
{ "pc_name": "LAB-A-PC-01", "badge_id": "NDC-0042" }

Logs

Method	Path	Description
GET	/logs	All session logs
GET	/browser-logs?pc_name=X&limit=N	Browser activity + search queries
GET	/temperature-logs?pc_name=X&limit=N	CPU temperature history
POST	/admin/login	Authenticate and receive JWT

WebSocket Event Reference

All events are validated server-side against Zod schemas in @juglone/shared-types.

Event type	Direction	Description
start	Agent → Server	PC session opened
stop	Agent → Server	PC session closed
heartbeat	Agent → Server	Keep-alive ping
system_info	Agent → Server	Full hardware metadata snapshot
system_load	Agent → Server	Live CPU % + RAM %
idle_status	Agent → Server	Idle / active state change
app_usage_start	Agent → Server	Foreground app opened
app_usage_update	Agent → Server	In-progress app metrics update
app_usage_end	Agent → Server	App closed with duration + resource stats
browser_activity	Agent → Server	URL visited + optional search_query + search_engine
cpu_temperature_log	Agent → Server	CPU temperature reading
power_voltage_log	Agent → Server	CPU voltage + power draw
rfid_tap	Agent → Server	Badge scan (tap-in or tap-out toggle)
usb_event	Agent → Server	USB device plug-in or unplug event

Data Model

Pc                   — hostname, labId, lastSeen, isOnline, isIdle, cpuUsage%, ramUsage%
Session              — pcName, startTime, endTime, userId?
AppUsageLog          — pcName, appName, startedAt, endedAt, durationSeconds, cpu%, mem
BrowserSearchLog     — pcName, browser, url, searchQuery?, searchEngine?, timestamp
PerformanceLog       — pcName, cpuUsagePercent, ramUsagePercent, recordedAt
CpuTemperatureLog    — pcName, cpuTemperature, timestamp
PowerVoltageLog      — pcName, cpuVoltage, cpuPower, timestamp
DiskStorage          — pcName, mountPoint, totalGb, usedGb, usePercent, smartStatus?, reallocatedSectors?
SystemInfo           — pcId, cpuModel, cpuCores, cpuSpeedGhz, totalRamGb, osVersion, uptimeSeconds?, lastBootAt?, avProductName, avRealTimeProtection, avLastUpdate, updateLastChecked, updateLastInstalled, updatePendingCount
AssetMetadata        — pcName (PK), assetTag?, purchaseDate?, warrantyExpiresAt?, notes?
User                 — rfidTag (unique), fullName, role              ← badge registry
RfidTapLog           — pcName, badgeId, tapType (in|out), personName, role, flagged, tappedAt
ActiveRfidSession    — pcName (PK), badgeId, personName, role, tapInAt, flagged
AlertRule            — id, name, metric, scope, scopeValue?, threshold, comparisonWindow, enabled
AlertEvent           — id, ruleId, pcName, value, triggeredAt, resolvedAt?, acknowledged, acknowledgedBy?
UsbEventLog          — id, pcId, deviceName, deviceClass?, eventType, occurredAt

Alert Evaluation Logic

Workstation Telemetry Event
  → socketHub.ts case system_load / cpu_temperature_log
  → alert.service.ts evaluateForPc(pcName, labId, sample)
      ├─ Load enabled AlertRules matching scope (fleet / matching lab / matching pc)
      ├─ For each rule, resolve current value and check if threshold exceeded
      │    ├─ Instant window: value > threshold
      │    └─ Sustained (5m / 15m) window: query log table since window; ALL logs must exceed threshold
      ├─ Threshold exceeded?
      │    ├─ YES  →  tryFire()  →  Check if open event exists. If none, create AlertEvent and send Webhook notification.
      │    └─ NO   →  tryResolve() →  Check if open event exists. If so, mark resolvedAt and send Webhook recovery notice.
  → Dashboard count polls /alerts/open-count every 5s → updates Sidebar Bell Badge
  → Dashboard fleet poll /alerts/open-by-pc every 5s → updates Fleet Cards warning indicators

Ghost Session Detection

A ghost session = an online PC that is actively logging app or browser activity but has no active RFID tap-in. This means someone is using the workstation without checking in.

Location	How it appears
Overview	Red alert strip: "N workstations with active app usage but no RFID tap-in"
Fleet card	Red ⚠ Ghost session badge below the PC name
PC Detail	Rose-bordered occupancy strip + "Ghost Session Detected" banner in Session History tab

Hardware Lifecycle & Asset Metadata Tracking

Vantry transforms raw telemetry into actionable IT procurement and maintenance insights:

• Disk S.M.A.R.T. Health: Evaluates drive condition (healthy, warning, failing, unknown) and tracks reallocated sector counts per disk alongside storage usage.
• Uptime & Reboot History: Monitors workstation uptime duration and last boot timestamp. Systems operating continuously past 14 days are flagged with reboot warning badges for patch compliance.
• Asset Metadata & Warranty Management: Admins can edit asset tags, purchase dates, warranty expiration dates, and notes per workstation directly via modal or inline editor.
• Fleet-Wide Lifecycle Analytics: Overview page and PC Fleet cards surface active SMART warnings, high uptime risks, out-of-warranty alerts, and 90-day replacement forecasts.

Analytics & Reporting Engine

Vantry includes a full-featured, multi-tab Analytics Intelligence Dashboard with 7 interactive tabs covering every major domain of laboratory fleet operations.

1. Application & Software Usage Analytics

• Top Applications Leaderboard: Bar chart ranking the most-used software across lab fleets (e.g., AutoCAD, VS Code, MATLAB, Chrome) by active hours and session counts.
• Software Category Breakdown: Donut chart segmenting total usage by category (IDE & Coding, Web Browsers, Engineering & CAD, System Utilities, Communication).
• Search Engine Share Visualization: Pie chart of browser search engine distribution across fleet queries (Google, Bing, DuckDuckGo, Ecosia).
• Live Web Search Query Stream: Real-time audit feed of recent student search queries, search engines used, and workstation origin.
• Software License & Idle Waste Tracker: Monitors high-cost commercial software seats (AutoCAD, MATLAB, SolidWorks) open on idle workstations (>30 min inactivity) — displays wasted license hours (48.5 hrs/mo) and estimated financial waste (₱14,550/mo).
• Unapproved & Prohibited Software Audit: Real-time detection stream flagging unauthorized executables (e.g., uTorrent, OpenVPN, Steam) with severity badges (HIGH RISK / WARNING), workstation hostname, and detection timestamp.
• Application & Software Fleet Usage Log Table: Searchable full-detail audit table with PC hostname, application name, category tag, session count, and total runtime per workstation.

2. Web & Browser Activity Intelligence

• Top Search Queries Stream: Aggregated audit feed of recent browser search queries logged across lab browsers.
• Domain & Category Traffic Breakdown: Categorized traffic analysis (Educational, AI Tools, Cloud Storage, Social Media) via pie charts.
• Browser Engine Share Analytics: Per-engine query distribution for Google, Bing, DuckDuckGo, and other search engines.

3. Power Consumption & Energy Efficiency (Eco Metrics)

• Interactive Fleet Power Calculator: Live calculator with adjustable sliders for electricity tariff rate (₱/kWh), workstation active draw (Watts), and standby idle draw (Watts).
• Philippine Peso (₱) Defaults: Default tariff set at ₱11.50/kWh (local standard rate) with locale-formatted cost outputs.
• Calculated Stat Cards: Est. Monthly Energy (kWh), Est. Monthly Utility Bill (₱), Idle Power Waste Cost (₱/mo), and Est. Annual Eco Savings (₱/yr).
• Energy Consumption Share Donut Chart: Visual breakdown of Active Load Energy vs. Standby Idle Energy.
• Nightly Auto-Shutdown Policy Toggle: Simulates impact of auto-power-off on idle waste reduction.
• Ecological Sustainability Impact: Calculates CO₂ emissions reduced (kg/yr) and equivalent trees planted when auto-shutdown is enabled.
• Currency Switcher: Toggle between Philippine Peso (₱) and US Dollar ($).

4. RFID Student & Occupancy Insights

• Live Occupancy Trend Chart: Area chart of concurrent active RFID sessions throughout the day.
• 24/7 Laboratory Occupancy Density Heatmap: Interactive 7-day × 24-hour grid showing peak lab congestion times — color-coded from Idle (dark slate) to Peak (rose red >85%) with live hover cell inspection (day, hour, occupancy %, active workstation count).
• Session Duration Breakdown: Distribution of session lengths (<30 min, 30–60 min, 1–2 hrs, 2+ hrs) with progress bars.
• Badge Status Audit: Authentication state breakdown (Verified RFID Tap-ins, Unregistered Check-ins, Ghost Activity).
• Top Occupants Ranking: Top current session holders ranked by session duration with role and workstation.
• Lab Usage by Academic Department: Bar chart aggregating total RFID session hours by degree program (BS Computer Science, BS Electronics Eng, BS Information Tech, BS Mechanical Eng).
• Top Student Visitor Leaderboard: Ranked table displaying top lab users by total cumulative session hours, badge ID, department/year level, and primary workstation.

5. Hardware Thermal & Maintenance Degradation

• CPU Thermal Throttling & Overheating Count: Monitors temperature spikes (>85°C) and thermal throttling events — shows per-workstation severity badges (CRITICAL OVERHEAT / THERMAL THROTTLE / ELEVATED TEMP) with recorded peak temperatures and timestamps.
• SSD/HDD Wear & Storage Saturation Trajectory: Predictive disk capacity exhaustion forecast (e.g., "14 days until saturation") with SMART TBW (Terabytes Written) lifespan percentage per drive.
• Problematic PC Maintenance Ranking: Workstation fault leaderboard ranked by cumulative hardware fault events (thermal spikes, network dropouts, SMART warnings, unapproved software flags).

6. Executive Reporting & Comparison Tools

• Side-by-Side Multi-Lab Comparison Matrix: Interactive comparison table of Lab Alpha, Lab Beta, and Lab Gamma across Utilization Rate, Avg CPU/RAM Load, Open Alerts, Thermal Events, and Monthly Power Bill — with automatic ▲ Best / ▼ Worst value highlights.
• CPU & RAM Load Comparison Bar Chart: Grouped bar chart for rapid visual comparison of hardware load across lab units.
• Lab Performance Composite Ranking: Algorithmic operational score ranking (Utilization % − Alerts×3 + Thermal Bonus) for at-a-glance lab health comparison.
• Auto-Generated Executive Director's Summary Narrative: Formatted readable text snapshot with today's date, live fleet counts, financial summaries, and prioritized IT Director action items.
• Fleet Executive Summary Stat Cards: Total Fleet Workstations, Online & Operational, Active RFID Sessions, and Fleet Monthly Power Bill (₱).
• 1-Click CSV Export: Downloadable multi-lab comparison report in CSV format for spreadsheet analysis.
• 1-Click Print / PDF Report: Triggers browser window.print() for formatted printable or PDF-ready executive reporting.

Overview & Trend Tabs

• Overview Tab: Fleet performance & load trends (AreaChart / BarChart), lab resource utilization breakdown, alert resolution trends, peak activity times, and the Power & Electricity Cost Calculator.
• Alerts & Health Tab: Anomaly resolution funnel (Triggered → Acknowledged → Resolved), weekly alert volume, trigger rates by metric type, CPU thermal diagnostics, SSD wear trajectories, and problematic PC rankings.
• Security & Lifecycle Tab: Composite system health score (0–100 rating), security factor meters, weekly compliance throughput, and aging hardware backlog.
• Trends & Forecasts Tab: Data-driven 30-day storage capacity saturation projections, upcoming warranty renewal timeline, and predicted peak occupancy times.
• Export & Reporting: Domain-tailored CSV export and printable report formatting across selected date ranges and laboratory scopes.