Comment on page

Welcome to Hosted Graphite

Let us host your monitoring environment so you don't have to!



Graphite is an open-source and highly scalable, real-time graphing system. The metrics and data that you send to Graphite’s carbon endpoint are timestamped, aggregated, stored, and can be graphed using a basic dashboard interface. Graphite is an efficient method of collecting and aggregating data, is well documented and is easy to work with.
Hosted Graphite has improved upon standard Graphite and offers additional tools and features that provide our customers with a robust and well-rounded monitoring solution.
  • Send system metrics from your running instances and servers, custom metrics from within your application code, or service metrics from other popular services that we integrate with, like Heroku and AWS.
  • Visualize your data in meaningful ways with customizable dashboards that look awesome!
  • Configure alerts to your metrics and integrate with popular notification channels such as Slack, and Pager Duty.
  • We handle the aggregation, storage, and backup of your data. See the specific retention and resolution mappings here.
  • We offer fast and friendly support and are dedicated to making sure you get the highest value possible from our services.
  • Hosted Graphite takes away the burden of self-hosting your own monitoring solution, allowing you more time and freedom to work on your most important tasks. You can measure, analyze, and visualize large amounts of data from your applications and infrastructure without the hassles of setting up your own servers, worrying about scaling, storing data, alerting, or maintenance.
  • You need a monitoring solution in order to make data-driven decisions for your business. Get an instant overview of how your technology stack is performing by monitoring your systems and observing trends in your data.
  • Hosted Graphite has many supported APIs, integrations, and plugins that can help you get data in, and return it in a way that is useful for you. Anytime you have questions about our product and services, our knowledgeable support team will respond quickly and give you useful advice.
A common monitoring target is the number of concurrent users in a web application. A possible solution is to have a scheduled background task, which once a minute queries the appropriate resource and sends us the current number of users. This metric is given an appropriate identifier, such as conc_users. Each time we receive a message with a metric (or metrics), we store the values with a UNIX timestamp. When you create a new dashboard, you can start graphing this newly available metric with just a few clicks:
Example of graphing a conc_users metric
Although it lets you get up and running quickly with simple graphs, our Hosted Dashboards are a very powerful tool. You can build complex graphs from multiple metrics, use Graphite functions to manipulate the metric data, and have the ability to fine tune the styling of the graphs.
Here’s another example: this time three metrics are being graphed simultaneously, and some styling has been applied to improve clarity. Check out the graph panel reference to see some of the many available possibilities.
Graphing 3 related metrics


A metric is a unique time-series collection of name-value data which can be aggregated, graphed, and alerted on. In other words, a metric is a unique namespace that you can send data to or query data from.
Hosted Graphite metrics use the following format:
metricname value [timestamp]
  • metricname is a period-delimited path, such as The periods will turn each path component into a sub-tree. The graphite project website has some metric naming advice.
  • value is an integer or floating point number. Hosted Graphite can only ingest numeric values.
  • timestamp (optional) is a UNIX timestamp, which is the number of seconds since Jan 1st 1970 (always UTC, never local time). If no timestamp is provided, the current time will be assumed. This is generally “good enough” for most uses.
You can send multiple metric values at the same time by putting them on separate lines in the same message: 59
test.memory.free_ram 33
Here’s an example of a metric with the optional UNIX timestamp: 59 1340981282
This means that the metric will be stored as being measured at the time specified, instead of the arrival time at our server. This is good for sending us historical data, or when you need the timestamps to match exactly with the timestamps on your system logs. Understanding the metric data format is important because this is how our hosted carbon endpoint is able to accept data.
Here’s an example of how to send a metric via TCP using the Netcat utility:
echo " 59" | nc 2003
In most cases, including this case, the metric will be timestamped upon ingestion.


Every Hosted Graphite account has an associated API Key. This API Key must be sent along with your metric data to associate it with your account. In most cases, this means prefixing the key to your metric names, e.g. YOUR-API-KEY.metricname which will ensure that your data is securely sent to our hosted carbon endpoint.
There are many ways to send metrics to us that are detailed in our Sending Metrics Guide. The most basic ways include TCP, UDP, and HTTP as seen in our Supported Protocols Guide. Or you can let a service/daemon perform the work, such as one of our supported agents.
We also have plugins for popular PAAS services such as Heroku, AWS Cloudwatch, and Azure Monitor. See our Add-Ons and Integrations Guide for a full list of 3rd party platforms and plugins that we support.
Last modified 1mo ago