...

Author: despiegk

.github/workflows/release-osx.yaml

@@ -0,0 +1,61 @@
+on:
+  push:
+    # Sequence of patterns matched against refs/tags
+    tags:
+      - "v*" # Push events to matching v*, i.e. v1.0, v20.15.10
+
+name: Create OSX Release
+
+jobs:
+  create-release:
+    name: Create Release
+    runs-on: ubuntu-latest
+    outputs:
+      upload_url: ${{ steps.create_release.outputs.upload_url }}
+    steps:
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: Release ${{ github.ref }} - OSX
+          draft: false
+          prerelease: false
+
+  build:
+    name: Build and Upload OSX Binaries
+    runs-on: macos-latest
+    needs: create-release
+    strategy:
+      matrix:
+        target:
+          - x86_64-apple-darwin
+          - aarch64-apple-darwin
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      - name: Install Rust toolchain
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: stable
+          target: ${{ matrix.target }}
+          override: true
+      - name: Build release
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+          args: --release --target=${{ matrix.target }}
+      - name: Strip binary
+        run: |
+          strip target/${{ matrix.target }}/release/zinit
+      - name: Upload Release Asset
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ needs.create-release.outputs.upload_url }}
+          asset_path: target/${{ matrix.target }}/release/zinit
+          asset_name: zinit-${{ matrix.target }}
+          asset_content_type: application/octet-stream

docs/stats.md

@@ -0,0 +1,125 @@
+# Service Stats Functionality
+
+This document describes the stats functionality in Zinit, which provides memory and CPU usage information for services and their child processes.
+
+## Overview
+
+The stats functionality allows you to monitor the resource usage of services managed by Zinit. It provides information about:
+
+- Memory usage (in bytes)
+- CPU usage (as a percentage)
+- Child processes and their resource usage
+
+This is particularly useful for monitoring system resources and identifying services that might be consuming excessive resources.
+
+## Command Line Usage
+
+To get stats for a service using the command line:
+
+```bash
+zinit stats <service-name>
+```
+
+Example:
+```bash
+zinit stats nginx
+```
+
+This will output YAML-formatted stats information:
+
+```yaml
+name: nginx
+pid: 1234
+memory_usage: 10485760  # Memory usage in bytes (10MB)
+cpu_usage: 2.5          # CPU usage as percentage
+children:               # Stats for child processes
+  - pid: 1235
+    memory_usage: 5242880
+    cpu_usage: 1.2
+  - pid: 1236
+    memory_usage: 4194304
+    cpu_usage: 0.8
+```
+
+## JSON-RPC API
+
+The stats functionality is also available through the JSON-RPC API:
+
+### Method: `service_stats`
+
+Get memory and CPU usage statistics for a service.
+
+**Parameters:**
+- `name` (string, required): The name of the service to get stats for
+
+**Returns:**
+- Object containing stats information:
+  - `name` (string): Service name
+  - `pid` (integer): Process ID of the service
+  - `memory_usage` (integer): Memory usage in bytes
+  - `cpu_usage` (number): CPU usage as a percentage (0-100)
+  - `children` (array): Stats for child processes
+    - Each child has:
+      - `pid` (integer): Process ID of the child process
+      - `memory_usage` (integer): Memory usage in bytes
+      - `cpu_usage` (number): CPU usage as a percentage (0-100)
+
+**Example Request:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "service_stats",
+  "params": {
+    "name": "nginx"
+  }
+}
+```
+
+**Example Response:**
+```json
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": {
+    "name": "nginx",
+    "pid": 1234,
+    "memory_usage": 10485760,
+    "cpu_usage": 2.5,
+    "children": [
+      {
+        "pid": 1235,
+        "memory_usage": 5242880,
+        "cpu_usage": 1.2
+      },
+      {
+        "pid": 1236,
+        "memory_usage": 4194304,
+        "cpu_usage": 0.8
+      }
+    ]
+  }
+}
+```
+
+**Possible Errors:**
+- `-32000`: Service not found
+- `-32003`: Service is down
+
+## Implementation Details
+
+The stats functionality works by:
+
+1. Reading process information from `/proc/<pid>/` directories on Linux systems
+2. Calculating memory usage from `/proc/<pid>/status` (VmRSS field)
+3. Calculating CPU usage by sampling `/proc/<pid>/stat` over a short interval
+4. Identifying child processes by checking the PPid field in `/proc/<pid>/status`
+
+On non-Linux systems, the functionality provides placeholder values as the `/proc` filesystem is specific to Linux.
+
+## Notes
+
+- Memory usage is reported in bytes
+- CPU usage is reported as a percentage (0-100)
+- The service must be running to get stats (otherwise an error is returned)
+- Child processes are identified by their parent PID matching the service's PID

example/example.sh

@@ -69,11 +69,11 @@ echo "Telling zinit to monitor the service..."
 echo "Listing zinit services to verify..."
 "$ZINIT_BIN" list
 
-# Step 6: Clean up (optional, but good for examples)
-echo "Cleaning up: stopping and forgetting $SERVICE_NAME..."
-"$ZINIT_BIN" stop "$SERVICE_NAME" > /dev/null 2>&1
-"$ZINIT_BIN" forget "$SERVICE_NAME" > /dev/null 2>&1
-rm -f "$SERVICE_FILE"
-echo "Cleanup complete."
+# # Step 6: Clean up (optional, but good for examples)
+# echo "Cleaning up: stopping and forgetting $SERVICE_NAME..."
+# "$ZINIT_BIN" stop "$SERVICE_NAME" > /dev/null 2>&1
+# "$ZINIT_BIN" forget "$SERVICE_NAME" > /dev/null 2>&1
+# rm -f "$SERVICE_FILE"
+# echo "Cleanup complete."
 
 echo "--- Script Finished ---"

openrpc.json

@@ -601,6 +601,105 @@
         }
       ]
     },
+    {
+      "name": "service_stats",
+      "description": "Get memory and CPU usage statistics for a service",
+      "params": [
+        {
+          "name": "name",
+          "description": "The name of the service to get stats for",
+          "required": true,
+          "schema": {
+            "type": "string"
+          }
+        }
+      ],
+      "result": {
+        "name": "ServiceStats",
+        "description": "Memory and CPU usage statistics for the service",
+        "schema": {
+          "type": "object",
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "Service name"
+            },
+            "pid": {
+              "type": "integer",
+              "description": "Process ID of the service"
+            },
+            "memory_usage": {
+              "type": "integer",
+              "description": "Memory usage in bytes"
+            },
+            "cpu_usage": {
+              "type": "number",
+              "description": "CPU usage as a percentage (0-100)"
+            },
+            "children": {
+              "type": "array",
+              "description": "Stats for child processes",
+              "items": {
+                "type": "object",
+                "properties": {
+                  "pid": {
+                    "type": "integer",
+                    "description": "Process ID of the child process"
+                  },
+                  "memory_usage": {
+                    "type": "integer",
+                    "description": "Memory usage in bytes"
+                  },
+                  "cpu_usage": {
+                    "type": "number",
+                    "description": "CPU usage as a percentage (0-100)"
+                  }
+                }
+              }
+            }
+          }
+        }
+      },
+      "examples": [
+        {
+          "name": "Get stats for redis service",
+          "params": [
+            {
+              "name": "name",
+              "value": "redis"
+            }
+          ],
+          "result": {
+            "name": "ServiceStatsResult",
+            "value": {
+              "name": "redis",
+              "pid": 1234,
+              "memory_usage": 10485760,
+              "cpu_usage": 2.5,
+              "children": [
+                {
+                  "pid": 1235,
+                  "memory_usage": 5242880,
+                  "cpu_usage": 1.2
+                }
+              ]
+            }
+          }
+        }
+      ],
+      "errors": [
+        {
+          "code": -32000,
+          "message": "Service not found",
+          "data": "service name \"unknown\" unknown"
+        },
+        {
+          "code": -32003,
+          "message": "Service is down",
+          "data": "service \"redis\" is down"
+        }
+      ]
+    },
     {
       "name": "system_start_http_server",
       "description": "Start an HTTP/RPC server at the specified address",

src/app/api.rs

@@ -37,6 +37,26 @@ pub struct Status {
     pub after: HashMap<String, String>,
 }
 
+/// Service stats information
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub struct Stats {
+    pub name: String,
+    pub pid: u32,
+    pub memory_usage: u64,
+    pub cpu_usage: f32,
+    pub children: Vec<ChildStats>,
+}
+
+/// Child process stats information
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub struct ChildStats {
+    pub pid: u32,
+    pub memory_usage: u64,
+    pub cpu_usage: f32,
+}
+
 pub struct ApiServer {
     _handle: ServerHandle,
 }

src/app/mod.rs

@@ -177,6 +177,13 @@ pub async fn kill(socket: &str, name: String, signal: String) -> Result<()> {
     Ok(())
 }
 
+pub async fn stats(socket: &str, name: String) -> Result<()> {
+    let client = IpcClientBuilder::default().build(socket.into()).await?;
+    let results = client.stats(name).await?;
+    encoder::to_writer(std::io::stdout(), &results)?;
+    Ok(())
+}
+
 pub async fn logs(
     socket: &str,
     filter: Option<String>,

src/app/rpc.rs

@@ -1,4 +1,4 @@
-use crate::app::api::Status;
+use crate::app::api::{Status, Stats, ChildStats};
 use crate::zinit::config;
 use async_trait::async_trait;
 use jsonrpsee::core::{RpcResult, SubscriptionResult};
@@ -84,6 +84,10 @@ pub trait ZinitServiceApi {
     /// Get the content of a service configuration file as a JSON Value.
     #[method(name = "get")]
     async fn get(&self, name: String) -> RpcResult<Value>;
+
+    /// Get memory and CPU usage statistics for a service.
+    #[method(name = "stats")]
+    async fn stats(&self, name: String) -> RpcResult<Stats>;
 }
 
 #[async_trait]
@@ -273,6 +277,28 @@ impl ZinitServiceApiServer for Api {
 
         Ok(json_value)
     }
+
+    async fn stats(&self, name: String) -> RpcResult<Stats> {
+        let stats = self
+            .zinit
+            .stats(&name)
+            .await
+            .map_err(|_| ErrorObjectOwned::from(ErrorCode::InternalError))?;
+
+        let result = Stats {
+            name: name.clone(),
+            pid: stats.pid as u32,
+            memory_usage: stats.memory_usage,
+            cpu_usage: stats.cpu_usage,
+            children: stats.children.into_iter().map(|child| ChildStats {
+                pid: child.pid as u32,
+                memory_usage: child.memory_usage,
+                cpu_usage: child.cpu_usage,
+            }).collect(),
+        };
+
+        Ok(result)
+    }
 }
 
 /// RPC methods for system-level operations.