Early Adopters: First 20 receive 20% off with 1 year technical support.

RogueDB logo

RogueDB

DEVELOPERSENTERPRISEDOCSPRICING

Global Protocol

Observability & Monitoring

RogueDB provides agent-less observability. The database exposes performance metrics through a simple API with practically zero impact to active workloads.

1. The Monitoring API

Observability in RogueDB is request-driven. You query your performance data exactly as you query your business data.

The Monitor Request

Use the Monitor message to define the window and granularity of the performance data you wish to retrieve.

Protobuf

enum Aggregate {
    INVALID_AGGREGATE = 0;
    MINUTE = 1;
    HOUR = 60;
    DAY = 1440;
    WEEK = 10080;
}

message Monitor {
    string api_key = 1;      // Requires admin or monitoring permissions
    uint32 hours = 2;        // How far back to look
    Aggregate aggregate = 3; // Granularity of the data points
    uint32 period = 4;       // Number of units per data point
}

The Performance Response

The database returns a high-fidelity time-series object. Because these are returned as repeated arrays, they are ready for immediate injection into your front-end charting libraries (e.g., Chart.js, D3) without additional processing.

Protobuf

message Performance {
    repeated uint64 timestamps = 1;             // Seconds since epoch
    repeated double cpu_utilization = 2;        // Percentage
    repeated double iops_utilization = 3;       // Percentage
    repeated double throughput_utilization = 4; // Percentage
    
    // Cumulative Totals & Peaks
    double peak_cpu_utilization = 7;
    uint64 total_network_received = 12;         // Bytes
    uint64 total_storage = 14;                  // Bytes
    uint64 available_storage = 15;              // Bytes
    // ... [See full .proto for all peak/network fields]
}

2. Why RogueDB Observability is Different

We have intentionally excluded "standard" monitoring integrations (like Prometheus or DataDog agents) to preserve the performance and simplicity of the database engine.

Zero Resource Contention

Third-party monitoring libraries add significant binary bloat and background CPU cycles. By using a native Protobuf API, observability has a near-zero impact on your throughput.

Native Time-Series Aggregation

The database performs the heavy lifting of calculating averages and peaks server-side. You receive clean, aggregated data points rather than raw, noisy logs.

Streamlined Signal

In a fully managed environment, infrastructure "noise" is irrelevant. RogueDB exposes only the metrics that directly impact your application: CPU, IOPS, Network, and Storage.

3. Code Example

To monitor your instance, ensure your User API Key has the monitor boolean set to true in the User schema.

C++

Python

Go

rogue::services::Monitor monitor{};
monitor.set_api_key(API_KEY);
monitor.set_hours(24);
monitor.set_aggregate(rogue::services::Aggregate::MINUTE);
monitor.set_period(5); // 5 min. increments

rogue::services::Performance response{};
// Any schemas excluded will have associated data deleted.
// Schema change failure results in no changes applied.
// Response contains the Registry proto without the import paths.
roguedb->monitor(&context, monitor, &response);

On This Page