Add a collector for ZFS, currently focussed on ARC stats.

README.md

@@ -32,7 +32,7 @@ textfile | Exposes statistics read from local disk. The `--collector.textfile.di
 time | Exposes the current system time. | _any_
 vmstat | Exposes statistics from `/proc/vmstat`. | Linux
 version | Exposes node\_exporter version. | _any_
-
+zfs | Exposes [ZFS](http://open-zfs.org/) performance statistics (ARC-only for now) | [FreeBSD](https://www.freebsd.org/doc/handbook/zfs.html),[Linux](http://zfsonlinux.org/)
 
 ### Disabled by default
 

collector/zfs.go

@@ -0,0 +1,157 @@
+package collector
+
+// +build !nofilesystem
+// +build !nozfs
+
+import (
+	"errors"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/common/log"
+)
+
+type zfsMetricValue int
+
+const zfsErrorValue = zfsMetricValue(-1)
+
+var zfsNotAvailableError = errors.New("ZFS / ZFS statistics are not available")
+
+type zfsSysctl string
+type zfsSubsystemName string
+
+const (
+	arc = zfsSubsystemName("zfs_arc")
+)
+
+//------------------------------------------------------------------------------
+//                                    Metrics
+//------------------------------------------------------------------------------
+
+type zfsMetric struct {
+	subsystem zfsSubsystemName // The Prometheus subsystem name
+	name      string           // The Prometheus name of the metric
+	sysctl    zfsSysctl        // The sysctl of the ZFS metric
+}
+
+func NewZFSMetric(subsystem zfsSubsystemName, sysctl, name string) zfsMetric {
+	return zfsMetric{
+		sysctl:    zfsSysctl(sysctl),
+		subsystem: subsystem,
+		name:      name,
+	}
+}
+func (m *zfsMetric) BuildFQName() string {
+	return prometheus.BuildFQName(Namespace, string(m.subsystem), m.name)
+}
+
+func (m *zfsMetric) HelpString() string {
+	return m.name
+}
+
+//------------------------------------------------------------------------------
+//                                 Collector
+//------------------------------------------------------------------------------
+
+func init() {
+	Factories["zfs"] = NewZFSCollector
+}
+
+type zfsCollector struct {
+	zfsMetrics     []zfsMetric
+	metricProvider zfsMetricProvider
+}
+
+func NewZFSCollector() (Collector, error) {
+	err := zfsInitialize()
+	switch {
+	case err == zfsNotAvailableError:
+		log.Debug(err)
+		break
+		return &zfsCollector{}, err
+	}
+
+	return &zfsCollector{
+		zfsMetrics: []zfsMetric{
+			NewZFSMetric(arc, "kstat.zfs.misc.arcstats.p", "mru_size"),
+			NewZFSMetric(arc, "kstat.zfs.misc.arcstats.size", "size"),
+			NewZFSMetric(arc, "kstat.zfs.misc.arcstats.c_min", "target_min_size"),
+			NewZFSMetric(arc, "kstat.zfs.misc.arcstats.c", "target_size"),
+			NewZFSMetric(arc, "kstat.zfs.misc.arcstats.c_max", "target_max_size"),
+			NewZFSMetric(arc, "kstat.zfs.misc.arcstats.hits", "hits"),
+			NewZFSMetric(arc, "kstat.zfs.misc.arcstats.misses", "misses"),
+		},
+		metricProvider: NewZFSMetricProvider(),
+	}, nil
+}
+
+func (c *zfsCollector) Update(ch chan<- prometheus.Metric) (err error) {
+
+	log.Debug("Preparing metrics update")
+	err = c.metricProvider.PrepareUpdate()
+	switch {
+	case err == zfsNotAvailableError:
+		log.Debug(err)
+		return nil
+		return err
+	}
+	defer c.metricProvider.InvalidateCache()
+
+	log.Debugf("Fetching %d metrics", len(c.zfsMetrics))
+	for _, metric := range c.zfsMetrics {
+
+		value, err := c.metricProvider.Value(metric.sysctl)
+		if err != nil {
+			return err
+		}
+
+		ch <- prometheus.MustNewConstMetric(
+			prometheus.NewDesc(
+				metric.BuildFQName(),
+				metric.HelpString(),
+				nil,
+				nil,
+			),
+			prometheus.UntypedValue,
+			float64(value),
+		)
+
+	}
+
+	return err
+}
+
+//------------------------------------------------------------------------------
+//                                 Metrics Provider
+// Platform-dependend parts implemented in zfs_${platform} files.
+//------------------------------------------------------------------------------
+
+type zfsMetricProvider struct {
+	values map[zfsSysctl]zfsMetricValue
+}
+
+func NewZFSMetricProvider() zfsMetricProvider {
+	return zfsMetricProvider{
+		values: make(map[zfsSysctl]zfsMetricValue),
+	}
+
+}
+
+func (p *zfsMetricProvider) InvalidateCache() {
+	p.values = make(map[zfsSysctl]zfsMetricValue)
+}
+
+func (p *zfsMetricProvider) Value(s zfsSysctl) (value zfsMetricValue, err error) {
+
+	var ok bool
+	value = zfsErrorValue
+
+	value, ok = p.values[s]
+	if !ok {
+		value, err = p.handleMiss(s)
+		if err != nil {
+			return value, err
+		}
+	}
+
+	return value, err
+}

collector/zfs_freebsd.go

@@ -0,0 +1,65 @@
+package collector
+
+// +build freebsd
+
+import (
+	"fmt"
+	"unsafe"
+)
+
+/*
+#cgo LDFLAGS:
+#include <fcntl.h>
+#include <stdlib.h>
+#include <sys/param.h>
+#include <sys/module.h>
+#include <sys/pcpu.h>
+#include <sys/resource.h>
+#include <sys/sysctl.h>
+#include <sys/time.h>
+
+int zfsIntegerSysctl(const char *name) {
+
+	int value;
+	size_t value_size = sizeof(value);
+	if (sysctlbyname(name,  &value, &value_size, NULL, 0) != -1 ||
+	    value_size != sizeof(value)) {
+		return -1;
+	}
+	return value;
+
+}
+
+int zfsModuleLoaded() {
+	int modid = modfind("zfs");
+	return modid < 0 ? 0 : -1;
+}
+
+*/
+import "C"
+
+func zfsInitialize() error {
+	return nil
+}
+
+func (c *zfsMetricProvider) PrepareUpdate() error {
+	if C.zfsModuleLoaded() == 0 {
+		return zfsNotAvailableError
+	}
+	return nil
+}
+
+func (p *zfsMetricProvider) handleMiss(s zfsSysctl) (zfsMetricValue, error) {
+
+	sysctlCString := C.CString(string(s))
+	defer C.free(unsafe.Pointer(sysctlCString))
+
+	value := int(C.zfsIntegerSysctl(sysctlCString))
+
+	if value == -1 {
+		return zfsErrorValue, fmt.Errorf("Could not retrieve sysctl '%s'", s)
+	}
+
+	return zfsMetricValue(value), nil
+
+}

collector/zfs_linux.go

@@ -0,0 +1,76 @@
+package collector
+
+// +build linux
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+
+	"github.com/prometheus/common/log"
+)
+
+const zfsArcstatsProcpath = "spl/kstat/zfs/arcstats"
+
+func zfsInitialize() error {
+	return nil
+}
+
+func (p *zfsMetricProvider) PrepareUpdate() (err error) {
+
+	err = p.prepareUpdateArcstats(zfsArcstatsProcpath)
+	if err != nil {
+		return
+	}
+	return nil
+}
+
+func (p *zfsMetricProvider) handleMiss(s zfsSysctl) (value zfsMetricValue, err error) {
+	// all values are fetched in PrepareUpdate()
+	return zfsErrorValue, fmt.Errorf("sysctl '%s' found")
+}
+
+func (p *zfsMetricProvider) prepareUpdateArcstats(zfsArcstatsProcpath string) (err error) {
+
+	file, err := os.Open(procFilePath(zfsArcstatsProcpath))
+	if err != nil {
+		log.Debugf("Cannot open ZFS arcstats procfs file for reading. " +
+			" Is the kernel module loaded?")
+		return zfsNotAvailableError
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+
+	parseLine := false
+	for scanner.Scan() {
+		parts := strings.Fields(scanner.Text())
+
+		if !parseLine && parts[0] == "name" && parts[1] == "type" && parts[2] == "data" {
+			// Start parsing from here
+			parseLine = true
+			continue
+		}
+
+		if !parseLine || len(parts) < 3 {
+			continue
+		}
+
+		key := fmt.Sprintf("kstat.zfs.misc.arcstats.%s", parts[0])
+
+		value, err := strconv.Atoi(parts[2])
+		if err != nil {
+			return fmt.Errorf("could not parse expected integer value for '%s'", key)
+		}
+		log.Debugf("%s = %d", key, value)
+		p.values[zfsSysctl(key)] = zfsMetricValue(value)
+	}
+	if !parseLine {
+		return errors.New("did not parse a single arcstat metrics")
+	}
+
+	return scanner.Err()
+}

node_exporter.go

@@ -29,7 +29,7 @@ import (
 )
 
 const (
-	defaultCollectors = "conntrack,cpu,diskstats,entropy,filefd,filesystem,loadavg,mdadm,meminfo,netdev,netstat,sockstat,stat,textfile,time,uname,version,vmstat"
+	defaultCollectors = "conntrack,cpu,diskstats,entropy,filefd,filesystem,loadavg,mdadm,meminfo,netdev,netstat,sockstat,stat,textfile,time,uname,version,vmstat,zfs"
 )
 
 var (