Whatever message this page gives is out now! Go check it out!

View cluster and node metrics

Last update:
May 18, 2026

Overview

The Overview section presents a high-level view of the following metrics:
  • Average Response Time: The amount of time, in milliseconds, the node takes to return the results of a request.
  • Throughput: Number of requests served by the node at a particular time interval. 
  • Success/failure: A pie chart showing the distribution of cfms, which were successful and unsuccessful, that were run from the node.
  • Errors: A stacked graph, which lists the count of the 400 series and 500 series errors that have occurred in the node.
  • Top slow URLs: The execution time (in descending order) of each cfm in the node.
  • System information along with information on ColdFusion and Java versions.
  • History of thread dumps taken: A table displaying the following information of thread dumps taken at node level. The information contains the following:
    • Thread dump ID
    • Total threads
    • Time stamp
    • Actions- Export the dump as a text file.
  • History of heap dumps taken:  A table displaying the following information of heap dumps taken at node level. The information contains the following:
    • Heap dump location
    • Time stamp
Figure: Node metrics overview
Node metrics overview

Top slow URLs

When you click on any url, it takes you to a page, where you can see the following sections:
  • Basic info
  • Code flow
  • CF Server: Contains Async Threads, where view the concurrent requests and status of threads that are queued and running.
  • Database
  • External services
  • Cloud services
  • Tags/functions
  • Error/timeout
  • Memory
  • Threads: Contains all the threads that were spawned in the request.

Application monitoring

The Applications tab in the CF Server page performs Application Monitoring by providing the metrics pertaining to all the applications under a cluster or an individual instance.
At a cluster level, the CF Server page provides an overview of the following:
  • Number of instances of the cluster and health percentage.
  • A stacked graph, which lists the count of the 400 series and 500 series errors that have occurred across the cluster.
  • Top slow URLs with an error distribution across the instances that are part of the cluster.
  • ART and throughput graphs for the cluster over time.
Figure: Application monitoring
Application monitoring
The Applications page displays the data captured as part of the Application Monitoring. The page has a dropdown from which you can select the applications that you want to monitor and know the details (maximum of five applications).
For the selected applications, you can view the following:
  • The Average Execution Time graph and the health score for each application.
  • The load distribution for the selected applications along with an error graph.
The graph is a stacked area that displays the total count of 400 series and 500 series errors that have occurred in any of these selected applications over a period.
Figure: List of applications
List of applications
Figure: Application graph
Application graph
Clicking any application from the list of applications redirects to the application detail page, which provides further details about that application, for example,
  • An ART graph.
  • Top slow URLs/Queries.
  • An error graph.
  • A pie-chart for distribution of data source calls and external services calls.
  • A pie chart distribution of  various response codes across the requests made from the selected app.
  • An active session count graph and a pie-chart with a distribution of the requests made across the nodes that are part of the cluster.
Figure: Application monitoring details
Application monitoring details
Figure: Application monitoring pie charts
Application monitoring pie charts

Monitoring of RunAsync Threads

You can monitor the number of threads that are running in an async operation. Click the cfm running the RunAsync method, and in the CF server tab, expand Async Threads to view the concurrent requests.
There is also a new tab, Threads, which contains all the threads that were spawned in the request.
Figure: Active threads
Active threads

CF metrics

To monitor the various ColdFusion related non-request metrics, navigate to CF Server on the left panel. The CF Metrics data is always captured at a node level for a ColdFusion server, which is refreshed after every 15 seconds.
For a node, you can find the tab CF Metrics once you navigate to CF Server.
For a cluster, to view the metrics of the node, click a node that is listed on the CF Server page.
The metrics captured here are controlled by the settings available in CF Admin. The throttle, requests and thread-related controls are present in the pages Server settings and Request tuning. The cache data on the caching page and database-related changes can be made for each individual database under its advanced settings to control its pool size.
The metrics captured are
  • Throttle Data
  • Request Queue Data
  • Sessions Data
  • Data source connection metrics
  • CF thread/Asynch thread metrics
  • Template/Component/Query Cache size
Throttle data
The throttle-related data is captured when the throttle threshold is reached as specified in the CF Admin setting.  On hovering, it shows the following values.
  1. Average throttle queue size: The average value of the requests queued over a period , when there is not enough throttle memory available.
  2. Average throttle memory: The value of the throttle memory used by the requests after being throttled because they have reached the threshold specified in the admin setting.
Figure: Request throttle data graph
Throttle data
Request queue
A stacked graph that shows an average value of the requests that have been queued. The types of requests captured here are CFM templates, CFCs, and web services (SOAP services). The final value seen in the graph is the sum of all these three types of requests. This too reflects the data based on the setting in the ‘Request Tuning’ page of CF Admin. Apart from Queued data, it also shows the Running and Timed-Out requests on hovering over the graph.
* The data does not get captured on a Standard edition of ColdFusion.
Figure: Request queue size graph
Request queue size data
Template/Component/Query cache size
Figure: Template Component/Cache size graph
CFThread/Asynch thread metrics
The graph displays the running and queued counts of the ColdFusion threads that are running. The threads are spawned using the cfthread tag or the equivalent thread functions in ColdFusion. The data too can be controlled with the setting on Request Tuning page.
This graph also shows the number of Asynch threads that were spawned.
Figure: CF Threads and Asynch graph
CF Threads and Asynch graph
Datasource connection metrics
A stacked bar graph that displays the connection-related data, for the data sources accessed by various requests, like Maximum connections available, Average open connections and Total connections made for that data source.
Figure: Data source connections metrics graph
Data source connections metrics
Session data
In the graph you can view the active and expired session counts over a period of time.
Figure: Sessions data graph
Sessions data graph
Bytes metrics
Bytes In/Sec: Bytes incoming per second
  • The number of bytes ColdFusion read in the last second (not an average).
Bytes Out/Sec: Bytes outgoing per second
  • The number of bytes ColdFusion wrote in the last second (not an average).
Figure: Byte metrics graph
Byte metrics graph

System metrics

The section provides you all the system-related metrics.
CPU usage
See the consumption percentage of the system and the JVM in a time series graph.
Figure: CPU Usage
CPU Usage
Memory usage
You can monitor memory consumption of the server in the Server tab. You can see the system memory consumption and usage of memory of all running processes in the server. The red dashed horizontal denotes the baseline usage.
Figure: Memory usage
Memory usage
Network I/O
Check how many packets were sent and received as well as the speed of your network at a particular time.
Figure: Network usage
Network usage
Disk I/O
See the disk read and write metrics at any time.
Figure: Disk usage
Disk usage

JVM metrics

The Performance Monitoring Toolset provides detailed metric about JVM, which is explained in the section. The following are the metrics that you find in JVM.
  • Heap and non-Heap memory along with distribution
  • GC distribution graph
  • Count of GC
  • Thread and Thread-Pool Metrics
  • Class Loading Metrics
Heap and non-Heap memory along with distribution
Figure: Heap
Heap
Figure: Non-heap
Non-heap
The JVM performs memory management and can have a significant effect on your performance depending on how you configure the JVM. The most important settings for the JVM are the initial heap size and maximum heap size. The initial heap size represents the amount of memory that the JVM uses on startup; the maximum heap size represents the amount of memory that the JVM can use. You can modify these settings in the ColdFusion Administrator on the Java and JVM Settings page.
GC distribution
Garbage collection is the process of recycling memory that was assigned to objects that a program no longer references. The chart below displays two types of GC.
  • Minor collection: Garbage collection that occurs in the young generation. In ColdFusion, minor collections  collect unreferenced local scope and variable scope variables.
  • Major collection: Garbage collection that occurs in tenured generation. In ColdFusion, major collections collect all unreferenced session scope variables.
Figure: Garbage collection
Garbage collection
There is a histogram of the number of Garbage Collections over time. If you hover on each bar on the graph, you can see the number of GCs for that particular duration.
Figure: Count of GC
Count of GC
Thread and Thread Pool metrics
The graphs indicate the number of requests that the server is processing and the number of requests that are awaiting allocation of an application server thread to begin execution.
If the graph indicates that many requests are queued, increase the size of the thread pool.
In the graph below, Thread Pool gives you an aggregated view of the number of threads that are active.
Figure: Thread metrics
Thread metrics
Figure: Thread pool metrics
Thread pool metrics
Class Loading Metrics
Shows the number of classes that are loaded or unloaded in a particular duration. For example, if in a UDF, there are ten methods, then ten classes get loaded along with the cfc and the cfm.
Figure: Class loading metrics
Class loading metrics

Take thread dumps

For any node in a cluster,you can take thread or heap dumps. Click the button for:
  • Taking thread dump
  • Taking heap dump
  • Triggering GC
Figure: Thread dump results
Thread dump results
To view the stack trace of the thread, click any thread state.
Figure: Stack trace of thread
Stack trace of thread
Click any thread group to view similar stack trace.
Figure: Stack trace of group
Stack trace of group

Heap memory

Heap memory is the runtime data area that the Java VM allocates memory for all class instances and arrays. The heap can be of a fixed or variable size.
  • Eden: The pool from which memory is initially allocated for most objects.
  • Survivor: The pool that contains objects that have survived the garbage collection of the Eden space.
  • Old gen: The pool that contains objects that have stayed for some time in the survivor space.

Non-heap memory

Non-heap memory includes an area shared among all threads and memory required for the internal processing or optimization for the Java VM. It stores meta space, code cache, and compressed cache.
To take a heap snapshot, click Heap Dump and the dump generates successfully.
Any ColdFusion application uses threads to process a request. Large number of concurrent users spawns more threads. When two or more threads use the same resources, a contention between the threads occurs. Thread dump is used to analyze thread contention issues and it provides information on the exact status of each thread and information about the call stack of each thread.
Note: You may sometimes see incorrect data for Heap and Non-Heap charts. For example, if you had set MaxMetaSpaceSize as 192 MB, the Performance Monitoring Toolkit may show the same as 1456 MB.
To take a thread dump, click Thread Dump. You can see the following thread status:
In Performance Monitoring Toolset, you can also trigger GC. The garbage collector manages the allocation and release of memory for your application. Every time you create an object, the runtime allocates memory for the object from the managed heap. If an address space is available in the managed heap, the runtime continues to allocate space for new objects.
When the garbage collector performs a collection, it checks for objects in the managed heap that are no longer being used by the application and performs the necessary operations to reclaim their memory.
To take a Heap Dump, click the button labeled Heap Dump. The heap data gets saved in the location, <ColdFusion_Home/cfusion> in a file admin-1532006781545.hprof.
To trigger Garbage Collection, click GC.

Caching

In the section, you can see what caching engine is being used. You can use the following:
  • Ehcache
  • Redis
  • Memcached
  • JCS
  • Custom plugin
You can also see the cache regions of both the application and the server.
If you choose the option, Cache regions of server, you can see the following details:
Figure: Cache regions of server
Cache regions of server
If you choose the option Cache regions of applications, you can see the cache stats of the application that you had specified in the file Application.cfc.
Figure: Cache regions of application
Cache regions of application

Active monitoring

To monitor currently active requests, queries, and ColdFusion threads, click CF Server on the left panel. For a node, you can find the tab Active Monitoring once you navigate to CF Server.
You can monitor the following options:
  • Async Threads
  • Sessions
For a cluster, click any individual node that you would see listed on the ColdFusion Server page to view its Active Monitoring details.
Figure: Active monitoring
Active monitoring
The list displays active requests/CF Threads/Queries and also Async Threads and Sessions.
Figure: List of requests
List of requests
Along with the additional details, there are certain actions that can be taken on these active requests and active CF Threads.
For active requests, you can view the Java stack trace of the thread for a particular request to know the state of that request.
From the stack trace, you can also view the time taken and other parameters, for example, a request that is causing a server to execute slowly. For such cases, you can kill the request.
Similarly, you can also kill any active ColdFusion thread.
Figure: Java stack trace
Java stack trace

Share this page

Was this page helpful?
We're glad. Tell us how this page helped.
We're sorry. Can you tell us what didn't work for you?
Thank you for your feedback. Your response will help improve this page.

On this page