AutoGineer
Generated banner for Render Monitor
Generated logo for Render Monitor

Render Monitor

RenderOfficialCreated by Render

  • Skill
  • Tool integration
  • Cloud and DevOps
  • MIT
  • No issues found
Download ZIP

From the author

Monitor Render services in real-time. Check health, performance metrics, logs, and resource usage. Use when users want to check service status, view metrics, monitor performance, or verify deployments are healthy.
— the description by Render

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The render-monitor skill provides a structured approach to observing the health and performance of services hosted on Render. It enables users to perform real-time checks on service status, resource utilization, HTTP latency, and database health. By leveraging MCP tools or CLI commands, the skill facilitates log analysis, error tracking, and deployment verification, ensuring that users can maintain stable and performant applications.

What it does

  • Checks the health status of active Render services.
  • Retrieves performance metrics including CPU, memory, and HTTP latency.
  • Monitors and filters logs to identify errors or specific events.
  • Verifies the status of recent deployments.
  • Provides database monitoring for PostgreSQL instances and key-value stores.
  • Offers fallback CLI commands for environments where MCP tools are unavailable.

When to use it

  • When investigating slow application performance or high latency.
  • To verify if a recent deployment is healthy and live.
  • When troubleshooting errors by inspecting service logs.
  • To monitor resource usage trends for capacity planning.
  • When checking the status of database connections or query performance.

Advantages

  • Provides a unified interface for both MCP and CLI-based monitoring.
  • Includes clear health thresholds for CPU, memory, and latency metrics.
  • Supports granular log filtering by level, text, and time range.
  • Enables direct database inspection through query execution.
  • Integrates with standard Render documentation workflows for up-to-date information.

Usage examples

“Is my web service healthy right now?”
The agent will list the service status, check the latest deployment, and review recent error logs to provide a health summary.
“Why is my API responding slowly?”
The agent will retrieve p95 HTTP latency metrics and check CPU/memory usage to identify potential bottlenecks.
“Show me the last 20 error logs for my service.”
The agent will execute a log retrieval command filtered by the 'error' level for the specified service ID.
“Are there any slow queries in my database?”
The agent will query the database's pg_stat_statements to identify and list the queries with the highest mean execution time.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/render-oss/render-monitor/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip render-monitor.zip -d .agents/skills

Documentation by Render

Monitor Render Services

Real-time monitoring of Render services including health checks, performance metrics, and logs.

When to Use This Skill

Activate this skill when users want to:

  • Check if services are healthy

  • View performance metrics

  • Monitor logs

  • Verify a deployment is working

  • Investigate slow performance

  • Check database health

Render Access

Before reading service state, logs, metrics, or database health, follow references/render-access.md to establish access and verify the intended workspace. Prefer MCP when available; the CLI can provide service status and logs, while metrics and database queries require MCP.

Before interpreting deploy or health-check state, read references/deployments.md.

Quick Health Check

Run these 5 checks to assess service health:

# 1. Check service status
list_services()

# 2. Check latest deploy
list_deploys(serviceId: "<service-id>", limit: 1)

# 3. Check for errors
list_logs(resource: ["<service-id>"], level: ["error"], limit: 20)

# 4. Check resource usage
get_metrics(resourceId: "<service-id>", metricTypes: ["cpu_usage", "memory_usage"])

# 5. Check latency
get_metrics(resourceId: "<service-id>", metricTypes: ["http_latency"], httpLatencyQuantile: 0.95)

Service Health

Check Status
list_services()
get_service(serviceId: "<id>")
Check Deployments
list_deploys(serviceId: "<service-id>", limit: 5)

Follow references/deployments.md to interpret asynchronous and terminal states, identify the specific deploy, and verify the workload after it becomes live.

Check Errors
list_logs(resource: ["<service-id>"], level: ["error"], limit: 50)
list_logs(resource: ["<service-id>"], statusCode: ["500", "502", "503"], limit: 50)

Performance Metrics

CPU & Memory
get_metrics(
  resourceId: "<service-id>",
  metricTypes: ["cpu_usage", "memory_usage", "cpu_limit", "memory_limit"]
)
MetricHealthyWarningCritical
CPU<70%70-85%>85%
Memory<80%80-90%>90%
HTTP Latency
get_metrics(
  resourceId: "<service-id>",
  metricTypes: ["http_latency"],
  httpLatencyQuantile: 0.95
)
p95 LatencyStatus
<200msExcellent
200-500msGood
500ms-1sConcerning
>1sProblem
Request Count
get_metrics(
  resourceId: "<service-id>",
  metricTypes: ["http_request_count"]
)
Filter by Endpoint
get_metrics(
  resourceId: "<service-id>",
  metricTypes: ["http_latency"],
  httpPath: "/api/users"
)

Detailed metrics guide: references/metrics-guide.md

Database Monitoring

PostgreSQL Status
list_postgres_instances()
get_postgres(postgresId: "<postgres-id>")
Connection Count
get_metrics(resourceId: "<postgres-id>", metricTypes: ["active_connections"])
Query Database
query_render_postgres(
  postgresId: "<postgres-id>",
  sql: "SELECT state, count(*) FROM pg_stat_activity GROUP BY state"
)
Find Slow Queries
query_render_postgres(
  postgresId: "<postgres-id>",
  sql: "SELECT query, mean_exec_time FROM pg_stat_statements ORDER BY mean_exec_time DESC LIMIT 10"
)
Key-Value Store
list_key_value()
get_key_value(keyValueId: "<kv-id>")

Log Monitoring

Recent Logs
list_logs(resource: ["<service-id>"], limit: 100)
Error Logs
list_logs(resource: ["<service-id>"], level: ["error"], limit: 50)
Search Logs
list_logs(resource: ["<service-id>"], text: ["timeout", "error"], limit: 50)
Filter by Time
list_logs(
  resource: ["<service-id>"],
  startTime: "2024-01-15T10:00:00Z",
  endTime: "2024-01-15T11:00:00Z"
)
Stream Logs (CLI)
render logs -r <service-id> --tail -o text

Quick Reference

MCP Tools
# Services
list_services()
get_service(serviceId: "<id>")
list_deploys(serviceId: "<id>", limit: 5)

# Logs
list_logs(resource: ["<id>"], level: ["error"], limit: 100)
list_logs(resource: ["<id>"], text: ["search"], limit: 50)

# Metrics
get_metrics(resourceId: "<id>", metricTypes: ["cpu_usage", "memory_usage"])
get_metrics(resourceId: "<id>", metricTypes: ["http_latency"], httpLatencyQuantile: 0.95)
get_metrics(resourceId: "<id>", metricTypes: ["http_request_count"])

# Database
list_postgres_instances()
get_postgres(postgresId: "<id>")
query_render_postgres(postgresId: "<id>", sql: "SELECT ...")
get_metrics(resourceId: "<postgres-id>", metricTypes: ["active_connections"])

# Key-Value
list_key_value()
get_key_value(keyValueId: "<id>")
CLI Commands (Fallback)

Use these if MCP tools are unavailable:

# Service status
render services -o json
render services instances <service-id>

# Deployments
render deploys list <service-id> -o json

# Logs
render logs -r <service-id> --tail -o text          # Stream logs
render logs -r <service-id> --level error -o json   # Error logs
render logs -r <service-id> --type deploy -o json   # Build logs

# Database
render psql <database-id>                           # Connect to PostgreSQL

# SSH for live debugging
render ssh <service-id>
Healthy Service Indicators
IndicatorHealthyWarningCritical
Error Rate<0.1%0.1-1%>1%
p95 Latency<500ms500ms-2s>2s
CPU Usage<70%70-90%>90%
Memory Usage<80%80-95%>95%

References

Related Skills

  • render-deploy — Deploy new applications to Render

  • render-debug — Diagnose and fix deployment failures

  • render-mcp — MCP server setup and capability discovery

<!-- shared:documentation-retrieval -->

Current documentation retrieval

Whenever this skill directs you to consult current Render documentation:

  1. Retrieve the linked Markdown document directly with an available URL-fetching tool or HTTP client, such as curl. Do not substitute web-search summaries for the document.

  2. Confirm that retrieval succeeded and returned the expected document, then read its contents. Saving a file or printing its path is not sufficient.

  3. If the request fails or your tool cannot read the Markdown response, open and read the linked HTML version instead.

  4. If neither version can be retrieved, disclose that the current reference is unavailable and follow any topic-specific fallback in the skill. Use bundled guidance only for stable constraints, and do not guess at changeable platform details.

When a task requires multiple references, apply this workflow to each one and distinguish the documents you verified from those that remain unavailable.

<!-- /shared:documentation-retrieval -->

Files

references/compute-plans.md

<!-- shared:compute-plans -->

Compute plans

A compute plan determines the CPU and RAM available to each instance of a Render service. Use compute plan, not the former term instance type. Do not confuse a service's compute plan with its workspace plan, which controls account-level features and limits.

Compute plans differ by service type:

  • Web services, private services, background workers, and cron jobs use CPU-and-memory plan IDs such as 0.5c-512mb and 1c-2g.

  • Render Postgres has its own plan catalog and connection limits.

  • Render Key Value uses memory-based plan IDs such as 256mb and 1g.

  • Workflow tasks select a compute plan in application code; a Workflow service does not set a Blueprint plan.

  • Static sites do not have compute plans.

Legacy plan names such as starter, standard, and pro remain valid in Render tooling, including Blueprints and API requests. For new configuration, prefer the current plan ID when the selected configuration surface accepts it. Before passing a plan to an API, MCP tool, or CLI command, inspect that operation's current schema or help and use one of its accepted values; the compute-plan reference describes the product catalog, not every tool version's input contract. Do not rename an existing legacy plan merely for consistency unless the user asks for that change.

Do not rely on a memorized plan catalog. When a task depends on current plan IDs, specifications, defaults, availability, or pricing, fetch the canonical compute-plan reference:

Using the documentation-retrieval workflow in the root SKILL.md, retrieve and read the Markdown reference or its HTML version.

Read the section for the relevant service type. If the document cannot be fetched, do not guess at current plan details. Preserve an existing valid plan where possible, or explain that the plan must be confirmed in the Render Dashboard or current documentation.

When estimating capacity or cost, remember that every instance of a scaled service uses the selected compute plan and is billed accordingly. Changing the compute plan for Render Postgres, Render Key Value, or a service with an attached persistent disk requires brief downtime; other services normally apply the change with a zero-downtime deploy.

<!-- /shared:compute-plans -->

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs an MCP server

The author says: Requires Render MCP tools or CLI

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Render
Publisher
Render (Official)
Source
render-oss/skills · skills/render-monitor · commit b985a63
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Render.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download render-monitor.zip