Monitoring Dashboard Templates

This page provides ready-to-use monitoring dashboard templates for Java applications. These templates can be imported into popular monitoring tools like Grafana, Prometheus, and Datadog to provide immediate visibility into your Java applications' performance and health.

Dashboard Categories

JVM Metrics

Monitor Java Virtual Machine performance, memory usage, and garbage collection

View Dashboards

Application Metrics

Monitor application-specific metrics like request rates, errors, and response times

View Dashboards

Database Performance

Monitor database connections, query performance, and overall health

View Dashboards

Microservices

Monitor service interactions, distributed traces, and system health

View Dashboards

JVM Metrics Dashboards {: #jvm-dashboards}

Java Virtual Machine Overview

This dashboard provides a comprehensive view of JVM performance metrics, including memory usage, garbage collection, and thread states.

Metrics Included

• Heap Memory Usage (Used vs. Max)
• Non-Heap Memory Usage
• Garbage Collection Frequency and Duration
• Thread Count by State
• CPU Usage
• Classloading Statistics

Available For

Grafana Prometheus Datadog

Grafana Prometheus Datadog

{
  "annotations": {
    "list": [
      {
        "builtIn": 1,
        "datasource": "-- Grafana --",
        "enable": true,
        "hide": true,
        "iconColor": "rgba(0, 211, 255, 1)",
        "name": "Annotations & Alerts",
        "type": "dashboard"
      }
    ]
  },
  "editable": true,
  "gnetId": null,
  "graphTooltip": 0,
  "id": 1,
  "links": [],
  "panels": [
    {
      "aliasColors": {},
      "bars": false,
      "dashLength": 10,
      "dashes": false,
      "datasource": null,
      "fieldConfig": {
        "defaults": {
          "custom": {}
        },
        "overrides": []
      },
      "fill": 1,
      "fillGradient": 0,
      "gridPos": {
        "h": 8,
        "w": 12,
        "x": 0,
        "y": 0
      },
      "hiddenSeries": false,
      "id": 2,
      "legend": {
        "avg": false,
        "current": false,
        "max": false,
        "min": false,
        "show": true,
        "total": false,
        "values": false
      },
      "lines": true,
      "linewidth": 1,
      "nullPointMode": "null",
      "options": {
        "alertThreshold": true
      },
      "percentage": false,
      "pluginVersion": "7.2.0",
      "pointradius": 2,
      "points": false,
      "renderer": "flot",
      "seriesOverrides": [],
      "spaceLength": 10,
      "stack": false,
      "steppedLine": false,
      "targets": [
        {
          "expr": "jvm_memory_used_bytes{area=\"heap\"}",
          "interval": "",
          "legendFormat": "{{instance}} - {{id}}",
          "refId": "A"
        },
        {
          "expr": "jvm_memory_max_bytes{area=\"heap\"}",
          "interval": "",
          "legendFormat": "{{instance}} - {{id}} (Max)",
          "refId": "B"
        }
      ],
      "thresholds": [],
      "timeFrom": null,
      "timeRegions": [],
      "timeShift": null,
      "title": "JVM Heap Memory",
      "tooltip": {
        "shared": true,
        "sort": 0,
        "value_type": "individual"
      },
      "type": "graph",
      "xaxis": {
        "buckets": null,
        "mode": "time",
        "name": null,
        "show": true,
        "values": []
      },
      "yaxes": [
        {
          "format": "bytes",
          "label": null,
          "logBase": 1,
          "max": null,
          "min": null,
          "show": true
        },
        {
          "format": "short",
          "label": null,
          "logBase": 1,
          "max": null,
          "min": null,
          "show": true
        }
      ],
      "yaxis": {
        "align": false,
        "alignLevel": null
      }
    },
    {
      "aliasColors": {},
      "bars": false,
      "dashLength": 10,
      "dashes": false,
      "datasource": null,
      "fieldConfig": {
        "defaults": {
          "custom": {}
        },
        "overrides": []
      },
      "fill": 1,
      "fillGradient": 0,
      "gridPos": {
        "h": 8,
        "w": 12,
        "x": 12,
        "y": 0
      },
      "hiddenSeries": false,
      "id": 4,
      "legend": {
        "avg": false,
        "current": false,
        "max": false,
        "min": false,
        "show": true,
        "total": false,
        "values": false
      },
      "lines": true,
      "linewidth": 1,
      "nullPointMode": "null",
      "options": {
        "alertThreshold": true
      },
      "percentage": false,
      "pluginVersion": "7.2.0",
      "pointradius": 2,
      "points": false,
      "renderer": "flot",
      "seriesOverrides": [],
      "spaceLength": 10,
      "stack": false,
      "steppedLine": false,
      "targets": [
        {
          "expr": "rate(jvm_gc_collection_seconds_sum[1m])",
          "interval": "",
          "legendFormat": "{{instance}} - {{gc}}",
          "refId": "A"
        }
      ],
      "thresholds": [],
      "timeFrom": null,
      "timeRegions": [],
      "timeShift": null,
      "title": "GC Collection Time (1m rate)",
      "tooltip": {
        "shared": true,
        "sort": 0,
        "value_type": "individual"
      },
      "type": "graph",
      "xaxis": {
        "buckets": null,
        "mode": "time",
        "name": null,
        "show": true,
        "values": []
      },
      "yaxes": [
        {
          "format": "s",
          "label": null,
          "logBase": 1,
          "max": null,
          "min": null,
          "show": true
        },
        {
          "format": "short",
          "label": null,
          "logBase": 1,
          "max": null,
          "min": null,
          "show": true
        }
      ],
      "yaxis": {
        "align": false,
        "alignLevel": null
      }
    }
  ],
  "refresh": "10s",
  "schemaVersion": 26,
  "style": "dark",
  "tags": [
    "java",
    "jvm",
    "micrometer"
  ],
  "templating": {
    "list": []
  },
  "time": {
    "from": "now-3h",
    "to": "now"
  },
  "timepicker": {},
  "timezone": "",
  "title": "JVM Metrics Dashboard",
  "uid": "java-jvm-metrics",
  "version": 1
}

groups:
- name: JVMAlerts
  rules:
  - alert: HighHeapUsage
    expr: (jvm_memory_used_bytes{area="heap"} / jvm_memory_max_bytes{area="heap"} * 100) > 85
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "High heap memory usage (instance {{ $labels.instance }})"
      description: "JVM heap memory usage is above 85% for 5 minutes\n  VALUE = {{ $value }}%"

  - alert: LongGCPause
    expr: rate(jvm_gc_collection_seconds_sum[1m]) > 0.5
    for: 2m
    labels:
      severity: warning
    annotations:
      summary: "Long garbage collection pauses (instance {{ $labels.instance }})"
      description: "GC pause time is taking more than 0.5s per minute\n  VALUE = {{ $value }}s"

{
  "title": "JVM Overview",
  "description": "Dashboard for monitoring JVM metrics",
  "widgets": [
    {
      "id": 123456,
      "definition": {
        "type": "timeseries",
        "requests": [
          {
            "q": "avg:jvm.heap_memory{*} by {host}",
            "display_type": "line"
          },
          {
            "q": "avg:jvm.heap_memory_max{*} by {host}",
            "display_type": "line"
          }
        ],
        "title": "JVM Heap Memory",
        "show_legend": true
      }
    }
  ],
  "template_variables": [],
  "layout_type": "ordered",
  "notify_list": []
}

Garbage Collection Performance

This specialized dashboard focuses on garbage collection performance, helping you identify GC-related performance issues.

Metrics Included

• GC Collection Counts
• GC Collection Times
• Memory Pool Sizes Before/After GC
• Allocation Rates
• Promotion Rates

Available For

Grafana Prometheus

Application Metrics Dashboards {: #application-dashboards}

Spring Boot Application Dashboard

A comprehensive dashboard for monitoring Spring Boot applications, including HTTP metrics, caches, and system resources.

Metrics Included

• Request Rate, Errors, Duration (RED)
• Endpoint Latency Distribution
• System Resources (CPU, Memory)
• Tomcat Thread Pool Usage
• Cache Hit Rates
• Client HTTP Requests

Available For

Grafana Datadog New Relic

Java API Performance Dashboard

A dashboard focused on API performance for Java applications, with detailed endpoint metrics and SLA tracking.

Metrics Included

• Endpoint Response Times (P50, P90, P99)
• Request Throughput by Endpoint
• Error Rates and Status Codes
• SLA Compliance
• Active Sessions
• Rate Limiting Metrics

Available For

Grafana Datadog

Database Dashboards {: #database-dashboards}

JDBC Connection Pool Dashboard

Monitor database connection pools in Java applications to optimize resource usage and identify connection leaks.

Metrics Included

• Active/Idle Connections
• Connection Acquisition Time
• Pool Saturation
• Connection Timeouts
• Query Execution Time
• Transaction Duration

Available For

Grafana Prometheus

Hibernate ORM Dashboard

Monitor Hibernate ORM performance metrics to optimize database interaction in Java applications.

Metrics Included

• Session Metrics
• Entity Cache Hit Rates
• Query Cache Performance
• Transaction Metrics
• Statement Execution Count
• 2nd Level Cache Statistics

Available For

Grafana

Microservices Dashboards {: #microservices-dashboards}

Microservices Overview Dashboard

A comprehensive view of microservices health and interactions in a Java microservices architecture.

Metrics Included

• Service Health Status
• Inter-service Communication
• Error Rates by Service
• Latency Between Services
• Circuit Breaker States
• Request Tracing

Available For

Grafana Datadog

Circuit Breaker Dashboard

Monitor circuit breakers in Java microservices using libraries like Resilience4j or Hystrix.

Metrics Included

• Circuit State (Open/Closed/Half-Open)
• Success/Failure Rates
• Slow Call Percentage
• Request Volume
• Circuit Transitions
• Failure Rate Threshold

Available For

Grafana

Custom Dashboard Generator

Use our dashboard generator to create custom monitoring dashboards tailored to your Java application's needs.

Dashboard Generator

Dashboard Name:

Monitoring Platform: Grafana Prometheus Datadog New Relic

Include Metric Categories:

JVM Metrics Application Metrics Database Metrics Distributed Tracing System Metrics

Application Framework: Spring Boot Quarkus Micronaut Jakarta EE Generic Java

Dashboard Style: Detailed (Many Panels) Concise (Key Metrics Only) Alert-Focused

Generate Dashboard

Your Custom Dashboard

Download Dashboard

Setting Up Alert Rules

Each dashboard template includes recommended alert rules to help you proactively monitor your Java applications.

Common Alert Rules for Java Applications

High JVM Heap Usage

Alerts when heap memory usage exceeds 85% for 5 minutes.

Severity: Warning

Resolution: Check for memory leaks, increase heap size, or optimize application memory usage.

High GC Pause Time

Alerts when garbage collection pause time exceeds 500ms per minute.

Severity: Warning

Resolution: Tune GC parameters, investigate memory usage patterns, or consider GC algorithm change.

High Error Rate

Alerts when HTTP error rate (5xx responses) exceeds 5% over 3 minutes.

Severity: Critical

Resolution: Check application logs, review recent deployments, or verify downstream service health.

Slow Response Time

Alerts when 95th percentile response time exceeds defined SLA (e.g., 500ms) for 5 minutes.

Severity: Warning

Resolution: Profile application, check database queries, or verify system resources.

Dashboard Customization Tips

Here are some best practices for customizing these dashboard templates for your specific needs:

1. Focus on Critical Metrics: Start with key metrics that impact your users and business, then add more detailed panels as needed.

2. Group Related Metrics: Organize your dashboard into logical sections (JVM, application, database, etc.) for easier navigation.

3. Use Consistent Naming: Maintain consistent metric naming and labeling conventions across all dashboards.

4. Add Context: Include documentation links, runbooks, or description text to help users understand each panel.

5. Set Appropriate Time Ranges: Configure default time ranges that make sense for your metrics (e.g., 6 hours for application metrics, 24 hours for system metrics).

6. Configure Alerting Thresholds: Set alert thresholds based on your specific application's normal behavior and SLAs.

7. Use Variables: Leverage dashboard variables for environment, service, or instance selection to make dashboards reusable.

8. Regular Review: Schedule regular reviews of your dashboards to ensure they remain relevant as your application evolves.

Implementation Notes

To use these dashboard templates, you'll need to:

1. Instrument Your Application: Ensure your Java application is properly instrumented to expose metrics:
2. For Spring Boot, add the Micrometer and Actuator dependencies

3. For other frameworks, use the appropriate instrumentation libraries

4. Set Up Metric Collection: Configure your monitoring system to collect metrics from your application:

5. For Prometheus, configure scraping endpoints
6. For Datadog, install and configure the agent

7. For other systems, follow their specific setup instructions

8. Import Dashboard: Import the dashboard template into your monitoring system:

9. For Grafana, use the Import Dashboard feature and paste the JSON

10. For other systems, follow their dashboard import procedure

11. Customize: Adjust the dashboard to match your specific metrics, naming conventions, and requirements

JavaScript Implementation Note

The dashboard download and preview functionality requires JavaScript:

document.addEventListener('DOMContentLoaded', function() {
    // Dashboard template selector
    document.querySelectorAll('.dashboard-download-btn').forEach(button => {
        button.addEventListener('click', function(e) {
            e.preventDefault();
            const format = this.dataset.format;
            const dashboard = this.dataset.dashboard;
            downloadDashboard(format, dashboard);
        });
    });

    // Tab switcher for code snippets
    document.querySelectorAll('.tab-btn').forEach(button => {
        button.addEventListener('click', function() {
            // Get the tab ID
            const tabId = this.dataset.tab;

            // Remove active class from all buttons and hide all content
            document.querySelectorAll('.tab-btn').forEach(btn => btn.classList.remove('active'));
            document.querySelectorAll('.tab-content').forEach(content => content.classList.add('hidden'));

            // Add active class to clicked button and show corresponding content
            this.classList.add('active');
            document.getElementById(tabId).classList.remove('hidden');
        });
    });

    // Dashboard generator
    document.getElementById('dashboard-generator-form').addEventListener('submit', function(e) {
        e.preventDefault();
        generateCustomDashboard();
    });
});

function downloadDashboard(format, dashboard) {
    // In a real implementation, this would fetch and download the dashboard template
    console.log(`Downloading ${dashboard} dashboard for ${format}`);

    // For demonstration purposes, we'll just show an alert
    alert(`Dashboard ${dashboard} would now download in ${format} format`);
}

function generateCustomDashboard() {
    // Get form values
    const name = document.getElementById('dashboard-name').value;
    const platform = document.getElementById('platform').value;
    const framework = document.getElementById('framework').value;
    const style = document.getElementById('template-style').value;

    // For demonstration purposes, just show the result area with placeholder
    document.getElementById('generated-dashboard').classList.remove('hidden');
    document.querySelector('#generated-dashboard code').textContent = 
        `Generated ${style} dashboard for ${framework} on ${platform} named "${name}"`;

    // In a real implementation, this would generate an actual dashboard configuration
}