2010 - 2012-08 Discontinued

CFTracker is a web application, written in CFML, designed to monitor and inspect the internals of the CFML engine (Adobe ColdFusion and Railo) that it's executing on. It was open source under the Apache Version 2 License, with the code available on GitHub.


  • Applications

    • See what's active

      Get a list of all active ColdFusion applications. This includes information like the last time it was accessed to the expected expiry date if no further activity is received.

    • Settings and Scopes

      Dig inside an application by viewing a dump of its scope. You can also see a dump of it's settings which is everything in it's application.cfc or CfApplication tag.

    • Take action!

      Select one or more applications and stop them completely, forcing ColdFusion to create a new one on the next request. Restart them, so they'll stay alive but execute onApplicationStart on their next request. Or refresh them, so their last accessed time is updated when you don't want them expiring yet.

  • Sessions

    • Who's there?

      See a list of all sessions on the server or filter them by application. You can also see information such as the last accessed time, expiry date, session creation IP and much more.

    • Peek inside their scopes

      Take a look inside any session on the server by viewing a dump of its scope. This can be very useful for making sure their session contents are correct or seeing who the session might belong to (if your app stores it there).

    • Actions

      Just like applications, sessions can also be stopped completely. This is very useful if you have a bunch of sessions that are taking up memory and you need to get rid of them. You can also refresh a session by updating its last accessed date, making it live a little longer.

  • Statistics

    • Misc Statistics

      Several various statistics about the server are exposed in this section. Furture version of CfTracker will provide a better insight to how these statistics affect your server.

  • Query Cache

    • Show me the cache

      View the contents of the Query cache. Each item includes its creation date, SQL, number of parameters and a special unique identifier.

    • Result dumps

      This section also gives you the ability to dump the result set of the cached query. You can also view a dump of the parameters that were process by the CfQueryParam tag, showing the types and values.

    • Actions

      Pick one or multiple items from the list of cached items and purge them. Want a cached query to stay in the cache for longer? Use the actions to update its creation time.

  • Memory

    • Heap, Non-heap and their pools

      Memory information in CfTracker has been expanded to cover both heap and non-heap memory, plus the pools contained within them. This gives a deeper insight as to what's going on within your server and you can even seen peak usage values.

    • Garbage Collection

      View information on what garbage collection processes are in place and how they are performing. You can see how many times they've taken place, durations, average time per collection and before & after usage for the pools they collected from.

    • Operating System

      Since you can see all the JVM memory information, it makes sense to see what's happening on the computer as a whole. CfTracker shows you the physical memory and swap usage.

  • Threads

    • See current threads

      Browse through a list of all Java threads. Shows which thread groups they belong to, current thread priority, status and much more. CfTracker also attempts to trace the ColdFusion file a thread may be processing.

Discontinuation reasons

While I felt the project had a good potential to become extremely useful to developers and hosting providers, it became a very difficult beast to test. I wanted to support at least Adobe ColdFusion and Railo, but also multiple versions of their engines. While on their CFML surfaces they're quite similar, internally they are quite different.

  • Too big for a single developer

    Trying to support both Railo and Adobe ColdFusion, plus different versions of them, was too much for me to handle. Although CFTracker was written with CFML, it accessed the internals through the use of Java objects (within the CFML).

  • Security issues within the engines

    I didn't want to release anything that could be abused on hosting providers. So after stumbling on a few security issues with both engines, I wanted them closed before going any further. Sometimes I think Adobe took over 6 months to deal with them on purpose :-P

  • Commercial competition

    Although I wasn't aiming to compete directly, certain features (and planned features) were present in other available tools like Adobe ColdFusion Enterprise's Server Monitor and FusionReactor. This made my target audience (already small) even smaller.

  • Lack of feedback

    I did get feedback from people, but it was from the few and not the many. People were using the project to solve an issue and then forgetting about it. Which meant I didn't receive much in the way of feedback to help steer development of new features.

  • Little personal gain

    I like to gain something from any project, either a learning experience to help me gain new skills or even money to encourage me to work on it further. While I'm pleased a few donated and it kept me going for a while, the learning experience wasn't going anywhere.

Original planned features

I was close to putting together a new version of CFTracker that had been rewritted from scratch. A raft of documents held my brain dumps of ideas, an Adobe ColdFusion compatible API had been constructed and a roadmap put together. It still needed work but I don't think it was far off an alpha release and would have contained the following:

  • AngularJS based client

    Lowered the overhead on the server as it only had to serve static HTML/JS and pure JSON data from the CFTracker API. Also made the interface more responsive due to the lower data transfer size.

  • Monitor multiple servers / instances

    The AngularJS client would support monitoring of multiple servers, allowing comparison between them and an overall view to easily track server status. Authentication details would be stored in the browser or required each time.

  • Mobile / Desktop app

    With the seperation of frontend and backend, the AngularJS based client was easily packable into a mobile application with some responsive web design adjustments. Also, a heavier desktop app could have been created via node-webkit that could have included log analysis code I had available.

  • Custom alerts & rules

    Configurable rules could be created against the various statistics monitored by CFTracker. These would have then fired off custom alerts (email, sms, custom code and others). The rules had been set up with alert and "unalert" levels to prevent multiple warnings generating while limits were breeched.

  • Configuration monitoring

    Tracking changes to any configuration settings for the JVM itself and the CFML engine. Also providing comparisons of configurations between servers (or instances). Additionally, configuration changes would optionally be highlighted on historical graphs, allowing you to easily see the impact of changes and what the change was.

  • Trend comparisons

    Taking data from previous weeks, months, years and comparing it to recent data.