Graphite website real-time information collection and statistics v1.1.10

Graphite is a highly scalable real-time graph system and enterprise-level monitoring tool. Used to collect real-time website information and perform statistics, and can collect various website service operating status information.

FAQ

Who should use Graphite?

Anyone who wants to track any numerical value over the long term. If you have a number that might change over time, and you might want to graph that value over time, then Graphite might suit your needs.

Specifically, Graphite is designed to handle numeric time series data. For example, Graphite is great for graphing stock prices because they are numbers that change over time. Whether it's a few data points, or dozens of performance metrics from thousands of servers, then Graphite is for you. As a bonus, you don't have to know the names of these things in advance (who wants to maintain such a huge configuration?); you just send a metric name, a timestamp, and a value, and Graphite handles the rest.

How scalable is Graphite?

From a CPU perspective, Graphite scales horizontally on both the frontend and backend, meaning you can simply add more machines to get more throughput. It is also fault tolerant, i.e. losing a backend machine will cause minimal data loss (regardless of what that machine has cached in memory) and will not break the system if you have enough remaining capacity to handle the load.

From an I/O perspective, under load, Graphite will perform many tiny I/O operations on many different files very quickly. This is because each different metric sent to Graphite is stored in its own database file, similar to how many tools built on top of RRD (drraw, Cacti, Centreon, etc.) work. In fact, Graphite did initially use RRD for storage until fundamental limitations arose requiring a new storage engine.

High capacity (thousands of different metrics updated per minute) almost requires a good RAID array and/or SSD. If the disk can't keep up with the large number of small writes happening (just a few bytes per data point, but most standard disks can't handle more than a few thousand I/O operations per second, even if they're small), Graphite's backend Incoming data will be cached. When this happens, Graphite's database engine whispers by allowing Carbon to write multiple data points at once, thereby increasing overall throughput at the expense of caching the excess data in memory until it can be written.

Graphite also supports alternative storage backends that can significantly change these features.

How real-time is the chart?

Very real time. Even under heavy load, when the number of incoming metrics per time interval is much greater than the speed at which the storage system can perform I/O operations, and a large number of data points are cached in the storage pipeline (see previous question explanation) , Graphite can still draw real-time graphs. The trick is that when the Graphite webapp receives a request to draw the graph, it retrieves the data from disk as well as from the pre-storage cache (the cache may be distributed if you have multiple backend servers) and combines the two data sources Combined to create a real-time graph.

Who is already using Graphite?

Graphite was developed internally by Orbitz, where it is used to visualize a variety of key operational data, including application metrics, database metrics, sales, and more. As of this writing, Orbitz's production system can process approximately 160,000 different metrics per minute, running on two niagra-2 Sun servers on a high-speed SAN.

What is Graphite written in?

The Graphite webapp is built on the Django web framework and uses the ExtJS javascript GUI toolkit. Graphics rendering is done using the Cairo graphics library. The backend and database are written in pure Python.

Who will write and maintain Graphite?

Graphite was originally developed by Chris Davis of Orbitz. Orbitz has long been part of the open source community and has released a number of other internally developed products.

Graphite is currently developed by a team of volunteers under the Graphite-Project GitHub organization.