Benchmarking Graphite

Before using Graphite in production, you should be aware of how much load it can handle. There is nothing worse than finding out your carefully planned and build setup is not good enough. If you are already using Graphite, you might want to know the facts of your current setup. Knowing the limits of a setup helps you to react on future requirements. Benchmarking is essential if you really want to know how many metrics you can send and how many requests you can make. To find this out, there are some tools out there that help you to run benchmarks.


The most important thing you need when starting to benchmark Graphite is time. A typical Graphite stack has 3 – 4 different components. You need plenty of time to properly find out how much load each of them can handle and even more to decide which settings you may want to tweak.


Haggar is a tool to simulate plenty of agents that send generated metrics to the receiving endpoint of a Graphite stack (carbon-cache, carbon-relay, go-carbon, etc…). The amount of agents and metrics is configurable, as well as the intervals. Even though Haggar does not consume much resources, you should start it on a separate machine.
Haggar is written in go and installed with the go get command. Ensure that Go (>= v1.8) is installed and working before installing Haggar.
Installing Haggar

go get

You’ll find the binary in your GOPATH that you have set during the installation of Go previously.
Running Haggar:

$GOPATH/bin/haggar -agents=100 -flush-interval=10s -metrics=1000

Each agent will send 1000 metrics every 10 seconds to on port 2003. The metrics are prefixed with haggar. by default. The more agents and metrics you send, the more write operations your Graphite server will perform.
Example output of Haggar:

root@graphite-server:/opt/graphite# /root/go/bin/haggar -agents=100 -flush-interval=10s -metrics=1000
2017/09/21 09:33:30 master: pid 16253
2017/09/21 09:33:30 agent 0: launched
2017/09/21 09:33:42 agent 1: launched
2017/09/21 09:33:46 agent 2: launched
2017/09/21 09:34:00 agent 0: flushed 1000 metrics
2017/09/21 09:34:02 agent 1: flushed 1000 metrics
2017/09/21 09:34:06 agent 2: flushed 1000 metrics

Testing the write performance is a good starting point, but it’s not the whole truth. In a production environment data is not only written but also read. For example by users staring at dashboards all day long. So reading the data is as much important as writing it because it also produces load on a server. This is where JMeter comes into play.


Apache JMeter usually is used to test the performance of web applications. It has many options to simulate requests against a web server. JMeter can also be used to simulate requests against Graphite-Web. You should do this simultaneously while Haggar is sending data, so you have the “complete” simulation.
The easiest way to configure JMeter is the graphical interface. Running test plans is recommended on the command line, though. Here’s an example how I set up JMeter to run requests against Graphite-Web:

  • Add a Thread Group to the Test Plan
    • Set the Number of Threads (eg. 5)
    • Set the loop count to Forever
  • Add a Random Variable to the Thread Group
    • Name the variable metric
    • Set the minimum to 1
    • Set the maximum to 1000
    • Set `Per Thread` to true
  • Add another Random Variable to the Thread Group
    • Name the variable agent
    • Set the minimum to 1
    • Set the maximum to 100
    • Set Per Thread to true

Haggar uses numbers to name it’s metrics. With these variables we can create dynamic requests.

  • Add a HTTP Request Defaults to the Thread Group
    • Set the server name or IP where your Graphite-Web is running (eg.
    • Add the path /render to access the rendering API of Graphite-Web
    • Add some parameters to the URL, examples:
      • width: 586
      • height: 308
      • from: -30min
      • format: png
      • target: haggar.agent.${agent}.metrics.${metric}

The most important part about the request defaults is the target parameter.

  • Add a HTTP Request to the Thread Group
    • Set the request method to GET
    • Set the request path to /render
  • Add a View Results in Table to the Thread Group

The results table shows details of each request. On the bottom there is an overview of the count of all samples, the average time and deviation. Optionally you can also add a Constant Throughput Timer to the Thread Group to limit the requests per minute.
If everything is working fine, you can now start the test plan and it should fire lots of requests against your Graphite-Web. For verification, you should also look into the access logs, just to make sure.
At this point your Graphite server is being hit by Haggar and JMeter at the same time. Change the settings to find out at which point your server goes down.


Obviously, killing your Graphite server is not the point of running benchmarks. What you actually want to know is, how each component behaves with certain amounts of load. The good thing is, every Graphite component writes metrics about itself. This way you get insights about how many queries are running, how the cache is behaving and many more.
I usually create separate dashboards to get the information. For general information, I use collectd to monitor the following data:

  • Load, CPU, Processes, I/O Bytes, Disk Time, I/O Operations, Pending I/O Operations, Memory

The other dashboards depend on the components I am using. For carbon-cache the following metrics are very interesting:

  • Metrics Received, Cache Queues, Cache Size, Update Operations, Points per Update, Average Update Time, Queries, Creates, Dropped Creates, CPU Usage, Memory Usage

For carbon-relay you need to monitor at least the following graphs:

  • Metrics Received, Metrics Send, Max Queue Length, Attempted Relays, CPU Usage, Memory Usage

All other Graphite alternatives like go-carbon or carbon-c-relay also write metrics about themselves. If you are using them instead of the default Graphite stack, you can create dashboards for them as well.

Observing the behaviour during a benchmark is the most crucial part of it. It is important to let the benchmark do its thing for a while before starting to draw conclusions. Most of the tests will peak at the start and then calm after a while. That’s why you need a lot of time when benchmarking Graphite, every test you make will take its own time.

Performance Tweaks

Most setups can be tuned to handle more metrics than usual. This performance gain usually comes with a loss of data integrity. To increase the number of handled metrics per minute the amount of I/Ops must be reduced.
This can be done by forcing the writer (eg. carbon-cache) to keep more metrics in the memory and write many data points per whisper update operation. With the default carbon-cache this can be achieved by setting MAX_UPDATES_PER_SECOND to a lower value than the possible I/Ops of the server. Another approach is to let the kernel handle caching and allow it to combine write operations. The following settings define the behaviour of the kernel regarding dirty memory ratio.

  • vm.dirty_ratio (eg. 80)
  • vm.dirty_background_ratio (eg. 50)
  • vm.diry_expire_centisecs (eg. 60000)

Increasing the default values will lead to more data points in the memory and multiple data points per write operation.
The downside of these techniques is that data will be lost on hardware failure. Also, stopping or restarting the daemon(s) will take much longer, since all the data needs to be flushed to disk first.

Blerim Sheqa
Blerim Sheqa
Product Manager

Blerim ist seit 2013 bei NETWAYS und seitdem schon viel in der Firma rum gekommen. Neben dem Support und diversen internen Projekten hat er auch im Team Infrastruktur tatkräftig mitgewirkt. Hin und wieder lässt er sich auch den ein oder anderen Consulting Termin nicht entgehen. Mittlerweile kümmert sich Blerim hauptsächlich im Icinga Umfeld um die technischen Partner und deren Integrationen in Verbindung mit Icinga 2.

JMeter für Lazy Tester – Proxy

jmeter-logoMittlerweile ist das Testen an jeder Ecke, man testet dies, man testet das, es gibt für jeden Einsatzzweck ein eigenes Tool und trotzdem machen alle das gleiche und zwar testen, testen und wieder testen. Manche Tools machen das Leben einfacher andere wiederum schwerer, sobald die Menge an Tests einen erschlägt und man nicht mehr den Code refactored sondern die Tests, vllt. wird es irgendwann soweit kommen, dass man Tests für die Tests anfängt zu schreiben 🙂
Na ja, wie auch immer, heute will ich euch den JMeter näher bringen, wie man mit seiner Hilfe, ganz einfache Tests für eine bestehende Webanwendung schreiben kann, ohne viel Aufwand dafür aufbringen zu müssen.
Zunächst besorgen wir uns JMeter Binaries, nachdem wir es entpackt haben, führen wir die ( | jmeter.bat ) im Ordner /bin aus, in wenigen Sekunden sollten wir vor unseren Augen die GUI zu sehen bekommen:
Als Erstes, wechseln wir die Sprache von Deutsch auf Englisch unter Optionen > Wählen Sie eine Sprache > English, gleich danach mit einem geschickten Maus-Rechtsklick auf den Testplan > Add > Threads (Users) > Thread Group und belasen alles so wie es ist.
Nun folgt ein weiterer Maus-Rechtsklick, diesmal aber auf den WorkBench > Add > Non-Test Elements > HTTP(S) Test Script Recorder und jetzt ändern wir hier ein paar Sachen ab:

  • Global Settings > Port = 8090
  • Test plan content > Target Controller = Testplan > Thread Group
  • URL Patterns to Include > Add = .*

Wir sind fast soweit, wir brauchen jetzt nur noch einen View Results Tree – Listener, also wieder Maus-Rechtsklick auf den Testplan > Add > Listener > View Results Tree.
Das Ganze sieht am Ende dann so aus:
Als letzten Schritt müssen wir jetzt nur noch den Proxy im Browser eintragen als Host: localhost und Port: 8090 und die Tests-Aufzeichnung kann beginnen, sobald wir auf den Start Button klicken beim HTTP(S) Test Script Recorder.
Was wollen wir aber testen? Nun, ich habe mich für Icinga Web 2 entschieden, wegen den vielen Requests die im Hintergrund so passieren und folgendes kleines Szenario überlegt:

  • aufrufen der Startseite
  • anmelden
  • nach test-flap-10 suchen
  • test-flap-10 Host aufrufen
  • System Configuration aufrufen
  • History Notifications aufrufen
  • Dashboard Landingpage aufrufen
  • abmelden

Jetzt drücken wir auf den Start Button und rufen im Browser http://localhost:8080/icingaweb auf und gehen das Szenario durch und wenn wir fertig sind, können wir die Test-Aufzeichnung im JMeter über den Stop Button beenden.
Das wars auch schon, die Thread Group wurde mit allen Requests gefüllt die so alles entstanden sind während der Test-Aufzeichnung und können nun auch von JMeter abgespielt werden.
Die Requests Ergebnisse können nach dem Abspielen im View Results Tree ausgewertet werden.
Sollte kein Request fehlgeschlagen haben, so können wir davon ausgehen, dass die Kommunikation zwischen dem Front- und Backend funktioniert.
Im Großen und Ganzen wie man sieht, lässt sich mit JMeter sehr schnell und einfach ein Test aufzeichnen, abspielen und auswerten und jetz kommt das ABER …
… dafür gibt’s weiter unten die Kommentare 😉
P.S. Humor …