# Resource Monitor Service v2.0

A comprehensive Windows VM monitoring service designed specifically for Unraid virtual machines. This service provides real-time system monitoring, alerting, and remote management capabilities through a REST API.

## 🚀 New Features in v2.0

### Enhanced Monitoring
- **Multi-core CPU monitoring** with per-core usage and frequency tracking
- **Advanced memory monitoring** including paged/non-paged memory
- **Enhanced GPU monitoring** with NVIDIA GPU support via NVML
- **Comprehensive disk monitoring** with I/O performance metrics
- **Network monitoring** with per-adapter statistics
- **Temperature monitoring** for CPU, GPU, and storage devices
- **Process monitoring** with detailed resource usage tracking

### VM-Specific Features
- **Hypervisor detection** (VMware, Hyper-V, QEMU/KVM, etc.)
- **VM information** including boot time and uptime tracking
- **Virtual machine optimization** for better performance in virtualized environments

### Game Detection & Management
- **Multi-platform game detection** (Steam, Epic Games, GOG, Origin, Ubisoft)
- **Fullscreen detection** for gaming sessions
- **Game performance monitoring** with memory and CPU usage
- **Enhanced process management** with graceful termination options

### Intelligent Alerting System
- **Configurable thresholds** for CPU, memory, GPU, and temperature
- **Duration-based alerting** to prevent false positives
- **Alert history** and active alert management
- **Automatic alert resolution** when conditions improve

### Improved API
- **RESTful endpoints** with structured responses
- **Enhanced error handling** and logging
- **Configurable CORS** and API key authentication
- **Health check endpoints** for monitoring service status
  - RAM Usage
  - GPU Usage
  - Currently Running Steam Games (if any)

- **Process Management**: Provides an API to kill processes by their process ID.

## Directory Structure

```
ResourceUsageAPI/
├── Worker.cs
├── Program.cs
├── Startup.cs
└── NvmlWrapper.cs
```

## Code Analysis

### Worker.cs

This file contains the main logic for monitoring system resources and exposing APIs.

- **Dependencies**: Uses `System.Diagnostics`, `Microsoft.AspNetCore.Builder`, `Newtonsoft.Json` among others.
- **Methods**:
  - `ExecuteAsync`: Sets up the ASP.NET Core web application, defines routes for resource usage and process management, and runs the server.
  - `GetComputerInfo`: Retrieves basic system information.
  - `GetCpuUsage`: Fetches CPU usage and lists top three processes by CPU usage if usage is over 80%.
  - `GetRamUsage`: Calculates RAM usage percentage.
  - `GetTotalPhysicalMemory`: Retrieves total physical memory size.
  - `GetGpuUsage`: Uses NVIDIA Management Library (NVML) to fetch GPU usage, temperature, and fan speed.
  - `GetCurrentlyRunningGame`: Detects if a Steam game is running by checking process paths.
  - `GetCurrentTime`: Returns the current time.

### Program.cs

This file sets up the hosting environment for the application.

- **Dependencies**: Uses `Microsoft.Extensions.DependencyInjection` and `Microsoft.Extensions.Hosting`.
- **Methods**:
  - `Main`: Entry point of the application, builds and runs the host.
  - `CreateHostBuilder`: Configures services and determines if the application should run as a Windows service based on command-line arguments or environment variables.

### Startup.cs

This file is not used in the current implementation since all routing and configuration are done within `Worker.cs`.

- **Dependencies**: Uses `Microsoft.AspNetCore.Builder` and `Microsoft.AspNetCore.Hosting`.
- **Methods**:
  - `ConfigureServices`: Placeholder method for adding services.
  - `Configure`: Placeholder method for configuring application HTTP requests pipeline.

### NvmlWrapper.cs

This file provides a C# wrapper for the NVIDIA Management Library (NVML) functions.

- **Dependencies**: Uses `System` and `System.Runtime.InteropServices`.
- **Methods**:
  - Importing NVML DLL functions to interact with GPU hardware.
  - Structures like `NvmlUtilization` are defined for handling utilization rates returned by NVML.

## Usage

1. **Build the Project**: Use your preferred .NET build tool (e.g., `dotnet build`) to compile the project.
2. **Run the Application**:
   - To run as a console application, execute the compiled binary directly.
   - To run as a Windows service, use the command-line argument `--windows-service` or set the environment variable `RUN_AS_SERVICE` to `"true"`.

## APIs

- **Get Resource Usage**: 
  - URL: `/api/resource-usage`
  - Method: GET
  - Description: Retrieves current system resource usage.
  
- **Kill Process**:
  - URL: `/api/kill-process`
  - Method: POST
  - Body: JSON with the process ID (`{"id": "1234"}`)
  - Description: Kills the specified process.

## Important Notes

- Ensure that the NVIDIA Management Library (NVML) is installed on the system for GPU monitoring to work.
- The application allows CORS from all origins, which should be configured securely in production environments.
- Error handling and logging are minimal; consider adding robust error handling and logging mechanisms for a production-ready solution.

## Contributing

Feel free to contribute by opening issues or submitting pull requests. Make sure to follow the project's coding style and best practices.


# devnote
dotnet run      
git add .
git commit -m "Add steam running games"     
git push origin master         
dotnet publish -c Release -o ./publish

# devtest
Invoke-WebRequest -Uri "http://localhost:5000/api/kill-process" -Method POST -Body "1234" -Headers @{ "X-API-KEY" = "b7f3e8a1-4c2d-4d9f-9a6e-2a1c5d7f8e9a" }

Invoke-WebRequest -Uri "http://192.168.50.52:5000/api/resource-usage" -Method GET -Headers @{ "X-API-KEY" = "b7f3e8a1-4c2d-4d9f-9a6e-2a1c5d7f8e9a" }

Use 'shutdown', 'restart', or 'cancel'.
Invoke-WebRequest -Uri "http://192.168.50.52:5000/api/force-shutdown" `
-Method POST `
-Headers @{ "X-API-KEY" = "b7f3e8a1-4c2d-4d9f-9a6e-2a1c5d7f8e9a" } `
-Body '{"Action": "shutdown", "DelaySeconds": 120}' `
-ContentType "application/json"