Download ColdFusion PMT Dashboard Templates (JSON)

Introduction

The downloadable resource is a curated set of ColdFusion Performance Monitoring Toolset (PMT) dashboard templates in JSON format. These prebuilt dashboards let you import a fully organized monitoring view into PMT—covering JVM health, request latency, slow transactions, database Performance, and external calls—so you can start analyzing performance in minutes rather than building everything from scratch. The templates are designed to be easily customizable, version-aware (ColdFusion 2018, 2021, 2023), and optimized for production triage, capacity planning, and ongoing Performance tuning.

—

H2: What You’ll Get

• 5 ready-to-import PMT dashboard JSON files:
  • Overview & SLA Health
  • JVM & Threads Health
  • Slow Requests & Errors
  • Database & Datasource Performance
  • External Services & REST APIs
• Optional alert rule stubs embedded as comments (where supported) or provided as inline notes for manual creation
• A quick-start guide (this article) with step-by-step import instructions via UI and REST API
• Field mapping guidance and Best practices for filters, tags, and normalization across environments
• Version notes for ColdFusion 2018/2021/2023 PMT compatibility

Note: PMT JSON schema can vary slightly by version. The templates below use field names and widget structures that are widely compatible and easy to adapt if your instance uses different metric identifiers.

—

H2: Overview

H3: Why these PMT dashboard templates matter

• Reduce setup time: Import fully structured dashboards instead of manually creating every chart.
• Standardize monitoring: Ensure teams look at the same metrics using the same visualization patterns.
• Improve triage speed: Quickly isolate hot spots across JVM, requests, database, and external dependencies.
• Scale across environments: Use consistent filters and tag patterns for dev, staging, and production.

H3: Supported Environments

• Adobe ColdFusion PMT:
  • ColdFusion 2018 (U5+ recommended)
  • ColdFusion 2021
  • ColdFusion 2023
• Operating Systems: Windows, Linux, macOS
• Browsers: Latest Chrome/Edge/Firefox recommended
• Access: PMT user with Dashboard management permissions

—

H2: File Contents

H3: Dashboard JSON Templates

Each dashboard template is a standalone JSON file. You can import them individually or all at once.

H4: 1) Overview & SLA Health (overview-dashboard.json)

Use when you need a high-level Health check: traffic volume, latency, errors, and CPU/memory.

{
“name”: “Overview & SLA Health”,
“version”: “1.0”,
“tags”: [“overview”, “sla”, “exec”],
“description”: “Top-level health: requests, latency, errors, CPU, heap.”,
“timeRange”: “last_24_hours”,
“widgets”: [
{
“title”: “Requests per Minute”,
“type”: “timeseries”,
“metric”: “cf.request.count”,
“aggregation”: “sum”,
“interval”: “1m”
},
{
“title”: “Average Response Time (ms)”,
“type”: “timeseries”,
“metric”: “cf.request.avg_time”,
“aggregation”: “avg”,
“interval”: “1m”
},
{
“title”: “Error Rate (%)”,
“type”: “timeseries”,
“metric”: “cf.request.error_rate”,
“aggregation”: “avg”,
“interval”: “1m”
},
{
“title”: “CPU Utilization (%)”,
“type”: “timeseries”,
“metric”: “host.cpu.utilization”,
“aggregation”: “avg”,
“interval”: “1m”
},
{
“title”: “JVM Heap Used (MB)”,
“type”: “timeseries”,
“metric”: “jvm.heap.used_mb”,
“aggregation”: “avg”,
“interval”: “1m”
}
]
}

H4: 2) JVM & Threads Health (jvm-threads-dashboard.json)

Focuses on memory pressure, GC activity, and thread pools.

{
“name”: “JVM & Threads Health”,
“version”: “1.0”,
“tags”: [“jvm”, “gc”, “threads”],
“description”: “Heap, GC, threads, blocked threads.”,
“timeRange”: “last_6_hours”,
“widgets”: [
{
“title”: “Heap Used vs Max (MB)”,
“type”: “dual_timeseries”,
“series”: [
{“metric”: “jvm.heap.used_mb”, “aggregation”: “avg”},
{“metric”: “jvm.heap.max_mb”, “aggregation”: “max”}
],
“interval”: “1m”
},
{
“title”: “GC Time per Minute (ms)”,
“type”: “timeseries”,
“metric”: “jvm.gc.time_ms”,
“aggregation”: “sum”,
“interval”: “1m”
},
{
“title”: “GC Count”,
“type”: “timeseries”,
“metric”: “jvm.gc.count”,
“aggregation”: “sum”,
“interval”: “1m”
},
{
“title”: “CF Threads Running”,
“type”: “timeseries”,
“metric”: “cf.threads.running”,
“aggregation”: “avg”,
“interval”: “1m”
},
{
“title”: “Blocked Threads”,
“type”: “timeseries”,
“metric”: “jvm.threads.blocked”,
“aggregation”: “avg”,
“interval”: “1m”
}
]
}

H4: 3) Slow Requests & Errors (slow-requests-dashboard.json)

Targeted for root-causing slow pages/actions and error spikes.

{
“name”: “Slow Requests & Errors”,
“version”: “1.0”,
“tags”: [“requests”, “errors”, “apm”],
“description”: “Top slowest requests, 95th/99th percentile, error hotspots.”,
“timeRange”: “last_2_hours”,
“widgets”: [
{
“title”: “P95 and P99 Response Time (ms)”,
“type”: “multi_stat”,
“metrics”: [
{“metric”: “cf.request.p95_ms”, “label”: “P95”},
{“metric”: “cf.request.p99_ms”, “label”: “P99”}
]
},
{
“title”: “Top 10 Slow URIs (Avg Time)”,
“type”: “topn”,
“metric”: “cf.request.avg_time”,
“groupBy”: “request.uri”,
“limit”: 10,
“sort”: “desc”
},
{
“title”: “Error Count by URI”,
“type”: “topn”,
“metric”: “cf.request.errors”,
“groupBy”: “request.uri”,
“limit”: 10,
“sort”: “desc”
},
{
“title”: “Requests vs Errors”,
“type”: “dual_timeseries”,
“series”: [
{“metric”: “cf.request.count”, “aggregation”: “sum”},
{“metric”: “cf.request.errors”, “aggregation”: “sum”}
],
“interval”: “1m”
}
]
}

H4: 4) Database & Datasource Performance (database-dashboard.json)

Useful for diagnosing Slow queries and datasource connectivity.

{
“name”: “Database & Datasource Performance”,
“version”: “1.0”,
“tags”: [“db”, “datasource”, “sql”],
“description”: “Query time, throughput, slow SQL, pool activity.”,
“timeRange”: “last_24_hours”,
“widgets”: [
{
“title”: “Average Query Time (ms)”,
“type”: “timeseries”,
“metric”: “cf.datasource.query_time_avg”,
“aggregation”: “avg”,
“interval”: “1m”
},
{
“title”: “Queries per Minute”,
“type”: “timeseries”,
“metric”: “cf.datasource.query_count”,
“aggregation”: “sum”,
“interval”: “1m”
},
{
“title”: “Top 10 Slow queries”,
“type”: “topn”,
“metric”: “cf.datasource.query_time_avg”,
“groupBy”: “query.signature”,
“limit”: 10,
“sort”: “desc”
},
{
“title”: “Active Connections”,
“type”: “timeseries”,
“metric”: “cf.datasource.active_connections”,
“aggregation”: “avg”,
“interval”: “1m”
}
]
}

H4: 5) External Services & REST APIs (external-services-dashboard.json)

Track outbound calls to Third-party APIs, REST endpoints, and Microservices.

{
“name”: “External Services & REST APIs”,
“version”: “1.0”,
“tags”: [“external”, “api”, “http”],
“description”: “HTTP call latency, error rate, and top endpoints by time.”,
“timeRange”: “last_6_hours”,
“widgets”: [
{
“title”: “Average HTTP Call Time (ms)”,
“type”: “timeseries”,
“metric”: “cf.http.avg_time”,
“aggregation”: “avg”,
“interval”: “1m”
},
{
“title”: “HTTP Errors (%)”,
“type”: “timeseries”,
“metric”: “cf.http.error_rate”,
“aggregation”: “avg”,
“interval”: “1m”
},
{
“title”: “Top 10 Endpoints by Time”,
“type”: “topn”,
“metric”: “cf.http.avg_time”,
“groupBy”: “http.endpoint”,
“limit”: 10,
“sort”: “desc”
}
]
}

H5: Note on metric names

• Metric keys such as cf.request.avg_time or jvm.heap.used_mb reflect common PMT conventions. If your PMT uses different identifiers, import will work but charts may appear empty. See the “Adjusting metric mappings” section below.

—

H2: Benefits

H3: Why these templates save time and improve performance

• Faster Onboarding: New team members get instant visibility into key performance indicators.
• Better incident response: Prewired visuals for error spikes, latency outliers, and resource saturation lead to faster MTTR.
• Consistent analysis: Shared dashboards reduce context switching and help compare environments reliably.
• Focus on outcomes: Spend time optimizing CFML code and SQL rather than configuring PMT UI elements.

H3: Use Cases

• Production triage: Identify whether a slowdown is JVM, thread, database, or external-service related.
• Capacity planning: Track trends in requests/minute, CPU, and heap to plan Scaling.
• Performance testing: Baseline P95/P99 metrics across builds for CI/CD performance gates.
• RCA documentation: Use standardized dashboards to capture evidence in post-incident reviews.

—

H2: How to Install and Use

H3: Option A: Import via PMT UI

H4: Step-by-step

1. Log in to PMT with an account that can manage dashboards.
2. Go to Dashboards.
3. Click Import (or the ••• menu > Import, depending on version).
4. Choose a JSON file (e.g., overview-dashboard.json) and confirm.
5. Repeat for each template you want.
6. Open the imported dashboard. Verify widgets populate with data.
7. If a widget is empty, edit it and reselect the correct metric from the PMT metric picker. Save.

H5: Tips

• Use environment tags (e.g., env:prod, env:staging) to filter dashboards per environment.
• Set default time ranges that match the use case (e.g., last 2 hours for incident triage).

H3: Option B: Import via REST API

If your PMT exposes dashboard APIs and you have a token:

H4: Example (curl)

• Replace PMT_BASE_URL and TOKEN. The endpoint path may vary by version.

curl -X POST \
-H “Authorization: Bearer TOKEN” \
-H “Content-Type: application/json” \
–data-binary @overview-dashboard.json \
https://PMT_BASE_URL/api/dashboards/import?replaceExisting=true

Check response for success. Repeat for other JSON files.

H3: Adjusting metric mappings

• Open an empty widget, click Edit, and pick the metric from the PMT metric selector.
• Note the metric key and update the JSON for future use.
• Common variations:
  • cf.request.avg_time vs cf.request.average_ms
  • cf.datasource.query_time_avg vs cf.datasource.avg_query_time_ms
  • jvm.heap.used_mb vs jvm.heap.used_bytes (convert if needed)
• Save your environment-specific copy after mapping.

H3: Organizing by environment and app

• Add dashboard tags: [“prod”, “myapp”] or [“staging”, “api”].
• Use PMT filters to scope to a server, instance, or application name.
• Clone dashboards to create “Per-App” versions with a default filter set.

—

H2: Best practices

H3: Visualization

• Emphasize percentiles (P95/P99) alongside averages to capture tail latency.
• Pair related metrics: requests vs errors, heap used vs max, GC time vs pause count.
• Keep a small, high-signal overview page; deeper topics get their own dashboards.

H3: Alerting and thresholds

• Use PMT or external alerting to watch for:
  • Error rate > 2% over 5 minutes
  • P95 > SLA for 3 consecutive intervals
  • Heap used > 80% for > 10 minutes
  • Blocked threads > 0 sustained
• Document alert thresholds directly in dashboard descriptions.

H3: Data hygiene and tagging

• Standardize labels: env, app, service, node.
• Avoid mixing prod and non-prod on the same view unless explicitly filtered.
• Periodically prune unused widgets to reduce noise.

H3: Version-specific notes

• ColdFusion 2018 PMT may label metrics differently; test import and remap as required.
• ColdFusion 2021/2023 have more consistent metric naming and improved widget types.
• If a widget type isn’t supported (e.g., dual_timeseries), convert to two timeseries.

—

H2: Pros and cons

H3: Advantages

• Quick start with production-grade layouts
• Adaptable and version-aware
• Encourages common Standards across teams

H3: Trade-offs

• Metric names can vary; some manual remapping may be necessary
• Not all organizations track the same dimensions; you may add or remove widgets
• Advanced alert rules typically require manual setup in PMT

—

H2: How to Customize

H3: Naming and descriptions

• Prefix dashboards with team or app name: “Checkout — Overview & SLA”
• Include Troubleshooting notes in descriptions: “If this spikes, check XYZ.”

H3: Filters and scopes

• Set a default filter for app=yourApp or instance=cfusion.
• Duplicate dashboards per environment to preserve signal clarity.

H3: Add-on widgets to consider

• CFML function profiler views
• Long-running requests heatmap
• Top remote hosts or user-agents
• Network I/O per node (if exposed)

—

H2: Troubleshooting

H3: Common issues and fixes

• Empty charts: Remap metric keys via Edit > Metric picker.
• Import error: Validate JSON structure; remove comments; ensure UTF-8 encoding.
• Missing widget type: Convert to a supported type and re-import.
• No data: Confirm PMT collectors are connected and time range includes recent activity.

H3: Validation Checklist

• Time range set correctly
• Filters not over-restrictive
• Server/Instance selected
• PMT data collection active and not paused

—

H2: Security and Access Control

H3: Recommendations

• Restrict dashboard editing to a small administrator group.
• Grant read-only access broadly for transparency and collaboration.
• Avoid placing secrets or internal hostnames in widget titles or descriptions.

—

H2: Key Takeaways

• Import-ready JSON dashboards for ColdFusion PMT speed up Performance monitoring and incident response.
• Five focused templates cover the majority of CF performance diagnostics: overview, JVM/threads, slow requests, database, and external services.
• Minor metric name differences may require quick remapping; save your customized copies.
• Use tags, filters, and environment-specific dashboards for clarity and consistency.
• Augment with alerts to catch problems early and reduce MTTR.

—

H2: FAQ

H4: Do these templates work with ColdFusion 2018 PMT?

Yes, with minor adjustments. Most widgets import cleanly, but some metric keys may differ. If a chart is blank, edit the widget and choose the correct metric from the PMT picker, then save your updated JSON.

H4: Can I import all dashboards at once?

If your PMT version supports bulk import via API, yes. Otherwise, import each JSON file individually through the UI. Group them with tags so they’re easy to find together.

H4: How do I handle different metric names in my environment?

Import the dashboard, open any empty widget, and reselect the metric in the editor. Note the exact metric key PMT uses and update your local JSON file. Keep a versioned copy per CF/PMT release.

H4: Can I add alerts directly from these JSON files?

Some PMT versions don’t support alert definition import via dashboard JSON. Use the included alert thresholds as guidance and configure alerts in PMT’s Alerts section to match your dashboards.

H4: Is there a recommended naming convention?

Use a consistent structure like: Team or App — Topic — Environment. Example: Payments — Database performance — Prod. Add tags such as [“prod”,”payments”] and reference them in filters.