AutoGineer
Generated banner for Grafana Dashboards
Generated logo for Grafana Dashboards

Grafana Dashboards

Seth HobsonCommunityCreated by Seth Hobson

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

From the author

Create and manage production Grafana dashboards for real-time visualization of system and application metrics. Use when building monitoring dashboards, visualizing metrics, or creating operational observability interfaces.
— the description by Seth Hobson

AutoGineer summary

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

This skill provides a comprehensive framework for creating effective Grafana dashboards. It covers essential design principles like the RED and USE methods, provides JSON templates for various panel types (stat, time series, table, heatmap), and explains how to implement dynamic variables and alerting. Additionally, it offers guidance on dashboard provisioning using configuration files, Terraform, and Ansible, ensuring a consistent approach to infrastructure and application monitoring.

What it does

  • Defines design principles for effective dashboard hierarchy and layout.
  • Provides JSON templates for common Grafana panel types.
  • Explains how to implement dynamic query variables for flexible dashboards.
  • Details the configuration of alerting rules within dashboard definitions.
  • Outlines methods for provisioning dashboards as code using Terraform and Ansible.
  • Offers best practices for consistent naming, grouping, and threshold configuration.

When to use it

  • When building new monitoring dashboards for infrastructure or applications.
  • When standardizing observability interfaces across a team or organization.
  • When automating the deployment of dashboards via infrastructure-as-code.
  • When implementing SLO-based monitoring or tracking business KPIs.

Advantages

  • Promotes consistent, professional dashboard design through established methodologies.
  • Reduces manual effort by providing reusable JSON templates and provisioning patterns.
  • Facilitates infrastructure-as-code workflows for dashboard management.
  • Improves observability by standardizing how metrics are visualized and alerted upon.

Usage examples

“Create a JSON template for a Grafana stat panel showing total requests with color-coded thresholds.”
The agent provides a structured JSON snippet for a stat panel, including field configuration for absolute thresholds (green, yellow, red) and reduction options.
“How should I structure a dashboard to monitor a microservice using the RED method?”
The agent outlines a layout focusing on Request Rate, Error Rate, and Duration (Latency), providing the corresponding Prometheus query expressions for each.
“Show me how to provision a Grafana dashboard using Terraform.”
The agent provides a Terraform HCL example using the grafana_dashboard resource to load a JSON configuration file into a specific folder.
“How can I add a dropdown variable for namespaces in my dashboard?”
The agent provides a JSON template for a query-type variable that fetches namespace values from Prometheus, along with an example of how to reference it in a query.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/wshobson/grafana-dashboards/download

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

    mkdir -p .agents/skills && unzip grafana-dashboards.zip -d .agents/skills

Documentation by Seth Hobson

Grafana Dashboards

Create and manage production-ready Grafana dashboards for comprehensive system observability.

Purpose

Design effective Grafana dashboards for monitoring applications, infrastructure, and business metrics.

When to Use

  • Visualize Prometheus metrics

  • Create custom dashboards

  • Implement SLO dashboards

  • Monitor infrastructure

  • Track business KPIs

Dashboard Design Principles

1. Hierarchy of Information
┌─────────────────────────────────────┐
│  Critical Metrics (Big Numbers)     │
├─────────────────────────────────────┤
│  Key Trends (Time Series)           │
├─────────────────────────────────────┤
│  Detailed Metrics (Tables/Heatmaps) │
└─────────────────────────────────────┘
2. RED Method (Services)

  • Rate - Requests per second

  • Errors - Error rate

  • Duration - Latency/response time

3. USE Method (Resources)

  • Utilization - % time resource is busy

  • Saturation - Queue length/wait time

  • Errors - Error count

Dashboard Structure

API Monitoring Dashboard
{
  "dashboard": {
    "title": "API Monitoring",
    "tags": ["api", "production"],
    "timezone": "browser",
    "refresh": "30s",
    "panels": [
      {
        "title": "Request Rate",
        "type": "graph",
        "targets": [
          {
            "expr": "sum(rate(http_requests_total[5m])) by (service)",
            "legendFormat": "{{service}}"
          }
        ],
        "gridPos": { "x": 0, "y": 0, "w": 12, "h": 8 }
      },
      {
        "title": "Error Rate %",
        "type": "graph",
        "targets": [
          {
            "expr": "(sum(rate(http_requests_total{status=~\"5..\"}[5m])) / sum(rate(http_requests_total[5m]))) * 100",
            "legendFormat": "Error Rate"
          }
        ],
        "alert": {
          "conditions": [
            {
              "evaluator": { "params": [5], "type": "gt" },
              "operator": { "type": "and" },
              "query": { "params": ["A", "5m", "now"] },
              "type": "query"
            }
          ]
        },
        "gridPos": { "x": 12, "y": 0, "w": 12, "h": 8 }
      },
      {
        "title": "P95 Latency",
        "type": "graph",
        "targets": [
          {
            "expr": "histogram_quantile(0.95, sum(rate(http_request_duration_seconds_bucket[5m])) by (le, service))",
            "legendFormat": "{{service}}"
          }
        ],
        "gridPos": { "x": 0, "y": 8, "w": 24, "h": 8 }
      }
    ]
  }
}

Panel Types

1. Stat Panel (Single Value)
{
  "type": "stat",
  "title": "Total Requests",
  "targets": [
    {
      "expr": "sum(http_requests_total)"
    }
  ],
  "options": {
    "reduceOptions": {
      "values": false,
      "calcs": ["lastNotNull"]
    },
    "orientation": "auto",
    "textMode": "auto",
    "colorMode": "value"
  },
  "fieldConfig": {
    "defaults": {
      "thresholds": {
        "mode": "absolute",
        "steps": [
          { "value": 0, "color": "green" },
          { "value": 80, "color": "yellow" },
          { "value": 90, "color": "red" }
        ]
      }
    }
  }
}
2. Time Series Graph
{
  "type": "graph",
  "title": "CPU Usage",
  "targets": [
    {
      "expr": "100 - (avg by (instance) (rate(node_cpu_seconds_total{mode=\"idle\"}[5m])) * 100)"
    }
  ],
  "yaxes": [
    { "format": "percent", "max": 100, "min": 0 },
    { "format": "short" }
  ]
}
3. Table Panel
{
  "type": "table",
  "title": "Service Status",
  "targets": [
    {
      "expr": "up",
      "format": "table",
      "instant": true
    }
  ],
  "transformations": [
    {
      "id": "organize",
      "options": {
        "excludeByName": { "Time": true },
        "indexByName": {},
        "renameByName": {
          "instance": "Instance",
          "job": "Service",
          "Value": "Status"
        }
      }
    }
  ]
}
4. Heatmap
{
  "type": "heatmap",
  "title": "Latency Heatmap",
  "targets": [
    {
      "expr": "sum(rate(http_request_duration_seconds_bucket[5m])) by (le)",
      "format": "heatmap"
    }
  ],
  "dataFormat": "tsbuckets",
  "yAxis": {
    "format": "s"
  }
}

Variables

Query Variables
{
  "templating": {
    "list": [
      {
        "name": "namespace",
        "type": "query",
        "datasource": "Prometheus",
        "query": "label_values(kube_pod_info, namespace)",
        "refresh": 1,
        "multi": false
      },
      {
        "name": "service",
        "type": "query",
        "datasource": "Prometheus",
        "query": "label_values(kube_service_info{namespace=\"$namespace\"}, service)",
        "refresh": 1,
        "multi": true
      }
    ]
  }
}
Use Variables in Queries
sum(rate(http_requests_total{namespace="$namespace", service=~"$service"}[5m]))

Alerts in Dashboards

{
  "alert": {
    "name": "High Error Rate",
    "conditions": [
      {
        "evaluator": {
          "params": [5],
          "type": "gt"
        },
        "operator": { "type": "and" },
        "query": {
          "params": ["A", "5m", "now"]
        },
        "reducer": { "type": "avg" },
        "type": "query"
      }
    ],
    "executionErrorState": "alerting",
    "for": "5m",
    "frequency": "1m",
    "message": "Error rate is above 5%",
    "noDataState": "no_data",
    "notifications": [{ "uid": "slack-channel" }]
  }
}

Dashboard Provisioning

dashboards.yml:

apiVersion: 1

providers:
  - name: "default"
    orgId: 1
    folder: "General"
    type: file
    disableDeletion: false
    updateIntervalSeconds: 10
    allowUiUpdates: true
    options:
      path: /etc/grafana/dashboards

Common Dashboard Patterns

Infrastructure Dashboard

Key Panels:

  • CPU utilization per node

  • Memory usage per node

  • Disk I/O

  • Network traffic

  • Pod count by namespace

  • Node status

Database Dashboard

Key Panels:

  • Queries per second

  • Connection pool usage

  • Query latency (P50, P95, P99)

  • Active connections

  • Database size

  • Replication lag

  • Slow queries

Application Dashboard

Key Panels:

  • Request rate

  • Error rate

  • Response time (percentiles)

  • Active users/sessions

  • Cache hit rate

  • Queue length

Best Practices

  1. Start with templates (Grafana community dashboards)

  2. Use consistent naming for panels and variables

  3. Group related metrics in rows

  4. Set appropriate time ranges (default: Last 6 hours)

  5. Use variables for flexibility

  6. Add panel descriptions for context

  7. Configure units correctly

  8. Set meaningful thresholds for colors

  9. Use consistent colors across dashboards

  10. Test with different time ranges

Dashboard as Code

Terraform Provisioning
resource "grafana_dashboard" "api_monitoring" {
  config_json = file("${path.module}/dashboards/api-monitoring.json")
  folder      = grafana_folder.monitoring.id
}

resource "grafana_folder" "monitoring" {
  title = "Production Monitoring"
}
Ansible Provisioning
- name: Deploy Grafana dashboards
  copy:
    src: "{{ item }}"
    dest: /etc/grafana/dashboards/
  with_fileglob:
    - "dashboards/*.json"
  notify: restart grafana

Related Skills

  • prometheus-configuration - For metric collection

  • slo-implementation - For SLO dashboards

Files

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 Node.js

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
Seth Hobson
Publisher
Seth Hobson (Community)
Source
wshobson/agents · plugins/observability-monitoring/skills/grafana-dashboards · commit 4bde316
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 Seth Hobson or Seth Hobson.

Download ZIP

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