-netdata
-=======
+[](https://travis-ci.org/firehol/netdata)
+<a href="https://scan.coverity.com/projects/firehol-netdata"><img alt="Coverity Scan Build Status" src="https://scan.coverity.com/projects/9140/badge.svg"/></a>
+[](https://registry.my-netdata.io/#netdata_registry)
+[](https://registry.my-netdata.io/#netdata_registry)
+[](https://registry.my-netdata.io/#netdata_registry)
-[Live Demo Site](http://netdata.firehol.org)
+[](https://registry.my-netdata.io/#netdata_registry)
+[](https://registry.my-netdata.io/#netdata_registry)
+[](https://registry.my-netdata.io/#netdata_registry)
-### Realtime time data collection and charts!
+# netdata
-**Netdata** is a daemon that collects data in realtime (up to per second) and presents a web site to view and analyze them.
-The presentation is full of charts that precisely render all system values, in realtime.
+> May 16th, 2016
+>
+> [netdata v1.2.0 released!](https://github.com/firehol/netdata/releases)
+>
+> - 30% faster!
+> - **[netdata registry](https://github.com/firehol/netdata/wiki/mynetdata-menu-item)**, the first step towards scaling out performance monitoring!
+> - real-time Linux Containers monitoring!
+> - dozens of additional new features, optimizations, bug-fixes
-It has been designed to be installed on every system, without desrupting its operation:
+---
-1. It will just use some spare CPU cycles.
+May 1st, 2016
- You can even control its CPU consumption by lowering its data collection frequency.
- It is also running with the lowest possible priority.
+##### 320.000+ views, 92.000+ visitors, 28.500+ downloads, 11.000+ github stars, 700+ forks, 1 month!
-2. It will use the memory you want it have.
+And it still runs with 600+ git downloads... per day!
- You can control the memory it will use by sizing its round robin in memory database.
+**[Check what our users say about netdata](https://github.com/firehol/netdata/issues/148)**.
-3. It does not use disk I/O.
+---
- All its database is in memory, and it is only saved on disk and loaded back when netdata restarts. You can also disable the access log of its embedded web server.
+**Real-time performance monitoring, done right!**
+This is the default dashboard of **netdata**:
-You can use it to monitor all your applications, servers, linux PCs or linux embedded devices.
+ - real-time, per second updates, snappy refreshes!
+ - 300+ charts out of the box, 2000+ metrics monitored!
+ - zero configuration, zero maintenance, zero dependencies!
-Out of the box, it comes with plugins for data collection about system information and popular applications.
+Live demo: [http://netdata.firehol.org](http://netdata.firehol.org)
+
-# Features
+---
-- **highly optimized C code**
+## Features
- It only needs a few milliseconds per second to collect all the data.
- It will nicelly run even on a raspberry pi with just one cpu core, or any other embedded system.
+**netdata** is a highly optimized Linux daemon providing **real-time performance monitoring for Linux systems, Applications, SNMP devices, over the web**!
-- **extremely lightweight**
+It tries to visualize the **truth of now**, in its **greatest detail**, so that you can get insights of what is happening now and what just happened, on your systems and applications.
- It only needs a few megabytes of memory to store all its round robin database.
+This is what you get:
- Although `netdata` does all its calculation using `long double` (128 bit) arithmetics, it stores all values using a **custom-made 32-bit number**. This custom-made number can store in 29 bits values from -167772150000000.0 to 167772150000000.0 with a precision of 0.00001 (yes, it is a floating point number, meaning that higher integer values have less decimal precision) and 3 bits for flags (2 are currently used and 1 is reserved for future use). This provides an extremely optimized memory footprint with just 0.0001% max accuracy loss (run: `./netdata --unittest` to see it in action).
+- **Stunning bootstrap dashboards**, out of the box (themable: dark, light)
+- **Blazingly fast** and **super efficient**, mostly written in C (for default installations, expect just 2% of a single core CPU usage and a few MB of RAM)
+- **Zero configuration** - you just install it and it autodetects everything
+- **Zero dependencies**, it is its own web server for its static web files and its web API
+- **Zero maintenance**, you just run it, it does the rest
+- **Custom dashboards** that can be built using simple HTML (no javascript necessary)
+- **Extensible**, you can monitor anything you can get a metric for, using its Plugin API (anything can be a netdata plugin - from BASH to node.js, so you can easily monitor any application, any API)
+- **Embeddable**, it can run anywhere a Linux kernel runs and its charts can be embedded on your web pages too
- It also supports KSM memory deduplication to lower its memory requirements even further.
+---
-- **per second data collection**
+## What does it monitor?
- Every chart, every value, is updated every second. Of course, you can control collection period per module.
+This is what it currently monitors (most with zero configuration):
- **netdata** can perform several calculations on each value (dimension) collected:
+- **CPU usage, interrupts, softirqs and frequency** (total and per core)
- - **absolute**, stores the collected value, as collected (this is used, for example for the number of processes running, the number of connections open, the amount of RAM used, etc)
+- **RAM, swap and kernel memory usage** (including KSM and kernel memory deduper)
- - **incremental**, stores the difference of the collected value to the last collected value (this is used, for example, for the bandwidth of interfaces, disk I/O, i.e. for counters that always get incremented) - **netdata** automatically interpolates these values to second boundary, using nanosecond calculations so that small delays at the data collection layer will not affect the quality of the result - also, **netdata** detects arithmetic overflows and presents them properly at the charts.
+- **Disks** (per disk: I/O, operations, backlog, utilization, space, etc)
- - **percentage of absolute row**, stores the percentage of the collected value, over the sum of all dimensions of the chart.
+ 
- - **percentage of incremental row**, stores the percentage of this collected value, over the sum of the the **incremental** differences of all dimensions of the chart (this is used, for example, for system CPU utilization).
+- **Network interfaces** (per interface: bandwidth, packets, errors, drops, etc)
-- **visualizes QoS classes automatically**
+ 
- If you also use FireQOS for QoS, it collects class names automatically.
+- **IPv4 networking** (bandwidth, packets, errors, fragments, tcp: connections, packets, errors, handshake, udp: packets, errors, broadcast: bandwidth, packets, multicast: bandwidth, packets)
-- **appealing web site**
+- **IPv6 networking** (bandwidth, packets, errors, fragments, ECT, udp: packets, errors, udplite: packets, errors, broadcast: bandwidth, multicast: bandwidth, packets, icmp: messages, errors, echos, router, neighbor, MLDv2, group membership, break down by type)
- The web site uses bootstrap and google charts for a very appealing result.
- It works even on mobile devices and adapts to screen size changes and rotation (responsive design).
+- **netfilter / iptables Linux firewall** (connections, connection tracker events, errors, etc)
-- **web charts do respect your browser resources**
+- **Linux DDoS protection** (SYNPROXY metrics)
- The charts adapt to show only as many points are required to have a clear view.
- Also, the javascript code respects your browser resources (stops refreshing when the window looses focus, when scrolling, etc).
+- **Processes** (running, blocked, forks, active, etc)
-- **highly configurable**
+- **Entropy** (random numbers pool, using in cryptography)
- All charts and all features can be enabled or disabled.
- The program generates its configuration file based on the resources available on the system it runs, for you to edit.
+- **NFS file servers**, v2, v3, v4 (I/O, cache, read ahead, RPC calls)
-- It reads and renders charts for all these:
- - `/proc/net/dev` (all netwrok interfaces for all their values)
- - `/proc/diskstats` (all disks for all their values)
- - `/proc/net/snmp` (total IPv4, TCP and UDP usage)
- - `/proc/net/netstat` (more IPv4 usage)
- - `/proc/net/stat/nf_conntrack` (connection tracking performance)
- - `/proc/net/ip_vs/stats` (IPVS connection statistics)
- - `/proc/stat` (CPU utilization)
- - `/proc/meminfo` (memory information)
- - `/proc/vmstat` (system performance)
- - `/proc/net/rpc/nfsd` (NFS server statistics for both v3 and v4 NFS)
- - `tc` classes (QoS classes - [with FireQOS class names](http://firehol.org/tutorial/fireqos-new-user/))
+- **Network QoS** (yes, the only tool that visualizes network `tc` classes in realtime)
-- It supports **plugins** for collecting information from other sources!
+ 
- Plugins can be written in any computer language (pipe / stdout communication for data collection).
+- **Linux Control Groups** (containers), systemd, lxc, docker, etc
- It ships with 2 plugins: `apps.plugin` and `charts.d.plugin`:
+- **Applications**, by grouping the process tree (CPU, memory, disk reads, disk writes, swap, threads, pipes, sockets, etc)
- - `apps.plugin` is a plugin that attempts to collect statistics per process. It groups the entire process tree based on your settings (for example, mplayer, kodi, vlc are all considered `media`) and for each group it attempts to find CPU usage, memory usages, physical and logical disk read and writes, number of processes, number of threads, number of open files, number of open sockets, number of open pipes, minor and major page faults (major = swapping), etc. 15 stackable (per group) charts in total.
+ 
- - `charts.d.plugin` provides a simple way to script data collection in BASH. It includes example plugins that collect values from:
+- **Users and User Groups resource usage**, by summarizing the process tree per user and group (CPU, memory, disk reads, disk writes, swap, threads, pipes, sockets, etc)
- - `nut` (UPS load, frequency, voltage, etc, for multiple UPSes)
- - `sensors` (temperature, voltage, current, power, humidity, fans rotation sensors)
- - `cpufreq` (current CPU clock frequency, for all CPUs)
- - `postfix` (e-mail queue size)
- - `squid` (web proxy statistics)
- - `mysql` (mysql global statistics)
- - `opensips` (opensips statistics)
+- **Apache web server** mod-status (v2.2, v2.4)
- Of course, you can write your own using BASH scripting.
+- **Nginx web server** stub-status
-- netdata is a web server, supporting gzip compression
+- **mySQL databases** (multiple servers, each showing: bandwidth, queries/s, handlers, locks, issues, tmp operations, connections, binlog metrics, threads, innodb metrics, etc)
- It serves its own static files and dynamic files for rendering the site.
- It does not support authentication or SSL - limit its access using your firewall.
- It does not allow ` .. ` or ` / ` in the files requested (so it can only serve files stored in the web directory `/usr/share/netdata/web`).
+- **ISC Bind name server** (multiple servers, each showing: clients, requests, queries, updates, failures and several per view metrics)
+- **Postfix email server** message queue (entries, size)
-# How it works
+ **IPFS** (Bandwidth, Peers)
-1. You run a daemon on your linux: netdata.
- This deamon is written in C and is extremely lightweight.
+- **Squid proxy server** (clients bandwidth and requests, servers bandwidth and requests)
- netdata:
+- **Hardware sensors** (temperature, voltage, fans, power, humidity, etc)
- - Spawns threads to collect all the data for all sources
- - Keeps track of the collected values in memory (no disk I/O at all)
- - Generates JSON and JSONP HTTP responses containing all the data needed for the web graphs
- - Is a standalone web server.
+- **NUT UPSes** (load, charge, battery voltage, temperature, utility metrics, output metrics)
- For example, you can access JSON data by using:
+- **Tomcat** (accesses, threads, free memory, volume)
- ```
- http://127.0.0.1:19999/data/net.eth0
- ```
+- **PHP-FPM** (multiple instances, each reporting connections, requests, performance)
- This will give you the JSON file for traffic on eth0.
- The above is equivalent to:
+- **SNMP devices** can be monitored too (although you will need to configure these)
- ```
- http://127.0.0.1:19999/data/net.eth0/3600/1/average/0/0
- ```
+And you can extend it, by writing plugins that collect data from any source, using any computer language.
- where:
+---
- - 3600 is the number of entries to generate.
- - 1 is grouping count, 1 = every single entry, 2 = half the entries, 3 = one every 3 entries, etc
- - `average` is the grouping method. It can also be `max`.
- - 0/0 they are `before` and `after` timestamps, allowing panning on the data
+## Still not convinced?
+Read **[Why netdata?](https://github.com/firehol/netdata/wiki/Why-netdata%3F)**
-2. If you need to embed a **netdata** chart on your web page, you can add a few javascript lines and a `div` for every graph you need. Check [this example](http://195.97.5.206:19999/datasource.html) (open it in a new tab and view its source to get the idea).
+---
-3. Graphs are generated using Google Charts API (so, your client needs to have internet access).
+## Installation
+Use our **[automatic installer](https://github.com/firehol/netdata/wiki/Installation)** to build and install it on your system
-# Installation
+It should run on **any Linux** system. It has been tested on:
-## Automatic installation
+- Gentoo
+- Arch Linux
+- Ubuntu / Debian
+- CentOS
+- Fedora
+- RedHat Enterprise Linux
+- SUSE
+- Alpine Linux
+- PLD Linux
-Before you start, make sure you have `zlib` development files installed.
-To install it in Ubuntu, you need to run:
+---
-```sh
-apt-get install zlib1g-dev
-```
+## Documentation
-You also need to have a basic build environment in place. You will need packages like
-`gcc`, `autoconf`, `autogen`, `automake`, `pgk-config`, etc.
-
-Then do this to install and run netdata:
-
-```sh
-
-# download it
-git clone https://github.com/ktsaou/netdata.git netdata.git
-cd netdata.git
-
-# build it
-./netdata-installer.sh
-
-```
-
-The script `netdata-installer.sh` will build netdata and install it to your system.
-
-Once the installer completes, the file `/etc/netdata/netdata.conf` will be created.
-You can edit this file to set options. To apply the changes you made, you have to restart netdata.
-
-- You can start netdata by executing it with `/usr/sbin/netdata` (the installer will also start it).
-
-- You can stop netdata by killing it with `killall netdata`.
- You can stop and start netdata at any point. Netdata saves on exit its round robbin
- database to `/var/cache/netdata` so that it will continue from where it stopped the last time.
-
-To access the web site for all graphs, go to:
-
- ```
- http://127.0.0.1:19999/
- ```
-
-You can get the running config file at any time, by accessing `http://127.0.0.1:19999/netdata.conf`.
-
-To start it at boot, just run `/usr/sbin/netdata` from your `/etc/rc.local` or equivalent.
+Check the **[netdata wiki](https://github.com/firehol/netdata/wiki)**.
projects / netdata.git / blobdiff