Render Monitor

RenderOfficialCreated by Render

Skill
Tool integration
Cloud and DevOps
MIT
No issues found

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

Download the skill as a ZIP:
https://mp-staging.autogineer.com/agent-skills/render-oss/render-monitor/download

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"]
)

Metric	Healthy	Warning	Critical
CPU	<70%	70-85%	>85%
Memory	<80%	80-90%	>90%

HTTP Latency

get_metrics(
  resourceId: "<service-id>",
  metricTypes: ["http_latency"],
  httpLatencyQuantile: 0.95
)

p95 Latency	Status
<200ms	Excellent
200-500ms	Good
500ms-1s	Concerning
>1s	Problem

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

Indicator	Healthy	Warning	Critical
Error Rate	<0.1%	0.1-1%	>1%
p95 Latency	<500ms	500ms-2s	>2s
CPU Usage	<70%	70-90%	>90%
Memory Usage	<80%	80-95%	>95%

References

Render access: references/render-access.md
Compute plans: references/compute-plans.md
Deployments: references/deployments.md
Metrics guide: references/metrics-guide.md

render-deploy — Deploy new applications to Render
render-debug — Diagnose and fix deployment failures
render-mcp — MCP server setup and capability discovery

Current documentation retrieval

Whenever this skill directs you to consult current Render documentation:

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.
Confirm that retrieval succeeded and returned the expected document, then read its contents. Saving a file or printing its path is not sufficient.
If the request fails or your tool cannot read the Markdown response, open and read the linked HTML version instead.
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.

Files

ATTRIBUTION.mdAdded by AutoGineer884 B
LICENSELicence file added by AutoGineer1.0 KiB
SKILL.md7.3 KiB
references/compute-plans.md2.3 KiB
references/deployments.md7.9 KiB
references/metrics-guide.md7.8 KiB
references/render-access.md4.7 KiB

references/render-access.md

Accessing Render

Prefer the hosted Render MCP server for structured access to Render resources when its tools are available. Use the Render CLI when MCP is unavailable or does not support the required operation, and use the Render Dashboard or API for capabilities exposed by neither. Do not assume that a remembered MCP tool or CLI command is still available; inspect the tools in the current environment or consult the current documentation.

The hosted Render MCP server uses streamable HTTP at:

https://mcp.render.com/mcp

Official Render plugins and connectors can authenticate MCP with browser-based OAuth. Manual and non-interactive configurations can use a Render API key as a bearer token. Never write an API key or OAuth token into a repository, skill, command output, chat response, or log. Prefer the client's supported secret storage or environment-variable mechanism. If a client requires a credential in local configuration, keep that file out of version control and restrict access to it.

Treat MCP responses as potentially sensitive even when the server attempts to minimize credential exposure. Request connection strings, credentials, secret environment variables, or other sensitive fields only when the task requires them. Do not repeat sensitive values in the response or persist them in files or logs.

Before configuring or troubleshooting MCP, fetch the current setup and capability reference:

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

Read the relevant client setup, supported-actions, and limitations sections. Prefer the hosted server unless the user's environment requires a local MCP server. After installing, updating, or reconfiguring an MCP integration, reload the client as required and verify the connection with a read-only operation such as listing services.

Most MCP operations and Render CLI commands that access Render resources are scoped to an active workspace. Check the selected workspace before reading or changing resources. If no workspace is selected—or if the intended workspace is ambiguous—list the available workspaces and have the user identify the correct one. Do not silently switch workspace context or infer it from a resource name. Commands for authentication, help, CLI configuration, and workspace discovery or selection do not require an already selected workspace.

For interactive CLI use, authenticate with render login. For automation, use a securely stored RENDER_API_KEY; an API key takes precedence over a saved CLI token. Verify CLI access and the active workspace with read-only commands before operating on resources:

render whoami --output json
render workspace current --output json

For CLI installation, authentication, workspace setup, and usage patterns, fetch the current CLI overview:

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

For exact command syntax and flags, prefer the help text from the installed CLI because it matches the version being used:

render help <command>

The published CLI command reference is generated automatically from the CLI's help text. Use it to browse the full command surface or when the CLI is not installed:

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

When an agent or automation invokes the CLI, select a non-interactive output format such as --output json, --output yaml, or --output text so results can be inspected reliably. The global --confirm flag skips confirmation prompts; use it for a mutating command only after that mutation is authorized. It is an execution convenience, not permission to perform the action.

Authentication establishes access; it does not establish user authorization for every available action. Use read-only discovery to resolve workspace, resource identity, and current state before a mutation. Perform changes only when they are within the user's requested scope, and retain normal approval requirements for consequential operations such as creation, configuration changes, deploys, restarts, scaling, or deletion.

When authentication or connectivity fails, report which access path failed, preserve the underlying error without exposing credentials, and either use an available supported fallback or explain what the user must configure before the task can continue.

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

2026-11-08

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

From the author

AutoGineer summary

What it does

When to use it

Advantages

Usage examples

Install

Documentation by Render

Monitor Render Services

When to Use This Skill

Render Access

Quick Health Check

Service Health

Check Status

Check Deployments

Check Errors

Performance Metrics

CPU & Memory

HTTP Latency

Request Count

Filter by Endpoint

Database Monitoring

PostgreSQL Status

Connection Count

Query Database

Find Slow Queries

Key-Value Store

Log Monitoring

Recent Logs

Error Logs

Search Logs

Filter by Time

Stream Logs (CLI)

Quick Reference

MCP Tools

CLI Commands (Fallback)

Healthy Service Indicators

References

Related Skills

Current documentation retrieval

Files

references/render-access.md

Accessing Render

Requirements and compatibility

Security

Attribution and licence

Related skills

Spark Memory Thermal Ops

Observability And Instrumentation

Gke Alert Configuration

Application Performance Observability Engineer

Distributed Debugging Devops Troubleshooter

Distributed Tracing

Download ZIP